From 6b5c8121cac59c5cf2f66ea80076b29c5dd82f27 Mon Sep 17 00:00:00 2001 From: Claude Date: Wed, 14 Oct 2026 07:56:12 +0000 Subject: [PATCH 1/4] fix(lead): stop requiring an owner pick on the New Lead form The create form marked owner_id required, so the console refused the save with "Lead Owner is required" before the platform's insert-time stamp could make the creator the owner. Keep the field on the form so a manager can still pick another owner, as the Opportunity, Account and Contact New forms already do. Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_01P8mZuzuyZAHSrgQKmv6ASv --- objectstack.config.bundled_4tw0mek20uf.mjs | 35749 +++++++++++++++++++ src/sales/views/lead.view.ts | 9 +- 2 files changed, 35754 insertions(+), 4 deletions(-) create mode 100644 objectstack.config.bundled_4tw0mek20uf.mjs diff --git a/objectstack.config.bundled_4tw0mek20uf.mjs b/objectstack.config.bundled_4tw0mek20uf.mjs new file mode 100644 index 00000000..00f6fd91 --- /dev/null +++ b/objectstack.config.bundled_4tw0mek20uf.mjs @@ -0,0 +1,35749 @@ +var __defProp = Object.defineProperty; +var __export = (target, all) => { + for (var name in all) + __defProp(target, name, { get: all[name], enumerable: true }); +}; + +// objectstack.config.ts +import { composeStacks } from "@objectstack/spec"; + +// src/sales/index.ts +import { defineStack } from "@objectstack/spec"; +var createHotCrmAppStack = (collections, options) => defineStack({ + manifest: { + id: "app.objectstack.hotcrm", + namespace: "crm", + version: "4.0.1", + type: "app", + name: "HotCRM", + description: "AI-Native CRM for the ObjectStack marketplace \u2014 Accounts, Contacts, Leads, Opportunities, Cases, Knowledge, Forecasts, Campaigns, Contracts.", + // ADR-0087 protocol handshake (ADR-0025 §3.2): the metadata/runtime + // protocol major this app's metadata is authored against. Only the major + // participates in the check — a runtime on a different major refuses the + // load with a structured OS_PROTOCOL_INCOMPATIBLE diagnostic (naming the + // `objectstack migrate meta` replay) instead of failing deep in a schema + // parse. Bump together with `specVersion` on every platform upgrade + // (docs/MAINTENANCE.md §3) — `test/docs-declared-versions.test.ts` now + // enforces that pairing against `objectstack.manifest.json` instead of + // trusting this comment, because two platform upgrades in a row (rc.2, then + // rc.3) moved the manifest and left this line behind (#728). Every package + // of this artifact states the same protocol; `src/service/index.ts` + // repeats it for the same reason. + engines: { protocol: "^18.0.0-next.0" } + }, + // ─── Platform capabilities this app needs ───────────────────────── + // The runtime resolves each capability name to a built-in service plugin + // and auto-loads it (with extras like Automation's node packs). No need + // to hand-instantiate plugins or pass `--preset` flags. See + // packages/cli/src/commands/serve.ts CAPABILITY_PROVIDERS for the + // complete map; explicit `plugins: [...]` always shadows the resolver. + // `auth` enables the auth/login surface (login/register) via @objectstack/plugin-auth. + // `ui` serves the unified Console shell and CRM apps under /_console/ + // (login at /_console/login). ObjectStack 7.x replaced the legacy + // /_studio/ and /_account/ mounts with this single /_console/ surface. + // Both are required for a clickable login flow when running `objectstack start` + // off the compiled artifact. + // Note: the foundational slate (queue, job, cache, settings, email, + // storage) is auto-injected by the CLI for every non-`minimal` + // preset — see `ALWAYS_CAPS` in packages/cli/src/commands/serve.ts. + // Listed below only the *opt-in* capabilities this stack actually + // wants on top of that slate. + // `triggers` installs the record-change + schedule trigger providers that + // actually fire autolaunched flows (record_change & schedule types). Without + // it the `automation` engine registers flows but nothing ever launches them. + // Schedule triggers run via the job service (in the always-on slate). + // + // This is the APP package's slate. `defineStack` validates capabilities per + // stack, so `src/service/index.ts` declares the four its own metadata needs + // itself, and the artifact's slate is the union of the two lists. + // + // `ai` is deliberately NOT listed. ObjectStack 11.3.0 (ADR-0025 S2) removed + // `@objectstack/service-ai` from the open edition — the AI runtime now ships + // only in the closed cloud package, and the framework CLI does not depend on + // it. Under ObjectStack 16, `requires: ['ai']` is a *fail-fast* capability: + // the serve command hard-aborts boot when the package is absent, so keeping it + // here would break `objectstack start`/`dev` for this open-edition app (the AI + // block runs before every other capability resolves). The AI metadata is + // unaffected — the skills still validate, build into the artifact, and run + // wherever a runtime provides the `ai` tier (cloud's objectos-runtime). There + // are no app-authored agents: they were retired in #512 and the surface is + // skills-only (ADR-0063 §2); skills attach to a platform agent by `surface`. + // A local open-edition boot simply omits the AI service and hides its console + // surface. To run AI locally, declare `@objectstack/service-ai` (cloud) in + // package.json — its mere presence best-effort auto-loads it. + // `hierarchy-security` is the ONE enterprise-edition capability this app + // declares. It was introduced for #880 — `sales_manager` authored + // `writeScope: 'own_and_reports'` on `crm_contract`, an ADR-0057 HIERARCHY + // scope resolved by the `hierarchy-scope-resolver` service that ships only + // in `@objectstack/security-enterprise`, and `defineStack` refuses such a + // grant unless the capability is declared. Since #549 `crm_contract` is + // `controlled_by_parent` under the account, that scope is inert and is no + // longer authored; the app currently authors NO hierarchy scope at all. + // + // The declaration STAYS. Maintainer ruling 2026-08-31 (#1378, pinned by + // `test/hierarchy-read-depth.test.ts`): nothing is removed from `requires[]`. + // Maintainer ruling, 2026-08-11, verbatim: 「本项目是元数据app，在企业版运行就 + // 具备企业版相关的能力，不重复开发。」 The app states what it MEANS and the + // edition supplies the capability, rather than approximating it with a broader + // open-edition value. + // + // UNLIKE `ai` above, this is SAFE to declare on an open-edition boot and does + // NOT fail fast. Verified against `@objectstack/cli`'s serve command: the + // capability resolver looks the token up in `CAPABILITY_PROVIDERS`, finds no + // entry, and because `hierarchy-security` IS in the known + // `PLATFORM_CAPABILITY_TOKENS` vocabulary it takes the deliberate "stay quiet" + // branch — no warning, no abort — since the capability arrives via an explicit + // enterprise plugin in `plugins[]`. Only tier-gated tokens (ai / ai-studio / + // i18n / ui / auth) have the dedicated hard-abort blocks the note above + // describes. `objectstack validate` does print one informational line naming + // the package to install; that is expected output, not a defect to silence. + requires: ["automation", "triggers", "analytics", "auth", "ui", "approvals", "sharing", "hierarchy-security"], + // The locale configuration is the ARTIFACT's, and `i18n` is a + // `'single'`-disposition key: two stacks declaring different values make + // `composeStacks` throw, and declaring identical ones twice is a second + // place to drift. It lives on the App package, alone. + i18n: { + defaultLocale: "en", + supportedLocales: ["en", "zh-CN", "ja-JP", "es-ES"], + fallbackLocale: "en" + }, + ...collections +}, { artifactObjects: options.artifactObjects }); + +// src/service/index.ts +import { defineStack as defineStack2 } from "@objectstack/spec"; + +// src/service/actions/case.actions.ts +import { P } from "@objectstack/spec"; +var EscalateCaseAction = { + name: "escalate_case", + label: "Escalate Case", + objectName: "crm_case", + icon: "alert-triangle", + type: "flow", + target: "escalate_case", + locations: ["record_header", "list_item"], + visible: P`has(record.is_escalated) && record.is_escalated == false && has(record.is_closed) && record.is_closed == false`, + confirmText: "This will escalate the case to the escalation team. Continue?", + successMessage: "Case escalated successfully!", + refreshAfter: true +}; +var CloseCaseAction = { + name: "close_case", + label: "Close Case", + objectName: "crm_case", + icon: "check-circle", + type: "flow", + target: "close_case", + locations: ["record_header"], + visible: P`has(record.is_closed) && record.is_closed == false`, + confirmText: "Are you sure you want to close this case?", + successMessage: "Case closed successfully!", + refreshAfter: true +}; +var ClaimCaseAction = { + name: "claim_case", + label: "Claim Case", + objectName: "crm_case", + icon: "user-plus", + type: "flow", + target: "claim_case", + locations: ["record_header", "list_item"], + // ⛔ Deliberately NOT `has()`-guarded — the one site the #1890 totality sweep + // left alone after making every other `visible` in `src/actions/` total. This + // predicate is the sharing grant's own text, verbatim, and + // `test/claim-case-one-owner-writer.test.ts` compares the two strings; the + // grant itself cannot carry `has()`, because `plugin-sharing` compiles a + // criteria condition with `compileCelToFilter`, which rejects the whole + // function-call class, and an untranslatable rule is DROPPED by the seeder + // (#621). `src/service/sharing/case.sharing.ts` writes that out in full, including why + // `record.owner_id == null` is total one layer down (`{ owner_id: { $null: true } }`). + // ⚠️ What that reasoning does NOT cover is THIS surface: an action `visible` is + // interpreted by CEL in the browser against whatever the page holds, which is + // `{}` for the first renders, so this predicate does abort there. Making it + // total needs the grant and the parity pin moved together — a maintainer call, + // not this card's. (#1890) + visible: P`record.owner_id == null && record.status != "resolved" && record.status != "closed"`, + successMessage: "Case claimed \u2014 it is yours now.", + refreshAfter: true +}; + +// src/service/objects/index.ts +var objects_exports = {}; +__export(objects_exports, { + ArticleFeedback: () => ArticleFeedback, + Case: () => Case, + KnowledgeArticle: () => KnowledgeArticle +}); + +// src/service/objects/article_feedback.object.ts +import { ObjectSchema, Field } from "@objectstack/spec/data"; +var ArticleFeedback = ObjectSchema.create({ + name: "crm_article_feedback", + label: "Article Feedback", + pluralLabel: "Article Feedback", + icon: "thumbs-up", + description: "One reader\u2019s helpful / not-helpful verdict on a knowledge article", + // ADR-0090 D1/D7: OWD is an authored decision. Feedback is an attribute of + // the article, so record access DERIVES from it (ADR-0055) — the same call + // `crm_campaign_member` makes, and for the same reason: a vote row means + // nothing apart from the article it is about, and `crm_knowledge_article` is + // `public_read`, so anyone who can read the article can read its feedback. + // + // ⛔ Not `private`: with the voter as owner, the counters' own evidence would + // be invisible to the author trying to understand them — the same way it was + // wrong on `crm_campaign_member`. + sharingModel: "controlled_by_parent", + // ADR-0079: junction rows have no derivable text title; point the canonical + // nameField at the stored autonumber explicitly (autonumber is not in the + // auto-derivation whitelist). Same call as `crm_campaign_member` and + // `crm_event_attendee`. + nameField: "feedback_number", + // A related list takes its columns from the child's `highlightFields` MINUS + // the lookup it is scoped by, and this object ships no view of its own — so + // this list IS the feedback panel on an article's detail page (#944): the + // verdict, and who gave it. + // + // TWO fields are deliberately absent, for two different reasons: + // + // - `feedback_number`, the same call `crm_campaign_member` makes with + // `member_number`: it is the record TITLE, which a detail page hoists out + // of the body, so leading the strip with it would fill the panel with + // autonumbers instead of verdicts. + // - `comment`, a 500-character textarea. A highlight strip holds short + // values, and keeping it out is also what stops the `basic` group being + // ENTIRELY title-or-strip — a group whose every field is hoisted keeps its + // heading on forms and silently vanishes from detail pages + // (`field-group-shadowed`, the same trap `crm_campaign_member`'s `basic` + // group and `crm_task`'s `assignment` group each had to be rescued from). + // So the comment is the group's own content on the row's detail page, + // and reaches the panel through `relatedListColumns` on the article + // lookup below instead (#1199). + highlightFields: ["crm_knowledge_article", "verdict", "owner_id"], + fieldGroups: [ + { key: "basic", label: "Feedback", icon: "message-square" } + ], + fields: { + feedback_number: Field.autonumber({ + label: "Feedback #", + format: "AF-{0000}", + group: "basic" + }), + // Platform ownership anchor — canonical note in `account.object.ts` (#548). + // Here it is also the VOTER: the platform stamps it on insert, which is + // what `unique_vote_per_reader` keys on and what lets a reader change + // their own mind without an admin's help. + owner_id: Field.lookup("sys_user", { + label: "Reader", + group: "basic", + system: true, + readonly: false + }), + /** + * The article this verdict is about. + * + * `deleteBehavior: 'cascade'` — a vote on a deleted article denotes + * nothing. This is the lesson #696 cost the campaign junction: both party + * lookups there took `Field.lookup`'s `set_null` default, the cleared row + * instantly violated the object's own required-reference rule, and every + * enrolled person became permanently undeletable. A required lookup that + * defaults to `set_null` is that bug waiting to happen, so the behaviour is + * spelled out here rather than inherited. + */ + crm_knowledge_article: Field.lookup("crm_knowledge_article", { + label: "Article", + required: true, + storage: { notNull: true }, + group: "basic", + deleteBehavior: "cascade", + description: "Knowledge article this feedback is about.", + // Curates the feedback panel on the article's detail page — the surface + // the article's AUTHOR reads (#1199). A related list reads + // `relatedListColumns` on the child's lookup before it falls back to + // `highlightFields` minus that lookup (#944), so this is a SUPERSET of + // the fallback (Verdict / Reader) plus `comment`: the note a reader + // types to explain a verdict was stored and shown on no list, and the + // author the field's own description names could not see it without + // opening each row. Last, because it is the one long value. + // + // ⛔ Deliberately NOT solved by adding `comment` to `highlightFields` — + // see the note above that list (`field-group-shadowed`). + relatedListColumns: ["verdict", "owner_id", "comment"] + }), + verdict: Field.select({ + label: "Verdict", + required: true, + storage: { notNull: true }, + group: "basic", + options: [ + { label: "Helpful", value: "helpful", color: "#10B981", default: true }, + { label: "Not Helpful", value: "not_helpful", color: "#EF4444" } + ] + }), + comment: Field.textarea({ + label: "Comment", + group: "basic", + maxLength: 500, + description: "Optional note explaining the verdict \u2014 read by the article\u2019s author." + }) + }, + indexes: [ + { fields: ["crm_knowledge_article"] }, + { fields: ["verdict"] }, + // One vote per reader per article. Without it the counters answer "how many + // clicks", which is not a number anybody wants next to "Not Helpful". + // + // `unique: 'organization'` states the scope explicitly, per ADR-0120: the + // driver prepends the NULL-safe organization key part + // (`COALESCE(organization_id, '__global__')`) at registration, so the + // constraint is one vote per reader per article WITHIN an organization, + // and rows with no organization form one bucket rather than each escaping + // under SQL's NULL-distinct semantics. Bare `unique: true` is the + // deprecated positional spelling of `'global'` — it warns today + // (`unique/unscoped-declared-index`) and protocol 18 rejects it, and + // "globally unique across every installation" is not what one reader's + // opinion of one article means. + { fields: ["crm_knowledge_article", "owner_id"], unique: "organization" } + ], + enable: { + apiEnabled: true, + apiMethods: ["get", "list", "create", "update", "delete"] + } +}); + +// src/service/objects/case.object.ts +import { ObjectSchema as ObjectSchema2, Field as Field2 } from "@objectstack/spec/data"; +import { F, P as P2 } from "@objectstack/spec"; +var Case = ObjectSchema2.create({ + name: "crm_case", + label: "Case", + pluralLabel: "Cases", + icon: "life-buoy", + description: "Customer support cases and service requests", + // ADR-0090 D1/D7: OWD is an authored decision. Owner + escalation sharing rule. + sharingModel: "private", + fieldGroups: [ + { key: "basic", label: "Case Information", icon: "info" }, + { key: "origin", label: "Origin & Routing", icon: "route" }, + { key: "sla", label: "SLA & Priority", icon: "clock" }, + { key: "resolution", label: "Resolution", icon: "check-circle" }, + { key: "escalation", label: "Escalation", icon: "alert-triangle", collapse: "collapsed" }, + { key: "system", label: "System", icon: "database", collapse: "collapsed" } + ], + fields: { + // Platform ownership anchor — canonical note in `account.object.ts` (#548). + owner_id: Field2.lookup("sys_user", { + label: "Case Owner", + group: "origin", + system: true, + readonly: false, + trackHistory: true + }), + // Case Information + // + // `unique: true` is declared HERE, on the field, and deliberately NOT as a + // `{ fields: ['organization_id', 'case_number'], unique: true }` entry in + // `indexes[]` below (#1023) — same spelling `crm_account.name`, + // `crm_contact.email` and `crm_product.sku` already use, for the same + // reason. Since framework #3696 the field-level form is per-organization: + // it materializes as the composite `(organization key part, case_number)`, + // unique WITHIN an organization. Since platform 17.0.0-rc.4 (ADR-0120 D3, + // #5030) that key part is NULL-safe — `COALESCE(organization_id, + // '__global__')` — so rows with no organization form ONE bucket instead of + // each escaping the constraint under SQL's NULL-distinct semantics. + // + // The hand-written table composite this replaced could not get that: a + // declared index is taken verbatim, so it materialized as plain + // `UNIQUE (organization_id, case_number)` and enforced NOTHING on any row + // whose `organization_id` was NULL — i.e. every row of a single-organization + // or untenanted install. It also read as "unique per organization" while + // materializing as an unscoped composite, which is the bare-`unique: true` + // spelling ADR-0120 warns on in 17.x and protocol 18 rejects (#5082). + // + // Scope spelling: bare `true` at FIELD level already means "per + // organization" and carries no deprecation (`'organization'` is its + // explicit synonym with byte-identical materialization — measured). It is + // written as `true` to match the four sibling objects above; switching the + // repo to the explicit word is a uniform decision for all of them, not + // something `crm_case` forks on alone. + case_number: Field2.autonumber({ + label: "Case Number", + group: "basic", + format: "CASE-{00000}", + unique: true + }), + subject: Field2.text({ + label: "Subject", + group: "basic", + required: true, + storage: { notNull: true }, + searchable: true, + maxLength: 255 + }), + // ADR-0079 record title (was titleFormat '{case_number} - {subject}'). + display_title: Field2.formula({ + label: "Display Title", + group: "basic", + expression: F`record.case_number + " - " + record.subject` + }), + description: Field2.markdown({ + label: "Description", + group: "basic", + required: true, + storage: { notNull: true } + }), + // Relationships + crm_account: Field2.lookup("crm_account", { + label: "Account", + group: "basic" + }), + crm_contact: Field2.lookup("crm_contact", { + label: "Contact", + group: "basic", + // Optional so Web-to-Case (anonymous) submissions can land without + // an existing CRM contact. Back-office staff or a triage flow links + // the case to a contact after the fact. This matches the Salesforce + // Web-to-Case convention. + // @objectstack 12: string[] `referenceFilters` is dead (not read by the + // picker). `dependsOn` is the live cascading-lookup form — it scopes the + // contact candidates to those sharing the case's `crm_account` (ADR-0049). + dependsOn: ["crm_account"] + }), + // Case Management + status: Field2.select({ + label: "Status", + group: "basic", + required: true, + storage: { notNull: true }, + // ADR-0052 §5b.1 — platform auto-renders status changes on the timeline + // ("Status: New → Escalated"). Delivers the case timeline declaratively + // (the hand-coded version was deferred in #396 due to a hook-crash bug). + trackHistory: true, + options: [ + { label: "New", value: "new", color: "#808080", default: true }, + { label: "In Progress", value: "in_progress", color: "#FFA500" }, + { label: "Waiting on Customer", value: "waiting_customer", color: "#FFD700" }, + { label: "Waiting on Support", value: "waiting_support", color: "#4169E1" }, + { label: "Escalated", value: "escalated", color: "#FF0000" }, + { label: "Resolved", value: "resolved", color: "#00AA00" }, + { label: "Closed", value: "closed", color: "#006400" } + ] + }), + priority: Field2.select({ + label: "Priority", + group: "sla", + required: true, + storage: { notNull: true }, + trackHistory: true, + options: [ + { label: "Low", value: "low", color: "#4169E1", default: true }, + { label: "Medium", value: "medium", color: "#FFA500" }, + { label: "High", value: "high", color: "#FF4500" }, + { label: "Critical", value: "critical", color: "#FF0000" } + ] + }), + // Sortable ordinal for `priority`. Ordering a queue by the select field + // itself sorts the raw strings, so `priority desc` yields + // medium > low > high > critical — the exact inversion of urgency, which + // buried every critical case at the bottom of the agent's queue. Select + // options carry no ordinal in the spec, so the rank is materialised here + // and stamped by `case_sla_defaults`; queue views sort on it instead. + // `0` is the UNRANKED sentinel, shared with crm_task.priority_rank: it is + // what a record carries when no recognised priority has been stamped, and + // it sorts below every real rank (1–4) on the `priority_rank desc` queues. + // ⛔ It must not be `1` here (or `2` on crm_task): a non-zero sentinel + // orders the same unknown priority differently on the two objects, and on + // this one it is indistinguishable from a genuine `low`. + priority_rank: Field2.number({ + label: "Priority Rank", + readonly: true, + defaultValue: 0 + }), + type: Field2.select({ + label: "Case Type", + group: "basic", + options: [ + { label: "Question", value: "question" }, + { label: "Problem", value: "problem" }, + { label: "Feature Request", value: "feature_request" }, + { label: "Bug", value: "bug" } + ] + }), + origin: Field2.select({ + label: "Case Origin", + group: "origin", + options: [ + { label: "Email", value: "email" }, + { label: "Phone", value: "phone" }, + { label: "Web", value: "web" }, + { label: "Chat", value: "chat" }, + { label: "Social Media", value: "social_media" } + ] + }), + // Assignment + // SLA and Metrics + // + // NO `created_date` here (#1992, the #575 B2 precedent on + // `crm_opportunity`): the platform already injects `created_at` on every + // object and stamps it on every insert, while this duplicate had no writer + // at all — only the seed data set it, so every case created through the + // UI or REST stored null and fell out of "Cases Opened by Priority × Day" + // and the service dashboard's date range. Surfaces that need the creation + // instant read `created_at` (the `case_metrics` dataset, the dashboard + // range, the `case_timeline` view, `case_sla_defaults`' resolution time); + // the seeds author it directly, and the seed loader keeps an authored + // `created_at` on first insert since @objectstack/objectql 17.7.0 + // (objectstack#21646). + closed_date: Field2.datetime({ + label: "Closed Date", + group: "sla", + readonly: true + }), + // ⛔ NOT `readonly`: stamped by `event_activity_bubble` + // (`src/sales/objects/event.hook.ts`) on the first HELD `crm_event` related to the + // case, whoever wrote that event. ⚠️ That hook reaches this case through + // `ctx.api`, a `ScopedContext` over the ACTING USER's execution context — + // so its write is a CALLER-supplied write from a non-`isSystem` context, + // which `stripReadonlyFields` deletes. `readonly` here silently disables + // the stamp. (A hook writing its OWN record's `ctx.input.data` is a + // different case and SURVIVES `readonly` — hook-written keys are not + // caller-supplied. Measured in `test/readonly-write-semantics.test.ts`.) + // + // Definition: the moment the customer first heard back from us, matching + // Salesforce `FirstResponseDateTime` / Zendesk first reply time — NOT an + // internal status change, which would report "responded" while the customer + // is still waiting. + first_response_date: Field2.datetime({ + label: "First Response Date", + group: "sla" + }), + resolution_time_hours: Field2.number({ + label: "Resolution Time (Hours)", + group: "sla", + readonly: true, + scale: 2 + }), + // Stamped once, on the first write that gives the case a priority, from the + // priority × account-tier matrix in `./_case-sla.ts` (`case_sla_defaults`). + // Not `readonly`: a service manager may legitimately renegotiate a deadline, + // and the hook never overwrites a value that is already there. + sla_due_date: Field2.datetime({ + label: "SLA Due Date", + description: "Set from the case priority and the account\u2019s Customer Tier, in calendar hours: nights, weekends and holidays count.", + group: "sla" + }), + // Stamped by two writers, one per side of the clock stop (#2070): the + // `case_sla_monitor` schedule flow while the case is live work, and + // `case_sla_defaults` on the write that resolves or closes it late. The + // rule both apply is `caseSlaBreached` in `./_case-sla.ts`. + // + // NOT `readonly` — but NOT for the reason this comment used to give, and + // the difference is measured in `test/readonly-write-semantics.test.ts` + // (#1429). `case_sla_monitor` declares `runAs: 'system'`, so its writes + // would SURVIVE a `readonly: true` here. It stays writable pending a + // decision that has to weigh the other surfaces (seed data, + // `service-agent.profile.ts`, the create form), not because the platform + // would drop the sweep's write. + // + // ⚠️ This is now the ONLY escalation-group flag still declared writable: + // `is_escalated` and `escalated_date` became `readonly: true` when #1434 + // moved their user-context writer into a system sub-flow. So the open + // question here is narrower than it was — it is purely about this field's + // authoring surfaces, with no platform obstacle left to blame. + is_sla_violated: Field2.boolean({ + label: "SLA Violated", + group: "sla", + defaultValue: false + }), + // Escalation + // + // `readonly: true` — the honest declaration, because nobody types this. + // Its three writers are now unanimously elevated (#1434, maintainer- + // approved decision batch #21 ②): + // + // case_escalation runAs: 'system' (record-change) + // case_sla_monitor runAs: 'system' (schedule) + // case_escalation_stamp runAs: 'system' (called by the escalate_case + // screen flow via a subflow node) + // + // ⭐ What changed, and why the readonly declaration is now safe: the + // `escalate_case` screen flow used to write this field itself, and it + // stays `runAs: 'user'` because a person clicks it. The platform's + // readonly strip is one branch of the UPDATE path + // (`if (!opCtx.context?.isSystem)`, over CALLER-supplied keys), so that + // user-context write WOULD have been silently dropped. Rather than + // elevating the whole screen flow, the stamp moved into the dedicated + // `case_escalation_stamp` sub-flow. The agent's own writes + // (`escalation_reason`, `priority`, `status`) still carry their identity; + // only these two stamps are elevated. + // + // The guest-submission branch of `case.hook.ts` also forces this false, and + // is unaffected: it is a `beforeInsert` hook, so its key is not + // caller-supplied AND the INSERT path is exempt from the strip entirely. + // Seed data (`service.seed.ts`) is exempt for the same reason. + // + // ⛔ If you find yourself reverting this to writable so a user-context flow + // write lands, you are re-opening #1434 — add a `subflow` step instead. + // Semantics measured in `test/readonly-write-semantics.test.ts`. + is_escalated: Field2.boolean({ + label: "Escalated", + group: "escalation", + readonly: true, + defaultValue: false + }), + // `readonly: true`, same reasoning as `is_escalated` above and stamped by + // the same writers — `case_escalation` and the `case_escalation_stamp` + // sub-flow, both `runAs: 'system'`. Never typed by a person. + escalated_date: Field2.datetime({ + label: "Escalated Date", + group: "escalation", + readonly: true + }), + // ⛔ DELIBERATELY NOT `readonly`, and this is load-bearing (#1434). This is + // the agent's own screen input — `escalate_case`'s screen collects it and + // writes it with the USER's context. Declaring it readonly would make the + // platform silently strip the reason the agent just typed, which is the + // harm #1434 was filed about, inverted onto user input. It is also + // required whenever `is_escalated` flips true (the + // `escalation_reason_required` validation below), so dropping it would + // reject the escalation outright. + escalation_reason: Field2.textarea({ + label: "Escalation Reason", + group: "escalation" + }), + // No `parent_case`. A case hierarchy was declared here and never + // traversed: nothing rolled child cases up, nothing closed or notified them + // with the parent, and no service flow read the link. Related cases that + // matter in this app are linked through the knowledge article that resolved + // them (`resolved_by_article`), which the deflection measures do read. + // Resolution + resolution: Field2.markdown({ + label: "Resolution", + group: "resolution" + }), + /** + * The knowledge article that RESOLVED this case (#601). + * + * The second half of a two-way link, and deliberately not a replacement for + * the first. `crm_knowledge_article.related_to_case` points the other way — + * "the case this article was WRITTEN FROM" — and the two answer different + * questions: provenance (where did this article come from) versus + * deflection (what did this article save us). Merging them would make both + * unanswerable, so both stay. + * + * This is the column the deflection measures on `case_metrics` read + * (`kb_resolved_count` / `kb_deflection_rate`), which is why blank is + * normalised to NULL by `case_resolution_article_normalize` in + * `case.hook.ts`: the close-case screen sends `''` for a field the agent + * left empty, an empty string is NOT null, and `count(resolved_by_article)` + * counts it — a silently inflated numerator on a ratio widget, the exact + * shape of #614. + */ + resolved_by_article: Field2.lookup("crm_knowledge_article", { + label: "Resolved by Article", + group: "resolution", + description: "Knowledge article that resolved this case \u2014 the deflection signal." + }), + // Internal notes + internal_notes: Field2.markdown({ + label: "Internal Notes", + group: "system", + description: "Internal notes; not visible to the customer." + }), + // Flags + is_closed: Field2.boolean({ + label: "Is Closed", + group: "system", + defaultValue: false, + readonly: true + }) + }, + // Database indexes for performance + // + // `case_number` is an autonumber (`CASE-{00000}`), and the platform's + // autonumber sequence is PER TENANT — every organization counts from 1. A + // platform-wide unique index on it therefore rejects the second + // organization's `CASE-00001` on insert: the exact collision framework #3696 + // exists to prevent. The constraint has to match the sequence that feeds it. + // + // No `{ fields: ['organization_id', 'case_number'], unique: true }` here + // (#1023). Case-number uniqueness is declared on the `case_number` field + // itself — see the note there for why the hand-written table composite could + // not express it. Do NOT add it back alongside the field-level declaration + // either: declaring both makes the verbatim index win and leaves the + // per-organization one unreachable (framework#3991 + // `unique/double-declaration`), which would silently undo the fix. + indexes: [ + { fields: ["crm_account"] }, + { fields: ["owner_id"] }, + { fields: ["status"] }, + { fields: ["priority"] } + ], + // API surface. History → Field.trackHistory (ADR-0052). + enable: { + apiEnabled: true, + // #602 — screenshots and logs are how a support case gets diagnosed. + // See the canonical capability note in `src/sales/objects/index.ts`. + files: true + }, + // ADR-0052 §5b.2 — declarative milestone activity for the service narrative. + // The caseSideEffects hook still owns its real side-effects (escalation task, + // closed-date stamping); these are timeline entries only, emitted by the platform. + activityMilestones: [ + { field: "status", value: "escalated", summary: "Case escalated \u2014 {subject}", type: "updated" }, + { field: "status", value: "resolved", summary: "Case resolved \u2014 {subject}", type: "completed" }, + { field: "status", value: "closed", summary: "Case closed \u2014 {subject}", type: "completed" } + ], + // ADR-0079: render-only `titleFormat` retired in favor of `nameField`, + // which names a real field. The former template composed two local fields, so + // the `display_title` formula field (see fields) reproduces it. + nameField: "display_title", + // Explicit search targets (ADR-0061). REQUIRED because nameField is a + // FORMULA (display_title/full_name): without this, $search auto-defaults to + // the formula field, which isn't a real column, so the lookup picker + global + // search silently return zero. These are real, indexed columns. + searchableFields: ["subject", "case_number"], + highlightFields: ["case_number", "subject", "crm_account", "status", "priority"], + // Removed: list_views and form_views belong in UI configuration, not object definition + // Predicates below are TOTAL: every `record.x` read is `has()`-guarded, so the + // rule returns a verdict even when the merged record has no such key. See + // AGENTS.md "Validation predicates must be TOTAL" and + // test/object-validation-predicates.test.ts, which fails the build otherwise. + validations: [ + { + name: "resolution_required_for_closed", + type: "script", + severity: "error", + message: "Resolution is required when closing a case", + condition: P2`has(record.status) && record.status == "closed" && (!has(record.resolution) || isBlank(record.resolution))` + }, + { + name: "escalation_reason_required", + type: "script", + severity: "error", + message: "Escalation reason is required when escalating a case", + condition: P2`has(record.is_escalated) && record.is_escalated == true && (!has(record.escalation_reason) || isBlank(record.escalation_reason))` + }, + { + name: "case_status_progression", + type: "state_machine", + severity: "warning", + message: "Invalid status transition", + field: "status", + // Escalate + Close actions are available from ANY open status (see + // escalate_case / close_case visibility). The transition map must permit + // →escalated and →closed from every open state, else those actions emit a + // spurious "Invalid status transition" warning (e.g. escalating a brand-new + // case, which is a legitimate support move). + transitions: { + "new": ["in_progress", "waiting_customer", "escalated", "closed"], + "in_progress": ["waiting_customer", "waiting_support", "escalated", "resolved", "closed"], + "waiting_customer": ["in_progress", "waiting_support", "escalated", "closed"], + "waiting_support": ["in_progress", "waiting_customer", "escalated", "closed"], + "escalated": ["in_progress", "resolved", "closed"], + "resolved": ["closed", "in_progress"], + // Can reopen + "closed": ["in_progress"] + // Can reopen + } + } + ] + // ⚠️ No `workflows[]` here, and none is possible: object `workflows[]` were + // removed from the platform. Field updates live in this object's `*.hook.ts`; + // scheduled status flips and notifications live in `src/*/flows/*.flow.ts`. +}); + +// src/service/objects/knowledge_article.object.ts +import { ObjectSchema as ObjectSchema3, Field as Field3 } from "@objectstack/spec/data"; +import { F as F2, P as P3 } from "@objectstack/spec"; +var KnowledgeArticle = ObjectSchema3.create({ + name: "crm_knowledge_article", + label: "Knowledge Article", + pluralLabel: "Knowledge Articles", + icon: "book-open", + description: "Reusable knowledge base articles for self-service and AI grounding", + // ADR-0090 D1/D7: OWD is an authored decision. Knowledge base is org-readable; authors edit. + sharingModel: "public_read", + // ─── Public access ───────────────────────────────────────────────────── + // + // Publishing a public article mints a share link through the platform's + // `publicSharing` surface (maintainer ruling, 2026-08-02: no customer portal, + // no anonymous-grant widening). ⛔ The whole safety of that rests on + // `eligibility`, which is the ONLY thing standing between a share dialog and + // a stranger reading an internal or draft article — so this block may only be + // declared while every key below is enforced. + // + // MEASURED on `@objectstack/plugin-sharing@17.1.0` — the version + // installed AT THE TIME of the measurement, not the current pin (this table + // has NOT been re-taken on any later pin — not 17.3.0, #1676, not 17.4.0, + // PR #1814, and not 17.5.0) — + // against the real `ShareLinkService` and a real engine, + // not read off a grep count: + // + // | key | measured on 17.1.0 | + // | -------------------- | ---------------------------------------------- | + // | `enabled` | ENFORCED — false ⇒ SHARING_NOT_ENABLED 422 | + // | `allowedAudiences` | ENFORCED — `signed_in` refused 422 | + // | `allowedPermissions` | ENFORCED — non-`view` refused 422 | + // | `redactFields` | APPLIED to every token-served response | + // | `eligibility` | **ENFORCED — false verdict ⇒ 422, no link** | + // + // `test/knowledge-article-share-links.test.ts` drives all of it end to end + // and is the acceptance evidence; read it before changing anything here. + // + // ⚠️ TWO SPELLING TRAPS, both measured, both of which produce a block that + // LOOKS declared and silently is not: + // + // 1. `eligibility` must be a PLAIN STRING. It is `z.ZodString` in the spec + // and `getPolicy()` keeps it only when `typeof raw.eligibility === + // 'string'`. The `P` tagged template used by `validations[].condition` + // below returns an Expression OBJECT `{ dialect, source }` — passing one + // here does not narrow anything, it makes the predicate vanish. + // + // 2. Every field read is `record.`-PREFIXED. The evaluator is + // `ExpressionEngine` from `@objectstack/formula` (record-level CEL), and + // `record` is the ONLY binding it is given. The bare-identifier spelling + // `status == 'published' && audience == 'public'` COMPILES and then fails + // at evaluate with `Unknown variable: audience`, + // which `assertEligible` turns into ELIGIBILITY_UNEVALUABLE 422. That + // fails CLOSED, so it is not a security hole; it is a feature that never + // mints a single link while reading as if it works. + // + // The predicate is TOTAL for the same reason the `validations` below are: + // `has()` guards every read. `assertEligible` materializes declared fields to + // `null` first, so an absent key would not abort here today — the guards keep + // that true if the field set changes. (The `has(record.x)` caveat carried + // from objectstack#7861 is about `compileCelToFilter`, the SHARING-RULE path. + // That is a different evaluator, it is not on this code path, and it is not + // even exported from `@objectstack/plugin-sharing`. Verified, not assumed.) + // + // ⚠️ Eligibility is evaluated at MINT time only; `resolveToken()` does not + // re-check it. Re-classifying a published/public article to internal or back + // to draft does NOT revoke links already minted from it — those must be + // revoked explicitly. That is platform behaviour, filed upstream, not + // something this app compensates for app-side. + publicSharing: { + enabled: true, + // `public` and `link_only` only. `signed_in` would be a different feature + // and `email` is refused at creation without an allowlist. + allowedAudiences: ["public", "link_only"], + // Read-only. Same as the platform default, declared anyway: this is a + // security boundary, and a default is not a decision. + allowedPermissions: ["view"], + // The gate. Published AND public-audience, nothing else — a draft, an + // in_review, an archived, or any internal-audience article is refused at + // `createLink` with RECORD_NOT_ELIGIBLE 422 and no row is written. + eligibility: 'has(record.status) && record.status == "published" && has(record.audience) && record.audience == "public"', + // Stripped from every token-served response. These are the fields that + // exist for staff: who owns the article, which customer case it was + // written from, and when an editor last reviewed it. None of them are part + // of the answer a reader followed the link for. + redactFields: ["owner_id", "related_to_case", "last_reviewed_at"] + }, + // ADR-0079: render-only `titleFormat` retired in favor of `nameField`, + // which names a real field. The former template composed two local fields, so + // a `display_title` formula field reproduces it for the record title. + nameField: "display_title", + // Explicit search targets (ADR-0061). REQUIRED because nameField is a + // FORMULA (display_title/full_name): without this, $search auto-defaults to + // the formula field, which isn't a real column, so the lookup picker + global + // search silently return zero. These are real, indexed columns. + searchableFields: ["title", "article_number", "summary"], + highlightFields: ["article_number", "title", "category", "status", "audience"], + fieldGroups: [ + { key: "basic", label: "Article Information", icon: "info" }, + { key: "content", label: "Content", icon: "file-text" }, + { key: "taxonomy", label: "Categorization", icon: "tag" }, + { key: "metrics", label: "Engagement", icon: "activity", collapse: "collapsed" } + ], + fields: { + // Platform ownership anchor — canonical note in `account.object.ts` (#548). + owner_id: Field3.lookup("sys_user", { + label: "Article Owner", + group: "basic", + system: true, + readonly: false, + trackHistory: true + }), + article_number: Field3.autonumber({ + label: "Article Number", + format: "KA-{0000}", + group: "basic" + }), + title: Field3.text({ + label: "Title", + required: true, + storage: { notNull: true }, + searchable: true, + maxLength: 255, + group: "basic" + }), + // ADR-0079 record title (was titleFormat '{article_number} - {title}'). + display_title: Field3.formula({ + label: "Display Title", + expression: F2`record.article_number + " - " + record.title`, + group: "basic" + }), + summary: Field3.text({ + label: "Summary", + description: "One-paragraph TL;DR shown in search results and AI citations.", + maxLength: 500, + searchable: true, + group: "basic" + }), + body: Field3.markdown({ + label: "Body", + description: "Full article content (Markdown).", + searchable: true, + group: "content" + }), + category: Field3.select({ + label: "Category", + group: "taxonomy", + options: [ + { label: "Getting Started", value: "getting_started", default: true }, + { label: "How-To", value: "how_to" }, + { label: "Troubleshooting", value: "troubleshooting" }, + { label: "Billing & Pricing", value: "billing" }, + { label: "API & Integrations", value: "api" }, + { label: "Release Notes", value: "release_notes" }, + { label: "Policy", value: "policy" } + ] + }), + tags: Field3.select({ + label: "Tags", + multiple: true, + group: "taxonomy", + options: [ + { label: "Auth", value: "auth" }, + { label: "SSO", value: "sso" }, + { label: "Mobile", value: "mobile" }, + { label: "Email", value: "email" }, + { label: "Reports", value: "reports" }, + { label: "Performance", value: "performance" }, + { label: "Data Import", value: "data_import" }, + { label: "Webhooks", value: "webhooks" } + ] + }), + status: Field3.select({ + label: "Status", + required: true, + storage: { notNull: true }, + group: "basic", + trackHistory: true, + options: [ + { label: "Draft", value: "draft", color: "#94A3B8", default: true }, + { label: "In Review", value: "in_review", color: "#F59E0B" }, + { label: "Published", value: "published", color: "#10B981" }, + { label: "Archived", value: "archived", color: "#475569" } + ] + }), + audience: Field3.select({ + label: "Audience", + required: true, + storage: { notNull: true }, + group: "basic", + description: "Public articles are visible in the customer portal; internal articles are agent-only.", + options: [ + { label: "Public", value: "public", default: true, color: "#0EA5E9" }, + { label: "Internal", value: "internal", color: "#7C3AED" } + ] + }), + language: Field3.select({ + label: "Language", + group: "basic", + options: [ + { label: "English", value: "en", default: true }, + { label: "Simplified Chinese", value: "zh_cn" }, + { label: "Spanish", value: "es_es" }, + { label: "Japanese", value: "ja_jp" } + ] + }), + related_to_case: Field3.lookup("crm_case", { + label: "Originating Case", + description: "Case this article was authored from (optional).", + group: "content" + }), + published_at: Field3.datetime({ + label: "Published At", + readonly: true, + group: "basic" + }), + last_reviewed_at: Field3.datetime({ + label: "Last Reviewed At", + readonly: true, + group: "basic" + }), + /** + * `view_count` is GONE (#601), and this note is the record of why. + * + * All three engagement counters were `readonly: true` with a writer + * nowhere — on the platform or in this app — so all three were pinned at + * whatever the seed said, forever, while the article grid summed a "Views" + * column. ADR-0049's enforce-or-remove leaves two honest endings per + * field: give it a writer, or delete it. The card left this one to the + * implementer, and the two below went the other way, so the split is + * argued rather than assumed. + * + * A page-view writer WOULD have been expressible — `afterFind` is a real + * hook event on this platform. It is not built, because of what the event + * actually means: `beforeFind`/`afterFind` fire on record MATERIALIZATION, + * for `find` and `findOne` alike, with no per-method read event + * (deliberately — see the spec's note on #3195). So a counter written + * there would increment on the article grid, on global search, on the + * lookup picker in the close-case screen, on the AI grounding queries that + * cite articles — every one of them a "view" of a row nobody read. The + * number would grow fastest for articles nobody opens, and it would carry + * a database write on every read path in the app to do it. + * + * "Views" that means "appearances in any query" is a worse lie than a + * field that is missing, because it looks like data. A real page-view + * counter needs a real view event from a real article surface — the day + * one exists, this field comes back with it, and not before. + * + * `helpful_count` / `not_helpful_count` DO get a writer, and it is the + * whole reason `crm_article_feedback` exists: reader verdicts are recorded + * as rows and these two are RECOUNTED from them by + * `article_feedback_metrics_refresh`. They stay `readonly: true` and that + * is now an accurate statement — derived from evidence, never typed in. + */ + helpful_count: Field3.number({ + label: "Helpful Votes", + group: "metrics", + readonly: true, + defaultValue: 0, + description: "Recounted from crm_article_feedback \u2014 never typed in." + }), + not_helpful_count: Field3.number({ + label: "Not Helpful Votes", + group: "metrics", + readonly: true, + defaultValue: 0, + description: "Recounted from crm_article_feedback \u2014 never typed in." + }) + }, + indexes: [ + { fields: ["title"] }, + { fields: ["category"] }, + { fields: ["status"] }, + { fields: ["audience"] }, + { fields: ["language"] } + ], + // API surface. History → Field.trackHistory (ADR-0052). + enable: { + apiEnabled: true, + apiMethods: ["get", "list", "create", "update", "delete"] + }, + // Predicates below are TOTAL: every `record.x` read is `has()`-guarded, so the + // rule returns a verdict even when the merged record has no such key. See + // AGENTS.md "Validation predicates must be TOTAL" and + // test/object-validation-predicates.test.ts, which fails the build otherwise. + validations: [ + { + name: "published_requires_body", + type: "script", + severity: "error", + message: "Articles cannot be published without a body.", + condition: P3`has(record.status) && record.status == "published" && (!has(record.body) || record.body == null || record.body == "")` + }, + { + name: "published_requires_summary", + type: "script", + severity: "warning", + message: "Published articles should have a summary for search results and AI citations.", + condition: P3`has(record.status) && record.status == "published" && (!has(record.summary) || record.summary == null || record.summary == "")` + } + ] +}); + +// src/sales/objects/index.ts +var objects_exports2 = {}; +__export(objects_exports2, { + Account: () => Account, + Contact: () => Contact, + Event: () => Event, + EventAttendee: () => EventAttendee, + Forecast: () => Forecast, + Lead: () => Lead, + Opportunity: () => Opportunity, + Task: () => Task +}); + +// src/sales/objects/account.object.ts +import { ObjectSchema as ObjectSchema4, Field as Field4 } from "@objectstack/spec/data"; +import { F as F3 } from "@objectstack/spec"; + +// src/sales/objects/_picklists.ts +var SALUTATION_OPTIONS = [ + { label: "Mr.", value: "mr" }, + { label: "Ms.", value: "ms" }, + { label: "Mrs.", value: "mrs" }, + { label: "Dr.", value: "dr" }, + { label: "Prof.", value: "prof" } +]; +var INDUSTRY_OPTIONS = [ + { label: "Technology", value: "technology" }, + { label: "Software / SaaS", value: "software" }, + { label: "Finance", value: "finance" }, + { label: "Healthcare", value: "healthcare" }, + { label: "Retail", value: "retail" }, + { label: "Manufacturing", value: "manufacturing" }, + { label: "Education", value: "education" }, + { label: "Real Estate", value: "real_estate" }, + { label: "Media & Entertainment", value: "media" }, + { label: "Logistics", value: "logistics" }, + { label: "Hospitality", value: "hospitality" }, + { label: "Energy & Utilities", value: "energy" }, + { label: "Government", value: "government" }, + { label: "Non-profit", value: "nonprofit" }, + { label: "Other", value: "other" } +]; +var LEAD_SOURCE_OPTIONS = [ + { label: "Web", value: "web" }, + { label: "Referral", value: "referral" }, + { label: "Event / Trade Show", value: "event" }, + { label: "Webinar", value: "webinar" }, + { label: "Partner", value: "partner" }, + { label: "Advertisement", value: "advertisement" }, + { label: "Paid Search", value: "paid_search" }, + { label: "Social Media", value: "social" }, + { label: "Content / Blog", value: "content" }, + { label: "Cold Call", value: "cold_call" }, + { label: "Email Campaign", value: "email_campaign" }, + { label: "Other", value: "other" } +]; +var PAYMENT_TERMS_OPTIONS = [ + { label: "Net 15", value: "net_15" }, + { label: "Net 30", value: "net_30", default: true }, + { label: "Net 60", value: "net_60" }, + { label: "Net 90", value: "net_90" }, + { label: "Due on Receipt", value: "due_on_receipt" } +]; +var TASK_TYPE_OPTIONS = [ + { label: "Call", value: "call" }, + { label: "Email", value: "email" }, + { label: "Meeting", value: "meeting" }, + { label: "Follow-up", value: "follow_up" }, + { label: "Demo", value: "demo" }, + { label: "Other", value: "other" } +]; +var OPPORTUNITY_STAGE_OPTIONS = [ + { label: "Prospecting", value: "prospecting", color: "#808080", default: true }, + { label: "Qualification", value: "qualification", color: "#FFA500" }, + { label: "Needs Analysis", value: "needs_analysis", color: "#FFD700" }, + { label: "Proposal", value: "proposal", color: "#4169E1" }, + { label: "Negotiation", value: "negotiation", color: "#9370DB" }, + { label: "Closed Won", value: "closed_won", color: "#00AA00" }, + { label: "Closed Lost", value: "closed_lost", color: "#FF0000" } +]; +var EVENT_TYPE_OPTIONS = [ + { label: "Meeting", value: "meeting", color: "#4169E1", default: true }, + { label: "Call", value: "call", color: "#00AA00" }, + { label: "Demo", value: "demo", color: "#9370DB" }, + { label: "Webinar", value: "webinar", color: "#FFA500" }, + { label: "Onsite Visit", value: "onsite_visit", color: "#0EA5E9" }, + { label: "Other", value: "other", color: "#808080" } +]; +var EVENT_STATUS_OPTIONS = [ + { label: "Planned", value: "planned", color: "#4169E1", default: true }, + { label: "Held", value: "held", color: "#00AA00" }, + { label: "Cancelled", value: "cancelled", color: "#999999" }, + { label: "No Show", value: "no_show", color: "#FF4500" } +]; +var ATTENDEE_RESPONSE_OPTIONS = [ + { label: "No Response", value: "no_response", color: "#808080", default: true }, + { label: "Accepted", value: "accepted", color: "#00AA00" }, + { label: "Declined", value: "declined", color: "#FF0000" }, + { label: "Tentative", value: "tentative", color: "#FFA500" } +]; +var RELATED_TO_TYPE_OPTIONS = [ + { label: "Account", value: "crm_account" }, + { label: "Contact", value: "crm_contact" }, + { label: "Opportunity", value: "crm_opportunity" }, + { label: "Lead", value: "crm_lead" }, + { label: "Case", value: "crm_case" } +]; +var DUPLICATE_OF_TYPE_AUTHORABLE_OPTIONS = [ + { label: "Lead", value: "crm_lead" }, + { label: "Contact", value: "crm_contact" } +]; +var DUPLICATE_OF_TYPE_ERASED = "erased"; +var DUPLICATE_OF_TYPE_OPTIONS = [ + ...DUPLICATE_OF_TYPE_AUTHORABLE_OPTIONS, + { label: "Erased Record", value: DUPLICATE_OF_TYPE_ERASED } +]; +var plainOptions = (options) => options.map(({ label, value }) => ({ label, value })); +var LEAD_NEED_TYPE_OPTIONS = [ + { label: "New Implementation", value: "new_implementation" }, + { label: "Expansion", value: "expansion" }, + { label: "Replacement", value: "replacement" }, + { label: "Renewal", value: "renewal" }, + { label: "Consulting", value: "consulting" }, + { label: "Support & Maintenance", value: "support" }, + { label: "Other", value: "other" } +]; + +// src/sales/objects/_territory.ts +var TERRITORY = { + NA: "na", + EMEA: "emea", + OTHER: "other" +}; +var TERRITORY_OPTIONS = [ + { label: "North America", value: TERRITORY.NA, color: "#0070D2" }, + { label: "EMEA", value: TERRITORY.EMEA, color: "#7C3AED" }, + { label: "Other", value: TERRITORY.OTHER, color: "#999999" } +]; +var TERRITORY_FALLBACK = TERRITORY.OTHER; +var TERRITORY_COUNTRIES = { + na: ["US", "CA", "MX"], + emea: ["GB", "DE", "FR", "IT", "ES"] +}; +var COUNTRY_ALIASES = { + "United States": "US", + "United States of America": "US", + USA: "US", + Canada: "CA", + Mexico: "MX", + UK: "GB", + "United Kingdom": "GB", + "Great Britain": "GB", + Germany: "DE", + France: "FR", + Italy: "IT", + Spain: "ES" +}; +var COUNTRY_TERRITORY = (() => { + const map = {}; + for (const [territory, countries] of Object.entries(TERRITORY_COUNTRIES)) { + for (const code of countries) map[code] = territory; + } + for (const [alias, code] of Object.entries(COUNTRY_ALIASES)) { + const territory = map[code]; + if (!territory) { + throw new Error(`COUNTRY_ALIASES: "${alias}" points at "${code}", which no territory covers`); + } + const key = normalizeCountry(alias); + if (map[key] && map[key] !== territory) { + throw new Error(`COUNTRY_ALIASES: "${alias}" collides with an entry mapped to "${map[key]}"`); + } + map[key] = territory; + } + return map; +})(); +function normalizeCountry(value) { + return typeof value === "string" ? value.trim().replace(/\s+/g, " ").toUpperCase() : ""; +} + +// src/sales/objects/account.object.ts +var Account = ObjectSchema4.create({ + name: "crm_account", + label: "Account", + pluralLabel: "Accounts", + icon: "building", + description: "Companies and organizations doing business with us", + // ADR-0090 D1/D7: OWD is an authored decision. Owner + sharing rules (team/territory grants below). + sharingModel: "private", + // ADR-0079: render-only `titleFormat` retired in favor of `nameField`, + // which names a real field. The former template composed two local fields, so + // a `display_title` formula field reproduces it for the record title. + nameField: "display_title", + // Explicit search targets (ADR-0061). REQUIRED because nameField is a + // FORMULA (display_title/full_name): without this, $search auto-defaults to + // the formula field, which isn't a real column, so the lookup picker + global + // search silently return zero. These are real, indexed columns. + searchableFields: ["name", "account_number", "registration_number"], + highlightFields: ["account_number", "name", "type", "owner_id"], + // The record's picture (#1199): the record chrome draws the logo beside the + // title in every account page header. No logo, no picture: the platform + // draws no placeholder or initials in its place. + imageField: "logo", + // Field groups organize the form layout. Array order == display order. + // Each field below opts in via `group: ''`. + fieldGroups: [ + { key: "basic", label: "Basic Information", icon: "building" }, + { key: "financials", label: "Financials", icon: "dollar-sign" }, + // REQ-0003 acceptance 3: the business-profile fields render as their own + // group with NO `record:details` section authored anywhere — the derived + // layout ladder's rung 1 (AGENTS.md: escape hatches are for extreme cases). + { key: "business_profile", label: "Business Profile", icon: "briefcase" }, + { key: "contact_info", label: "Contact Information", icon: "phone" }, + { key: "ownership", label: "Ownership & Status", icon: "users" }, + { key: "branding", label: "Branding", icon: "palette", collapse: "collapsed" }, + { key: "system", label: "System", icon: "settings", collapse: "collapsed" } + ], + fields: { + // ─── Ownership ───────────────────────────────────────────────────── + // + // `owner_id` is the PLATFORM ownership anchor, not an app invention: the + // registry injects exactly this column into every user-owned object + // (`applySystemFields`), and it is the one OWD, sharing rules, owner-scope + // widening and the `is_private` row filter all read. ⛔ Never author a + // SECOND `owner` lookup beside it — reassigning that moves the record in + // every list and report and moves no access at all. + // + // ⚠️ Declared rather than left to injection, which the platform supports + // explicitly ("author-declared fields with the same name always win over + // injection, no overwrite"). Three things only a declaration buys: + // • `os validate` resolves it. An injected column is invisible to every + // author-time rule, so `highlightFields: ['owner_id']` is reported as + // "not a field on this object — silently skipped by every consumer", + // and a CEL predicate reading `record.owner_id` fails outright. + // • the per-object label and `group` survive (an injected field carries + // the generic label "Owner" and no group at all); + // • `trackHistory` survives, so a transfer still renders on the record + // timeline instead of only in the compliance audit log. + // `system: true` keeps the injected marker the platform's own tooling + // reads — notably the clone path, which strips system columns so a copy is + // stamped to the cloner rather than inheriting the source's owner. + // + // No `defaultValue`: the security middleware stamps `owner_id` to the + // acting user on any insert that leaves it empty, and denies one that names + // another user without `allowTransfer` (#3004). That is stronger than a + // field default, which evaluates to nothing on every user-less write. + owner_id: Field4.lookup("sys_user", { + label: "Account Owner", + group: "ownership", + system: true, + readonly: false, + trackHistory: true + }), + // AutoNumber field - Unique account identifier + account_number: Field4.autonumber({ + label: "Account Number", + format: "ACC-{000000}", + group: "basic" + }), + // Basic Information + // + // ⚠️ `unique: true` is declared HERE, on the field, and deliberately NOT as + // a `{ fields: ['name'], unique: true }` entry in `indexes[]` below. The + // field-level form is tenant-scoped — it materializes as + // `(organization_id, name)`, unique WITHIN an organization — while a + // declared index is taken verbatim, i.e. platform-wide. The table form + // means the SECOND organization to create an "Acme Corp" is rejected by the + // database, and account name is also the seed data's external-id / upsert + // key (`src/sales/data/sales.seed.ts`), so it bites the first multi-tenant + // install. The composite also indexes the column, so no separate + // `{ fields: ['name'] }` entry is needed for the `searchableFields` / + // seed-upsert read paths. + name: Field4.text({ + label: "Account Name", + required: true, + storage: { notNull: true }, + searchable: true, + unique: true, + maxLength: 255, + group: "basic" + }), + /** + * Case- and whitespace-folded copy of `name` — the key lead conversion + * matches accounts on. + * + * ### Why a stored column, and not any of the cheaper shapes + * + * ⚠️ Three cheaper fixes are all dead ends, and each is a live platform + * constraint. `test/account-name-normalized-match.test.ts` re-measures every + * one so this note cannot quietly go stale: + * + * - **A flow cannot normalize.** `service-automation`'s `resolveToken` + * understands exactly one function form, `/^(NOW|TODAY)\s*\(\s*\)…/`. + * `{LOWER(x)}`, `{TRIM(x)}` and `{x.toLowerCase()}` all resolve to + * `undefined` (every bare identifier is substituted before the expression + * is evaluated, so no string method is reachable), and an unwrapped + * `LOWER({x})` interpolates literally to `"LOWER(Acme Corp)"`. + * - **A formula field cannot be the match key.** `driver-sql`'s + * `fieldHasColumn` returns false for `type: 'formula'`, so a computed + * value has no physical column and nothing can filter on it. + * - **`$regex` is not an answer.** On `driver-sql` it does not run as a + * regex at all: it compiles to `LIKE '%value%'`, a SUBSTRING match, so + * `"Acme Corp"` also matches `"Not Acme Corp Ltd"`. It cannot collapse + * internal whitespace, the leading wildcard defeats the index, and on the + * in-memory driver it does compile user-controlled text into a `RegExp`. + * + * So the canonical form is established by the PRODUCER at write time — the + * same doctrine `crm_lead.email` / `crm_contact.email` follow — and the + * reader does a plain, indexed equality match. The other side of that + * comparison is `crm_lead.company_normalized`, which exists for the same + * reason: a flow can compare two stored columns, it cannot compute either. + * + * ### What it holds + * + * `name`, trimmed, lower-cased, with runs of internal whitespace collapsed + * to one space. Nothing else — normalize-then-EXACT. Fuzzy matching + * (punctuation folding, legal-suffix stripping, edit distance) is + * deliberately out of scope; it turns a lookup into a ranking problem and + * needs a human review affordance this app does not have. + * + * Derived, never authored: `account.hook.ts` recomputes it on every write + * that carries `name`, and leaves it alone otherwise. `readonly` keeps + * user/API writes off it (INSERT is exempt from the strip and UPDATE strips + * only CALLER-supplied keys, so the hook's own write always survives); + * `hidden` keeps a machine-owned column out of forms and pickers — the same + * pairing `crm_forecast.seed_key` uses. + */ + name_normalized: Field4.text({ + label: "Account Name (Normalized)", + description: "Match key for lead conversion: Account Name lower-cased, trimmed, with internal whitespace collapsed. Maintained by the account_protection hook \u2014 never edit directly.", + readonly: true, + hidden: true, + maxLength: 255, + group: "system" + }), + // ADR-0079 record title (was titleFormat '{account_number} - {name}'). + display_title: Field4.formula({ + label: "Display Title", + expression: F3`record.account_number + " - " + record.name`, + group: "basic" + }), + /** + * The counterparty's registered identity in a government registry. + * + * ⛔ NOT named after one country's registry, and that is the whole design + * constraint (REQ-0003 *Disposition & rationale*). The requirement arrived + * as 社会信用代码 because the customer registers in China; a Japanese install + * writes 法人番号 here, a German one a Handelsregisternummer, a US one an + * EIN. A `unified_social_credit_code` field would carry one country's + * registry in its NAME, where no install can rename it — so the core field + * is generic and the registry it came from is the install's own knowledge. + * + * ⚠️ Distinct from `account_number` above, which is OUR sequence + * (`Field.autonumber`, `ACC-{000000}`) and already spent as half the record + * title. That is an identifier we issue; this is one we were given, and + * invoicing, credit checks and entity resolution key on the latter. + * + * `searchable` + the `searchableFields` entry above is REQ-0003 acceptance + * 1 — the value is findable from global search and the lookup picker. It is + * indexed below for that read path. + * + * ⛔ NOT `unique: true`. Refusing a save because two rows carry the same + * registered identity is a data-quality POLICY, and this repo has already + * chosen the soft shape for that question once — the hard unique on + * `crm_lead.email` was removed because refusing a repeat is worse than + * recording it. The same reasoning `name_normalized` records: a match key, + * not a policy. Deduplication is a review affordance this app does not have. + */ + registration_number: Field4.text({ + label: "Registration Number", + description: "The counterparty's registered identity as issued by its own government registry \u2014 whichever registry that is. Not the Account Number, which we issue.", + searchable: true, + maxLength: 64, + group: "basic" + }), + /** + * What this account may be used for commercially — the category that GATES + * capability rather than merely classifying (REQ-0003, the record's most + * valuable primitive: *some counterparties are payable but not sellable*). + * + * ## Why a field BESIDE `type`, and not four more options on it + * + * REQ-0003 leaves this open ("either new options on `type` or a field + * beside it, decided when built"). It is a separate field because `type` + * is a RELATIONSHIP-STAGE axis — prospect → customer → former, plus + * partner — and it already has two readers that would be broken by a value + * meaning "may not be sold to": `account.hook.ts` promotes on it, and + * `opportunity.hook.ts` flips a won deal's account to `customer`. An + * `agency` option on `type` would therefore be overwritten into `customer` + * by the first won deal booked against it, silently un-restricting the + * account. The two axes are independent — an agency can be a prospect, a + * customer or a former customer — so they are two fields. + * + * ## Generic values only + * + * REQ-0003 rules the customer's own vocabulary (招标代理公司 …) **C**: + * overlay configuration, ⛔ never committed into core. Core ships the + * capability distinction itself; an install maps its market's categories + * onto these two values. + * + * ## What reads it: `opportunity.hook.ts` `beforeInsert` + * + * REQ-0003 is explicit that "a category no rule reads is prose, and the + * rule is the point", so this field ships WITH its reader. The reader is a + * hook, and which construct carries the gate is a maintainer ruling + * (2026-09-16), quoted verbatim and kept untranslated: + * + * 「闸门走 `opportunity.hook.ts` 的 `beforeInsert`，用 hook 的 `ctx.api` 读客户类别。 + * REQ-0003 第 128 行的 `validations[]` 与该记录自己的验收第 2 条冲突，以验收为准。」 + * + * ⛔ Do NOT restate the gate as the `validations[]` entry REQ-0003 line + * 128 names. TWO independent measurements say it cannot be that, and both + * are recorded here because each alone would be talked past: + * + * 1. **It would brick history.** A validation is evaluated against + * `{...previous, ...data}` on EVERY write, so "already linked to a + * restricted account" and "linking now" are the same state and every + * later edit to every historical opportunity would be refused — the + * exact thing REQ-0003 acceptance 2 forbids ("opportunities that + * already point at it keep working and keep being editable"). + * `lead.hook.ts` carries the same finding for its own gate. + * 2. **It cannot read the account at all.** A predicate is evaluated by + * `checkPredicate(rule, merged, previous)` over plain data objects — + * the opportunity's OWN stored columns. `record.crm_account.type` + * does not traverse the lookup (measured: `runtime: No such key: + * type`), and `os.lookup(...)` has no overload because `buildScope()` + * in `@objectstack/formula` composes `os` from only `ctx.user` / + * `ctx.org` / `ctx.env` and never binds `ctx.api` (measured: + * `runtime: found no matching overload for 'dyn.lookup(string, + * dyn)'`; filed upstream as objectstack#18318). An unevaluable + * predicate REJECTS THE WRITE, so authoring it literally refuses + * every opportunity write, insert and update alike. + * + * ⚠️ The hook's `ctx.api` is a DIFFERENT surface from the formula + * `EvalContext.api` that measurement 2 is about, and the two are routinely + * confused. The hook one is live and used ~20 times across + * `src/sales/objects/*.hook.ts`; its shape is `./_hook-api.ts`, pinned + * against a real engine by `test/hook-query-predicate.test.ts` and + * `test/hook-write-shape.test.ts`. objectstack#18318 does not block this + * field. + * + * ⛔ Do NOT "fix" anything here by denormalising this value onto + * `crm_opportunity`: a copy needs a writer and goes stale the moment an + * account is reclassified, and anything able to write the copy is able to + * simply refuse. + */ + commercial_capability: Field4.select({ + label: "Commercial Capability", + group: "basic", + description: "Whether new business may be opened against this account. Settlement Only accounts stay fully usable for billing and payment, but no new opportunity may be linked to them.", + defaultValue: "full", + options: [ + { label: "Full", value: "full", color: "#00AA00", default: true }, + { label: "Settlement Only", value: "settlement_only", color: "#FFA500" } + ] + }), + // Select fields with custom options + type: Field4.select({ + label: "Account Type", + group: "basic", + options: [ + { label: "Prospect", value: "prospect", color: "#FFA500", default: true }, + { label: "Customer", value: "customer", color: "#00AA00" }, + { label: "Partner", value: "partner", color: "#0000FF" }, + { label: "Former Customer", value: "former", color: "#999999" } + ] + }), + industry: Field4.select({ + label: "Industry", + group: "basic", + // Canonical set shared with Lead (#490): lead_conversion copies + // `leadRecord.industry` onto the account it creates, so this must + // accept every Lead value. + options: [...INDUSTRY_OPTIONS] + }), + description: Field4.markdown({ + label: "Description", + group: "basic" + }), + // Number fields + annual_revenue: Field4.currency({ + label: "Annual Revenue", + min: 0, + group: "financials", + trackHistory: true + }), + /** + * Rolled-up annual revenue of this account's direct children. + * + * ⚠️ DIRECT children only, one level — the engine aggregates over the rows + * whose `parent_account` is this account, not over a transitive closure. A + * grandparent shows the sum of its own children, and the docs say so; + * anything else needs a different (and much more expensive) primitive than + * the one the platform ships. + * + * Self-referencing roll-ups are worth measuring rather than assuming, + * because parent and child are the same object and the engine's summary + * index is keyed by child object. `test/decorative-field-sweep.test.ts` + * drives all four legs of the lifecycle (insert, raise, re-parent, delete) + * so a platform regression cannot quietly turn this back into decoration. + */ + child_account_revenue: Field4.summary({ + label: "Child Account Revenue", + group: "financials", + scale: 2, + summaryOperations: { + object: "crm_account", + field: "annual_revenue", + function: "sum", + relationshipField: "parent_account" + } + }), + number_of_employees: Field4.number({ + label: "Employees", + min: 0, + group: "financials" + }), + // ─── Business profile (REQ-0003 step 3) ──────────────────────────── + // + // Generic B2B sales intelligence, not IT-services vocabulary: who holds the + // account today, how much there is to win this year, and how they pay. + // + // ⚠️ `annual_revenue` above answers none of these — it is the account's OWN + // turnover, what the counterparty earns, whereas the budget below is what + // it will SPEND with vendors. Reusing one for the other is the mistake this + // group exists to prevent. + // + // ⚠️ `pnpm validate` reports all three as "carrier-only — declared but + // nothing in this stack reads or displays it", and that reading is EXPECTED + // here rather than a defect to tidy away. The liveness diagnostic counts + // view columns, form sections, page bindings, flow nodes, formulas, hooks + // and actions as sites; it does NOT count `fieldGroups` membership, which + // is precisely the DERIVED layout REQ-0003 acceptance 3 asks for ("render + // as their own group … without any `record:details` section being + // authored"). These are data-entry fields a person fills in and a person + // reads off the derived form. ⛔ Do NOT answer the warning by authoring a + // `record:details` section — that is the escape hatch AGENTS.md reserves + // for a named customer demand, and it would trade acceptance 3 for a + // quieter log. No guard reads this warning. + incumbent_vendor: Field4.text({ + label: "Incumbent Vendor", + description: "The supplier currently holding this account for the spend we are chasing.", + maxLength: 255, + group: "business_profile" + }), + annual_purchasing_budget: Field4.currency({ + label: "Annual Purchasing Budget", + description: "What this account expects to SPEND with vendors this year \u2014 not its own revenue.", + min: 0, + group: "business_profile" + }), + // Payment terms as a select, not free text: it is read by a person sizing + // cash-flow risk, and a picklist keeps that domain knowable. The values are + // the net-terms ladder every B2B install shares; a customer whose contracts + // use a different ladder overlays its own. + payment_cycle: Field4.select({ + label: "Payment Cycle", + group: "business_profile", + options: [ + { label: "Prepaid", value: "prepaid" }, + { label: "Net 30", value: "net_30" }, + { label: "Net 60", value: "net_60" }, + { label: "Net 90", value: "net_90" } + ] + }), + // Contact Information + phone: Field4.text({ + label: "Phone", + format: "phone", + group: "contact_info" + }), + website: Field4.url({ + label: "Website", + group: "contact_info" + }), + // Structured Address field (new field type) + billing_address: Field4.address({ + label: "Billing Address", + group: "contact_info" + }), + /** + * Flat projection of `billing_address.country`. + * + * ### Why the flat column exists — the trap that catches every rule + * ### authored against an `address` + * + * ⚠️ `billing_address` is an `address` field: the platform stores the whole + * {street, city, state, postalCode, country, countryCode, formatted} value + * in ONE column. A sharing rule's CEL condition is compiled to a + * pushdown-able `FilterCondition` by `compileCelToFilter`, and that compiler + * rejects every path reaching INSIDE such a value: + * + * record.billing_address.country in ["US","CA","MX"] + * → unsupported: cross-object/nested field path + * "record.billing_address.country" is not pushdown-able + * + * `plugin-sharing` then refuses to seed the rule rather than degrade it to + * match-all, so the rule is dropped on every boot and its recipients get + * nothing at all. Measured: the blocker is the NESTED PATH, not the + * `in [...]` operator — `in [...]`, `==`, `!=`, `<`, `>`, `&&`, `||`, `!`, + * `startsWith()` and `== null` all compile fine against a FLAT field. + * Rewriting the condition as a disjunction of `==` therefore does NOT help; + * only a flat column does. `test/sharing-seeding.test.ts` measures that + * matrix instead of assuming it. + * + * ### What it holds + * + * `billing_address.country`, trimmed, internal whitespace collapsed, and + * upper-cased — nothing else. It is what was TYPED, so it is still free + * text and still capable of holding `Deutschland`. Nothing matches against + * it: `territory` below classifies it, and an unrecognised spelling lands in + * a stated `other`. `countryCode` is deliberately not consulted; see the + * note in `account.hook.ts` for why the ISO slot is not the input. + * + * Derived, never authored: `account.hook.ts` recomputes it on every write + * that carries `billing_address`, and leaves it untouched otherwise. + */ + billing_country: Field4.text({ + label: "Billing Country", + description: "Derived from Billing Address \u2014 the country exactly as it was entered, trimmed and upper-cased. Territory is classified from it.", + readonly: true, + maxLength: 64, + group: "contact_info" + }), + /** + * Territory — the declared value the territory sharing rules filter on. + * + * ### Why a select and not the country + * + * Matching free-text `billing_country` against a list of country codes + * inside a CEL string means an account whose address reads `United States` + * belongs to NO territory, silently — the metadata says territory sharing + * works and for that account it does nothing, with no error anywhere. A + * `select` makes the domain knowable: three values, declared, every one + * reachable, and an account outside the staffed territories says `other` + * rather than nothing. + * + * It also collapses four copies of the country list (two CEL strings and + * six localised documentation tables) into one authored table in + * `./_territory.ts`. Adding a country is a line there; the sharing rules, + * this picklist and the docs all follow, and + * `test/territory-single-source.test.ts` fails if any of them does not. + * + * ### Readonly, and always stated + * + * Derived by `account_protection` from `billing_address.country`, never + * authored — correcting an account's territory means correcting its + * address, which keeps ONE fact behind the classification. Every insert + * states it (an account with no address at all is `other`), and an update + * that does not carry the address leaves it alone. + */ + territory: Field4.select({ + label: "Territory", + description: "Derived from Billing Address \u2014 the sales territory this account belongs to. Accounts outside the staffed territories are Other.", + readonly: true, + options: [...TERRITORY_OPTIONS], + group: "contact_info" + }), + // Office Location (new field type) + office_location: Field4.location({ + label: "Office Location", + group: "contact_info" + }), + // Relationship fields + /** + * The account hierarchy. `child_account_revenue` below is its one reader — + * the platform computes roll-up summaries itself, so the honest consumer is + * a single declaration rather than hand-written recompute hooks. + */ + parent_account: Field4.lookup("crm_account", { + label: "Parent Account", + description: "Parent company in hierarchy", + group: "ownership" + }), + // Boolean field + is_active: Field4.boolean({ + label: "Active", + defaultValue: true, + group: "ownership", + trackHistory: true + }), + /** + * Where this account stands in its sign-off (REQ-0003 step 5 / acceptance 4). + * + * `readonly`, so only the platform's own approval write reaches it: a + * user's insert or edit that names this column has it stripped (measured + * on 17.7.0 for `approved`, `pending` and `rejected` alike, #2067). + * + * ⛔ NOT a second boolean beside `is_active`, which REQ-0003 rules out by + * name. `is_active` answers "is this account live at all"; this answers + * "has the record been signed off", and collapsing them would make + * deactivating an account indistinguishable from rejecting one. + * + * ⚠️ Ships with NO default, and that is what keeps the gate armed (#2067). + * A new account is born blank, `account_approval` starts on the blank, and + * its approval node opens the request; the node's `approvalStatusField` + * mirror then writes `pending` (plugin-approvals `openNodeRequest`) before + * the create returns; only the create's own response body still shows the + * blank row it inserted. So with approvals in the composition REQ-0003 + * acceptance 4 holds in as many words ("A newly created account sits in a + * pending state, appears in the platform approval inbox …"), and `pending` + * always has a request behind it. Without approvals (a plan or edition + * that omits the capability) nothing opens a request, so nothing writes + * `pending`: the account stays blank and editable instead of reading + * "locked for approval" forever, which is what a shipped `pending` default + * did, since the console derives its lock from this column's value. + * + * ⛔ Do not restore `defaultValue: 'pending'`, nor an option-level + * `default: true` on Pending (the form would preselect it). An install + * that wants no account sign-off ADDS `defaultValue: 'approved'`; the + * flow's start condition is then false for every record and the gate is + * off, switchable and inert. That is the same kind of off switch + * `crm_lead.conversion_approval_status` records, and ⛔ NOT the flow's + * `status`, for the reasons measured in `lead-conversion-approval.flow.ts`. + * + * ⛔ There is deliberately no `not_required` value. Blank already says + * "no request has been opened", and `approved` already spells "nothing to + * decide". + */ + approval_status: Field4.select({ + label: "Approval Status", + group: "ownership", + readonly: true, + trackHistory: true, + options: [ + { label: "Pending", value: "pending", color: "#FFA500" }, + { label: "Approved", value: "approved", color: "#00AA00" }, + { label: "Rejected", value: "rejected", color: "#FF0000" } + ] + }), + // Brand color (new field type) + brand_color: Field4.color({ + label: "Brand Color", + group: "branding" + }), + // Company logo (uploaded image). `accept` / `maxSize` are server-enforced + // from @objectstack 17 — see the note on `crm_product.image`. + logo: Field4.image({ + label: "Company Logo", + group: "branding", + accept: ["image/png", "image/jpeg", "image/svg+xml", "image/webp"], + maxSize: 2 * 1024 * 1024 + }), + // Date field + // + // ⛔ NOT `readonly`, and it must not become readonly. This is the signal + // `at_risk_accounts` and `customer_churn_signals` are built on, and it is + // written by ONE path: another object's hook calling + // `api.object('crm_account').update({ last_activity_date }, …)`. + // + // ⚠️ Platform constraint: `stripReadonlyFields` deletes a readonly key from + // any payload whose CALLER supplied it, for every context that is not + // `isSystem` — and a hook's `ctx.api` is a `ScopedContext` over the ACTING + // USER's execution context, not a system one. So a readonly field a hook + // writes is silently dropped: the engine logs `Field '…' is read-only — + // ignoring incoming change` and the column stays null forever. + // + // ⛔ `crm_campaign_member.added_date` was cited here as a twin and is NOT + // one — it was ruled `readonly: true` in #1667 precisely because its + // writers are INSERTs, which the strip never reaches. THIS field is an + // UPDATE through a hook's `ctx.api`, which is the one shape that cannot be + // `readonly`. Note the rule + // is about the CONTEXT, not about hooks or flows as such — a hook stamping + // its own `ctx.input.data` survives, and a flow survives when its `runAs` + // is `'system'` (measured: `test/readonly-write-semantics.test.ts`, #1429; + // `crm_case.is_sla_violated` is cited elsewhere as a twin of this field + // and is NOT one — its writer is a system flow). This field stays out of + // every form section instead, which is the protection that actually + // holds. `test/activity-recency.test.ts` proves + // the write lands — and fails if the flag comes back. + last_activity_date: Field4.date({ + label: "Last Activity Date", + group: "system" + }), + // ─── Customer Success / Account Health ──────────────────────────── + tier: Field4.select({ + label: "Customer Tier", + group: "ownership", + options: [ + { label: "Strategic", value: "strategic", color: "#7C3AED" }, + { label: "Enterprise", value: "enterprise", color: "#4169E1" }, + { label: "Mid-Market", value: "mid_market", color: "#00AA00" }, + { label: "SMB", value: "smb", color: "#FFA500", default: true } + ] + }), + segment: Field4.select({ + label: "Segment", + group: "ownership", + options: [ + { label: "Net New", value: "net_new" }, + { label: "Growth", value: "growth" }, + { label: "At Risk", value: "at_risk" }, + { label: "Stable", value: "stable" } + ] + }), + health_score: Field4.select({ + label: "Health Score", + group: "ownership", + description: "CSM-maintained health indicator", + options: [ + { label: "Healthy", value: "healthy", color: "#00AA00" }, + { label: "Watching", value: "watching", color: "#FFA500" }, + { label: "At Risk", value: "at_risk", color: "#FF4500" }, + { label: "Churning", value: "churning", color: "#FF0000" } + ] + }) + // ⛔ No account-level renewal model here, on purpose. Renewal is a + // CONTRACT-level process with exactly one home — `crm_contract.end_date` + + // `renewal_notice_days`, swept daily by `src/revenue/flows/contract-renewal.flow.ts`, + // which books the task and notifies the CONTRACT owner; the user-facing + // queue is that object's `renewal_calendar` view. A `renewal_owner` / + // `next_renewal_date` pair here would be declared and inert, telling an + // admin a renewal reaches the CSM they named when nothing would. If an + // account-level renewal owner is ever wanted, it is a change to that flow + // plus a real writer for the date — not a second pair of fields. + }, + // Database indexes for performance + // + // ⚠️ No `{ fields: ['name'], unique: true }` here. Account-name uniqueness is + // declared on the `name` field itself, which the framework builds as the + // tenant composite `(organization_id, name)`. Declaring the single-column + // index too makes the platform-wide constraint win and leaves the per-tenant + // one unreachable (framework#3991 `unique/double-declaration`) — the same + // trap `crm_contact`, `crm_lead` and `crm_product` document. Two + // organizations must be able to each have their own "Acme Corp". + indexes: [ + { fields: ["owner_id"] }, + { fields: ["type", "is_active"] }, + // The territory sharing rules filter on this column, so it is read on every + // account query a territory recipient makes. `billing_country` carries no + // index of its own: nothing filters on it — it is displayed, and classified + // into this column by the hook. + { fields: ["territory"] }, + // Lead conversion filters on this column on every conversion — the column + // exists to replace an unindexed `$regex` scan. Plain index, NOT + // `unique: true`, deliberately: + // + // 1. Per-tenant uniqueness of account names is already declared on the + // `name` field. A unique `name_normalized` would SUBSUME it (equal names + // normalize equally) and force that constraint to be re-decided. + // 2. This column is a MATCH key, not a policy. Rejecting a near-duplicate + // name outright is a separate data-quality decision, and this repo has + // already chosen the soft shape for that question once (the hard unique + // on `crm_lead.email` was removed because refusing a repeat enquiry is + // worse than recording it). + // 3. ⚠️ Measured hazard: `create_index` FAILS on any deployment already + // holding `Acme Corp` and `ACME Corp` separately, so a unique index + // could not be an upgrade step without a merge pass first. That hazard + // is bounded today ONLY because this repo's deployment shape is fresh + // installs — see docs/MAINTENANCE.md §3.3. The conclusion is conditional + // on that premise, not universal. + // + // Consequence, recorded rather than hidden: two accounts CAN still hold the + // same normalized name if something outside the flow creates them, and + // `get_record` has no `sort` option, so the conversion would reuse an + // arbitrary one. Reusing one of N is still better than creating the N+1th. + { fields: ["name_normalized"] }, + // `searchableFields` carries `registration_number`, and the note at the top + // of this file records why those must be real, indexed columns. + { fields: ["registration_number"] } + ], + // API surface + capabilities. `files` and `feeds` are live and enforced (see + // the canonical note in `src/sales/objects/index.ts`). Field history lives on + // individual `Field.trackHistory` (ADR-0052); global search uses + // `searchableFields` / per-field `searchable`. + enable: { + apiEnabled: true, + // Expose via REST/GraphQL + apiMethods: ["get", "list", "create", "update", "delete"], + // Whitelist allowed API operations + // Contracts, org charts and RFPs live on the account record. Opt-in (spec + // default false); attach/download/delete authority is the parent record's + // own, so this adds a surface, not a grant. + files: true + } + // ⚠️ No `workflows[]` here, and none is possible: object `workflows[]` were + // removed from the platform. Field updates live in this object's `*.hook.ts`; + // scheduled status flips and notifications live in `src/*/flows/*.flow.ts`. +}); + +// src/sales/objects/contact.object.ts +import { ObjectSchema as ObjectSchema5, Field as Field5 } from "@objectstack/spec/data"; +import { F as F4 } from "@objectstack/spec"; +var Contact = ObjectSchema5.create({ + name: "crm_contact", + label: "Contact", + pluralLabel: "Contacts", + icon: "user", + description: "People associated with accounts", + // ADR-0090 D1/D7: OWD is an authored decision. Master-detail child of crm_account — inherits the account's sharing. + sharingModel: "controlled_by_parent", + fieldGroups: [ + { key: "identity", label: "Identity", icon: "user" }, + { key: "account_info", label: "Account & Title", icon: "briefcase" }, + { key: "buying_centre", label: "Buying Centre", icon: "users" }, + { key: "contact_info", label: "Contact Information", icon: "phone" }, + { key: "mailing_address", label: "Mailing Address", icon: "map-pin", collapse: "collapsed" }, + { key: "additional", label: "Additional Info", icon: "info", collapse: "collapsed" }, + { key: "preferences", label: "Communication Preferences", icon: "bell-off", collapse: "collapsed" } + ], + fields: { + // Platform ownership anchor — canonical note in `account.object.ts` (#548). + owner_id: Field5.lookup("sys_user", { + label: "Contact Owner", + group: "account_info", + system: true, + readonly: false, + trackHistory: true + }), + // Name fields + salutation: Field5.select({ + label: "Salutation", + group: "identity", + // Canonical set shared with Lead (#490) — see _picklists.ts. + options: [...SALUTATION_OPTIONS] + }), + first_name: Field5.text({ + label: "First Name", + required: true, + storage: { notNull: true }, + searchable: true, + group: "identity" + }), + last_name: Field5.text({ + label: "Last Name", + required: true, + storage: { notNull: true }, + searchable: true, + group: "identity" + }), + // Formula field - Full name + // `salutation` is a picklist, so the formula sees the raw VALUE (`ms`, `dr`), + // not the label — names rendered as "ms Emily Davis" in lists and details + // (#461). The formula language has no proper-case or option-label lookup, and + // hardcoding "Ms." would defeat translation, so the name is built from the + // name fields alone; salutation stays its own (translated) field. + full_name: Field5.formula({ + label: "Full Name", + expression: F4`joinNonEmpty([record.first_name, record.last_name], ' ')`, + group: "identity" + }), + // Avatar field. `accept` / `maxSize` are server-enforced from + // @objectstack 17 — see the note on `crm_product.image`. + avatar: Field5.avatar({ + label: "Profile Picture", + group: "identity", + accept: ["image/png", "image/jpeg", "image/webp"], + maxSize: 2 * 1024 * 1024 + }), + // Relationship: Link to Account (Master-Detail) + crm_account: Field5.masterDetail("crm_account", { + label: "Account", + required: true, + storage: { notNull: true }, + deleteBehavior: "cascade", + // Delete contacts when account is deleted + group: "account_info" + }), + // Professional Information + title: Field5.text({ + label: "Job Title", + group: "account_info" + }), + department: Field5.select({ + label: "Department", + group: "account_info", + options: [ + { label: "Executive", value: "executive" }, + { label: "Sales", value: "sales" }, + { label: "Marketing", value: "marketing" }, + { label: "Engineering", value: "engineering" }, + { label: "Support", value: "support" }, + { label: "Finance", value: "finance" }, + { label: "Human Resources", value: "hr" }, + { label: "Operations", value: "operations" } + ] + }), + // ── Buying centre (REQ-0004) ───────────────────────────────────────── + // + // The three attributes that turn an account's contact list from a + // DIRECTORY into a MAP: what this person does in the purchase decision, + // where they stand on us, and how strong our relationship with them is. + // `title` above is the employer's job title and `is_primary` below is a + // one-bit answer to "who do we call" — neither of them is this fact. + // + // ⛔ Read by people and by reporting, never by a gate. No hook, no flow + // and no validation is authored against any of the three, none is + // `required`, and none carries an option `default`: a contact with all + // three blank saves exactly as it did before this group existed + // (REQ-0004 acceptance 4). They are sales intelligence, and AGENTS.md + // metadata semantics rule 8 is what keeps a machine signal from refusing + // a write. + // ⚠️ `buying_function`, not `buying_role` — and 'Buying Function', not + // 'Buying Role'. `security-role-word` (an author-time rule, ADR-0090 D3) + // refuses the word `role` on BOTH, measured on this branch as two + // successive `pnpm validate` exit-1 runs: first the field name, then the + // label, because "admins must meet ONE vocabulary" and `role` is the + // platform's security vocabulary (permission_set / position / + // business_unit). Its own remedy prescribes the replacement used here — + // "a domain word (e.g. 'function', 'duty')". + // + // The rule's surface is the ENGLISH one it can read: it matches + // `/\brole(s)?\b/i` over object/field/action/permission-set/position/app + // declarations and does not reach the locale packs. So the three + // non-English packs keep the natural business term for this concept in + // their own language (zh-CN 采购角色, es-ES Rol de Compra, ja-JP 購買役割) + // — same fact, each written the way its reader says it. + buying_function: Field5.select({ + label: "Buying Function", + group: "buying_centre", + // SINGLE-valued, and REQ-0004 left that call to the implementing PR. + // `multiple: true` would cost the field the property acceptance 2 asks + // for: `GroupingConfigSchema` (`@objectstack/spec/ui`, the installed + // pin) answers a grouped list with ONE server-side aggregate query, and + // its `GroupingFieldSchema.field` says the group header "carries its + // raw stored value" — so a multi-valued column groups by the + // COMBINATION. `decision_maker` + `user` would become a group of its + // own instead of feeding both, which is the opposite of reading an + // account as a map. A person who is genuinely two things is recorded as + // the role that governs THIS decision; the second one is already + // legible from `title` / `department`. + // + // The six are the generic buying-centre slots every industry reads the + // same way — ⛔ deliberately not one company's role model. + options: [ + { label: "Decision Maker", value: "decision_maker" }, + { label: "Economic Buyer", value: "economic_buyer" }, + { label: "Technical Evaluator", value: "technical_evaluator" }, + { label: "User", value: "user" }, + { label: "Influencer", value: "influencer" }, + { label: "Gatekeeper", value: "gatekeeper" } + ] + }), + attitude: Field5.select({ + label: "Attitude to Us", + group: "buying_centre", + // ORDERED, most to least favourable — declaration order IS the order a + // picklist and a grouped list present, so the ladder is authored rather + // than described. A blank means nobody has formed a view yet, which is + // a different fact from `neutral`. + options: [ + { label: "Champion", value: "champion" }, + { label: "Supportive", value: "supportive" }, + { label: "Neutral", value: "neutral" }, + { label: "Skeptical", value: "skeptical" }, + { label: "Blocker", value: "blocker" } + ] + }), + relationship_strength: Field5.select({ + label: "Relationship Strength", + group: "buying_centre", + // ORDERED, weakest to strongest. ⛔ Not a free-text score, and ⛔ not + // derived from `last_contacted_date` below: recency is machine-written + // and measures something else — a weekly call with someone who will not + // take our side is not a strong relationship. A blank means unassessed; + // `distant` is an assessment that came back weak. + options: [ + { label: "Distant", value: "distant" }, + { label: "Acquaintance", value: "acquaintance" }, + { label: "Working Relationship", value: "working" }, + { label: "Strong", value: "strong" }, + { label: "Trusted Advisor", value: "trusted_advisor" } + ] + }), + // No `reports_to`. The org chart was declared and never built: no page + // rendered the tree the contact docs promised, no skill read the chain when + // summarising an account, and no flow escalated along it. Sharing derives + // from the master `crm_account`, never from this lookup. + // Contact Information + email: Field5.email({ + label: "Email", + required: true, + storage: { notNull: true }, + unique: true, + group: "contact_info" + }), + phone: Field5.text({ + label: "Phone", + format: "phone", + group: "contact_info" + }), + mobile: Field5.text({ + label: "Mobile", + format: "phone", + group: "contact_info" + }), + // Mailing Address — one structured `address` value, the same shape as + // `crm_account.billing_address` and `crm_lead.address`, because a postal + // address is one fact and AGENTS.md's field-type guidance names + // `Field.address()` for it (ruling on #1836; it replaced five flat + // `mailing_*` text fields, converted by `scripts/backfill-contact-mailing-address.ts`). + mailing_address: Field5.address({ + label: "Mailing Address", + group: "mailing_address" + }), + // Additional Information + // + // No `birthdate`. Nothing greeted, segmented or reported on it, and an + // importable date of birth with no consumer is personal data held for no + // stated purpose — the one field on this object where "declared but inert" + // also carries a data-protection cost. + lead_source: Field5.select({ + label: "Lead Source", + group: "additional", + // Canonical set shared with Lead + Opportunity (#490) — a converted + // lead's source must remain representable on the contact. + options: [...LEAD_SOURCE_OPTIONS] + }), + description: Field5.markdown({ + label: "Description", + group: "additional" + }), + // Flags + is_primary: Field5.boolean({ + label: "Primary Contact", + defaultValue: false, + description: "Is this the main contact for the account?", + group: "preferences" + }), + do_not_call: Field5.boolean({ + label: "Do Not Call", + defaultValue: false, + group: "preferences" + }), + email_opt_out: Field5.boolean({ + label: "Email Opt Out", + defaultValue: false, + group: "preferences" + }), + // Interaction recency for the PERSON (#592). `crm_account` carries + // `last_activity_date` for the company and `crm_lead` carries + // `last_contacted_date` for a prospect; the contact — the record a rep + // actually calls and emails — had neither, so "when did anyone last speak + // to our champion?" was unanswerable. + // + // Written by the activity bubble in `event.hook.ts` / `task.hook.ts` and by + // `send_email`. Deliberately NOT `readonly`: a readonly field is stripped + // from every non-system write whose caller supplied the key (#2948), which + // is exactly how the account and lead columns above ended up permanently + // null. It is kept off the form sections instead. + last_contacted_date: Field5.datetime({ + label: "Last Contacted", + group: "additional" + }) + }, + // Enable features + // API surface. History → Field.trackHistory (ADR-0052). + enable: { + apiEnabled: true, + // #602 — signed NDAs, business cards, meeting notes attach to the person. + // See the canonical capability note in `src/sales/objects/index.ts`. + files: true + }, + // Database indexes for performance + // + // NOTE: no `{ fields: ['email'], unique: true }` here. Email uniqueness is + // declared on the field itself (`unique: true`), which since framework #3696 + // materializes as the tenant composite `(organization_id, email)` — unique + // WITHIN an organization, which is what a multi-tenant CRM wants (two orgs + // may each know john@acme.com). A declared single-column index is taken + // verbatim, i.e. platform-wide, so declaring both left the global index + // enforcing the old behaviour and the per-tenant constraint unreachable + // (framework#3991 `unique/double-declaration`). + indexes: [ + { fields: ["crm_account"] }, + { fields: ["owner_id"] }, + { fields: ["last_name", "first_name"] } + ], + // Display configuration. ADR-0079 `nameField` names the real field holding + // the record title — here the `full_name` formula field defined above. + nameField: "full_name", + // Explicit search targets (ADR-0061). REQUIRED because nameField is a + // FORMULA (display_title/full_name): without this, $search auto-defaults to + // the formula field, which isn't a real column, so the lookup picker + global + // search silently return zero. These are real, indexed columns. + searchableFields: ["first_name", "last_name", "email"], + highlightFields: ["full_name", "email", "crm_account", "phone"] + // ⚠️ No standalone `type: 'unique'` validation exists on this platform + // (ADR-0032 validation union). Email uniqueness is enforced by the + // field-level `unique: true` above, scoped per organization. + // ⚠️ No `workflows[]` here, and none is possible: object `workflows[]` were + // removed from the platform. Field updates live in this object's `*.hook.ts`; + // scheduled status flips and notifications live in `src/*/flows/*.flow.ts`. +}); + +// src/sales/objects/event.object.ts +import { P as P4 } from "@objectstack/spec"; +import { ObjectSchema as ObjectSchema6, Field as Field6 } from "@objectstack/spec/data"; +var Event = ObjectSchema6.create({ + name: "crm_event", + label: "Event", + pluralLabel: "Events", + icon: "calendar-days", + description: "Meetings, calls and other scheduled interactions with customers", + // ADR-0090 D1/D7: OWD is an authored decision. Mirrors `crm_task`: an event + // is a personal activity record, owned by the rep who ran it. + sharingModel: "private", + fieldGroups: [ + { key: "basic", label: "Event Information", icon: "info" }, + { key: "schedule", label: "Schedule", icon: "calendar" }, + { key: "related", label: "Related Records", icon: "link" }, + { key: "outcome", label: "Outcome", icon: "clipboard-check", collapse: "collapsed" } + ], + fields: { + // Platform ownership anchor — canonical note in `account.object.ts` (#548). + owner_id: Field6.lookup("sys_user", { + label: "Assigned To", + group: "basic", + system: true, + readonly: false, + trackHistory: true + }), + // ─── Event Information ──────────────────────────────────────────── + subject: Field6.text({ + group: "basic", + label: "Subject", + required: true, + storage: { notNull: true }, + searchable: true, + maxLength: 255 + }), + type: Field6.select({ + group: "basic", + label: "Event Type", + required: true, + storage: { notNull: true }, + // Field-level default, not just the option flag: the option `default` + // only preselects in some form surfaces, so a quick-create opened from a + // related list left this required field blank (same defect crm_task.status + // carries a note about). + defaultValue: "meeting", + options: [...EVENT_TYPE_OPTIONS] + }), + status: Field6.select({ + group: "basic", + label: "Status", + required: true, + storage: { notNull: true }, + trackHistory: true, + defaultValue: "planned", + options: [...EVENT_STATUS_OPTIONS] + }), + description: Field6.markdown({ + group: "basic", + label: "Description" + }), + // ─── Schedule ───────────────────────────────────────────────────── + start_datetime: Field6.datetime({ + group: "schedule", + label: "Start", + required: true, + storage: { notNull: true } + }), + end_datetime: Field6.datetime({ + group: "schedule", + label: "End" + }), + all_day: Field6.boolean({ + group: "schedule", + label: "All Day Event", + defaultValue: false + }), + // Derived in `event.hook.ts` from start/end. NOT `readonly`: the field is + // also what the activity actions supply directly when a rep logs a call + // that took 20 minutes, and a readonly field is stripped from any write + // whose CALLER supplied the key (#2948) — including an action body running + // under the rep's own context. Derivation inside this object's own + // before-hook is unaffected either way (the strip keys off the caller's + // payload, not the post-hook document), so leaving it writable costs + // nothing and keeps `log_call` honest. + duration_minutes: Field6.number({ + group: "schedule", + label: "Duration (minutes)", + min: 0, + scale: 0 + }), + location: Field6.text({ + group: "schedule", + label: "Location", + maxLength: 255, + description: "Room, address, or meeting link" + }), + // ─── Related Records (polymorphic, same shape as crm_task) ───────── + related_to_type: Field6.select({ + group: "related", + label: "Related To Type", + options: [...RELATED_TO_TYPE_OPTIONS] + }), + related_to_account: Field6.lookup("crm_account", { + group: "related", + label: "Related Account" + }), + related_to_contact: Field6.lookup("crm_contact", { + group: "related", + label: "Related Contact" + }), + related_to_opportunity: Field6.lookup("crm_opportunity", { + group: "related", + label: "Related Opportunity" + }), + related_to_lead: Field6.lookup("crm_lead", { + group: "related", + label: "Related Lead" + }), + related_to_case: Field6.lookup("crm_case", { + group: "related", + label: "Related Case" + }), + // ─── Outcome ────────────────────────────────────────────────────── + outcome_notes: Field6.markdown({ + group: "outcome", + label: "Outcome Notes", + description: "What was agreed, and what happens next" + }) + // No `is_past` / `is_upcoming` boolean. A write-time snapshot of "has this + // happened yet" is stale the moment the clock passes it, and the app has + // already been burnt by exactly that (`crm_task.is_overdue` — see the + // `overdue_tasks` view's label note). `status` is the authored, non-decaying + // signal, and the upcoming/past views filter on it and sort by + // `start_datetime` instead. + }, + // API surface. History → Field.trackHistory (ADR-0052). + enable: { + apiEnabled: true + }, + indexes: [ + { fields: ["start_datetime"] }, + { fields: ["owner_id"] }, + { fields: ["status"] }, + { fields: ["related_to_account"] }, + { fields: ["related_to_opportunity"] } + ], + // ADR-0079: `nameField` names the real field holding the record title. + nameField: "subject", + highlightFields: ["subject", "type", "status", "start_datetime", "owner_id"], + searchableFields: ["subject", "location"], + // Predicates below are TOTAL: every `record.x` read is `has()`-guarded, so the + // rule returns a verdict even when the merged record has no such key. See + // AGENTS.md "Validation predicates must be TOTAL" and + // test/object-validation-predicates.test.ts, which fails the build otherwise. + validations: [ + { + name: "end_after_start", + type: "script", + severity: "error", + message: "The end time must be after the start time", + // BOTH guards, on both operands, because they answer different hazards + // (AGENTS.md "Validation predicates must be TOTAL"): + // · `has(...)` — absent key. On a driver that stores only the columns + // a row was written with, an absent `end_datetime` aborts the whole + // predicate under strict CEL, and from 17.0.0-rc.2 that abort REJECTS + // the save rather than skipping the rule (#4649). + // · `!= null` — present-but-null. `dyn < dyn` aborts too, and + // `has()` says nothing about it. + // An ordering comparison needs both; neither substitutes for the other. + condition: P4`has(record.start_datetime) && has(record.end_datetime) && record.start_datetime != null && record.end_datetime != null && !isBlank(record.end_datetime) && record.end_datetime < record.start_datetime` + }, + { + name: "related_to_required", + type: "script", + severity: "warning", + message: "At least one related record should be selected", + condition: P4`(!has(record.related_to_account) || isBlank(record.related_to_account)) && (!has(record.related_to_contact) || isBlank(record.related_to_contact)) && (!has(record.related_to_opportunity) || isBlank(record.related_to_opportunity)) && (!has(record.related_to_lead) || isBlank(record.related_to_lead)) && (!has(record.related_to_case) || isBlank(record.related_to_case))` + } + ] +}); + +// src/sales/objects/event_attendee.object.ts +import { expression } from "@objectstack/spec"; +import { ObjectSchema as ObjectSchema7, Field as Field7 } from "@objectstack/spec/data"; +var ATTENDEE_RESOLUTIONS = [ + { value: "contact", column: "crm_contact", label: "Contact", color: "#4169E1" }, + { value: "lead", column: "crm_lead", label: "Lead", color: "#FFA500" }, + { value: "user", column: "sys_user", label: "User", color: "#00AA00" }, + { value: "external", column: "external_name", label: "External", color: "#8A8A8A" } +]; +var DEFAULT_ATTENDEE_TYPE = "contact"; +var blank = (f) => `(!has(record.${f}) || isBlank(record.${f}))`; +var filled = (f) => `(has(record.${f}) && !isBlank(record.${f}))`; +var typeIs = (v) => `(has(record.attendee_type) && record.attendee_type == "${v}")`; +var typeIsNot = (v) => `(has(record.attendee_type) && record.attendee_type != "${v}")`; +var RESOLVES_CONDITION = ATTENDEE_RESOLUTIONS.map((r) => `(${typeIs(r.value)} && ${blank(r.column)})`).join(" || "); +var EXCLUSIVE_CONDITION = ATTENDEE_RESOLUTIONS.map((r) => `(${filled(r.column)} && ${typeIsNot(r.value)})`).join(" || "); +var partyFormHints = (column) => { + const resolution = ATTENDEE_RESOLUTIONS.find((r) => r.column === column); + if (!resolution) { + throw new Error(`No attendee resolution declares the column "${column}"`); + } + return { + requiredWhen: expression(typeIs(resolution.value), "cel") + }; +}; +var EventAttendee = ObjectSchema7.create({ + name: "crm_event_attendee", + label: "Event Attendee", + pluralLabel: "Event Attendees", + icon: "users", + description: "A person invited to or present at an event", + sharingModel: "controlled_by_parent", + // ADR-0079: junction rows have no derivable text title; point the canonical + // nameField at the stored autonumber explicitly (autonumber is not in the + // auto-derivation whitelist). + nameField: "attendee_number", + highlightFields: ["crm_event", "attendee_type", "response", "is_organizer"], + fieldGroups: [ + { key: "basic", label: "Attendee", icon: "user" }, + { key: "response", label: "Invitation", icon: "mail-check" } + ], + fields: { + attendee_number: Field7.autonumber({ + group: "basic", + label: "Attendee Number", + format: "EA-{00000}" + }), + // ⚠️ Deliberately left on the spec default, and NOT cascaded with the party + // lookups below. Because it is REQUIRED, the engine escalates the stored + // `set_null` to a refusal at delete time, with a message naming the real + // obstacle instead of an unrelated rule: "Cannot delete crm_event (...): 3 + // dependent crm_event_attendee record(s) reference it via crm_event + // (crm_event is required, so it cannot be cleared)." That is the correct + // answer on this side, for the same reason `crm_campaign_member.crm_campaign` + // keeps it: a meeting's attendee list is the meeting's historical record, + // not a per-person artefact. `test/event-attendee-cascade.test.ts` pins the + // resolved value so a copy-paste of the three cascades cannot reach here. + crm_event: Field7.lookup("crm_event", { + group: "basic", + label: "Event", + required: true, + storage: { notNull: true } + }), + // The discriminator says which of the four columns below is the live one. It + // is authored rather than derived so a query can filter "internal attendees + // only" without four OR'd null checks. The options are GENERATED from the + // resolution table rather than retyped — see the note at the top of this + // file for why the pairing is declared once. + attendee_type: Field7.select({ + group: "basic", + label: "Attendee Type", + required: true, + storage: { notNull: true }, + defaultValue: DEFAULT_ATTENDEE_TYPE, + options: ATTENDEE_RESOLUTIONS.map((r) => ({ + label: r.label, + value: r.value, + color: r.color, + ...r.value === DEFAULT_ATTENDEE_TYPE ? { default: true } : {} + })) + }), + // ⛔ `deleteBehavior: 'cascade'` on ALL THREE party lookups, not the default. + // + // ⚠️ Platform constraint: a lookup defaults to `set_null`, and the engine + // implements `set_null` by UPDATING the row that holds it. On a column a + // validation rule reads, that makes the referenced party permanently + // UNDELETABLE: clearing this column leaves the row the engine just edited in + // violation of `attendee_resolves` below, and the whole delete rolls back + // with an error naming an object the caller never addressed. The same + // construction bites `crm_campaign_member`. + // + // `external_name` is the fourth resolution, but it is blank on every row the + // product actually writes (`src/sales/actions/activity-actions.ts` logs attendees + // with a party reference and never an external name), so it rescues nothing. + // + // Cascade rather than `restrict`: an attendee row is a JUNCTION whose whole + // meaning is "this person was in this room". Once the person is gone the row + // denotes nothing, and the query it exists to serve ("meetings this person + // attended") has lost its subject. `restrict` would produce an accurate + // message but keep the person undeletable until someone deleted their + // attendance by hand, and undeletable PEOPLE is the impact being fixed. + // Cascade also leaves no reachable state in which a stored attendee row + // breaks its own object's rule. + crm_contact: Field7.lookup("crm_contact", { + group: "basic", + label: "Contact", + deleteBehavior: "cascade", + description: "Set when the attendee is an existing customer contact", + ...partyFormHints("crm_contact") + }), + crm_lead: Field7.lookup("crm_lead", { + group: "basic", + label: "Lead", + deleteBehavior: "cascade", + description: "Set when the attendee is still an unconverted lead", + ...partyFormHints("crm_lead") + }), + // `sys_user` gets the SAME answer as the two CRM parties, and it was worth a + // second look rather than a copy-paste: + // + // · Deleting a user is a real, reachable operation. Generic CRUD delete on + // the identity table is off (`sys_user` ships `apiMethods: ['get', + // 'list', 'update', 'bulk']`), but better-auth's own routes — + // `/api/v1/auth/delete-user`, which the platform's `sys_user` object + // surfaces as the "Delete My Account" record action, and + // `/api/v1/auth/admin/remove-user` — resolve `user` to `sys_user` and + // land on `dataEngine.delete(...)`, i.e. the SAME ObjectQL delete that + // runs the referential pass. So `set_null` here is not dormant: it breaks + // account erasure for any colleague who ever attended a meeting. + // · The app's shipped stance is already "a deleted user's references + // degrade". EVERY other `sys_user` lookup in HotCRM (every `owner_id`, + // plus `product_manager`) is `set_null` and NO validation rule reads any + // of them — the rule below is the only one in the app that reads a user + // reference at all, which is precisely why this is the only lookup where + // the default misbehaves. `restrict` here would make this junction the + // ONE app row able to veto a platform identity erasure — an app object + // holding a `protection: { lock: 'full' }`, better-auth-managed table + // hostage, surfacing as an opaque failure from an auth route. That is a + // layering inversion, not a fix. + // · The cost of cascade is bounded and is the right half to lose: the + // meeting itself (`crm_event` — subject, times, outcome notes) survives + // untouched; only the per-person row goes, and it goes because the + // person's identity record was erased. Deactivation, not deletion, is the + // ordinary offboarding path (the platform ships ban/unban), and it + // touches nothing here. + sys_user: Field7.lookup("sys_user", { + group: "basic", + label: "User", + deleteBehavior: "cascade", + description: "Set when the attendee is a colleague", + ...partyFormHints("sys_user") + }), + // Free text is the LAST resort, not the default: it exists only for the + // genuinely unmodelled guest (a prospect's lawyer who is in no CRM object). + // It is the resolution of ONE attendee type — `external` — and the rules + // below enforce that both ways: an `external` row must fill it, and no + // other type may. It is not a place to paste a list, and not a note field + // to hang off a Contact row. + external_name: Field7.text({ + group: "basic", + label: "External Attendee", + maxLength: 255, + description: "Name of an attendee who is in no CRM object \u2014 set when Attendee Type is External", + ...partyFormHints("external_name") + }), + response: Field7.select({ + group: "response", + label: "Response", + required: true, + storage: { notNull: true }, + trackHistory: true, + defaultValue: "no_response", + options: [...ATTENDEE_RESPONSE_OPTIONS] + }), + is_organizer: Field7.boolean({ + group: "response", + label: "Organizer", + defaultValue: false + }), + // ⛔ NOT `readonly` — but the cross-reference this note used to carry is + // retired, not merely reworded: `crm_campaign_member.added_date` was ruled + // `readonly: true` in #1667, so it is no longer a precedent for keeping an + // insert-stamped column open, and the reason it cited ("the engine strips a + // readonly key the CALLER supplied") does not reach an INSERT at all — the + // strip is an UPDATE-path rule (`test/readonly-write-semantics.test.ts`). + // What holds it open is now MEASURED (#1747, the per-writer census #1435 + // ran for the other three), not "nobody has ruled on it": this column has a + // user-context UPDATE writer, which none of the three columns #1666 / #1667 + // moved had. The census, in full: + // • the fifteen generated activity actions (5 `ACTIVITY_TARGETS` × 3 + // kinds, one shared body in `activity-actions.ts`) INSERT it, and an + // action body runs `isSystem` — exempt twice over; + // • the two `service.seed.ts` attendee seeds write it, and their + // `mode: 'upsert'` replay UPDATE is exempt too, because seed writes are + // `isSystem` (`flow-scheduled.test.ts` pins that via ownerless rows); + // • the record form — `event_attendee.view.ts` lists it in the + // `invitation` section, AUTHORED rather than synthesized, and the four + // profiles that name the object all grant `allowEdit`. A rep correcting + // Invited on a saved row is a non-`isSystem` UPDATE carrying a + // caller-supplied key: precisely what the strip deletes. The three + // flipped columns appear in NO form section anywhere in `src/*/views/`, + // `crm_opportunity`'s authored form included. + // ⭐ It is also not the same KIND of column. `added_date` / `approved_date` + // are stamped `{NOW()}` by the writer, so their value IS the write moment; + // `invited_date` records when the invitation went out, and the seed dates it + // 3-10 days before its own event, per row. A column whose value is not the + // write moment is one a person can be right about. ⛔ Do not flip it on the + // strength of the sibling ruling. + invited_date: Field7.datetime({ + group: "response", + label: "Invited" + }) + }, + indexes: [ + { fields: ["crm_event"] }, + { fields: ["crm_contact"] }, + { fields: ["sys_user"] } + ], + // ⚠️ Predicates below are TOTAL: every `record.x` read is `has()`-guarded, so + // the rule returns a verdict even when the merged record has no such key. See + // AGENTS.md "Validation predicates must be TOTAL" and + // test/object-validation-predicates.test.ts, which fails the build otherwise. + // + // Both rules are GENERATED from `ATTENDEE_RESOLUTIONS` at the top of this + // file. ⚠️ `expression(..., 'cel')` is the same envelope the ``P`…` `` tag + // produces, but the tag JSON-quotes an interpolated string and so cannot + // splice a source fragment — which is why these use the function form. The + // pairing is declared once and read twice; see the note up there. + validations: [ + // The type's own column must be filled. + { + name: "attendee_resolves", + type: "script", + severity: "error", + message: "An attendee must fill the party its Attendee Type names \u2014 a Contact row needs a Contact, an External row needs an External Attendee name", + condition: expression(RESOLVES_CONDITION, "cel") + }, + // …and no other column may be filled. The separate rule is deliberate: one + // condition, one wording. Folding both into `attendee_resolves` would make + // its message a lie for half the rows it rejects, and "you filled the wrong + // column" is not the same instruction as "you filled nothing". + { + name: "attendee_type_exclusive", + type: "script", + severity: "error", + message: "An attendee names exactly one party \u2014 clear every party column its Attendee Type does not name", + condition: expression(EXCLUSIVE_CONDITION, "cel") + } + ] +}); + +// src/sales/objects/forecast.object.ts +import { ObjectSchema as ObjectSchema8, Field as Field8 } from "@objectstack/spec/data"; +import { F as F5, P as P5 } from "@objectstack/spec"; +var Forecast = ObjectSchema8.create({ + name: "crm_forecast", + label: "Forecast", + pluralLabel: "Forecasts", + icon: "trending-up", + description: "Periodic pipeline snapshot by owner used for revenue forecasting.", + // OWD is an authored decision (ADR-0090 D1/D7). Forecasts are personal to the + // owner. + sharingModel: "private", + // ADR-0079 record title. ⚠️ A formula cannot dot-walk a lookup (ADR-0072), so + // `display_title` composes local fields only: period_label + (period_start). + nameField: "display_title", + // ⚠️ Explicit search targets (ADR-0061), REQUIRED because `nameField` is a + // FORMULA: without this, `$search` auto-defaults to the formula field, which + // is not a real column, so the lookup picker and global search silently + // return zero. These are real, indexed columns. + searchableFields: ["period_label"], + highlightFields: ["owner_id", "period", "period_start", "commit_amount", "closed_amount"], + fieldGroups: [ + { key: "basic", label: "Snapshot", icon: "info" }, + { key: "amounts", label: "Amounts", icon: "dollar-sign" }, + { key: "meta", label: "Source", icon: "database", collapse: "collapsed" } + ], + fields: { + // Platform ownership anchor — canonical note in `account.object.ts` (#548). + owner_id: Field8.lookup("sys_user", { + label: "Owner", + group: "basic", + system: true, + readonly: false, + trackHistory: true + }), + period: Field8.select({ + label: "Period", + required: true, + storage: { notNull: true }, + group: "basic", + options: [ + { label: "Month", value: "month", default: true }, + { label: "Quarter", value: "quarter" } + ] + }), + // Wording mirrors the two refusal messages this field is bound by + // (`period_start_first_of_period` / `quarter_starts_on_quarter_boundary`, + // both below) so the form and the rejection agree on the same rule + // instead of describing two different ones (#1085). + period_start: Field8.date({ + label: "Period Start", + description: "Must be the first day of the period \u2014 e.g. 2026-08-01 for Aug 2026. A quarterly forecast must additionally start on a quarter boundary: January 1, April 1, July 1 or October 1.", + required: true, + storage: { notNull: true }, + group: "basic" + }), + // Still not read-only: `forecast.hook.ts` fills it only when the write + // leaves it unset, and `src/sales/data/forecast.seed.ts` hand-fills it on every + // seeded row — so hand-entry is a capability this app uses. A hand-filled + // value is pinned to the same calendar period `period_start` is + // (`period_end_matches_calendar_period` below), and the description states + // that rule rather than the weaker `period_end_after_start` it subsumes: + // the form says what is actually enforced. + period_end: Field8.date({ + label: "Period End", + description: "Normally derived automatically from Period and Period Start. If set by hand, it must be the last day of that period \u2014 e.g. 2026-09-30 for a quarter starting 2026-07-01, or 2026-08-31 for Aug 2026.", + required: true, + storage: { notNull: true }, + group: "basic" + }), + period_label: Field8.text({ + label: "Period Label", + description: 'Human-friendly label, e.g. "Q3 2026" or "Aug 2026".', + group: "basic" + }), + // ADR-0079 record title. ⚠️ A formula cannot dot-walk a lookup (ADR-0072), + // so this composes local fields only; `period_start` (a date) is + // string()-coerced for concat. + // + // ⚠️ The coercion is `string()`, NOT `text()`. `text` is not a registered + // CEL function — it is absent from `CEL_STDLIB_FUNCTIONS` — so a formula + // using it faults at runtime and leaves the record's `nameField` null. The + // author-time `expression-invalid` rule now REPORTS it ("found no matching + // overload for 'text(dyn)'") instead of letting a broken formula through to + // null silently. `string` is the catalog's coercion, alongside + // `int`/`bool`/`double`/`timestamp`. + display_title: Field8.formula({ + label: "Display Title", + expression: F5`record.period_label + " (" + string(record.period_start) + ")"`, + group: "basic" + }), + snapshot_date: Field8.date({ + label: "Snapshot Date", + description: "The day this snapshot was captured.", + required: true, + storage: { notNull: true }, + group: "meta" + }), + quota: Field8.currency({ + label: "Quota", + min: 0, + group: "amounts", + trackHistory: true + }), + pipeline_amount: Field8.currency({ + label: "Pipeline", + description: "Sum of all open opportunities closing in this period (any stage).", + min: 0, + group: "amounts" + }), + best_case_amount: Field8.currency({ + label: "Best Case", + description: "Open opportunities in the Best Case or Commit forecast category.", + min: 0, + group: "amounts" + }), + commit_amount: Field8.currency({ + label: "Commit", + description: "Open opportunities in the Commit forecast category (owner-committed).", + min: 0, + group: "amounts" + }), + closed_amount: Field8.currency({ + label: "Closed Won", + description: "Already-closed-won amount in this period.", + min: 0, + group: "amounts" + }), + expected_amount: Field8.formula({ + label: "Expected", + description: "Closed Won + Commit \u2014 what the owner reasonably expects to land.", + expression: F5`coalesce(record.closed_amount, 0) + coalesce(record.commit_amount, 0)`, + scale: 2, + group: "amounts" + }), + attainment_pct: Field8.formula({ + label: "Attainment %", + description: "Closed Won \xF7 Quota \xD7 100. Reads 0% until a positive quota is set.", + expression: F5`coalesce(record.quota, 0) > 0 ? (coalesce(record.closed_amount, 0) * 100.0) / record.quota : 0.0`, + scale: 2, + group: "amounts" + }), + coverage_ratio: Field8.formula({ + label: "Coverage Ratio", + description: "Pipeline \xF7 (Quota \u2212 Closed Won) \u2014 whether enough pipeline remains to cover the gap. Reads 0 once the quota is already met.", + expression: F5`(coalesce(record.quota, 0) - coalesce(record.closed_amount, 0)) > 0 ? coalesce(record.pipeline_amount, 0) / (record.quota - coalesce(record.closed_amount, 0)) : 0.0`, + scale: 2, + group: "amounts" + }), + source: Field8.select({ + label: "Source", + group: "meta", + options: [ + { label: "Scheduled snapshot", value: "scheduled", default: true }, + { label: "AI skill", value: "ai" }, + { label: "Manual entry", value: "manual" } + ] + }), + notes: Field8.text({ + label: "Notes", + maxLength: 1e3, + group: "meta" + }), + // Fixture identity — the seed loader's `externalId`, and nothing else. + // + // `crm_forecast` is a PER-OWNER snapshot: its real identity is + // (owner_id, period, period_start), and every other column is a rendering of + // part of that. `period_label` in particular names a SET of rows once the + // `forecast_snapshot` sweep writes one row per active owner per quarter — + // they all read 'Q3 2026' — so upserting on that label lets a re-seed match, + // and overwrite, a real rep's snapshot. + // + // ⚠️ The true composite `externalId: ['owner_id', 'period', 'period_start']` + // is not available here: a seed cannot name a user (see the note in + // `objectstack.composition.ts`, "A seed can't name a user"), so `owner_id` + // is null on every seeded row, and + // the loader's `externalIdKey` returns "" as soon as any part is empty. An + // empty key never matches, so upsert degrades to insert-on-every-replay. + // Dropping `owner_id` does not rescue it: a runtime row for the current + // quarter carries exactly the same (period, period_start). + // + // ⚠️ `mode: 'insert'` does NOT mean "insert once" — the loader inserts + // unconditionally on every replay boot (framework#3434). `'ignore'` is the + // real insert-once mode, but it decides "already there?" from the same + // `externalId`, so on a broken key it would SKIP the demo row because a real + // rep's row already claimed 'Q3 2026'. Fixing the identity is a prerequisite + // either way. Hence this synthetic, seeder-only key. + // + // ⚠️ `readonly` is the load-bearing part, not decoration: seed writes run + // `{ isSystem: true }` and bypass readonly stripping, while readonly + // stripping does guard user/API writes — so a genuine forecast row can never + // acquire a `seed_key` and can never be matched by a re-seed. That is what + // makes the fix structural rather than a naming convention. `hidden` keeps a + // fixtures-only column out of forms and pickers. + seed_key: Field8.text({ + label: "Seed Key", + description: "Demo-fixture identity. Written only by the seed loader; empty on every real snapshot.", + maxLength: 64, + readonly: true, + hidden: true, + group: "meta" + }) + }, + indexes: [ + { fields: ["owner_id", "period_start", "period"] }, + { fields: ["snapshot_date"] }, + { fields: ["period_start"] } + ], + // API surface. History → Field.trackHistory (ADR-0052). + enable: { + apiEnabled: true, + apiMethods: ["get", "list", "create", "update", "delete"] + }, + // Predicates below are TOTAL: every `record.x` read is `has()`-guarded, so the + // rule returns a verdict even when the merged record has no such key. See + // AGENTS.md "Validation predicates must be TOTAL" and + // test/object-validation-predicates.test.ts, which fails the build otherwise. + validations: [ + { + name: "period_end_after_start", + type: "script", + severity: "error", + message: "Period End must be after Period Start.", + // `<=`, not `<`: the rule name says "after" and a forecast period is a + // month or a quarter, never a single instant, so `period_end == + // period_start` is a zero-length period rather than a valid one. Same + // operator and wording as the `end_after_start` twins on + // campaign/contract. + condition: P5`has(record.period_end) && record.period_end != null && has(record.period_start) && record.period_start != null && record.period_end <= record.period_start` + }, + // A hand-filled `period_start` must be the first day of the calendar period + // it labels. Maintainer ruling 2026-08-11: 「接受你的全部建议」 — refuse + // rather than accept or snap. + // + // The hook derives `period_end` as "start + one period" — a ROLLING window. + // That is calendar-true for a start on a boundary and drifts for anything + // else: `period: 'quarter'` + `period_start: 2026-08-15` derives + // `period_end: 2026-10-31` under `period_label: 'Q3 2026'`, a window + // labelled Q3 that reaches a month into Q4. The row is internally + // inconsistent in a way no consumer can detect: every "this quarter" + // equals-filter reads `period_start`, and the nightly sweep selects the + // current row by `period_start <= today <= period_end`. + // + // These rules are the ONE enforcement point — deliberately not a throw in + // `forecast.hook.ts` as well. ⚠️ A declared rule is the shape the platform + // can act on: it refuses the write with a `ValidationError` / + // `VALIDATION_FAILED` envelope (HTTP 400) on the record form, on the API and + // on a seed's system write alike, where a hook throw is a bare `Error`. The + // derivation is left alone: with the start pinned to a boundary, "start + + // one period" IS the calendar period. + // + // ⚠️ WHY A REGEX AND NOT DATE ARITHMETIC: the CEL stdlib this app compiles + // against (`CEL_STDLIB_FUNCTIONS`) has no month/day accessor — the date + // functions are `today`/`daysBetween`/`addDays`/`addMonths`/`date` — so "the + // 1st of its month" is not expressible as arithmetic. Both drivers this app + // can run on hand `period_start` back as a `YYYY-MM-DD` string, and an ISO + // *datetime* string still matches these prefix-anchored patterns. A caller + // that writes a JS `Date` object is the one shape `string()` has no overload + // for; the engine then rejects that write naming the rule rather than + // admitting it, and no writer in this app does that. + { + name: "period_start_first_of_period", + type: "script", + severity: "error", + message: "Period Start must be the first day of the period \u2014 e.g. 2026-08-01 for Aug 2026.", + condition: P5`has(record.period_start) && record.period_start != null && !matches(string(record.period_start), "^[0-9]{4}-[0-9]{2}-01")` + }, + { + name: "quarter_starts_on_quarter_boundary", + type: "script", + severity: "error", + // The month rule above already rejects any non-1st day, so this one only + // ever adds the quarter-month half: 2026-08-01 is a valid month start and + // not a valid quarter start. + message: "A quarterly forecast must start on a quarter boundary \u2014 January 1, April 1, July 1 or October 1.", + condition: P5`has(record.period) && record.period == "quarter" && has(record.period_start) && record.period_start != null && !matches(string(record.period_start), "^[0-9]{4}-(01|04|07|10)-01")` + }, + // …and the OTHER end of the same window. The two rules above pin the START; + // `period_end` stays reachable, because the hook derives it only when the + // write leaves it unset and the field sits editable on the record form. + // Without this rule, `period: 'quarter'` + `period_start: 2026-07-01` (a + // boundary the rules above admit) + a hand-typed `period_end: 2027-05-15` is + // ADMITTED under `period_label: 'Q3 2026'` — a ten-month window labelled as + // one quarter, reached through the other field. + // + // WHY A RULE AND NOT A READ-ONLY FIELD: deriving `period_end` always and + // locking the form breaks the demo seed — + // `src/sales/data/forecast.seed.ts` hand-fills it on every seeded row. + // Hand-entry stays; it is now bounded. + // + // ⚠️ WHY `type: 'script'` AND NOT A FIELD CONSTRAINT: a field bound judges + // only the value being written, so a row already stored wrong keeps + // accepting edits forever; a script validation is evaluated against the + // MERGED record on every write and is therefore a true invariant. + // `test/forecast-period-end-boundary.test.ts` pins both halves — a legacy + // row is refused on its next unrelated edit, and the repair is admitted. + // + // WHY DATE ARITHMETIC HERE WHEN THE TWO RULES ABOVE USE A REGEX: not taste. + // Those rules inspect ONE date's components ("is this the 1st of its + // month?"), and the CEL stdlib has no month/day accessor. This rule compares + // TWO dates, which `addMonths`/`addDays`/`daysBetween` express directly. + // + // The predicate says "one period long", and that is the same claim as "ends + // on the calendar boundary" ONLY because the two rules above pin the start + // to one. That coupling is deliberate: the three are one set enforcing one + // invariant (a row's window is exactly the calendar period it is labelled + // with), not three independent gates. + // + // ⚠️ `daysBetween(a, b) != 0` rather than `a == b`: both drivers this app + // runs on hand dates back as `YYYY-MM-DD` strings while `addDays` returns a + // timestamp, and a string never `==` a timestamp — the rule would be + // permanently green. `daysBetween` puts both sides through the same + // `toDate`, so the string, an ISO datetime spelling and a JS `Date` all + // compare alike. + // + // ⚠️ The `!= null` guards are load-bearing for a THIRD hazard beyond the two + // AGENTS.md names: `daysBetween(null, …)` reaches `BigInt(NaN)` and THROWS, + // which the engine reports as `predicate failed to evaluate` — a rule that + // cannot answer, i.e. a rejected ordinary save. This predicate has no + // ordering operator, so `object-validation-predicates.test.ts`'s + // unguarded-comparison sweep does not cover it; the pin lives in + // `test/forecast-period-end-boundary.test.ts` instead. + { + name: "period_end_matches_calendar_period", + type: "script", + severity: "error", + message: "Period End must be the last day of the period \u2014 e.g. 2026-09-30 for a quarter starting 2026-07-01, or 2026-08-31 for Aug 2026.", + // Spelled out per period value instead of a ternary on the month count: + // an undeclared `period` is refused BY NAME by the picklist ("Period must + // be one of: month, quarter", measured), so this rule judges only the two + // values it understands and leaves the rest to the schema. + condition: P5`has(record.period) && record.period != null && has(record.period_start) && record.period_start != null && has(record.period_end) && record.period_end != null && ((record.period == "month" && daysBetween(record.period_end, addDays(addMonths(record.period_start, 1), -1)) != 0) || (record.period == "quarter" && daysBetween(record.period_end, addDays(addMonths(record.period_start, 3), -1)) != 0))` + }, + { + name: "snapshot_amounts_non_negative", + type: "script", + severity: "error", + message: "Snapshot amounts cannot be negative.", + condition: P5`(has(record.pipeline_amount) && record.pipeline_amount != null && record.pipeline_amount < 0) || (has(record.best_case_amount) && record.best_case_amount != null && record.best_case_amount < 0) || (has(record.commit_amount) && record.commit_amount != null && record.commit_amount < 0) || (has(record.closed_amount) && record.closed_amount != null && record.closed_amount < 0)` + } + ] +}); + +// src/sales/objects/lead.object.ts +import { ObjectSchema as ObjectSchema9, Field as Field9 } from "@objectstack/spec/data"; +import { F as F6, P as P6 } from "@objectstack/spec"; +var Lead = ObjectSchema9.create({ + name: "crm_lead", + label: "Lead", + pluralLabel: "Leads", + icon: "user-plus", + description: "Potential customers not yet qualified", + // ADR-0090 D1/D7: OWD is an authored decision. Owner-worked queue. + sharingModel: "private", + fieldGroups: [ + { key: "identity", label: "Identity", icon: "user-plus" }, + { key: "company_info", label: "Company Information", icon: "building" }, + { key: "contact_info", label: "Contact Information", icon: "phone" }, + { key: "qualification", label: "Qualification", icon: "star" }, + { key: "assignment", label: "Assignment", icon: "user" }, + { key: "address", label: "Address", icon: "map-pin", collapse: "collapsed" }, + { key: "additional", label: "Additional Info", icon: "info", collapse: "collapsed" }, + { key: "preferences", label: "Communication Preferences", icon: "bell-off", collapse: "collapsed" }, + { key: "conversion", label: "Conversion", icon: "check-circle", collapse: "collapsed" }, + { key: "duplicates", label: "Duplicate Management", icon: "copy", collapse: "collapsed" } + ], + fields: { + // Platform ownership anchor — canonical note in `account.object.ts` (#548). + owner_id: Field9.lookup("sys_user", { + label: "Lead Owner", + group: "assignment", + system: true, + readonly: false, + trackHistory: true + }), + // Personal Information + salutation: Field9.select({ + label: "Salutation", + group: "identity", + // Canonical set shared with Contact (#490) — see _picklists.ts. + options: [...SALUTATION_OPTIONS] + }), + first_name: Field9.text({ + label: "First Name", + required: true, + storage: { notNull: true }, + searchable: true, + group: "identity" + }), + last_name: Field9.text({ + label: "Last Name", + required: true, + storage: { notNull: true }, + searchable: true, + group: "identity" + }), + // ⚠️ `salutation` is a picklist, so a formula sees the raw VALUE (`ms`, + // `dr`), not the label — including it renders names as "ms Emily Davis" in + // lists and details. Dropped here and from `display_title` below, matching + // Contact. + full_name: Field9.formula({ + label: "Full Name", + expression: F6`joinNonEmpty([record.first_name, record.last_name], ' ')`, + group: "identity" + }), + // ADR-0079 record title (was titleFormat '{full_name} - {company}'). + // Composed from the same source fields as `full_name` (not formula-on-formula) + // plus `company`, so the title resolves from real stored values. + display_title: Field9.formula({ + label: "Display Title", + expression: F6`joinNonEmpty([record.first_name, record.last_name], ' ') + " - " + record.company`, + group: "identity" + }), + // Company Information + company: Field9.text({ + label: "Company", + required: true, + storage: { notNull: true }, + searchable: true, + group: "company_info" + }), + /** + * Case- and whitespace-folded copy of `company` — the value lead conversion + * compares against `crm_account.name_normalized`. + * + * ### Why the LEAD needs one too + * + * ⚠️ A normalized column on `crm_account` alone fixes nothing: the + * conversion flow would then compare a raw company string against a folded + * account name, and `"ACME Corp"` still would not match `acme corp`. Both + * sides have to be canonical, and the flow can canonicalize neither — + * `service-automation`'s `resolveToken` accepts exactly one function form + * (`NOW()` / `TODAY()`), so `{LOWER(x)}`, `{TRIM(x)}` and + * `{x.toLowerCase()}` all resolve to `undefined`. See the field comment on + * `crm_account.name_normalized` for the full measurement. + * + * `company` itself is NOT folded in place: it is the display value, it is + * copied verbatim onto the account the conversion creates, and lower-casing + * it would ship `acme corp` as a customer-visible account name. That is the + * one way this differs from `email`, which has no meaningful case and so is + * canonicalized in place. + * + * Derived, never authored: `lead_duplicate_check` recomputes it on every + * write that carries `company`. Not indexed — nothing filters on it; it is + * read off the lead record the flow already fetched. + */ + company_normalized: Field9.text({ + label: "Company (Normalized)", + description: "Match key for lead conversion: Company lower-cased, trimmed, with internal whitespace collapsed. Maintained by the lead_duplicate_check hook \u2014 never edit directly.", + readonly: true, + hidden: true, + maxLength: 255, + group: "company_info" + }), + title: Field9.text({ + label: "Job Title", + group: "company_info" + }), + industry: Field9.select({ + label: "Industry", + group: "company_info", + // Canonical set shared with Account (#490): lead_conversion copies this + // value onto the created Account, so both objects MUST agree. + options: [...INDUSTRY_OPTIONS] + }), + // ⚠️ NOT `unique`. A hard uniqueness constraint on a lead's email says a + // person may enquire once, ever, and the database enforces it by REJECTING + // the second enquiry — turning an ordinary follow-up into a 500 on the + // public form. Real funnels re-capture the same address routinely. + // Duplicates are a fact to be RECORDED, not an error: `lead_duplicate_check` + // in lead.hook.ts links the new lead to the record it repeats (see the + // `duplicates` field group below). The plain index below is what keeps the + // column indexed in the constraint's absence — the intake dedupe lookup, the + // `crm_lead_import` upsert key and the conversion flow all read leads by + // email on every write. + email: Field9.email({ + label: "Email", + required: true, + storage: { notNull: true }, + group: "contact_info" + }), + phone: Field9.text({ + label: "Phone", + format: "phone", + group: "contact_info" + }), + mobile: Field9.text({ + label: "Mobile", + format: "phone", + group: "contact_info" + }), + website: Field9.url({ + label: "Website", + group: "contact_info" + }), + // Lead Qualification + status: Field9.select({ + label: "Lead Status", + required: true, + storage: { notNull: true }, + group: "qualification", + trackHistory: true, + // Field-level default: option-level `default: true` only preselects in + // UI forms after first paint; the quick-create dialog and API inserts + // need a real defaultValue (see approval_status for the same lesson). + defaultValue: "new", + options: [ + { label: "New", value: "new", color: "#808080", default: true }, + { label: "Contacted", value: "contacted", color: "#FFA500" }, + { label: "Qualified", value: "qualified", color: "#4169E1" }, + { label: "Unqualified", value: "unqualified", color: "#FF0000" }, + { label: "Converted", value: "converted", color: "#00AA00" } + ] + }), + rating: Field9.rating(5, { + label: "Lead Score", + description: "Lead quality score (1-5 stars)", + group: "qualification" + }), + lead_source: Field9.select({ + label: "Lead Source", + group: "qualification", + // Canonical set shared with Contact + Opportunity (#490): lead_conversion + // copies this value onto the created Opportunity, so all three MUST agree. + options: [...LEAD_SOURCE_OPTIONS] + }), + // ── Demand: what this prospect wants, and what it is worth ───────── + // + // REQ-0005 steps 6-7. Both fields are in `qualification` because they ARE + // qualification data — what the buyer is asking for and how big it is are + // the two facts a rep weighs before working a lead — and neither is + // required: a lead captured off the public form has neither, and saves + // exactly as it did before. + need_type: Field9.select({ + label: "Need Type", + group: "qualification", + description: "What this prospect is asking for. Routing, prioritisation and demand reporting read this.", + // Generic starter vocabulary, declared once in `_picklists.ts` — see the + // note there for why it is NOT shared with `crm_opportunity.type`. + options: [...LEAD_NEED_TYPE_OPTIONS] + }), + // ⛔ NEVER conflated with `annual_revenue`, which sits two groups below in + // `additional` and answers a different question: that is the prospect + // COMPANY's own turnover, a size signal, and it is the value + // `lead_conversion` copies onto the account it creates. This is the value + // of the DEMAND — the number that becomes `crm_opportunity.amount` when the + // lead converts, and the only figure the pipeline has before then. + // + // ⛔ Nor is it a second copy of `crm_opportunity.amount`. The opportunity's + // amount is a committed deal figure a rep defends in a forecast; this is an + // estimate taken before qualification, and the conversion screen is where a + // human turns one into the other (it PREFILLS from here — see the + // `opportunityAmount` screen field in `lead-conversion.flow.ts` — rather + // than copying silently, so the rep confirms the number that enters the + // forecast). + estimated_amount: Field9.currency({ + label: "Estimated Amount", + group: "qualification", + description: "Estimated value of this demand, before qualification. Prefills the deal amount at conversion." + }), + // ── The conversion approval gate (REQ-0005 step 7) ───────────────── + // + // ⚠️ `defaultValue: 'not_required'` IS THE GATE'S OFF SWITCH, and it is the + // one line an install changes to arm it. REQ-0005: "The gate must be + // configurable — off by default. A single-seller install must not be forced + // through an approval to convert a lead." + // + // OFF (shipped) every lead is born `not_required`; nothing ever writes + // `pending`, so `lead_conversion_approval` never enters, + // the Convert button never hides and the write-path gate in + // `lead.hook.ts` never fires. Conversion behaves EXACTLY as + // it did before this field existed. + // ON change this one value to `'pending'`. Every lead is then + // born pending, `lead_conversion_approval` opens its + // request, and conversion is refused until an approver + // decides. + // + // Leads that predate the switch keep whatever they were born with, which is + // the point: arming the gate does not invalidate or re-open a single + // existing record (REQ-0005 acceptance 4). This is a TRANSITION GATE, not an + // invariant (AGENTS.md metadata semantics rule 7) — what is refused is the + // ACT of converting, evaluated against `previous` in `lead.hook.ts`, never + // the state of a record that is already converted. + // + // Shape copied from `crm_opportunity.approval_status`: `readonly: true` + // plus a REAL field-level `defaultValue`, ⛔ not only an option-level + // `default: true` — the same lesson `status` above records, and the reason + // that field's own comment gives: an option default only preselects in UI + // forms after first paint, so a quick-create dialog or an API insert would + // land a null and a null matches no flow entry condition. + // + // ⛔ Do NOT add an "approved" value to `status` instead. That select is the + // qualification lifecycle; a sixth value there would break the + // `convert_lead` predicate, the `lead_status_progression` transitions and + // the seeded rows, and would conflate "this lead is worth working" with + // "someone signed off on converting it". + conversion_approval_status: Field9.select({ + label: "Conversion Approval", + group: "qualification", + readonly: true, + trackHistory: true, + description: "Whether this lead has been signed off for conversion. Not Required means no approval is asked for \u2014 the shipped default.", + defaultValue: "not_required", + options: [ + { label: "Not Required", value: "not_required", default: true }, + { label: "Pending", value: "pending", color: "#FFA500" }, + { label: "Approved", value: "approved", color: "#00AA00" }, + { label: "Rejected", value: "rejected", color: "#FF0000" } + ] + }), + // Assignment + // Conversion tracking. + // ⛔ NOT `readonly`: the `lead_conversion` flow's `mark_converted` node + // UPDATEs this column and the four `converted_*` ones below, and that flow + // declares no `runAs` — so it runs at the engine default `'user'`, which is + // also where house rule 9 keeps a screen flow. `stripReadonlyFields` runs + // under `if (!opCtx.context?.isSystem)` and deletes every readonly key the + // CALLER supplied, so `readonly` here would silently un-convert every + // conversion. + // ⚠️ The other writer is unaffected, and is not the reason: the + // guest-submission sanitiser in `lead.hook.ts` ASSIGNS these on + // `beforeInsert`, and hook-written keys are not caller-supplied — nor does + // the strip run on INSERT at all. Measured in + // `test/readonly-write-semantics.test.ts`. + // ⇒ Declaring these `readonly` would need the flow's write ELEVATED, which + // is a privilege decision on the maintainer's floor, not this file's (#1435). + // Edit-protection is the `beforeUpdate` guard in `lead.hook.ts`, which + // rejects any USER edit to a converted lead outside a small allow-list — + // and it is the ONLY guard, deliberately: a script validation beside it + // never fires, because the hook's throw always wins the race. + is_converted: Field9.boolean({ + label: "Converted", + defaultValue: false, + group: "conversion", + trackHistory: true + }), + converted_account: Field9.lookup("crm_account", { + label: "Converted Account", + group: "conversion" + }), + converted_contact: Field9.lookup("crm_contact", { + label: "Converted Contact", + group: "conversion" + }), + converted_opportunity: Field9.lookup("crm_opportunity", { + label: "Converted Opportunity", + group: "conversion" + }), + converted_date: Field9.datetime({ + label: "Converted Date", + group: "conversion" + }), + // Address (using new address field type) + address: Field9.address({ + label: "Address", + group: "address" + }), + // Additional Info + annual_revenue: Field9.currency({ + label: "Annual Revenue", + group: "additional" + }), + number_of_employees: Field9.number({ + label: "Number of Employees", + group: "additional" + }), + description: Field9.markdown({ + label: "Description", + group: "additional" + }), + // Custom notes with rich text formatting + notes: Field9.richtext({ + label: "Notes", + description: "Working notes on this lead \u2014 supports formatting.", + group: "additional" + }), + // Flags + do_not_call: Field9.boolean({ + label: "Do Not Call", + defaultValue: false, + group: "preferences" + }), + email_opt_out: Field9.boolean({ + label: "Email Opt Out", + defaultValue: false, + group: "preferences" + }), + // Follow-up & disqualification tracking + next_followup_date: Field9.date({ + label: "Next Follow-up Date", + group: "qualification" + }), + // NOT `readonly` (#592) — see the long note on + // `crm_account.last_activity_date`. The activity bubble writes this from + // another object's hook, and a readonly field is stripped from any + // non-system write whose caller supplied the key (#2948), so every bubble + // into this column was silently discarded. + last_contacted_date: Field9.datetime({ + label: "Last Contacted", + group: "qualification" + }), + disqualification_reason: Field9.select({ + label: "Disqualification Reason", + group: "qualification", + description: "Required when status is Unqualified", + options: [ + { label: "Not a Fit", value: "not_a_fit" }, + { label: "No Budget", value: "no_budget" }, + { label: "Wrong Persona", value: "wrong_persona" }, + { label: "Unreachable", value: "unreachable" }, + { label: "Duplicate", value: "duplicate" }, + { label: "Competitor", value: "competitor" }, + { label: "Other", value: "other" } + ] + }), + // ── Duplicate management ─────────────────────────────────────────── + // + // `disqualification_reason: 'duplicate'` is only meaningful if the record + // says WHAT it duplicates — otherwise the "duplicate" bar on the + // disqualification breakdown points at nothing you can open. + // + // ⚠️ The surviving record can live on either object — a still-open lead, or + // a contact the prospect already became — and `Field.lookup` takes exactly + // one target (`Field.lookup(['crm_lead','crm_contact'])` is rejected at + // schema parse: "reference: expected string, received array"). So the link + // is the same TYPE-DISCRIMINATOR shape `crm_task.related_to_*` already uses: + // one select naming the object, one lookup per object, and the pairing + // enforced declaratively. + // + // The vocabulary is TWO sets, declared and split in `_picklists.ts`: the two + // object names an author may pick, plus `erased` — a tombstone the form does + // not offer and only `lead_duplicate_check` ever writes. + // + // The tombstone is what lets an erasure COMPLETE against a lead a human + // confirmed as a duplicate, without relaxing one rule, so read it as a + // constraint rather than as a spare value: `requiredWhen` below pairs only + // `crm_lead` / `crm_contact`, so a tombstoned type never fires either + // pairing and never demands a pointer to a record that is gone; and + // `duplicate_disqualification_requires_survivor` asks for a NON-BLANK type + // plus `duplicate_status == "confirmed"`, both of which a tombstoned lead + // still satisfies — so the verdict a reviewer recorded survives the erasure + // instead of being deleted as a side effect of someone else's GDPR request. + duplicate_of_type: Field9.select({ + label: "Duplicate Of", + group: "duplicates", + description: "Which object holds the surviving record this lead repeats.", + options: [...DUPLICATE_OF_TYPE_OPTIONS] + }), + // ⚠️ The type↔lookup pairing is `requiredWhen`, not a script validation: + // "the lookup named by the type must be populated" is exactly a conditional + // write contract, the engine evaluates it on insert and update, and it + // reports against the FIELD, so the form marks the empty lookup instead of + // showing a record-level error. (`crm_task` states the same intent as a + // warning-severity script rule because it predates `requiredWhen`, + // ADR-0113.) + // + // ⚠️ `has(...)` is load-bearing, not decoration. A bare + // `record.duplicate_of_type == "crm_lead"` aborts with `No such key` on any + // record whose merged shape omits the column, and the engine's response to a + // predicate that fails to evaluate is to SKIP it ("requiredWhen for + // 'duplicate_of_lead' failed to evaluate — skipped"). The rule would then + // read as enforced and require nothing at all. + // + // ⚠️ Both lookups take the spec default `deleteBehavior: 'set_null'`, and + // that is deliberate: a lead is a first-class record that happens to carry a + // flag, so `cascade` would destroy the lead because the record it was + // compared against was deleted. What keeps the pairing honest under a + // `set_null` clear is the retirement block in `lead_duplicate_check` + // (`lead.hook.ts`, job 1c): when a write leaves the named lookup blank it + // drops `duplicate_of_type` and `duplicate_status` in the same write, so the + // pair is never left half-stated and this rule never has to be loosened to + // tolerate one. Read that note before changing either predicate. + duplicate_of_lead: Field9.lookup("crm_lead", { + label: "Duplicate Of Lead", + group: "duplicates", + requiredWhen: P6`has(record.duplicate_of_type) && record.duplicate_of_type == "crm_lead"` + }), + duplicate_of_contact: Field9.lookup("crm_contact", { + label: "Duplicate Of Contact", + group: "duplicates", + requiredWhen: P6`has(record.duplicate_of_type) && record.duplicate_of_type == "crm_contact"` + }), + // Machine suspicion and human verdict are ONE field with two values, not two + // parallel sets of link fields: the intake hook writes `suspected` and only + // ever when this is blank (lead.hook.ts), so a human's `confirmed` survives + // every later write, and both states stay queryable off one column. + duplicate_status: Field9.select({ + label: "Duplicate Status", + group: "duplicates", + trackHistory: true, + description: "Suspected = flagged automatically at intake. Confirmed = a human verified the match.", + options: [ + { label: "Suspected", value: "suspected", color: "#FFA500" }, + { label: "Confirmed", value: "confirmed", color: "#FF0000" } + ] + }) + }, + // Lifecycle transitions are enforced via a `state_machine` validation rule + // (see validations[] below). ⚠️ There is no top-level `stateMachines` key on + // the platform — status state machines are expressed in the validation union. + // Database indexes for performance + // + // ⚠️ `email` is indexed but NOT unique, and the index must stay explicit: it + // used to exist only as a side effect of a field-level `unique: true`, so + // dropping that constraint would otherwise have dropped the index with it and + // left three read paths — the `lead_duplicate_check` intake lookup, the + // `crm_lead_import` upsert key and the conversion flow — scanning the table + // on every write. + // + // ⛔ Do NOT add `unique: true` back here: a single-column unique index makes + // the platform-wide constraint win over the per-tenant composite + // (framework#3991), so two organizations could not work the same address + // independently. Uniqueness is not the rule this object wants at all. + indexes: [ + { fields: ["owner_id"] }, + { fields: ["status"] }, + { fields: ["company"] }, + { fields: ["email"] } + ], + // API surface. History → Field.trackHistory (ADR-0052). + enable: { + apiEnabled: true + }, + // ADR-0079 record title — the `display_title` formula field defined above. + nameField: "display_title", + // Explicit search targets (ADR-0061). REQUIRED because nameField is a + // FORMULA (display_title/full_name): without this, $search auto-defaults to + // the formula field, which isn't a real column, so the lookup picker + global + // search silently return zero. These are real, indexed columns. + searchableFields: ["first_name", "last_name", "company", "email"], + highlightFields: ["full_name", "company", "email", "status", "owner_id"], + // Removed: list_views and form_views belong in UI configuration, not object definition + // Predicates below are TOTAL: every `record.x` read is `has()`-guarded, so the + // rule returns a verdict even when the merged record has no such key. See + // AGENTS.md "Validation predicates must be TOTAL" and + // test/object-validation-predicates.test.ts, which fails the build otherwise. + validations: [ + { + name: "email_required", + type: "script", + severity: "error", + message: "Email is required", + condition: P6`!has(record.email) || isBlank(record.email)` + }, + { + // The field description promises "Required when status is Unqualified"; + // this is what enforces it. A lead in `unqualified` with no recorded + // reason loses the one datum a disqualification review needs. Same shape + // as `crm_case.escalation_reason_required`. + name: "disqualification_reason_required", + type: "script", + severity: "error", + message: "Disqualification reason is required when a lead is Unqualified", + condition: P6`has(record.status) && record.status == "unqualified" && (!has(record.disqualification_reason) || isBlank(record.disqualification_reason))` + }, + { + // "Disqualified as a duplicate" has to name the survivor. + // + // Same shape as `disqualification_reason_required` directly above — a + // declarative condition evaluated by the engine on insert and update, with + // no hook involved. The two clauses are the two things the field-level + // `requiredWhen` on the lookups cannot say: + // + // 1. `duplicate_of_type` must be chosen, which is what makes exactly one + // of the two `requiredWhen` predicates fire and demand its lookup. + // 2. `duplicate_status` must be `confirmed` SPECIFICALLY. `requiredWhen` + // asks whether a field is populated, not what it holds — and a lead + // closed on the machine's `suspected` guess is precisely the outcome + // this rule exists to prevent. A human has to look and agree. + // + // ⚠️ Every field reference is wrapped in `has(...)`, and that is what makes + // this an enforced rule rather than a decorative one. The engine evaluates + // a validation against `{...previous, ...data}` and fills absent fields + // with null on INSERT — but not on UPDATE, where `previous` is whatever + // the driver returned, and a driver that stores only the columns a row was + // written with hands back a record with no `duplicate_status` key at all. + // Strict CEL then aborts the whole predicate with `No such key`, and a + // predicate that fails to evaluate is SKIPPED, not failed: + // + // WARN Validation rule '…' predicate failed to evaluate (…) — skipped + // + // The unguarded first draft of this rule let a lead be closed as a + // duplicate with no survivor named, silently, on the in-memory driver — + // the driver the whole test suite runs on. + name: "duplicate_disqualification_requires_survivor", + type: "script", + severity: "error", + message: "Disqualifying a lead as Duplicate requires naming the surviving record and setting Duplicate Status to Confirmed", + condition: P6`has(record.disqualification_reason) && record.disqualification_reason == "duplicate" && !(has(record.duplicate_of_type) && !isBlank(record.duplicate_of_type) && has(record.duplicate_status) && record.duplicate_status == "confirmed")` + }, + { + name: "lead_status_progression", + type: "state_machine", + severity: "warning", + message: "Invalid lead status transition", + field: "status", + // Conversion (→ converted) is allowed from any worked-open status so the + // Convert action's widened visibility (new/contacted/qualified) never trips + // a spurious "invalid transition" warning when the flow stamps + // status:'converted'. + transitions: { + new: ["contacted", "qualified", "unqualified", "converted"], + contacted: ["qualified", "unqualified", "converted"], + qualified: ["converted", "unqualified"], + unqualified: ["new"], + converted: [] + } + } + ] + // ⚠️ No `workflows[]` here, and none is possible: object `workflows[]` were + // removed from the platform. Field updates live in this object's `*.hook.ts`; + // scheduled status flips and notifications live in `src/*/flows/*.flow.ts`. +}); + +// src/sales/objects/opportunity.object.ts +import { ObjectSchema as ObjectSchema10, Field as Field10 } from "@objectstack/spec/data"; +import { F as F7, P as P7 } from "@objectstack/spec"; +var Opportunity = ObjectSchema10.create({ + name: "crm_opportunity", + label: "Opportunity", + pluralLabel: "Opportunities", + icon: "dollar-sign", + description: "Sales opportunities and deals in the pipeline", + // ADR-0090 D1/D7: OWD is an authored decision. Owner + high-value management sharing rule. + sharingModel: "private", + // ⚠️ ADR-0079 `nameField` is a FIELD, not a render template, and a FORMULA + // sees the stored select VALUE rather than its translated label — so a + // `'{name} - {stage}'` title renders every deal "Enterprise Deal - + // closed_won" in lookups, related lists and search, in every locale. The + // formula language has no option-label lookup, so the title is the plain + // `name` column; `stage` still leads the highlight strip below, translated. + nameField: "name", + // Explicit search targets (ADR-0061). `name` is a real indexed column, so + // $search resolves on its own here; the list is kept explicit to pin the + // intent (other objects whose nameField IS a formula rely on it). + searchableFields: ["name"], + highlightFields: ["name", "crm_account", "amount", "stage", "owner_id"], + fieldGroups: [ + { key: "basic", label: "Basic Information", icon: "dollar-sign" }, + { key: "financials", label: "Financials", icon: "trending-up" }, + { key: "sales_process", label: "Sales Process", icon: "target" }, + { key: "qualification", label: "Qualification", icon: "filter" }, + { key: "narrative", label: "Deal Narrative", icon: "book-open" }, + { key: "classification", label: "Classification", icon: "tag" }, + { key: "campaign", label: "Campaigns", icon: "flag", collapse: "collapsed" }, + { key: "notes", label: "Notes & Next Steps", icon: "file-text" }, + { key: "crm_forecast", label: "Forecast & Metrics", icon: "bar-chart", collapse: "collapsed" } + ], + fields: { + // Platform ownership anchor — canonical note in `account.object.ts` (#548). + owner_id: Field10.lookup("sys_user", { + label: "Opportunity Owner", + group: "basic", + system: true, + readonly: false, + trackHistory: true + }), + // Basic Information + name: Field10.text({ + label: "Opportunity Name", + required: true, + storage: { notNull: true }, + searchable: true, + group: "basic" + }), + // (No `display_title` formula — see `nameField` above: composing the title + // from `stage` leaked the raw select value into every rendered title.) + // Relationships + crm_account: Field10.lookup("crm_account", { + label: "Account", + required: true, + storage: { notNull: true }, + group: "basic" + }), + primary_contact: Field10.lookup("crm_contact", { + label: "Primary Contact", + // @objectstack 12: string[] `referenceFilters` is dead (not read by the + // picker); `dependsOn` is the live cascading form — scopes contacts to the + // opportunity's `crm_account` (ADR-0049). + dependsOn: ["crm_account"], + group: "basic" + }), + // Financial Information + amount: Field10.currency({ + label: "Amount", + required: true, + storage: { notNull: true }, + min: 0, + group: "financials", + trackHistory: true + }), + expected_revenue: Field10.currency({ + label: "Expected Revenue", + readonly: true, + // Calculated field + group: "financials" + }), + // ─── Qualification (REQ-0006 step 8) ─────────────────────────────── + // + // The standard triage vocabulary of a seller that cannot pursue every + // deal. `forecast_category` answers a different question — it is the + // forecast roll-up bucket, derived from `stage` — so none of this is + // folded into it. GENERIC values only: a customer's own grading scale is + // overlay configuration (REQ-0006 acceptance 5). + // + // ⚠️ `pnpm validate` reports the fields in this block, in the narrative + // block below, and the customer-side dates as "carrier-only — declared + // but nothing in this stack reads or displays it", and that reading is + // EXPECTED here rather than a defect to tidy away. The liveness + // diagnostic counts view columns, form sections, page bindings, flow + // nodes, formulas, hooks and actions as sites; it does NOT count + // `fieldGroups` membership, which is precisely the DERIVED layout + // REQ-0006 acceptance 1 asks for. ⛔ Do NOT answer the warning by + // authoring a `record:details` section — that is the escape hatch + // AGENTS.md reserves for a named customer demand, and it would trade + // acceptance 1 for a quieter log. `crm_account`'s business-profile block + // carries the same verdict on `main` for the same reason (#1948). + will_bid: Field10.boolean({ + label: "Will Bid", + description: "Whether we intend to bid. Unset means the decision is open.", + group: "qualification" + }), + controllability: Field10.select({ + label: "Controllability", + group: "qualification", + options: [ + { label: "High", value: "high" }, + { label: "Medium", value: "medium" }, + { label: "Low", value: "low" } + ] + }), + priority: Field10.select({ + label: "Priority", + group: "qualification", + options: [ + { label: "High", value: "high" }, + { label: "Medium", value: "medium" }, + { label: "Low", value: "low" } + ] + }), + deal_level: Field10.select({ + label: "Deal Level", + group: "qualification", + options: [ + { label: "Strategic", value: "strategic" }, + { label: "Key", value: "key" }, + { label: "Standard", value: "standard" } + ] + }), + // The FACT of subcontracting is generic and belongs in core; the + // customer's supplier list is not and is not proposed here. + is_subcontracted: Field10.boolean({ + label: "Involves Subcontracting", + defaultValue: false, + group: "qualification" + }), + subcontracting_note: Field10.textarea({ + label: "Subcontracting Note", + group: "qualification" + }), + // ─── The 立项 (qualification) gate: the rep's request ───────────── + // + // REQ-0006 step 11: 「销售立项需走审批流程；新增商机可跟进，立项通过后方可更新阶段、 + // 投标、赢丢单操作。」 The rep ASKS for 立项 by ticking this box, and + // `opportunity_qualification_approval` opens one approval when it turns on + // (the TRANSITION, not the current value). A rejection clears it, so + // ticking it again is a fresh request — the role `requested_status` plays + // for the status-change gate, as a boolean because 立项 asks for one thing. + // + // `defaultValue: false` is load-bearing for the start condition: every deal + // born after this column then STORES the key, so `has(previous.…)` holds + // on every driver and the off→on transition is visible. Not readonly: this + // is the one half of the gate a person writes. Inert while the gate is + // off — nothing reads it unless an install arms the verdict below. + qualification_requested: Field10.boolean({ + label: "Request Qualification Approval", + description: "Tick to send this deal for qualification approval. A rejection clears it; tick it again to ask again.", + defaultValue: false, + group: "qualification" + }), + // ─── The 立项 gate's switch AND its verdict column ───────────────── + // + // ⚠️ This `defaultValue` IS the switch, exactly as on + // `status_change_approval_status` below, and shipped it is `not_required`: + // the gate is OFF by default (REQ-0006 *Disposition*: "Both gates must be + // configurable — off by default"). No deal is born `pending`, the flow's + // start condition and the `opportunity_lifecycle` refusal are false for + // every record that has ever existed, and a stage move, Will Bid and a + // direct close work exactly as they do without it. An install ARMS the gate + // by changing this one value to `'pending'`; deals that already exist keep + // `not_required`, so arming it invalidates no record. ⛔ Not the flow's + // `status` — `lead-conversion-approval.flow.ts` records why. + // + // ⚠️ Its OWN column — ⛔ never `approval_status` (the amount-tiered + // flow's; its entry keys on `not_required`, so sharing would re-arm it) and + // ⛔ never `status_change_approval_status` (one gate's verdict would erase + // the other's, and the step-14 hook reads that column input-first). + // + // `readonly: true` on the #1666 grounds: the only writers are the gate's + // own `runAs: 'system'` flow and the insert default, and both survive the + // readonly strip. A user-supplied verdict is stripped BEFORE the + // `beforeUpdate` hooks run — measured on 17.6.0 with a real ObjectQL: a + // user update of `{ stage, qualification_approval_status: 'approved' }` + // reached the hooks as `{ id, stage }` and was refused 409 — so the + // input-first read in `opportunity_lifecycle` cannot be fed an `approved` + // by hand. + qualification_approval_status: Field10.select({ + label: "Qualification Approval", + group: "qualification", + readonly: true, + defaultValue: "not_required", + options: [ + { label: "Not Required", value: "not_required", default: true }, + { label: "Pending", value: "pending", color: "#FFA500" }, + { label: "Approved", value: "approved", color: "#00AA00" }, + { label: "Rejected", value: "rejected", color: "#FF0000" } + ] + }), + // Sales Process + stage: Field10.select({ + label: "Stage", + required: true, + storage: { notNull: true }, + group: "sales_process", + // ADR-0052 §5b.1 — the platform auto-renders each stage change on the + // activity timeline as "Stage: Proposal → Negotiation" (no hook code). + trackHistory: true, + // Canonical set (#490) — the mass_update_stage action renders the same + // list; see _picklists.ts. + options: [...OPPORTUNITY_STAGE_OPTIONS] + }), + probability: Field10.percent({ + label: "Probability (%)", + min: 0, + max: 100, + defaultValue: 10, + group: "sales_process" + }), + // Important Dates + close_date: Field10.date({ + label: "Close Date", + required: true, + storage: { notNull: true }, + group: "sales_process", + trackHistory: true + }), + // NO `created_date` here: the platform already injects `created_at` on + // every object, and this duplicate had no writer at all — not the seed + // data, not a hook, not a flow — so it was permanently null while + // `created_at` carried the real value (#575 B2). Surfaces that need the + // creation instant read `created_at` (see the deal_timeline view). + // + // Stage-age clock (#489). This is the STORED half of the pair: a real, + // indexed date column, so it is what automation and views may filter and + // sort on. `days_in_stage` below is a formula derived from it. + // `opportunity_lifecycle` stamps it on insert and re-stamps it on every + // stage change; readonly because nothing but that hook should move it + // (before-hook writes survive readonly stripping — only caller-supplied + // keys are dropped). + stage_entry_date: Field10.date({ + label: "Stage Entry Date", + description: "Date this opportunity entered its current stage.", + readonly: true, + group: "sales_process" + }), + // ─── The customer's own procurement calendar (REQ-0006 step 8) ───── + // + // ⛔ Never folded into `close_date`: that is a single date and it is OUR + // expected close. These are three distinct BUYER-side events, and + // REQ-0006 acceptance 2 requires them to be reportable independently of + // the forecast close date — see the `tender_this_quarter` list view, + // which predicates on `expected_tender_date` alone. + customer_initiation_date: Field10.date({ + label: "Customer Initiation Date", + group: "sales_process" + }), + expected_tender_date: Field10.date({ + label: "Expected Tender Date", + group: "sales_process" + }), + expected_signing_date: Field10.date({ + label: "Expected Signing Date", + group: "sales_process" + }), + expected_tender_amount: Field10.currency({ + label: "Expected Tender Amount", + min: 0, + group: "sales_process" + }), + expected_signing_amount: Field10.currency({ + label: "Expected Signing Amount", + min: 0, + group: "sales_process" + }), + // Additional Classification + type: Field10.select({ + label: "Opportunity Type", + group: "classification", + options: [ + { label: "New Business", value: "new_business" }, + { label: "Existing Customer - Upgrade", value: "existing_upgrade" }, + { label: "Existing Customer - Renewal", value: "existing_renewal" }, + { label: "Existing Customer - Expansion", value: "existing_expansion" } + ] + }), + // ⛔ BESIDE `type`, never replacing or overloading it: `type`'s four + // values are a RELATIONSHIP taxonomy that `opportunity.hook.ts` and + // reporting read. Generic delivery-model values only — the customer's own + // line-of-business list is overlay (REQ-0006 acceptance 5). + business_line: Field10.select({ + label: "Business Line", + group: "classification", + options: [ + { label: "Product", value: "product" }, + { label: "Professional Services", value: "services" }, + { label: "Consulting", value: "consulting" }, + { label: "Support & Maintenance", value: "support" }, + { label: "Other", value: "other" } + ] + }), + lead_source: Field10.select({ + label: "Lead Source", + group: "classification", + // Canonical set shared with Lead + Contact (#490): lead_conversion + // copies `leadRecord.lead_source` onto the opportunity it creates, so + // this must accept every Lead value. + options: [...LEAD_SOURCE_OPTIONS] + }), + // Campaign tracking + crm_campaign: Field10.lookup("crm_campaign", { + label: "Campaign", + description: "Marketing campaign that generated this opportunity", + group: "campaign" + }), + // Sales cycle metrics + // + // ⚠️ FORMULA, not a stored counter. As a plain number column nothing ever + // raises it: the hook resets it to 0 on a stage change and no sweep + // increments it, so `days_in_stage > 14` matches only rows a seed hardcoded + // and the `opportunity_stagnation` flow never fires on real data. Deriving + // it from `stage_entry_date` is correct on every read and costs no nightly + // full-table pass. + // + // ⚠️ The trade-off: formulas are evaluated AFTER the query (the engine's + // `applyFormulaPlan` walks the returned rows), so this is not a real column + // and CANNOT appear in a filter or a sort. Anything that needs to *select* + // stalled deals predicates on `stage_entry_date` instead — see + // `opportunity-stagnation.flow.ts` and the `stale_opportunities` view. + // + // ⚠️ `has()` + null guard: `daysBetween(null, …)` faults and the whole field + // silently evaluates to null, so an unstamped row is spelled out as null + // rather than arriving there by accident. + days_in_stage: Field10.formula({ + label: "Days in Current Stage", + expression: F7`has(record.stage_entry_date) && record.stage_entry_date != null ? daysBetween(record.stage_entry_date, today()) : null`, + returnType: "number", + group: "crm_forecast" + }), + // Additional information + description: Field10.markdown({ + label: "Description", + group: "notes" + }), + next_step: Field10.textarea({ + label: "Next Steps", + group: "notes" + }), + // ─── Deal narrative (REQ-0006 step 10) ───────────────────────────── + // + // The standard deal-review narrative, split out of `description` so each + // part is reviewable, templatable and (later) reportable on its own — + // ⛔ not more prose crammed into one markdown field. + // + // ⚠️ `payment_terms` is PROSE here and a select on `crm_quote` / + // `crm_contract`: what a rep records mid-pursuit is the shape of a term + // still being negotiated, not the net-terms ladder a signed document + // carries. ⛔ Do not "unify" it onto PAYMENT_TERMS_OPTIONS — that would + // force a half-agreed term into a closed vocabulary. + // + // All four are `Field.textarea` (REQ-0006 names markdown OR textarea per + // field). Measured on the 17.6.0 console, the Details tab's edit mode — + // the surface these fields render on — has no markdown editor, so a + // markdown field here could be read but never written. The maintainer + // ruled textarea for the three that were markdown (2026-10-03, on #1950: + // 「改成 textarea(推荐)」). + customer_background: Field10.textarea({ + label: "Customer Background", + group: "narrative" + }), + project_background: Field10.textarea({ + label: "Project Background", + group: "narrative" + }), + risk_analysis: Field10.textarea({ + label: "Risk Analysis", + group: "narrative" + }), + payment_terms: Field10.textarea({ + label: "Payment Terms", + group: "narrative" + }), + // Flags + is_private: Field10.boolean({ + label: "Private", + defaultValue: false, + group: "crm_forecast" + }), + forecast_category: Field10.select({ + label: "Forecast Category", + group: "crm_forecast", + options: [ + { label: "Pipeline", value: "pipeline" }, + { label: "Best Case", value: "best_case" }, + { label: "Commit", value: "commit" }, + { label: "Omitted", value: "omitted" }, + { label: "Closed", value: "closed" } + ] + }), + // Approval workflow tracking. + // ⭐ `readonly: true` — DECLARED, and the declaration is the honest one + // rather than a hopeful one. Audited per writer (#1666): every writer of + // this column and of `approved_date` is elevated or an insert. + // `opportunity_approval` declares `runAs: 'system'`, and + // `opportunity_approval_on_create` inherits it by spreading that flow, so + // `resolveRunDataContext` hands the engine `isSystem: true` and the + // `if (!opCtx.context?.isSystem)` strip branch is skipped outright; the + // `approval` node's own `approvalStatusField` write runs inside those same + // system runs; seeds write on INSERT, which the strip never touches. No + // view, page or action writes either column. ⇒ No writer loses its write. + // Ruled #1666 (director seat, decision batch #74, 2026-09-07): "Declared = + // enforced" applies to the audit surface too. ⛔ The hand-edit escape hatch + // — an admin clearing a stuck approval by typing over the stamp — is given + // up ON PURPOSE: a stuck approval is a platform or flow defect to be fixed + // as one, not a reason to keep an audit stamp hand-editable. ⛔ Do not + // reintroduce a bypass, and do not soften either column back to editable + // without a new ruling. Both halves are pinned in + // `test/audit-stamp-readonly.test.ts`: the system path still lands both + // stamps, and a plain user-context UPDATE of either is stripped. + // ⚠️ `defaultValue` at FIELD level: option-level `default: true` + // only preselects in UI forms — API and flow inserts land null without it, + // and a null `approval_status` never matches the flow's entry condition. + approval_status: Field10.select({ + label: "Approval Status", + group: "sales_process", + readonly: true, + defaultValue: "not_required", + options: [ + { label: "Not Required", value: "not_required", default: true }, + { label: "Pending", value: "pending", color: "#FFA500" }, + { label: "Approved", value: "approved", color: "#00AA00" }, + { label: "Rejected", value: "rejected", color: "#FF0000" } + ] + }), + approved_date: Field10.datetime({ + label: "Approved Date", + group: "sales_process", + readonly: true + }), + // ─── The status-change gate's switch AND its verdict column ──────── + // + // ⚠️ This `defaultValue` IS the switch, and shipped it is `not_required`, + // so the gate is OFF by default — REQ-0006 acceptance 3: "with it off + // (the default), the existing amount-tiered behaviour of + // `opportunity-approval.flow.ts` is bit-for-bit what it is today". No + // record is ever born `pending`, `opportunity_status_change_approval`'s + // start condition is false for every row that has ever existed, and + // nothing about the amount-tiered flow changes. An install ARMS the gate + // by changing this one value to `'pending'`. + // + // ⛔ Not the flow's `status`, for the reason + // `lead-conversion-approval.flow.ts` records and measured: `draft` still + // fires its triggers, and `obsolete` composes with the installation's + // activation ledger into a gate no install can ever turn ON. + // + // ⚠️ Deliberately NOT `approval_status`. That column is the amount-tiered + // flow's, and sharing it would make either gate's verdict erase the + // other's — and re-trigger the amount flow, whose entry condition keys on + // `approval_status == "not_required"`. + // + // `readonly: true` on the same audited grounds as `approval_status` + // (#1666): the only writers are the gate's own `runAs: 'system'` flow and + // the insert default, and both survive the readonly strip. + // What the rep is ASKING for, ⛔ never the stage itself: REQ-0006 + // acceptance 3 requires the stage not to move until the request is + // decided, and a `record_change` flow binds an AFTER hook — by the time it + // runs, a stage the rep wrote has already moved. So the rep writes the + // request here (with the win/loss reason), and the approved decision + // writes `stage` — the customer's own step 14, 「通过后商机状态正式生效」. + // + // Values ARE the two stage values, so the flow's approve branch can apply + // it with `stage: '{oppRecord.requested_status}'` and no mapping table can + // drift. Not readonly: this is the one half of the gate a person writes. + // Inert while the gate is off — nothing reads it unless the install arms + // `status_change_approval_status`. + requested_status: Field10.select({ + label: "Requested Status", + group: "sales_process", + options: [ + { label: "Won", value: "closed_won" }, + { label: "Lost", value: "closed_lost" } + ] + }), + status_change_approval_status: Field10.select({ + label: "Status Change Approval", + group: "sales_process", + readonly: true, + defaultValue: "not_required", + options: [ + { label: "Not Required", value: "not_required", default: true }, + { label: "Pending", value: "pending", color: "#FFA500" }, + { label: "Approved", value: "approved", color: "#00AA00" }, + { label: "Rejected", value: "rejected", color: "#FF0000" } + ] + }), + // ─── Win / Loss analysis ─────────────────────────────────────────── + // + // ⛔ The reason is captured AT CLOSE, and that is enforced, not requested. + // Leaving both fields optional means every seeded and user-closed deal + // lands with them empty and the win/loss widgets below have nothing to draw. + // + // `requiredWhen`, not a script validation, for the same reason + // `crm_lead.duplicate_of_lead` uses it (ADR-0113): "this field must hold a + // value when the record looks like X" is exactly a conditional write + // contract, the engine evaluates it on insert AND update inside + // `evaluateValidationRules`, and it reports against the FIELD — so the form + // marks the empty picklist instead of showing a record-level banner. It is + // ALSO the only shape the freeze below leaves usable: once a deal is closed, + // `opportunity.hook.ts` refuses every user edit outside the narrative + // fields, so a reason not captured in the closing write can never be added + // afterwards. Close time is the only chance. + // `test/win-loss-capture.test.ts` drives both predicates through a real + // ObjectQL over a real driver, on insert and on update. + // + // ⚠️ `has(...)` is load-bearing. A bare `record.stage == "closed_lost"` + // aborts with `No such key` on any merged record that omits the column, and + // the engine's answer to a predicate that cannot evaluate is to SKIP it + // ("requiredWhen for 'loss_reason' failed to evaluate — skipped"), which + // would make this read as enforced while requiring nothing at all. + win_reason: Field10.select({ + label: "Win Reason", + description: "Why this deal was won. Required to close an opportunity as Won.", + group: "classification", + requiredWhen: P7`has(record.stage) && record.stage == "closed_won"`, + options: [ + { label: "Better Product", value: "better_product" }, + { label: "Better Price", value: "better_price" }, + { label: "Existing Relationship", value: "relationship" }, + { label: "Better Support", value: "better_support" }, + { label: "Best Fit / Features", value: "best_fit" }, + // Written by the machine, not chosen by a rep: `quote_on_accepted` + // (quote.hook.ts) wins the deal the moment a customer accepts the + // quote, and no human is in that write to attribute it. Naming the + // automated path is this repo's existing idiom for exactly that split + // (`crm_lead.duplicate_status` = machine `suspected` vs human + // `confirmed`) and it keeps the rule exception-free: every closed_won + // row carries a reason, and an analyst can still tell a CPQ close from + // a rep's attribution instead of reading a fabricated "Better Product". + { label: "Quote Accepted", value: "quote_accepted" }, + { label: "Other", value: "other" } + ] + }), + loss_reason: Field10.select({ + label: "Loss Reason", + description: "Why this deal was lost. Required to close an opportunity as Lost.", + group: "classification", + requiredWhen: P7`has(record.stage) && record.stage == "closed_lost"`, + options: [ + { label: "Price Too High", value: "price" }, + { label: "Lost to Competitor", value: "competitor" }, + { label: "No Budget", value: "no_budget" }, + { label: "No Decision", value: "no_decision" }, + { label: "Bad Timing", value: "timing" }, + { label: "Missing Features", value: "features" }, + { label: "Other", value: "other" } + ] + }), + loss_details: Field10.textarea({ + label: "Loss/Win Details", + description: "Free-text context behind the win or loss reason.", + group: "classification" + }) + }, + // Database indexes for performance + indexes: [ + { fields: ["name"] }, + { fields: ["crm_account"] }, + { fields: ["owner_id"] }, + { fields: ["stage"] }, + { fields: ["close_date"] }, + // The stagnation sweep filters on this every morning. + { fields: ["stage_entry_date"] } + ], + // Enable advanced features + // + // Stage/amount history is tracked per-field via `Field.trackHistory` + // (ADR-0052). ⚠️ Ownership is NOT: it lives on the platform's injected + // `owner_id`, which carries no `trackHistory` flag — a transfer is recorded + // in the compliance audit log (`sys_audit_log`, unconditional) rather than on + // the activity feed. + enable: { + apiEnabled: true, + apiMethods: ["get", "list", "create", "update", "delete"], + // Whitelist allowed API operations + // #602 — proposals, redlines and signed orders belong on the deal. + // See the canonical capability note in `src/sales/objects/index.ts`. + files: true + }, + // ADR-0052 §5b.2 — declarative milestone activity. When `stage` enters these + // values the platform emits a semantic timeline entry (no hook code). + // Combined with the field-level `trackHistory` above (stage-change rows) this + // replaces any hand-coded activity hook. + activityMilestones: [ + { field: "stage", value: "closed_won", summary: "Deal won \u2014 {name}", type: "completed" }, + { field: "stage", value: "closed_lost", summary: "Deal lost \u2014 {name}", type: "completed" } + ], + // Removed: list_views and form_views belong in UI configuration, not object definition + // Lifecycle transitions are enforced via a `state_machine` validation rule + // (see validations[] below). ⚠️ There is no top-level `stateMachines` key on + // the platform — status state machines live in the validation union. + // Validation Rules + // + // Predicates below are TOTAL: every `record.x` read is `has()`-guarded, so the + // rule returns a verdict even when the merged record has no such key. See + // AGENTS.md "Validation predicates must be TOTAL" and + // test/object-validation-predicates.test.ts, which fails the build otherwise. + validations: [ + { + name: "close_date_future", + type: "script", + severity: "warning", + message: "Close date should not be in the past unless opportunity is closed", + // An absent `stage` key means "no stage recorded", which is not a closed + // stage — hence `!has(record.stage) || (…)` rather than a leading + // `has(record.stage) &&`, which would suppress the warning instead. + condition: P7`has(record.close_date) && record.close_date != null && record.close_date < today() && (!has(record.stage) || (record.stage != "closed_won" && record.stage != "closed_lost"))` + }, + { + name: "amount_positive", + type: "script", + severity: "error", + message: "Amount must be greater than zero", + condition: P7`has(record.amount) && record.amount != null && record.amount <= 0` + }, + { + name: "opportunity_stage_progression", + type: "state_machine", + severity: "warning", + message: "Invalid opportunity stage transition", + field: "stage", + transitions: { + // `→ proposal` is legal from every pre-proposal stage: the + // quote_generation flow fast-forwards the deal to `proposal` when a + // quote is generated, which can happen at any open stage. + prospecting: ["qualification", "proposal", "closed_lost"], + qualification: ["needs_analysis", "proposal", "closed_lost"], + needs_analysis: ["proposal", "closed_lost"], + // `proposal → closed_won` is legal: the quote_on_accepted hook closes + // the linked deal directly from the CPQ path (quote_generation parks + // the opportunity at `proposal`; an accepted quote wins it without a + // separate negotiation step). + proposal: ["negotiation", "closed_won", "closed_lost"], + negotiation: ["closed_won", "closed_lost"], + closed_won: [], + closed_lost: [] + } + } + ] + // ⚠️ `probability` and `expected_revenue` are NOT computed declaratively. + // They are derived in `opportunity.hook.ts` (single source of truth = + // stage → STAGE_PROBABILITY); keeping the math in one place avoids drift + // between a declarative CASE() table and the hook's lookup table. + // + // ⚠️ No `workflows[]` here, and none is possible: object `workflows[]` were + // removed from the platform. Field updates live in this object's `*.hook.ts`; + // scheduled status flips and notifications live in `src/*/flows/*.flow.ts`. +}); + +// src/sales/objects/task.object.ts +import { ObjectSchema as ObjectSchema11, Field as Field11 } from "@objectstack/spec/data"; +import { P as P8 } from "@objectstack/spec"; +var Task = ObjectSchema11.create({ + name: "crm_task", + label: "Task", + pluralLabel: "Tasks", + icon: "check-square", + description: "Activities and to-do items", + // ADR-0090 D1/D7: OWD is an authored decision. Personal activity records. + sharingModel: "private", + // Every other business object with a detail page groups its fields; task was + // one of the two that did not, so its detail page fell back to one flat grid + // where the five polymorphic `related_to_*` lookups and the recurrence + // machinery sat inline with the subject. The keys mirror the sections the + // task form already uses (Task / Related Records / Recurrence & Effort) so + // the two surfaces agree. + fieldGroups: [ + { key: "basic", label: "Task Information", icon: "info" }, + { key: "scheduling", label: "Scheduling", icon: "calendar" }, + // No 'assignment' group: the assignee (`owner_id`) was its only member, and + // the synthesized detail page hoists it into the highlight strip — so the + // group rendered on forms and never on detail pages + // (`field-group-shadowed`). It lives in `basic` alongside + // subject/status/priority instead. + { key: "related", label: "Related Records", icon: "link" }, + { key: "recurrence", label: "Recurrence", icon: "refresh-ccw", collapse: "collapsed" }, + { key: "effort", label: "Progress & Effort", icon: "activity", collapse: "collapsed" }, + { key: "system", label: "System", icon: "database", collapse: "collapsed" } + ], + fields: { + // Platform ownership anchor — canonical note in `account.object.ts` (#548). + owner_id: Field11.lookup("sys_user", { + label: "Assigned To", + group: "basic", + system: true, + readonly: false, + trackHistory: true + }), + // Task Information + subject: Field11.text({ + group: "basic", + label: "Subject", + required: true, + storage: { notNull: true }, + searchable: true, + maxLength: 255 + }), + description: Field11.markdown({ + group: "basic", + label: "Description" + }), + // Task Management + status: Field11.select({ + group: "basic", + label: "Status", + required: true, + storage: { notNull: true }, + trackHistory: true, + // Field-level default, not just the option flag: the option `default` + // only preselects in some form surfaces, so a quick-create modal opened + // from a related list left this required field blank and the rep had to + // pick "Not Started" by hand every time. + defaultValue: "not_started", + options: [ + { label: "Not Started", value: "not_started", color: "#808080", default: true }, + { label: "In Progress", value: "in_progress", color: "#FFA500" }, + { label: "Waiting", value: "waiting", color: "#FFD700" }, + { label: "Completed", value: "completed", color: "#00AA00" }, + { label: "Deferred", value: "deferred", color: "#999999" } + ] + }), + priority: Field11.select({ + group: "basic", + label: "Priority", + required: true, + storage: { notNull: true }, + trackHistory: true, + // `normal` is the default rather than `low`: a rep filing a to-do has + // made no priority judgement, and defaulting everything to Low made the + // field meaningless (nothing ever sorted above the noise). + defaultValue: "normal", + options: [ + { label: "Low", value: "low", color: "#4169E1" }, + { label: "Normal", value: "normal", color: "#00AA00", default: true }, + { label: "High", value: "high", color: "#FFA500" }, + { label: "Urgent", value: "urgent", color: "#FF0000" } + ] + }), + // Sortable ordinal for `priority` — see crm_case.priority_rank. Sorting on + // the select itself compares raw strings (normal > low > high > urgent), + // which pushes urgent work to the bottom of the to-do queue. + // + // `0` is the UNRANKED sentinel, identical to crm_case.priority_rank. ⛔ It + // must stay identical on both: a differing sentinel orders the same unknown + // priority differently on the two objects, and `2` here would make an + // unranked task indistinguishable from a genuine `normal`. + priority_rank: Field11.number({ + label: "Priority Rank", + readonly: true, + defaultValue: 0 + }), + type: Field11.select({ + group: "basic", + label: "Task Type", + // Canonical set (#490) — the schedule_followup screen renders the same + // list; see _picklists.ts. + options: [...TASK_TYPE_OPTIONS] + }), + // Dates + due_date: Field11.date({ + group: "scheduling", + label: "Due Date" + }), + reminder_date: Field11.datetime({ + group: "scheduling", + label: "Reminder Date/Time" + }), + completed_date: Field11.datetime({ + group: "scheduling", + label: "Completed Date", + readonly: true + }), + // Related To (Polymorphic relationship - can link to multiple object types) + related_to_type: Field11.select({ + group: "related", + label: "Related To Type", + options: [ + { label: "Account", value: "crm_account" }, + { label: "Contact", value: "crm_contact" }, + { label: "Opportunity", value: "crm_opportunity" }, + { label: "Lead", value: "crm_lead" }, + { label: "Case", value: "crm_case" } + ] + }), + related_to_account: Field11.lookup("crm_account", { + group: "related", + label: "Related Account" + }), + related_to_contact: Field11.lookup("crm_contact", { + group: "related", + label: "Related Contact" + }), + related_to_opportunity: Field11.lookup("crm_opportunity", { + group: "related", + label: "Related Opportunity" + }), + related_to_lead: Field11.lookup("crm_lead", { + group: "related", + label: "Related Lead" + }), + related_to_case: Field11.lookup("crm_case", { + group: "related", + label: "Related Case" + }), + // Recurrence (for recurring tasks) + is_recurring: Field11.boolean({ + group: "recurrence", + label: "Recurring Task", + defaultValue: false + }), + recurrence_type: Field11.select({ + group: "recurrence", + label: "Recurrence Type", + options: [ + { label: "Daily", value: "daily" }, + { label: "Weekly", value: "weekly" }, + { label: "Monthly", value: "monthly" }, + { label: "Yearly", value: "yearly" } + ] + }), + recurrence_interval: Field11.number({ + group: "recurrence", + label: "Recurrence Interval", + defaultValue: 1, + min: 1 + }), + recurrence_end_date: Field11.date({ + group: "recurrence", + label: "Recurrence End Date" + }), + // Flags + is_completed: Field11.boolean({ + group: "system", + label: "Is Completed", + defaultValue: false, + readonly: true + }), + is_overdue: Field11.boolean({ + group: "system", + label: "Is Overdue", + defaultValue: false, + readonly: true + }), + // Set by the `task_due_reminder` schedule flow once a reminder has fired + // (the sweep de-dups on `reminder_date`, which it clears; this flag is the + // audit trail), and defaulted to `false` by `task.hook.ts` on insert. + // + // NOT readonly — but the old reason here ("16.x drops flow writes to + // readonly fields") does not survive measurement. Taken on 17.1.0, + // RE-TAKEN on 17.2.0 (#1460) and RE-CONFIRMED on 17.3.0 (#1676) — the pin + // at each of those takings; not re-taken on 17.4.0 (PR #1814, #1807) or + // 17.5.0 — same verdict all three times: `task_due_reminder` + // declares `runAs: 'system'`, so its write WOULD survive a + // `readonly: true`. + // + // ⚠️ The other half of that reason EXPIRED at 17.4.0 and is ⛔ NOT + // renumbered here: "the insert path is exempt from the strip" held through + // 17.3.0 and was reversed as a declared BREAKING change — the retirement + // is recorded in the INSERT-path section of + // `test/readonly-write-semantics.test.ts` (#1429) and in + // `campaign_member.object.ts`. Neither half moves this field, which is not + // `readonly` at all. Left writable as-is; flipping it is a separate + // decision, not a comment fix. + reminder_sent: Field11.boolean({ + group: "system", + label: "Reminder Sent", + defaultValue: false + }), + // Progress + progress_percent: Field11.percent({ + group: "effort", + label: "Progress (%)", + min: 0, + max: 100, + defaultValue: 0 + }) + // No time tracking. `estimated_hours` / `actual_hours` were declared and + // inert: no rollup summed them onto a case or an opportunity, no variance + // report compared them, and nothing warned when actual overran estimate. + // Effort on a task is `progress_percent`, which the task views do read. + }, + // API surface. History → Field.trackHistory (ADR-0052). + enable: { + apiEnabled: true + }, + // Database indexes for performance + indexes: [ + { fields: ["status"] }, + { fields: ["priority"] }, + { fields: ["owner_id"] }, + { fields: ["due_date"] } + ], + // ADR-0079: render-only `titleFormat` retired in favor of `nameField`, + // which names the real field holding the record title (here: `subject`). + nameField: "subject", + highlightFields: ["subject", "status", "priority", "due_date", "owner_id"], + // Removed: list_views and form_views belong in UI configuration, not object definition + // Predicates below are TOTAL: every `record.x` read is `has()`-guarded, so the + // rule returns a verdict even when the merged record has no such key. See + // AGENTS.md "Validation predicates must be TOTAL" and + // test/object-validation-predicates.test.ts, which fails the build otherwise. + validations: [ + { + name: "completed_date_required", + type: "script", + severity: "error", + message: "Completed date is required when status is Completed", + condition: P8`has(record.status) && record.status == "completed" && (!has(record.completed_date) || isBlank(record.completed_date))` + }, + { + name: "recurrence_fields_required", + type: "script", + severity: "error", + message: "Recurrence type is required for recurring tasks", + condition: P8`has(record.is_recurring) && record.is_recurring == true && (!has(record.recurrence_type) || isBlank(record.recurrence_type))` + }, + { + name: "related_to_required", + type: "script", + severity: "warning", + message: "At least one related record should be selected", + condition: P8`(!has(record.related_to_account) || isBlank(record.related_to_account)) && (!has(record.related_to_contact) || isBlank(record.related_to_contact)) && (!has(record.related_to_opportunity) || isBlank(record.related_to_opportunity)) && (!has(record.related_to_lead) || isBlank(record.related_to_lead)) && (!has(record.related_to_case) || isBlank(record.related_to_case))` + } + ] + // ⚠️ No `workflows[]` here, and none is possible: object `workflows[]` were + // removed from the platform. Field updates live in this object's `*.hook.ts`; + // scheduled status flips and notifications live in `src/*/flows/*.flow.ts`. +}); + +// src/sales/actions/activity-actions.ts +var nameFieldMap = (objectDefs) => Object.fromEntries( + Object.values(objectDefs).filter( + (o) => typeof o?.name === "string" && typeof o?.nameField === "string" + ).map((o) => [o.name, o.nameField]) +); +var ACTIVITY_TARGETS = { + crm_lead: "related_to_lead", + crm_contact: "related_to_contact", + crm_account: "related_to_account", + crm_opportunity: "related_to_opportunity", + crm_case: "related_to_case" +}; +var lit = (value) => JSON.stringify(value); +var ACTOR_NAME_RESOLUTION_SOURCE = `// The acting user's DISPLAY name, for the sys_activity row (#673 / #678). + // + // PLATFORM WORKAROUND. \`ctx.user.name\` is not a display name on the + // dispatch path the Console uses: the REST action dispatcher builds the + // body's user as \`{ id: ec.userId, name: ec.userId, \u2026 }\` \u2014 the key is + // present and carries the raw id, so \`ctx.user?.name\` reads as a + // plausible string and silently wrote ids like + // "grDEyLoIgnunJ2M7Y2muLgcuQbDUT0s2" into \`sys_activity.actor_name\` + // (@objectstack/runtime 17.0.0-rc.2, dist/index.js:5397-5399). The MCP + // dispatcher does try a display name first + // (\`ec.userName ?? ec.userDisplayName ?? ec.userId\`, dist/index.js:1776) + // but nothing in the installed platform ever populates either field, so + // it falls back to the id too. + // + // So the name is resolved HERE, from \`sys_user.name\` (the column the + // platform itself treats as the profile display name), with the id kept + // as the last resort \u2014 an opaque id is bad, a blank actor is worse. + // A name that differs from the id is taken as already-resolved, which is + // what makes this one query and not a query per activity write. + // + // DELETE THIS once the platform delivers a display name on ctx.user.name + // for REST-dispatched action bodies: every splice site collapses back to + // \`actor_name: ctx.user?.name\` (objectstack-ai/objectstack#5372). + const ctxName = ctx.user?.name ? String(ctx.user.name).trim() : ''; + let actorName = ctxName && ctxName !== userId ? ctxName : ''; + if (!actorName && userId) { + try { + const found = await ctx.api.object('sys_user').find({ + where: { id: userId }, + fields: ['name'], + top: 1, + }); + const users = Array.isArray(found) ? found : (found?.records ?? []); + const resolved = users.length && users[0].name ? String(users[0].name).trim() : ''; + if (resolved) actorName = resolved; + } catch (e) { + // A denied or unavailable sys_user read must not fail the log \u2014 the + // interaction the rep just recorded matters more than its label. + } + } + if (!actorName) actorName = userId;`; +function activityAction(spec, objectName, nameField) { + const relatedField = ACTIVITY_TARGETS[objectName]; + if (!relatedField) { + throw new Error( + `activityAction: '${objectName}' is not an activity target \u2014 extend ACTIVITY_TARGETS together with crm_event.related_to_type and its related_to_* lookup.` + ); + } + return { + name: spec.name, + label: spec.label, + // Object-scoped, one registration per object. The runtime registers a body + // action under `:` and the dispatcher probes + // `` then `*`; a body action with no objectName lands under a + // 'global' key nothing ever probes ("Action 'log_call' on object '*' not + // found", verified 2026-07-28). ⛔ Never author an object-less body action. + objectName, + icon: spec.icon, + // script, not modal: modal submits die on GET /api/v1/meta/object/ + // → 400 in 16.1.0; script actions POST /api/v1/actions/... and execute. + type: "script", + body: { + language: "js", + source: ` + const OBJECT_NAME = ${lit(objectName)}; + const RELATED_FIELD = ${lit(relatedField)}; + const NAME_FIELD = ${lit(nameField)}; + const EVENT_TYPE = ${lit(spec.eventType)}; + const EVENT_STATUS = ${lit(spec.eventStatus)}; + + const record = ctx.record ?? {}; + const recordId = ctx.recordId ?? record.id ?? null; + const userId = ctx.user?.id ?? null; + const nowIso = new Date().toISOString(); + + ${ACTOR_NAME_RESOLUTION_SOURCE} + + const subject = input.subject ? String(input.subject) : ${lit(spec.defaultSubject)}; + const duration = input.duration ? Number(input.duration) : 0; + const notes = input.notes ? String(input.notes) : ''; + const location = input.location ? String(input.location) : ''; + + // A booking states its own start; a log is "just now". + // + // WORKAROUND for objectstack-ai/objectstack#5061 \u2014 the start is collected + // as a CALENDAR DAY + a WALL CLOCK (\`start_date\` / \`start_time\`) and + // joined here, instead of as one \`type: 'datetime'\` param. A datetime + // param is unusable from the Console: it renders as a zone-less + // \`\` and POSTs the raw value + // ("2026-08-10T15:00"), which the runtime's action-param validator rejects + // with 400 "expected an ISO-8601 instant with explicit zone" \u2014 no user + // input can pass. \`date\` and \`time\` are the two param types whose + // renderer output ("YYYY-MM-DD" / "HH:MM") the validator accepts verbatim, + // so the pair is submittable where the single datetime never was. + // + // TIMEZONE: the wall clock is interpreted as **UTC**, and both param + // labels say so. UTC is the only zone this body can apply deterministically + // \u2014 the sandbox context carries no user or org timezone (\`ctx.user\` is + // id/name/email), and reading the server's local zone would make the same + // input mean different instants on different hosts and in tests. Everything + // else this app writes is likewise a UTC instant (\`new Date().toISOString()\`). + // + // When #5061 lands (the Console serializing datetime-local in the + // browser's zone), this reverts to ONE \`type: 'datetime'\` param and the + // zone becomes the user's own \u2014 see \`collectsSchedule\` in this file. + let startIso = nowIso; + const startDate = input.start_date ? String(input.start_date).trim() : ''; + if (startDate) { + const startTime = input.start_time ? String(input.start_time).trim() : '00:00'; + // 'HH:MM' and 'HH:MM:SS' are both shapes the validator lets through. + const clock = startTime.length === 5 ? startTime + ':00' : startTime; + const parsed = new Date(startDate + 'T' + clock + '.000Z'); + // An unparseable value falls back to now rather than writing NaN into a + // required column. + if (!isNaN(parsed.getTime())) startIso = parsed.toISOString(); + } + + // 1. the interaction itself, as a queryable record. + const eventDoc = { + subject: subject, + type: EVENT_TYPE, + status: EVENT_STATUS, + start_datetime: startIso, + // Load-bearing, not decoration: an action body executes with + // isSystem: true (runtime buildActionExecutionContext), which + // short-circuits the security middleware \u2014 so the insert-time + // auto-stamp of owner_id never fires here. Omitting it would land the + // interaction ownerless, i.e. invisible in "My \u2026" and uneditable under + // a private OWD (#548, the #622 failure mode). + owner_id: userId, + related_to_type: OBJECT_NAME, + }; + if (duration > 0) eventDoc.duration_minutes = duration; + if (location) eventDoc.location = location; + if (notes) eventDoc.description = notes; + if (recordId) eventDoc[RELATED_FIELD] = recordId; + const event = await ctx.api.object('crm_event').insert(eventDoc); + const eventId = event?.id ?? null; + + // 2. attendees, as rows \u2014 the point of #592. + // A multi-lookup param may arrive as an array or, on a surface that + // renders it single-valued, as one scalar. Normalising both is not a + // lenient parse of authored metadata: it is the console's own input + // shape, which this body does not control. + const toList = (v) => { + if (v === null || v === undefined || v === '') return []; + return Array.isArray(v) ? v : [v]; + }; + const attendees = []; + if (userId) { + attendees.push({ attendee_type: 'user', sys_user: userId, is_organizer: true, response: 'accepted' }); + } + // The record the action was fired from IS an attendee when it is a + // person. On an account / opportunity / case it is not, so nothing is + // invented for it \u2014 the event's related_to_* link already records it. + if (OBJECT_NAME === 'crm_contact' && recordId) { + attendees.push({ attendee_type: 'contact', crm_contact: recordId, response: 'no_response' }); + } + if (OBJECT_NAME === 'crm_lead' && recordId) { + attendees.push({ attendee_type: 'lead', crm_lead: recordId, response: 'no_response' }); + } + for (const c of toList(input.attendee_contacts)) { + attendees.push({ attendee_type: 'contact', crm_contact: String(c), response: 'no_response' }); + } + for (const u of toList(input.attendee_users)) { + attendees.push({ attendee_type: 'user', sys_user: String(u), response: 'no_response' }); + } + + const seen = {}; + const attendeeIds = []; + for (const a of attendees) { + const who = a.sys_user ?? a.crm_contact ?? a.crm_lead ?? ''; + const key = a.attendee_type + ':' + who; + if (seen[key]) continue; + seen[key] = true; + const doc = Object.assign({}, a, { crm_event: eventId, invited_date: nowIso }); + const row = await ctx.api.object('crm_event_attendee').insert(doc); + if (row?.id) attendeeIds.push(row.id); + } + + // 3. the unified-timeline pointer. + // \`metadata\` no longer carries the attendee list: it is a display hint + // beside a real record now, not the record itself. ADR-0052 + // source_object/source_id is the queryable drill to the crm_event row. + const summary = duration ? subject + ' (' + duration + ' min)' : subject; + const activity = await ctx.api.object('sys_activity').insert({ + type: EVENT_STATUS === 'held' ? 'completed' : 'scheduled', + summary: ${lit(spec.summaryPrefix)} + summary, + actor_id: userId, + actor_name: actorName, + object_name: OBJECT_NAME, + record_id: recordId, + // #514 item 2: the object's DECLARED nameField, not a hardcoded name. + record_label: record[NAME_FIELD] ?? null, + source_object: 'crm_event', + source_id: eventId, + metadata: JSON.stringify({ + kind: EVENT_TYPE, + duration_minutes: duration, + notes: notes, + attendee_count: attendeeIds.length, + }), + }); + + // 4. SLA first-response stamp \u2014 NOT here. #575 B2 originally stamped + // \`crm_case.first_response_date\` from this body, which meant the metric + // was only ever written when the interaction was recorded through the two + // buttons this factory builds; an event created any other way left it + // null, under a comment asking every future author to remember. #595 + // moved the stamp to \`event_activity_bubble\` in + // \`src/sales/objects/event.hook.ts\`, which already fires on exactly the + // condition that matters ("a held event, on its transition into held") + // and already resolves \`related_to_case\`. Step 1 above writes that + // event, so this action still stamps the case \u2014 through one writer + // instead of a convention. Do not reintroduce a copy here: two writers + // racing on a "first" timestamp is how it becomes a "last" one. + + return { eventId: eventId, activityId: activity?.id ?? null, attendeeIds: attendeeIds }; + `, + capabilities: ["api.read", "api.write"], + timeoutMs: 5e3 + }, + locations: ["record_header", "list_item", "record_related"], + params: [ + { + name: "subject", + label: spec.subjectLabel, + type: "text", + required: true + }, + // WORKAROUND objectstack-ai/objectstack#5061 — one `type: 'datetime'` + // param ("Starts At") is what this WANTS to be, and it is unusable: the + // Console renders it as a zone-less `` and + // POSTs the raw value, which the action-param validator rejects with a + // 400 (`expected an ISO-8601 instant with explicit zone`). The renderer's + // output shape and the validator's accepted shape do not intersect, so + // NO user input can submit the action — reproduced from both the list-row + // menu and the record header. + // + // `date` and `time` are the two param types where they DO intersect: the + // Console renders native `` / `` + // pickers (`ui-components` DateField / TimeField, both emitting + // `e.target.value` verbatim) and the validator's `CalendarDateValueSchema` + // /`ClockTimeValueSchema` accept exactly `YYYY-MM-DD` and `HH:MM`. Two + // native pickers are also better UX than one free-text box, which is the + // other shape that would have submitted. + // + // The zone is stated in the LABELS, not in `helpText`: the Console's + // action-param form forwards only name/label/type/required/placeholder/ + // options/multiple/accept/maxSize to the field widget, so a `helpText` + // here would never reach the user. + // + // REVERT WHEN #5061 LANDS: back to + // { name: 'start', label: 'Starts At', type: 'datetime', required: true } + // and drop the join in the body above. + ...spec.collectsSchedule ? [ + { name: "start_date", label: "Start Date (UTC)", type: "date", required: true }, + { name: "start_time", label: "Start Time (UTC)", type: "time", required: true }, + { name: "location", label: "Location", type: "text", required: false } + ] : [], + { + name: "duration", + label: "Duration (minutes)", + type: "number", + required: false + }, + // Two typed lookups, not one free-text box: the platform has no + // polymorphic picker, and typed lookups produce queryable rows where a + // text box produces a comma-separated sentence nothing can filter on. + { + name: "attendee_contacts", + label: "Contact Attendees", + type: "lookup", + reference: "crm_contact", + multiple: true, + required: false + }, + { + name: "attendee_users", + label: "Internal Attendees", + type: "lookup", + reference: "sys_user", + multiple: true, + required: false + }, + { + name: "notes", + label: spec.notesLabel, + type: "textarea", + required: false + } + ], + successMessage: spec.successMessage, + refreshAfter: true + }; +} +var LOG_CALL_SPEC = { + name: "log_call", + label: "Log a Call", + icon: "phone", + eventType: "call", + eventStatus: "held", + summaryPrefix: "", + defaultSubject: "Untitled Call", + subjectLabel: "Call Subject", + notesLabel: "Call Notes", + successMessage: "Call logged successfully!" +}; +var LOG_MEETING_SPEC = { + name: "log_meeting", + label: "Log a Meeting", + icon: "calendar-check", + eventType: "meeting", + eventStatus: "held", + summaryPrefix: "Meeting: ", + defaultSubject: "Untitled Meeting", + subjectLabel: "Meeting Subject", + notesLabel: "Meeting Notes", + successMessage: "Meeting logged successfully!" +}; +var SCHEDULE_MEETING_SPEC = { + name: "schedule_meeting", + label: "Schedule a Meeting", + icon: "calendar-plus", + eventType: "meeting", + // `planned`, and that is the whole difference that matters: a booking must + // NOT reset the customer's recency clock (see event.hook.ts). + eventStatus: "planned", + summaryPrefix: "Meeting scheduled: ", + defaultSubject: "Untitled Meeting", + subjectLabel: "Meeting Subject", + notesLabel: "Agenda", + collectsSchedule: true, + successMessage: "Meeting scheduled!" +}; +var ACTIVITY_SPECS = [LOG_CALL_SPEC, LOG_MEETING_SPEC, SCHEDULE_MEETING_SPEC]; +var activityActionsFor = (objectName, objectDefs) => { + const nameField = nameFieldMap(objectDefs)[objectName] ?? "name"; + const built = ACTIVITY_SPECS.map((spec) => activityAction(spec, objectName, nameField)); + return Object.fromEntries(built.map((a) => [a.name, a])); +}; +var leadActivityActions = activityActionsFor("crm_lead", objects_exports2); +var contactActivityActions = activityActionsFor("crm_contact", objects_exports2); +var accountActivityActions = activityActionsFor("crm_account", objects_exports2); +var opportunityActivityActions = activityActionsFor("crm_opportunity", objects_exports2); +var LeadLogCallAction = leadActivityActions.log_call; +var LeadLogMeetingAction = leadActivityActions.log_meeting; +var LeadScheduleMeetingAction = leadActivityActions.schedule_meeting; +var ContactLogCallAction = contactActivityActions.log_call; +var ContactLogMeetingAction = contactActivityActions.log_meeting; +var ContactScheduleMeetingAction = contactActivityActions.schedule_meeting; +var AccountLogCallAction = accountActivityActions.log_call; +var AccountLogMeetingAction = accountActivityActions.log_meeting; +var AccountScheduleMeetingAction = accountActivityActions.schedule_meeting; +var OpportunityLogCallAction = opportunityActivityActions.log_call; +var OpportunityLogMeetingAction = opportunityActivityActions.log_meeting; +var OpportunityScheduleMeetingAction = opportunityActivityActions.schedule_meeting; + +// src/service/actions/case-activity.actions.ts +var caseActivityActions = activityActionsFor("crm_case", objects_exports); +var LogCallAction = caseActivityActions.log_call; +var LogMeetingAction = caseActivityActions.log_meeting; +var CaseScheduleMeetingAction = caseActivityActions.schedule_meeting; + +// src/service/actions/knowledge_article.actions.ts +import { P as P9 } from "@objectstack/spec"; +var feedbackBody = (verdict) => ` + const id = ctx.recordId; + if (!id) throw new Error('submit_article_feedback requires a recordId'); + const userId = ctx.user?.id ?? null; + if (!userId) throw new Error('Sign in to rate an article.'); + + // One row per (article, reader) \u2014 the unique index says so, and this + // read is what keeps a mind-change an UPDATE instead of a duplicate. + const existing = await ctx.api.object('crm_article_feedback').findOne({ + where: { crm_knowledge_article: id, owner_id: userId }, + }); + + if (existing && existing.id) { + if (existing.verdict === '${verdict}') { + return { ok: true, id: existing.id, verdict: '${verdict}', changed: false }; + } + await ctx.api.object('crm_article_feedback').update( + { id: existing.id, verdict: '${verdict}' }, + { where: { id: existing.id } }, + ); + return { ok: true, id: existing.id, verdict: '${verdict}', changed: true }; + } + + const inserted = await ctx.api.object('crm_article_feedback').insert({ + crm_knowledge_article: id, + verdict: '${verdict}', + owner_id: userId, + }); + return { ok: true, id: inserted?.id ?? null, verdict: '${verdict}', changed: true }; + `; +var publishedOnly = P9`has(record.status) && record.status == "published"`; +var MarkArticleHelpfulAction = { + name: "mark_article_helpful", + label: "Helpful", + objectName: "crm_knowledge_article", + icon: "thumbs-up", + type: "script", + body: { + language: "js", + source: feedbackBody("helpful"), + capabilities: ["api.read", "api.write"], + timeoutMs: 5e3 + }, + locations: ["record_header"], + visible: publishedOnly, + successMessage: "Thanks \u2014 recorded as helpful.", + refreshAfter: true +}; +var MarkArticleNotHelpfulAction = { + name: "mark_article_not_helpful", + label: "Not Helpful", + objectName: "crm_knowledge_article", + icon: "thumbs-down", + type: "script", + body: { + language: "js", + source: feedbackBody("not_helpful"), + capabilities: ["api.read", "api.write"], + timeoutMs: 5e3 + }, + locations: ["record_header"], + visible: publishedOnly, + successMessage: "Thanks \u2014 recorded as not helpful.", + refreshAfter: true +}; + +// src/service/dashboards/service.dashboard.ts +var dataset = "case_metrics"; +var ServiceDashboard = { + name: "service_dashboard", + label: "Customer Service", + description: "Case load, SLA health, and resolution performance", + columns: 12, + gap: 4, + refreshIntervalSeconds: 60, + // 1 minute — service desks need fresh numbers + header: { + showTitle: true, + showDescription: true + // Header action buttons removed: `create_case` is not a defined action and + // `/objects/case?owner=current_user` / `/reports/sla` are not in-app view + // routes — all three were dead. Re-add real, wired-up actions here when available. + }, + // Historical note (#460 → #1157): this dashboard shipped without a date + // picker from PR #546 until the 17.0.0 GA upgrade, because windowing a + // `Field.datetime()` could not be compared — `driver-sql` 16.1.0 coerced + // datetime bounds to epoch-ms INTEGER while every datetime in the database is + // ISO TEXT, so `$gte` matched everything and `$lte` matched nothing and the + // whole dashboard read zeros. Both named preconditions are fixed and + // released: objectstack#3912 (the coercion) and objectstack#3777 (a bare-date + // `$lte` dropping same-day rows). The window below is not restored on the + // strength of those closures alone — `test/dashboard-date-range-window.test.ts` + // executes it against a real SQLite database and compares every widget to a + // ground truth computed in the same run, so a re-regression fails CI here + // rather than being discovered as an all-zero dashboard again. + // + // The range windows `created_at`, the platform's creation stamp (#1992). It + // used to window `created_date`, which nothing wrote on a real case, so + // every case created through the UI or REST fell outside every range. + dateRange: { field: "created_at", defaultRange: "last_90_days", allowCustomRange: true }, + globalFilters: [ + { + field: "owner_id", + label: { en: "Agent", "zh-CN": "\u8D1F\u8D23\u4EBA", "es-ES": "Propietario del Caso", "ja-JP": "\u30B1\u30FC\u30B9\u62C5\u5F53\u8005" }, + type: "lookup", + scope: "dashboard", + optionsFrom: { object: "sys_user", valueField: "id", labelField: "name" } + }, + { + field: "priority", + label: { en: "Priority", "zh-CN": "\u4F18\u5148\u7EA7", "es-ES": "Prioridad", "ja-JP": "\u512A\u5148\u5EA6" }, + type: "select", + scope: "dashboard", + options: [ + // zh-CN `critical` is 严重, never 紧急 — 紧急 belongs to crm_task.priority.urgent + // and the two vocabularies are distinct sets (ruling #1342). Same wording as + // `objects.crm_case.fields.priority.options` in every locale pack. + { value: "critical", label: { en: "Critical", "zh-CN": "\u4E25\u91CD", "es-ES": "Cr\xEDtica", "ja-JP": "\u91CD\u5927" } }, + { value: "high", label: { en: "High", "zh-CN": "\u9AD8", "es-ES": "Alta", "ja-JP": "\u9AD8" } }, + { value: "medium", label: { en: "Medium", "zh-CN": "\u4E2D", "es-ES": "Media", "ja-JP": "\u4E2D" } }, + { value: "low", label: { en: "Low", "zh-CN": "\u4F4E", "es-ES": "Baja", "ja-JP": "\u4F4E" } } + ] + } + ], + widgets: [ + // ─── Row 1: Case-Load KPIs ──────────────────────────────────────── + { + id: "open_cases", + title: "Open Cases", + description: "Cases that are not yet closed", + type: "metric", + filter: { is_closed: false }, + colorVariant: "orange", + dataset, + values: ["case_count"], + layout: { x: 0, y: 0, w: 3, h: 2 } + }, + { + id: "critical_cases", + title: "Critical Cases", + description: "Open cases marked as critical priority", + type: "metric", + filter: { priority: "critical", is_closed: false }, + colorVariant: "danger", + dataset, + values: ["case_count"], + layout: { x: 3, y: 0, w: 3, h: 2 } + }, + { + id: "avg_resolution_time", + title: "Avg Resolution Time", + description: "Mean time to close, in hours", + type: "metric", + filter: { is_closed: true }, + colorVariant: "blue", + dataset, + values: ["avg_resolution"], + layout: { x: 6, y: 0, w: 3, h: 2 } + }, + { + id: "sla_violations", + title: "SLA Violations", + description: "Cases that breached their SLA", + type: "metric", + // Counted at READ time (#2070): a case already flagged, OR a case still + // open whose deadline has passed. The second branch is the selection + // `case_sla_monitor` sweeps — same status set, same strict `$lt` at the + // current instant (`{now}` is that instant in a query filter; `{NOW()}` + // in a flow template) — so the tile reads true on a deployment that runs + // no scheduled work, where nothing flags an open breach. It counts; it + // does not act: escalation and the owner's alert still need the sweep. + // `test/case-sla-breach-on-close.test.ts` pins the two to one selection. + filter: { + $or: [ + { is_sla_violated: true }, + { status: { $nin: ["resolved", "closed"] }, sla_due_date: { $lt: "{now}" } } + ] + }, + colorVariant: "warning", + dataset, + values: ["case_count"], + layout: { x: 9, y: 0, w: 3, h: 2 } + }, + // ─── Row 2: Distribution ────────────────────────────────────────── + { + id: "cases_by_status", + title: "Cases by Status", + description: "Workload distribution across the pipeline", + type: "donut", + filter: { is_closed: false }, + colorVariant: "blue", + dataset, + dimensions: ["status"], + values: ["case_count"], + layout: { x: 0, y: 2, w: 4, h: 4 }, + chartConfig: { + showLegend: true, + showDataLabels: true, + colors: ["#0EA5E9", "#06B6D4", "#14B8A6", "#10B981", "#F59E0B"] + } + }, + { + id: "cases_by_priority", + title: "Cases by Priority", + description: "Open case mix by urgency", + type: "pie", + filter: { is_closed: false }, + colorVariant: "warning", + dataset, + dimensions: ["priority"], + values: ["case_count"], + layout: { x: 4, y: 2, w: 4, h: 4 }, + chartConfig: { + showLegend: true, + showDataLabels: true, + // critical → high → medium → low + colors: ["#DC2626", "#F97316", "#F59E0B", "#10B981"] + } + }, + { + id: "cases_by_origin", + title: "Cases by Origin", + description: "Where our cases are coming from", + type: "bar", + colorVariant: "purple", + dataset, + dimensions: ["origin"], + values: ["case_count"], + layout: { x: 8, y: 2, w: 4, h: 4 }, + chartConfig: { + showLegend: false, + showDataLabels: true, + colors: ["#8B5CF6"] + } + }, + // ─── Row 3: Volume & SLA Trends ─────────────────────────────────── + { + id: "daily_case_volume", + title: "Daily Case Volume", + description: "New cases created over the last 30 days", + type: "area", + filter: { created_at: { $gte: "{30_days_ago}" } }, + // Opted out ON PURPOSE, re-decided in #1157 rather than inherited. + // + // The floor above is no longer inert: on 17.0.0 `{30_days_ago}` resolves + // to a start-of-day bound the driver compares correctly (measured, with a + // ground truth, in `test/dashboard-date-range-window.test.ts`), so this + // chart really does plot the last 30 days and its title is true again. + // That is exactly why it must not follow the picker: the dashboard range + // is ANDed into every bound widget, so a reader who selects "last 7 days" + // would get a 7-day chart still labelled "last 30 days". Self-described + // windows opt out — the same rule the Executive dashboard's YTD tile + // follows, pinned by `test/action-references.test.ts`. Binding it instead + // would mean dropping this filter and retitling the widget in all four + // locale bundles; the fixed 30-day volume trend beside a 90-day case load + // is the intended reading. + filterBindings: { dateRange: false }, + colorVariant: "blue", + dataset, + dimensions: ["created_at"], + values: ["case_count"], + layout: { x: 0, y: 6, w: 8, h: 4 }, + chartConfig: { + showLegend: false, + showDataLabels: false, + colors: ["#0EA5E9"], + interaction: { tooltips: true, brush: true } + }, + options: { dateGranularity: "day" } + }, + { + id: "sla_compliance_gauge", + title: "SLA Compliance", + description: "Percent of cases resolved within SLA this period", + type: "gauge", + filter: { is_closed: true }, + colorVariant: "success", + // Plots COMPLIANCE, the quantity the title, the description, the + // success colouring and the 0.95 target line all name (#1213). It used + // to plot `avg_sla_violated` — the complement — with `options.invert` + // asking the renderer to flip it. `invert` is not a declared key on + // `DashboardWidgetOptionsSchema`; it rode the `.passthrough()`, nothing + // could report it inert, and the gauge read 0.0% on an org with 100% + // compliance. The key is gone rather than left pretending: a measure + // that means what the widget says is the fix, and the measure's own + // label prints under the number, so the two cannot drift apart again. + dataset, + values: ["sla_compliance_rate"], + layout: { x: 8, y: 6, w: 4, h: 4 }, + chartConfig: { + showLegend: false, + showDataLabels: true, + colors: ["#10B981", "#F59E0B", "#EF4444"], + annotations: [ + { type: "line", axis: "y", value: 0.95, label: "Target", style: "dashed", color: "#10B981" } + ] + } + // The target line was written for COMPLIANCE and is unchanged: it was + // always right — it was the plotted value that disagreed with it. (The + // green/amber/red `options.thresholds` ladder beside it was deleted in + // 17.6.0's strict cleanup: no dashboard renderer reads widget + // `thresholds`, so it never coloured anything.) + }, + // ─── Row 4: Knowledge deflection (#601) ─────────────────────────── + // + // The deflection metric the card asks the service dashboard to show, and + // the reason it is THREE tiles rather than one: a ratio widget on its own + // is unreadable — 100% could be "40 of 40" or "1 of 1", and a blank rate + // could be "no closed cases" or "no KB resolutions" (measured: a filtered + // measure contributes NO row for a group it selects nothing in, so the + // rate comes back absent, not 0). Numerator and denominator therefore ship + // beside the percentage, the same rule the sales dashboard's win rate + // follows after #614. + { + id: "kb_deflection_rate", + title: "KB Deflection Rate", + description: "Share of closed cases resolved with a knowledge article", + type: "metric", + colorVariant: "success", + dataset, + values: ["kb_deflection_rate"], + layout: { x: 0, y: 10, w: 4, h: 2 } + }, + { + id: "kb_resolved_cases", + title: "Resolved by KB", + description: "Closed cases pointing at the article that resolved them", + type: "metric", + colorVariant: "blue", + dataset, + values: ["kb_resolved_count"], + layout: { x: 4, y: 10, w: 4, h: 2 } + }, + { + id: "closed_cases_total", + title: "Closed Cases", + description: "The denominator behind the deflection rate", + type: "metric", + colorVariant: "default", + dataset, + values: ["closed_count"], + layout: { x: 8, y: 10, w: 4, h: 2 } + }, + { + id: "top_resolving_articles", + title: "Top Resolving Articles", + description: "Knowledge articles ranked by the closed cases they resolved", + type: "table", + filter: { is_closed: true }, + colorVariant: "default", + dataset, + dimensions: ["resolved_article"], + values: ["kb_resolved_count"], + layout: { x: 0, y: 12, w: 12, h: 4 }, + options: { + sortBy: "kb_resolved_count", + sortOrder: "desc", + limit: 10 + } + }, + // ─── Row 5: My Open Cases by Priority ───────────────────────────── + // A dashboard `table` binds to an analytics cube and aggregates; it cannot + // list individual cases (ADR-0021) — for the case-by-case queue, use the + // my_open_cases ListView ("My Cases" in the My Work nav group). + // `{current_user_id}` scopes what this widget SHOWS; it is presentation + // scope, not an access boundary — row-level security owns that (#510). + { + id: "my_open_cases_by_priority", + title: "My Open Cases by Priority", + description: "Your open cases and their SLA-violation rate, broken down by priority", + type: "table", + filter: { is_closed: false, owner_id: "{current_user_id}" }, + // Opts out of the Agent global filter (keyed by its field, `owner_id`): + // ANDing an agent pick into "mine" empties the widget for anyone else. + filterBindings: { owner_id: false }, + colorVariant: "default", + dataset, + dimensions: ["priority"], + values: ["case_count", "avg_sla_violated"], + layout: { x: 0, y: 16, w: 12, h: 4 }, + options: { + sortBy: "case_count", + sortOrder: "desc", + limit: 10 + } + } + ] +}; + +// src/service/datasets/case.dataset.ts +import { defineDataset } from "@objectstack/spec/ui"; +var CaseDataset = defineDataset({ + name: "case_metrics", + label: "Case Metrics", + description: "Semantic layer for support-case counts, resolution time and SLA", + object: "crm_case", + dimensions: [ + { name: "status", label: "Status", field: "status", type: "string" }, + { name: "priority", label: "Priority", field: "priority", type: "string" }, + { name: "origin", label: "Origin", field: "origin", type: "string" }, + { name: "type", label: "Type", field: "type", type: "string" }, + // The platform's creation stamp (#1992) — the same dimension + // `account_metrics` and `lead_metrics` declare, bucketed by day here. + { name: "created_at", label: "Created", field: "created_at", type: "date", dateGranularity: "day" }, + // Article ranking by resolutions (#601) — group closed cases by the + // article that resolved them. `type: 'lookup'`, the same spelling the + // `owner` dimension on `opportunity_metrics` uses for `owner_id`. + { name: "resolved_article", label: "Resolving Article", field: "resolved_by_article", type: "lookup" } + ], + measures: [ + { name: "case_count", label: "Cases", aggregate: "count" }, + { name: "avg_resolution", label: "Avg Resolution (h)", aggregate: "avg", field: "resolution_time_hours", format: "0.0" }, + { name: "avg_sla_violated", label: "SLA Violation Rate", aggregate: "avg", field: "is_sla_violated", format: "0.0%" }, + // ─── Knowledge deflection (#601) ──────────────────────────────────── + // + // "% of closed cases resolved with an article". Built to the shape + // `opportunity_metrics.win_rate` arrived at the hard way (#593/#614): the + // two halves of the ratio are declared HERE as named measures, once, so no + // widget improvises a denominator — a wrong denominator does not error, it + // returns a plausible number. + // + // Each half carries its OWN `filter`, which the executor runs as a + // sub-query and merges back on the selected dimensions. A widget-level + // filter cannot express this: it would narrow BOTH halves to the same row + // set, which is how you end up dividing a number by itself. + // + // `kb_resolved_count` counts the COLUMN, not the rows: `count()` + // counts non-NULL values, so it needs no `$ne: null` predicate and no + // parallel boolean flag to drift out of step with the lookup. MEASURED on + // 17.0.0-rc.6 against both drivers — the numbers are pinned in + // `test/knowledge-deflection.test.ts`. The one thing it CANNOT discount is + // an empty string, which is non-NULL; that is why the blank is normalised + // to NULL at write time by `case_resolution_article_normalize`, and why + // that hook is part of this metric rather than a tidy-up beside it. + // + // Every widget that shows `kb_deflection_rate` also shows + // `kb_resolved_count` and `closed_count` beside it, so a reader can check + // the arithmetic that produced the percentage. + { name: "closed_count", label: "Closed Cases", aggregate: "count", filter: { is_closed: true } }, + { + name: "kb_resolved_count", + label: "Resolved by KB", + aggregate: "count", + field: "resolved_by_article", + filter: { is_closed: true } + }, + { + name: "kb_deflection_rate", + label: "KB Deflection Rate", + derived: { op: "ratio", of: ["kb_resolved_count", "closed_count"] }, + format: "0%" + }, + // ─── SLA compliance (#1213) ───────────────────────────────────────── + // + // The service dashboard's gauge asks "are we meeting SLA?", so the number + // it plots has to BE compliance. It used to plot `avg_sla_violated` — the + // complement — and ask the renderer to flip it with `options.invert`. That + // key is not declared by `DashboardWidgetOptionsSchema`; it rides the + // schema's `.passthrough()`, so no validator, lint rule or gate could ever + // tell the author it does nothing — and none did. The gauge read 0.0% on + // an org with 100% compliance. + // + // Spelled as a ratio of two counts rather than `1 - avg_sla_violated` + // because `DerivedMeasureOp` operands are MEASURE NAMES only (`of: + // string[]` — "no raw fields, no raw SQL"), so there is no literal `1` to + // subtract from. `difference` cannot express it either. This is the card's + // own second option and the spec's sanctioned shape — the one + // `kb_deflection_rate` above already uses. + // + // `is_sla_violated: false`, not `$ne: true`: the field declares + // `defaultValue: false`, and MEASURED on both drivers this app runs, a + // closed case inserted without the column stores `false` rather than NULL. + // So `sla_met_count + violated = closed_count` holds with no NULL hole. + // Both spellings measured identical (2 of 3, both drivers); the plain one + // is the one that reads as what it means. + // + // The denominator is `closed_count`, already declared above — the same + // measure the `closed_cases_total` tile shows, so a reader can check the + // percentage against a number on the same page. An empty numerator group + // does NOT blank the rate: the executor fills a `count` column's empty + // group with 0 BEFORE evaluating derived measures, so a fully-breached org + // reads 0%, not blank. A zero DENOMINATOR (no closed cases at all) does + // return null — "no data", which is the honest reading. + { name: "sla_met_count", label: "Cases Within SLA", aggregate: "count", filter: { is_closed: true, is_sla_violated: false } }, + { + name: "sla_compliance_rate", + label: "SLA Compliance Rate", + derived: { op: "ratio", of: ["sla_met_count", "closed_count"] }, + format: "0%" + } + ] +}); + +// src/sales/email-templates/_bundle.ts +var bundle = (packs) => Object.entries(packs).flatMap(([locale, pack]) => Object.entries(pack).map(([name, row]) => ({ name, locale, ...row }))); + +// src/service/email-templates/en.ts +var en = { + "crm.case_escalated": { + label: "Case Escalated", + subject: "Case escalated: {{case_number}}", + bodyHtml: "

Case {{case_number}} ({{priority}}) has been auto-escalated on critical priority. Ownership passes to the service manager with the lightest load; while nobody holds that position the case stays with you. Open the case to see who owns it now.

" + }, + "crm.case_sla_breach": { + label: "Case SLA Breached", + subject: "SLA breached: case {{case_number}}", + bodyHtml: "

Case {{case_number}} ({{priority}}) passed its SLA due date and has been auto-escalated.

" + } +}; + +// src/service/email-templates/zh-CN.ts +var zhCN = { + "crm.case_escalated": { + label: "\u5DE5\u5355\u5DF2\u5347\u7EA7", + subject: "\u5DE5\u5355\u5DF2\u5347\u7EA7\uFF1A{{case_number}}", + bodyHtml: "

\u5DE5\u5355 {{case_number}}\uFF08{{priority}}\uFF09\u56E0\u4E25\u91CD\u7EA7\u522B\u5DF2\u81EA\u52A8\u5347\u7EA7\u3002\u6240\u6709\u6743\u5C06\u8F6C\u4EA4\u7ED9\u5F53\u524D\u8D1F\u8377\u6700\u8F7B\u7684\u670D\u52A1\u7ECF\u7406\uFF1B\u82E5\u8BE5\u804C\u4F4D\u6682\u65E0\u4EBA\u62C5\u4EFB\uFF0C\u5DE5\u5355\u4ECD\u5F52\u60A8\u6240\u6709\u3002\u8BF7\u6253\u5F00\u5DE5\u5355\u67E5\u770B\u5F53\u524D\u8D1F\u8D23\u4EBA\u3002

" + }, + "crm.case_sla_breach": { + label: "\u5DE5\u5355 SLA \u8D85\u65F6", + subject: "SLA \u8D85\u65F6\uFF1A\u5DE5\u5355 {{case_number}}", + bodyHtml: "

\u5DE5\u5355 {{case_number}}\uFF08{{priority}}\uFF09\u5DF2\u8D85\u8FC7 SLA \u5230\u671F\u65F6\u95F4\uFF0C\u5E76\u5DF2\u81EA\u52A8\u5347\u7EA7\u3002

" + } +}; + +// src/service/email-templates/ja-JP.ts +var jaJP = { + "crm.case_escalated": { + label: "\u30B1\u30FC\u30B9\u306E\u30A8\u30B9\u30AB\u30EC\u30FC\u30B7\u30E7\u30F3", + subject: "\u30B1\u30FC\u30B9\u304C\u30A8\u30B9\u30AB\u30EC\u30FC\u30B7\u30E7\u30F3\u3055\u308C\u307E\u3057\u305F: {{case_number}}", + bodyHtml: "

\u30B1\u30FC\u30B9 {{case_number}}\uFF08{{priority}}\uFF09\u306F\u91CD\u5927\u5EA6\u304C\u9AD8\u3044\u305F\u3081\u81EA\u52D5\u7684\u306B\u30A8\u30B9\u30AB\u30EC\u30FC\u30B7\u30E7\u30F3\u3055\u308C\u307E\u3057\u305F\u3002\u6240\u6709\u6A29\u306F\u8CA0\u8377\u306E\u6700\u3082\u8EFD\u3044\u30B5\u30FC\u30D3\u30B9\u30DE\u30CD\u30FC\u30B8\u30E3\u30FC\u306B\u79FB\u308A\u307E\u3059\u3002\u305D\u306E\u5F79\u8077\u306B\u8AB0\u3082\u3044\u306A\u3044\u9593\u306F\u3001\u30B1\u30FC\u30B9\u306F\u3042\u306A\u305F\u306E\u307E\u307E\u3067\u3059\u3002\u30B1\u30FC\u30B9\u3092\u958B\u3044\u3066\u73FE\u5728\u306E\u6240\u6709\u8005\u3092\u3054\u78BA\u8A8D\u304F\u3060\u3055\u3044\u3002

" + }, + "crm.case_sla_breach": { + label: "\u30B1\u30FC\u30B9\u306E SLA \u8D85\u904E", + subject: "SLA \u8D85\u904E: \u30B1\u30FC\u30B9 {{case_number}}", + bodyHtml: "

\u30B1\u30FC\u30B9 {{case_number}}\uFF08{{priority}}\uFF09\u306F SLA \u671F\u9650\u3092\u904E\u304E\u305F\u305F\u3081\u3001\u81EA\u52D5\u7684\u306B\u30A8\u30B9\u30AB\u30EC\u30FC\u30B7\u30E7\u30F3\u3055\u308C\u307E\u3057\u305F\u3002

" + } +}; + +// src/service/email-templates/es-ES.ts +var esES = { + "crm.case_escalated": { + label: "Caso escalado", + subject: "Caso escalado: {{case_number}}", + bodyHtml: "

El caso {{case_number}} ({{priority}}) se ha escalado autom\xE1ticamente por prioridad cr\xEDtica. La propiedad pasa al responsable de servicio con menos carga; mientras nadie ocupe ese puesto, el caso sigue siendo tuyo. Abre el caso para ver qui\xE9n lo tiene ahora.

" + }, + "crm.case_sla_breach": { + label: "SLA del caso incumplido", + subject: "SLA incumplido: caso {{case_number}}", + bodyHtml: "

El caso {{case_number}} ({{priority}}) super\xF3 su fecha l\xEDmite de SLA y se ha escalado autom\xE1ticamente.

" + } +}; + +// src/service/email-templates/crm.email-template.ts +var ServiceEmailTemplates = bundle({ + "en-US": en, + "zh-CN": zhCN, + "ja-JP": jaJP, + "es-ES": esES +}); + +// src/service/flows/case-escalation.flow.ts +import { P as P10, cel } from "@objectstack/spec"; +var CaseEscalationFlow = { + name: "case_escalation", + label: "Case Escalation Process", + description: "Automatically escalate high-priority cases", + type: "record_change", + status: "active", + // A record-change flow fired by a SYSTEM write carries no trigger user + // either — the user-less exposure is NOT schedule-only (ADR-0049), and the + // platform's own build-time lint cannot see this shape + // because it is only knowable at run time. Measured on 17.0.0-rc.2: a + // user-less run refuses the very first data node — "[runAs] refusing a data + // operation (object 'crm_case', event 'record-after-update')" — so a case + // raised by the seed loader, an integration, or another runAs:'system' + // flow's write silently keeps its critical priority forever. + // + // Elevating the USER-driven runs too is correct here: escalation is a + // service-level policy, not the writer's own edit. Both data nodes are keyed + // to `{record.id}` — the row that just fired the trigger — so user scope + // buys no restriction that matters, while it does add a failure mode: an + // agent may legitimately raise a case without holding edit rights on the + // escalation lifecycle fields (`is_escalated` / `escalated_date` / `status`). + // This also puts the flow on the same footing as `case_sla_monitor`, which + // performs the same escalation on a schedule under `runAs: 'system'`. + runAs: "system", + variables: [ + { name: "caseId", type: "text", isInput: true, isOutput: false } + ], + nodes: [ + { + // Trigger wiring (7.4): bind to afterUpdate and gate on the critical + // transition. The re-fire guard MUST NOT rely on the boolean + // `is_escalated`: this flow's own escalation write re-triggers + // record-after-update, and on SQLite/libsql a boolean persists as integer + // `1`, so `record.is_escalated != true` is `1 != true` = true — the guard + // never trips and the flow loops forever (it wedged a first-boot seed on + // 2026-07-06). Instead: + // - `escalated_date == null` marks "never escalated" (the escalation write + // stamps it, suppressing the second fire AND any re-escalation when an + // agent later moves the case back to in_progress to work it); + // - the status terms keep the flow off cases already escalated or already + // finished — without them a critical case could never be resolved or + // closed (the flow would yank `status` straight back to `escalated`). + id: "start", + type: "start", + label: "Start", + config: { + objectName: "crm_case", + triggerType: "record-after-update", + // Also suppress on closed/resolved: closing a critical case is itself + // an afterUpdate, and with only the `!= "escalated"` guard this flow + // re-escalated the case the moment it was closed (observed live: + // close_case wrote status "closed", this flow immediately rewrote it + // to "escalated"). Status strings are the reliable guard — comparing + // the boolean is_closed suffers the SQLite `1 != true` trap above. + // `escalated_date == null` additionally keeps a case that was already + // escalated once (then reopened) from being escalated again. + // + // TOTALITY: every `record.x` read carries a `has(record.x)` + // guard — see the house-rule block in + // `test/flow-condition-totality.test.ts`. Measured end-to-end on + // driver-memory: a case BORN critical is stored without an + // `escalated_date` column at all, `record.escalated_date == null` + // aborted with `No such key: escalated_date`, and this flow never ran + // on the very population it exists for. The guards below preserve the + // predicate's answer on every shape where it previously had one. + // `escalated_date` absent means the same as null ("never escalated"); + // an absent `status` cannot be a terminal status, so it must not + // suppress the escalation. + condition: P10`has(record.priority) && record.priority == "critical" + && (!has(record.escalated_date) || record.escalated_date == null) + && (!has(record.status) + || (record.status != "escalated" && record.status != "resolved" && record.status != "closed"))` + } + }, + { + id: "get_case", + type: "get_record", + label: "Get Case Record", + config: { objectName: "crm_case", filter: { id: cel`record.id` }, outputVariable: "caseRecord" } + }, + { + // The `label` names what this node actually does: it flags the case as + // escalated (see `fields` below) and reassigns nothing. The `id` keeps + // its original `assign_senior_agent` spelling on purpose — `edges[]` + // reference nodes by id, and `CaseEscalationOnCreateFlow` rewrites the + // node list by id, so renaming one is a behaviour change, not a wording + // fix. + id: "assign_senior_agent", + type: "update_record", + label: "Flag as Escalated", + config: { + objectName: "crm_case", + filter: { id: cel`record.id` }, + // `escalation_reason` must be set whenever `is_escalated` flips true — the + // object's `escalation_reason_required` validation rejects the write + // otherwise (which silently aborted this flow until it was supplied). + // + // ⛔ This node writes NO owner, and cannot: reassigning from a flow + // would mean `{caseRecord.owner_id.manager}`, and a flow template + // cannot traverse a lookup — it interpolates to the literal "undefined" + // and would orphan the case under a phantom owner. The hand-off does not + // need to happen here: this very update fires the + // `case_escalation_reassign` beforeUpdate hook + // (`src/service/objects/_case-assignment.ts`), which puts the case with the + // least-loaded holder of the flat `service_manager` position — a pool, + // which the app can resolve, rather than a manager chain, which it + // cannot. With that pool unstaffed the case keeps its owner and this + // write is unchanged. + fields: { is_escalated: true, escalation_reason: "Auto-escalated: critical priority", escalated_date: cel`isoDatetime(now())`, status: "escalated" } + } + }, + // No `create_task` node here: the escalation write above flips `status` to + // `escalated`, which fires the `case_status_side_effects` hook — the single + // owner of escalation follow-up tasks (it also covers the `escalate_case` + // action and the SLA monitor). A second task node here produced duplicate, + // disagreeing tasks (case owner/high vs account owner/urgent) per escalation. + { + // Gateway only — the live predicate is on the out-edge `e4`. The engine + // never reads a `decision` node's singular `config.condition`, so a copy + // here would restate the gate without BEING the gate + // (`flow-inert-node-condition`); `pnpm lint` — `os lint --strict` — + // fails on that. + // + // Why the gate exists: `crm_case.owner_id` is NULLABLE and an unowned case + // is an ordinary state — this repo ships `scripts/backfill-owner-id.ts` + // and `pnpm backfill:owner` precisely because ownerless rows happen, and + // ordinary REST creation / import reach the same state. `notify_team` + // below addresses exactly ONE recipient, so an ownerless case leaves it + // with an empty slate, which the builtin node treats as a HARD failure: + // `execute` returns `success: false`, `executeNode` turns that into a + // throw, and the run ends `status: 'failed'`. + // + // BLAST RADIUS, stated precisely because it differs from the sibling + // defect in `case_sla_monitor` and the difference is structural: these two + // are `record_change` flows with NO loop, so one ownerless case kills only + // its OWN run — there is no queue of other records behind it. A `schedule` + // flow whose work sits inside a `loop` awaits `runRegion` with no + // try/catch, and there one ownerless row takes down every record ordered + // behind it. + // + // ⛔ The gate sits AFTER `assign_senior_agent`, which stays + // UNCONDITIONAL: the escalation itself must still land (measured + // `is_escalated: true`, `status: 'escalated'` on every failing run), so an + // ownerless critical case stays visible in views and reports. Only the + // notify is gated — and here that loses nothing a reader would want, + // because `caseRecord` is read by `get_case` UPSTREAM of the escalation + // write, so `{caseRecord.owner_id}` is deliberately the owner the case had + // BEFORE the hand-off. With no such person there is no "previous owner" + // for the message to be addressed to. + // + // ⚠️ This guard is exactly the duplication objectstack#13682 exists to + // retire — `notify` should treat an empty audience as a RECORDED SKIP + // rather than a hard failure. When that lands, delete this node and edge + // `e4`'s predicate here, and the same pair in `case-sla-monitor.flow.ts`. + id: "check_owner", + type: "decision", + label: "Case Has an Owner?" + }, + { + // ADR-0012: the dedicated `notify` node dispatches through the messaging + // service (inbox + email + push). The legacy `script` + `actionType:'email'` + // shape is a no-op stub in 7.4 and never delivered anything. + // Owner only: `{caseRecord.owner_id.manager}` cannot traverse a lookup in + // flow templates — it interpolates to the literal "undefined". + // The `label` names the single recipient this node has (`recipients` + // below); the `id` keeps its `notify_team` spelling because `edges[]` + // reference it. Cf. the same node in `case-sla-monitor.flow.ts`, whose + // label already says `Alert Owner`. + id: "notify_team", + type: "notify", + label: "Notify Case Owner", + config: { + // Owner only, and the owner it reaches is the one the case had BEFORE + // the escalation: `caseRecord` was read by `get_case` upstream of the + // write, so `{caseRecord.owner_id}` is the agent being handed off from + // — exactly the person this message is for. Flow templates cannot + // traverse a lookup (see the note on `assign_senior_agent` above): + // `{caseRecord.owner_id.manager}` and `{caseRecord.crm_account.name}` + // both interpolate to the literal string "undefined" — a phantom + // recipient and a garbled body. + recipients: [cel`caseRecord.owner_id`], + channels: ["inbox", "email"], + severity: "critical", + topic: "case_escalated", + // ⚠️ The body — now `crm.case_escalated` in `../email-templates/`, one + // row per locale — must stay true on BOTH outcomes. "It remains + // assigned to you" is false whenever the hand-off finds a manager; the + // opposite claim ("it has been reassigned") is false whenever the + // `service_manager` pool is unstaffed, which is the first-install norm. + // So it states the rule and points at the record for the answer, in + // every language. + template: "crm.case_escalated", + templateData: { case_number: cel`caseRecord.case_number`, priority: cel`caseRecord.priority` }, + actionUrl: "/crm_case/{{record.id}}" + } + }, + { id: "end", type: "end", label: "End" } + ], + edges: [ + { id: "e1", source: "start", target: "get_case", type: "default" }, + { id: "e2", source: "get_case", target: "assign_senior_agent", type: "default" }, + { id: "e3", source: "assign_senior_agent", target: "check_owner", type: "default" }, + // The gate. A `decision` with no matching out-edge simply ends the run + // here, after the escalation has already been written. + // + // TOTALITY: `caseRecord` is a `get_record` OUTPUT — a raw driver row, sparse + // in the way `driver-memory` / `driver-mongodb` store only the columns a row + // was written with — so only `has()` is total, and it must be `vars.`-scoped + // (measured: bare `has(caseRecord.owner_id)` still aborts with `Unknown + // variable` on an unbound root, while `has(vars.caseRecord)` answers + // `false`). + // + // ⛔ EVERY TERM IS LOAD-BEARING — do not simplify this predicate. The last + // one MIRRORS THE NOTIFY NODE'S OWN emptiness rule rather than guessing at + // it: builtin `notify` builds its audience with `String(v).trim()` + + // `.filter(Boolean)`, so null, undefined, `''` and any all-whitespace value + // all collapse to the same empty slate. Each term was measured through + // `evaluateCondition` on the shape it alone covers, by dropping it and + // recording what the rest do: + // - `has(vars.caseRecord)` — an UNBOUND root. Without it the predicate + // aborts with `No such key: caseRecord`. `get_case` binds the variable + // on every path here (it sets it even when it matched nothing), so this + // term is what keeps a future graph edit from turning a gate into an + // abort — and the `vars.`-scoped `has()` pair is the house rule + // `test/flow-variable-conditions.test.ts` enforces. + // - `has(vars.caseRecord.owner_id)` — the ABSENT key. Without it, + // `vars.caseRecord.owner_id != null` aborts with `No such key: owner_id`. + // - `vars.caseRecord.owner_id != null` — the explicit NULL. Without it the + // wrap is handed one and aborts with `no matching overload for + // 'string(null)'`, so this term must short-circuit in front of it. + // - `string(...).trim() != ""` — the BLANK/whitespace id. `' ' != ""` is + // TRUE in CEL, so a gate written that way opens for a whitespace + // `owner_id` and reproduces this very defect one input narrower. The + // `string()` wrap is not decoration either: measured, a bare `.trim()` + // on a numeric id aborts with `no matching overload for + // 'double.trim()'` and `.matches()` with `'double.matches(string)'` — a + // thrown condition, the fault mode this gate exists to remove. + // + // ⛔ Do NOT add a `vars.caseRecord != null` term for the row that is GONE by + // the time `get_case` reads it. Measured INERT: `get_record` with no match + // sets the variable to `null`, key present, and `has()` on a null base + // answers `false` rather than aborting, so the four terms above already + // close that shape (`test/flow-escalation-ownerless-case.test.ts` covers + // it). A term that cannot change an answer is an inert copy, not defence in + // depth. + { id: "e4", source: "check_owner", target: "notify_team", type: "conditional", condition: P10`has(vars.caseRecord) && has(vars.caseRecord.owner_id) + && vars.caseRecord.owner_id != null && string(vars.caseRecord.owner_id).trim() != ""`, label: "Has owner" }, + { id: "e5", source: "notify_team", target: "end", type: "default" } + ] +}; +var CaseEscalationOnCreateFlow = { + ...CaseEscalationFlow, + name: "case_escalation_on_create", + label: "Case Escalation Process (on create)", + description: "Escalate cases created critical (insert-time twin of case_escalation)", + nodes: CaseEscalationFlow.nodes.map( + (n) => n.id === "start" ? { ...n, config: { ...n.config, triggerType: "record-after-create" } } : n + ) +}; + +// src/service/flows/case-actions.flow.ts +import { cel as cel2 } from "@objectstack/spec"; + +// src/service/objects/_case-assignment.ts +var CLAIMABLE_TARGET_STATUSES = [ + "in_progress", + "waiting_customer", + "waiting_support" +]; +function createCaseRoundRobinAssign(hookName = "case_auto_assign") { + return { + name: hookName, + object: "crm_case", + events: ["beforeInsert"], + priority: 250, + description: "Assign ownerless new cases to the least-loaded service agent.", + handler: async (ctx) => { + const { input } = ctx; + if (typeof input.owner_id === "string" && input.owner_id) return; + const api = ctx.api; + if (!api) return; + try { + const holders = await api.object("sys_user_position").find({ + where: { position: "service_agent" }, + fields: ["user_id"], + top: 1e3 + }); + const agentIds = Array.from( + new Set( + (holders ?? []).map((r) => typeof r.user_id === "string" ? r.user_id : "").filter(Boolean) + ) + ); + if (agentIds.length === 0) return; + let best; + let bestCount = Infinity; + for (const agentId of agentIds) { + const openCount = await api.object("crm_case").count({ + where: { owner_id: agentId, status: { $nin: ["resolved", "closed"] } } + }); + if (openCount < bestCount) { + bestCount = openCount; + best = agentId; + } + } + if (best) input.owner_id = best; + } catch { + } + } + }; +} +function createCaseEscalationReassign(hookName = "case_escalation_reassign") { + return { + name: hookName, + object: "crm_case", + events: ["beforeUpdate"], + priority: 250, + runAs: "system", + description: "Hand a case being escalated to the least-loaded service manager.", + handler: async (ctx) => { + if (ctx.dispatch?.mode === "per-row") return; + const { input } = ctx; + const previous = ctx.previous; + if (!previous) return; + if (input.status !== "escalated" || previous.status === "escalated") return; + if (typeof input.owner_id === "string" && input.owner_id) return; + const api = ctx.api; + if (!api) return; + const organizationId = typeof previous.organization_id === "string" && previous.organization_id !== "" ? previous.organization_id : void 0; + const inOrganization = organizationId ? { organization_id: organizationId } : {}; + try { + const holders = await api.object("sys_user_position").find({ + where: { position: "service_manager", ...inOrganization }, + fields: ["user_id"], + top: 1e3 + }); + const managerIds = Array.from( + new Set( + (holders ?? []).map((r) => typeof r.user_id === "string" ? r.user_id : "").filter(Boolean) + ) + ); + if (managerIds.length === 0) return; + const currentOwner = typeof previous.owner_id === "string" && previous.owner_id || ""; + if (currentOwner && managerIds.indexOf(currentOwner) !== -1) return; + let best; + let bestCount = Infinity; + for (const managerId of managerIds) { + const openCount = await api.object("crm_case").count({ + where: { owner_id: managerId, status: { $nin: ["resolved", "closed"] }, ...inOrganization } + }); + if (openCount < bestCount) { + bestCount = openCount; + best = managerId; + } + } + if (best) input.owner_id = best; + } catch { + } + } + }; +} +function createCaseSelfClaim(hookName = "case_self_claim") { + return { + name: hookName, + object: "crm_case", + events: ["beforeUpdate"], + priority: 260, + description: "Let a user claim an unowned open case by picking it up; the owner written is always the caller.", + handler: async (ctx) => { + if (ctx.dispatch?.mode === "per-row") return; + const { input } = ctx; + const previous = ctx.previous; + if (!previous) return; + const claimant = ctx.user?.id; + if (typeof claimant !== "string" || !claimant) return; + if (ctx.session?.isSystem) return; + if ("owner_id" in input) return; + if (typeof previous.owner_id === "string" && previous.owner_id) return; + if (previous.status === "closed") return; + if (previous.is_closed === true || previous.is_closed === 1) return; + const next = input.status; + if (typeof next !== "string" || next === previous.status) return; + if (next !== "in_progress" && next !== "waiting_customer" && next !== "waiting_support") return; + input.owner_id = claimant; + } + }; +} + +// src/service/flows/case-actions.flow.ts +var EscalateCaseFlow = { + name: "escalate_case", + label: "Escalate Case", + description: "Collect an escalation reason, then flag and re-prioritise the case.", + type: "screen", + status: "active", + variables: [ + // MUST be `recordId` — the console's flow-action contract seeds only that + // name (and its camelCase object alias); a custom name arrives undefined. + { name: "recordId", type: "text", isInput: true, isOutput: false }, + { name: "reason", type: "text", isInput: true, isOutput: false } + ], + nodes: [ + { id: "start", type: "start", label: "Start", config: { objectName: "crm_case" } }, + { + id: "screen_1", + type: "screen", + label: "Escalate Case", + config: { + fields: [ + { name: "reason", label: "Escalation Reason", type: "textarea", required: true } + ] + } + }, + { + // The USER-CONTEXT half of the escalation. Everything here is a + // column the acting agent may legitimately write, so it is written with + // their identity — this flow stays `runAs: 'user'`. + // + // escalation_reason the agent's own screen input + // priority an ordinary editable field + // status ordinary, and the hook trigger (below) + // + // The two stamps a person never types — `is_escalated` and + // `escalated_date` — are `readonly: true` on `crm_case` and are written + // by the `case_escalation_stamp` subflow that follows, with the system + // context. See `src/service/flows/case-escalation-stamp.flow.ts`. + // + // ⚠️ `status: 'escalated'` MUST stay in this node, and not only because + // it is user-writable: it is the trigger both escalation hooks key off — + // `case_escalation_reassign` (`_case-assignment.ts`) gates on + // `input.status !== 'escalated' || previous.status === 'escalated'`, and + // `case_status_side_effects` (`case.hook.ts`) reads the same transition. + // Keeping it here keeps the ownership hand-off and the side-effect tasks + // firing from the ACTING USER's write, exactly as they did before the + // split. Moving it into the elevated subflow would silently re-attribute + // both to the system. + // + // It is also what suppresses a double-fire of the automatic + // `case_escalation` record-change flow. + id: "escalate", + type: "update_record", + label: "Escalate Case", + config: { + objectName: "crm_case", + filter: { id: cel2`recordId` }, + fields: { + escalation_reason: cel2`reason`, + status: "escalated", + priority: "critical" + } + } + }, + { + // The ELEVATED half, and the only elevation in this flow: one + // `runAs: 'system'` flow, one `update_record`, two readonly columns. + // The maintainer-approved direction — elevate the write, not the flow. + // + // ⚠️ THIS NODE MUST RUN AFTER `escalate`, NOT BEFORE. `crm_case`'s + // `escalation_reason_required` validation rejects any write whose merged + // record has `is_escalated == true` and a blank `escalation_reason`. The + // reason is written by the node above, so by the time the flag flips it + // is already stored. Reversing these two nodes fires that validation + // against a record with no reason yet and the stamp is rejected. + // + // ⛔ Do not "simplify" this by giving THIS flow `runAs: 'system'` and + // folding the stamp back into the node above. That is option A, costed + // and explicitly not adopted: it elevates every write this screen flow + // makes and stops it carrying the acting user's context downstream. + // `AGENTS.md` house rule 9 states it as standing policy. + id: "stamp_escalation", + type: "subflow", + label: "Stamp Escalation Flags", + config: { + flowName: "case_escalation_stamp", + input: { recordId: cel2`recordId` } + } + }, + { id: "end", type: "end", label: "End" } + ], + edges: [ + { id: "e1", source: "start", target: "screen_1", type: "default" }, + { id: "e2", source: "screen_1", target: "escalate", type: "default" }, + { id: "e3", source: "escalate", target: "stamp_escalation", type: "default" }, + { id: "e4", source: "stamp_escalation", target: "end", type: "default" } + ] +}; +var CloseCaseFlow = { + name: "close_case", + label: "Close Case", + description: "Collect the resolution, then close the case and stop the SLA clock.", + type: "screen", + status: "active", + // `is_closed` is a readonly lifecycle field. This trusted screen flow owns + // the transition and must therefore run with the system writer. + // + // ⛔ A HISTORICAL PRECEDENT, NOT A POLICY — do not cite this line to justify + // elevating another screen flow (#1434, the maintainer ruling that settled + // it). The standing rule is the opposite one: a screen flow stays + // `runAs: 'user'` and a write that genuinely needs elevation is split into a + // dedicated `system` sub-flow reached by a `subflow` node — see + // `escalate_case` above and `src/service/flows/case-escalation-stamp.flow.ts`. + // "Readonly stripped my write, so I made the flow system" is the pattern + // that ruling exists to stop being copied; `AGENTS.md` house rule 9 carries + // it as house policy. This flow predates that rule and has not been + // re-shaped to match it. + runAs: "system", + variables: [ + { name: "recordId", type: "text", isInput: true, isOutput: false }, + { name: "resolution", type: "text", isInput: true, isOutput: false }, + { name: "resolved_by_article", type: "text", isInput: true, isOutput: false } + ], + nodes: [ + { id: "start", type: "start", label: "Start", config: { objectName: "crm_case" } }, + { + // The "attach the article that resolved it" affordance. Optional + // on purpose: most cases are not resolved out of the knowledge base, and + // a required field here would be answered with a junk value rather than + // left honest — which is worse than an absent link for a measure whose + // whole job is to say how OFTEN the KB resolves a case. + // + // `reference` names the object the picker offers. Up to + // `@objectstack/spec@17.4.0` a screen field had no such key, so this + // `type: 'lookup'` field had nothing to resolve a record picker from; + // 17.5.0 added `reference` to `ScreenFieldConfigSchema` and made it + // REQUIRED on a lookup screen field (#17913) — the stack does not load + // without it. It is the same target the case's own `resolved_by_article` + // lookup declares (`crm_knowledge_article`). + // + // The `Resolved by Article` lookup in the case's Resolution group, on the + // record form, writes the same column; the action is + // `refreshAfter: true`, so the record form is what the agent lands on + // immediately after closing. + id: "screen_1", + type: "screen", + label: "Close Case", + config: { + fields: [ + { name: "resolution", label: "Resolution", type: "textarea", required: true }, + { + name: "resolved_by_article", + label: "Resolved by Article (optional)", + type: "lookup", + reference: "crm_knowledge_article", + required: false + } + ] + } + }, + { + // `resolved_by_article` is written unconditionally, and a blank one is + // normalised to NULL by `case_resolution_article_normalize` + // (`src/service/objects/case.hook.ts`) rather than branched around here: MEASURED + // on the real engine, a screen field left empty resumes as `''` and lands + // as an empty string, which `count(resolved_by_article)` counts. A + // `decision` node could not have branched it either — this repo has + // measured `decision.config.condition` to be inert metadata + // (`test/win-loss-capture.test.ts`'s table of five such surfaces). + // + // The read is guarded because the field is optional: a resume that omits + // it leaves the variable unbound, which the 17.x template wrote as nothing + // (the stored link left alone) and CEL refuses. The guard writes NULL + // there — the value a blank field already lands as after the normalize + // hook — so an omitted answer and an empty one now close the case alike. + id: "close", + type: "update_record", + label: "Close Case", + config: { + objectName: "crm_case", + filter: { id: cel2`recordId` }, + fields: { + is_closed: true, + resolution: cel2`resolution`, + status: "closed", + resolved_by_article: cel2`has(vars.resolved_by_article) ? resolved_by_article : null` + } + } + }, + { id: "end", type: "end", label: "End" } + ], + edges: [ + { id: "e1", source: "start", target: "screen_1", type: "default" }, + { id: "e2", source: "screen_1", target: "close", type: "default" }, + { id: "e3", source: "close", target: "end", type: "default" } + ] +}; +var CLAIM_STATUS_LABEL = { + in_progress: "In Progress", + waiting_customer: "Waiting on Customer", + waiting_support: "Waiting on Support" +}; +var CLAIM_STATUS_OPTIONS = CLAIMABLE_TARGET_STATUSES.map((value) => ({ + value, + label: CLAIM_STATUS_LABEL[value] +})); +var ClaimCaseFlow = { + name: "claim_case", + label: "Claim Case", + description: "Take an unowned case out of triage by moving it to a status that means you are on it.", + type: "screen", + status: "active", + // Load-bearing, not boilerplate — see the header. A system run claims nobody. + runAs: "user", + variables: [ + // MUST be `recordId` — the console's flow-action contract seeds only that + // name (and its camelCase object alias); a custom name arrives undefined. + { name: "recordId", type: "text", isInput: true, isOutput: false }, + { name: "claimStatus", type: "text", isInput: true, isOutput: false } + ], + nodes: [ + { id: "start", type: "start", label: "Start", config: { objectName: "crm_case" } }, + { + id: "screen_1", + type: "screen", + label: "Claim Case", + config: { + fields: [ + { + name: "claimStatus", + label: "Working status", + type: "select", + required: true, + defaultValue: "in_progress", + options: CLAIM_STATUS_OPTIONS + } + ] + } + }, + { + // ⛔ `status` is the ONLY field this node may ever carry. Adding + // `owner_id` here does not "make the claim explicit" — it makes the write + // refused by the transfer gate before any hook runs, and it takes + // `case_self_claim` out of the path on the one caller it would reach. + // The guard beside this file fails on any such addition. + id: "claim", + type: "update_record", + label: "Claim Case", + config: { + objectName: "crm_case", + filter: { id: cel2`recordId` }, + fields: { + status: cel2`claimStatus` + } + } + }, + { id: "end", type: "end", label: "End" } + ], + edges: [ + { id: "e1", source: "start", target: "screen_1", type: "default" }, + { id: "e2", source: "screen_1", target: "claim", type: "default" }, + { id: "e3", source: "claim", target: "end", type: "default" } + ] +}; + +// src/service/flows/case-escalation-stamp.flow.ts +import { cel as cel3 } from "@objectstack/spec"; +var CaseEscalationStampFlow = { + name: "case_escalation_stamp", + label: "Stamp Case Escalation", + description: "Write the two readonly escalation stamps (is_escalated, escalated_date) with the system context. Called by escalate_case through a subflow node.", + type: "autolaunched", + status: "active", + // ⭐ THE ENTIRE POINT OF THIS FILE. This is the only elevation in the + // escalate path, and it covers exactly one `update_record` node. + runAs: "system", + variables: [ + // Supplied by the caller's `subflow` node, whose `input` envelope reads its own `recordId`. + { name: "recordId", type: "text", isInput: true, isOutput: false } + ], + nodes: [ + // `config: {}` matches the shape measured in + // `test/readonly-write-semantics.test.ts`: an autolaunched callee is handed + // its params by the `subflow` executor and resolves no trigger record of + // its own, so there is no `objectName` for the start node to load. + { id: "start", type: "start", label: "Start", config: {} }, + { + id: "stamp", + type: "update_record", + label: "Stamp Escalation Flags", + config: { + objectName: "crm_case", + filter: { id: cel3`recordId` }, + // ⛔ Do not add fields here. Every column in this node is written with + // the elevated context; anything a user can legitimately type belongs + // in `escalate_case` instead. + fields: { + is_escalated: true, + escalated_date: cel3`isoDatetime(now())` + } + } + }, + { id: "end", type: "end", label: "End" } + ], + edges: [ + { id: "e1", source: "start", target: "stamp", type: "default" }, + { id: "e2", source: "stamp", target: "end", type: "default" } + ] +}; + +// src/service/flows/case-sla-monitor.flow.ts +import { P as P11, cel as cel4 } from "@objectstack/spec"; + +// src/sales/flows/_guarded-iteration.ts +var guarded = (key, region) => ({ + nodes: [{ + id: `guard_${key}`, + type: "try_catch", + label: "Guarded Iteration", + config: { + try: region, + catch: { nodes: [{ id: `handled_${key}`, type: "assignment", label: "Skip This Item" }] } + } + }] +}); + +// src/service/flows/case-sla-monitor.flow.ts +var CASE_HAS_OWNER = () => P11`has(vars.currentCase) && has(vars.currentCase.owner_id) + && vars.currentCase.owner_id != null && string(vars.currentCase.owner_id).trim() != ""`; +var CASE_HAS_NO_OWNER = () => P11`has(vars.currentCase) && (!has(vars.currentCase.owner_id) + || vars.currentCase.owner_id == null || string(vars.currentCase.owner_id).trim() == "")`; +var CaseSlaMonitorFlow = { + name: "case_sla_monitor", + label: "Case SLA Monitor", + description: "Hourly sweep: flag and escalate open cases that have breached their SLA due date.", + type: "schedule", + status: "active", + // Scheduled runs have no trigger user, so under the default runAs:'user' the + // data nodes execute UNSCOPED anyway. Declare runAs:'system' to make that + // RLS-bypassing elevation explicit and intended (ADR-0049). + runAs: "system", + variables: [], + nodes: [ + { id: "start", type: "start", label: "Start (hourly)", config: { schedule: "0 * * * *" } }, + { + id: "query_breached", + type: "get_record", + label: "Find Breached Cases", + config: { + objectName: "crm_case", + // ⛔ `$nin` on `status`, never `is_closed: false`: a case in `resolved` + // has met its SLA — work is finished — but `is_closed` only flips on + // `closed`, so the boolean filter stamps false breaches on resolved + // cases and drags them back to `escalated`. + // + // `$lt` is `caseSlaBreached` (`src/service/objects/_case-sla.ts`) read + // with "now" as the instant: STRICTLY past due. Its other half is + // `case_sla_defaults`, which applies the same rule on the write that + // settles a case — so a case settled late is flagged even when this + // sweep never reached it, or never runs (#2070). + // + // "Now" is the query engine's own `{now}` placeholder, which an + // 18.0.0-next.0 filter operand leaves to the engine as written. It + // renders the instant's ISO text, as the retired `{NOW()}` flow token + // did, and it is the spelling the SLA Violations tile reads, so the + // sweep and the tile say "past due" in one wording. + filter: { + status: { $nin: ["resolved", "closed"] }, + is_sla_violated: false, + sla_due_date: { $lt: "{now}" } + }, + limit: 500, + outputVariable: "caseList" + } + }, + { + id: "loop_cases", + type: "loop", + label: "For Each Breached Case", + config: { + collection: cel4`caseList`, + iteratorVariable: "currentCase", + body: guarded("case", { + nodes: [ + { + id: "flag_breach", + type: "update_record", + label: "Flag SLA Breach", + config: { + objectName: "crm_case", + filter: { id: cel4`currentCase.id` }, + // `escalation_reason` must accompany `is_escalated: true` — the + // object's `escalation_reason_required` validation (severity: + // error) rejects the whole write otherwise, turning this sweep + // into a silent no-op (cf. the same fix in case_escalation). + fields: { + is_sla_violated: true, + is_escalated: true, + status: "escalated", + escalated_date: cel4`isoDatetime(now())`, + escalation_reason: "Auto-escalated: SLA due date breached" + } + } + }, + { + // Gateway only — the predicate lives on the out-edge. + // + // `crm_case.owner_id` is NULLABLE and an unowned case is an + // ordinary state (this repo ships `scripts/backfill-owner-id.ts` / + // `pnpm backfill:owner` precisely because ownerless rows happen; + // ordinary REST creation and import reach it too). The `notify` + // node below addresses exactly one recipient, so an ownerless case + // left it with an empty slate — which the builtin node treats as a + // HARD failure, and that failure is not scoped to the one case: + // `executeNode` throws, `runRegion` rethrows, and the `loop` node + // awaits it with no try/catch, so the whole sweep died on the + // ownerless row and every breached case ORDERED BEHIND IT was + // never even flagged. Measured, not assumed — see + // `test/flow-sla-ownerless-case.test.ts`. + // + // The gate sits AFTER `flag_breach` on purpose. `flag_breach` is + // unconditional, so an ownerless breach is still RECORDED on the + // record — visible in views and reports, where a service manager + // finds it. Gating both would trade a dead run for a silently + // dropped alert on exactly the cases most likely to be neglected. + // + // The ownerless branch is not a dead end: it goes to + // `reload_case`, because by the time the gate is reached the + // sweep's own write may ALREADY HAVE GIVEN THE CASE AN OWNER — + // see that node (maintainer ruling 2026-09-03, option C). + id: "check_owner", + type: "decision", + label: "Case Has an Owner?" + }, + { + // Re-read the case the sweep just wrote. + // + // ⚠️ THE ASSIGNMENT IS NOT AUTHORED HERE, AND MUST NOT BE. + // `flag_breach` writes `status: 'escalated'`, and that IS the + // escalation transition `case_escalation_reassign` + // (`src/service/objects/_case-assignment.ts`, `beforeUpdate`, priority + // 250) fires on: it stamps the least-loaded holder of the + // `service_manager` position onto the payload of the update + // already in flight. So the sweep does not need a seam to "call" + // the assignment — performing the transition IS putting the case + // through it, and the app keeps ONE answer to "who should own + // this case" instead of a flow-shaped second implementation of + // least-loaded balancing. + // + // MEASURED, not assumed (`test/flow-sla-ownerless-case.test.ts` + // drives the real flow, the real engine and the real hooks): with + // a staffed pool an ownerless breached case comes back owned; with + // an empty pool the hook stands down and the case comes back + // ownerless. No second write, no re-entry, no loop — the hook + // mutates the in-flight payload and issues no operation of its + // own. + // + // ⛔ The READ is what this node is for, not a second write: + // `currentCase` is the loop item bound by `query_breached` BEFORE + // `flag_breach` ran, so the owner the sweep just assigned is + // invisible to it and `{currentCase.owner_id}` addresses the + // pre-write state. Re-binding the SAME variable is what makes the + // rest of the iteration — the gate below and the notify node's + // whole template — read the case as it now stands, with no second + // notify node to keep in step. + // + // No `limit`: `get_record` calls `findOne` at or below 1 and binds + // the single row itself, which is what `{currentCase.}` + // needs. A miss binds `null` — `get_record` always binds — which + // `check_assigned` below is there to read. + id: "reload_case", + type: "get_record", + label: "Re-read Case After Escalation", + config: { + objectName: "crm_case", + filter: { id: cel4`currentCase.id` }, + outputVariable: "currentCase" + } + }, + { + // Gateway only — the predicate lives on the out-edge. + // + // The ruled empty-pool clause, as a gate rather than a failure: + // when the `service_manager` pool resolves empty the hook assigns + // nobody, the re-read case is still ownerless, no edge matches and + // the iteration ends. The breach stays on the record and in the + // run summary, the notification is skipped at a NAMED gate, and + // the run survives. ⛔ No hard failure, no fallback recipient, no + // manager-chain dot-walk. + id: "check_assigned", + type: "decision", + label: "Escalation Found an Owner?" + }, + { + // Owner only: `{currentCase.owner_id.manager}` cannot traverse a + // lookup in flow templates — it interpolates to the literal + // "undefined" (cf. case_escalation / opportunity_won_alert). + // + // Reached from BOTH gates, and the whole template reads + // `currentCase` either way: on the owned branch that is the row + // `query_breached` bound, on the ownerless branch the row + // `reload_case` re-bound. One node, one wording, one recipient + // rule — a second notify node would be the same alert authored + // twice, free to drift on the half nobody is looking at. + // + // ⚠️ THE RECIPIENT IS RULED, NOT INCIDENTAL — #1535, maintainer + // ruling 2026-09-07, option A. On a breached + // case that ALREADY HAS AN OWNER, `flag_breach` writes + // `status: 'escalated'` and `case_escalation_reassign` hands the + // case to the least-loaded `service_manager` inside that same + // write — yet this node addresses `currentCase` as + // `query_breached` bound it, BEFORE the hand-off. So the breach + // alert deliberately reaches the agent the case is being taken + // FROM, not the manager who now owns it. + // + // It is the SAME etiquette `case_escalation` already states in + // `content/docs/service/sla-and-escalation.mdx` — "the + // notification goes to the previous owner alone" — and that page + // now states it for this sweep too. One escalation etiquette + // across both mechanisms. + // + // ⛔ Do not "fix" this into an alert for the new owner. That is + // option C, and it would have to re-rule `case_escalation` in the + // same stroke — ⛔ never one mechanism only. + // + // `test/flow-sla-ownerless-assignment.test.ts` pins the pairing + // (the owned breach IS handed over AND its alert still goes to + // the pre-hand-off owner), and records the ruling's declared gap + // as measured: the hand-off hook issues no notice of its own, so + // the receiving manager is told nothing by this run. + id: "notify_team", + type: "notify", + label: "Alert Owner", + config: { + // Owner only — `{currentCase.owner_id.manager}` dot-walks a + // lookup, which flow templates interpolate as "undefined". + recipients: [cel4`currentCase.owner_id`], + channels: ["inbox", "email"], + severity: "critical", + topic: "case_sla_breach", + template: "crm.case_sla_breach", + templateData: { + case_number: cel4`currentCase.case_number`, + priority: cel4`currentCase.priority` + }, + actionUrl: "/crm_case/{{currentCase.id}}" + } + } + ], + edges: [ + { id: "b1", source: "flag_breach", target: "check_owner", type: "default" }, + // The two out-edges of `check_owner` are an exact PARTITION of the + // cases where `currentCase` is bound (see {@link CASE_HAS_OWNER} / + // {@link CASE_HAS_NO_OWNER}) — never a `default` edge alongside a + // conditional one, which would traverse BOTH and notify twice. + // + // ⚠️ The owned branch reads `currentCase` as `query_breached` bound + // it, deliberately: a case that already had an + // owner keeps alerting THAT owner, which is what the sweep has + // always done. ⚠️ That is RULED intent now, no longer an open + // question — the `notify_team` node carries the ruling. + { id: "b2", source: "check_owner", target: "notify_team", type: "conditional", condition: CASE_HAS_OWNER(), label: "Has owner" }, + { id: "b3", source: "check_owner", target: "reload_case", type: "conditional", condition: CASE_HAS_NO_OWNER(), label: "No owner \u2014 re-read after escalation" }, + { id: "b4", source: "reload_case", target: "check_assigned", type: "default" }, + // Both branches converge on the ONE notify node, which is why the + // re-read re-binds `currentCase` rather than a second variable: the + // recipient, the title, the message and the action URL are authored + // once and cannot drift into two versions of the same alert. + // + // A gate with no matching edge simply ends the iteration, so an + // ownerless case the pool could not place is skipped and the loop + // moves on to the next breached case — the run survives, which is + // the property this flow was repaired for. + { id: "b5", source: "check_assigned", target: "notify_team", type: "conditional", condition: CASE_HAS_OWNER(), label: "Escalation assigned an owner" } + ] + }) + } + }, + { id: "end", type: "end", label: "End" } + ], + edges: [ + { id: "e1", source: "start", target: "query_breached", type: "default" }, + { id: "e2", source: "query_breached", target: "loop_cases", type: "default" }, + { id: "e3", source: "loop_cases", target: "end", type: "default" } + ] +}; + +// src/service/objects/article_feedback.hook.ts +var articleFeedbackMetricsRefresh = { + name: "article_feedback_metrics_refresh", + object: "crm_article_feedback", + events: ["afterInsert", "afterUpdate", "afterDelete"], + priority: 800, + async: true, + onError: "log", + runAs: "system", + description: "Recount an article\u2019s helpful / not-helpful votes from crm_article_feedback.", + handler: async (ctx) => { + const api = ctx.api; + if (!api) return; + const { input } = ctx; + const previous = ctx.previous; + const articleIds = Array.from(new Set([ + typeof input?.crm_knowledge_article === "string" ? input.crm_knowledge_article : "", + typeof previous?.crm_knowledge_article === "string" ? previous.crm_knowledge_article : "" + ].filter(Boolean))); + for (const id of articleIds) { + const helpful = await api.object("crm_article_feedback").count({ + where: { crm_knowledge_article: id, verdict: "helpful" } + }); + const notHelpful = await api.object("crm_article_feedback").count({ + where: { crm_knowledge_article: id, verdict: "not_helpful" } + }); + await api.object("crm_knowledge_article").update({ + id, + helpful_count: helpful, + not_helpful_count: notHelpful + }, { where: { id } }); + } + } +}; +var article_feedback_hook_default = [articleFeedbackMetricsRefresh]; + +// src/service/objects/case.hook.ts +var caseValidation = { + name: "case_sla_defaults", + object: "crm_case", + events: ["beforeInsert", "beforeUpdate"], + priority: 200, + description: "Apply the priority \xD7 account-tier SLA matrix and the case lifecycle defaults.", + handler: async (ctx) => { + if (ctx.event === "beforeUpdate" && ctx.dispatch?.mode === "per-row") return; + const { input } = ctx; + const api = ctx.api; + const isGuestSubmission = !ctx.previous && !ctx.user?.id && !ctx.session?.isSystem; + if (isGuestSubmission) { + if (!input.origin) input.origin = "web"; + if (!input.status) input.status = "new"; + input.owner_id = null; + input.is_escalated = false; + input.escalation_reason = null; + input.internal_notes = null; + input.resolution = null; + } + const priority = typeof input.priority === "string" && input.priority || typeof ctx.previous?.priority === "string" && ctx.previous.priority || void 0; + if (priority) { + const rank = { low: 1, medium: 2, high: 3, critical: 4 }; + input.priority_rank = rank[priority] ?? 0; + } + if (priority && !input.sla_due_date && !ctx.previous?.sla_due_date) { + const slaCalendarHours = { + critical: { strategic: 4, enterprise: 4, mid_market: 4, smb: 4 }, + high: { strategic: 6, enterprise: 8, mid_market: 8, smb: 8 }, + medium: { strategic: 24, enterprise: 36, mid_market: 48, smb: 48 }, + low: { strategic: 96, enterprise: 120, mid_market: 168, smb: 168 } + }; + const DEFAULT_TIER = "smb"; + const row = slaCalendarHours[priority]; + if (row) { + let tier = DEFAULT_TIER; + const variesByTier = row.strategic !== row.enterprise || row.enterprise !== row.mid_market || row.mid_market !== row.smb; + const accountId = typeof input.crm_account === "string" && input.crm_account || typeof ctx.previous?.crm_account === "string" && ctx.previous.crm_account || void 0; + if (variesByTier && accountId && api) { + try { + const found = await api.object("crm_account").find({ + where: { id: accountId }, + fields: ["tier"], + top: 1 + }); + const rows = Array.isArray(found) ? found : []; + const stored = rows.length ? rows[0].tier : void 0; + if (typeof stored === "string" && stored) tier = stored; + } catch { + } + } + const hours = row[tier] ?? row[DEFAULT_TIER]; + input.sla_due_date = new Date(Date.now() + hours * 36e5).toISOString(); + } + } + const effStatus = typeof input.status === "string" && input.status || typeof ctx.previous?.status === "string" && ctx.previous.status || void 0; + if (typeof effStatus === "string") input.is_closed = effStatus === "closed"; + if (!isGuestSubmission) { + const becameClosed = input.status === "closed" && ctx.previous?.status !== "closed"; + if (becameClosed && !input.closed_date && !ctx.previous?.closed_date) { + input.closed_date = (/* @__PURE__ */ new Date()).toISOString(); + } + const closedDate = typeof input.closed_date === "string" && input.closed_date || typeof ctx.previous?.closed_date === "string" && ctx.previous.closed_date || void 0; + const createdDate = typeof input.created_at === "string" && input.created_at || typeof ctx.previous?.created_at === "string" && ctx.previous.created_at || void 0; + if (closedDate && createdDate) { + const hrs = (new Date(closedDate).getTime() - new Date(createdDate).getTime()) / 36e5; + if (Number.isFinite(hrs) && hrs >= 0) input.resolution_time_hours = Math.round(hrs * 10) / 10; + } + const settledStatuses = ["resolved", "closed"]; + if (settledStatuses.includes(String(effStatus)) && !settledStatuses.includes(String(ctx.previous?.status))) { + const due = input.sla_due_date !== void 0 ? input.sla_due_date : ctx.previous?.sla_due_date; + const stoppedAt = typeof input.closed_date === "string" && input.closed_date || (/* @__PURE__ */ new Date()).toISOString(); + if (typeof due === "string" && Date.parse(due) < Date.parse(stoppedAt)) input.is_sla_violated = true; + } + } + } +}; +var caseSideEffects = { + name: "case_status_side_effects", + object: "crm_case", + events: ["afterUpdate"], + priority: 800, + async: true, + onError: "log", + description: "Open the escalation follow-up task for the account owner.", + handler: async (ctx) => { + const { input } = ctx; + const previous = ctx.previous; + if (!previous) return; + const api = ctx.api; + if (!api) return; + const caseId = typeof input.id === "string" && input.id || (typeof previous.id === "string" ? previous.id : void 0); + const accountId = typeof input.crm_account === "string" && input.crm_account || typeof previous.crm_account === "string" && previous.crm_account || void 0; + if (input.status === "escalated" && previous.status !== "escalated" && accountId) { + const account = await api.object("crm_account").findOne({ where: { id: accountId } }); + const ownerId = account?.owner_id ?? ctx.user?.id; + const due = /* @__PURE__ */ new Date(); + due.setUTCDate(due.getUTCDate() + 1); + const caseNumber = typeof previous.case_number === "string" ? previous.case_number.trim() : ""; + const caseSubject = typeof input.subject === "string" && input.subject.trim() || typeof previous.subject === "string" && previous.subject.trim() || ""; + const label = [caseNumber, caseSubject].filter(Boolean).join(" \xB7 "); + const titled = label ? `Escalated: ${label}` : "Escalated case needs attention"; + await api.object("crm_task").insert({ + subject: titled.length > 255 ? `${titled.slice(0, 254)}\u2026` : titled, + status: "not_started", + priority: "urgent", + type: "follow_up", + due_date: due.toISOString().slice(0, 10), + owner_id: ownerId, + related_to_type: "crm_case", + related_to_case: caseId, + related_to_account: accountId + }); + } + } +}; +var caseResolutionAccountActivity = { + name: "case_resolution_account_activity", + object: "crm_case", + events: ["afterUpdate"], + priority: 800, + async: true, + onError: "log", + runAs: "system", + description: "Bump the account\u2019s last activity date when a case is resolved.", + handler: async (ctx) => { + const { input } = ctx; + const previous = ctx.previous; + if (!previous) return; + if (input.status !== "resolved" || previous.status === "resolved") return; + const api = ctx.api; + if (!api) return; + const accountId = typeof input.crm_account === "string" && input.crm_account || typeof previous.crm_account === "string" && previous.crm_account || void 0; + if (!accountId) return; + await api.object("crm_account").update( + { id: accountId, last_activity_date: (/* @__PURE__ */ new Date()).toISOString().slice(0, 10) }, + { where: { id: accountId } } + ); + } +}; +var caseAutoAssign = createCaseRoundRobinAssign(); +var caseEscalationReassign = createCaseEscalationReassign(); +var caseSelfClaim = createCaseSelfClaim(); +var caseResolutionArticleNormalize = { + name: "case_resolution_article_normalize", + object: "crm_case", + events: ["beforeInsert", "beforeUpdate"], + priority: 150, + description: "Normalise a blank resolved_by_article to null so the deflection measure counts only real links.", + handler: async (ctx) => { + const { input } = ctx; + if (!("resolved_by_article" in input)) return; + const value = input.resolved_by_article; + if (value === "" || value === void 0) { + input.resolved_by_article = null; + return; + } + if (typeof value === "string" && value.trim() === "") { + input.resolved_by_article = null; + } + } +}; +var case_hook_default = [ + caseValidation, + caseAutoAssign, + caseEscalationReassign, + caseSelfClaim, + caseResolutionArticleNormalize, + caseSideEffects, + caseResolutionAccountActivity +]; + +// src/service/objects/knowledge_article.hook.ts +var knowledgeArticlePublish = { + name: "knowledge_article_publish_timestamps", + object: "crm_knowledge_article", + events: ["beforeInsert", "beforeUpdate"], + priority: 300, + description: "Stamp published_at on the first publish; refresh last_reviewed_at while published.", + handler: async (ctx) => { + if (ctx.event === "beforeUpdate" && ctx.dispatch?.mode === "per-row") return; + const { input } = ctx; + const previous = ctx.previous; + const nextStatus = typeof input.status === "string" && input.status || previous?.status; + if (nextStatus !== "published") return; + const nowIso = (/* @__PURE__ */ new Date()).toISOString(); + input.last_reviewed_at = nowIso; + const existing = input.published_at ?? previous?.published_at; + if (existing === void 0 || existing === null || existing === "") { + input.published_at = nowIso; + } + } +}; +var knowledge_article_hook_default = knowledgeArticlePublish; + +// src/service/pages/case_detail.page.ts +var CaseDetailPage = { + name: "case_detail_page", + label: "Case Detail", + description: "Service-agent case record: highlights, SLA path, details and activity timeline.", + type: "record", + object: "crm_case", + template: "full-width", + kind: "full", + variables: [ + { name: "activeTab", type: "string", defaultValue: "details" } + ], + regions: [ + { + name: "header", + width: "full", + components: [ + { + type: "page:header", + id: "case_header", + label: "Case Information", + properties: { + title: "{case_number} \xB7 {subject}", + // The lookup field is `crm_account` — `{account}` matched nothing + // and the subtitle rendered blank. + subtitle: "{crm_account}", + // `icon` removed from `page:header` in @objectstack/spec 17.0.0 + // (#6946, ADR-0087 D2) — deleted, not renamed. See the full note on + // `account_detail.page.ts`; nothing ever drew it. + // `breadcrumb` retired from `page:header` in @objectstack/spec 17.6.0 + // (#20785, `page-header-breadcrumb-removed`) — deleted: no renderer + // ever drew a trail for it; the app shell's own trail is unchanged. + // Action IDs, not `ActionDef` objects: `PageHeaderProps.actions` is + // `z.array(z.string())` ("Action IDs to show in header") in + // @objectstack/spec 17.3.0, and this repo authors against the + // protocol (#1653). Each id is the `name` of a crm_case-scoped + // action — `claim_case` / `escalate_case` / `close_case` in + // `src/service/actions/case.actions.ts`, the activity trio in + // `src/service/actions/case-activity.actions.ts`. + // + // This list is the whole header (#2072, the #592 sentence on + // `lead_detail.page.ts`): an action it does not name is reachable + // only from the list row's ⋮ menu, which is how an agent on an + // unowned case had to go back to the list to claim it, and could + // not log or book a meeting here at all. Each action's own + // `visible` still decides when it shows — `claim_case` only on an + // ownerless open case. `claim_case` goes FIRST because the header + // draws three buttons inline and folds the rest into ⋯: on an + // ownerless case claiming is the gesture, and on an owned one it + // is hidden, so the inline three stay escalate / close / call. + // `test/action-references.test.ts` holds this list to every + // crm_case action placed at `record_header`. + actions: ["claim_case", "escalate_case", "close_case", "log_call", "log_meeting", "schedule_meeting"] + } + }, + { + type: "record:highlights", + id: "case_highlights", + label: "Key Information", + properties: { + // crm_case carries a single `sla_due_date` plus the derived + // `is_sla_violated` flag — the split response/resolution deadlines + // named here do not exist, so the agent's most time-critical fact + // was missing from the strip entirely. + fields: [ + "status", + "priority", + "sla_due_date", + "is_sla_violated", + "owner_id", + "crm_account" + ] + } + }, + { + type: "record:path", + id: "case_status_path", + label: "Case Status Path", + properties: { + statusField: "status", + stages: [ + { value: "new", label: "New" }, + { value: "in_progress", label: "In Progress" }, + // The status option is `waiting_customer`; the longer spelling + // matched no option, so this stage never lit up and rendered + // untranslated next to its neighbours. + { value: "waiting_customer", label: "Waiting on Customer" }, + { value: "escalated", label: "Escalated" }, + { value: "resolved", label: "Resolved" }, + { value: "closed", label: "Closed" } + ] + } + } + ] + }, + { + name: "main", + width: "large", + components: [ + { + type: "page:tabs", + id: "case_main_tabs", + properties: { + // `type` → `tabStyle` (@objectstack/spec 17.0.0, #6776, ADR-0087 + // D2). Same concept, same three values (`line` | `card` | `pill`); + // the rename exists because a props key called `type` collides with + // the component node's own dispatch key and is unauthorable in the + // flat and JSX carriers. See the full note on `home.page.ts`. + tabStyle: "line", + position: "top", + items: [ + { + // Tab item `key` → `value` (#1269). `value` is the stable + // `?tab=` URL token the renderer reads (`it.value`, falling back + // to an index-derived `tab-`); `key` is read by nothing, so + // these tabs were addressable only as `tab-0`/`tab-1`/`tab-2`, + // which point at different tabs the moment the item list + // changes. `PageTabsProps`' own alias table answers `key` with + // `value` for exactly this reason. + value: "details", + label: "Details", + children: [ + { + type: "record:details", + id: "case_details", + label: "Case Details", + properties: { + // `columns` is a STRING enum ('1'|'2'|'3'|'4') in + // @objectstack/spec 17, and `layout` was removed there + // (#6946 / ADR-0087 D2). + columns: "2", + // Every section references one of crm_case's `fieldGroups` + // (#970, the #806 class ruling C): the renderer derives + // members, label, icon and collapse state from the object, + // so this page curates only the order. The full note — + // what a group section does on 17.6.0 and what may not sit + // beside `group` — is on `lead_detail.page.ts`. + // + // The highlights strip still wins (#1211): the renderer + // drops what `record:highlights` registered (`status`, + // `priority`, `sla_due_date`, `is_sla_violated`, + // `owner_id`, `crm_account`) and the title candidate + // `subject` from the derived members. + // + // `escalated_date` — written by three flows and shown + // nowhere until now (#970) — arrives with the `escalation` + // group, beside `is_escalated` and `escalation_reason`. + // + // `internal_notes` (#1428) is in the `system` group with + // `is_closed`. A group whose members are ALL empty renders + // nothing, but a boolean always holds a value, so `system` + // renders on every case and an unwritten `internal_notes` + // stays reachable the way every empty field here is: the + // section's "Show N empty fields" toggle, then inline edit. + // ⛔ Not the create form — `/new` and edit both resolve + // `view.form`, and `case.hook.ts` nulls the column for + // anonymous web-to-case submissions. + // + // `resolution` / `resolved_by_article` render once the case + // carries one; `close_case` is the flow that collects the + // resolution. + // + // `hideEmpty: false` (#2003, the #1211 reasoning) only on + // `origin`: with `owner_id` in the strip, its one member is + // the channel an agent picks, and without the key the + // section vanishes on a new case. Not on `sla`: outside + // the strip its members are stamps no one types + // (`closed_date` and `resolution_time_hours` at close, + // `first_response_date` by `event.hook.ts`), so the key + // would draw empty rows to look at, not to fill. + sections: [ + { group: "basic" }, + { group: "origin", hideEmpty: false }, + { group: "sla" }, + { group: "escalation" }, + { group: "resolution" }, + { group: "system" } + ] + } + } + ] + }, + { + value: "related", + label: "Related", + children: [ + { + type: "page:accordion", + id: "case_related_accordion", + properties: { + items: [ + { + // An accordion item `key` is DELETED, not renamed to + // `value` — the opposite verdict to the tab items + // above, and the difference is a read point (#1269). + // `PageAccordionProps`' item shape is + // `{ label, icon?, collapsed?, children }` and it + // prescribes AGAINST `value` by name: the renderer + // maps every item to `{ ...it, value: `panel-` }` + // before rendering, so an authored value is + // overwritten. `page:tabs` really does read `it.value`; + // `page:accordion` does not. Nothing addresses these + // panels, so the identifier has nowhere to land. + label: "Open Tasks", + children: [ + { + type: "record:related_list", + id: "case_tasks", + properties: { + objectName: "crm_task", + relationshipField: "related_to_case", + columns: [ + "subject", + "status", + "priority", + "due_date", + "owner_id" + ], + filter: [ + { field: "status", operator: "not_equals", value: "completed" } + ], + limit: 10 + } + } + ] + } + ] + } + } + ] + }, + { + value: "activity", + label: "Activity", + children: [ + { + type: "record:activity", + id: "case_activity", + properties: { + filterMode: "all", + showFilterToggle: true, + limit: 25, + unifiedTimeline: true, + showCommentInput: true, + enableMentions: true, + enableReactions: true, + enableThreading: true, + // Load-bearing (#2071): a call or meeting logged on the + // case is a `sys_activity` row of type `completed` (the + // `task` feed kind), and the renderer drops every such + // row unless this is true — so an agent's logged call + // never reached this tab. The case's other `completed` + // writers are its own `resolved` / `closed` milestones + // (`case.object.ts`), which belong on this timeline too. + // Completed crm_task rows do NOT arrive here: a task's + // audit rows are keyed to the task, and this feed reads + // only rows keyed to the case. No `types` filter, unlike + // the lead page: this timeline mixes comments and field + // changes on purpose (`unifiedTimeline` above). + showCompleted: true + } + } + ] + } + ] + } + } + ] + } + ], + isDefault: true, + aria: { + ariaLabel: "Case Detail Page", + ariaDescribedBy: "Service-agent case detail view with SLA path, details, related items and activity timeline." + } +}; + +// src/service/reports/case.report.ts +var CasesByStatusPriorityReport = { + name: "cases_by_status_priority", + label: "Cases by Status and Priority", + description: "Summary of cases by status and priority", + // The chart counts cases, so `case_count` must be selected alongside the + // resolution time — and the yAxis must name that MEASURE ('case_number' + // was a raw-field name that exists in no dataset, so the axis was empty). + dataset: "case_metrics", + rows: ["status", "priority"], + values: ["case_count", "avg_resolution"], + type: "summary", + chart: { type: "bar", title: "Cases by Status", showLegend: true, xAxis: "status", yAxis: "case_count" } +}; +var SlaPerformanceReport = { + name: "sla_performance", + label: "SLA Performance Report", + description: "Analysis of SLA compliance", + // 'avg_sla_violated' (not a duplicated 'case_count') — the table showed two + // identical Cases columns and no violation measure; the chart's yAxis must + // name a dataset MEASURE, not a raw field ('is_sla_violated' leaked the + // column name onto the axis). + dataset: "case_metrics", + rows: ["priority"], + values: ["case_count", "avg_sla_violated", "avg_resolution"], + type: "summary", + runtimeFilter: { is_closed: true }, + chart: { type: "column", title: "SLA Violations by Priority", showLegend: false, xAxis: "priority", yAxis: "avg_sla_violated" } +}; +var CasesOpenedByDayPriorityReport = { + name: "cases_opened_by_day_priority", + label: "Cases Opened by Priority \xD7 Day", + description: "Daily case inflow split by priority", + dataset: "case_metrics", + rows: ["priority"], + columns: ["created_at"], + values: ["case_count"], + type: "matrix" +}; + +// src/service/sharing/case.sharing.ts +import { P as P12 } from "@objectstack/spec"; +var CaseEscalationSharingRule = { + name: "case_escalation_sharing", + label: "Escalated Cases Sharing", + object: "crm_case", + type: "criteria", + condition: P12`record.priority == "critical" && record.is_closed == false`, + accessLevel: "edit", + sharedWith: { type: "position", value: "service_manager" } +}; +var CaseDirectorSharingRule = { + name: "case_director_sharing", + label: "Escalated Cases \u2014 Service Director", + object: "crm_case", + type: "criteria", + condition: P12`record.priority == "critical" && record.is_closed == false`, + accessLevel: "read", + sharedWith: { type: "position", value: "service_director" } +}; +var CaseUnassignedTriageSharingRule = { + name: "case_unassigned_triage_sharing", + label: "Unassigned Cases \u2014 Triage", + object: "crm_case", + type: "criteria", + condition: P12`record.owner_id == null && record.status != "resolved" && record.status != "closed"`, + accessLevel: "edit", + sharedWith: { type: "position", value: "service_agent" } +}; + +// src/service/skills/case-triage.skill.ts +import { defineSkill } from "@objectstack/spec"; +var CaseTriageSkill = defineSkill({ + name: "case_triage", + label: "Case Triage", + description: "Triages a support case, assigns a priority with its justification, and points at the escalate/close action.", + instructions: `When the user asks to triage, prioritise, or classify a case: + +1. Read the case first \u2014 call \`describe_object\` for \`crm_case\` (the + schema is alive; admins add fields), then \`get_record\` for the case + at hand. Never triage from memory of a previous turn. +2. Assign a priority yourself from what you read. There is no triage + tool and you do not need one \u2014 weigh, in order: customer tier and + contract value, whether the customer is blocked with no workaround, + how long the case has been open against its SLA, and the sentiment + of the latest customer message. +3. State the priority and the ONE reason that drove it. Cite the case + ID and the field values you used. +4. If the priority is critical, say so and point the user at + **Escalate Case** on the record header \u2014 offer a ready-to-paste + \`reason\` built from step 3. You cannot escalate yourself, and should + not imply otherwise. +5. If the case is resolved in substance, point at **Close Case** and + offer a \`resolution\` summary the user can paste. +6. For the customer-facing reply, hand off to the \`email_drafting\` + skill rather than drafting it here.`, + tools: ["describe_object", "get_record"], + triggerConditions: [ + { field: "objectName", operator: "eq", value: "crm_case" } + ] +}); + +// src/service/views/case.view.ts +import { defineView } from "@objectstack/spec/ui"; +var data = { provider: "object", object: "crm_case" }; +var CaseViews = defineView({ + list: { + type: "grid", + name: "all_cases", + label: "All Cases", + userActions: { editInline: true }, + data, + columns: [ + { field: "case_number", width: 130, sortable: true, link: true, pinned: "left" }, + { field: "subject", width: 280, sortable: true }, + { field: "crm_account", width: 180 }, + { field: "crm_contact", width: 160 }, + { field: "priority", width: 110, sortable: true }, + { field: "status", width: 130, sortable: true }, + { field: "origin", width: 120 }, + { field: "sla_due_date", width: 160, sortable: true }, + { field: "is_sla_violated", width: 110, align: "center" }, + { field: "is_escalated", width: 110, align: "center" }, + { field: "owner_id", width: 150 } + ], + // Sort on the materialised ordinal, not the select itself: `priority desc` + // compares raw strings and lands medium > low > high > critical, burying + // every critical case at the bottom of the queue. + sort: [ + { field: "priority_rank", order: "desc" }, + { field: "sla_due_date", order: "asc" } + ], + rowColor: { + field: "priority", + colors: { critical: "red", high: "orange", medium: "yellow", low: "slate" } + }, + selection: { type: "multiple" }, + pagination: { pageSize: 50 }, + // The UI door for the `allowExport` grant four profiles already hold on + // `crm_case`. Export runs on ONE server-side route + // (`GET /api/v1/data/crm_case/export`, gated by `security.canExport`), so + // this declares which formats the toolbar offers — not a second gate: a + // profile without the grant gets 403 whether it clicks the button or + // curls the route. Measured in #798/#816; before this the grant was live + // but reachable only by `curl`. + exportOptions: { formats: ["csv", "xlsx"] }, + appearance: { + showDescription: true, + allowedVisualizations: ["grid", "kanban", "calendar", "timeline"] + }, + // Binds the 'calendar' entry above: the switcher opens the same deadlines + // the dedicated `sla_calendar` view shows, on the field this list already + // sorts by. `sla_due_date` is optional — a case the SLA monitor has not + // stamped carries no date at all, which is the truthful answer; the + // alternative the platform refuses is a guessed field putting every such + // case on today. + calendar: { + startDateField: "sla_due_date", + titleField: "subject", + colorField: "priority" + } + // Escalate straight from the queue: escalate_case's own + // `locations: ['list_item']` auto-injects the row-menu item. + }, + listViews: { + /** Service workflow board */ + case_workflow: { + name: "case_workflow", + type: "kanban", + label: "Service Workflow", + data, + columns: ["case_number", "subject", "priority", "sla_due_date"], + kanban: { + groupByField: "status", + columns: ["case_number", "subject", "crm_account", "priority", "owner_id"] + }, + filter: [{ field: "is_closed", operator: "equals", value: false }], + navigation: { mode: "drawer", width: "640px" } + }, + /** SLA calendar */ + sla_calendar: { + name: "sla_calendar", + type: "calendar", + label: "SLA Calendar", + data, + columns: ["case_number", "subject", "priority"], + calendar: { + startDateField: "sla_due_date", + titleField: "subject", + colorField: "priority" + } + }, + /** Chronological case stream */ + case_timeline: { + name: "case_timeline", + type: "timeline", + label: "Case Timeline", + data, + columns: ["case_number", "subject"], + timeline: { + // `created_at`, the platform's own creation stamp — the object's + // duplicate `created_date` was removed in #1992 because nothing wrote + // it on a real case, so every user-created case started its bar at + // null. Same spelling as `deal_timeline` on crm_opportunity (#575 B2). + startDateField: "created_at", + endDateField: "closed_date", + titleField: "subject", + groupByField: "owner_id", + colorField: "status", + scale: "day" + } + }, + /** + * The agent's personal queue: the cases themselves, one row each. Its + * aggregate counterpart is service_dashboard's "My Open Cases by + * Priority" (#510) — a dashboard widget counts, it cannot list. + */ + my_open_cases: { + name: "my_open_cases", + type: "grid", + label: "My Open Cases", + userActions: { editInline: true }, + data, + columns: ["case_number", "subject", "crm_account", "priority", "status", "sla_due_date"], + // ⚠️ `status not_in CLOSED_CASE_STATUSES`, NOT `is_closed == false`: the + // flag is derived as `effStatus === 'closed'` and never flips on + // `resolved`, so the flag spelling listed every RESOLVED case under a tab + // labelled "My Open Cases" — measured on the seeded demo population, the + // flag returned 30 of 38 cases and 7 of those 30 were resolved. A resolved + // case is finished work awaiting closure, not an open queue, and the + // mainstream service-cloud reading of "open" excludes it (Zendesk's open + // set omits Solved; ServiceNow's OOTB Open filter is + // `state not in (Resolved, Closed, Cancelled)`). Ruled 2026-08-31; pinned by + // `test/live-work-predicate-parity.test.ts` (#1145), whose consumer roster + // this view joined in the same change. + filter: [ + { field: "owner_id", operator: "equals", value: "{current_user_id}" }, + { field: "status", operator: "not_in", value: ["resolved", "closed"] } + ], + sort: [ + { field: "priority_rank", order: "desc" }, + { field: "sla_due_date", order: "asc" } + ] + }, + /** + * Unassigned — triage (#596). The second half of the queue substitute. + * + * `case_auto_assign` (`src/service/objects/_case-assignment.ts`) is a NO-OP whenever + * the `service_agent` pool is empty, and an empty pool is the FIRST-INSTALL + * NORM rather than an edge case: `sys_user_position` membership is runtime + * data, so on a fresh org — and any time every agent has been unassigned + * from the position — an inbound web-to-case lands ownerless. Best-effort + * assignment also stands down on a permission denial (the anonymous + * public-form context cannot read `sys_user_position` at all). + * + * Those cases used to be invisible: no view filtered on the absence of an + * owner, so an unowned case appeared in `All Cases` with a blank Owner + * column and nothing distinguished it from the rest. This view is the + * standing answer — silence replaced by a pinned tab whose row count IS the + * intake backlog. + * + * `is_null` on `owner_id`, not `equals: null`: the ownerless shape is an + * ABSENT column on driver-memory (see the totality note in + * `case-escalation.flow.ts`, where `record.escalated_date == null` aborted + * with `No such key`) as well as a NULL one on SQL, and only the operator + * form answers the same way for both. + * + * The predicate for "no longer live work" is `status not_in ['resolved', + * 'closed']`, NOT `is_closed == false`. `is_closed` is derived by + * `case_sla_defaults` as `effStatus === 'closed'`, so it never flips on + * `resolved` — and a resolved ownerless case satisfied both of this view's + * old filters and sat here forever, which is neither "arrives with no + * owner" nor "work waiting for a human". `not_in` lowers to the `$nin` the + * load-balancing hooks and `case_sla_monitor` already use for the same + * concept, so the four consumers now state one predicate; the roster that + * holds them together by NAME is `test/live-work-predicate-parity.test.ts`. + * `closed` stays excluded for the reason it always was: history, not + * backlog. + * + * ⚠️ WHO ACTUALLY SEES ROWS HERE is decided by record-level access, not by + * this view, and the answer today is narrower than the tab suggests. A + * view tab carries no role scoping — `ViewTabSchema` has `pinned`, + * `isDefault` and a boolean `visible`, and nothing per-profile — so this is + * pinned for everyone who can open Cases, while the ROWS resolve per + * profile: + * + * - `system_admin` — `viewAllRecords`, so the full backlog. This is the + * persona the empty-pool state is FOR: an empty `service_agent` pool is + * fixed by staffing `sys_user_position`, which only an admin can do. + * - `sales_manager` — `viewAllRecords`, read-only. + * - a service manager / director — the critical, open slice only, via the + * existing `case_escalation_sharing` / `case_director_sharing` criteria + * rules (`src/service/sharing/case.sharing.ts`). + * - `service_agent` — `readScope: 'own'` on `crm_case`, and an unowned + * row is owned by nobody, so **an agent's triage tab is empty**. + * + * The last line is a real gap for the "agent pulls from the queue" story + * and is deliberately NOT closed here: granting service roles sight of + * unowned cases is a sharing-model change (a new criteria rule, or a + * `readScope` widening), which is outside this card's file surface and is + * exactly the kind of quiet permission widening the #596 ruling rules out. + * Filed as #1096 for a decision, with the reach table above and the three + * options priced. + */ + unassigned_triage: { + name: "unassigned_triage", + type: "grid", + label: "Unassigned \u2014 triage", + userActions: { editInline: true }, + data, + columns: ["case_number", "subject", "crm_account", "crm_contact", "priority", "status", "origin", "sla_due_date"], + filter: [ + { field: "owner_id", operator: "is_null" }, + { field: "status", operator: "not_in", value: ["resolved", "closed"] } + ], + // Same ordering as the main queue: urgency first (on the materialised + // ordinal, never the raw select), then soonest deadline. + sort: [ + { field: "priority_rank", order: "desc" }, + { field: "sla_due_date", order: "asc" } + ], + rowColor: { + field: "priority", + colors: { critical: "red", high: "orange", medium: "yellow", low: "slate" } + }, + // The empty state carries the operational instruction, because "no rows" + // here is ambiguous on its own: it means either "the round-robin placed + // everything" (good) or "no case has arrived yet" (also fine) — and the + // reader most likely to be looking is someone who just found the tab + // full and needs to know why. + emptyState: { + title: "Nothing waiting for triage", + message: "Every case has an owner. Cases appear here when they arrive with no owner \u2014 typically a web-to-case submission that arrived while nobody held the Service Agent position.", + icon: "inbox" + } + }, + escalated_cases: { + name: "escalated_cases", + type: "grid", + label: "Escalated Cases", + userActions: { editInline: true }, + data, + columns: ["case_number", "subject", "crm_account", "priority", "sla_due_date", "owner_id"], + filter: [{ field: "is_escalated", operator: "equals", value: true }], + sort: [{ field: "priority_rank", order: "desc" }] + }, + /** + * SLA-at-risk: open cases at High or Critical priority needing attention. + * + * ⚠️ Names what the filter below actually selects. This read + * "high/urgent" until #1333 — but `crm_case.priority` is + * low/medium/high/critical (`case.object.ts:138-142`) and has NO `urgent`; + * that value belongs to `crm_task`. The mirror-image crossing already + * shipped a real defect once (`task.view.ts:35` — Case colour keys on the + * task view left every urgent and normal row uncoloured), and the + * direction that cost something was the one where the comment was + * believed. Two overlapping-but-unequal vocabularies: keep them apart. + */ + sla_at_risk: { + name: "sla_at_risk", + type: "grid", + label: "\u23F0 SLA at Risk", + userActions: { editInline: true }, + data, + columns: ["case_number", "subject", "crm_account", "priority", "sla_due_date", "owner_id"], + // Operator-only filter — sort by SLA due date ascending so the soonest + // surface first. (The view runtime does not interpolate `{NOW() + 4h}`.) + // + // ⚠️ `status not_in CLOSED_CASE_STATUSES`, NOT `is_closed == false`: the + // flag is derived as `effStatus === 'closed'` and never flips on + // `resolved`, so the flag spelling listed resolved cases as at risk while + // `case_sla_monitor` — the automation that OWNS SLA — had already + // excluded them (`status: { $nin: ['resolved', 'closed'] }`). The tab a + // human reads and the sweep that acts must answer this one question the + // same way. Pinned by `test/live-work-predicate-parity.test.ts` (#1145). + filter: [ + { field: "status", operator: "not_in", value: ["resolved", "closed"] }, + { field: "priority", operator: "in", value: ["high", "critical"] } + ], + sort: [{ field: "sla_due_date", order: "asc" }] + } + }, + /** + * The record form — and, because the platform has ONE, the CREATE form too. + * + * ## ⚠️ This object's `form` IS the create dialog (#1214 item 3) + * + * Measured against the console this app shipped at that taking + * (`@objectstack/console` 17.1.0, `dist/assets/`; this bundle read was ⛔ NOT + * re-taken on any later pin), BOTH + * entry points that open a case form resolve + * it the same way and neither takes a create/edit argument: + * + * RecordFormPage (`/{object}/new`, `/{object}/record/{id}/edit`) + * view.form ?? view.formViews?.default + * useActionModal (the `+ New` modal off a list view) + * view.form ?? view.formViews?.default + * + * ⇒ There is no create-only form to author. `ListViewSchema.addRecord` + * carries a `formView` key in `@objectstack/spec`, but NO console code path + * reads it (the string appears only in the view designer's own i18n table), + * so pointing it at a second form view would ship an ADR-0049 + * declared-but-unenforced shape and change nothing on screen. + * + * ⇒ Therefore the create-safe field set has to BE this form's field set. + * That is why the SLA and Resolution sections are gone rather than gated. + * + * ## ⛔ Why the tab strip was not the object's `fieldGroups` + * + * `crm_case.fieldGroups` declares SIX groups (Case Information / Origin & + * Routing / SLA & Priority / Resolution / Escalation / System) and the + * dialog showed THREE tabs — these sections. The renderer only reaches for + * `fieldGroups` on its AUTO-DERIVED path, taken when a form authors no + * `sections` at all; an authored `sections` array wins outright. So + * `src/service/objects/case.object.ts` is not part of this surface. + * + * ## ⚠️ Authoring `sections` OPTS OUT of the create-mode field strip + * + * That auto-derived path also runs two filters the authored path never sees + * (`plugin-form`: `Qe` → `qe` drops `readonly`/`hidden` fields, and on + * `mode === 'create'` `Je` additionally drops formula / summary / autonumber + * fields). An authored section renders its list VERBATIM. That is the whole + * mechanism behind this defect: the platform would have hidden + * `created_date` (retired in #1992), `closed_date`, `resolution_time_hours` + * and `is_closed` from a creator by itself, and naming them in a section put + * them back. + * + * ## ⛔ Why not gate the old sections on a predicate instead + * + * A section-level `visibleWhen` is parsed by `FormSectionSchema` and read by + * NOTHING in the form renderer (only FIELD-level `visibleWhen` is + * evaluated), so it would hide nothing. And field-level predicate evaluation + * FAILS OPEN — an unevaluable predicate renders the field visible, with no + * diagnostic (the house rule at the top of `lead.view.ts`, upstream + * objectstack-ai/objectstack#5149). A gate that fails open is not a gate for + * a data-integrity control, which is what this one is. + * + * ## What a creator may author here, and why the rest left + * + * Everything below is a fact the person raising the case HAS at intake. + * `case_number` stays because it is `readonly: true` on the object, so the + * renderer disables it — it is shown, never authored. + * + * The removed fields are all written by the lifecycle, and every one of them + * still has the surface it belongs on (pinned in + * `test/case-create-form-narrowing.test.ts`, both directions): + * + * closed_date readonly; `case_timeline` end + * (its start is the platform's + * `created_at`; `created_date` was + * retired in #1992) + * sla_due_date `case.hook.ts` stamps it from the + * priority × tier matrix; list column, + * sort key, `sla_calendar.startDateField`, + * detail-page highlights + * first_response_date `event.hook.ts` is its SINGLE writer + * resolution_time_hours readonly; derived at close; detail page + * is_sla_violated list column + detail-page highlights + * is_escalated, escalation_reason written by `case_escalation` / + * `case_sla_monitor` / `escalate_case`; + * detail page's Status & SLA section + * resolution detail page's Description section + * (the `resolution_required_on_close` + * validation still has its surface) + * is_closed readonly; derived from `status` + * + * ⚠️ `internal_notes`, `customer_rating` and `customer_feedback` left with + * the Resolution section and had NO other authoring surface at all. #1428 + * settled both halves of that, and neither answer was "put them back here": + * + * internal_notes `case_detail.page.ts`'s Description + * section, authored by inline edit — + * staff prose an agent writes while + * WORKING a case, which is why it did not + * come back to this form. The guest + * branch of `case.hook.ts` nulls the + * column on anonymous intake, so an + * intake surface for it would be a + * surface for a value the app discards. + * + * customer_rating, RETIRED under ADR-0049 enforce-or-remove + * customer_feedback (maintainer ruling, decision batch #21, + * 2026-09-03). Neither column exists on + * `crm_case` any more, so there is nothing + * here to omit and nothing anywhere to + * author. + * + * ⛔ Do not re-introduce either field, here or elsewhere. The ruling was not + * "no room on this form": a satisfaction score typed by the person being + * scored is not the same fact as one the customer gave, and neither field was + * named in ANY profile's `fields` map — which on this platform means + * unrestricted, not restricted. `case_csat_followup`, whose only purpose was + * to notify the case owner to log a rating, was retired in the same change. + * A customer-answered survey is a feature and would arrive as its own card, + * not as two inputs added back here. + * + * `type: 'simple'`, not `'tabbed'`: one section is not a tab strip. + */ + form: { + type: "simple", + sections: [ + { + name: "case", + label: "Case", + columns: 2, + fields: [ + "case_number", + { field: "subject", required: true, span: "full" }, + { field: "crm_account", required: true }, + "crm_contact", + { field: "status", required: true }, + "priority", + "origin", + "owner_id", + // Required on the object with no default — a form without it could + // never save a new case. + { field: "description", required: true, span: "full" } + ] + } + ] + }, + /** + * Additional named form views. + * + * `web_to_case` is a PUBLIC / ANONYMOUS support form (Salesforce + * Web-to-Case equivalent). Hosted at `/forms/support` and embeddable in + * a help center. Guests can ONLY submit — the `guest_portal` profile + * denies read/edit/delete on `crm_case`. Internal fields (status, origin, + * owner_id, SLA) are stamped by `case.hook.ts` after a guest submission. + * `priority` is NOT one of them: this form asks the guest for it, and an + * unset one is filled by the `low` option `crm_case.priority` declares + * `default: true`. Field defaults are applied before `beforeInsert`, so the + * hook only ever reads `priority` (to derive `priority_rank`). + */ + formViews: { + web_to_case: { + type: "simple", + data, + sections: [ + { + name: "how_can_we_help", + label: "How can we help?", + columns: 1, + fields: [ + { + field: "subject", + required: true, + placeholder: "Short summary of the issue" + }, + { + field: "description", + required: true, + placeholder: "Steps to reproduce, error messages, screenshots..." + }, + { + field: "type", + helpText: "Pick the option that best matches your issue." + }, + { + field: "priority", + helpText: "Critical issues should also be reported via phone." + } + ] + } + ], + sharing: { + enabled: true, + allowAnonymous: true, + publicLink: "/forms/support" + } + } + } +}); + +// src/service/views/knowledge_article.view.ts +import { defineView as defineView2 } from "@objectstack/spec/ui"; +var KnowledgeArticleViews = defineView2({ + list: { + type: "grid", + name: "all_articles", + label: "All Articles", + userActions: { editInline: true }, + data: { provider: "object", object: "crm_knowledge_article" }, + columns: [ + { field: "article_number", width: 120, link: true, pinned: "left", sortable: true }, + { field: "title", width: 320, sortable: true }, + { field: "category", width: 160 }, + { field: "status", width: 130, sortable: true }, + { field: "audience", width: 110 }, + { field: "language", width: 110 }, + { field: "owner_id", width: 150 }, + { field: "published_at", width: 160, sortable: true }, + { field: "helpful_count", width: 110, align: "right", summary: "sum" } + ], + sort: [{ field: "published_at", order: "desc" }], + grouping: { fields: [{ field: "category", order: "asc" }] }, + selection: { type: "multiple" }, + pagination: { pageSize: 50 }, + rowColor: { + field: "status", + colors: { draft: "slate", in_review: "amber", published: "emerald", archived: "gray" } + }, + appearance: { + showDescription: true, + allowedVisualizations: ["grid", "kanban"] + } + }, + listViews: { + published_articles: { + name: "published_articles", + type: "grid", + label: "Published", + userActions: { editInline: true }, + data: { provider: "object", object: "crm_knowledge_article" }, + columns: ["article_number", "title", "category", "audience", "helpful_count", "not_helpful_count", "published_at"], + filter: [{ field: "status", operator: "equals", value: "published" }], + sort: [{ field: "helpful_count", order: "desc" }] + }, + my_drafts: { + name: "my_drafts", + type: "grid", + label: "My Drafts", + userActions: { editInline: true }, + data: { provider: "object", object: "crm_knowledge_article" }, + columns: ["article_number", "title", "category", "status", "updated_at"], + filter: [ + { field: "status", operator: "in", value: ["draft", "in_review"] }, + // `{current_user_id}` is the only user token the view runtime resolves. + { field: "owner_id", operator: "equals", value: "{current_user_id}" } + ], + sort: [{ field: "updated_at", order: "desc" }] + } + }, + form: { + type: "simple", + sections: [ + { + name: "article", + label: "Article", + columns: 2, + fields: [ + "article_number", + { field: "title", required: true, span: "full" }, + { field: "summary", span: "full" }, + "category", + "tags", + "status", + "audience", + "language", + "owner_id" + ] + }, + { + name: "content", + label: "Content", + columns: 1, + fields: ["body"] + }, + { + // `name` alongside `label` (#1100): a form section declaring only a + // label renders its ENGLISH label under every locale, and neither the + // existing i18n tests nor the `i18n/missing-*` gate can see it — the + // heading has no key for a translator to miss. This section is named + // because this change edits it (`view_count` was removed from it, #601); + // the app-wide sweep of the other headings is #1100's job, held behind + // this card precisely so the two do not collide in the locale packs. + name: "engagement", + label: "Engagement", + columns: 3, + fields: ["helpful_count", "not_helpful_count", "published_at", "last_reviewed_at", "related_to_case"] + } + ] + } +}); + +// src/service/index.ts +var serviceHooks = [article_feedback_hook_default, case_hook_default, knowledge_article_hook_default].flat(); +var serviceFlows = [ + CaseEscalationFlow, + CaseEscalationOnCreateFlow, + EscalateCaseFlow, + CloseCaseFlow, + ClaimCaseFlow, + CaseEscalationStampFlow, + CaseSlaMonitorFlow +]; +var serviceSkills = [CaseTriageSkill]; +var serviceSharingRules = [ + CaseEscalationSharingRule, + CaseDirectorSharingRule, + CaseUnassignedTriageSharingRule +]; +var createHotCrmServiceStack = (collections) => defineStack2({ + manifest: { + id: "app.objectstack.hotcrm.service", + name: "HotCRM Service", + // The app package's namespace, deliberately (ADR-0130 D1). + namespace: "crm", + // The ARTIFACT's version: one `package.json`, one build, one release + // (ADR-0130 D6), so a module of this artifact is never at a version of its + // own. Bump it with the app package's and `package.json` — + // `test/docs-declared-versions.test.ts` holds all three, and the range + // below, to one value. + version: "4.0.1", + type: "module", + description: "HotCRM support module \u2014 cases, knowledge articles, and the SLA surface.", + // The same protocol as the app package (ADR-0087 handshake); bump it with + // `specVersion` on every platform upgrade, exactly as the app's is. + engines: { protocol: "^18.0.0-next.0" }, + // The App package this module extends. + dependencies: { "app.objectstack.hotcrm": "^4.0.1" }, + /** + * The five navigation entries this module puts into the app's menu + * (ADR-0029 D7). + * + * Not a design choice: an app's own `navigation` may not name another + * package's object (ADR-0130 §1.5, rule R3 of `module-split-plan.md`), so + * all five became contributions the moment `crm_case`, + * `crm_knowledge_article`, `service_dashboard` and `sla_performance` left + * the app package. The app keeps the GROUPS (`group_service`, `group_work`, + * `group_insights`) — a container a module cannot declare inside an app it + * does not own — and this module fills them. + * + * `app` is the app's bare `name` (`crm_enterprise`), not the manifest id: a + * dotted id is refused as a non-snake_case identifier. + * + * ⚠️ `priority` orders CONTRIBUTIONS against each other inside a group. It + * does NOT interleave them with the app's own children — a contributed item + * is appended after everything the app itself declares in that group. The + * one visible consequence is `nav_my_cases`, 4th of 6 in *My Work* before + * the split and last after it; the three `group_service` items and + * `nav_report_sla` keep their positions because the app declares nothing + * after them. ⛔ Do not compensate with a per-item `order`: that key sorts + * in the renderer only, this app authors none anywhere, and adding one to + * work around a platform merge rule is what AGENTS.md forbids. + */ + navigationContributions: [ + { + app: "crm_enterprise", + group: "group_service", + // Stated rather than defaulted so that the day a second package + // contributes into one of these groups, the order is an authored fact + // instead of a registration-order accident. + priority: 10, + items: [ + { id: "nav_case", type: "object", objectName: "crm_case", label: "Cases", icon: "life-buoy" }, + { id: "nav_knowledge", type: "object", objectName: "crm_knowledge_article", label: "Knowledge", icon: "book-open" }, + { id: "nav_service_dashboard", type: "dashboard", dashboardName: "service_dashboard", label: "Service Overview", icon: "gauge" } + ] + }, + { + app: "crm_enterprise", + group: "group_work", + priority: 20, + items: [ + { id: "nav_my_cases", type: "object", objectName: "crm_case", viewName: "my_open_cases", label: "My Cases", icon: "life-buoy" } + ] + }, + { + app: "crm_enterprise", + group: "group_insights", + priority: 30, + items: [ + { id: "nav_report_sla", type: "report", reportName: "sla_performance", label: "SLA Performance", icon: "timer" } + ] + } + ] + }, + // What THIS package's metadata needs — see the `requires` paragraph above. + requires: ["automation", "triggers", "analytics", "sharing"], + objects: [ArticleFeedback, Case, KnowledgeArticle], + hooks: serviceHooks, + views: [CaseViews, KnowledgeArticleViews], + pages: [CaseDetailPage], + flows: serviceFlows, + actions: [ + EscalateCaseAction, + CloseCaseAction, + ClaimCaseAction, + LogCallAction, + LogMeetingAction, + CaseScheduleMeetingAction, + MarkArticleHelpfulAction, + MarkArticleNotHelpfulAction + ], + datasets: [CaseDataset], + reports: [CasesByStatusPriorityReport, SlaPerformanceReport, CasesOpenedByDayPriorityReport], + dashboards: [ServiceDashboard], + skills: serviceSkills, + sharingRules: serviceSharingRules, + emailTemplates: ServiceEmailTemplates, + ...collections +}); + +// src/revenue/objects/index.ts +var objects_exports3 = {}; +__export(objects_exports3, { + Contract: () => Contract, + OpportunityLineItem: () => OpportunityLineItem, + Product: () => Product, + Quote: () => Quote, + QuoteLineItem: () => QuoteLineItem +}); + +// src/revenue/objects/contract.object.ts +import { ObjectSchema as ObjectSchema12, Field as Field12 } from "@objectstack/spec/data"; +import { P as P13 } from "@objectstack/spec"; +var Contract = ObjectSchema12.create({ + name: "crm_contract", + label: "Contract", + pluralLabel: "Contracts", + icon: "file-pen-line", + description: "Legal contracts and agreements", + // ADR-0090 D1/D7: OWD is an authored decision. Master-detail child of + // crm_account — a contract IS account data: reachable by whoever can reach + // the account, editable by whoever can edit it (#549, ruling 2026-08-31). + sharingModel: "controlled_by_parent", + // ADR-0079: render-only `titleFormat` retired in favor of `nameField`. + // Original template was '{contract_number} - {crm_account.name}'. The + // `crm_account.name` segment is a lookup DOT-WALK, which a formula field + // cannot reference (ADR-0072), so it is DROPPED. Only the local + // `contract_number` (autonumber) remains, so no formula is needed — point + // `nameField` straight at it. + nameField: "contract_number", + highlightFields: ["contract_number", "crm_account", "status", "start_date", "end_date"], + fieldGroups: [ + { key: "basic", label: "Contract Information", icon: "info" }, + { key: "parties", label: "Parties", icon: "users" }, + { key: "terms", label: "Terms & Dates", icon: "calendar" }, + { key: "value", label: "Contract Value", icon: "dollar-sign" }, + { key: "status", label: "Status & Approval", icon: "check-circle" }, + { key: "renewal", label: "Renewal", icon: "refresh-ccw", collapse: "collapsed" } + ], + fields: { + // Platform ownership anchor — canonical note in `account.object.ts` (#548). + owner_id: Field12.lookup("sys_user", { + label: "Contract Owner", + group: "parties", + system: true, + readonly: false, + trackHistory: true + }), + // AutoNumber field + contract_number: Field12.autonumber({ + label: "Contract Number", + group: "basic", + format: "CTR-{0000}" + }), + // Relationships — the master the OWD derives from. Authored as + // master-detail so the master is not decided by declaration order against + // the required `crm_contact` lookup below (objectstack#14747). + crm_account: Field12.masterDetail("crm_account", { + label: "Account", + group: "parties", + required: true, + storage: { notNull: true }, + deleteBehavior: "cascade" + }), + crm_contact: Field12.lookup("crm_contact", { + label: "Primary Contact", + group: "parties", + required: true, + storage: { notNull: true }, + // @objectstack 12: string[] `referenceFilters` is dead (not read by the + // picker); `dependsOn` is the live cascading-lookup form — scopes contacts + // to the contract's `crm_account` (ADR-0049). + dependsOn: ["crm_account"] + }), + crm_opportunity: Field12.lookup("crm_opportunity", { + label: "Related Opportunity", + group: "parties", + // Scope opportunities to the contract's account (was dead referenceFilters). + dependsOn: ["crm_account"] + }), + // Status + status: Field12.select({ + label: "Status", + group: "status", + options: [ + { label: "Draft", value: "draft", color: "#999999", default: true }, + { label: "In Approval", value: "in_approval", color: "#FFA500" }, + { label: "Activated", value: "activated", color: "#00AA00" }, + { label: "Expired", value: "expired", color: "#FF0000" }, + { label: "Terminated", value: "terminated", color: "#666666" } + ], + required: true, + storage: { notNull: true }, + trackHistory: true + }), + // Contract Terms + contract_term_months: Field12.number({ + label: "Contract Term (Months)", + group: "terms", + required: true, + storage: { notNull: true }, + min: 1 + }), + start_date: Field12.date({ + label: "Start Date", + group: "terms", + required: true, + storage: { notNull: true } + }), + end_date: Field12.date({ + label: "End Date", + group: "terms", + required: true, + storage: { notNull: true } + }), + // Financial + contract_value: Field12.currency({ + label: "Contract Value", + group: "value", + min: 0, + required: true, + storage: { notNull: true } + }), + billing_frequency: Field12.select({ + label: "Billing Frequency", + group: "value", + options: [ + { label: "Monthly", value: "monthly", default: true }, + { label: "Quarterly", value: "quarterly" }, + { label: "Annually", value: "annually" }, + { label: "One-time", value: "one_time" } + ] + }), + payment_terms: Field12.select({ + label: "Payment Terms", + group: "value", + // Canonical set shared with Quote: an accepted quote's terms (incl. + // due_on_receipt) must survive the copy onto the contract. That copy is + // `quote_accepted_contract_draft` (src/revenue/objects/quote.hook.ts). This field's `net_30` + // option default applies only when the quote itself carried no term, + // which is the intended fall-through, not a gap. + options: [...PAYMENT_TERMS_OPTIONS] + }), + // Renewal + auto_renewal: Field12.boolean({ + label: "Auto Renewal", + group: "renewal", + defaultValue: false + }), + renewal_notice_days: Field12.number({ + label: "Renewal Notice (Days)", + group: "renewal", + min: 0, + defaultValue: 30 + }), + // Legal + contract_type: Field12.select({ + label: "Contract Type", + group: "basic", + options: [ + { label: "Subscription", value: "subscription" }, + { label: "Service Agreement", value: "service" }, + { label: "License", value: "license" }, + { label: "Partnership", value: "partnership" }, + { label: "NDA", value: "nda" }, + { label: "MSA", value: "msa" } + ] + }), + signed_date: Field12.date({ + label: "Signed Date", + group: "status" + }), + signed_by: Field12.text({ + label: "Signed By", + group: "status", + maxLength: 255 + }), + document_url: Field12.url({ + label: "Contract Document", + group: "basic" + }), + // Terms & Conditions + special_terms: Field12.markdown({ + label: "Special Terms", + group: "terms" + }), + description: Field12.markdown({ + label: "Description", + group: "basic" + }), + // Billing Address + billing_address: Field12.address({ + label: "Billing Address", + group: "value" + }) + }, + // Database indexes + indexes: [ + { fields: ["crm_account"] }, + { fields: ["status"] }, + { fields: ["start_date"] }, + { fields: ["end_date"] }, + { fields: ["owner_id"] } + ], + // Enable advanced features + // API surface. History → Field.trackHistory (ADR-0052). + enable: { + apiEnabled: true, + apiMethods: ["get", "list", "create", "update", "delete"], + // #602 — the executed contract itself. `document_url` remains the pointer + // to an external DMS copy; this is where the file actually lives. + // See the canonical capability note in `src/sales/objects/index.ts`. + files: true + }, + // Validation Rules + // + // Predicates below are TOTAL: every `record.x` read is `has()`-guarded, so the + // rule returns a verdict even when the merged record has no such key. See + // AGENTS.md "Validation predicates must be TOTAL" and + // test/object-validation-predicates.test.ts, which fails the build otherwise. + validations: [ + { + name: "end_after_start", + type: "script", + severity: "error", + message: "End Date must be after Start Date", + condition: P13`has(record.end_date) && record.end_date != null && has(record.start_date) && record.start_date != null && record.end_date <= record.start_date` + }, + // NOTE: the `valid_contract_term` warning (months-between term check) was + // dropped in the 9.8.0 upgrade — its CEL predicate used `monthsBetween()`, + // which 9.8.0's aligned CEL stdlib (ADR-0032) no longer provides. It was a + // non-blocking warning; the hard end-date>start-date rule above remains. + { + // #575 B4. Like `crm_quote`, this object shipped a lifecycle vocabulary + // with no transition constraint and no status guard in `contract.hook.ts` + // — so `draft → activated` was a legal move, activating an agreement that + // never passed approval. Activation is the consequential edge here: + // `contract_on_activation` stamps `signed_date`, promotes the account to + // `customer`, and the renewal flow starts counting from it. + name: "contract_status_progression", + type: "state_machine", + severity: "warning", + message: "Invalid contract status transition", + field: "status", + transitions: { + draft: ["in_approval", "terminated"], + // Approval either lands (`activated`) or sends the paperwork back. + in_approval: ["draft", "activated", "terminated"], + // `→ expired` is the contract_expiration flow, whose own sweep filter + // is `status: 'activated'` — nothing else ages out. + activated: ["expired", "terminated"], + // Both ends are terminal: a renewal is a NEW contract (the + // contract_renewal flow files a task, it does not revive the old row). + expired: [], + terminated: [] + } + } + ] + // Workflow Rules + // ⚠️ No `workflows[]` here, and none is possible: object `workflows[]` were + // removed from the platform. Field updates live in this object's `*.hook.ts`; + // scheduled status flips and notifications live in `src/*/flows/*.flow.ts`. +}); + +// src/revenue/objects/opportunity_line_item.object.ts +import { ObjectSchema as ObjectSchema13, Field as Field13 } from "@objectstack/spec/data"; +import { F as F8, P as P14 } from "@objectstack/spec"; +var OpportunityLineItem = ObjectSchema13.create({ + name: "crm_opportunity_line_item", + label: "Opportunity Line Item", + pluralLabel: "Opportunity Line Items", + icon: "package", + description: "A single product line on an Opportunity", + // ADR-0090 D1/D7: OWD is an authored decision. A line item has no meaning + // apart from its deal, so its record access DERIVES from the opportunity + // (ADR-0055), and as of 17.0.0-rc.4 that derivation means what it says. + // + // ⚠️ Reads ARE filtered to line items whose `crm_opportunity` the caller can + // read, and master accessibility resolves through the same paths a direct + // read of the opportunity takes — ownership and `sys_record_share` grants + // included, NOT the master's row-level security policies alone. So a rep + // reads the lines of the deals in their own book plus anything shared to + // them, and the private-deal RLS filter carried by the `sales_manager` and + // `marketing_user` sets narrows on top of that rather than being the only + // thing that narrows. The parent-write gate derives the same way: a line + // whose opportunity the caller cannot edit is refused. + // + // `test/parent-derived-reach.test.ts` pins the narrow semantics and was + // written to go red the day the platform widens them: with the master set + // resolved from RLS policies alone, any caller without the private-deal + // policy — `sales_rep` included — reaches EVERY opportunity's lines. + // ADR-0055's relation resolver accepts a REQUIRED LOOKUP as the parent, so + // this works without converting the relationship to master-detail. + // + // ⛔ Not `private`: this object has no owner of its own, so `private` falls + // back to the platform's auto-stamped `owner_id` (whoever inserted the row) — + // and the rep who owns the deal then cannot see a line the quote-generation + // flow or their manager added to it. + sharingModel: "controlled_by_parent", + // Per-field history is opt-in via `Field.trackHistory` (ADR-0052), set on + // quantity/unit_price/discount below. Master-detail children still inherit + // the master's sharing automatically. + highlightFields: ["crm_product", "quantity", "unit_price", "total_price"], + // Two groups, derived from the nine fields this object actually declares + // rather than copied off a neighbour (#1453). The split is the one the + // arithmetic already makes: everything `total_price` multiplies together is + // `pricing`, everything that says WHICH line this is is `basic`. + // + // `quantity` is a pricing field here, not an identity one — it is a factor in + // `total_price`, and separating it from the price it multiplies would put the + // two halves of one product on two sections. `crm_quote_line_item` takes the + // same split over its ten fields, and the parents agree: `crm_quote` and + // `crm_product` both keep every money field in `pricing` — `crm_quote`'s + // `tax` included — and both keep `description` in `basic`. + // + // ⚠️ Neither group may be a subset of the highlight strip: a synthesized + // detail page hoists the title plus the first four `highlightFields` out of + // the body, so an all-hoisted group renders on forms and nowhere else + // (`field-group-shadowed`; `pnpm lint` — `os lint --strict` — fails on it). + // `basic` keeps crm_opportunity/description/line_number and `pricing` keeps + // list_price/discount outside that strip, so both survive the hoist. + fieldGroups: [ + { key: "basic", label: "Line Item", icon: "package" }, + { key: "pricing", label: "Pricing", icon: "dollar-sign" } + ], + fields: { + // The parent link, and the ONE field on this object that decides whether the + // deal it belongs to can be deleted at all (#727). + // + // Declaring nothing here does not mean "no opinion": `Field.lookup` resolves + // `deleteBehavior` to the spec default `set_null`, and the engine's + // `cascadeDeleteRelations` escalates a `set_null` default on a REQUIRED + // lookup to `restrict` — a NOT NULL column cannot be cleared. So the silent + // default made every itemised opportunity undeletable, with a message that + // told the API caller to `set deleteBehavior:'cascade'` on this very field: + // + // DELETE /api/v1/data/crm_opportunity/ + // → 409 DELETE_RESTRICTED "…1 dependent crm_opportunity_line_item + // record(s) reference it via crm_opportunity…" + // + // `cascade` is the semantics this object already claims twice over: the + // header comment says a line has no meaning apart from its deal, and + // `opportunity_line_item.hook.ts` derives `crm_opportunity.amount` FROM the + // line set. A record whose parent is gone denotes nothing and would keep a + // dead deal's revenue in the line-level reports. + // + // This is deliberately NOT the campaign/event answer (#696, #711 kept + // `crm_campaign_member.crm_campaign` and `crm_event_attendee.crm_event` on + // the restricting default): a member list is a campaign's historical record + // and survives on its own terms. A price line does not. + crm_opportunity: Field13.masterDetail("crm_opportunity", { + label: "Opportunity", + group: "basic", + required: true, + storage: { notNull: true }, + deleteBehavior: "cascade" + }), + // Deliberately left on the default, which the same escalation turns into + // `restrict`: deleting a catalog product must NOT shred the priced history + // of deals that sold it. `product.hook.ts`'s own `beforeDelete` says the + // same thing in words ("Set is_active=false to retire instead"). + crm_product: Field13.lookup("crm_product", { + label: "Product", + group: "basic", + required: true, + storage: { notNull: true } + }), + description: Field13.text({ + label: "Description", + group: "basic", + maxLength: 500 + }), + quantity: Field13.number({ + label: "Quantity", + group: "pricing", + required: true, + storage: { notNull: true }, + scale: 2, + min: 0, + defaultValue: 1, + trackHistory: true + }), + list_price: Field13.currency({ + label: "List Price", + group: "pricing", + readonly: true, + description: "Auto-populated from the product's List Price." + }), + unit_price: Field13.currency({ + label: "Sales Price", + group: "pricing", + required: true, + storage: { notNull: true }, + description: "Negotiated unit price (may differ from list price)", + trackHistory: true + }), + discount: Field13.percent({ + label: "Discount %", + group: "pricing", + scale: 2, + min: 0, + max: 100, + defaultValue: 0, + trackHistory: true + }), + total_price: Field13.formula({ + label: "Total", + group: "pricing", + expression: F8`record.quantity * record.unit_price * (1 - record.discount / 100)` + }), + line_number: Field13.number({ + label: "Line #", + group: "basic", + scale: 0, + readonly: true + }) + }, + // Predicates below are TOTAL: every `record.x` read is `has()`-guarded, so the + // rule returns a verdict even when the merged record has no such key. See + // AGENTS.md "Validation predicates must be TOTAL" and + // test/object-validation-predicates.test.ts, which fails the build otherwise. + validations: [ + { + name: "unit_price_positive", + type: "script", + severity: "error", + message: "Sales price cannot be negative", + // Both guards are load-bearing, not defensive noise. `has(...)` answers + // "is the key present at all": on update the predicate sees + // `{...previous, ...data}`, and a driver that stores only written columns + // returns no key, which aborts the whole predicate and silently skips the + // rule (#630). `!= null` answers "does it hold a value": strict CEL + // ABORTS on `null < 0` instead of evaluating it false, so the unguarded + // form left this rule inert on a blank price — it never fired at all, + // which is the opposite of what a validation is for. The `null` hazard is + // written up at `account.object.ts:244-245`; the same-named rule in + // `quote_line_item.object.ts` has carried that guard all along. + condition: P14`has(record.unit_price) && record.unit_price != null && record.unit_price < 0` + } + ] +}); + +// src/revenue/objects/product.object.ts +import { ObjectSchema as ObjectSchema14, Field as Field14 } from "@objectstack/spec/data"; +import { F as F9, P as P15 } from "@objectstack/spec"; +var Product = ObjectSchema14.create({ + name: "crm_product", + label: "Product", + pluralLabel: "Products", + icon: "box", + description: "Products and services offered by the company", + // ADR-0090 D1/D7: OWD is an authored decision. Product catalog is org-visible; only owners edit. + sharingModel: "public_read", + // ADR-0079: render-only `titleFormat` retired in favor of `nameField`, + // which names a real field. The former template composed two local fields, so + // a `display_title` formula field reproduces it for the record title. + nameField: "display_title", + // Explicit search targets (ADR-0061). REQUIRED because nameField is a + // FORMULA (display_title/full_name): without this, $search auto-defaults to + // the formula field, which isn't a real column, so the lookup picker + global + // search silently return zero. These are real, indexed columns. + searchableFields: ["name", "product_code", "sku"], + highlightFields: ["product_code", "name", "category", "is_active"], + fieldGroups: [ + { key: "basic", label: "Product Information", icon: "info" }, + { key: "pricing", label: "Pricing", icon: "dollar-sign" }, + { key: "metadata", label: "Resources", icon: "link", collapse: "collapsed" } + ], + fields: { + // AutoNumber field - Unique product identifier + product_code: Field14.autonumber({ + label: "Product Code", + group: "basic", + format: "PRD-{0000}" + }), + // Basic Information + name: Field14.text({ + label: "Product Name", + group: "basic", + required: true, + storage: { notNull: true }, + searchable: true, + maxLength: 255 + }), + // ADR-0079 record title (was titleFormat '{product_code} - {name}'). + display_title: Field14.formula({ + label: "Display Title", + group: "basic", + expression: F9`record.product_code + " - " + record.name` + }), + description: Field14.markdown({ + label: "Description", + group: "basic" + }), + // Categorization + category: Field14.select({ + label: "Category", + group: "basic", + options: [ + { label: "Software", value: "software", default: true }, + { label: "Hardware", value: "hardware" }, + { label: "Service", value: "service" }, + { label: "Subscription", value: "subscription" }, + { label: "Support", value: "support" } + ] + }), + family: Field14.select({ + label: "Product Family", + group: "basic", + options: [ + { label: "Enterprise Solutions", value: "enterprise" }, + { label: "SMB Solutions", value: "smb" }, + { label: "Professional Services", value: "services" }, + { label: "Cloud Services", value: "cloud" } + ] + }), + // Pricing + list_price: Field14.currency({ + label: "List Price", + group: "pricing", + min: 0, + required: true, + storage: { notNull: true } + }), + cost: Field14.currency({ + label: "Cost", + group: "pricing", + min: 0 + }), + // SKU + // + // `quantity_on_hand` / `reorder_point` were removed with the rest of the + // inventory surface: nothing in this app decremented stock, and the "Low + // Stock" view they fed compared against a hardcoded 10 rather than the + // reorder point beside it. HotCRM sells from a catalog; warehouse state + // belongs to the system of record that owns it. + sku: Field14.text({ + label: "SKU", + group: "basic", + maxLength: 50, + unique: true + }), + // Status + is_active: Field14.boolean({ + label: "Active", + group: "basic", + defaultValue: true, + trackHistory: true + }), + // Relationships + product_manager: Field14.lookup("sys_user", { + label: "Product Manager", + group: "basic" + }), + // Images and Assets + // `accept` / `maxSize` are declarable AND server-enforced from + // @objectstack 17 (ADR-0104 D3 wave 2). Before that the upload widget read + // them but `FieldSchema` dropped them at parse, so the constraint existed + // only in the browser and any direct API caller walked past it. + image: Field14.image({ + label: "Product Image", + group: "metadata", + accept: ["image/png", "image/jpeg", "image/webp"], + maxSize: 5 * 1024 * 1024 + }), + datasheet: Field14.file({ + label: "Datasheet", + group: "metadata", + accept: ["application/pdf"], + maxSize: 20 * 1024 * 1024 + }) + // `billing_type` and `unit_of_measure` were removed with the tax flag: both + // were seeded on all 13 catalog products and read by nothing — no quote + // total, no revenue-recognition report and no line-item behaviour ever + // consulted either. A picklist that only ever renders itself is a + // maintenance obligation (four locales, an import column, every future + // migration) charged against a capability that does not exist. + }, + // Database indexes + // + // No `{ fields: ['sku'], unique: true }` here: the field-level `unique: true` + // already builds the tenant composite `(organization_id, sku)` since + // framework #3696. Declaring the single-column index too made the + // platform-wide constraint win and left the per-tenant one unreachable + // (framework#3991) — an SKU is unique inside a catalogue, and two + // organizations may legitimately both stock "ABC-123". + indexes: [ + { fields: ["name"] }, + { fields: ["category"] }, + { fields: ["is_active"] } + ], + // Enable advanced features + // API surface. History → Field.trackHistory (ADR-0052). + enable: { + apiEnabled: true, + apiMethods: ["get", "list", "create", "update", "delete"] + }, + // Validation Rules + // + // Predicates below are TOTAL: every `record.x` read is `has()`-guarded, so the + // rule returns a verdict even when the merged record has no such key. See + // AGENTS.md "Validation predicates must be TOTAL" and + // test/object-validation-predicates.test.ts, which fails the build otherwise. + validations: [ + { + name: "price_positive", + type: "script", + severity: "error", + message: "List Price must be positive", + // Two distinct guards, both required. `has(...)` answers "is the key + // there at all" — on update the merged record is `{...previous, ...data}` + // and a driver that stores only written columns hands back no key, which + // aborts the whole predicate (#630). `!= null` then answers "does it hold + // a value" — strict CEL cannot compare dyn < int, the hazard + // written up on `account.object.ts`. `list_price` is `required`, but the + // rule also runs on partial updates that omit it. + condition: P15`has(record.list_price) && record.list_price != null && record.list_price < 0` + }, + { + name: "cost_less_than_price", + type: "script", + severity: "warning", + message: "Cost should be less than List Price", + // Both operands need both guards: `cost` is optional and absent on every + // seeded product, so this warning has never once evaluated. + condition: P15`has(record.cost) && record.cost != null && has(record.list_price) && record.list_price != null && record.cost >= record.list_price` + } + ] +}); + +// src/revenue/objects/quote.object.ts +import { ObjectSchema as ObjectSchema15, Field as Field15 } from "@objectstack/spec/data"; +import { F as F10, P as P16, cel as cel5 } from "@objectstack/spec"; + +// src/sales/objects/_thresholds.ts +var LARGE_DEAL_AMOUNT = 1e5; +var HIGH_VALUE_DEAL_AMOUNT = 5e5; +var QUOTE_DISCOUNT_CEILING = 60; + +// src/revenue/objects/quote.object.ts +var Quote = ObjectSchema15.create({ + name: "crm_quote", + label: "Quote", + pluralLabel: "Quotes", + icon: "file-text", + description: "Price quotes for customers", + // ADR-0090 D1/D7: OWD is an authored decision. Master-detail child of + // crm_account — a quote is reachable by whoever can reach its account, and + // its line items derive one level further (#549, ruling 2026-08-31). + sharingModel: "controlled_by_parent", + // ADR-0079: render-only `titleFormat` retired in favor of `nameField`, + // which names a real field. The former template composed two local fields, so + // a `display_title` formula field reproduces it for the record title. + nameField: "display_title", + // Explicit search targets (ADR-0061). REQUIRED because nameField is a + // FORMULA (display_title/full_name): without this, $search auto-defaults to + // the formula field, which isn't a real column, so the lookup picker + global + // search silently return zero. These are real, indexed columns. + searchableFields: ["name", "quote_number"], + highlightFields: ["quote_number", "name", "crm_account", "status", "total_price"], + fieldGroups: [ + { key: "basic", label: "Quote Information", icon: "info" }, + { key: "pricing", label: "Pricing", icon: "dollar-sign" }, + { key: "terms", label: "Terms & Validity", icon: "calendar" }, + { key: "address", label: "Addresses", icon: "map-pin", collapse: "collapsed" }, + { key: "system", label: "System", icon: "database", collapse: "collapsed" } + ], + fields: { + // Platform ownership anchor — canonical note in `account.object.ts` (#548). + owner_id: Field15.lookup("sys_user", { + label: "Quote Owner", + group: "basic", + system: true, + readonly: false, + trackHistory: true + }), + // AutoNumber field + quote_number: Field15.autonumber({ + label: "Quote Number", + group: "basic", + format: "QTE-{0000}" + }), + // Basic Information + name: Field15.text({ + label: "Quote Name", + group: "basic", + required: true, + storage: { notNull: true }, + searchable: true, + maxLength: 255 + }), + // ADR-0079 record title (was titleFormat '{quote_number} - {name}'). + display_title: Field15.formula({ + label: "Display Title", + group: "basic", + expression: F10`record.quote_number + " - " + record.name` + }), + // Relationships — the master the OWD derives from (authored, not positional). + crm_account: Field15.masterDetail("crm_account", { + label: "Account", + group: "basic", + required: true, + storage: { notNull: true }, + deleteBehavior: "cascade" + }), + crm_contact: Field15.lookup("crm_contact", { + label: "Contact", + group: "basic", + // Optional AT DRAFT TIME, required from `presented` on (#1017). + // + // quote_generation maps the opportunity's `primary_contact`, which is + // itself optional — a flat `required: true` here meant contact-less + // opportunities could never draft a quote at all. So the recipient is + // nailed down by the time a quote is PRESENTED, not when it is drafted. + // That sentence sat in this comment for the field's whole life with + // nothing enforcing it: no rule stopped a contact-less quote reaching + // `presented` or `accepted`, and the bill came due one object over. + // `crm_contract.crm_contact` is `required` + `notNull`, so accepting such + // a quote made `quote_on_accepted` fail to draft the contract — since + // #714/#1013 that failure is honest and no longer swallows the close-won + // leg, but the hook is `async` + `onError: 'log'`, so the accepting write + // still answers 200 and the only evidence is a server log nobody reads. + // `requiredWhen` moves the same refusal to the synchronous, someone-is- + // watching moment: the rep is told on the write that turns the quote + // outward, against the field, with the quote still editable. + // + // WHY EXACTLY `presented` + `accepted`, and not the other two terminal + // states. Both of those are reachable WITHOUT the quote ever being sent + // (see the `quote_status_progression` transitions below): + // • `expired` — the `quote_expiration` flow sweeps on `expiration_date` + // alone and expires never-sent drafts as readily as presented ones. + // Requiring a recipient there would make a nightly system write fail + // on exactly the quotes that have no recipient BECAUSE nobody sent + // them, and the sweep's `runAs: 'system'` would not exempt it — the + // gate applies on write, not on actor. + // • `rejected` — legal straight from `in_review`, i.e. a quote killed + // internally before anyone saw it. Demanding a contact to file that + // verdict asks for a recipient the quote never had. + // Neither state passes anything on to a contract, so neither needs one. + // + // ⚠️ `has(record.status)` is load-bearing, not decoration — the same trap + // documented at `lead.object.ts`'s duplicate lookups: a bare + // `record.status == "presented"` aborts with `No such key` on any merged + // record that simply omits the column, and the engine's answer to a + // predicate that fails to evaluate is to SKIP it ("requiredWhen for + // 'crm_contact' failed to evaluate — skipped"). The rule would then read + // as enforced and require nothing at all. + // + // @objectstack 12: string[] `referenceFilters` is dead (not read by the + // picker); `dependsOn` is the live cascading form — scopes contacts to the + // quote's `crm_account` (ADR-0049). + dependsOn: ["crm_account"], + requiredWhen: P16`has(record.status) && (record.status == "presented" || record.status == "accepted")`, + description: "Required once the quote is Presented or Accepted \u2014 the drafted contract takes its Primary Contact from here." + }), + crm_opportunity: Field15.lookup("crm_opportunity", { + label: "Opportunity", + group: "basic", + // Scope opportunities to the quote's account (was dead referenceFilters). + dependsOn: ["crm_account"] + }), + // Status + status: Field15.select({ + label: "Status", + group: "basic", + options: [ + { label: "Draft", value: "draft", color: "#999999", default: true }, + { label: "In Review", value: "in_review", color: "#FFA500" }, + { label: "Presented", value: "presented", color: "#4169E1" }, + { label: "Accepted", value: "accepted", color: "#00AA00" }, + { label: "Rejected", value: "rejected", color: "#FF0000" }, + { label: "Expired", value: "expired", color: "#666666" } + ], + required: true, + storage: { notNull: true }, + trackHistory: true + }), + // Dates + quote_date: Field15.date({ + label: "Quote Date", + group: "terms", + required: true, + storage: { notNull: true }, + defaultValue: cel5`today()` + }), + expiration_date: Field15.date({ + label: "Expiration Date", + group: "terms", + required: true, + storage: { notNull: true } + }), + // Pricing + // subtotal/discount_amount/total_price are NOT `readonly`, and the writer + // that decides it is the LINE-ITEM ROLLUP — not the flow this note used to + // name. `quote_total_rollup` (`quote_line_item.hook.ts`) recomputes all + // three on every line insert/update/delete through + // `api.object('crm_quote').update(...)`: a cross-record write via `ctx.api`, + // which is a `ScopedContext` over the ACTING USER's context. The keys are + // therefore CALLER-supplied to a non-`isSystem` UPDATE, exactly what + // `stripReadonlyFields` deletes — with `readonly` on, a quote's totals would + // freeze at whatever the flow first seeded and never track its lines again. + // ⚠️ `quote_generation` writes them too, but at CREATE time, and the strip + // is an UPDATE-path rule — that write would survive `readonly` untouched. + // The retired 16.x claim rested on that create-time write, which is how this + // note reached a right conclusion from the wrong writer. + // Measured in `test/readonly-write-semantics.test.ts` (insert is exempt) and + // `test/activity-recency.test.ts` (the `ctx.api` strip, on the real engine). + subtotal: Field15.currency({ + label: "Subtotal", + group: "pricing" + }), + discount: Field15.percent({ + label: "Discount %", + group: "pricing", + scale: 2, + min: 0, + max: 100 + }), + discount_amount: Field15.currency({ + label: "Discount Amount", + group: "pricing" + }), + tax: Field15.currency({ + label: "Tax", + group: "pricing" + }), + shipping_handling: Field15.currency({ + label: "Shipping & Handling", + group: "pricing" + }), + total_price: Field15.currency({ + label: "Total Price", + group: "pricing" + }), + // Terms + payment_terms: Field15.select({ + label: "Payment Terms", + group: "terms", + // Canonical set shared with Contract (#490) — see _picklists.ts. + options: [...PAYMENT_TERMS_OPTIONS] + }), + shipping_terms: Field15.text({ + label: "Shipping Terms", + group: "terms", + maxLength: 255 + }), + // Billing & Shipping Address + billing_address: Field15.address({ + label: "Billing Address", + group: "address" + }), + shipping_address: Field15.address({ + label: "Shipping Address", + group: "address" + }), + // Notes + description: Field15.markdown({ + label: "Description", + group: "basic" + }), + internal_notes: Field15.textarea({ + label: "Internal Notes", + group: "system" + }) + }, + // Database indexes + indexes: [ + { fields: ["crm_account"] }, + { fields: ["crm_opportunity"] }, + { fields: ["owner_id"] }, + { fields: ["status"] }, + { fields: ["quote_date"] } + ], + // Enable advanced features + // API surface. History → Field.trackHistory (ADR-0052). + enable: { + apiEnabled: true, + apiMethods: ["get", "list", "create", "update", "delete"], + // #602 — the generated quote PDF and the customer's countersigned copy. + // See the canonical capability note in `src/sales/objects/index.ts`. + files: true + }, + // Validation Rules + // + // Predicates below are TOTAL: every `record.x` read is `has()`-guarded, so the + // rule returns a verdict even when the merged record has no such key. See + // AGENTS.md "Validation predicates must be TOTAL" and + // test/object-validation-predicates.test.ts, which fails the build otherwise. + validations: [ + { + name: "expiration_after_quote", + type: "script", + severity: "error", + message: "Expiration Date must be after Quote Date", + condition: P16`has(record.expiration_date) && record.expiration_date != null && has(record.quote_date) && record.quote_date != null && record.expiration_date <= record.quote_date` + }, + { + // #599. The only discount constraint this object ever had was the field's + // own `max: 100` — the arithmetic domain of a percentage — so a rep could + // put 90% off a $99K deal on a quote and nothing anywhere objected: the + // approval flow keys on the opportunity's AMOUNT, and $99K is under the + // large-deal line. This is the policy ceiling that constraint never was. + // + // ⚠️ A predicate of `record.discount > 100` here would be DEAD: field-level + // bounds are evaluated BEFORE object validations, so `discount: 150` is + // already refused by `max: 100` with `code: 'max_value'` and the message + // "Discount % must be ≤ 100", and the rule's own message is unreachable on + // every input that could reach it. + // + // ### Why a script validation and not a lower `max` on the field + // + // This is an INVARIANT — "a quote's discount may never exceed the + // ceiling" — not a transition condition, and #1069 is open on exactly + // that distinction for `requiredWhen`. Both instruments were measured + // against a row stored above the ceiling before the rule existed + // (`test/quote-discount-ceiling.test.ts` runs the measurement): + // + // Field.percent({ max: 60 }) legacy row, unrelated edit → ADMITTED + // this rule legacy row, unrelated edit → REFUSED + // + // A field bound checks the value being WRITTEN; a script validation is + // evaluated against the MERGED record on every write. So `max` carries + // the same silent legacy hole #1069 describes, in a second instrument, + // and the rule does not. The cost of the invariant, stated rather than + // hidden: an over-ceiling row is frozen to everything except the repair — + // bringing the discount back under the ceiling is admitted, and is an + // ordinary edit. HotCRM ships no such row (deepest seeded discount: 20%). + // + // `max: 100` stays on the field as the domain of a percentage. The policy + // number lives in `_thresholds.ts`, interpolated into both the predicate + // and the message so the two cannot disagree. + name: "discount_within_ceiling", + type: "script", + severity: "error", + message: `Discount cannot exceed ${QUOTE_DISCOUNT_CEILING}%`, + condition: P16`has(record.discount) && record.discount != null && record.discount > ${QUOTE_DISCOUNT_CEILING}` + }, + { + // #575 B4. `crm_quote` had a full lifecycle vocabulary and no transition + // constraint whatsoever — nor a status guard in `quote.hook.ts` — so a + // quote could go straight from `draft` to `accepted`, which in CPQ terms + // is a signed number nobody reviewed or sent. `warning` severity matches + // the lead / opportunity / case machines: it flags the jump on the record + // without blocking a support-driven correction. + name: "quote_status_progression", + type: "state_machine", + severity: "warning", + message: "Invalid quote status transition", + field: "status", + transitions: { + // `→ expired` is legal from every UNSETTLED state: the quote_expiration + // flow sweeps on `expiration_date` alone and expires drafts that were + // never sent as readily as presented ones. + draft: ["in_review", "expired"], + in_review: ["draft", "presented", "rejected", "expired"], + presented: ["accepted", "rejected", "expired"], + // `accepted` and `expired` are terminal, and not only by convention — + // `quote_pricing_guard` in quote.hook.ts freezes both, allowing edits + // to `internal_notes` and nothing else. + accepted: [], + expired: [], + // A rejected quote is not frozen: the rep revises the numbers and + // re-issues, which starts again at `draft`. + rejected: ["draft"] + } + } + ] + // Workflow Rules + // ⚠️ No `workflows[]` here, and none is possible: object `workflows[]` were + // removed from the platform. Field updates live in this object's `*.hook.ts`; + // scheduled status flips and notifications live in `src/*/flows/*.flow.ts`. +}); + +// src/revenue/objects/quote_line_item.object.ts +import { ObjectSchema as ObjectSchema16, Field as Field16 } from "@objectstack/spec/data"; +import { F as F11, P as P17 } from "@objectstack/spec"; +var QuoteLineItem = ObjectSchema16.create({ + name: "crm_quote_line_item", + label: "Quote Line Item", + pluralLabel: "Quote Line Items", + icon: "package", + description: "A single product line on a Quote", + // OWD is an authored decision (ADR-0090 D1/D7). Record access DERIVES from + // the quote (ADR-0055). + // + // ⚠️ Reads ARE filtered to lines whose `crm_quote` the caller can read, and + // "can read" resolves through the same paths a direct read of the quote takes + // — owner scope and `sys_record_share` grants included, NOT the master's + // row-level security policies alone. A rep who owns one quote reads that + // quote's lines and no others. The parent-write gate derives the same way: a + // line whose quote the caller cannot edit is refused with a + // `PermissionDeniedError` naming the master. + // + // `test/parent-derived-reach.test.ts` pins those semantics with positive + // controls, so a regression is caught in either direction — it was written to + // go red the day the platform widens them: with the derivation consulting + // master RLS policies only, under a SYSTEM context, and no policy authored on + // `crm_quote`, the master set is EVERY quote and a line item is readable — + // and writable — by every holder of object-level read on this object. The + // relation resolver accepts a REQUIRED LOOKUP as the parent, so no + // master-detail conversion is needed. + // + // ⛔ Not `private`: with no owner field on this object that resolves to the + // platform's auto-stamped `owner_id` — the row's inserter — so lines cloned + // onto a quote by the `quote_generation` flow are invisible to the rep who + // owns the quote. + sharingModel: "controlled_by_parent", + // Per-field history is opt-in via `Field.trackHistory` (ADR-0052), set on + // quantity/unit_price/discount below. Master-detail children still inherit + // the master's sharing automatically. + highlightFields: ["crm_product", "quantity", "unit_price", "total_price"], + // The same two-group split as `crm_opportunity_line_item` (#1453), derived + // from the ten fields declared here: every factor `total_price` multiplies + // is `pricing`, everything that says WHICH line this is is `basic`. + // + // ⚠️ Neither group may be a subset of the highlight strip — see the twin + // object for the hoisting rule this satisfies. + fieldGroups: [ + { key: "basic", label: "Line Item", icon: "package" }, + { key: "pricing", label: "Pricing", icon: "dollar-sign" } + ], + fields: { + // The parent link — same decision, same reasoning, as + // `opportunity_line_item.crm_opportunity` (#727); read the long note there. + // In short: declaring nothing resolves to the spec default `set_null`, which + // the engine escalates to `restrict` on a REQUIRED lookup, so every quote + // that had been itemised refused to delete with a 409 quoting this field. + // A quote line is subordinate to its quote (`quote_line_item.hook.ts` rolls + // the quote's subtotal/total UP from these rows), so it goes with it. + crm_quote: Field16.masterDetail("crm_quote", { + label: "Quote", + group: "basic", + required: true, + storage: { notNull: true }, + deleteBehavior: "cascade", + // Curates the line-items panel on a quote's detail page (#1199) — the + // mechanism that panel reads first (#944; the long note is on + // `crm_campaign_member.crm_campaign`). A SUPERSET of the fallback it + // replaces (`highlightFields` minus this lookup: Product / Quantity / + // Sales Price / Total) plus `subtotal`, the line's price after its own + // discount — the formula was evaluated on every read and shown in no list. + // + // ⛔ Not added to `highlightFields`: the detail page hoists the first + // four of that strip, so a fifth entry never reaches the strip, and + // reordering it would evict `total_price` from the record's header. + relatedListColumns: ["crm_product", "quantity", "unit_price", "subtotal", "total_price"] + }), + // Left on the restricting default on purpose — see the twin object: a + // product's catalog entry must not take priced quote history with it. + crm_product: Field16.lookup("crm_product", { + label: "Product", + group: "basic", + required: true, + storage: { notNull: true } + }), + description: Field16.text({ + label: "Description", + group: "basic", + maxLength: 500 + }), + quantity: Field16.number({ + label: "Quantity", + group: "pricing", + required: true, + storage: { notNull: true }, + scale: 2, + min: 0, + defaultValue: 1, + trackHistory: true + }), + list_price: Field16.currency({ + label: "List Price", + group: "pricing", + readonly: true + }), + unit_price: Field16.currency({ + label: "Sales Price", + group: "pricing", + required: true, + storage: { notNull: true }, + trackHistory: true + }), + discount: Field16.percent({ + label: "Discount %", + group: "pricing", + scale: 2, + min: 0, + max: 100, + defaultValue: 0, + trackHistory: true + }), + subtotal: Field16.formula({ + label: "Subtotal", + group: "pricing", + expression: F11`record.quantity * record.unit_price * (1 - record.discount / 100)` + }), + // A line carries no tax: tax is the quote's own amount (#2069), so Total is + // `subtotal`'s expression, not a read of `subtotal` — a formula reading a + // formula depends on hydration order (`lead.object.ts:61-64`). + total_price: Field16.formula({ + label: "Total", + group: "pricing", + expression: F11`record.quantity * record.unit_price * (1 - record.discount / 100)` + }), + line_number: Field16.number({ + label: "Line #", + group: "basic", + scale: 0, + readonly: true + }) + }, + // Predicates below are TOTAL: every `record.x` read is `has()`-guarded, so the + // rule returns a verdict even when the merged record has no such key. See + // AGENTS.md "Validation predicates must be TOTAL" and + // test/object-validation-predicates.test.ts, which fails the build otherwise. + validations: [ + { + name: "unit_price_positive", + type: "script", + severity: "error", + message: "Sales price cannot be negative", + condition: P17`has(record.unit_price) && record.unit_price != null && record.unit_price < 0` + }, + { + // #1086. The other half of #599's ceiling, and the reason that card's own + // acceptance criterion — "a quote with a 90% line discount cannot reach + // `presented`" — was not met by the quote-level rule alone. + // + // ### The walk-around this closes + // + // A quote's total has TWO independent discount multipliers, and + // `quote_total_rollup` composes them: + // + // subtotal = Σ line (quantity × unit_price × (1 − LINE discount/100)) + // discount_amount = subtotal × QUOTE discount% + // + // #599 put a ceiling on the second one only. So a quote at + // `discount: 0` — which clears `discount_within_ceiling` on `crm_quote` + // outright — with every line at `discount: 90` prices 90% below list, and + // nothing objected: this object's only discount constraint was the + // field's own `max: 100`, the arithmetic domain of a percentage. An + // invariant with a documented walk-around is worse than no invariant, + // because a reader (human or AI) cites the rule as the guarantee. + // + // ### Same constant, same instrument, deliberately + // + // The number is `QUOTE_DISCOUNT_CEILING` — imported, never retyped, so the + // two ceilings are one policy and cannot drift into two. The instrument is + // a `type: 'script'` validation for the reason #599 measured on the quote + // (and this card re-measured on this object, in + // `test/quote-discount-ceiling.test.ts`): a field-level `max` validates + // only the value being WRITTEN, so a line stored above the ceiling before + // the rule existed keeps accepting edits forever, while a script + // validation is evaluated against the MERGED record on every write and is + // therefore a true invariant. `max: 100` stays on the field as the domain + // of a percentage; the policy line lives here. + // + // ### What this rule does NOT decide + // + // 60% per line AND 60% on the quote still compounds to ~84% EFFECTIVE. + // Whether the ceiling should be read against the effective discount is a + // business-policy question with no answer in this codebase, and it is + // open as #1109 — deliberately not guessed here. A per-line ceiling is + // correct under either answer: it is the whole policy if the answer is + // per-line, and a component of it if the answer is effective. + name: "discount_within_ceiling", + type: "script", + severity: "error", + // Names the LINE, because the quote carries a same-named rule with its + // own message: on a refused save the rep must be able to tell which of + // the two numbers the platform is objecting to. + message: `Line discount cannot exceed ${QUOTE_DISCOUNT_CEILING}%`, + condition: P17`has(record.discount) && record.discount != null && record.discount > ${QUOTE_DISCOUNT_CEILING}` + } + ] +}); + +// src/marketing/objects/index.ts +var objects_exports4 = {}; +__export(objects_exports4, { + Campaign: () => Campaign, + CampaignMember: () => CampaignMember +}); + +// src/marketing/objects/campaign.object.ts +import { ObjectSchema as ObjectSchema17, Field as Field17 } from "@objectstack/spec/data"; +import { F as F12, P as P18 } from "@objectstack/spec"; +var Campaign = ObjectSchema17.create({ + name: "crm_campaign", + label: "Campaign", + pluralLabel: "Campaigns", + icon: "megaphone", + description: "Marketing campaigns and initiatives", + // ADR-0090 D1/D7: OWD is an authored decision. Campaign catalog is org-visible; only owners edit. + sharingModel: "public_read", + // ADR-0079: render-only `titleFormat` retired in favor of `nameField`, + // which names a real field. The former template composed two local fields, so + // a `display_title` formula field reproduces it for the record title. + nameField: "display_title", + // Explicit search targets (ADR-0061). REQUIRED because nameField is a + // FORMULA (display_title/full_name): without this, $search auto-defaults to + // the formula field, which isn't a real column, so the lookup picker + global + // search silently return zero. These are real, indexed columns. + searchableFields: ["name", "campaign_code"], + highlightFields: ["campaign_code", "name", "type", "status", "start_date"], + // Every other business object with a detail page groups its fields; campaign + // was one of the two that did not, so its detail page fell back to one flat + // 30-field grid with the ROI formulas sitting next to the campaign name. The + // labels mirror the sections the campaign form uses (Campaign Information / + // Schedule / Budget & ROI / Performance) so the two surfaces agree — the + // form's old three-section shape buried the two manual-entry cost fields in a + // combined "Schedule & Budget" row and was split to match this one (#597). + fieldGroups: [ + { key: "basic", label: "Campaign Information", icon: "megaphone" }, + { key: "schedule", label: "Schedule", icon: "calendar" }, + { key: "budget", label: "Budget & ROI", icon: "dollar-sign" }, + { key: "metrics", label: "Performance", icon: "bar-chart" }, + { key: "assignment", label: "Ownership", icon: "user" }, + { key: "assets", label: "Campaign Assets", icon: "link", collapse: "collapsed" } + ], + fields: { + // Platform ownership anchor — canonical note in `account.object.ts` (#548). + owner_id: Field17.lookup("sys_user", { + label: "Campaign Owner", + group: "assignment", + system: true, + readonly: false, + trackHistory: true + }), + // AutoNumber field + campaign_code: Field17.autonumber({ + group: "basic", + label: "Campaign Code", + format: "CPG-{0000}" + }), + // Basic Information + name: Field17.text({ + group: "basic", + label: "Campaign Name", + required: true, + storage: { notNull: true }, + searchable: true, + maxLength: 255 + }), + // ADR-0079 record title (was titleFormat '{campaign_code} - {name}'). + display_title: Field17.formula({ + group: "basic", + label: "Display Title", + expression: F12`record.campaign_code + " - " + record.name` + }), + description: Field17.markdown({ + group: "basic", + label: "Description" + }), + // Type & Channel + type: Field17.select({ + group: "basic", + label: "Campaign Type", + options: [ + { label: "Email", value: "email", default: true }, + { label: "Webinar", value: "webinar" }, + { label: "Trade Show", value: "trade_show" }, + { label: "Conference", value: "conference" }, + { label: "Direct Mail", value: "direct_mail" }, + { label: "Social Media", value: "social_media" }, + { label: "Content Marketing", value: "content" }, + { label: "Partner Marketing", value: "partner" } + ] + }), + channel: Field17.select({ + group: "basic", + label: "Primary Channel", + options: [ + { label: "Digital", value: "digital" }, + { label: "Social", value: "social" }, + { label: "Email", value: "email" }, + { label: "Events", value: "events" }, + { label: "Partner", value: "partner" } + ] + }), + // Status + status: Field17.select({ + group: "basic", + label: "Status", + options: [ + { label: "Planning", value: "planning", color: "#999999", default: true }, + { label: "In Progress", value: "in_progress", color: "#FFA500" }, + { label: "Completed", value: "completed", color: "#00AA00" }, + { label: "Aborted", value: "aborted", color: "#FF0000" } + ], + required: true, + storage: { notNull: true }, + trackHistory: true + }), + // Dates + start_date: Field17.date({ + group: "schedule", + label: "Start Date", + required: true, + storage: { notNull: true } + }), + end_date: Field17.date({ + group: "schedule", + label: "End Date", + required: true, + storage: { notNull: true } + }), + // Budget & ROI + budgeted_cost: Field17.currency({ + group: "budget", + label: "Budgeted Cost", + min: 0 + }), + actual_cost: Field17.currency({ + group: "budget", + label: "Actual Cost", + min: 0 + }), + expected_revenue: Field17.currency({ + group: "budget", + label: "Expected Revenue", + min: 0 + }), + // ⛔ NOT `readonly` (here and on the num_* snapshot fields below), and the + // reason holds on the pinned engine rather than on the retired 16.x claim + // this note used to carry. The metric block — `CAMPAIGN_METRIC_FIELDS` in + // `campaign.hook.ts` — is written by FOUR refresh hooks, not by the + // long-retired `campaign_snapshot_metrics`: `campaign_metrics_refresh`, + // `campaign_attribution_refresh`, `campaign_lead_conversion_refresh` and + // `campaign_member_metrics_refresh`. Every one of them writes + // `api.object('crm_campaign').update(...)`, and none declares `Hook.runAs`, + // which defaults to `'inherit'` — so `ctx.api` is a `ScopedContext` over the + // ACTING USER's context, and the keys are CALLER-supplied to a + // non-`isSystem` UPDATE, exactly what `stripReadonlyFields` deletes. Their + // least-privileged trigger is an ordinary user edit — a rep moving a + // campaign's status, saving an opportunity, enrolling a member — so + // `readonly` here would freeze the whole block at its seeded values. + // Measured in `test/activity-recency.test.ts`, which runs this same + // `ctx.api` shape through the real engine under a plain user context. + actual_revenue: Field17.currency({ + group: "budget", + label: "Actual Revenue", + min: 0 + }), + // Metrics + target_size: Field17.number({ + group: "metrics", + label: "Target Size", + description: "Target number of leads/contacts", + min: 0 + }), + // NOT `readonly`: written by the same four refresh hooks, and for the same + // reason — see the note on `actual_revenue` above. + // Definition: total members enrolled. + num_sent: Field17.number({ + group: "metrics", + label: "Number Sent", + min: 0 + }), + num_responses: Field17.number({ + group: "metrics", + label: "Number of Responses", + min: 0 + }), + num_leads: Field17.number({ + group: "metrics", + label: "Number of Leads", + min: 0 + }), + num_converted_leads: Field17.number({ + group: "metrics", + label: "Converted Leads", + min: 0 + }), + num_opportunities: Field17.number({ + group: "metrics", + label: "Opportunities Created", + min: 0 + }), + num_won_opportunities: Field17.number({ + group: "metrics", + label: "Won Opportunities", + min: 0 + }), + // Calculated Metrics (Formula Fields) + response_rate: Field17.formula({ + group: "metrics", + label: "Response Rate %", + expression: F12`coalesce(record.num_sent, 0) > 0 ? (coalesce(record.num_responses, 0) * 100.0) / record.num_sent : 0.0`, + scale: 2 + }), + roi: Field17.formula({ + group: "budget", + label: "ROI %", + expression: F12`coalesce(record.actual_cost, 0) > 0 ? ((coalesce(record.actual_revenue, 0) - record.actual_cost) * 100.0) / record.actual_cost : 0.0`, + scale: 2 + }), + // No `parent_campaign`. Campaign hierarchy was declared and never used: no + // page, doc or report mentioned it, and the honest consumer for it — a + // rolled-up ROI — cannot be one declaration. `roi` here is a formula over + // this campaign's OWN `actual_cost` / `actual_revenue`, so a hierarchy ROI + // would put a second, differently-scoped ROI on the same record and leave + // every reader to guess which one they were looking at. + // Campaign Assets + landing_page_url: Field17.url({ + group: "assets", + label: "Landing Page" + }), + is_active: Field17.boolean({ + group: "assets", + label: "Active", + defaultValue: true + }) + }, + // Database indexes + indexes: [ + { fields: ["name"] }, + { fields: ["type"] }, + { fields: ["status"] }, + { fields: ["start_date"] }, + { fields: ["owner_id"] } + ], + // Enable advanced features + // API surface. History → Field.trackHistory (ADR-0052). + enable: { + apiEnabled: true, + apiMethods: ["get", "list", "create", "update", "delete"] + }, + // Validation Rules + // + // Predicates below are TOTAL: every `record.x` read is `has()`-guarded, so the + // rule returns a verdict even when the merged record has no such key. See + // AGENTS.md "Validation predicates must be TOTAL" and + // test/object-validation-predicates.test.ts, which fails the build otherwise. + validations: [ + { + name: "end_after_start", + type: "script", + severity: "error", + message: "End Date must be after Start Date", + // `<=`, not `<`: the message promises "after", so a campaign that ends + // the day it starts is a violation. Matches `crm_contract`'s twin rule + // and `crm_forecast.period_end_after_start` (#514 item 12). + condition: P18`has(record.end_date) && record.end_date != null && has(record.start_date) && record.start_date != null && record.end_date <= record.start_date` + }, + { + name: "actual_cost_within_budget", + type: "script", + severity: "warning", + message: "Actual Cost exceeds Budgeted Cost", + condition: P18`has(record.actual_cost) && record.actual_cost != null && has(record.budgeted_cost) && record.budgeted_cost != null && record.actual_cost > record.budgeted_cost` + } + ] + // Workflow Rules + // ⚠️ No `workflows[]` here, and none is possible: object `workflows[]` were + // removed from the platform. Field updates live in this object's `*.hook.ts`; + // scheduled status flips and notifications live in `src/*/flows/*.flow.ts`. +}); + +// src/marketing/objects/campaign_member.object.ts +import { ObjectSchema as ObjectSchema18, Field as Field18 } from "@objectstack/spec/data"; +import { P as P19 } from "@objectstack/spec"; +var CampaignMember = ObjectSchema18.create({ + name: "crm_campaign_member", + label: "Campaign Member", + pluralLabel: "Campaign Members", + icon: "user-plus", + description: "Membership and response tracking for marketing campaigns", + // ADR-0090 D1/D7: OWD is an authored decision. Membership is an attribute of + // the campaign, so record access DERIVES from it (ADR-0055). The relation + // resolver accepts the REQUIRED `crm_campaign` LOOKUP as the parent, so no + // master-detail conversion is needed. + // + // The derivation delivers exactly "members whose `crm_campaign` the caller + // can read". ⚠️ Master accessibility resolves through the same paths a direct + // read of the campaign takes — ownership and `sys_record_share` grants folded + // in ALONGSIDE the master's row-level security policies, not the policies + // alone. `test/parent-derived-reach.test.ts` pins that, and was written to go + // red the day the platform changes it: an earlier version consulted master + // RLS ONLY, under a SYSTEM context, so with no policy narrowing a SELECT on + // `crm_campaign` a member row was readable by every holder of object-level + // read on this object. + // + // ⚠️ The write side reaches further than reads: the platform's + // `member_default` set carries an owner-only-writes RLS policy on updates, + // and because the derivation folds master RLS in, that policy reaches through + // to member writes — see the `marketing_campaign_updates` note in + // `src/sales/profiles/marketing-user.profile.ts`. + // + // ⛔ Not `private`: with no owner field on the junction row that resolves to + // "whoever inserted it", which is nobody's idea of campaign membership and + // hides rows written by the enrollment flow. + sharingModel: "controlled_by_parent", + // Per-field history is opt-in via `Field.trackHistory` (ADR-0052), set on + // `status` below — there is no object-level history flag. + // ADR-0079: junction rows have no derivable text title; point the canonical + // nameField at the stored autonumber explicitly (autonumber is not in the + // auto-derivation whitelist). + nameField: "member_number", + // Load-bearing on TWO surfaces, and the second one is why this list is not + // the side that gave way to fix `field-group-shadowed` below (#715). Besides the + // detail highlight strip, it is what curates the members panel on a + // campaign's detail page: a related list takes its columns from the child's + // `highlightFields` minus the lookup it is scoped by, and this object ships + // no view at all, so dropping `crm_lead`/`crm_contact` here would leave that + // panel showing Status / Response Date and no person — measured and pinned in + // `test/view-references.test.ts` (#944). + highlightFields: ["crm_campaign", "crm_lead", "crm_contact", "status", "response_date"], + // Both groups render on detail pages as well as on forms, and keeping them + // that way is a constraint on the two lists above, not a free choice (#715). + // A synthesized detail page hoists the record title plus the first four + // highlightFields out of the body, so a group whose every field is hoisted + // keeps its heading on forms and silently disappears from detail pages + // (`field-group-shadowed`). + // `basic` was exactly that: member_number is the title, and campaign/lead/ + // contact are the first three of the strip. `added_date` — the enrollment + // stamp, which describes the MEMBERSHIP rather than the person's response — + // sits here rather than under `response` so the group has something of its + // own to show. Same resolution as `crm_task`'s shadowed `assignment` group + // (#582): move the field to the group it reads under, leave the strip alone. + fieldGroups: [ + { key: "basic", label: "Basic Information", icon: "info" }, + { key: "response", label: "Response Tracking", icon: "activity" } + ], + fields: { + member_number: Field18.autonumber({ + label: "Member Number", + format: "CM-{00000}", + group: "basic" + }), + crm_campaign: Field18.lookup("crm_campaign", { + label: "Campaign", + required: true, + storage: { notNull: true }, + group: "basic", + // Curates the members panel on a campaign — and it is the ONE mechanism + // that actually reaches that panel. Measured in #944 and restated in + // `test/view-references.test.ts`: a detail-page related list reads + // `relatedListColumns` on the CHILD's lookup first, and only without it + // falls back to the child's `highlightFields` minus this lookup. The + // child's `list` view is never consulted, which is why authoring one + // here would not have shown anything. + // + // It is a SUPERSET of the fallback it replaces — Lead / Contact / + // Status / Response Date, in that order — plus the one column the panel + // was missing. `added_date` is the enrollment stamp: `readonly: true` + // (#1667) and written on every enrollment by the two elevated sub-flows + // #1807 built for it, so a marketer could see WHEN a member responded + // but not when they were added, on a register whose whole subject is + // the enrollment. It sits after the person and before the response + // lifecycle, which is the order the row happens in. + // + // ⛔ Deliberately NOT solved by adding `added_date` to + // `highlightFields`: that strip is hoisted out of the detail body, and + // `added_date` is the only field in the `basic` group that is neither + // the record title nor already in the strip — hoisting it would leave + // the group with nothing of its own and silently vanish its heading + // from every detail page (`field-group-shadowed`, the trap the note + // above this object's `fieldGroups` records being rescued from). + relatedListColumns: ["crm_lead", "crm_contact", "added_date", "status", "response_date"] + }), + // `deleteBehavior: 'cascade'` on BOTH party lookups (#696). A lookup + // defaults to `set_null`, and that default made every enrolled person + // permanently undeletable: deleting the lead cleared this column, the + // cleared row instantly violated `lead_or_contact_required` below, and the + // whole delete rolled back with a 400 naming an object the caller never + // touched ("A campaign member must reference either a Lead or a Contact", + // `"object":"crm_lead"`). A GDPR "delete this person" request could not be + // served through the API or the UI. + // + // Cascade rather than `restrict`: this is a JUNCTION row whose entire + // meaning is "this person is enrolled in this campaign". Once the person is + // gone the row denotes nothing, so keeping it (restrict) would only trade + // one undeletable person for a manual un-enrol chore, and the impact this + // fixes is undeletable people, not a confusing message. Cascade also makes + // the object's own rule unfalsifiable by construction: there is no longer a + // reachable state in which a stored member row breaks it. + crm_lead: Field18.lookup("crm_lead", { + label: "Lead", + group: "basic", + deleteBehavior: "cascade", + description: "Set when the member was a Lead at enrollment time" + }), + crm_contact: Field18.lookup("crm_contact", { + label: "Contact", + group: "basic", + deleteBehavior: "cascade", + description: "Set when the member is an existing Contact" + }), + // ⭐ `readonly: true` — DECLARED, and it still costs no writer its write, + // but the reason CHANGED on the @objectstack/* 17.4.0 migration. It used to + // be "the strip is an UPDATE-path rule and every writer here is an INSERT". + // objectql 17.4.0 retired that: a static readonly field is now stripped from + // a NON-SYSTEM caller's INSERT payload inside `engine.insert` too, so an + // ordinary user-context create no longer seeds this column. + // + // Every writer is therefore elevated now, and the elevation is scoped as + // narrowly as AGENTS.md house rule 9 requires — the `campaign_enrollment` + // SCREEN flow stays `runAs: 'user'` and hands only the insert to + // `campaign_lead_member_enroll` / `campaign_contact_member_enroll` + // (`runAs: 'system'`, one `create_record` each); the marketing seed is a + // system write already. Nothing updates it: there is no `update_record` + // node, no hook and no action that writes `added_date`. This column's own + // two halves are pinned in `test/audit-stamp-readonly.test.ts` — the + // enrollment writers still stamp it, and a user-context UPDATE is stripped. + // Ruled #1667 (director seat, decision batch #74, 2026-09-07): an + // enrollment stamp nobody is meant to hand-edit gets the declaration that + // says so. ⛔ The 16.x claim this note used to carry ("every member landed + // with a null Added Date while the flag was on") described an engine this + // repo no longer runs; ⛔ do not resurrect it as a reason to open the + // column back up. + // + // Grouped under `basic`, not `response` (#715): it records when the + // membership was created, which is a fact about the enrollment, not a step + // in the response lifecycle the other stamps track. + added_date: Field18.datetime({ + label: "Added Date", + group: "basic", + readonly: true + }), + // Writers, one per surviving value (#597): + // sent — campaign_enrollment flow, `create_campaign` (leads) and + // `add_contact_to_campaign` (contacts) stamp it on insert. + // responded — the `mark_responded` action (src/marketing/actions/campaign.actions.ts). + // converted — the member's lead converting; `campaign_lead_conversion_refresh` + // (src/sales/objects/lead.campaign-metrics.hook.ts) promotes + // the row when `crm_lead.is_converted` flips. + // unsubscribed — set by a rep (or an opt-out request) on the member row; + // `campaign_member_optout_sync` round-trips it to the + // lead/contact's `email_opt_out`, which is what makes the + // enrollment flow's opt-out filter honour it next run. + // + // `opened` / `clicked` / `bounced` were removed here — see the object + // docblock. Nothing on the platform can produce them. + status: Field18.select({ + label: "Status", + required: true, + storage: { notNull: true }, + group: "response", + trackHistory: true, + options: [ + { label: "Sent", value: "sent", default: true, color: "#A0A0A0" }, + { label: "Responded", value: "responded", color: "#00AA00" }, + { label: "Converted", value: "converted", color: "#7C3AED" }, + { label: "Unsubscribed", value: "unsubscribed", color: "#FF0000" } + ] + }), + // Written by the `mark_responded` action, and by + // `campaign_member_lifecycle` when it back-fills a member whose response + // was recorded by flipping `status` directly. + response_date: Field18.datetime({ + label: "Response Date", + group: "response" + }), + // Kept in lockstep with `status == "responded"` by + // `campaign_member_lifecycle` (beforeInsert/beforeUpdate) — a boolean that + // disagrees with the status it summarises is the shape the response + // surfaces cannot render, and it is what `test/seed-consistency.test.ts` + // already pins on the seed side. + has_responded: Field18.boolean({ + label: "Has Responded", + defaultValue: false, + group: "response" + }) + }, + // Predicates below are TOTAL: every `record.x` read is `has()`-guarded, so the + // rule returns a verdict even when the merged record has no such key. See + // AGENTS.md "Validation predicates must be TOTAL" and + // test/object-validation-predicates.test.ts, which fails the build otherwise. + validations: [ + { + name: "lead_or_contact_required", + type: "script", + severity: "error", + message: "A campaign member must reference either a Lead or a Contact", + condition: P19`(!has(record.crm_lead) || isBlank(record.crm_lead)) && (!has(record.crm_contact) || isBlank(record.crm_contact))` + } + ] +}); + +// src/sales/actions/index.ts +var actions_exports = {}; +__export(actions_exports, { + AccountLogCallAction: () => AccountLogCallAction, + AccountLogMeetingAction: () => AccountLogMeetingAction, + AccountScheduleMeetingAction: () => AccountScheduleMeetingAction, + AddContactToCampaignAction: () => AddContactToCampaignAction, + CloneOpportunityAction: () => CloneOpportunityAction, + ContactLogCallAction: () => ContactLogCallAction, + ContactLogMeetingAction: () => ContactLogMeetingAction, + ContactScheduleMeetingAction: () => ContactScheduleMeetingAction, + ConvertLeadAction: () => ConvertLeadAction, + CreateCampaignAction: () => CreateCampaignAction, + GenerateQuoteAction: () => GenerateQuoteAction, + LeadLogCallAction: () => LeadLogCallAction, + LeadLogMeetingAction: () => LeadLogMeetingAction, + LeadScheduleMeetingAction: () => LeadScheduleMeetingAction, + MarkPrimaryContactAction: () => MarkPrimaryContactAction, + MassUpdateStageAction: () => MassUpdateStageAction, + OpportunityLogCallAction: () => OpportunityLogCallAction, + OpportunityLogMeetingAction: () => OpportunityLogMeetingAction, + OpportunityScheduleMeetingAction: () => OpportunityScheduleMeetingAction, + ScheduleFollowUpAction: () => ScheduleFollowUpAction, + SendEmailAction: () => SendEmailAction +}); + +// src/sales/actions/contact.actions.ts +import { P as P20 } from "@objectstack/spec"; +var MarkPrimaryContactAction = { + name: "mark_primary", + label: "Mark as Primary Contact", + objectName: "crm_contact", + icon: "star", + type: "script", + body: { + language: "js", + source: ` + const id = ctx.recordId; + if (!id) throw new Error('mark_primary requires a recordId'); + await ctx.api.object('crm_contact').update({ id, is_primary: true }, { where: { id } }); + return { ok: true, id, is_primary: true }; + `, + capabilities: ["api.write"], + timeoutMs: 2e3 + }, + locations: ["record_header", "list_item"], + visible: P20`has(record.is_primary) && record.is_primary == false`, + confirmText: "Mark this contact as the primary contact for the account?", + successMessage: "Contact marked as primary!", + refreshAfter: true +}; +var AddContactToCampaignAction = { + name: "add_contact_to_campaign", + label: "Add to Campaign", + objectName: "crm_contact", + icon: "send", + type: "script", + body: { + language: "js", + source: ` + // Value key = the param's field name ('crm_campaign') since the param + // omits an explicit 'name'. Insert uses the REAL lookup field names on + // crm_campaign_member (crm_campaign / crm_contact). + const campaignId = input.crm_campaign ?? null; + if (!campaignId) throw new Error('add_contact_to_campaign requires a campaign id'); + const ids = ctx.recordId ? [ctx.recordId] : []; + if (!ids.length) throw new Error('add_contact_to_campaign: no contact selected'); + const raw = await ctx.api.object('crm_campaign_member').find({ + where: { crm_campaign: campaignId }, + fields: ['crm_contact'], + top: 5000, + }); + const existingRows = Array.isArray(raw) ? raw : (raw?.records ?? []); + const existing = new Set(existingRows.map((r) => r.crm_contact)); + const inserted = []; + let skipped = 0; + for (const contactId of ids) { + if (existing.has(contactId)) { skipped++; continue; } + const row = await ctx.api.object('crm_campaign_member').insert({ + crm_campaign: campaignId, + crm_contact: contactId, + status: 'sent', + }); + inserted.push(row?.id ?? null); + } + return { campaignId, count: inserted.length, skipped, ids: inserted }; + `, + capabilities: ["api.read", "api.write"], + timeoutMs: 1e4 + }, + locations: ["list_toolbar", "list_item"], + params: [ + { + field: "crm_campaign", + objectOverride: "crm_campaign_member", + label: "Campaign", + required: true + } + ], + // An opted-out contact must not be added to a campaign by hand either — the + // enrollment flow already filters them out, and a manual add-to-campaign is + // the obvious way around a filter nobody remembers is there. Same predicate + // the `send_email` action uses. + visible: P20`has(record.email_opt_out) && record.email_opt_out == false`, + successMessage: "Contacts added to campaign!", + refreshAfter: true +}; +var SendEmailAction = { + name: "send_email", + label: "Send Email", + objectName: "crm_contact", + icon: "mail", + // script, not modal: modal submits die on GET /api/v1/meta/object/ + // → 400 in 16.1.0; script actions POST /api/v1/actions/... and execute. + type: "script", + body: { + language: "js", + source: ` + const record = ctx.record ?? {}; + const recipientId = ctx.recordId ?? record.id ?? null; + const to = record.email ? String(record.email) : ''; + const from = ctx.user?.email ?? 'noreply@hotcrm.local'; + const userId = ctx.user?.id ?? null; + const subject = input.subject ? String(input.subject) : ('Email to ' + to); + const body = input.body ? String(input.body) : ''; + const email = await ctx.api.object('sys_email').insert({ + from_address: from, + to_addresses: to, + subject, + body_text: body, + status: 'queued', + related_object: 'crm_contact', + related_id: recipientId, + sent_by: userId, + }); + + ${ACTOR_NAME_RESOLUTION_SOURCE} + + // Surface the email on the contact's unified activity timeline + // (the audit writer only logs generic CRUD; this is the semantic event). + const activity = await ctx.api.object('sys_activity').insert({ + type: 'completed', + summary: 'Email: ' + subject, + actor_id: userId, + actor_name: actorName, + object_name: 'crm_contact', + record_id: recipientId, + record_label: record.full_name ?? record.name ?? to, + // ADR-0052 ActivityPointer: structured pointer to the rich source entity + // (the sys_email row) so the timeline renders a "View source \u2192" drill to + // the full email \u2014 the queryable replacement for stashing the id in metadata. + source_object: 'sys_email', + source_id: email?.id ?? null, + metadata: JSON.stringify({ kind: 'email', to, subject }), + }); + // #592 scope item 3: every activity writer bumps interaction recency. + // An email is an interaction but NOT a calendar slot, so it writes no + // \`crm_event\` \u2014 which means it cannot ride the event hook's bubble and + // has to stamp the two timestamps itself. Both columns are deliberately + // non-readonly (see crm_account.last_activity_date's note): a readonly + // field is stripped from any non-system write whose caller supplied the + // key (#2948), and an action body runs under the sending rep's context. + if (recipientId) { + const nowIso = new Date().toISOString(); + try { + await ctx.api.object('crm_contact').update( + { id: recipientId, last_contacted_date: nowIso }, + { where: { id: recipientId } }, + ); + } catch (e) { /* best-effort recency; never fail the send */ } + const accountId = record.crm_account ? String(record.crm_account) : null; + if (accountId) { + try { + await ctx.api.object('crm_account').update( + { id: accountId, last_activity_date: nowIso.slice(0, 10) }, + { where: { id: accountId } }, + ); + } catch (e) { /* best-effort recency; never fail the send */ } + } + } + return { emailId: email?.id, activityId: activity?.id }; + `, + capabilities: ["api.read", "api.write"], + timeoutMs: 5e3 + }, + locations: ["record_header", "list_item"], + visible: P20`has(record.email_opt_out) && record.email_opt_out == false`, + params: [ + { name: "subject", label: "Subject", type: "text", required: true }, + { name: "body", label: "Body", type: "textarea", required: true } + ], + refreshAfter: false +}; + +// src/sales/actions/lead.actions.ts +import { P as P21 } from "@objectstack/spec"; +var ConvertLeadAction = { + name: "convert_lead", + label: "Convert Lead", + objectName: "crm_lead", + icon: "arrow-right-circle", + type: "flow", + target: "lead_conversion", + locations: ["record_header", "list_item"], + // Convert is the lead's most basic outcome — surface it on ANY open lead + // (new / contacted / qualified), not just qualified. Gating to qualified-only + // hid the button on most seeded leads, so it read as "conversion is missing". + // Only already-converted or disqualified leads hide it. + // + // TOTALITY (AGENTS.md → "Validation predicates must be TOTAL", #630): every + // `record.x` read carries a `has(record.x)`, and the guards are arranged to + // fail CLOSED — an unknown record hides the button. That arrangement is a + // MEASUREMENT, not a preference. Measured in the browser on console 17.4.0 by + // instrumenting the shipped predicate evaluator: the record page evaluates this + // predicate twice against an EMPTY record (`record` is `{}`, zero keys) before + // the row lands, then re-evaluates it against the full row. So an absent + // `status` here means "no record yet", never "a lead with no status" — a lead + // with no status cannot exist, since `status` is `required` with + // `storage: { notNull: true }` and `defaultValue: 'new'` (src/sales/objects/lead.object.ts), + // and the REST payload this surface reads carries every declared column. + // Fail-open (`!has(record.status) || …`) would therefore buy nothing and cost + // something real: Convert would flash on a disqualified lead for the + // pre-hydration beat, on an IRREVERSIBLE action. + // Unguarded, strict CEL aborted the whole predicate on those two renders + // (`[runtime] No such key: status`) and object-ui fell back to its own + // `fallback: false`, so this spelling states the policy the error path was + // already applying — minus the console warning on every lead page load. (#1890) + // + // ⚠️ The approval term is the ONE fail-OPEN read in this predicate, and the + // asymmetry is deliberate rather than an oversight in an otherwise + // fail-closed arrangement (REQ-0005 step 7). The two terms above fail closed + // because an absent `status` means "no record yet" — a lead with no status + // cannot exist, since `status` is `required` with a `defaultValue`. An absent + // `conversion_approval_status` means something else entirely: a lead written + // before the column existed, which must convert the way it always did. And + // the shipped `not_required` default is the gate's OFF position, so treating + // "not one of the two refusing verdicts" as convertible is what makes the + // default install behave exactly as it did before this field. `lead.hook.ts` + // and `lead-conversion.flow.ts`'s `decision_approval` carry the same polarity + // — the three surfaces have to agree about what "off" means, or the button + // disappears on leads the write path would happily convert. + // + // ⛔ Hiding this button is NOT the gate. It is the courtesy half; the control + // is the `beforeUpdate` refusal in `lead.hook.ts`, which a REST caller cannot + // route around. + visible: P21`has(record.is_converted) && record.is_converted == false && has(record.status) && record.status != "unqualified" && record.status != "converted" + && (!has(record.conversion_approval_status) || (record.conversion_approval_status != "pending" && record.conversion_approval_status != "rejected"))`, + // NO `confirmText`. A screen flow IS the confirmation, and this one opens + // `Conversion Details` — a screen carrying the decision (`Create + // Opportunity?`, and the deal's name and amount), a Cancel button, and the + // suspected-duplicate warning that says something TRUE about THIS lead. A + // dialog in front of it costs every conversion one extra click to answer a + // question it cannot help anyone answer. Confirms are for DESTRUCTIVE actions + // with no follow-up UI — `close_case` / `escalate_case` in `case.actions.ts` + // are the shape that still earns one. + // + // Mechanism, measured on the console this app pinned at that taking + // (@objectstack/console 17.3.0, `dist/assets/`; this bundle read was ⛔ NOT + // re-taken on any later pin — 17.4.0, PR #1814, or 17.5.0) rather than + // assumed: the runner gates the dialog on + // the key's presence alone — + // if (action.confirmText && !await confirmHandler(evaluate(action.confirmText))) + // return { success: false, error: 'Action cancelled by user' }; + // — so REMOVING the key is what removes the dialog; there is no `confirm: + // false` to write, and no other key re-raises it. + successMessage: "Lead converted successfully!", + refreshAfter: true, + // ADR-0011 — opt this Action in to AI, which materialises the + // `action_convert_lead` tool the `lead_qualification` skill references. + // Flow-typed with a target, so it has a headless path. `requiresConfirmation` + // is the only key the AI path reads: `actionLooksDestructive` consults + // `ai.requiresConfirmation` and nothing else, and the console's + // confirm-dialog string reached no AI code — so dropping `confirmText` above + // leaves the AI approval signal exactly where it was. The flag is SURFACED, + // not enforced — `list_actions` reports `requiresConfirmation: true` and the + // calling client decides what to do with it, while `run_action` dispatches + // the flow with no server-side pause. It warns the caller that this is + // irreversible; it is not a lock. + ai: { + exposed: true, + requiresConfirmation: true, + description: "Converts a qualified lead into an account, contact and opportunity. Irreversible \u2014 requires human approval before it runs." + } +}; +var ScheduleFollowUpAction = { + name: "schedule_followup", + label: "Schedule Follow-up", + objectName: "crm_lead", + icon: "calendar-plus", + type: "flow", + target: "schedule_followup", + locations: ["record_header", "list_item"], + // A converted or disqualified lead has no next touch to schedule. + visible: P21`has(record.is_converted) && record.is_converted == false && has(record.status) && record.status != "unqualified" && record.status != "converted"`, + successMessage: "Follow-up scheduled.", + refreshAfter: true, + // ADR-0011 — materialises `action_schedule_followup` for the + // `lead_qualification` skill. Additive and reversible, so no approval gate. + ai: { + exposed: true, + description: "Schedules the next follow-up task on a lead, assigned to its owner, so the next touch lands on the rep list." + } +}; +var CreateCampaignAction = { + name: "create_campaign", + label: "Add to Campaign", + objectName: "crm_lead", + icon: "send", + // script, not modal — a `type: 'modal'` action has NO server dispatch at all: + // the renderer just opens its `target`, and the runtime refuses it over REST + // (`headlessActionTypeError`, 400 "a client-side action with no server + // dispatch"), so its `body` never runs. To collect input and then run + // server-side, the shape is `type: 'script'` + `params` — the runner collects + // the same dialog. See ScheduleFollowUpAction. + type: "script", + body: { + language: "js", + source: ` + // Value key = the param's field name ('crm_campaign') since the param + // omits an explicit 'name'. Insert uses the REAL lookup field names on + // crm_campaign_member (crm_campaign / crm_lead) \u2014 not the generic + // campaign_id / lead_id an earlier revision of the doc example taught, + // which don't exist here and left crm_campaign null \u2192 'Campaign required' + // validation failure. + const campaignId = input.crm_campaign ?? null; + if (!campaignId) throw new Error('create_campaign requires a campaign id'); + // One lead per dispatch \u2014 the bare-string \`bulkActions\` wiring fans this + // body out once per selected row (see the note above). \`ids\` stays a + // list so the dedupe + skip loop below reads the same on both contracts, + // should this action ever move to an aggregate def. + const ids = ctx.recordId ? [ctx.recordId] : []; + if (!ids.length) throw new Error('create_campaign: no lead selected'); + // Skip leads already on this campaign \u2014 the modal copy promises + // duplicates are skipped, and re-running the action on the same + // selection must not double-count marketing touches. + const raw = await ctx.api.object('crm_campaign_member').find({ + where: { crm_campaign: campaignId }, + fields: ['crm_lead'], + top: 5000, + }); + const existingRows = Array.isArray(raw) ? raw : (raw?.records ?? []); + const existing = new Set(existingRows.map((r) => r.crm_lead)); + const inserted = []; + let skipped = 0; + for (const leadId of ids) { + if (existing.has(leadId)) { skipped++; continue; } + const row = await ctx.api.object('crm_campaign_member').insert({ + crm_campaign: campaignId, + crm_lead: leadId, + status: 'sent', + }); + inserted.push(row?.id ?? null); + } + return { campaignId, count: inserted.length, skipped, ids: inserted }; + `, + capabilities: ["api.read", "api.write"], + timeoutMs: 1e4 + }, + // list_item gives every row a working record-scoped entry point. The + // list_toolbar button is single-record by construction: with no `_selectedIds` + // in the bag the dispatcher resolves a recordId from the grid selection, and a + // multi-row selection there is ambiguous, so it is refused client-side with + // "This action runs on a single record — select exactly one row." + // Multi-lead enrollment is the SELECTION-BAR button instead, which the view's + // `bulkActions: ['create_campaign']` produces and which fans out per row. + locations: ["list_toolbar", "list_item"], + params: [ + // Field-backed param: `field` + `objectOverride` make the console resolve + // the widget from crm_campaign_member.crm_campaign (a lookup → crm_campaign), + // rendering a RECORD PICKER. A bare `{ type:'lookup' }` with no field can't + // resolve a target object and silently falls back to a paste-the-ID textbox. + { + field: "crm_campaign", + objectOverride: "crm_campaign_member", + label: "Campaign", + required: true + } + ], + successMessage: "Leads added to campaign!", + refreshAfter: true +}; + +// src/sales/actions/opportunity.actions.ts +import { P as P22 } from "@objectstack/spec"; +var CloneOpportunityAction = { + name: "clone_opportunity", + label: "Clone Opportunity", + objectName: "crm_opportunity", + icon: "copy", + type: "script", + body: { + language: "js", + source: ` + const id = ctx.recordId; + if (!id) throw new Error('clone_opportunity requires a recordId'); + // Read the source from ctx.record (seeded by the runner for record-scoped + // actions \u2014 same source send_email uses). This avoids the in-sandbox + // find() that previously faulted, WHILE still copying the REQUIRED fields + // (crm_account / amount / close_date). The old minimal insert set only + // name+stage, so every clone failed the object's required-field + amount>0 + // validations at runtime and no opportunity was ever created. + const src = ctx.record ?? {}; + if (!src.crm_account) { + throw new Error('clone_opportunity: source account not loaded; cannot clone.'); + } + // Give the clone a fresh 90-day close horizon so a copied past date can't + // trip the "close date in the past" validation on a new prospecting deal. + // + // The step is on the UTC calendar because the render below is + // (\`toISOString()\`). The base is \`new Date()\` \u2014 an instant, not a + // stored \`YYYY-MM-DD\` \u2014 so unlike quote.hook/task.hook there is no + // UTC-midnight anchor being read back on the wrong calendar here; the + // only mixture was the step itself. A local \`getDate\`/\`setDate\` step + // preserves WALL-CLOCK time, so a 90-day window containing a DST + // transition is 23 h or 25 h long and the rendered UTC day lands one off + // whenever the clone instant is within an hour of a UTC day boundary. + const horizon = new Date(); + horizon.setUTCDate(horizon.getUTCDate() + 90); + const inserted = await ctx.api.object('crm_opportunity').insert({ + name: 'Copy of ' + (src.name ?? ('opportunity ' + id)), + crm_account: src.crm_account, + primary_contact: src.primary_contact ?? null, + amount: src.amount ?? 1, + stage: 'prospecting', + probability: 10, + close_date: horizon.toISOString().slice(0, 10), + type: src.type ?? null, + lead_source: src.lead_source ?? null, + crm_campaign: src.crm_campaign ?? null, + // Explicit because an action body runs \`isSystem\`, so nothing stamps + // \`owner_id\` for it \u2014 see the note in activity-actions.ts (#548). + owner_id: ctx.user?.id ?? null, + }); + return { id: inserted?.id ?? null }; + `, + capabilities: ["api.read", "api.write"], + timeoutMs: 5e3 + }, + locations: ["record_header", "record_more"], + successMessage: "Opportunity cloned successfully!", + refreshAfter: true +}; +var MassUpdateStageAction = { + name: "mass_update_stage", + label: "Update Stage", + objectName: "crm_opportunity", + icon: "layers", + type: "script", + body: { + language: "js", + source: ` + const newStage = input.stage ?? null; + if (!newStage) throw new Error('mass_update_stage requires a stage'); + // Selection first, single record as the fallback. An aggregate dispatch + // carries the whole selection in \`_selectedIds\` and NO recordId; a + // single-record dispatch carries recordId and no selection. The two are + // never both present, so the order only decides which shape wins if the + // platform ever sends both. + const selected = Array.isArray(input._selectedIds) ? input._selectedIds : []; + const ids = selected.length ? selected : (ctx.recordId ? [ctx.recordId] : []); + if (!ids.length) throw new Error('mass_update_stage: no opportunity selected'); + const missed = []; + let firstCause = ''; + let updated = 0; + for (const id of ids) { + // \`update(data, options)\` \u2014 \`ctx.api\` is the engine repo facade, whose + // update takes a DOCUMENT, not an id. \`updateById(id, data)\` exists on + // ObjectRepository but NOT on the facade the runtime builds when it has + // no scoped context, so this spelling is the only one live on both. + // + // An id that matches no row is a MISS, not an abort, and the engine has + // answered it both ways: through @objectstack/* 17.0.0-rc.6 \`update\` + // RESOLVED WITH NULL, and from 17.0.0 it REJECTS (RECORD_NOT_FOUND / + // 404). Both are handled here, and neither may end the loop \u2014 an + // uncaught rejection on the first stale id would leave every id after + // it unattempted, so re-running the action over the same selection + // would fail at the same row forever and the live rows behind it could + // never be covered. That is strictly worse than the silent-success + // failure #588 pulled this button for, because it is unrecoverable + // from the UI. Collect the miss, keep going, reject once at the end. + // + // The catch is deliberately cause-AGNOSTIC \u2014 but NOT because the cause + // is invisible. Read on 17.4.0 (\`hostErrorToVm\`; not re-read on 17.5.0), a host + // rejection reaches a body as \`name\` and \`message\` plus, when the host + // error carries them, \`code\`, \`status\`, \`fields\` and \`userMessage\` \u2014 + // nothing else, so a stale id arrives branchable as + // \`code === 'RECORD_NOT_FOUND'\` while \`details\` really is dropped. The + // branch is not taken because every cause has the same outcome here \u2014 + // the row did not move, so collect it and keep going \u2014 and narrowing + // the catch to a roster of known codes would let an unlisted cause + // abort the loop, the failure the paragraph above forbids. Message text + // is engine wording and not contract, so \`firstCause\` is carried + // verbatim and never parsed. + let row = null; + try { + row = await ctx.api.object('crm_opportunity').update( + { id: id, stage: newStage }, + { where: { id: id } }, + ); + } catch (err) { + row = null; + if (!firstCause) firstCause = (err && err.message) ? String(err.message) : String(err); + } + // Count only what came back: counting the ATTEMPT is how a stale or + // invisible id turns into a success toast for a write that never + // happened (#588). + if (row) { updated++; } else { missed.push(id); } + } + // Aggregate dispatch is all-or-nothing (objectui#3139): a handler that + // cannot cover the whole selection must reject rather than report partial + // work, because the bar offers no per-row retry \u2014 the retry IS re-running + // the action over the selection, which is safe here since setting a stage + // is idempotent. Rows already moved in this run keep the new stage; the + // error names the ones that did not so the rep can see the difference. + if (missed.length) { + throw new Error( + 'mass_update_stage: ' + missed.length + ' of ' + ids.length + + ' selected opportunities could not be updated (' + missed.join(', ') + + '). Re-run the action on the selection to retry.' + + (firstCause ? ' First cause: ' + firstCause : '') + ); + } + return { stage: newStage, updated }; + `, + capabilities: ["api.write"], + timeoutMs: 1e4 + }, + locations: ["list_toolbar"], + params: [ + { + name: "stage", + label: "New Stage", + type: "select", + required: true, + // Mirrors crm_opportunity.stage exactly — see _picklists.ts. + options: plainOptions(OPPORTUNITY_STAGE_OPTIONS) + } + ], + successMessage: "Opportunities updated successfully!", + refreshAfter: true +}; +var GenerateQuoteAction = { + name: "generate_quote", + label: "Generate Quote", + objectName: "crm_opportunity", + icon: "receipt", + type: "flow", + target: "quote_generation", + // Mirror clone_opportunity's placement (header + overflow menu) so the action + // is reachable both as a primary button and from the "…" menu on narrow + // viewports where the header collapses. + locations: ["record_header", "record_more", "list_item"], + visible: P22`has(record.stage) && record.stage != "closed_won" && record.stage != "closed_lost"`, + successMessage: "Quote created from opportunity!", + refreshAfter: true +}; + +// src/marketing/actions/index.ts +var actions_exports2 = {}; +__export(actions_exports2, { + EnrollLeadsAction: () => EnrollLeadsAction, + MarkRespondedAction: () => MarkRespondedAction +}); + +// src/marketing/actions/campaign.actions.ts +import { P as P23 } from "@objectstack/spec"; +var EnrollLeadsAction = { + name: "enroll_leads", + label: "Enroll Members", + objectName: "crm_campaign", + icon: "user-plus", + type: "flow", + target: "campaign_enrollment", + locations: ["record_header", "record_more"], + // Enrollment only makes sense while the campaign is open — the flow + // double-checks this server-side. + visible: P23`has(record.status) && (record.status == "planning" || record.status == "in_progress")`, + successMessage: "Eligible members enrolled in campaign.", + refreshAfter: true +}; +var MarkRespondedAction = { + name: "mark_responded", + label: "Mark Responded", + objectName: "crm_campaign_member", + icon: "reply", + // script, not modal — a `type: 'modal'` action has no server dispatch at all + // and its body never runs (see `create_campaign`'s note in lead.actions.ts). + type: "script", + body: { + language: "js", + source: ` + const id = ctx.recordId; + if (!id) throw new Error('mark_responded requires a recordId'); + const respondedAt = new Date().toISOString(); + await ctx.api.object('crm_campaign_member').update( + { id, status: 'responded', has_responded: true, response_date: respondedAt }, + { where: { id } }, + ); + return { id, status: 'responded', response_date: respondedAt }; + `, + capabilities: ["api.write"], + timeoutMs: 5e3 + }, + locations: ["record_header", "list_item"], + // Already-responded and converted members have nothing to record; an + // unsubscribed member must not be dragged back into the funnel by a + // mis-click (`campaign_member_optout_sync` has already opted that person out + // of email, and this action would not undo that — leaving the two records + // disagreeing about the same person). + visible: P23`has(record.status) && record.status == "sent"`, + successMessage: "Response recorded on this campaign member.", + refreshAfter: true +}; + +// src/sales/dashboards/index.ts +var dashboards_exports = {}; +__export(dashboards_exports, { + ActivityDashboard: () => ActivityDashboard, + CrmOverviewDashboard: () => CrmOverviewDashboard, + ExecutiveDashboard: () => ExecutiveDashboard, + SalesDashboard: () => SalesDashboard +}); + +// src/sales/dashboards/activity.dashboard.ts +var ActivityDashboard = { + name: "sales_activity_dashboard", + label: "Sales Activity", + description: "Who is talking to customers, how often, and which accounts have gone quiet", + columns: 12, + gap: 4, + refreshIntervalSeconds: 300, + header: { + showTitle: true, + showDescription: true + }, + globalFilters: [ + { + field: "owner_id", + label: { en: "Rep", "zh-CN": "\u9500\u552E\u4EE3\u8868", "es-ES": "Representante", "ja-JP": "\u62C5\u5F53\u8005" }, + type: "lookup", + scope: "dashboard", + optionsFrom: { object: "sys_user", valueField: "id", labelField: "name" } + } + ], + widgets: [ + // ─── Row 1: what happened, and what is booked ───────────────────── + { + id: "interactions_held", + title: "Interactions Logged", + description: "Calls and meetings that actually happened", + type: "metric", + filter: { status: "held" }, + colorVariant: "success", + dataset: "event_metrics", + values: ["event_count"], + layout: { x: 0, y: 0, w: 3, h: 2 } + }, + { + id: "meetings_booked", + title: "Meetings Booked", + description: "Meetings on the calendar that have not happened yet", + type: "metric", + filter: { status: "planned", type: "meeting" }, + colorVariant: "blue", + dataset: "event_metrics", + values: ["event_count"], + layout: { x: 3, y: 0, w: 3, h: 2 } + }, + { + id: "customer_minutes", + title: "Customer Minutes", + description: "Total time spent in front of customers", + type: "metric", + filter: { status: "held" }, + colorVariant: "purple", + dataset: "event_metrics", + values: ["total_minutes"], + layout: { x: 6, y: 0, w: 3, h: 2 } + }, + { + // First widget in the app to use `task_metrics`. The dataset shipped with + // the "My Day" work and then had no consumer at all (#592) — a semantic + // layer nobody queries is a maintenance cost with no reader. + id: "tasks_completed", + title: "Tasks Completed", + description: "Follow-ups closed out \u2014 the other half of activity", + type: "metric", + filter: { is_completed: true }, + colorVariant: "orange", + dataset: "task_metrics", + values: ["task_count"], + layout: { x: 9, y: 0, w: 3, h: 2 } + }, + // ─── Row 2: who, and when ───────────────────────────────────────── + { + id: "activity_by_rep", + title: "Activity by Rep", + description: "Logged interactions per owner \u2014 the coverage question", + type: "bar", + filter: { status: "held" }, + colorVariant: "success", + dataset: "event_metrics", + dimensions: ["owner"], + values: ["event_count"], + layout: { x: 0, y: 2, w: 6, h: 4 }, + chartConfig: { + showLegend: false, + showDataLabels: true, + colors: ["#10B981"] + } + }, + { + id: "activity_by_week", + title: "Activity Volume by Week", + description: "Interactions per week \u2014 is the team speeding up or going quiet?", + type: "area", + filter: { status: "held" }, + colorVariant: "blue", + // The week bucket lives on the DIMENSION, not in a filter — see the + // header note on why the trend belongs on an axis here. The datetime + // filter bound itself works (objectstack#3912 / #3777, 17.0.0); putting + // the trend in a filter would narrow it, which is a different objection. + dataset: "event_metrics", + dimensions: ["start_datetime"], + values: ["event_count"], + layout: { x: 6, y: 2, w: 6, h: 4 }, + chartConfig: { + showLegend: false, + showDataLabels: false, + colors: ["#0EA5E9"], + interaction: { tooltips: true, brush: true } + } + }, + // ─── Row 3: what the activity is about ──────────────────────────── + { + id: "activity_mix", + title: "Activity Mix", + description: "Calls vs meetings vs demos", + type: "donut", + filter: { status: "held" }, + colorVariant: "purple", + dataset: "event_metrics", + dimensions: ["type"], + values: ["event_count"], + layout: { x: 0, y: 6, w: 4, h: 4 }, + chartConfig: { + showLegend: true, + showDataLabels: true, + colors: ["#4169E1", "#10B981", "#8B5CF6", "#F59E0B", "#0EA5E9", "#94A3B8"] + } + }, + { + id: "activity_by_record_type", + title: "Where the Activity Lands", + description: "Which part of the funnel is getting attention", + type: "bar", + filter: { status: "held" }, + colorVariant: "blue", + dataset: "event_metrics", + dimensions: ["related_to_type"], + values: ["event_count"], + layout: { x: 4, y: 6, w: 4, h: 4 }, + chartConfig: { + showLegend: false, + showDataLabels: true, + colors: ["#4169E1"] + } + }, + { + // "Activity per open deal" as two honest numbers rather than one + // fabricated ratio: the semantic layer has no cross-dataset calculated + // measure, so a single "1.8 activities/deal" tile would have to be + // computed by the renderer over two independent queries — which nothing + // does today. A manager reads the pair; a made-up quotient would read as + // measured. Filed as a follow-up rather than faked here. + id: "deal_activity", + title: "Interactions on Deals", + description: "Logged interactions linked to an opportunity \u2014 read against Open Deals \u2192", + type: "metric", + filter: { status: "held", related_to_type: "crm_opportunity" }, + colorVariant: "success", + dataset: "event_metrics", + values: ["event_count"], + layout: { x: 8, y: 6, w: 2, h: 4 } + }, + { + id: "open_deals_for_activity", + title: "Open Deals", + description: "Opportunities still in play", + type: "metric", + filter: { stage: { $nin: ["closed_won", "closed_lost"] } }, + colorVariant: "blue", + dataset: "opportunity_metrics", + values: ["opp_count"], + layout: { x: 10, y: 6, w: 2, h: 4 } + }, + // ─── Row 4: the churn story, now backed by a real signal ────────── + // These window `crm_account.last_activity_date`, which is a `Field.date()` + // (TEXT `YYYY-MM-DD`) — the same shape `customer_churn_signals` already + // filters safely. Until #592 the column was written by nothing at all: the + // bubble that fed it was silently discarded on every invocation because + // the field was `readonly` (#2948). These three tiles are the reason that + // mattered. + { + id: "quiet_accounts_30", + title: "Quiet 30+ Days", + description: "Active accounts with no logged interaction in a month", + type: "metric", + filter: { is_active: true, last_activity_date: { $lt: "{30_days_ago}" } }, + colorVariant: "warning", + dataset: "account_metrics", + values: ["account_count"], + layout: { x: 0, y: 10, w: 4, h: 2 } + }, + { + id: "quiet_accounts_60", + title: "Quiet 60+ Days", + description: "Two months of silence \u2014 the at-risk threshold", + type: "metric", + filter: { is_active: true, last_activity_date: { $lt: "{60_days_ago}" } }, + colorVariant: "orange", + dataset: "account_metrics", + values: ["account_count"], + layout: { x: 4, y: 10, w: 4, h: 2 } + }, + { + id: "quiet_accounts_90", + title: "Quiet 90+ Days", + description: "A quarter with no contact \u2014 intervene or write it off", + type: "metric", + filter: { is_active: true, last_activity_date: { $lt: "{90_days_ago}" } }, + colorVariant: "danger", + dataset: "account_metrics", + values: ["account_count"], + layout: { x: 8, y: 10, w: 4, h: 2 } + } + ] +}; + +// src/sales/dashboards/shared-widgets.ts +var pipelineByStageFunnelWidget = (layout) => ({ + id: "pipeline_by_stage", + title: "Pipeline by Stage", + description: "Open opportunity value at each sales stage", + type: "funnel", + filter: { stage: { $nin: ["closed_won", "closed_lost"] } }, + dataset: "opportunity_metrics", + dimensions: ["stage"], + values: ["total_amount"], + layout, + suppressWarnings: ["chart-config-missing"] + // intentional default rendering +}); +var avgDealSizeMetricWidget = (layout, overrides = {}) => ({ + id: "avg_deal_size", + title: "Avg Deal Size", + description: "Average value of closed-won deals", + type: "metric", + filter: { stage: "closed_won" }, + colorVariant: "orange", + dataset: "opportunity_metrics", + values: ["avg_amount"], + layout, + ...overrides +}); + +// src/sales/dashboards/crm.dashboard.ts +var CrmOverviewDashboard = { + name: "crm_overview_dashboard", + label: "CRM Overview", + description: "Revenue metrics, pipeline analytics, and deal insights", + columns: 12, + gap: 4, + refreshIntervalSeconds: 300, + header: { + showTitle: true, + showDescription: true + // Header action buttons removed: `create_opportunity` / `create_lead` are not + // defined actions and `/reports` is not an in-app view route — all three were + // dead. Re-add real, wired-up actions here when available. + }, + dateRange: { + field: "close_date", + defaultRange: "this_quarter", + allowCustomRange: true + }, + globalFilters: [ + { + field: "owner_id", + label: { en: "Owner", "zh-CN": "\u8D1F\u8D23\u4EBA", "es-ES": "Responsable", "ja-JP": "\u62C5\u5F53\u8005" }, + type: "lookup", + scope: "dashboard", + optionsFrom: { object: "sys_user", valueField: "id", labelField: "name" } + } + ], + widgets: [ + // ─── KPI Row ────────────────────────────────────────────────────── + { + id: "total_revenue", + title: "Total Revenue", + description: "Closed-won revenue this period", + type: "metric", + filter: { stage: "closed_won" }, + colorVariant: "success", + dataset: "opportunity_metrics", + values: ["total_amount"], + layout: { x: 0, y: 0, w: 3, h: 2 } + }, + { + id: "active_deals", + title: "Active Deals", + description: "Open opportunities in the pipeline", + type: "metric", + filter: { stage: { $nin: ["closed_won", "closed_lost"] } }, + colorVariant: "blue", + dataset: "opportunity_metrics", + values: ["opp_count"], + layout: { x: 3, y: 0, w: 3, h: 2 } + }, + { + id: "won_deals", + title: "Won Deals", + description: "Closed-won deals this period", + type: "metric", + filter: { stage: "closed_won" }, + colorVariant: "purple", + dataset: "opportunity_metrics", + values: ["opp_count"], + layout: { x: 6, y: 0, w: 3, h: 2 } + }, + // No overrides left once the fabricated trend is gone. + avgDealSizeMetricWidget({ x: 9, y: 0, w: 3, h: 2 }), + // ─── Charts Row 1 ───────────────────────────────────────────────── + { + id: "revenue_trends", + title: "Revenue Trends", + description: "Closed-won revenue over the last 12 months", + type: "area", + filter: { stage: "closed_won", close_date: { $gte: "{12_months_ago}" } }, + filterBindings: { dateRange: false }, + // self-scoped to 12 months — the date picker must not narrow it + colorVariant: "success", + dataset: "opportunity_metrics", + dimensions: ["close_date"], + values: ["total_amount"], + layout: { x: 0, y: 2, w: 9, h: 4 }, + chartConfig: { + showLegend: false, + showDataLabels: false, + colors: ["#10B981"], + interaction: { tooltips: true, brush: true } + }, + options: { dateGranularity: "month" } + }, + { + id: "lead_source", + title: "Lead Source", + description: "Pipeline value by acquisition channel", + type: "donut", + colorVariant: "purple", + dataset: "opportunity_metrics", + dimensions: ["lead_source"], + values: ["total_amount"], + layout: { x: 9, y: 2, w: 3, h: 4 }, + chartConfig: { + showLegend: true, + showDataLabels: true, + colors: ["#4F46E5", "#06B6D4", "#10B981", "#F59E0B", "#EF4444", "#8B5CF6"] + } + }, + // ─── Charts Row 2 ───────────────────────────────────────────────── + pipelineByStageFunnelWidget({ x: 0, y: 6, w: 6, h: 4 }), + { + id: "top_products", + title: "Top Products", + description: "Total list-price revenue by product category", + type: "bar", + colorVariant: "blue", + // crm_product has no `close_date`, so the date picker would fail it with + // `no such column`. ObjectStack 15 (framework#2501) injects every dashboard + // filter (dateRange + globalFilters) into each widget's query. + // The `owner_id` opt-out is SEMANTIC, not structural: since #548 every + // business object carries the injected `owner_id`, so the filter would now + // resolve — it just means nothing on a shared product catalog, where the + // column records whoever created the entry. + filterBindings: { dateRange: false, owner_id: false }, + dataset: "product_metrics", + dimensions: ["category"], + values: ["list_price_sum"], + layout: { x: 6, y: 6, w: 6, h: 4 }, + chartConfig: { + showLegend: false, + showDataLabels: true, + colors: ["#4F46E5"] + } + }, + // ─── Pipeline by Owner ──────────────────────────────────────────── + // A dashboard `table` binds to an analytics dataset (a cube), so it must + // aggregate — it cannot list raw records (ADR-0021). The previous + // "Recent Opportunities" table selected only the `opp_count` measure with + // no dimension, which renders a single summary row, not a per-deal list. + // For a true per-record listing, surface an object-bound ListView through + // app navigation instead (ADR-0017). Here we group by owner for a rep + // pipeline breakdown that renders one row per owner. + { + id: "pipeline_by_owner", + title: "Pipeline by Owner", + description: "Open pipeline value and deal count per sales rep", + type: "table", + filter: { stage: { $nin: ["closed_won", "closed_lost"] } }, + colorVariant: "default", + dataset: "opportunity_metrics", + dimensions: ["owner"], + values: ["total_amount", "opp_count", "avg_amount"], + layout: { x: 0, y: 10, w: 12, h: 4 }, + options: { + sortBy: "total_amount", + sortOrder: "desc", + limit: 10 + } + } + ] +}; + +// src/sales/dashboards/executive.dashboard.ts +var LEAD_SOURCE_FILTER_LABELS = { + web: { en: "Web", "zh-CN": "\u7F51\u7AD9", "es-ES": "Web", "ja-JP": "\u30A6\u30A7\u30D6" }, + referral: { en: "Referral", "zh-CN": "\u63A8\u8350", "es-ES": "Referencia", "ja-JP": "\u7D39\u4ECB" }, + event: { en: "Event / Trade Show", "zh-CN": "\u6D3B\u52A8 / \u5C55\u4F1A", "es-ES": "Evento / Feria", "ja-JP": "\u30A4\u30D9\u30F3\u30C8\u30FB\u5C55\u793A\u4F1A" }, + webinar: { en: "Webinar", "zh-CN": "\u7EBF\u4E0A\u7814\u8BA8\u4F1A", "es-ES": "Seminario Web", "ja-JP": "\u30A6\u30A7\u30D3\u30CA\u30FC" }, + partner: { en: "Partner", "zh-CN": "\u5408\u4F5C\u4F19\u4F34", "es-ES": "Socio", "ja-JP": "\u30D1\u30FC\u30C8\u30CA\u30FC" }, + advertisement: { en: "Advertisement", "zh-CN": "\u5E7F\u544A", "es-ES": "Publicidad", "ja-JP": "\u5E83\u544A" }, + paid_search: { en: "Paid Search", "zh-CN": "\u4ED8\u8D39\u641C\u7D22", "es-ES": "B\xFAsqueda de Pago", "ja-JP": "\u6709\u6599\u691C\u7D22" }, + social: { en: "Social Media", "zh-CN": "\u793E\u4EA4\u5A92\u4F53", "es-ES": "Redes Sociales", "ja-JP": "\u30BD\u30FC\u30B7\u30E3\u30EB\u30E1\u30C7\u30A3\u30A2" }, + content: { en: "Content / Blog", "zh-CN": "\u5185\u5BB9 / \u535A\u5BA2", "es-ES": "Contenido / Blog", "ja-JP": "\u30B3\u30F3\u30C6\u30F3\u30C4\u30FB\u30D6\u30ED\u30B0" }, + cold_call: { en: "Cold Call", "zh-CN": "\u964C\u751F\u62DC\u8BBF", "es-ES": "Llamada en Fr\xEDo", "ja-JP": "\u30B3\u30FC\u30EB\u30C9\u30B3\u30FC\u30EB" }, + email_campaign: { en: "Email Campaign", "zh-CN": "\u90AE\u4EF6\u8425\u9500", "es-ES": "Campa\xF1a de Email", "ja-JP": "\u30E1\u30FC\u30EB\u30AD\u30E3\u30F3\u30DA\u30FC\u30F3" }, + other: { en: "Other", "zh-CN": "\u5176\u4ED6", "es-ES": "Otro", "ja-JP": "\u305D\u306E\u4ED6" } +}; +var ExecutiveDashboard = { + name: "executive_dashboard", + label: "Executive Overview", + description: "High-level revenue, customer, and pipeline KPIs for leadership", + columns: 12, + gap: 4, + refreshIntervalSeconds: 300, + // 5 minutes + header: { + showTitle: true, + showDescription: true + // Header action buttons removed: they referenced actions/routes that were + // never implemented (`export_dashboard_pdf`, `schedule_dashboard_email`, + // `customize_dashboard` are not defined anywhere), so they rendered as dead + // buttons. Re-add real, wired-up actions here if these features land. + }, + dateRange: { + field: "close_date", + defaultRange: "this_quarter", + allowCustomRange: true + }, + globalFilters: [ + { + field: "owner_id", + label: { en: "Owner", "zh-CN": "\u8D1F\u8D23\u4EBA", "es-ES": "Responsable", "ja-JP": "\u62C5\u5F53\u8005" }, + type: "lookup", + scope: "dashboard", + optionsFrom: { object: "sys_user", valueField: "id", labelField: "name" } + }, + { + field: "lead_source", + label: { en: "Lead Source", "zh-CN": "\u7EBF\u7D22\u6765\u6E90", "es-ES": "Origen del Prospecto", "ja-JP": "\u30EA\u30FC\u30C9\u30BD\u30FC\u30B9" }, + type: "select", + scope: "dashboard", + // Roster derived, wording from the language packs — see + // LEAD_SOURCE_FILTER_LABELS above. Order follows the canonical constant. + options: LEAD_SOURCE_OPTIONS.map(({ value }) => ({ + value, + label: LEAD_SOURCE_FILTER_LABELS[String(value)] + })) + } + ], + widgets: [ + // ─── Row 1: Headline KPIs ───────────────────────────────────────── + { + id: "total_revenue_ytd", + title: "Total Revenue (YTD)", + description: "Closed-won revenue this year", + type: "metric", + filter: { stage: "closed_won", close_date: { $gte: "{current_year_start}" } }, + // Self-scoped to YTD; without this the injected dashboard dateRange + // (default this_quarter) is ANDed in and the tile shows quarter revenue. + filterBindings: { dateRange: false }, + dataset: "opportunity_metrics", + values: ["total_amount"], + layout: { x: 0, y: 0, w: 3, h: 2 } + }, + { + id: "total_accounts", + title: "Active Accounts", + description: "Customers with at least one active relationship", + type: "metric", + filter: { is_active: true }, + // crm_account has neither `close_date` nor `lead_source`; opt this widget + // out of both dashboard filters bound to those fields. ObjectStack 15 + // (framework#2501) injects every dashboard filter (dateRange + globalFilters) + // into each widget's query, so a widget on an object lacking a filter field + // fails with `no such column`. crm_account DOES have `owner_id` (injected + // into every business object, #548), so the owner filter is left to apply. + filterBindings: { dateRange: false, lead_source: false }, + dataset: "account_metrics", + values: ["account_count"], + layout: { x: 3, y: 0, w: 3, h: 2 } + }, + { + id: "total_contacts", + title: "Total Contacts", + description: "People in our address book", + type: "metric", + filterBindings: { dateRange: false }, + // crm_contact has no close_date — opt out of the date picker + dataset: "contact_metrics", + values: ["contact_count"], + layout: { x: 6, y: 0, w: 3, h: 2 } + }, + { + id: "open_leads", + title: "Open Leads", + description: "Unconverted leads in the funnel", + type: "metric", + filter: { is_converted: false }, + filterBindings: { dateRange: false }, + // crm_lead has no close_date — opt out of the date picker + dataset: "lead_metrics", + values: ["lead_count"], + layout: { x: 9, y: 0, w: 3, h: 2 } + }, + // ─── Row 2: Revenue Analysis ────────────────────────────────────── + { + id: "revenue_trend", + title: "Revenue Trend", + description: "Closed-won revenue over the last 12 months", + type: "area", + filter: { stage: "closed_won", close_date: { $gte: "{12_months_ago}" } }, + filterBindings: { dateRange: false }, + // self-scoped to 12 months — the date picker must not narrow it + dataset: "opportunity_metrics", + dimensions: ["close_date"], + values: ["total_amount"], + layout: { x: 0, y: 2, w: 8, h: 4 }, + // Default rendering is intentional: the dataset widget plots the selected + // dimension × values directly; a chartConfig would duplicate them inertly. + suppressWarnings: ["chart-config-missing"] + }, + { + id: "revenue_by_industry", + title: "Revenue by Industry", + description: "YTD closed-won revenue split by customer industry", + type: "donut", + filter: { stage: "closed_won", close_date: { $gte: "{current_year_start}" } }, + filterBindings: { dateRange: false }, + // self-scoped to YTD — the date picker must not narrow it + dataset: "opportunity_metrics", + dimensions: ["account_industry"], + values: ["total_amount"], + layout: { x: 8, y: 2, w: 4, h: 4 }, + suppressWarnings: ["chart-config-missing"] + // intentional default rendering (see revenue_trend) + }, + // ─── Row 3: Pipeline & Activity ─────────────────────────────────── + // The funnel now comes from the shared factory (#539); its remaining inert + // config lives in shared-widgets.ts and is out of this PR's scope. + pipelineByStageFunnelWidget({ x: 0, y: 6, w: 6, h: 4 }), + { + id: "new_accounts_by_month", + title: "New Accounts", + description: "Account creation cadence \u2014 last 6 months", + type: "bar", + filter: { created_at: { $gte: "{6_months_ago}" } }, + filterBindings: { dateRange: false, lead_source: false }, + // crm_account has no close_date/lead_source; scopes itself by created_at + dataset: "account_metrics", + dimensions: ["created_at"], + values: ["account_count"], + layout: { x: 6, y: 6, w: 6, h: 4 }, + suppressWarnings: ["chart-config-missing"] + // intentional default rendering (see revenue_trend) + }, + // ─── Row 4: Revenue by Industry ─────────────────────────────────── + // A dashboard `table` binds to an analytics cube, so it aggregates rather + // than listing raw accounts (ADR-0021). The previous "Top Accounts by + // Revenue" table selected only the `account_count` measure with no + // dimension — a single summary row, not a customer ranking. Grouping by + // industry gives a real multi-row breakdown of book-of-business by sector; + // for a per-account list, use an object-bound ListView (ADR-0017). + // Column headers and number formats come from the dataset's dimension and + // measure metadata. + { + id: "accounts_by_industry", + title: "Accounts by Industry", + description: "Total annual revenue and account count per industry", + type: "table", + filterBindings: { dateRange: false, lead_source: false }, + // crm_account has no close_date/lead_source — opt out of both + dataset: "account_metrics", + dimensions: ["industry"], + values: ["annual_revenue_sum", "account_count"], + layout: { x: 0, y: 10, w: 12, h: 4 } + } + ] +}; + +// src/sales/dashboards/sales.dashboard.ts +var SalesDashboard = { + name: "sales_dashboard", + label: "Sales Performance", + description: "Pipeline analytics, win rate trends, and rep performance", + columns: 12, + gap: 4, + refreshIntervalSeconds: 180, + // 3 minutes + header: { + showTitle: true, + // Keep the opening KPI row in the first viewport for a live demo. The + // description remains available in dashboard metadata and translations. + showDescription: false + // Header action buttons removed: `create_opportunity` / `export_dashboard_pdf` + // are not defined actions, and `/reports/forecast` matches no report route — + // all three were dead. Re-add real, wired-up actions here when available. + }, + dateRange: { + field: "close_date", + defaultRange: "this_quarter", + allowCustomRange: true + }, + globalFilters: [ + { + field: "owner_id", + label: { en: "Sales Rep", "zh-CN": "\u9500\u552E\u4EE3\u8868", "es-ES": "Representante de Ventas", "ja-JP": "\u55B6\u696D\u62C5\u5F53\u8005" }, + type: "lookup", + scope: "dashboard", + optionsFrom: { object: "sys_user", valueField: "id", labelField: "name" } + }, + { + field: "type", + label: { en: "Deal Type", "zh-CN": "\u5546\u673A\u7C7B\u578B", "es-ES": "Tipo de Oportunidad", "ja-JP": "\u5546\u8AC7\u30BF\u30A4\u30D7" }, + type: "select", + scope: "dashboard", + options: [ + { value: "new_business", label: { en: "New Business", "zh-CN": "\u65B0\u4E1A\u52A1", "es-ES": "Nuevo Negocio", "ja-JP": "\u65B0\u898F\u30D3\u30B8\u30CD\u30B9" } }, + { value: "existing_upgrade", label: { en: "Existing Customer - Upgrade", "zh-CN": "\u8001\u5BA2\u6237\u5347\u7EA7", "es-ES": "Cliente Existente - Mejora", "ja-JP": "\u65E2\u5B58\u9867\u5BA2 - \u30A2\u30C3\u30D7\u30B0\u30EC\u30FC\u30C9" } }, + { value: "existing_renewal", label: { en: "Existing Customer - Renewal", "zh-CN": "\u8001\u5BA2\u6237\u7EED\u7EA6", "es-ES": "Cliente Existente - Renovaci\xF3n", "ja-JP": "\u65E2\u5B58\u9867\u5BA2 - \u66F4\u65B0" } }, + { value: "existing_expansion", label: { en: "Existing Customer - Expansion", "zh-CN": "\u8001\u5BA2\u6237\u62D3\u5C55", "es-ES": "Cliente Existente - Expansi\xF3n", "ja-JP": "\u65E2\u5B58\u9867\u5BA2 - \u62E1\u5927" } } + ] + } + ], + widgets: [ + // ─── Row 1: Pipeline KPIs ───────────────────────────────────────── + { + id: "total_pipeline_value", + title: "Total Pipeline", + description: "Sum of open opportunity value", + type: "metric", + filter: { stage: { $nin: ["closed_won", "closed_lost"] } }, + colorVariant: "blue", + dataset: "opportunity_metrics", + values: ["total_amount"], + layout: { x: 0, y: 0, w: 3, h: 2 } + }, + { + id: "closed_won_qtd", + title: "Closed Won (QTD)", + description: "Revenue closed this quarter", + type: "metric", + filter: { stage: "closed_won", close_date: { $gte: "{current_quarter_start}" } }, + filterBindings: { dateRange: false }, + // self-scoped to QTD — the date picker must not re-window it + colorVariant: "success", + dataset: "opportunity_metrics", + values: ["total_amount"], + layout: { x: 3, y: 0, w: 3, h: 2 } + }, + { + id: "open_opportunities", + title: "Open Opportunities", + description: "Active deals in flight", + type: "metric", + filter: { stage: { $nin: ["closed_won", "closed_lost"] } }, + colorVariant: "orange", + dataset: "opportunity_metrics", + values: ["opp_count"], + layout: { x: 6, y: 0, w: 3, h: 2 } + }, + avgDealSizeMetricWidget({ x: 9, y: 0, w: 3, h: 2 }, { + description: "Average value of closed-won deals this quarter", + filter: { stage: "closed_won", close_date: { $gte: "{current_quarter_start}" } }, + filterBindings: { dateRange: false }, + // self-scoped to QTD — the date picker must not re-window it + colorVariant: "purple" + }), + // ─── Row 2: Win / Loss KPIs ─────────────────────────────────────── + // + // The ratio and its two inputs sit side by side ON PURPOSE (#593). A win + // rate is the failure mode #614 shipped: a wrong denominator raises no + // error, it just prints a plausible percentage. Showing "62%" next to + // "8 won" and "5 lost" means a reader can check the arithmetic at a + // glance, and a half that silently loses its filter stops being invisible. + // + // All three windows are the same self-scoped 12 months (`dateRange: false` + // so the header's date picker cannot re-window one of them and not the + // others — three tiles over three different windows would be worse than + // no tiles at all). + { + // NOTE: no `stage` filter here, and that is deliberate. Both halves of + // the ratio come from the DATASET's own measure filters — `won_count` + // over closed_won, `decided_count` over closed_won + closed_lost — so + // open pipeline is excluded by the measures. A widget-level + // `stage: {$in: [...]}` filter would narrow numerator and denominator + // alike, which is how a ratio quietly becomes a division by itself. + id: "win_rate_12m", + title: "Win Rate (12M)", + description: "Deals won as a share of all deals settled in the last 12 months", + type: "metric", + filter: { close_date: { $gte: "{12_months_ago}" } }, + filterBindings: { dateRange: false }, + colorVariant: "success", + dataset: "opportunity_metrics", + values: ["win_rate"], + layout: { x: 0, y: 2, w: 4, h: 2 } + }, + { + id: "won_deals_12m", + title: "Deals Won (12M)", + description: "The numerator of the win rate", + type: "metric", + filter: { close_date: { $gte: "{12_months_ago}" } }, + filterBindings: { dateRange: false }, + colorVariant: "blue", + dataset: "opportunity_metrics", + values: ["won_count"], + layout: { x: 4, y: 2, w: 4, h: 2 } + }, + { + id: "lost_deals_12m", + title: "Deals Lost (12M)", + description: "The other half of the win-rate denominator", + type: "metric", + filter: { close_date: { $gte: "{12_months_ago}" } }, + filterBindings: { dateRange: false }, + colorVariant: "orange", + dataset: "opportunity_metrics", + values: ["lost_count"], + layout: { x: 8, y: 2, w: 4, h: 2 } + }, + // ─── Row 3: Pipeline & Trends ───────────────────────────────────── + pipelineByStageFunnelWidget({ x: 0, y: 4, w: 6, h: 4 }), + { + id: "monthly_revenue_trend", + title: "Monthly Revenue Trend", + description: "Closed-won revenue, last 12 months", + type: "area", + filter: { stage: "closed_won", close_date: { $gte: "{12_months_ago}" } }, + filterBindings: { dateRange: false }, + // self-scoped to 12 months — the date picker must not narrow it + colorVariant: "success", + dataset: "opportunity_metrics", + dimensions: ["close_date"], + values: ["total_amount"], + layout: { x: 6, y: 4, w: 6, h: 4 }, + chartConfig: { + showLegend: false, + showDataLabels: false, + colors: ["#10B981"], + // No quota annotation line: ChartAnnotationSchema only takes a STATIC + // value, and the real quotas live per-owner/per-period in + // crm_forecast.quota (seeded 500k–1.5M — the old hardcoded 100000 was + // fiction). Quota vs. actual is the quota_attainment_by_rep table + // below, bound to the forecast_metrics dataset. + interaction: { tooltips: true, brush: true } + }, + options: { dateGranularity: "month" } + }, + // ─── Row 4: Performance Breakdown ───────────────────────────────── + { + id: "pipeline_by_forecast_category", + title: "Pipeline by Forecast Category", + description: "Open pipeline grouped by sales forecast category", + type: "horizontal-bar", + filter: { stage: { $nin: ["closed_won", "closed_lost"] } }, + colorVariant: "blue", + dataset: "opportunity_metrics", + dimensions: ["forecast_category"], + values: ["total_amount"], + layout: { x: 0, y: 8, w: 6, h: 4 }, + chartConfig: { + showLegend: false, + showDataLabels: true, + colors: ["#4F46E5"] + } + }, + { + id: "lead_source_breakdown", + title: "Lead Source", + description: "Where our pipeline is coming from", + type: "donut", + filter: { stage: { $nin: ["closed_lost"] } }, + colorVariant: "purple", + dataset: "opportunity_metrics", + dimensions: ["lead_source"], + values: ["total_amount"], + layout: { x: 6, y: 8, w: 6, h: 4 }, + chartConfig: { + showLegend: true, + showDataLabels: true, + colors: ["#4F46E5", "#06B6D4", "#10B981", "#F59E0B", "#EF4444", "#8B5CF6"] + } + }, + // ─── Row 5: Rep Leaderboard ─────────────────────────────────────── + // A dashboard `table` binds to an analytics cube and aggregates; it cannot + // list raw deals (ADR-0021). The previous "Top Open Opportunities" table + // selected only `opp_count` with no dimension — one summary row, not a deal + // ranking. Grouping open pipeline by owner yields a rep leaderboard (one + // row per rep). For a per-deal list, surface an object-bound ListView + // through app navigation (ADR-0017). + { + id: "open_pipeline_by_owner", + title: "Open Pipeline by Owner", + description: "In-flight pipeline value, deal count and avg win probability per rep", + type: "table", + filter: { stage: { $nin: ["closed_won", "closed_lost"] } }, + colorVariant: "default", + dataset: "opportunity_metrics", + dimensions: ["owner"], + values: ["total_amount", "opp_count", "avg_probability"], + layout: { x: 0, y: 12, w: 12, h: 4 }, + options: { + sortBy: "total_amount", + sortOrder: "desc", + limit: 10 + } + }, + // ─── Row 6: Quota Attainment ────────────────────────────────────── + // The real per-rep quota data (crm_forecast.quota) surfaced as a table: + // dashboard chart annotations cannot reference a dataset (static values + // only), so quota vs. actual gets its own widget instead of a fake line. + { + id: "quota_attainment_by_rep", + title: "Quota Attainment by Rep", + description: "Current-quarter quota, closed revenue and attainment per rep, from forecast snapshots", + type: "table", + colorVariant: "default", + // crm_forecast has neither `close_date` nor `type`; opt out of the + // dashboard filters bound to those fields (framework#2501 injects every + // dashboard filter into each widget query). `owner` exists and applies. + filterBindings: { dateRange: false, type: false }, + // ONE period, or the numbers are nonsense (#614). `crm_forecast` holds a + // row per owner PER PERIOD, and `quota_sum` / `closed_sum` are plain + // `sum` measures — so an unpinned query adds this quarter's quota to this + // month's quota to every settled quarter's quota and labels the total + // "Quota". On the shipped seeds that turned a rep's real 1,500,000 + // quarterly quota into 7,940,000, with attainment wrong by the same + // construction (89% instead of 55%). + // + // Both halves of the key are needed. `period: 'quarter'` alone still sums + // every quarter ever snapshotted; `period_start` alone still merges the + // quarter row with the month row that opens the same quarter (Q3 and July + // both start on the 1st). Together they name exactly one snapshot per + // owner — the same (owner, period, period_start) tuple the snapshot sweep + // upserts on and the object indexes. + // + // `{current_quarter_start}` is resolved by the ANALYTICS path, verified + // rather than assumed: `queryDataset` runs both the dataset filter and the + // widget's `runtimeFilter` through `resolveFilterTokens`, which + // understands `{(current|last|next)_(week|month|quarter|year)_(start|end)}` + // and throws `FILTER_TOKEN_UNKNOWN` on anything else. + // + // The LIST path resolves the same macros, and has since 17.0.0-rc.0: + // `resolveFilterTokens()` was wired into the ObjectQL READ path (objectql + // `feat(filters): evaluate {filter-token} placeholders server-side`, + // #3582) ahead of the middleware chain, covering `find` / `findOne` / + // `count` / `aggregate` — the one gate every server-side read passes + // through, saved-view filters included. So this widget's filter and a + // saved view's filter now read the same way, and the sibling + // `this_quarter_forecasts` in `src/sales/views/forecast.view.ts` pins this same + // quarter with this same macro. Measured, not inferred: + // `test/forecast-current-quarter-view.test.ts` runs both filter shapes — + // the `period_start` equality (#730) and the `close_date` range (#743) — + // through a real engine and pins a three-way outcome (current quarter + // only: not zero rows, not every quarter). First taken on 17.0.0-rc.2; + // RE-RUN 2026-09-03 on 17.2.0 (#1467), RE-RUN on 17.3.0 (#1676, the PR + // #1577 pin) and RE-RUN again on 17.4.0 (PR #1814, #1807) — green all + // four times, so the outcome held on every pin it was taken on, not + // only the first. Not yet re-run on 17.5.0. + // + // What stood here before described the two paths as asymmetric and told + // the next author not to generalise between them. That was true on + // @objectstack 16.1.0 and expired at rc.0 (#744). + // + // Cost of pinning to the CURRENT quarter rather than the latest one: for + // the few hours between a quarter boundary and the 03:00 sweep that opens + // the new row, the table is empty. Empty is the honest state — the + // alternative renders last quarter's attainment under a header that says + // this one. + filter: { period: "quarter", period_start: "{current_quarter_start}" }, + dataset: "forecast_metrics", + dimensions: ["owner"], + values: ["quota_sum", "closed_sum", "attainment"], + layout: { x: 0, y: 16, w: 12, h: 4 }, + options: { + sortBy: "attainment", + sortOrder: "desc", + limit: 10 + } + }, + // ─── Row 7: Win / Loss analysis ─────────────────────────────────── + // + // Three widgets over the settled half of the pipeline (#593). Each of the + // two win-rate breakdowns is a TABLE, not a bar chart, and that is the + // whole design: a bar of "67%" is unfalsifiable, whereas a row reading + // "Won 2 · Lost 1 · Settled 3 · 67%" carries its own proof. Perturb either + // half — win a deal that was lost, or lose one that was won — and three of + // those four numbers move. `test/win-loss-capture.test.ts` does exactly + // that against the real dataset executor and the real seeds. + // + // Both tables opt out of the header's `close_date` window + // (`dateRange: false`) for the reason the quota table does: a win rate over + // "this quarter" on a demo database is computed from whichever one or two + // deals happen to have settled inside it, which is noise wearing the + // costume of a KPI. Twelve months is the same window the row-2 tiles and + // the revenue trend use, so the dashboard tells one consistent story. + { + id: "win_rate_by_owner", + title: "Win / Loss by Rep", + description: "Deals won, deals lost and win rate per rep \u2014 last 12 months", + type: "table", + filter: { close_date: { $gte: "{12_months_ago}" } }, + filterBindings: { dateRange: false }, + colorVariant: "default", + dataset: "opportunity_metrics", + dimensions: ["owner"], + values: ["won_count", "lost_count", "decided_count", "win_rate", "won_amount"], + layout: { x: 0, y: 20, w: 6, h: 4 }, + options: { + sortBy: "decided_count", + sortOrder: "desc", + limit: 10 + } + }, + { + id: "win_rate_by_lead_source", + title: "Win / Loss by Lead Source", + description: "Which sources produce deals that actually close \u2014 last 12 months", + type: "table", + filter: { close_date: { $gte: "{12_months_ago}" } }, + filterBindings: { dateRange: false }, + colorVariant: "default", + dataset: "opportunity_metrics", + dimensions: ["lead_source"], + values: ["won_count", "lost_count", "decided_count", "win_rate", "won_amount"], + layout: { x: 6, y: 20, w: 6, h: 4 }, + options: { + sortBy: "decided_count", + sortOrder: "desc", + limit: 12 + } + }, + { + // The loss-reason breakdown the fields were declared for and never got. + // + // `loss_reason` is mandatory on every `closed_lost` record (see + // crm_opportunity), so this chart has no "unattributed" slice to + // apologise for — an empty chart here means no losses in the window, + // never "nobody filled the field in". + // + // Counts, not amounts: the question a loss review asks is "how often did + // we lose for this reason", and one large lost deal should not outweigh + // five recurring feature gaps. `lost_amount` is declared on the dataset + // for the revenue view of the same question. + id: "loss_reason_breakdown", + title: "Why We Lose", + description: "Lost deals by reason \u2014 last 12 months", + type: "donut", + filter: { stage: "closed_lost", close_date: { $gte: "{12_months_ago}" } }, + filterBindings: { dateRange: false }, + colorVariant: "orange", + dataset: "opportunity_metrics", + dimensions: ["loss_reason"], + values: ["opp_count"], + layout: { x: 0, y: 24, w: 12, h: 4 }, + chartConfig: { + showLegend: true, + showDataLabels: true, + colors: ["#EF4444", "#F59E0B", "#8B5CF6", "#06B6D4", "#4F46E5", "#10B981", "#64748B"] + } + }, + // ─── Row 9: Pivot — Stage × Lead Source ─────────────────────────── + { + id: "pipeline_stage_by_source", + title: "Pipeline by Stage \xD7 Lead Source", + description: "Cross-tab of open opportunity amount by stage and source", + type: "pivot", + filter: { stage: { $nin: ["closed_won", "closed_lost"] } }, + colorVariant: "default", + dataset: "opportunity_metrics", + dimensions: ["stage", "lead_source"], + values: ["total_amount"], + layout: { x: 0, y: 28, w: 12, h: 4 } + } + ] +}; + +// src/sales/datasets/index.ts +var datasets_exports = {}; +__export(datasets_exports, { + AccountDataset: () => AccountDataset, + ContactDataset: () => ContactDataset, + EventDataset: () => EventDataset, + ForecastDataset: () => ForecastDataset, + LeadDataset: () => LeadDataset, + OpportunityDataset: () => OpportunityDataset, + TaskDataset: () => TaskDataset +}); + +// src/sales/datasets/opportunity.dataset.ts +import { defineDataset as defineDataset2 } from "@objectstack/spec/ui"; +var OpportunityDataset = defineDataset2({ + name: "opportunity_metrics", + label: "Opportunity Metrics", + description: "Semantic layer for sales-pipeline counts and amounts", + object: "crm_opportunity", + // Include the account relationship so dimensions can traverse it (the join is + // derived from the `crm_account` lookup — no hand-written ON clause). + include: ["crm_account"], + dimensions: [ + { name: "stage", label: "Stage", field: "stage", type: "string" }, + { name: "lead_source", label: "Lead Source", field: "lead_source", type: "string" }, + { name: "forecast_category", label: "Forecast Category", field: "forecast_category", type: "string" }, + { name: "type", label: "Deal Type", field: "type", type: "string" }, + // Semantic name `owner`; column `owner_id`, the platform anchor (#548). + { name: "owner", label: "Owner", field: "owner_id", type: "lookup" }, + // Win/loss attribution (#593). Both columns are now mandatory at close + // (`requiredWhen` on crm_opportunity), so grouping by either one over + // settled deals has no "unattributed" bucket to explain away. + { name: "win_reason", label: "Win Reason", field: "win_reason", type: "string" }, + { name: "loss_reason", label: "Loss Reason", field: "loss_reason", type: "string" }, + // v17 fixes scoped aggregate execution and SQLite's epoch bucketing. + // Trends and quarter coverage need different buckets over the same field, + // so each one is its own semantic dimension. + { name: "close_date", label: "Close Date", field: "close_date", type: "date", dateGranularity: "month" }, + { name: "close_quarter", label: "Close Quarter", field: "close_date", type: "date", dateGranularity: "quarter" }, + // Cross-object dimension: account industry via the crm_account relationship. + { name: "account_industry", label: "Account Industry", field: "crm_account.industry", type: "string" } + ], + measures: [ + { name: "opp_count", label: "Opportunities", aggregate: "count" }, + { name: "total_amount", label: "Total Amount", aggregate: "sum", field: "amount", format: "0,0" }, + { name: "avg_amount", label: "Avg Deal Size", aggregate: "avg", field: "amount", format: "0,0" }, + { name: "avg_probability", label: "Avg Probability", aggregate: "avg", field: "probability", format: "0%" }, + // ─── Win rate (#593) ──────────────────────────────────────────────── + // + // A ratio is the most dangerous kind of measure: a wrong denominator does + // not error, it returns a plausible number (#614 rendered a 1,500,000 + // quota as 7,940,000 because a filter was missing one of its two halves). + // So the two halves are declared here, ONCE, as named measures — not + // improvised per widget — and every widget that shows `win_rate` also + // shows `won_count` and `lost_count` beside it, so the reader can check + // the arithmetic that produced the percentage. + // + // Each carries its OWN `filter`, which the executor honours by running + // that measure as its own sub-query and merging the result back on the + // selected dimensions. That is what lets one widget row hold "won 2, lost + // 1, 67%" — the counts are over different row sets, and only a + // measure-level filter can say so. A widget-level `filter` cannot: it + // narrows the whole row set at once, which is exactly how you end up + // dividing a number by itself. + // + // `decided_count` is deliberately its own filtered count and NOT + // `derived: { op: 'sum', of: ['won_count', 'lost_count'] }`. Measured on + // 17.0.0-rc.1: a filtered measure contributes NO row for a group its + // filter selects nothing in — the count comes back absent, not 0 — and a + // derived measure over an absent input evaluates to null. Summing the two + // would therefore blank the win rate of any rep who has never lost a deal + // (100%, the group you least want to hide). Counting the union directly + // keeps the denominator present whenever the group has any settled deal at + // all. The remaining asymmetry — a group with losses but NO wins reports a + // null win rate rather than 0% — is a platform behaviour, not something a + // widget can paper over; it is pinned by `test/win-loss-capture.test.ts` + // and filed as #656. The tables show `lost_count` next to `win_rate` + // precisely so that a blank rate reads as "0 wins out of 3", not as + // "no data". + { name: "won_count", label: "Won Deals", aggregate: "count", filter: { stage: "closed_won" } }, + { name: "lost_count", label: "Lost Deals", aggregate: "count", filter: { stage: "closed_lost" } }, + { + name: "decided_count", + label: "Settled Deals", + aggregate: "count", + filter: { stage: { $in: ["closed_won", "closed_lost"] } } + }, + { name: "won_amount", label: "Won Revenue", aggregate: "sum", field: "amount", filter: { stage: "closed_won" }, format: "0,0" }, + { name: "lost_amount", label: "Lost Revenue", aggregate: "sum", field: "amount", filter: { stage: "closed_lost" }, format: "0,0" }, + { name: "win_rate", label: "Win Rate", derived: { op: "ratio", of: ["won_count", "decided_count"] }, format: "0%" } + ] +}); + +// src/sales/datasets/account.dataset.ts +import { defineDataset as defineDataset3 } from "@objectstack/spec/ui"; +var AccountDataset = defineDataset3({ + name: "account_metrics", + label: "Account Metrics", + description: "Semantic layer for account counts by industry / type", + object: "crm_account", + dimensions: [ + { name: "industry", label: "Industry", field: "industry", type: "string" }, + { name: "type", label: "Type", field: "type", type: "string" }, + { name: "created_at", label: "Created", field: "created_at", type: "date", dateGranularity: "month" } + ], + measures: [ + { name: "account_count", label: "Accounts", aggregate: "count" }, + { name: "annual_revenue_sum", label: "Annual Revenue", aggregate: "sum", field: "annual_revenue", format: "0,0" } + ] +}); + +// src/sales/datasets/contact.dataset.ts +import { defineDataset as defineDataset4 } from "@objectstack/spec/ui"; +var ContactDataset = defineDataset4({ + name: "contact_metrics", + label: "Contact Metrics", + description: "Semantic layer for contact counts", + object: "crm_contact", + dimensions: [], + measures: [{ name: "contact_count", label: "Contacts", aggregate: "count" }] +}); + +// src/sales/datasets/lead.dataset.ts +import { defineDataset as defineDataset5 } from "@objectstack/spec/ui"; +var LeadDataset = defineDataset5({ + name: "lead_metrics", + label: "Lead Metrics", + description: "Semantic layer for lead counts", + object: "crm_lead", + dimensions: [ + { name: "status", label: "Status", field: "status", type: "string" }, + { name: "lead_source", label: "Source", field: "lead_source", type: "string" }, + { name: "created_at", label: "Created", field: "created_at", type: "date" }, + { name: "last_contacted_date", label: "Last Contacted", field: "last_contacted_date", type: "date", dateGranularity: "month" } + ], + measures: [{ name: "lead_count", label: "Leads", aggregate: "count" }] +}); + +// src/sales/datasets/task.dataset.ts +import { defineDataset as defineDataset6 } from "@objectstack/spec/ui"; +var TaskDataset = defineDataset6({ + name: "task_metrics", + label: "Task Metrics", + description: "Semantic layer for task workload and completion", + object: "crm_task", + dimensions: [ + { name: "status", label: "Status", field: "status", type: "string" }, + { name: "priority", label: "Priority", field: "priority", type: "string" }, + { name: "priority_rank", label: "Urgency", field: "priority_rank", type: "number" }, + { name: "type", label: "Type", field: "type", type: "string" }, + { name: "due_date", label: "Due Date", field: "due_date", type: "date" }, + { name: "is_overdue", label: "Overdue", field: "is_overdue", type: "boolean" }, + { name: "is_completed", label: "Completed", field: "is_completed", type: "boolean" } + ], + measures: [ + { name: "task_count", label: "Tasks", aggregate: "count" }, + { name: "avg_progress", label: "Avg Progress", aggregate: "avg", field: "progress_percent", format: "0.0%" } + ] +}); + +// src/sales/datasets/event.dataset.ts +import { defineDataset as defineDataset7 } from "@objectstack/spec/ui"; +var EventDataset = defineDataset7({ + name: "event_metrics", + label: "Activity Metrics", + description: "Semantic layer for meetings, calls and interaction recency", + object: "crm_event", + dimensions: [ + { name: "type", label: "Activity Type", field: "type", type: "string" }, + { name: "status", label: "Status", field: "status", type: "string" }, + // `owner` is the SEMANTIC name every widget/report selects by; the column + // behind it is the platform ownership anchor `owner_id` (#548). + { name: "owner", label: "Owner", field: "owner_id", type: "string" }, + { name: "related_to_type", label: "Related To", field: "related_to_type", type: "string" }, + { + name: "start_datetime", + label: "Activity Week", + field: "start_datetime", + type: "date", + dateGranularity: "week" + } + ], + measures: [ + { name: "event_count", label: "Activities", aggregate: "count" }, + { + name: "total_minutes", + label: "Minutes", + aggregate: "sum", + field: "duration_minutes", + format: "0,0" + }, + { + name: "avg_minutes", + label: "Avg Duration", + aggregate: "avg", + field: "duration_minutes", + format: "0,0" + } + ] +}); + +// src/sales/datasets/forecast.dataset.ts +import { defineDataset as defineDataset8 } from "@objectstack/spec/ui"; +var ForecastDataset = defineDataset8({ + name: "forecast_metrics", + label: "Forecast Metrics", + description: "Semantic layer for per-owner quota, attainment and pipeline coverage", + object: "crm_forecast", + dimensions: [ + // Semantic name `owner`; column `owner_id`, the platform anchor (#548). + { name: "owner", label: "Owner", field: "owner_id", type: "lookup" }, + { name: "period", label: "Period Type", field: "period", type: "string" }, + { name: "period_label", label: "Period", field: "period_label", type: "string" }, + { name: "period_start", label: "Period Start", field: "period_start", type: "date" } + ], + measures: [ + { name: "quota_sum", label: "Quota", aggregate: "sum", field: "quota", format: "0,0" }, + { name: "closed_sum", label: "Closed", aggregate: "sum", field: "closed_amount", format: "0,0" }, + { name: "pipeline_sum", label: "Pipeline", aggregate: "sum", field: "pipeline_amount", format: "0,0" }, + { name: "commit_sum", label: "Commit", aggregate: "sum", field: "commit_amount", format: "0,0" }, + // Derived ratio (ADR-0021 Q1) rather than avg(attainment_pct): summing + // closed and quota before dividing weights every rep/period by quota + // size, where an average of per-row percentages would not. + { name: "attainment", label: "Attainment", derived: { op: "ratio", of: ["closed_sum", "quota_sum"] }, format: "0%" } + ] +}); + +// src/revenue/datasets/index.ts +var datasets_exports2 = {}; +__export(datasets_exports2, { + ProductDataset: () => ProductDataset +}); + +// src/revenue/datasets/product.dataset.ts +import { defineDataset as defineDataset9 } from "@objectstack/spec/ui"; +var ProductDataset = defineDataset9({ + name: "product_metrics", + label: "Product Metrics", + description: "Semantic layer for product catalog counts and list price", + object: "crm_product", + dimensions: [ + { name: "category", label: "Category", field: "category", type: "string" } + ], + measures: [ + { name: "product_count", label: "Products", aggregate: "count" }, + { name: "list_price_sum", label: "Total List Price", aggregate: "sum", field: "list_price", format: "0,0" } + ] +}); + +// src/sales/reports/index.ts +var reports_exports = {}; +__export(reports_exports, { + AccountsByIndustryTypeReport: () => AccountsByIndustryTypeReport, + CustomerChurnSignalsReport: () => CustomerChurnSignalsReport, + LeadInflowByMonthSourceReport: () => LeadInflowByMonthSourceReport, + OpportunitiesByStageReport: () => OpportunitiesByStageReport, + OpportunityFunnelByOwnerStageReport: () => OpportunityFunnelByOwnerStageReport, + PipelineCoverageByQuarterReport: () => PipelineCoverageByQuarterReport, + WonOpportunitiesByOwnerReport: () => WonOpportunitiesByOwnerReport +}); + +// src/sales/reports/account.report.ts +var AccountsByIndustryTypeReport = { + name: "accounts_by_industry_type", + label: "Accounts by Industry and Type", + description: "Matrix report showing accounts by industry and type", + dataset: "account_metrics", + rows: ["industry"], + columns: ["type"], + values: ["account_count", "annual_revenue_sum"], + type: "matrix", + runtimeFilter: { is_active: true } +}; + +// src/sales/reports/lead.report.ts +var LeadInflowByMonthSourceReport = { + name: "lead_inflow_by_month_source", + label: "Lead Engagement by Month \xD7 Source", + description: "Contacted-lead volume per month, broken down by acquisition channel", + dataset: "lead_metrics", + rows: ["lead_source"], + columns: ["last_contacted_date"], + values: ["lead_count"], + type: "matrix", + // A never-contacted lead has no engagement month, and grouping it produced a + // headerless '—' column next to the real ones. This report counts CONTACTED + // leads (see the label/description), so the empty bucket is excluded at the + // source rather than rendered as a mystery column. + runtimeFilter: { last_contacted_date: { $ne: null } } +}; + +// src/sales/reports/opportunity.report.ts +var OpportunitiesByStageReport = { + name: "opportunities_by_stage", + label: "Opportunities by Stage", + description: "Summary of opportunities grouped by stage", + dataset: "opportunity_metrics", + rows: ["stage"], + values: ["total_amount", "avg_probability"], + type: "summary", + // `{current_year_start}` is a spec date macro (DATE_MACRO_TOKENS) resolved + // per-query, so the YTD window rolls with time instead of freezing the year + // the artifact was built into dist/objectstack.json. + runtimeFilter: { stage: { $ne: "closed_lost" }, close_date: { $gte: "{current_year_start}" } }, + chart: { type: "bar", title: "Pipeline by Stage", showLegend: true, xAxis: "stage", yAxis: "total_amount" } +}; +var WonOpportunitiesByOwnerReport = { + name: "won_opportunities_by_owner", + label: "Won Opportunities by Owner", + description: "Closed won opportunities grouped by owner", + dataset: "opportunity_metrics", + rows: ["owner"], + values: ["total_amount"], + type: "summary", + runtimeFilter: { stage: "closed_won" }, + chart: { type: "column", title: "Revenue by Sales Rep", showLegend: false, xAxis: "owner", yAxis: "total_amount" } +}; +var PipelineCoverageByQuarterReport = { + name: "pipeline_coverage_by_quarter", + label: "Pipeline Coverage by Forecast \xD7 Quarter", + description: "Open pipeline amount by forecast category, bucketed by close quarter", + dataset: "opportunity_metrics", + rows: ["forecast_category"], + columns: ["close_quarter"], + values: ["total_amount", "opp_count"], + type: "matrix", + runtimeFilter: { stage: { $nin: ["closed_won", "closed_lost"] } } +}; +var OpportunityFunnelByOwnerStageReport = { + name: "opportunity_funnel_owner_stage", + label: "Opportunity Funnel by Owner \u2192 Stage", + description: "Per-rep stage-by-stage pipeline funnel", + dataset: "opportunity_metrics", + rows: ["owner", "stage"], + values: ["total_amount", "opp_count", "avg_probability"], + type: "summary", + runtimeFilter: { stage: { $ne: "closed_lost" } }, + chart: { type: "funnel", title: "Pipeline Funnel", showLegend: false, xAxis: "stage", yAxis: "total_amount" } +}; + +// src/sales/reports/churn.report.ts +var CustomerChurnSignalsReport = { + name: "customer_churn_signals", + label: "Customer Churn Signals", + description: "Three-panel early-warning view: at-risk customers, silent high-value accounts, and recently-lost opportunities.", + type: "joined", + blocks: [ + { + // Named for the ACTOR, not the value, because `at_risk` is also a + // `health_score` option and `at_risk_accounts` is already the block + // below (a time window, nothing to do with the field). The two are + // allowed to overlap: this one asks "who did a human flag", that one + // asks "whose clock stopped". + name: "csm_flagged_accounts", + label: "CSM-Flagged Accounts", + description: "Accounts a CSM has hand-flagged as at-risk or churning, grouped by type \u2014 human judgement, independent of the activity clock.", + type: "summary", + dataset: "account_metrics", + rows: ["type"], + values: ["account_count"], + // No date term on purpose (see the header). `is_active` matches the two + // account blocks below: a deactivated account has already churned, so it + // is not a retention queue item. Grouping by `type` separates a flagged + // CUSTOMER (revenue at risk today) from a flagged prospect or partner, + // which the grid view `crm_account.at_risk_accounts` cannot show — it is + // scoped to `type: 'customer'` before anything else. + runtimeFilter: { + is_active: true, + health_score: { $in: ["at_risk", "churning"] } + } + }, + { + name: "at_risk_accounts", + label: "At-Risk Accounts", + description: "Active accounts with no activity in 60+ days, grouped by industry.", + type: "summary", + dataset: "account_metrics", + rows: ["industry"], + values: ["account_count"], + runtimeFilter: { + is_active: true, + last_activity_date: { $lt: "{60_days_ago}" } + } + }, + { + name: "silent_high_value", + label: "Silent High-Value Accounts", + description: "Strategic and enterprise accounts gone quiet for 90+ days, grouped by type.", + type: "summary", + dataset: "account_metrics", + rows: ["type"], + values: ["account_count"], + // "High-value" is the account's tier, not a revenue threshold: the + // strategic/enterprise tiers are exactly the book the CSM team owns. + runtimeFilter: { + is_active: true, + tier: { $in: ["strategic", "enterprise"] }, + last_activity_date: { $lt: "{90_days_ago}" } + } + }, + { + name: "recently_closed_lost", + label: "Recently Lost Opportunities", + description: "Opportunities closed-lost in the last 30 days \u2014 investigate before the customer fully churns.", + type: "summary", + dataset: "opportunity_metrics", + rows: ["owner"], + values: ["total_amount", "opp_count"], + runtimeFilter: { + stage: "closed_lost", + close_date: { $gte: "{30_days_ago}" } + } + } + ] +}; + +// src/sales/mappings/index.ts +var mappings_exports = {}; +__export(mappings_exports, { + AccountImportMapping: () => AccountImportMapping, + ContactImportMapping: () => ContactImportMapping, + LeadImportMapping: () => LeadImportMapping +}); + +// src/sales/mappings/account_import.mapping.ts +import { defineMapping } from "@objectstack/spec/data"; + +// src/sales/mappings/_shared.ts +var INDUSTRY_SYNONYMS = { + "SaaS": "software", + "Saas": "software", + "IT": "technology", + "Tech": "technology", + "Information Technology": "technology", + "Financial Services": "finance", + "Banking": "finance", + "Insurance": "finance", + "Health Care": "healthcare", + "Pharmaceuticals": "healthcare", + "E-commerce": "retail", + "Ecommerce": "retail", + "Consumer Goods": "retail", + "Transportation": "logistics", + "Utilities": "energy", + "Oil & Gas": "energy", + "Public Sector": "government", + "Non Profit": "nonprofit", + "Non-Profit": "nonprofit", + "NGO": "nonprofit", + "Travel & Hospitality": "hospitality" +}; +var LEAD_SOURCE_SYNONYMS = { + "Website": "web", + "Web Site": "web", + "Inbound": "web", + "Word of mouth": "referral", + "Customer Referral": "referral", + "Trade Show": "event", + "Conference": "event", + "Seminar": "webinar", + "Partner Referral": "partner", + "Google Ads": "paid_search", + "AdWords": "paid_search", + "SEM": "paid_search", + "LinkedIn": "social", + "Facebook": "social", + "X": "social", + "Twitter": "social", + "Blog": "content", + "Whitepaper": "content", + "Phone Inquiry": "cold_call", + "Outbound": "cold_call", + "Email": "email_campaign", + "Newsletter": "email_campaign" +}; +var DEPARTMENT_SYNONYMS = { + "HR": "hr" +}; + +// src/sales/mappings/account_import.mapping.ts +var AccountImportMapping = defineMapping({ + name: "crm_account_import", + label: "Account Import (CSV)", + targetObject: "crm_account", + sourceFormat: "csv", + // also accepted for .xlsx uploads — both are tabular + mode: "upsert", + upsertKey: ["name"], + fieldMapping: [ + { source: "Account Name", target: "name" }, + { + source: "Account Type", + target: "type", + transform: "map", + params: { + valueMap: { + "Client": "customer", + "Reseller": "partner", + "Churned": "former", + "Lost Customer": "former" + } + } + }, + { + source: "Industry", + target: "industry", + transform: "map", + params: { valueMap: INDUSTRY_SYNONYMS } + }, + // The account hook rejects a website that is not http(s) — keep full URLs + // in the source sheet (see `src/sales/objects/account.hook.ts`). + { source: "Website", target: "website" }, + { source: "Phone", target: "phone" }, + { source: "Annual Revenue", target: "annual_revenue" }, + { source: "Employees", target: "number_of_employees" }, + { source: "Description", target: "description" }, + // Owner resolution. VERIFIED against the platform import path + // (`packages/rest/src/import-runner.ts` → `resolveRef`): a reference cell + // is resolved against the referenced object by `id`, the field's + // `displayField`, then `name` / `title` / `label` / `full_name` / `email` / + // `username`. `sys_user` has an `email` column, so an owner-email cell + // resolves to that user's id — no separate resolution step is needed here. + // An address that matches no user FAILS the row (`reference_not_found`); + // leaving the cell BLANK is the supported fallback — the security + // middleware's insert-time stamp then makes the importing user the owner + // (the import write carries the importer's context, not `isSystem`). + // + // The target is `owner_id`, the platform ownership anchor — #548 retired + // the app-authored `owner` lookup this used to name. A resolved cell is + // therefore an ownership TRANSFER: it plants the row under someone other + // than the importer, which the #3004 guard denies unless the importing user + // holds `allowTransfer` (system_admin / sales_manager do). That is the + // intended posture — a bulk file that silently reassigns the book is + // exactly what the grant exists to gate. + { source: "Account Owner Email", target: "owner_id", transform: "lookup" }, + // Self-reference: a parent named later in the same file still resolves — + // the runner flushes buffered creates and retries once (framework#3148). + { source: "Parent Account", target: "parent_account", transform: "lookup" } + // NOT MAPPED — `billing_address` / `office_location` are structured + // (json-backed `address` / `location`) fields. A joined string is not a + // way in: the engine rejects it per row — measured, `Billing Address has an + // invalid address value: Invalid input: expected object, received string`. + // (The dry run does NOT predict that rejection; it reports the row ok. + // Framework-side, filed as objectstack-ai/objectstack#4633.) + // Address columns are therefore left out of the account template. A target + // may now name a declared PART of a compound field — `contact_import.mapping.ts` + // maps five columns into `mailing_address.street` … `.country` (#1836) — so + // adding address columns here would be a template change, not a platform gap. + ] +}); + +// src/sales/mappings/contact_import.mapping.ts +import { defineMapping as defineMapping2 } from "@objectstack/spec/data"; +var ContactImportMapping = defineMapping2({ + name: "crm_contact_import", + label: "Contact Import (CSV)", + targetObject: "crm_contact", + sourceFormat: "csv", + mode: "upsert", + upsertKey: ["email"], + fieldMapping: [ + { source: "Salutation", target: "salutation" }, + { source: "First Name", target: "first_name" }, + { source: "Last Name", target: "last_name" }, + // Required master-detail parent; resolved by account name. + { source: "Account Name", target: "crm_account", transform: "lookup" }, + { source: "Title", target: "title" }, + { + source: "Department", + target: "department", + transform: "map", + params: { valueMap: DEPARTMENT_SYNONYMS } + }, + { source: "Email", target: "email" }, + { source: "Phone", target: "phone" }, + { source: "Mobile", target: "mobile" }, + // Five template columns, one structured field: each column names a part + // of `mailing_address`, and the import assembles the parts one row maps + // into that field's single value. + { source: "Mailing Street", target: "mailing_address.street" }, + { source: "Mailing City", target: "mailing_address.city" }, + { source: "Mailing State", target: "mailing_address.state" }, + { source: "Mailing Postal Code", target: "mailing_address.postalCode" }, + { source: "Mailing Country", target: "mailing_address.country" }, + { + source: "Lead Source", + target: "lead_source", + transform: "map", + params: { valueMap: LEAD_SOURCE_SYNONYMS } + }, + { source: "Description", target: "description" }, + // Owner-email resolution, the blank-cell fallback, and why a filled cell + // needs `allowTransfer`: see the long note in `account_import.mapping.ts`. + { source: "Contact Owner Email", target: "owner_id", transform: "lookup" } + ] +}); + +// src/sales/mappings/lead_import.mapping.ts +import { defineMapping as defineMapping3 } from "@objectstack/spec/data"; +var LeadImportMapping = defineMapping3({ + name: "crm_lead_import", + label: "Lead Import (CSV)", + targetObject: "crm_lead", + sourceFormat: "csv", + mode: "upsert", + upsertKey: ["email"], + fieldMapping: [ + { source: "Salutation", target: "salutation" }, + { source: "First Name", target: "first_name" }, + { source: "Last Name", target: "last_name" }, + { source: "Company", target: "company" }, + { source: "Title", target: "title" }, + { + source: "Industry", + target: "industry", + transform: "map", + params: { valueMap: INDUSTRY_SYNONYMS } + }, + { source: "Email", target: "email" }, + { source: "Phone", target: "phone" }, + { source: "Mobile", target: "mobile" }, + { source: "Website", target: "website" }, + { + source: "Lead Status", + target: "status", + transform: "map", + params: { + valueMap: { + "Open": "new", + "Working": "contacted", + "In Progress": "contacted", + "Nurturing": "contacted", + "Disqualified": "unqualified", + "Closed - Not Converted": "unqualified" + } + } + }, + { + source: "Lead Source", + target: "lead_source", + transform: "map", + params: { valueMap: LEAD_SOURCE_SYNONYMS } + }, + { source: "Annual Revenue", target: "annual_revenue" }, + { source: "Employees", target: "number_of_employees" }, + { source: "Description", target: "description" }, + // Owner-email resolution and the `allowTransfer` gate on a filled cell: + // see the long note in `account_import.mapping.ts`. The blank-cell + // behaviour differs — see the header comment above. + { source: "Lead Owner Email", target: "owner_id", transform: "lookup" } + // NOT MAPPED — `crm_lead.address` is a structured (json-backed) `address` + // field; the import path cannot compose one from separate street/city/ + // postcode columns, and a joined string is rejected per row. Same + // reasoning, and the same measurement, as the account mapping. + ] +}); + +// src/sales/apps/index.ts +var apps_exports = {}; +__export(apps_exports, { + CrmApp: () => CrmApp +}); + +// src/sales/apps/crm.app.ts +import { App } from "@objectstack/spec/ui"; +var HOTCRM_ICON = 'data:image/svg+xml,%0A %0A %0A%0A'; +var CrmApp = App.create({ + name: "crm_enterprise", + label: "HotCRM", + icon: "briefcase", + // ADR-0063 §1/§2 — `defaultAgent` is a surface binding, not a custom-agent + // slot: the only resolvable values are the two PLATFORM agents, `ask` (data + // surface) and `build` (authoring surface). HotCRM is a data surface, so it + // binds `ask`; the app's own AI capability ships as skills (`src/*/skills/`), + // which attach to the platform agents by `surface` affinity. The app-authored + // agents this key used to name were retired in #512. + defaultAgent: "ask", + // `logo` and `favicon` are the inlined `HOTCRM_ICON` above (#2051), never a + // server path: an install serves only what the artifact carries. The console + // passes each value through untouched — `logo` as the sidebar's ``, + // `favicon` as the favicon `link.href` — and a `data:` URI renders in both. + // `primaryColor` is the icon's tile fill (#2066): the mark and the theme are one orange. + branding: { + primaryColor: "#EA580C", + logo: HOTCRM_ICON, + favicon: HOTCRM_ICON + }, + navigation: [ + // Pinned landing — single executive view, single click from launcher. + { + id: "nav_home", + type: "dashboard", + dashboardName: "executive_dashboard", + label: "Home", + icon: "home" + }, + { + id: "group_sales", + type: "group", + label: "Sales", + icon: "chart-line", + expanded: true, + children: [ + { id: "nav_lead", type: "object", objectName: "crm_lead", label: "Leads", icon: "user-plus" }, + { id: "nav_account", type: "object", objectName: "crm_account", label: "Accounts", icon: "building" }, + // ADR-0047 interface page — the curated counterpart to the Accounts + // object entry (quick filters only; activates with spec > 9.2.0). + { id: "nav_account_workbench", type: "page", pageName: "account_workbench", label: "Account Workbench", icon: "sliders-horizontal" }, + { id: "nav_contact", type: "object", objectName: "crm_contact", label: "Contacts", icon: "user" }, + // No separate "Pipeline" entry: the kanban board is another tab on + // this same list page — `pipeline_kanban` in + // `OpportunityViews.listViews`, which the switcher puts on the strip + // under its own label, *Sales Pipeline* — one click from here and + // zero clicks further than a second sidebar row. The + // view-entry exemplar duty this item used to carry now sits with the + // "My Work" items below, which are all object + `viewName`. + { id: "nav_opportunity", type: "object", objectName: "crm_opportunity", label: "Opportunities", icon: "target" }, + { id: "nav_quote", type: "object", objectName: "crm_quote", label: "Quotes", icon: "receipt" }, + // Contracts close the sales cycle: quote → signed agreement → renewal. + // The object, its views and its renewal automation all shipped, but + // there was no way to reach any of it from the app. + { id: "nav_contract", type: "object", objectName: "crm_contract", label: "Contracts", icon: "file-signature" }, + // Products sit here, not under Marketing (#1259): they are the + // revenue master data every quote line and opportunity line item + // points at — a sales object that happened to be filed next to + // campaigns. + { id: "nav_product", type: "object", objectName: "crm_product", label: "Products", icon: "package" }, + { id: "nav_sales_dashboard", type: "dashboard", dashboardName: "sales_dashboard", label: "Sales Performance", icon: "chart-line" } + ] + }, + { + // Everything a rep owes someone. `crm_task` had views, seed data, a + // recurrence hook and two reminder flows, and no entry point — the only + // way to see a task was to open the record it hung off. + id: "group_work", + type: "group", + label: "My Work", + icon: "list-checks", + expanded: true, + // These are ListViews: they list the records themselves, which a + // dashboard widget (an aggregate over a dataset, ADR-0021) cannot. Both + // surfaces resolve `{current_user_id}` since objectstack#12230 — the + // Service dashboard's "My Open Cases by Priority" is the aggregate + // counterpart of "My Cases" (#510). + // + // Every item here is object + `viewName`, which makes this group the + // app's view-entry exemplar since #1259 retired the "Pipeline" row. + // The one exception is the approvals Inbox at the bottom — a + // `component` entry, and the app's only one. + children: [ + { id: "nav_my_tasks", type: "object", objectName: "crm_task", viewName: "my_open_tasks", label: "My Tasks", icon: "circle-check" }, + { id: "nav_my_deals", type: "object", objectName: "crm_opportunity", viewName: "my_open_deals", label: "My Deals", icon: "target" }, + { id: "nav_my_leads", type: "object", objectName: "crm_lead", viewName: "my_leads", label: "My Leads", icon: "user-plus" }, + // #592 — the rep's own calendar: a list of events, so a view, not a + // dashboard. + { id: "nav_my_calendar", type: "object", objectName: "crm_event", viewName: "my_events", label: "My Calendar", icon: "calendar-days" }, + // No "All Tasks" entry: "My Tasks" opens the `crm_task` list page, + // whose tab strip leads with *All Tasks* — `TaskViews.list`, name + // `all_tasks`. It leads because it is the object's PRIMARY list: the + // switcher moves the primary to the front of the strip and marks it + // default, so nothing has to be authored to say so. The whole book is + // one tab away, and the sidebar keeps one row per object instead of + // two. + // + // ── The approvals Inbox lives here, not in a group of its own (#1259) + // + // It used to be the single child of an "Approvals" group. Its content + // is a personal queue — the things waiting on *you* — which is what + // this group is; a one-item group next to it was structure without a + // distinction. Dissolving that group is why this entry moved, not any + // rule against single-item groups (Marketing is one and stays one). + // + // "Inbox" (zh-CN 待我审批) must land somewhere an approver can actually + // approve. It used to be `type: 'object'` on `sys_approval_request` — + // the approvals plugin's raw request table, which is read-only: no row + // actions, no approve/reject, only Share on the record detail. The label + // promised an action the destination could not perform (#1123). + // + // `component` — not `url`. The platform's approval centre is a + // first-party console surface registered in the ComponentRegistry as + // `approvals:inbox` (registered by @objectstack/console itself, source + // `@object-ui/console`, rendering ApprovalsInboxPage) — exactly what the + // spec documents `component` for: "a first-party UI shipped with the + // platform — typically admin/setup surfaces that have no row in any data + // store". `url` is documented as the *external link* type, and taking it + // would mean hard-coding a console-internal route plus this app's own + // name (`/apps/crm_enterprise/system/approvals`) into metadata. A + // `componentRef` instead resolves against the *current* app base, so the + // entry keeps the user inside HotCRM's shell without naming the app, and + // a ref that ever stops resolving renders a loud "Component not + // registered" panel rather than silently bouncing to the console home. + // + // The read-only object list is not kept as a second "history" entry: the + // approval centre already subsumes it — My Pending / Submitted by me / + // All tabs plus a status filter (Pending / Approved / Rejected / + // Recalled / Returned for revision) — so a second entry would add a + // strictly weaker view of the same rows. + // + // `requiresObject` is retained: it is a base nav-item field on every + // item type, so the entry still hides itself on installs where + // @objectstack/plugin-approvals is absent and no approval exists to act + // on. + // + // There is no "Processes" item either: @objectstack/plugin-approvals + // registers sys_approval_request / sys_approval_action / + // sys_approval_approver / sys_approval_delegation — but neither a bare + // `sys_approval` nor a `sys_approval_process` object exists in any + // installed plugin (measured on the 17.2.0 rosters), + // so the old item's requiresObject guard hid it on every install, + // forever. + { id: "nav_approval_requests", type: "component", componentRef: "approvals:inbox", label: "Inbox", icon: "inbox", requiresObject: "sys_approval_request" } + ] + }, + { + // #592 — activity was the app's largest blind spot: `crm_event` and its + // attendee rows had nowhere to be seen, and no dashboard anywhere counted + // an interaction. Kept as its own group rather than buried under Sales, + // because "what happened with this customer, and when?" is the question + // the whole batch was about. + id: "group_activity", + type: "group", + label: "Activity", + icon: "calendar-days", + expanded: true, + children: [ + // One row for the object, one for the dashboard. The calendar and the + // interaction history are two more tabs on this same list page — + // `event_calendar` and `held_events` in `EventViews.listViews`, which + // the switcher puts on the strip under each view's own label — #1259 + // removed the sidebar duplicates, not the surfaces. `crm_event` had + // four sidebar rows; + // it was the single largest source of the nav's growth. + { id: "nav_event", type: "object", objectName: "crm_event", label: "Events", icon: "calendar-days" }, + { id: "nav_activity_dashboard", type: "dashboard", dashboardName: "sales_activity_dashboard", label: "Sales Activity", icon: "activity" } + ] + }, + { + // Campaigns drive lead_source and the campaign-member records that + // "Add to Campaign" writes — with no nav entry the marketing half of + // the data model was invisible. + // + // A single-item group on purpose (#1259). Marketing is a domain of its + // own, and a reader scanning the sidebar for "where does campaign work + // live" finds it by name. Item-count symmetry is not the goal; the + // Approvals group was dissolved because its item *was* personal work, + // not because one child is too few. + id: "group_marketing", + type: "group", + label: "Marketing", + icon: "megaphone", + children: [ + { id: "nav_campaign", type: "object", objectName: "crm_campaign", label: "Campaigns", icon: "megaphone" } + ] + }, + { + id: "group_service", + type: "group", + label: "Service", + icon: "headset", + expanded: true, + // EMPTY ON PURPOSE — this group is a CONTAINER, not a menu. + // + // `crm_case`, `crm_knowledge_article`, `service_dashboard` and + // `sla_performance` belong to `app.objectstack.hotcrm.service`, and an + // app's own `navigation` may not name another package's object (ADR-0130 + // §1.5): the entry fails at author time with "references object + // `crm_case` which is not defined in objects". The module puts all three + // back through `navigationContributions` (ADR-0029 D7), and it can only + // aim at a group the app DECLARES — a module cannot create one inside an + // app it does not own. So the app publishes the anchor and the module + // fills it; `src/service/index.ts` holds the other half, and the two + // service items of *My Work* and *Insights* come back the same way. + // + // ⛔ Do not "tidy" the group away: deleting it relocates all three + // contributed items to the app's top level with a + // `nav_contribution_group_missing` warning. + children: [] + }, + { + id: "group_insights", + type: "group", + label: "Insights", + icon: "sparkles", + children: [ + // Trimmed to three high-signal reports. Full report catalogue still + // ships as metadata; admins can pin more from the report picker. + { id: "nav_crm_dashboard", type: "dashboard", dashboardName: "crm_overview_dashboard", label: "CRM Overview", icon: "layout-dashboard" }, + { id: "nav_forecast", type: "object", objectName: "crm_forecast", label: "Forecasts", icon: "trending-up" }, + { id: "nav_report_pipeline_coverage", type: "report", reportName: "pipeline_coverage_by_quarter", label: "Pipeline Coverage", icon: "columns-3" }, + { id: "nav_report_lead_inflow", type: "report", reportName: "lead_inflow_by_month_source", label: "Lead Inflow", icon: "trending-up" } + ] + } + ] +}); + +// src/sales/profiles/index.ts +var profiles_exports = {}; +__export(profiles_exports, { + GuestPortalProfile: () => GuestPortalProfile, + MarketingUserProfile: () => MarketingUserProfile, + SalesManagerProfile: () => SalesManagerProfile, + SalesRepProfile: () => SalesRepProfile, + ServiceAgentProfile: () => ServiceAgentProfile, + ServiceManagerProfile: () => ServiceManagerProfile, + SystemAdminProfile: () => SystemAdminProfile +}); + +// src/sales/profiles/guest-portal.profile.ts +var GuestPortalProfile = { + name: "guest_portal", + label: "Guest (Public Forms)", + description: "Anonymous visitors submitting public Web-to-Lead / Web-to-Case forms. INSERT-only on lead and case; no read/edit/delete on any object.", + // No `allowExport` anywhere below, deliberately: this set is bound to the + // `guest` anchor, and ADR-0090 D9 classes `allowExport` as a high-privilege + // bit no anchor may confer — the set would stop binding at all, on top of + // handing anonymous visitors bulk table egress. See `src/sales/profiles/index.ts`. + objects: { + crm_lead: { + allowCreate: true, + allowRead: false, + allowEdit: false, + allowDelete: false, + viewAllRecords: false, + modifyAllRecords: false + }, + crm_case: { + allowCreate: true, + allowRead: false, + allowEdit: false, + allowDelete: false, + viewAllRecords: false, + modifyAllRecords: false + } + } +}; + +// src/sales/profiles/marketing-user.profile.ts +var MarketingUserProfile = { + name: "marketing_user", + label: "Marketing User", + objects: { + // `allowExport` where an export surface exists — canonical note in + // `src/sales/profiles/index.ts`. Lead and contact list exports are marketing's + // core targeting workflow; account/opportunity back the campaign-ROI + // reports. No `crm_case` grant here, so no export bit for it either. + crm_lead: { allowCreate: true, allowRead: true, allowEdit: true, allowDelete: false, viewAllRecords: true, modifyAllRecords: false, allowExport: true }, + crm_account: { allowCreate: false, allowRead: true, allowEdit: false, allowDelete: false, viewAllRecords: true, modifyAllRecords: false, allowExport: true }, + crm_contact: { allowCreate: true, allowRead: true, allowEdit: true, allowDelete: false, viewAllRecords: true, modifyAllRecords: false, allowExport: true }, + crm_campaign: { allowCreate: true, allowRead: true, allowEdit: true, allowDelete: false, viewAllRecords: true, modifyAllRecords: false }, + // Org-wide read: marketing attributes campaign → pipeline ROI, which needs + // every opportunity, not just self-owned. viewAllRecords was false here + // while every other object on this set is true — an oversight that hid all + // pipeline from marketing (and tripped security-private-no-readscope). + crm_opportunity: { allowCreate: false, allowRead: true, allowEdit: false, allowDelete: false, viewAllRecords: true, modifyAllRecords: false, allowExport: true }, + // Campaign membership is THIS profile's core write surface: the + // "Add to Campaign" action (`src/sales/actions/lead.actions.ts`) inserts + // `crm_campaign_member` rows, and before #488 no permission set granted the + // object — the action failed for the only persona meant to run it. Rows + // derive from the campaign (controlled_by_parent), so there is no record + // scope to author — and as of 17.0.0-rc.4 that derivation does follow the + // campaign grant: MEASURED and pinned by + // `test/parent-derived-reach.test.ts`, master accessibility resolves through + // the same paths a direct read of the campaign takes, ownership and + // `sys_record_share` grants included. For THIS profile the delta is small — + // `crm_campaign` is `public_read` and this set holds org-wide campaign read, + // so the rows are the same either way — but the grant is now scope that + // follows the campaigns above, not org-wide read in fact as it was through + // 17.0.0-rc.3 (objectstack-ai/objectstack#5386, #694). + // Deleting membership history stays a manager/admin privilege, matching + // every other object here. + crm_campaign_member: { allowCreate: true, allowRead: true, allowEdit: true, allowDelete: false, viewAllRecords: false, modifyAllRecords: false }, + // Read-only reference: knowledge articles for campaign copy + // (public_read catalog). + // Reads the KB and may rate it; cannot author articles (#601). + crm_article_feedback: { allowCreate: true, allowRead: true, allowEdit: true, allowDelete: false, viewAllRecords: true, modifyAllRecords: false }, + crm_knowledge_article: { allowCreate: false, allowRead: true, allowEdit: false, allowDelete: false, viewAllRecords: true, modifyAllRecords: false }, + // The record Attachments panel, READ only: canonical note on `enable.files` + // in `src/sales/objects/index.ts` (#2029). Which attachments it lists + // derives from the parent record; upload and delete wait upstream. + sys_attachment: { allowCreate: false, allowRead: true, allowEdit: false, allowDelete: false, viewAllRecords: false, modifyAllRecords: false }, + // The record Discussion panel, comments and activity: canonical note on + // `enable.feeds` in `src/sales/objects/index.ts` (#2029). Which threads it + // reaches derives from the parent record; deleting a comment waits upstream. + sys_comment: { allowCreate: true, allowRead: true, allowEdit: true, allowDelete: false, viewAllRecords: false, modifyAllRecords: false }, + sys_activity: { allowCreate: false, allowRead: true, allowEdit: false, allowDelete: false, viewAllRecords: false, modifyAllRecords: false } + }, + fields: { + // Marketing reads pipeline for campaign ROI but never prices a deal, and + // account health is the renewal team's call — read, never write (#488). + "crm_opportunity.amount": { readable: true, editable: false }, + "crm_account.health_score": { readable: true, editable: false } + }, + // The same private-deal row filter the sales_manager set carries: this + // profile also holds org-wide opportunity read, so it is one of the readers + // `crm_opportunity.is_private` has to hold back. See sales-manager.profile.ts + // for the full rationale. + rowLevelSecurity: [ + { + name: "opportunity_private_owner_only_marketing", + // A deal flagged Private is visible only to its owner, even to holders of + // org-wide opportunity read. (`rowLevelSecurity[].label` / `description` + // are display copy — the 17.7.0 liveness ledger marks both live: the + // permission editor draws them on the policy card. This policy authors + // neither, so its intent lives in this comment.) + object: "crm_opportunity", + operation: "select", + using: "is_private == false || owner_id == current_user.id" + }, + // The platform's `member_default` set carries a wildcard owner-only-writes + // policy (`created_by == current_user.id` on update), and RLS policies are + // OR-combined — so without a policy of its own, this set's allowEdit on + // campaigns only reaches campaigns the user personally created. That also + // silently broke "Add to Campaign": enrolling a member is a write DERIVED + // from the campaign (controlled_by_parent), so it requires campaign edit at + // the row level. This is the one direction in which the ADR-0055 derivation + // really does narrow: a master RLS policy is exactly what it folds in, while + // ownership and `sys_record_share` grants are not (which is why the READ + // side of these member rows is org-wide — see the `crm_campaign_member` + // grant above and objectstack-ai/objectstack#5386, #694). This policy widens + // campaign updates to every holder of the set — exactly what the object + // grant above already declares. `id != null` + // is the pushdown-safe "all rows" predicate (verified: compiles to + // `{id: {$null: false}}`). + { + name: "marketing_campaign_updates", + // Marketing users edit any campaign (and thereby enrol members into it), + // not only campaigns they created. + object: "crm_campaign", + operation: "update", + using: "id != null" + }, + // Same widening for the member rows themselves: response tracking means + // updating rows the enrollment flow (system context) created, which the + // default owner-only-writes policy would otherwise deny. + { + name: "marketing_campaign_member_updates", + // Marketing users update member response state on rows they did not + // personally create. + object: "crm_campaign_member", + operation: "update", + using: "id != null" + } + ] +}; + +// src/sales/profiles/sales-manager.profile.ts +var SalesManagerProfile = { + name: "sales_manager", + label: "Sales Manager", + objects: { + // `allowTransfer` on exactly the objects this set holds `modifyAllRecords` + // on — the sales book a manager reassigns. Canonical note in + // `src/sales/profiles/index.ts`. + // `allowExport` where an export surface exists — canonical note in + // `src/sales/profiles/index.ts`. A manager owns the number, so the pipeline and + // book exports that feed offline forecasting are part of the job. + crm_lead: { allowCreate: true, allowRead: true, allowEdit: true, allowDelete: true, viewAllRecords: true, modifyAllRecords: true, allowTransfer: true, allowExport: true }, + crm_account: { allowCreate: true, allowRead: true, allowEdit: true, allowDelete: true, viewAllRecords: true, modifyAllRecords: true, allowTransfer: true, allowExport: true }, + crm_contact: { allowCreate: true, allowRead: true, allowEdit: true, allowDelete: true, viewAllRecords: true, modifyAllRecords: true, allowTransfer: true, allowExport: true }, + crm_opportunity: { allowCreate: true, allowRead: true, allowEdit: true, allowDelete: true, viewAllRecords: true, modifyAllRecords: true, allowTransfer: true, allowExport: true }, + crm_quote: { allowCreate: true, allowRead: true, allowEdit: true, allowDelete: true, viewAllRecords: true, modifyAllRecords: true, allowTransfer: true }, + // No writeScope: `crm_contract` is `controlled_by_parent` under + // `crm_account` (#549), so a scope here would be inert — the write gate + // asks for EDIT on the account instead, which this set holds org-wide + // (`modifyAllRecords` above). That retires the #880 gap on BOTH editions: + // the contract an accepted quote drafts hangs under the rep, and the + // manager edits it because they can edit its account, not because of a + // hierarchy depth. `own_and_reports` was the app's only authored hierarchy + // scope; `requires: ['hierarchy-security']` stays declared (#1378 ruling). + // `allowDelete: false` must keep holding; `modifyAllRecords: false` keeps + // this off the super-user bypass. `test/contract-write-depth.test.ts`. + crm_contract: { allowCreate: true, allowRead: true, allowEdit: true, allowDelete: false, viewAllRecords: true, modifyAllRecords: false }, + crm_product: { allowCreate: true, allowRead: true, allowEdit: true, allowDelete: false, viewAllRecords: true, modifyAllRecords: false }, + crm_campaign: { allowCreate: true, allowRead: true, allowEdit: true, allowDelete: false, viewAllRecords: true, modifyAllRecords: false }, + crm_case: { allowCreate: false, allowRead: true, allowEdit: false, allowDelete: false, viewAllRecords: true, modifyAllRecords: false, allowExport: true }, + crm_task: { allowCreate: true, allowRead: true, allowEdit: true, allowDelete: true, viewAllRecords: true, modifyAllRecords: true, allowTransfer: true }, + // A manager coaches on activity, so this is org-wide read AND write on a + // private object — the same shape their `crm_task` grant already has. + // `crm_event_attendee` is `controlled_by_parent` (ADR-0055): no scope to + // author — one would be inert metadata. It narrows to the events this set + // can read, which is every event: `viewAllRecords` on `crm_event` above puts + // the whole activity stack in reach, so the derived attendee rows follow. + // MEASURED on 17.0.0-rc.4 and pinned by `test/parent-derived-reach.test.ts`, + // master accessibility resolves through the same paths a direct read of the + // event takes — ownership and `sys_record_share` grants folded in, not the + // master's row-level security policies alone. Until 17.0.0-rc.3 this grant + // was org-wide in FACT rather than by derivation, whatever the event grants + // said (#694); objectstack-ai/objectstack#5386 fixed that upstream and it + // shipped in rc.4. Same note in `sales-rep.profile.ts`. + crm_event: { allowCreate: true, allowRead: true, allowEdit: true, allowDelete: true, viewAllRecords: true, modifyAllRecords: true, allowTransfer: true }, + crm_event_attendee: { allowCreate: true, allowRead: true, allowEdit: true, allowDelete: true, viewAllRecords: false, modifyAllRecords: false }, + // The forecast IS the manager's job: they read every rep's snapshot and + // adjust the committed number, so this is org-wide read AND write on a + // private object (#488 — the object had no grant at all). + crm_forecast: { allowCreate: true, allowRead: true, allowEdit: true, allowDelete: false, viewAllRecords: true, modifyAllRecords: true, allowTransfer: true }, + // Knowledge is service-authored; sales reads it (public_read OWD). + // Reads the KB and may rate it; cannot author articles (#601). + crm_article_feedback: { allowCreate: true, allowRead: true, allowEdit: true, allowDelete: false, viewAllRecords: true, modifyAllRecords: false }, + crm_knowledge_article: { allowCreate: false, allowRead: true, allowEdit: false, allowDelete: false, viewAllRecords: true, modifyAllRecords: false }, + // Enrollment is marketing's job; a manager only reads the membership rows + // behind campaign ROI. `crm_campaign_member` is `controlled_by_parent`, so + // no readScope/viewAllRecords applies (ADR-0055) — but the rows do not + // "follow the campaign": the derivation resolves the master set through the + // master's RLS policies only (none narrow a select on `crm_campaign`), so + // this is org-wide read on every member row. The practical delta is small + // here — `crm_campaign` is `public_read` and this set reads every campaign + // anyway — so the intended derivation would return the same rows. See + // `campaign_member.object.ts` and objectstack-ai/objectstack#5386 (#694). + crm_campaign_member: { allowCreate: false, allowRead: true, allowEdit: false, allowDelete: false, viewAllRecords: false, modifyAllRecords: false }, + // Line items: full CRUD so a manager can fix pricing on any rep's deal or + // quote. Both objects are `controlled_by_parent`, so there is no scope to + // author — but that derivation does not narrow these rows to the deals and + // quotes the manager can read. MEASURED (see the note in + // `sales-rep.profile.ts` and `test/parent-derived-reach.test.ts`): the master + // set comes from the master's RLS policies only, never from ownership or a + // share. This set authors one such policy — the private-deal filter on + // `crm_opportunity` below — and none on `crm_quote`, so quote lines are + // org-wide, and opportunity lines are bounded by that policy and nothing + // else (the guard test pins the quote chain; the opportunity side follows + // from the same measured mechanism). Upstream gap: + // objectstack-ai/objectstack#5386 (#694). + crm_opportunity_line_item: { allowCreate: true, allowRead: true, allowEdit: true, allowDelete: true, viewAllRecords: false, modifyAllRecords: false }, + crm_quote_line_item: { allowCreate: true, allowRead: true, allowEdit: true, allowDelete: true, viewAllRecords: false, modifyAllRecords: false }, + // The record Attachments panel, READ only: canonical note on `enable.files` + // in `src/sales/objects/index.ts` (#2029). Which attachments it lists + // derives from the parent record; upload and delete wait upstream. + sys_attachment: { allowCreate: false, allowRead: true, allowEdit: false, allowDelete: false, viewAllRecords: false, modifyAllRecords: false }, + // The record Discussion panel, comments and activity: canonical note on + // `enable.feeds` in `src/sales/objects/index.ts` (#2029). Which threads it + // reaches derives from the parent record; deleting a comment waits upstream. + sys_comment: { allowCreate: true, allowRead: true, allowEdit: true, allowDelete: false, viewAllRecords: false, modifyAllRecords: false }, + sys_activity: { allowCreate: false, allowRead: true, allowEdit: false, allowDelete: false, viewAllRecords: false, modifyAllRecords: false } + }, + fields: { + // Sensitive fields a manager must see in full. Authored explicitly rather + // than left absent: these are the fields other sets mask, and an unauthored + // grant reads as an oversight instead of a decision (#488). + "crm_opportunity.amount": { readable: true, editable: true }, + "crm_account.health_score": { readable: true, editable: true }, + "crm_quote.internal_notes": { readable: true, editable: true }, + // Case internal notes are the service team's working memory: a sales + // manager reads them for account context but never edits them. + "crm_case.internal_notes": { readable: true, editable: false } + }, + // ADR-0058: `crm_opportunity.is_private` is settable in the opportunity form + // (`opportunity.view.ts`) and, before this rule, was read by nothing — a + // checkbox that promised confidentiality and delivered none. Org-wide readers + // are exactly who it has to hold back, so the set that grants + // `viewAllRecords` on opportunities also carries the row filter that honours + // it. Compiles to `{ $or: [{ is_private: false }, { owner_id: }] }`. + // + // `owner_id`, not the app-authored `owner` lookup this used to name: #548 + // retired that field. The predicate now keys on the SAME column the OWD / + // sharing owner-match reads, so "its owner" means one thing app-wide. + rowLevelSecurity: [ + { + name: "opportunity_private_owner_only", + // A deal flagged Private is visible only to its owner, even to holders of + // org-wide opportunity read. (`rowLevelSecurity[].label` / `description` + // are display copy — the 17.7.0 liveness ledger marks both live: the + // permission editor draws them on the policy card. This policy authors + // neither, so its intent lives in this comment.) + object: "crm_opportunity", + operation: "select", + using: "is_private == false || owner_id == current_user.id" + } + ] +}; + +// src/sales/profiles/sales-rep.profile.ts +var SalesRepProfile = { + name: "sales_rep", + label: "Sales Representative", + // A rep's book of business is private by design (own records + whatever a + // sharing rule or team grant extends). The objects below carry an explicit + // `readScope: 'own'` so the intent is authored, not inferred — this both + // silences the `security-private-no-readscope` liveness warning and pins the + // behavior: without it, a private-OWD object with allowRead but no scope is + // an under-specified grant the engine reads as "own only" anyway. + // + // What widens that scope today is narrower than it sounds: the territory / + // account-team rules are authored on `crm_account` ONLY, and a sharing rule + // widens the object it names — not the records hanging off it. So a rep who + // receives an account through a territory rule reads that account, while the + // tasks on it stay own-only and opportunities widen only through the + // >= $100k leadership rules. Quotes and contracts are the exception since + // #549 (ruling 2026-08-31): both are `controlled_by_parent` under the + // account, so they arrive with it — the same derivation as contacts. + // + // The `controlled_by_parent` grants below read as narrow, and as of + // 17.0.0-rc.4 they ARE. MEASURED and pinned by + // `test/parent-derived-reach.test.ts`: the ADR-0055 derivation resolves master + // accessibility through the same paths a direct read of the master takes — + // owner scope AND `sys_record_share` grants, not the master's row-level + // security policies alone. A rep holding ONE account through a territory rule + // reads that account's contacts and no others, and reads line items only under + // the quotes they can reach. Writes derive the same way: a child of a master + // the rep cannot edit is refused. So each grant below is bounded by the + // parent's sharing, which is what it looks like. + // + // Until 17.0.0-rc.3 the same grants were org-wide reads and this note said so + // (#694): the derivation consulted master RLS policies only, and HotCRM + // authors none, so the master set was every record. + // objectstack-ai/objectstack#5386 fixed that upstream and it shipped in rc.4. + objects: { + // `allowExport` where an export surface exists — canonical note in + // `src/sales/profiles/index.ts`. Safe alongside `readScope: 'own'`: export is + // read-derived, so a rep's CSV carries their own book, not the org's. + crm_lead: { allowCreate: true, allowRead: true, allowEdit: true, allowDelete: false, viewAllRecords: false, modifyAllRecords: false, readScope: "own", allowExport: true }, + crm_account: { allowCreate: true, allowRead: true, allowEdit: true, allowDelete: false, viewAllRecords: false, modifyAllRecords: false, readScope: "own", allowExport: true }, + // NO readScope: `crm_contact` is `controlled_by_parent` (master-detail to + // crm_account), so a `readScope` here is inert — the sharing service only + // applies owner scope to `private` objects — and it read as a promise the + // engine never kept: it said "own contacts only" while access derived from + // the parent (#488). That derivation now delivers exactly "the accounts the + // rep can read": measured on 17.0.0-rc.4, a rep holding one territory + // account reads THAT account's contacts and no others (see the note at the + // top of this file, #694). + crm_contact: { allowCreate: true, allowRead: true, allowEdit: true, allowDelete: false, viewAllRecords: false, modifyAllRecords: false, allowExport: true }, + crm_opportunity: { allowCreate: true, allowRead: true, allowEdit: true, allowDelete: false, viewAllRecords: false, modifyAllRecords: false, readScope: "own", allowExport: true }, + // NO readScope on quote/contract either: both are `controlled_by_parent` + // under `crm_account` (#549), so a scope here would be inert. A rep reads + // the quotes and contracts of every account they can reach, edits the + // quotes of accounts they can edit, and never edits a contract (object + // gate). `test/parent-derived-reach.test.ts` measures both levels. + crm_quote: { allowCreate: true, allowRead: true, allowEdit: true, allowDelete: false, viewAllRecords: false, modifyAllRecords: false }, + crm_contract: { allowCreate: false, allowRead: true, allowEdit: false, allowDelete: false, viewAllRecords: false, modifyAllRecords: false }, + crm_product: { allowCreate: false, allowRead: true, allowEdit: false, allowDelete: false, viewAllRecords: true, modifyAllRecords: false }, + crm_campaign: { allowCreate: false, allowRead: true, allowEdit: false, allowDelete: false, viewAllRecords: true, modifyAllRecords: false }, + crm_case: { allowCreate: false, allowRead: true, allowEdit: false, allowDelete: false, viewAllRecords: false, modifyAllRecords: false, readScope: "own", allowExport: true }, + crm_task: { allowCreate: true, allowRead: true, allowEdit: true, allowDelete: true, viewAllRecords: false, modifyAllRecords: false, readScope: "own" }, + // ─── Activity (#592) ────────────────────────────────────────────── + // `crm_event` is `private` like `crm_task` — a personal activity record — + // so an explicit record scope is required alongside allowRead (an omitted + // scope silently means "own only" and reads as an unmade decision). + // `crm_event_attendee` is `controlled_by_parent`, so authoring a readScope + // here would be inert metadata the engine never applies. Its rows narrow to + // the events the rep can read — which, `crm_event` being private and + // own-scoped, is their own calendar (see the note at the top of this file, + // #694). + crm_event: { allowCreate: true, allowRead: true, allowEdit: true, allowDelete: true, viewAllRecords: false, modifyAllRecords: false, readScope: "own" }, + crm_event_attendee: { allowCreate: true, allowRead: true, allowEdit: true, allowDelete: true, viewAllRecords: false, modifyAllRecords: false }, + // Reference catalog (public_read OWD): reps read knowledge articles, which + // are authored by service. + // Reads the KB and may rate it; cannot author articles (#601). + crm_article_feedback: { allowCreate: true, allowRead: true, allowEdit: true, allowDelete: false, viewAllRecords: true, modifyAllRecords: false }, + crm_knowledge_article: { allowCreate: false, allowRead: true, allowEdit: false, allowDelete: false, viewAllRecords: true, modifyAllRecords: false }, + // Forecast snapshots are written by the nightly `forecast.hook` job and the + // `revenue_forecasting` skill, never by hand — read-only, and only the rep's + // own snapshots (private OWD + explicit own scope, as above). + crm_forecast: { allowCreate: false, allowRead: true, allowEdit: false, allowDelete: false, viewAllRecords: false, modifyAllRecords: false, readScope: "own" }, + // Product lines on deals and quotes. Both objects are + // `controlled_by_parent`, so there is no readScope to author — one would be + // inert metadata. That derivation scopes a rep to the lines under the deals + // and quotes they can reach: measured on 17.0.0-rc.4, a rep reads the lines + // of the one quote they own and none of the others (see the note at the top + // of this file, #694). Without these grants the opportunity "Products" + // related list and the whole CPQ path were denied for every non-admin user + // (#488). + crm_opportunity_line_item: { allowCreate: true, allowRead: true, allowEdit: true, allowDelete: true, viewAllRecords: false, modifyAllRecords: false }, + crm_quote_line_item: { allowCreate: true, allowRead: true, allowEdit: true, allowDelete: true, viewAllRecords: false, modifyAllRecords: false }, + // Which campaign sourced a lead — read-only context, derived from the + // campaign (controlled_by_parent). Enrollment belongs to marketing_user. + crm_campaign_member: { allowCreate: false, allowRead: true, allowEdit: false, allowDelete: false, viewAllRecords: false, modifyAllRecords: false }, + // The record Attachments panel, READ only: canonical note on `enable.files` + // in `src/sales/objects/index.ts` (#2029). Which attachments it lists + // derives from the parent record; upload and delete wait upstream. + sys_attachment: { allowCreate: false, allowRead: true, allowEdit: false, allowDelete: false, viewAllRecords: false, modifyAllRecords: false }, + // The record Discussion panel, comments and activity: canonical note on + // `enable.feeds` in `src/sales/objects/index.ts` (#2029). Which threads it + // reaches derives from the parent record; deleting a comment waits upstream. + sys_comment: { allowCreate: true, allowRead: true, allowEdit: true, allowDelete: false, viewAllRecords: false, modifyAllRecords: false }, + sys_activity: { allowCreate: false, allowRead: true, allowEdit: false, allowDelete: false, viewAllRecords: false, modifyAllRecords: false } + }, + fields: { + "crm_account.annual_revenue": { readable: true, editable: false }, + "crm_account.description": { readable: true, editable: true }, + "crm_opportunity.amount": { readable: true, editable: true }, + "crm_opportunity.probability": { readable: true, editable: true }, + // Health score drives the renewal book and the at-risk views: reps see it, + // the renewal/CS process sets it. Readable (the `at_risk_accounts` view + // filters and sorts on it, and a masked field cannot be filtered) but never + // rep-editable — it was previously unauthored on every set (#488). + "crm_account.health_score": { readable: true, editable: false }, + // Quote internal notes stay rep-editable: `quote.hook` deliberately keeps + // them writable after a quote is sent, when nothing else is. + "crm_quote.internal_notes": { readable: true, editable: true }, + // Case internal notes are the service team's private working notes. A rep + // reads the case (own scope) for account context; the agent-only commentary + // inside it is masked — no view filters or sorts on this field, so masking + // costs nothing but the value itself. + "crm_case.internal_notes": { readable: false, editable: false } + } +}; + +// src/sales/profiles/service-agent.profile.ts +var ServiceAgentProfile = { + name: "service_agent", + label: "Service Agent", + objects: { + // Reference context an agent needs to work ANY ticket — a customer's cases + // are meaningless without seeing the account/contact behind them, so these + // are org-visible reads (viewAllRecords: true), NOT own-only. This was the + // security-private-no-readscope warning's real signal: allowRead on a + // private object with no scope had silently locked agents out of every + // account they didn't personally own. + // `allowExport` where an export surface exists — canonical note in + // `src/sales/profiles/index.ts`. `crm_opportunity` carries no export bit: this + // set has no read on it at all, and the axis never widens read. + crm_lead: { allowCreate: false, allowRead: true, allowEdit: false, allowDelete: false, viewAllRecords: true, modifyAllRecords: false, allowExport: true }, + crm_account: { allowCreate: false, allowRead: true, allowEdit: false, allowDelete: false, viewAllRecords: true, modifyAllRecords: false, allowExport: true }, + crm_contact: { allowCreate: false, allowRead: true, allowEdit: true, allowDelete: false, viewAllRecords: true, modifyAllRecords: false, allowExport: true }, + crm_opportunity: { allowCreate: false, allowRead: false, allowEdit: false, allowDelete: false, viewAllRecords: false, modifyAllRecords: false }, + // Cases + tasks: an agent's own queue by default (readScope: 'own'). + // Cross-agent visibility exists for CASES only — the escalation rules widen + // open critical cases to service_manager / service_director. `crm_task` has + // no sharing rule at all, so an agent reading an account org-wide still + // sees only their own tasks on it (#549). + crm_case: { allowCreate: true, allowRead: true, allowEdit: true, allowDelete: false, viewAllRecords: false, modifyAllRecords: false, readScope: "own", allowExport: true }, + // `allowTransfer` on `crm_task` ONLY — canonical note in + // `src/sales/profiles/index.ts`. Narrow and load-bearing: escalating a case fires + // `case_status_side_effects`, which opens the follow-up task OWNED BY the + // account owner (`case.hook.ts`). That insert runs on `ctx.api` with the + // agent's own context, so planting it under another user is a transfer and + // is denied without this bit — the case update would fail with it. This is + // "assign work to a colleague", not "reassign the ticket": the agent holds + // no transfer grant on `crm_case` or any customer record. + // + // ⚠️ Escalation DOES now move a case to the `service_manager` pool (#1070), + // and it does so with no `crm_case` grant here — deliberately. That + // hand-off runs on the `beforeUpdate` seam, which the #3004 guard cannot + // see (measured, three readings, in `_case-assignment.ts`'s header and + // pinned in `test/case-assignment.test.ts`), so the case moves as part of + // the escalation write the automation is already performing rather than as + // an agent-initiated transfer. Doing it the other way — a `ctx.api` write + // from `afterUpdate` — WOULD need `crm_case.allowTransfer` here, which + // would let an agent reassign any case they can edit. That is a + // permission-model decision and is not being taken as a side effect of a + // hook: this line stays `crm_task` only. + crm_task: { allowCreate: true, allowRead: true, allowEdit: true, allowDelete: true, viewAllRecords: false, modifyAllRecords: false, readScope: "own", allowTransfer: true }, + // #592 — `log_call` / `log_meeting` are scoped to `crm_case` too, and an + // agent who cannot INSERT a `crm_event` gets a button that 403s. Same + // own-scoped shape as their tasks. + crm_event: { allowCreate: true, allowRead: true, allowEdit: true, allowDelete: true, viewAllRecords: false, modifyAllRecords: false, readScope: "own" }, + crm_event_attendee: { allowCreate: true, allowRead: true, allowEdit: true, allowDelete: true, viewAllRecords: false, modifyAllRecords: false }, + crm_product: { allowCreate: false, allowRead: true, allowEdit: false, allowDelete: false, viewAllRecords: true, modifyAllRecords: false }, + // The knowledge base is this team's own surface: agents draft and revise + // articles (draft → in_review → published is enforced by the KB flow, not by + // CRUD), and read every published article regardless of author. Archiving + // is destructive-by-policy, so deletion stays with admins. Before #488 the + // object had no grant at all — the "Knowledge" nav item was denied for + // everyone, including the agents it was built for. + // Agents rate the articles they use to close cases (#601). Create + edit + // their OWN row (`modifyAllRecords: false` keeps them off everyone else's + // vote); no delete — a withdrawn opinion is a changed verdict, not an + // erased one. + crm_article_feedback: { allowCreate: true, allowRead: true, allowEdit: true, allowDelete: false, viewAllRecords: true, modifyAllRecords: false }, + crm_knowledge_article: { allowCreate: true, allowRead: true, allowEdit: true, allowDelete: false, viewAllRecords: true, modifyAllRecords: false }, + // The record Attachments panel, READ only: canonical note on `enable.files` + // in `src/sales/objects/index.ts` (#2029). Which attachments it lists + // derives from the parent record; upload and delete wait upstream. + sys_attachment: { allowCreate: false, allowRead: true, allowEdit: false, allowDelete: false, viewAllRecords: false, modifyAllRecords: false }, + // The record Discussion panel, comments and activity: canonical note on + // `enable.feeds` in `src/sales/objects/index.ts` (#2029). Which threads it + // reaches derives from the parent record; deleting a comment waits upstream. + sys_comment: { allowCreate: true, allowRead: true, allowEdit: true, allowDelete: false, viewAllRecords: false, modifyAllRecords: false }, + sys_activity: { allowCreate: false, allowRead: true, allowEdit: false, allowDelete: false, viewAllRecords: false, modifyAllRecords: false } + }, + fields: { + "crm_case.is_sla_violated": { readable: true, editable: false }, + "crm_case.resolution_time_hours": { readable: true, editable: false }, + // Internal notes are the agent's working memory on a ticket — full access + // here, read-only for sales_manager, masked for sales_rep (#488). + "crm_case.internal_notes": { readable: true, editable: true }, + // Account health is renewal-team data an agent reads for context only. + "crm_account.health_score": { readable: true, editable: false } + } +}; +var ServiceManagerProfile = { + ...ServiceAgentProfile, + name: "service_manager", + label: "Service Manager" +}; + +// src/sales/profiles/system-admin.profile.ts +var SystemAdminProfile = { + name: "system_admin", + label: "System Administrator", + objects: { + // `allowTransfer` on every object — canonical note in `src/sales/profiles/index.ts`. + // The admin is the persona that reassigns ownership when someone leaves. + // `allowExport` on the five objects with an export surface — see the + // canonical note in `src/sales/profiles/index.ts`. It is authored even here: + // 17.0 gates export on the explicit bit, and `modifyAllRecords` does not + // stand in for it, so without these an admin cannot export either. + crm_lead: { allowCreate: true, allowRead: true, allowEdit: true, allowDelete: true, viewAllRecords: true, modifyAllRecords: true, allowTransfer: true, allowExport: true }, + crm_account: { allowCreate: true, allowRead: true, allowEdit: true, allowDelete: true, viewAllRecords: true, modifyAllRecords: true, allowTransfer: true, allowExport: true }, + crm_contact: { allowCreate: true, allowRead: true, allowEdit: true, allowDelete: true, viewAllRecords: true, modifyAllRecords: true, allowTransfer: true, allowExport: true }, + crm_opportunity: { allowCreate: true, allowRead: true, allowEdit: true, allowDelete: true, viewAllRecords: true, modifyAllRecords: true, allowTransfer: true, allowExport: true }, + crm_quote: { allowCreate: true, allowRead: true, allowEdit: true, allowDelete: true, viewAllRecords: true, modifyAllRecords: true, allowTransfer: true }, + crm_contract: { allowCreate: true, allowRead: true, allowEdit: true, allowDelete: true, viewAllRecords: true, modifyAllRecords: true, allowTransfer: true }, + crm_product: { allowCreate: true, allowRead: true, allowEdit: true, allowDelete: true, viewAllRecords: true, modifyAllRecords: true, allowTransfer: true }, + crm_campaign: { allowCreate: true, allowRead: true, allowEdit: true, allowDelete: true, viewAllRecords: true, modifyAllRecords: true, allowTransfer: true }, + crm_case: { allowCreate: true, allowRead: true, allowEdit: true, allowDelete: true, viewAllRecords: true, modifyAllRecords: true, allowTransfer: true, allowExport: true }, + crm_task: { allowCreate: true, allowRead: true, allowEdit: true, allowDelete: true, viewAllRecords: true, modifyAllRecords: true, allowTransfer: true }, + crm_event: { allowCreate: true, allowRead: true, allowEdit: true, allowDelete: true, viewAllRecords: true, modifyAllRecords: true, allowTransfer: true }, + crm_event_attendee: { allowCreate: true, allowRead: true, allowEdit: true, allowDelete: true, viewAllRecords: true, modifyAllRecords: true, allowTransfer: true }, + // The objects below shipped with navigation, views, hooks and seed data + // but no grant in ANY permission set (#488): "Knowledge" and "Forecasts" + // were permission-denied nav items for every user, admins included. + crm_forecast: { allowCreate: true, allowRead: true, allowEdit: true, allowDelete: true, viewAllRecords: true, modifyAllRecords: true, allowTransfer: true }, + crm_article_feedback: { allowCreate: true, allowRead: true, allowEdit: true, allowDelete: true, viewAllRecords: true, modifyAllRecords: true, allowTransfer: true }, + crm_knowledge_article: { allowCreate: true, allowRead: true, allowEdit: true, allowDelete: true, viewAllRecords: true, modifyAllRecords: true, allowTransfer: true }, + // Detail rows. Their RECORD-level access derives from the master + // (ADR-0055 `controlled_by_parent`), but object-level CRUD is a separate + // gate that is never derived — it has to be granted explicitly here. + crm_opportunity_line_item: { allowCreate: true, allowRead: true, allowEdit: true, allowDelete: true, viewAllRecords: true, modifyAllRecords: true, allowTransfer: true }, + crm_quote_line_item: { allowCreate: true, allowRead: true, allowEdit: true, allowDelete: true, viewAllRecords: true, modifyAllRecords: true, allowTransfer: true }, + crm_campaign_member: { allowCreate: true, allowRead: true, allowEdit: true, allowDelete: true, viewAllRecords: true, modifyAllRecords: true, allowTransfer: true }, + // The record Attachments panel, READ only: canonical note on `enable.files` + // in `src/sales/objects/index.ts` (#2029). Which attachments it lists + // derives from the parent record; upload and delete wait upstream. + sys_attachment: { allowCreate: false, allowRead: true, allowEdit: false, allowDelete: false, viewAllRecords: false, modifyAllRecords: false }, + // The record Discussion panel, comments and activity: canonical note on + // `enable.feeds` in `src/sales/objects/index.ts` (#2029). Which threads it + // reaches derives from the parent record; deleting a comment waits upstream. + sys_comment: { allowCreate: true, allowRead: true, allowEdit: true, allowDelete: false, viewAllRecords: false, modifyAllRecords: false }, + sys_activity: { allowCreate: false, allowRead: true, allowEdit: false, allowDelete: false, viewAllRecords: false, modifyAllRecords: false } + }, + systemPermissions: [ + "view_setup", + "manage_users", + "customize_application", + "view_all_data", + "modify_all_data", + "manage_profiles", + "manage_roles", + "manage_sharing" + ] +}; + +// src/sales/translations/index.ts +var translations_exports = {}; +__export(translations_exports, { + CrmTranslations: () => CrmTranslations +}); + +// src/sales/translations/en/app.ts +var appSurface = { + apps: { + crm_enterprise: { + label: "HotCRM", + description: "Customer relationship management for sales, service, and marketing", + navigation: { + group_activity: { label: "Activity" }, + group_sales: { label: "Sales" }, + group_service: { label: "Service" }, + group_marketing: { label: "Marketing" } + } + } + }, + messages: { + "common.save": "Save", + "common.cancel": "Cancel", + "common.delete": "Delete", + "common.edit": "Edit", + "common.create": "Create", + "common.search": "Search", + "common.filter": "Filter", + "common.export": "Export", + "common.back": "Back", + "common.confirm": "Confirm", + "nav.sales": "Sales", + "nav.service": "Service", + "nav.marketing": "Marketing", + "nav.products": "Products", + "nav.analytics": "Analytics", + "success.saved": "Record saved successfully", + "success.converted": "Lead converted successfully", + "confirm.delete": "Are you sure you want to delete this record?", + "confirm.convert_lead": "Convert this lead to account, contact, and opportunity?", + "error.required": "This field is required", + "error.load_failed": "Failed to load data" + }, + dashboards: { + sales_activity_dashboard: { + label: "Sales Activity", + description: "Who is talking to customers, how often, and which accounts have gone quiet", + widgets: { + interactions_held: { title: "Interactions Logged", description: "Calls and meetings that actually happened" }, + meetings_booked: { title: "Meetings Booked", description: "Meetings on the calendar that have not happened yet" }, + customer_minutes: { title: "Customer Minutes", description: "Total time spent in front of customers" }, + tasks_completed: { title: "Tasks Completed", description: "Follow-ups closed out \u2014 the other half of activity" }, + activity_by_rep: { title: "Activity by Rep", description: "Logged interactions per owner" }, + activity_by_week: { title: "Activity Volume by Week", description: "Interactions per week" }, + activity_mix: { title: "Activity Mix", description: "Calls vs meetings vs demos" }, + activity_by_record_type: { title: "Where the Activity Lands", description: "Which part of the funnel is getting attention" }, + deal_activity: { title: "Interactions on Deals", description: "Logged interactions linked to an opportunity" }, + open_deals_for_activity: { title: "Open Deals", description: "Opportunities still in play" }, + quiet_accounts_30: { title: "Quiet 30+ Days", description: "Active accounts with no logged interaction in a month" }, + quiet_accounts_60: { title: "Quiet 60+ Days", description: "Two months of silence \u2014 the at-risk threshold" }, + quiet_accounts_90: { title: "Quiet 90+ Days", description: "A quarter with no contact" } + } + }, + crm_overview_dashboard: { + label: "CRM Overview", + description: "Revenue metrics, pipeline analytics, and deal insights", + widgets: { + total_revenue: { title: "Total Revenue", description: "Closed-won revenue this period" }, + active_deals: { title: "Active Deals", description: "Open opportunities in the pipeline" }, + won_deals: { title: "Won Deals", description: "Closed-won deals this period" }, + avg_deal_size: { title: "Avg Deal Size", description: "Average value of closed-won deals" }, + revenue_trends: { title: "Revenue Trends", description: "Closed-won revenue over the last 12 months" }, + lead_source: { title: "Lead Source", description: "Pipeline value by acquisition channel" }, + pipeline_by_stage: { title: "Pipeline by Stage", description: "Open opportunity value at each sales stage" }, + top_products: { title: "Top Products", description: "Total list-price revenue by product category" }, + pipeline_by_owner: { title: "Pipeline by Owner", description: "Open pipeline value and deal count per sales rep" } + } + }, + executive_dashboard: { + label: "Executive Overview", + description: "High-level revenue, customer, and pipeline KPIs for leadership", + widgets: { + total_revenue_ytd: { title: "Total Revenue (YTD)", description: "Closed-won revenue this year" }, + total_accounts: { title: "Active Accounts", description: "Customers with at least one active relationship" }, + total_contacts: { title: "Total Contacts", description: "People in our address book" }, + open_leads: { title: "Open Leads", description: "Unconverted leads in the funnel" }, + revenue_trend: { title: "Revenue Trend", description: "Closed-won revenue over the last 12 months" }, + revenue_by_industry: { title: "Revenue by Industry", description: "YTD closed-won revenue split by customer industry" }, + pipeline_by_stage: { title: "Pipeline by Stage", description: "Open opportunity value at each sales stage" }, + new_accounts_by_month: { title: "New Accounts", description: "Account creation cadence \u2014 last 6 months" }, + accounts_by_industry: { title: "Accounts by Industry", description: "Total annual revenue and account count per industry" } + } + }, + sales_dashboard: { + label: "Sales Performance", + description: "Pipeline analytics, win rate trends, and rep performance", + widgets: { + total_pipeline_value: { title: "Total Pipeline", description: "Sum of open opportunity value" }, + closed_won_qtd: { title: "Closed Won (QTD)", description: "Revenue closed this quarter" }, + open_opportunities: { title: "Open Opportunities", description: "Active deals in flight" }, + avg_deal_size: { title: "Avg Deal Size", description: "Average value of closed-won deals this quarter" }, + pipeline_by_stage: { title: "Pipeline by Stage", description: "Open opportunity value at each sales stage" }, + monthly_revenue_trend: { title: "Monthly Revenue Trend", description: "Closed-won revenue, last 12 months" }, + pipeline_by_forecast_category: { title: "Pipeline by Forecast Category", description: "Open pipeline grouped by sales forecast category" }, + lead_source_breakdown: { title: "Lead Source", description: "Where our pipeline is coming from" }, + open_pipeline_by_owner: { title: "Open Pipeline by Owner", description: "In-flight pipeline value, deal count and avg win probability per rep" }, + quota_attainment_by_rep: { title: "Quota Attainment by Rep", description: "Current-quarter quota, closed revenue and attainment per rep, from forecast snapshots" }, + pipeline_stage_by_source: { title: "Pipeline by Stage \xD7 Lead Source", description: "Cross-tab of open opportunity amount by stage and source" }, + win_rate_12m: { title: "Win Rate (12M)", description: "Deals won as a share of all deals settled in the last 12 months" }, + won_deals_12m: { title: "Deals Won (12M)", description: "The numerator of the win rate" }, + lost_deals_12m: { title: "Deals Lost (12M)", description: "The other half of the win-rate denominator" }, + win_rate_by_owner: { title: "Win / Loss by Rep", description: "Deals won, deals lost and win rate per rep \u2014 last 12 months" }, + win_rate_by_lead_source: { title: "Win / Loss by Lead Source", description: "Which sources produce deals that actually close \u2014 last 12 months" }, + loss_reason_breakdown: { title: "Why We Lose", description: "Lost deals by reason \u2014 last 12 months" } + } + }, + service_dashboard: { + label: "Customer Service", + description: "Case load, SLA health, and resolution performance", + widgets: { + open_cases: { title: "Open Cases", description: "Cases that are not yet closed" }, + critical_cases: { title: "Critical Cases", description: "Open cases marked as critical priority" }, + avg_resolution_time: { title: "Avg Resolution Time", description: "Mean time to close, in hours" }, + sla_violations: { title: "SLA Violations", description: "Cases that breached their SLA" }, + cases_by_status: { title: "Cases by Status", description: "Workload distribution across the pipeline" }, + cases_by_priority: { title: "Cases by Priority", description: "Open case mix by urgency" }, + cases_by_origin: { title: "Cases by Origin", description: "Where our cases are coming from" }, + daily_case_volume: { title: "Daily Case Volume", description: "New cases created over the last 30 days" }, + sla_compliance_gauge: { title: "SLA Compliance", description: "Percent of cases resolved within SLA this period" }, + kb_deflection_rate: { title: "KB Deflection Rate", description: "Share of closed cases resolved with a knowledge article" }, + kb_resolved_cases: { title: "Resolved by KB", description: "Closed cases pointing at the article that resolved them" }, + closed_cases_total: { title: "Closed Cases", description: "The denominator behind the deflection rate" }, + top_resolving_articles: { title: "Top Resolving Articles", description: "Knowledge articles ranked by the closed cases they resolved" }, + my_open_cases_by_priority: { title: "My Open Cases by Priority", description: "Your open cases and their SLA-violation rate, broken down by priority" } + } + } + }, + pages: { + account_detail_page: { + label: "Account Detail", + description: "Slotted account record page \u2014 custom header + persistent discussion feed.", + // Required, though it equals the page source: a missing `title` falls + // back to `label`, and the header then read "Account Detail" instead of + // the account's name (#2042). + title: "{name}", + subtitle: "{industry} \xB7 {type}" + }, + account_workbench: { + label: "Account Workbench", + description: "Curated account list for the sales team: quick filters only, no view management." + }, + app_launcher_page: { + label: "App Launcher", + description: "Central hub for accessing all applications", + subtitle: "Select an app to get started", + components: { + app_search: { label: "Search Apps" }, + app_grid: { label: "Application Grid" } + } + }, + case_detail_page: { + label: "Case Detail", + description: "Service-agent case record: highlights, SLA path, details and activity timeline.", + title: "{case_number} \xB7 {subject}", + subtitle: "{crm_account}", + components: { + case_highlights: { label: "Key Information" }, + case_status_path: { label: "Case Status Path" } + } + }, + lead_detail_page: { + label: "Lead Detail", + description: "Comprehensive lead detail page with highlights, details, and related information", + title: "{first_name} {last_name}", + subtitle: "{company}", + components: { + lead_duplicate_alert_confirmed: { label: "Confirmed Duplicate Alert" }, + lead_duplicate_alert_suspected: { label: "Suspected Duplicate Alert" }, + lead_highlights: { label: "Key Information" }, + lead_path: { label: "Lead Status Path" }, + main_tabs: { label: "Lead Information Tabs" } + } + }, + opportunity_detail_page: { + label: "Opportunity Detail", + description: "Comprehensive opportunity detail page with path, highlights, details, and related lists", + title: "{name}", + subtitle: "{crm_account}", + components: { + opp_highlights: { label: "Key Information" }, + opp_stage_path: { label: "Opportunity Stage Path" } + } + }, + sales_home_page: { + label: "Sales Home", + description: "Sales team home page with key metrics and quick actions", + title: "Sales Dashboard", + subtitle: "Welcome back", + components: { + quick_create: { title: "Quick Create", label: "Quick Create" }, + key_metrics: { title: "Key Performance Indicators", label: "Key Metrics" }, + home_tabs: { label: "Home Tabs" }, + ai_briefing: { + title: "Ask the AI Assistant", + label: "Today with the AI Assistant" + }, + upcoming_events: { title: "Upcoming Events", label: "Upcoming Events" } + } + }, + utility_bar_page: { + label: "Utility Bar", + description: "Quick access utility bar with floating tools", + components: { + notifications_panel: { label: "Notifications" }, + quick_notes: { title: "Quick Notes", label: "Quick Notes" }, + quick_search: { label: "Quick Search" } + } + } + } +}; + +// src/sales/translations/en/_shared.ts +var activityActions = { + log_call: { + label: "Log a Call", + successMessage: "Call logged successfully!", + params: { + subject: { label: "Call Subject" }, + duration: { label: "Duration (minutes)" }, + attendee_contacts: { label: "Contact Attendees" }, + attendee_users: { label: "Internal Attendees" }, + notes: { label: "Call Notes" } + } + }, + log_meeting: { + label: "Log a Meeting", + successMessage: "Meeting logged successfully!", + params: { + subject: { label: "Meeting Subject" }, + duration: { label: "Duration (minutes)" }, + attendee_contacts: { label: "Contact Attendees" }, + attendee_users: { label: "Internal Attendees" }, + notes: { label: "Meeting Notes" } + } + }, + schedule_meeting: { + label: "Schedule a Meeting", + successMessage: "Meeting scheduled!", + params: { + subject: { label: "Meeting Subject" }, + start_date: { label: "Start Date (UTC)" }, + start_time: { label: "Start Time (UTC)" }, + location: { label: "Location" }, + duration: { label: "Duration (minutes)" }, + attendee_contacts: { label: "Contact Attendees" }, + attendee_users: { label: "Internal Attendees" }, + notes: { label: "Agenda" } + } + } +}; + +// src/sales/translations/en/objects.customer.ts +var customer = { + crm_account: { + label: "Account", + pluralLabel: "Accounts", + fields: { + account_number: { label: "Account Number" }, + registration_number: { + label: "Registration Number", + help: "The counterparty's registered identity as issued by its own government registry. Not the Account Number, which we issue." + }, + commercial_capability: { + label: "Commercial Capability", + help: "Whether new business may be opened against this account. Settlement Only accounts stay usable for billing and payment, but no new opportunity may be linked to them.", + options: { full: "Full", settlement_only: "Settlement Only" } + }, + incumbent_vendor: { label: "Incumbent Vendor", help: "The supplier currently holding this account for the spend we are chasing." }, + annual_purchasing_budget: { label: "Annual Purchasing Budget", help: "What this account expects to spend with vendors this year \u2014 not its own revenue." }, + payment_cycle: { + label: "Payment Cycle", + options: { prepaid: "Prepaid", net_30: "Net 30", net_60: "Net 60", net_90: "Net 90" } + }, + approval_status: { + label: "Approval Status", + help: "Where this account stands in its sign-off. A new account starts Pending and is decided in the approval inbox.", + options: { pending: "Pending", approved: "Approved", rejected: "Rejected" } + }, + name: { label: "Account Name", help: "Legal name of the company or organization" }, + type: { + label: "Type", + options: { prospect: "Prospect", customer: "Customer", partner: "Partner", former: "Former Customer" } + }, + industry: { + label: "Industry", + options: { + technology: "Technology", + software: "Software / SaaS", + finance: "Finance", + healthcare: "Healthcare", + retail: "Retail", + manufacturing: "Manufacturing", + education: "Education", + real_estate: "Real Estate", + media: "Media & Entertainment", + logistics: "Logistics", + hospitality: "Hospitality", + energy: "Energy & Utilities", + government: "Government", + nonprofit: "Non-profit", + other: "Other" + } + }, + annual_revenue: { label: "Annual Revenue" }, + child_account_revenue: { label: "Child Account Revenue", help: "Sum of the annual revenue of the direct children of this account." }, + number_of_employees: { label: "Number of Employees" }, + phone: { label: "Phone" }, + website: { label: "Website" }, + billing_address: { label: "Billing Address" }, + billing_country: { + label: "Billing Country", + help: "Derived from Billing Address \u2014 the country exactly as entered, trimmed and upper-cased." + }, + territory: { + label: "Territory", + help: "Derived from Billing Address \u2014 the sales territory the sharing rules match on. Accounts outside the staffed territories are Other.", + options: { na: "North America", emea: "EMEA", other: "Other" } + }, + office_location: { label: "Office Location" }, + owner_id: { label: "Account Owner" }, + parent_account: { label: "Parent Account", help: "Parent company in hierarchy" }, + description: { label: "Description" }, + is_active: { label: "Active" }, + last_activity_date: { label: "Last Activity Date" }, + brand_color: { label: "Brand Color" }, + logo: { label: "Company Logo" }, + tier: { + label: "Customer Tier", + options: { strategic: "Strategic", enterprise: "Enterprise", mid_market: "Mid-Market", smb: "SMB" } + }, + segment: { + label: "Segment", + options: { net_new: "Net New", growth: "Growth", at_risk: "At Risk", stable: "Stable" } + }, + health_score: { + label: "Health Score", + help: "CSM-maintained health indicator", + options: { healthy: "Healthy", watching: "Watching", at_risk: "At Risk", churning: "Churning" } + }, + name_normalized: { + label: "Account Name (Normalized)", + help: "Match key for lead conversion: Account Name lower-cased, trimmed, with internal whitespace collapsed. Maintained by the account_protection hook \u2014 never edit directly." + }, + display_title: { label: "Display Title" } + }, + _views: { + all_accounts: { label: "All Accounts", description: "Primary account list with revenue & industry summaries" }, + account_gallery: { label: "Account Cards", description: "Branded account cards with brand-color highlights" }, + account_map: { label: "Accounts by Location", description: "Geospatial distribution of accounts" }, + enterprise_accounts: { label: "Enterprise Accounts", description: "Accounts with the highest annual revenue" }, + my_accounts: { label: "My Accounts", description: "Accounts owned by the current user" }, + at_risk_accounts: { label: "\u26A0\uFE0F At-Risk Accounts" } + }, + _sections: { + basic: { label: "Basic Information" }, + financials: { label: "Financials" }, + business_profile: { label: "Business Profile" }, + contact_info: { label: "Contact Information" }, + ownership: { label: "Ownership & Status" }, + branding: { label: "Branding" }, + system: { label: "System" }, + // Form section names on account.view.ts (#1100) + profile: { label: "Profile" }, + customer_success: { label: "Customer Success" }, + locations: { label: "Locations" }, + description: { label: "Description" } + }, + _actions: { ...activityActions } + }, + crm_contact: { + label: "Contact", + pluralLabel: "Contacts", + fields: { + salutation: { + label: "Salutation", + options: { mr: "Mr.", ms: "Ms.", mrs: "Mrs.", dr: "Dr.", prof: "Prof." } + }, + first_name: { label: "First Name" }, + last_name: { label: "Last Name" }, + full_name: { label: "Full Name" }, + crm_account: { label: "Account" }, + email: { label: "Email" }, + phone: { label: "Phone" }, + mobile: { label: "Mobile" }, + title: { label: "Title" }, + department: { + label: "Department", + options: { + executive: "Executive", + sales: "Sales", + marketing: "Marketing", + engineering: "Engineering", + support: "Support", + finance: "Finance", + hr: "Human Resources", + operations: "Operations" + } + }, + // Buying centre (REQ-0004) — the decision map. English is the source + // wording for the option VALUES; every other pack translates these. + buying_function: { + label: "Buying Function", + options: { + decision_maker: "Decision Maker", + economic_buyer: "Economic Buyer", + technical_evaluator: "Technical Evaluator", + user: "User", + influencer: "Influencer", + gatekeeper: "Gatekeeper" + } + }, + attitude: { + label: "Attitude to Us", + options: { + champion: "Champion", + supportive: "Supportive", + neutral: "Neutral", + skeptical: "Skeptical", + blocker: "Blocker" + } + }, + relationship_strength: { + label: "Relationship Strength", + options: { + distant: "Distant", + acquaintance: "Acquaintance", + working: "Working Relationship", + strong: "Strong", + trusted_advisor: "Trusted Advisor" + } + }, + owner_id: { label: "Contact Owner" }, + description: { label: "Description" }, + is_primary: { label: "Primary Contact", help: "Is this the main contact for the account?" }, + avatar: { label: "Profile Picture" }, + mailing_address: { label: "Mailing Address" }, + lead_source: { + label: "Lead Source", + options: { + web: "Web", + referral: "Referral", + event: "Event / Trade Show", + webinar: "Webinar", + partner: "Partner", + advertisement: "Advertisement", + paid_search: "Paid Search", + social: "Social Media", + content: "Content / Blog", + cold_call: "Cold Call", + email_campaign: "Email Campaign", + other: "Other" + } + }, + do_not_call: { label: "Do Not Call" }, + email_opt_out: { label: "Email Opt Out" }, + last_contacted_date: { label: "Last Contacted" } + }, + _views: { + all_contacts: { label: "All Contacts" }, + contact_directory: { label: "People Directory" }, + primary_contacts: { label: "Primary Contacts" } + }, + _sections: { + identity: { label: "Identity" }, + account_info: { label: "Account & Title" }, + buying_centre: { label: "Buying Centre" }, + contact_info: { label: "Contact Information" }, + mailing_address: { label: "Mailing Address" }, + additional: { label: "Additional Info" }, + preferences: { label: "Communication Preferences" }, + // Form section names on contact.view.ts (#1100). `contact_details` / + // `comm_preferences`, not `contact_info` / `preferences` — those are + // already fieldGroup keys with their own (longer) wording above. + contact_details: { label: "Contact Info" }, + comm_preferences: { label: "Preferences" } + }, + _actions: { + ...activityActions, + mark_primary: { + label: "Mark as Primary Contact", + confirmText: "Mark this contact as the primary contact for the account?", + successMessage: "Contact marked as primary!" + }, + send_email: { + label: "Send Email", + params: { + subject: { label: "Subject" }, + body: { label: "Body" } + } + }, + add_contact_to_campaign: { + label: "Add to Campaign", + successMessage: "Contacts added to campaign!", + params: { + crm_campaign: { label: "Campaign" } + } + } + } + } +}; + +// src/sales/translations/en/objects.pipeline.ts +var pipeline = { + crm_lead: { + label: "Lead", + pluralLabel: "Leads", + fields: { + first_name: { label: "First Name" }, + last_name: { label: "Last Name" }, + company: { label: "Company" }, + title: { label: "Title" }, + email: { label: "Email" }, + phone: { label: "Phone" }, + status: { + label: "Status", + options: { + new: "New", + contacted: "Contacted", + qualified: "Qualified", + unqualified: "Unqualified", + converted: "Converted" + } + }, + lead_source: { + label: "Lead Source", + options: { + web: "Web", + referral: "Referral", + event: "Event / Trade Show", + webinar: "Webinar", + partner: "Partner", + advertisement: "Advertisement", + paid_search: "Paid Search", + social: "Social Media", + content: "Content / Blog", + cold_call: "Cold Call", + email_campaign: "Email Campaign", + other: "Other" + } + }, + owner_id: { label: "Lead Owner" }, + is_converted: { label: "Converted" }, + description: { label: "Description" }, + salutation: { + label: "Salutation", + options: { mr: "Mr.", ms: "Ms.", mrs: "Mrs.", dr: "Dr.", prof: "Prof." } + }, + full_name: { label: "Full Name" }, + industry: { + label: "Industry", + options: { + technology: "Technology", + software: "Software / SaaS", + finance: "Finance", + healthcare: "Healthcare", + retail: "Retail", + manufacturing: "Manufacturing", + education: "Education", + real_estate: "Real Estate", + media: "Media & Entertainment", + logistics: "Logistics", + hospitality: "Hospitality", + energy: "Energy & Utilities", + government: "Government", + nonprofit: "Non-profit", + other: "Other" + } + }, + mobile: { label: "Mobile" }, + website: { label: "Website" }, + rating: { label: "Lead Score", help: "Lead quality score (1-5 stars)" }, + converted_account: { label: "Converted Account" }, + converted_contact: { label: "Converted Contact" }, + converted_opportunity: { label: "Converted Opportunity" }, + converted_date: { label: "Converted Date" }, + address: { label: "Address" }, + annual_revenue: { label: "Annual Revenue" }, + number_of_employees: { label: "Number of Employees" }, + notes: { label: "Notes", help: "Working notes on this lead \u2014 supports formatting." }, + do_not_call: { label: "Do Not Call" }, + email_opt_out: { label: "Email Opt Out" }, + disqualification_reason: { + label: "Disqualification Reason", + help: "Required when status is Unqualified", + options: { + not_a_fit: "Not a Fit", + no_budget: "No Budget", + wrong_persona: "Wrong Persona", + unreachable: "Unreachable", + duplicate: "Duplicate", + competitor: "Competitor", + other: "Other" + } + }, + duplicate_of_type: { + label: "Duplicate Of", + help: "Which object holds the surviving record this lead repeats.", + // `erased` is a tombstone, not a choice: the form does not offer it + // (see `src/sales/views/lead.view.ts`), but a lead whose survivor was + // deleted carries it, so it needs a label wherever the record is + // READ — detail page, list column, export. Untranslated it would + // render as the raw `erased`. + options: { crm_lead: "Lead", crm_contact: "Contact", erased: "Erased Record" } + }, + duplicate_of_lead: { label: "Duplicate Of Lead" }, + duplicate_of_contact: { label: "Duplicate Of Contact" }, + duplicate_status: { + label: "Duplicate Status", + help: "Suspected = flagged automatically at intake. Confirmed = a human verified the match.", + options: { suspected: "Suspected", confirmed: "Confirmed" } + }, + display_title: { label: "Display Title" }, + company_normalized: { + label: "Company (Normalized)", + help: "Match key for lead conversion: Company lower-cased, trimmed, with internal whitespace collapsed. Maintained by the lead_duplicate_check hook \u2014 never edit directly." + }, + next_followup_date: { label: "Next Follow-up Date" }, + last_contacted_date: { label: "Last Contacted" }, + need_type: { + label: "Need Type", + help: "What this prospect is asking for. Routing, prioritisation and demand reporting read this.", + options: { + new_implementation: "New Implementation", + expansion: "Expansion", + replacement: "Replacement", + renewal: "Renewal", + consulting: "Consulting", + support: "Support & Maintenance", + other: "Other" + } + }, + estimated_amount: { + label: "Estimated Amount", + help: "Estimated value of this demand, before qualification. Prefills the deal amount at conversion." + }, + conversion_approval_status: { + label: "Conversion Approval", + help: "Whether this lead has been signed off for conversion. Not Required means no approval is asked for \u2014 the shipped default.", + options: { + not_required: "Not Required", + pending: "Pending", + approved: "Approved", + rejected: "Rejected" + } + } + }, + _views: { + all_leads: { + label: "All Leads", + emptyState: { title: "No Leads Yet", message: "Get started by creating your first lead" } + }, + kanban_by_status: { label: "Lead Pipeline" }, + calendar_by_created: { label: "Lead Calendar" }, + gallery_view: { label: "Lead Cards" }, + my_leads: { label: "My Leads" }, + high_priority: { label: "High Priority" }, + hot_leads: { label: "\u{1F525} Hot Leads" }, + suspected_duplicates: { + label: "Suspected Duplicates", + emptyState: { + title: "No Suspected Duplicates", + message: "Nothing to review \u2014 every re-captured email has been checked." + } + } + }, + _sections: { + identity: { label: "Identity" }, + company_info: { label: "Company Information" }, + contact_info: { label: "Contact Information" }, + qualification: { label: "Qualification" }, + assignment: { label: "Assignment" }, + address: { label: "Address" }, + additional: { label: "Additional Info" }, + preferences: { label: "Communication Preferences" }, + conversion: { label: "Conversion" }, + duplicates: { label: "Duplicate Management" }, + // The detail page's sections reference the groups above (#806), so it + // has no section names of its own. + // Form section names on lead.view.ts (#1100). The sections of the + // default form and of every named formView live here — add a form + // there, add its section names here. `address` / `qualification` above + // are reused (identical fieldGroup wording); every other name here is new. + contact_information: { label: "Contact Information" }, + lead_classification: { label: "Lead Classification" }, + company_information: { label: "Company Information" }, + additional_information: { label: "Additional Information" }, + privacy: { label: "Privacy" }, + general: { label: "General" }, + details: { label: "Details" }, + step_1_contact_details: { label: "Step 1: Contact Details" }, + step_2_company_information: { label: "Step 2: Company Information" }, + step_3_qualification: { label: "Step 3: Qualification" }, + step_4_review_and_convert: { label: "Step 4: Review & Convert" }, + primary_information: { label: "Primary Information" }, + extended_details: { label: "Extended Details" }, + quick_edit: { label: "Quick Edit" }, + update_lead_status: { label: "Update Lead Status" }, + tell_us_about_yourself: { label: "Tell us about yourself" }, + about_your_company: { label: "About your company" }, + how_can_we_help: { label: "How can we help?" }, + lead_information: { label: "Lead Information" }, + address_information: { label: "Address Information" }, + privacy_preferences: { label: "Privacy Preferences" } + }, + _actions: { + ...activityActions, + convert_lead: { + label: "Convert Lead", + successMessage: "Lead converted successfully!" + }, + create_campaign: { + label: "Add to Campaign", + successMessage: "Leads added to campaign!", + params: { + crm_campaign: { label: "Campaign" } + } + }, + schedule_followup: { + label: "Schedule Follow-up", + successMessage: "Follow-up scheduled." + } + } + }, + crm_opportunity: { + label: "Opportunity", + pluralLabel: "Opportunities", + fields: { + name: { label: "Opportunity Name" }, + crm_account: { label: "Account" }, + primary_contact: { label: "Primary Contact" }, + owner_id: { label: "Opportunity Owner" }, + amount: { label: "Amount" }, + expected_revenue: { label: "Expected Revenue" }, + stage: { + label: "Stage", + options: { + prospecting: "Prospecting", + qualification: "Qualification", + needs_analysis: "Needs Analysis", + proposal: "Proposal", + negotiation: "Negotiation", + closed_won: "Closed Won", + closed_lost: "Closed Lost" + } + }, + probability: { label: "Probability (%)" }, + close_date: { label: "Close Date" }, + type: { + label: "Type", + options: { + new_business: "New Business", + existing_upgrade: "Existing Customer - Upgrade", + existing_renewal: "Existing Customer - Renewal", + existing_expansion: "Existing Customer - Expansion" + } + }, + forecast_category: { + label: "Forecast Category", + options: { + pipeline: "Pipeline", + best_case: "Best Case", + commit: "Commit", + omitted: "Omitted", + closed: "Closed" + } + }, + description: { label: "Description" }, + next_step: { label: "Next Step" }, + lead_source: { + label: "Lead Source", + options: { + web: "Web", + referral: "Referral", + event: "Event / Trade Show", + webinar: "Webinar", + partner: "Partner", + advertisement: "Advertisement", + paid_search: "Paid Search", + social: "Social Media", + content: "Content / Blog", + cold_call: "Cold Call", + email_campaign: "Email Campaign", + other: "Other" + } + }, + crm_campaign: { label: "Campaign", help: "Marketing campaign that generated this opportunity" }, + days_in_stage: { label: "Days in Current Stage" }, + stage_entry_date: { + label: "Stage Entry Date", + help: "Date this opportunity entered its current stage." + }, + is_private: { label: "Private" }, + approval_status: { + label: "Approval Status", + options: { not_required: "Not Required", pending: "Pending", approved: "Approved", rejected: "Rejected" } + }, + approved_date: { label: "Approved Date" }, + win_reason: { + label: "Win Reason", + help: "Why this deal was won. Required to close an opportunity as Won.", + options: { + better_product: "Better Product", + better_price: "Better Price", + relationship: "Existing Relationship", + better_support: "Better Support", + best_fit: "Best Fit / Features", + quote_accepted: "Quote Accepted", + other: "Other" + } + }, + loss_reason: { + label: "Loss Reason", + help: "Why this deal was lost. Required to close an opportunity as Lost.", + options: { + price: "Price Too High", + competitor: "Lost to Competitor", + no_budget: "No Budget", + no_decision: "No Decision", + timing: "Bad Timing", + features: "Missing Features", + other: "Other" + } + }, + loss_details: { + label: "Loss/Win Details", + help: "Free-text context behind the win or loss reason." + }, + // REQ-0006 — qualification, the customer's procurement calendar, the + // deal narrative, the business line and the status-change gate. + will_bid: { + label: "Will Bid", + help: "Whether we intend to bid. Unset means the decision is open." + }, + controllability: { label: "Controllability", options: { high: "High", medium: "Medium", low: "Low" } }, + priority: { label: "Priority", options: { high: "High", medium: "Medium", low: "Low" } }, + deal_level: { label: "Deal Level", options: { strategic: "Strategic", key: "Key", standard: "Standard" } }, + is_subcontracted: { label: "Involves Subcontracting" }, + subcontracting_note: { label: "Subcontracting Note" }, + customer_initiation_date: { label: "Customer Initiation Date" }, + expected_tender_date: { label: "Expected Tender Date" }, + expected_signing_date: { label: "Expected Signing Date" }, + expected_tender_amount: { label: "Expected Tender Amount" }, + expected_signing_amount: { label: "Expected Signing Amount" }, + business_line: { + label: "Business Line", + options: { + product: "Product", + services: "Professional Services", + consulting: "Consulting", + support: "Support & Maintenance", + other: "Other" + } + }, + customer_background: { label: "Customer Background" }, + project_background: { label: "Project Background" }, + risk_analysis: { label: "Risk Analysis" }, + payment_terms: { label: "Payment Terms" }, + requested_status: { label: "Requested Status", options: { closed_won: "Won", closed_lost: "Lost" } }, + status_change_approval_status: { + label: "Status Change Approval", + options: { not_required: "Not Required", pending: "Pending", approved: "Approved", rejected: "Rejected" } + }, + // REQ-0006 step 11 — the 立项 (qualification) approval gate. + qualification_requested: { + label: "Request Qualification Approval", + help: "Tick to send this deal for qualification approval. A rejection clears it; tick it again to ask again." + }, + qualification_approval_status: { + label: "Qualification Approval", + options: { not_required: "Not Required", pending: "Pending", approved: "Approved", rejected: "Rejected" } + } + }, + _views: { + tender_this_quarter: { + label: "Tender This Quarter", + emptyState: { + title: "No Tenders Expected This Quarter", + message: "This tab lists open deals whose customer-side tender date falls inside the current quarter. Record Expected Tender Date on a deal to see it here." + } + }, + open_opportunities: { label: "Open Deals" }, + all_opportunities: { label: "All Opportunities" }, + pipeline_kanban: { label: "Sales Pipeline" }, + close_date_calendar: { label: "Forecast Calendar" }, + deal_timeline: { label: "Deal Timeline" }, + deal_gallery: { label: "Deal Cards" }, + my_open_deals: { label: "My Open Deals" }, + stale_opportunities: { label: "\u26A0\uFE0F Stale Opportunities \xB7 Longest in Stage First" }, + closing_this_quarter: { + label: "Closing This Quarter", + emptyState: { + title: "No Deals Closing This Quarter", + message: "This tab lists open commit and best-case deals with a close date inside the current quarter. Nothing matches right now \u2014 deals closing later are on the Open Deals tab." + } + } + }, + _sections: { + basic: { label: "Basic Information" }, + financials: { label: "Financials" }, + sales_process: { label: "Sales Process" }, + classification: { label: "Classification" }, + campaign: { label: "Campaigns" }, + notes: { label: "Notes & Next Steps" }, + qualification: { label: "Qualification" }, + narrative: { label: "Deal Narrative" }, + crm_forecast: { label: "Forecast & Metrics" }, + // The detail page's sections reference the groups above (#1452), so it + // has no section names of its own. + // Form section names on opportunity.view.ts (#1100) + overview: { label: "Overview" }, + forecast: { label: "Forecast" }, + sales_strategy: { label: "Sales Strategy" }, + win_loss: { label: "Win / Loss" } + }, + _actions: { + ...activityActions, + clone_opportunity: { + label: "Clone Opportunity", + successMessage: "Opportunity cloned successfully!" + }, + mass_update_stage: { + label: "Update Stage", + successMessage: "Opportunities updated successfully!", + params: { + stage: { label: "New Stage" } + } + }, + generate_quote: { + label: "Generate Quote", + successMessage: "Quote created from opportunity!" + } + } + }, + crm_opportunity_line_item: { + label: "Opportunity Line Item", + pluralLabel: "Opportunity Line Items", + description: "Per-product pricing lines under an opportunity", + fields: { + crm_opportunity: { label: "Opportunity" }, + crm_product: { label: "Product" }, + description: { label: "Description" }, + quantity: { label: "Quantity" }, + list_price: { label: "List Price", help: "Auto-populated from the product's List Price." }, + unit_price: { + label: "Sales Price", + help: "Negotiated unit price (may differ from list price)" + }, + discount: { label: "Discount %" }, + total_price: { label: "Total" }, + line_number: { label: "Line #" } + }, + _sections: { + basic: { label: "Line Item" }, + pricing: { label: "Pricing" } + } + }, + crm_forecast: { + label: "Forecast", + pluralLabel: "Forecasts", + description: "Periodic pipeline snapshot by owner used for revenue forecasting", + fields: { + owner_id: { label: "Owner" }, + period: { label: "Period", options: { month: "Month", quarter: "Quarter" } }, + period_start: { + label: "Period Start", + help: "Must be the first day of the period \u2014 e.g. 2026-08-01 for Aug 2026. A quarterly forecast must additionally start on a quarter boundary: January 1, April 1, July 1 or October 1." + }, + period_end: { + label: "Period End", + help: "Normally derived automatically from Period and Period Start. If set by hand, it must be the last day of that period \u2014 e.g. 2026-09-30 for a quarter starting 2026-07-01, or 2026-08-31 for Aug 2026." + }, + period_label: { label: "Period", help: 'Human-friendly label, e.g. "Q3 2026" or "Aug 2026".' }, + snapshot_date: { label: "Snapshot Date", help: "The day this snapshot was captured." }, + source: { + label: "Source", + options: { scheduled: "Scheduled snapshot", ai: "AI skill", manual: "Manual entry" } + }, + quota: { label: "Quota" }, + pipeline_amount: { + label: "Pipeline", + help: "Sum of all open opportunities closing in this period (any stage)." + }, + best_case_amount: { + label: "Best Case", + help: "Open opportunities in the Best Case or Commit forecast category." + }, + commit_amount: { + label: "Commit", + help: "Open opportunities in the Commit forecast category (owner-committed)." + }, + closed_amount: { label: "Closed Won", help: "Already-closed-won amount in this period." }, + expected_amount: { + label: "Expected", + help: "Closed Won + Commit \u2014 what the owner reasonably expects to land." + }, + attainment_pct: { label: "Attainment %", help: "Closed Won \xF7 Quota \xD7 100. Reads 0% until a positive quota is set." }, + coverage_ratio: { + label: "Coverage", + help: "Pipeline \xF7 (Quota \u2212 Closed Won) \u2014 whether enough pipeline remains to cover the gap. Reads 0 once the quota is already met." + }, + notes: { label: "Notes" }, + display_title: { label: "Display Title" }, + seed_key: { + label: "Seed Key", + help: "Demo-fixture identity. Written only by the seed loader; empty on every real snapshot." + } + }, + _views: { + all_forecasts: { label: "All Forecasts" }, + this_quarter_forecasts: { + label: "This Quarter", + emptyState: { + title: "This Quarter Has No Snapshots Yet", + message: "Quarterly snapshots are written by the nightly forecast sweep. Until it has run once for the current quarter this view is empty \u2014 settled quarters are on the All tab." + } + }, + my_forecast: { label: "My Forecast" } + }, + _sections: { + basic: { label: "Snapshot" }, + amounts: { label: "Amounts" }, + meta: { label: "Source" }, + // Form section names on forecast.view.ts (#1100). `basic`'s label + // matches "Snapshot" but its key does not, so this form section + // needs its own entry; `notes` has no fieldGroup counterpart at all. + snapshot: { label: "Snapshot" }, + notes: { label: "Notes" } + } + } +}; + +// src/sales/translations/en/objects.commerce.ts +var commerce = { + crm_quote: { + label: "Quote", + pluralLabel: "Quotes", + fields: { + quote_number: { label: "Quote Number" }, + name: { label: "Quote Name" }, + crm_account: { label: "Account" }, + crm_contact: { + label: "Contact", + help: "Required once the quote is Presented or Accepted \u2014 the drafted contract takes its Primary Contact from here." + }, + crm_opportunity: { label: "Opportunity" }, + owner_id: { label: "Quote Owner" }, + status: { + label: "Status", + options: { + draft: "Draft", + in_review: "In Review", + presented: "Presented", + accepted: "Accepted", + rejected: "Rejected", + expired: "Expired" + } + }, + quote_date: { label: "Quote Date" }, + expiration_date: { label: "Expiration Date" }, + subtotal: { label: "Subtotal" }, + discount: { label: "Discount %" }, + discount_amount: { label: "Discount Amount" }, + tax: { label: "Tax" }, + shipping_handling: { label: "Shipping & Handling" }, + total_price: { label: "Total Price" }, + payment_terms: { + label: "Payment Terms", + options: { + net_15: "Net 15", + net_30: "Net 30", + net_60: "Net 60", + net_90: "Net 90", + due_on_receipt: "Due on Receipt" + } + }, + shipping_terms: { label: "Shipping Terms" }, + billing_address: { label: "Billing Address" }, + shipping_address: { label: "Shipping Address" }, + description: { label: "Description" }, + internal_notes: { label: "Internal Notes" }, + display_title: { label: "Display Title" } + }, + _views: { + all_quotes: { label: "All Quotes" }, + quote_pipeline: { label: "Quote Pipeline" }, + quote_calendar: { label: "Quote Calendar" } + }, + _sections: { + basic: { label: "Quote Information" }, + pricing: { label: "Pricing" }, + terms: { label: "Terms & Validity" }, + address: { label: "Addresses" }, + system: { label: "System" }, + // Form section names on quote.view.ts (#1100). `quote_terms`, not + // `terms` — `terms` is already the fieldGroup key for "Terms & Validity". + quote: { label: "Quote" }, + totals: { label: "Totals" }, + quote_terms: { label: "Terms" }, + addresses_and_notes: { label: "Addresses & Notes" } + } + }, + crm_quote_line_item: { + label: "Quote Line Item", + pluralLabel: "Quote Line Items", + description: "Per-product pricing lines under a quote", + fields: { + crm_quote: { label: "Quote" }, + crm_product: { label: "Product" }, + description: { label: "Description" }, + quantity: { label: "Quantity" }, + list_price: { label: "List Price" }, + unit_price: { label: "Sales Price" }, + discount: { label: "Discount %" }, + subtotal: { label: "Subtotal" }, + total_price: { label: "Total" }, + line_number: { label: "Line #" } + }, + _sections: { + basic: { label: "Line Item" }, + pricing: { label: "Pricing" } + } + }, + crm_contract: { + label: "Contract", + pluralLabel: "Contracts", + fields: { + contract_number: { label: "Contract Number" }, + crm_account: { label: "Account" }, + crm_contact: { label: "Primary Contact" }, + crm_opportunity: { label: "Related Opportunity" }, + owner_id: { label: "Contract Owner" }, + status: { + label: "Status", + options: { + draft: "Draft", + in_approval: "In Approval", + activated: "Activated", + expired: "Expired", + terminated: "Terminated" + } + }, + contract_term_months: { label: "Contract Term (Months)" }, + start_date: { label: "Start Date" }, + end_date: { label: "End Date" }, + contract_value: { label: "Contract Value" }, + billing_frequency: { + label: "Billing Frequency", + options: { + monthly: "Monthly", + quarterly: "Quarterly", + annually: "Annually", + one_time: "One-time" + } + }, + payment_terms: { + label: "Payment Terms", + options: { + net_15: "Net 15", + net_30: "Net 30", + net_60: "Net 60", + net_90: "Net 90", + due_on_receipt: "Due on Receipt" + } + }, + auto_renewal: { label: "Auto Renewal" }, + renewal_notice_days: { label: "Renewal Notice (Days)" }, + contract_type: { + label: "Contract Type", + options: { + subscription: "Subscription", + service: "Service Agreement", + license: "License", + partnership: "Partnership", + nda: "NDA", + msa: "MSA" + } + }, + signed_date: { label: "Signed Date" }, + signed_by: { label: "Signed By" }, + document_url: { label: "Contract Document" }, + special_terms: { label: "Special Terms" }, + description: { label: "Description" }, + billing_address: { label: "Billing Address" } + }, + _views: { + all_contracts: { label: "All Contracts" }, + renewal_calendar: { label: "Renewal Calendar" }, + contract_gantt: { label: "Contract Terms" }, + contract_timeline: { label: "Contract Timeline" } + }, + _sections: { + basic: { label: "Contract Information" }, + parties: { label: "Parties" }, + terms: { label: "Terms & Dates" }, + value: { label: "Contract Value" }, + status: { label: "Status & Approval" }, + renewal: { label: "Renewal" }, + // Form section names on contract.view.ts (#1100). `contract_terms`, + // not `terms` — `terms` is already the fieldGroup key for "Terms & Dates". + contract_terms: { label: "Terms" }, + signing_and_documents: { label: "Signing & Documents" }, + notes: { label: "Notes" } + } + }, + crm_product: { + label: "Product", + pluralLabel: "Products", + fields: { + product_code: { label: "Product Code" }, + name: { label: "Product Name" }, + description: { label: "Description" }, + category: { + label: "Category", + options: { + software: "Software", + hardware: "Hardware", + service: "Service", + subscription: "Subscription", + support: "Support" + } + }, + family: { + label: "Product Family", + options: { + enterprise: "Enterprise Solutions", + smb: "SMB Solutions", + services: "Professional Services", + cloud: "Cloud Services" + } + }, + list_price: { label: "List Price" }, + cost: { label: "Cost" }, + sku: { label: "SKU" }, + is_active: { label: "Active" }, + product_manager: { label: "Product Manager" }, + image: { label: "Product Image" }, + datasheet: { label: "Datasheet" }, + display_title: { label: "Display Title" } + }, + _views: { + all_products: { label: "All Products" }, + product_catalog: { label: "Product Catalog" } + }, + _sections: { + basic: { label: "Product Information" }, + pricing: { label: "Pricing" }, + metadata: { label: "Resources" }, + // Form section names on product.view.ts (#1100) + product_info: { label: "Product Info" }, + pricing_info: { label: "Pricing" }, + media: { label: "Media" } + } + } +}; + +// src/sales/translations/en/objects.service.ts +var service = { + crm_case: { + label: "Case", + pluralLabel: "Cases", + fields: { + case_number: { label: "Case Number" }, + subject: { label: "Subject" }, + description: { label: "Description" }, + crm_account: { label: "Account" }, + crm_contact: { label: "Contact" }, + status: { + label: "Status", + options: { + new: "New", + in_progress: "In Progress", + waiting_customer: "Waiting on Customer", + waiting_support: "Waiting on Support", + escalated: "Escalated", + resolved: "Resolved", + closed: "Closed" + } + }, + priority: { + label: "Priority", + options: { low: "Low", medium: "Medium", high: "High", critical: "Critical" } + }, + type: { + label: "Case Type", + options: { + question: "Question", + problem: "Problem", + feature_request: "Feature Request", + bug: "Bug" + } + }, + origin: { + label: "Case Origin", + options: { email: "Email", phone: "Phone", web: "Web", chat: "Chat", social_media: "Social Media" } + }, + owner_id: { label: "Case Owner" }, + closed_date: { label: "Closed Date" }, + first_response_date: { label: "First Response Date" }, + resolution_time_hours: { label: "Resolution Time (Hours)" }, + sla_due_date: { label: "SLA Due Date", help: "Set from the case priority and the account\u2019s Customer Tier, in calendar hours: nights, weekends and holidays count." }, + is_sla_violated: { label: "SLA Violated" }, + is_escalated: { label: "Escalated" }, + escalation_reason: { label: "Escalation Reason" }, + resolution: { label: "Resolution" }, + resolved_by_article: { label: "Resolved by Article", help: "Knowledge article that resolved this case \u2014 the deflection signal." }, + internal_notes: { label: "Internal Notes", help: "Internal notes; not visible to the customer." }, + is_closed: { label: "Is Closed" }, + display_title: { label: "Display Title" }, + priority_rank: { label: "Priority Rank" }, + escalated_date: { label: "Escalated Date" } + }, + _views: { + all_cases: { label: "All Cases" }, + case_workflow: { label: "Service Workflow" }, + sla_calendar: { label: "SLA Calendar" }, + case_timeline: { label: "Case Timeline" }, + unassigned_triage: { + label: "Unassigned \u2014 triage", + emptyState: { + title: "Nothing waiting for triage", + message: "Every case has an owner. Cases appear here when they arrive with no owner \u2014 typically a web-to-case submission that arrived while nobody held the Service Agent position." + } + }, + escalated_cases: { label: "Escalated Cases" }, + my_open_cases: { label: "My Open Cases" }, + sla_at_risk: { label: "\u23F0 SLA at Risk" } + }, + _sections: { + basic: { label: "Case Information" }, + origin: { label: "Origin & Routing" }, + sla: { label: "SLA & Priority" }, + resolution: { label: "Resolution" }, + escalation: { label: "Escalation" }, + system: { label: "System" }, + // The detail page's sections reference the groups above (#970), so it + // has no section names of its own. + // Form section names on case.view.ts (#1100). + case: { label: "Case" }, + how_can_we_help: { label: "How can we help?" } + }, + _actions: { + ...activityActions, + escalate_case: { + label: "Escalate Case", + confirmText: "This will escalate the case to the escalation team. Continue?", + successMessage: "Case escalated successfully!" + }, + close_case: { + label: "Close Case", + confirmText: "Are you sure you want to close this case?", + successMessage: "Case closed successfully!" + }, + claim_case: { + label: "Claim Case", + successMessage: "Case claimed \u2014 it is yours now." + } + } + }, + crm_knowledge_article: { + label: "Knowledge Article", + pluralLabel: "Knowledge Base", + description: "Reusable answers and how-to guides for customers and agents", + fields: { + article_number: { label: "Article #" }, + title: { label: "Title" }, + summary: { label: "Summary", help: "One-paragraph TL;DR shown in search results and AI citations." }, + body: { label: "Body", help: "Full article content (Markdown)." }, + category: { + label: "Category", + options: { + getting_started: "Getting Started", + how_to: "How-To", + troubleshooting: "Troubleshooting", + billing: "Billing & Pricing", + api: "API & Integrations", + release_notes: "Release Notes", + policy: "Policy" + } + }, + tags: { + label: "Tags", + options: { + auth: "Auth", + sso: "SSO", + mobile: "Mobile", + email: "Email", + reports: "Reports", + performance: "Performance", + data_import: "Data Import", + webhooks: "Webhooks" + } + }, + status: { + label: "Status", + options: { draft: "Draft", in_review: "In Review", published: "Published", archived: "Archived" } + }, + audience: { + label: "Audience", + help: "Public articles are visible in the customer portal; internal articles are agent-only.", + options: { public: "Public", internal: "Internal" } + }, + language: { + label: "Language", + options: { en: "English", zh_cn: "Simplified Chinese", es_es: "Spanish", ja_jp: "Japanese" } + }, + owner_id: { label: "Owner" }, + related_to_case: { label: "Source Case", help: "Case this article was authored from (optional)." }, + published_at: { label: "Published At" }, + last_reviewed_at: { label: "Last Reviewed" }, + helpful_count: { label: "Helpful", help: "Recounted from crm_article_feedback \u2014 never typed in." }, + not_helpful_count: { label: "Not Helpful", help: "Recounted from crm_article_feedback \u2014 never typed in." }, + display_title: { label: "Display Title" } + }, + _views: { + all_articles: { label: "All Articles" }, + published_articles: { label: "Published" }, + my_drafts: { label: "My Drafts" } + }, + _sections: { + basic: { label: "Article Information" }, + content: { label: "Content" }, + taxonomy: { label: "Categorization" }, + metrics: { label: "Engagement" }, + engagement: { label: "Engagement" }, + // Form section name on knowledge_article.view.ts (#1100) + article: { label: "Article" } + }, + _actions: { + mark_article_helpful: { + label: "Helpful", + successMessage: "Thanks \u2014 recorded as helpful." + }, + mark_article_not_helpful: { + label: "Not Helpful", + successMessage: "Thanks \u2014 recorded as not helpful." + } + } + }, + crm_article_feedback: { + label: "Article Feedback", + pluralLabel: "Article Feedback", + description: "One reader\u2019s helpful / not-helpful verdict on a knowledge article", + fields: { + feedback_number: { label: "Feedback #" }, + owner_id: { label: "Reader" }, + crm_knowledge_article: { label: "Article", help: "Knowledge article this feedback is about." }, + verdict: { + label: "Verdict", + options: { helpful: "Helpful", not_helpful: "Not Helpful" } + }, + comment: { label: "Comment", help: "Optional note explaining the verdict \u2014 read by the article\u2019s author." } + }, + _sections: { + basic: { label: "Feedback" } + } + } +}; + +// src/sales/translations/en/objects.activity.ts +var activity = { + crm_task: { + label: "Task", + pluralLabel: "Tasks", + fields: { + subject: { label: "Subject" }, + description: { label: "Description" }, + status: { + label: "Status", + options: { + not_started: "Not Started", + in_progress: "In Progress", + waiting: "Waiting", + completed: "Completed", + deferred: "Deferred" + } + }, + priority: { + label: "Priority", + options: { low: "Low", normal: "Normal", high: "High", urgent: "Urgent" } + }, + type: { + label: "Task Type", + options: { + call: "Call", + email: "Email", + meeting: "Meeting", + follow_up: "Follow-up", + demo: "Demo", + other: "Other" + } + }, + due_date: { label: "Due Date" }, + reminder_date: { label: "Reminder Date/Time" }, + completed_date: { label: "Completed Date" }, + owner_id: { label: "Assigned To" }, + related_to_type: { + label: "Related To Type", + options: { + crm_account: "Account", + crm_contact: "Contact", + crm_opportunity: "Opportunity", + crm_lead: "Lead", + crm_case: "Case" + } + }, + related_to_account: { label: "Related Account" }, + related_to_contact: { label: "Related Contact" }, + related_to_opportunity: { label: "Related Opportunity" }, + related_to_lead: { label: "Related Lead" }, + related_to_case: { label: "Related Case" }, + is_recurring: { label: "Recurring Task" }, + recurrence_type: { + label: "Recurrence Type", + options: { daily: "Daily", weekly: "Weekly", monthly: "Monthly", yearly: "Yearly" } + }, + recurrence_interval: { label: "Recurrence Interval" }, + recurrence_end_date: { label: "Recurrence End Date" }, + is_completed: { label: "Is Completed" }, + is_overdue: { label: "Is Overdue" }, + progress_percent: { label: "Progress (%)" }, + priority_rank: { label: "Priority Rank" }, + reminder_sent: { label: "Reminder Sent" } + }, + _views: { + all_tasks: { label: "All Tasks" }, + task_board: { label: "Task Board" }, + task_calendar: { label: "Task Schedule" }, + task_gantt: { label: "Execution Plan" }, + task_timeline: { label: "Worklog Timeline" }, + my_open_tasks: { label: "My Open Tasks" }, + todays_tasks: { label: "\u{1F4C5} My Priority Tasks" }, + overdue_tasks: { label: "\u23F0 Open Tasks \xB7 Most Overdue First" } + }, + _sections: { + basic: { label: "Task Information" }, + scheduling: { label: "Scheduling" }, + related: { label: "Related Records" }, + recurrence: { label: "Recurrence" }, + effort: { label: "Progress & Effort" }, + system: { label: "System" }, + // Form section names on task.view.ts (#1100) + task: { label: "Task" }, + related_records: { label: "Related Records" }, + recurrence_and_effort: { label: "Recurrence & Effort" } + } + }, + crm_event: { + label: "Event", + pluralLabel: "Events", + description: "Meetings, calls and other scheduled interactions with customers", + fields: { + subject: { label: "Subject" }, + description: { label: "Description" }, + type: { + label: "Event Type", + options: { + meeting: "Meeting", + call: "Call", + demo: "Demo", + webinar: "Webinar", + onsite_visit: "Onsite Visit", + other: "Other" + } + }, + status: { + label: "Status", + options: { + planned: "Planned", + held: "Held", + cancelled: "Cancelled", + no_show: "No Show" + } + }, + owner_id: { label: "Assigned To" }, + start_datetime: { label: "Start" }, + end_datetime: { label: "End" }, + all_day: { label: "All Day Event" }, + duration_minutes: { label: "Duration (minutes)" }, + location: { label: "Location", help: "Room, address, or meeting link" }, + related_to_type: { + label: "Related To Type", + options: { + crm_account: "Account", + crm_contact: "Contact", + crm_opportunity: "Opportunity", + crm_lead: "Lead", + crm_case: "Case" + } + }, + related_to_account: { label: "Related Account" }, + related_to_contact: { label: "Related Contact" }, + related_to_opportunity: { label: "Related Opportunity" }, + related_to_lead: { label: "Related Lead" }, + related_to_case: { label: "Related Case" }, + outcome_notes: { label: "Outcome Notes", help: "What was agreed, and what happens next" } + }, + _views: { + all_events: { label: "All Events" }, + event_calendar: { label: "Event Calendar" }, + event_timeline: { label: "Team Schedule" }, + my_events: { label: "My Calendar" }, + upcoming_events: { label: "\u{1F4C5} Upcoming \xB7 Soonest First" }, + held_events: { label: "\u2705 Interaction History" } + }, + _sections: { + basic: { label: "Event Information" }, + schedule: { label: "Schedule" }, + related: { label: "Related Records" }, + outcome: { label: "Outcome" }, + // Form section names on event.view.ts (#1100). `related_records`, + // not `related` — `related` is already the fieldGroup key above. + event: { label: "Event" }, + related_records: { label: "Related Records" } + } + }, + crm_event_attendee: { + label: "Event Attendee", + pluralLabel: "Event Attendees", + description: "A person invited to or present at an event", + fields: { + attendee_number: { label: "Attendee Number" }, + crm_event: { label: "Event" }, + attendee_type: { + label: "Attendee Type", + options: { contact: "Contact", lead: "Lead", user: "User", external: "External" } + }, + crm_contact: { label: "Contact", help: "Set when the attendee is an existing customer contact" }, + crm_lead: { label: "Lead", help: "Set when the attendee is still an unconverted lead" }, + sys_user: { label: "User", help: "Set when the attendee is a colleague" }, + external_name: { + label: "External Attendee", + help: "Name of an attendee who is in no CRM object \u2014 set when Attendee Type is External" + }, + response: { + label: "Response", + options: { + no_response: "No Response", + accepted: "Accepted", + declined: "Declined", + tentative: "Tentative" + } + }, + is_organizer: { label: "Organizer" }, + invited_date: { label: "Invited" } + }, + _views: { + all_event_attendees: { label: "Event Attendees" } + }, + _sections: { + basic: { label: "Attendee" }, + response: { label: "Invitation" }, + // Form section names on event_attendee.view.ts (#1100) — same English + // text as the fieldGroups above, but a distinct key: `attendee` / + // `invitation` are not `basic` / `response`. + attendee: { label: "Attendee" }, + invitation: { label: "Invitation" } + } + } +}; + +// src/sales/translations/en/objects.marketing.ts +var marketing = { + crm_campaign: { + label: "Campaign", + pluralLabel: "Campaigns", + fields: { + campaign_code: { label: "Campaign Code" }, + name: { label: "Campaign Name" }, + description: { label: "Description" }, + type: { + label: "Campaign Type", + options: { + email: "Email", + webinar: "Webinar", + trade_show: "Trade Show", + conference: "Conference", + direct_mail: "Direct Mail", + social_media: "Social Media", + content: "Content Marketing", + partner: "Partner Marketing" + } + }, + channel: { + label: "Primary Channel", + options: { + digital: "Digital", + social: "Social", + email: "Email", + events: "Events", + partner: "Partner" + } + }, + status: { + label: "Status", + options: { + planning: "Planning", + in_progress: "In Progress", + completed: "Completed", + aborted: "Aborted" + } + }, + start_date: { label: "Start Date" }, + end_date: { label: "End Date" }, + budgeted_cost: { label: "Budgeted Cost" }, + actual_cost: { label: "Actual Cost" }, + expected_revenue: { label: "Expected Revenue" }, + actual_revenue: { label: "Actual Revenue" }, + target_size: { label: "Target Size", help: "Target number of leads/contacts" }, + num_sent: { label: "Number Sent" }, + num_responses: { label: "Number of Responses" }, + num_leads: { label: "Number of Leads" }, + num_converted_leads: { label: "Converted Leads" }, + num_opportunities: { label: "Opportunities Created" }, + num_won_opportunities: { label: "Won Opportunities" }, + response_rate: { label: "Response Rate %" }, + roi: { label: "ROI %" }, + owner_id: { label: "Campaign Owner" }, + landing_page_url: { label: "Landing Page" }, + is_active: { label: "Active" }, + display_title: { label: "Display Title" } + }, + _views: { + all_campaigns: { label: "All Campaigns" }, + campaign_gantt: { label: "Campaign Schedule" }, + campaign_calendar: { label: "Launch Calendar" }, + campaign_timeline: { label: "Marketing Timeline" } + }, + _sections: { + basic: { label: "Campaign Information" }, + schedule: { label: "Schedule" }, + budget: { label: "Budget & ROI" }, + metrics: { label: "Performance" }, + assignment: { label: "Ownership" }, + assets: { label: "Campaign Assets" } + }, + _actions: { + enroll_leads: { + label: "Enroll Members", + successMessage: "Eligible members enrolled in campaign." + } + } + }, + crm_campaign_member: { + label: "Campaign Member", + pluralLabel: "Campaign Members", + description: "Leads and contacts touched by a campaign, with response status", + fields: { + member_number: { label: "Member Number" }, + crm_campaign: { label: "Campaign" }, + crm_lead: { label: "Lead", help: "Set when the member was a Lead at enrollment time" }, + crm_contact: { label: "Contact", help: "Set when the member is an existing Contact" }, + status: { + label: "Status", + options: { + sent: "Sent", + responded: "Responded", + converted: "Converted", + unsubscribed: "Unsubscribed" + } + }, + added_date: { label: "Added Date" }, + response_date: { label: "Response Date" }, + has_responded: { label: "Has Responded" } + }, + _sections: { + basic: { label: "Basic Information" }, + response: { label: "Response Tracking" } + }, + _actions: { + mark_responded: { + label: "Mark Responded", + successMessage: "Response recorded on this campaign member." + } + } + } +}; + +// src/sales/translations/en.ts +var en2 = { + objects: { + crm_account: customer.crm_account, + crm_contact: customer.crm_contact, + crm_knowledge_article: service.crm_knowledge_article, + crm_forecast: pipeline.crm_forecast, + crm_lead: pipeline.crm_lead, + crm_opportunity: pipeline.crm_opportunity, + crm_case: service.crm_case, + crm_contract: commerce.crm_contract, + crm_product: commerce.crm_product, + crm_quote: commerce.crm_quote, + crm_task: activity.crm_task, + crm_campaign: marketing.crm_campaign, + crm_event: activity.crm_event, + crm_event_attendee: activity.crm_event_attendee, + crm_article_feedback: service.crm_article_feedback, + crm_campaign_member: marketing.crm_campaign_member, + crm_opportunity_line_item: pipeline.crm_opportunity_line_item, + crm_quote_line_item: commerce.crm_quote_line_item + }, + ...appSurface +}; + +// src/sales/translations/zh-CN/app.ts +var appSurface2 = { + apps: { + crm_enterprise: { + label: "HotCRM", + description: "\u6DB5\u76D6\u9500\u552E\u3001\u670D\u52A1\u548C\u5E02\u573A\u8425\u9500\u7684\u5BA2\u6237\u5173\u7CFB\u7BA1\u7406\u7CFB\u7EDF", + // Keyed by navigation-node `id` (a flat keyspace regardless of depth). + navigation: { + group_activity: { label: "\u6D3B\u52A8" }, + nav_event: { label: "\u6D3B\u52A8" }, + nav_activity_dashboard: { label: "\u9500\u552E\u6D3B\u52A8" }, + nav_my_calendar: { label: "\u6211\u7684\u65E5\u5386" }, + nav_home: { label: "\u9996\u9875" }, + group_sales: { label: "\u9500\u552E" }, + nav_lead: { label: "\u7EBF\u7D22" }, + nav_account: { label: "\u5BA2\u6237" }, + nav_account_workbench: { label: "\u5BA2\u6237\u5DE5\u4F5C\u53F0" }, + nav_contact: { label: "\u8054\u7CFB\u4EBA" }, + nav_opportunity: { label: "\u5546\u673A" }, + nav_quote: { label: "\u62A5\u4EF7" }, + nav_contract: { label: "\u5408\u540C" }, + nav_product: { label: "\u4EA7\u54C1" }, + nav_sales_dashboard: { label: "\u9500\u552E\u4E1A\u7EE9" }, + group_work: { label: "\u6211\u7684\u5DE5\u4F5C" }, + nav_my_tasks: { label: "\u6211\u7684\u4EFB\u52A1" }, + nav_my_deals: { label: "\u6211\u7684\u5546\u673A" }, + nav_my_leads: { label: "\u6211\u7684\u7EBF\u7D22" }, + nav_my_cases: { label: "\u6211\u7684\u5DE5\u5355" }, + nav_approval_requests: { label: "\u5F85\u6211\u5BA1\u6279" }, + group_marketing: { label: "\u5E02\u573A\u8425\u9500" }, + nav_campaign: { label: "\u8425\u9500\u6D3B\u52A8" }, + group_service: { label: "\u670D\u52A1" }, + nav_case: { label: "\u5DE5\u5355" }, + nav_knowledge: { label: "\u77E5\u8BC6\u5E93" }, + nav_service_dashboard: { label: "\u670D\u52A1\u6982\u89C8" }, + group_insights: { label: "\u6570\u636E\u6D1E\u5BDF" }, + nav_crm_dashboard: { label: "CRM \u603B\u89C8" }, + nav_forecast: { label: "\u9500\u552E\u9884\u6D4B" }, + nav_report_pipeline_coverage: { label: "\u7BA1\u9053\u8986\u76D6\u7387" }, + nav_report_lead_inflow: { label: "\u7EBF\u7D22\u6D41\u5165" }, + nav_report_sla: { label: "SLA \u8FBE\u6210" } + } + } + }, + messages: { + "common.save": "\u4FDD\u5B58", + "common.cancel": "\u53D6\u6D88", + "common.delete": "\u5220\u9664", + "common.edit": "\u7F16\u8F91", + "common.create": "\u65B0\u5EFA", + "common.search": "\u641C\u7D22", + "common.filter": "\u7B5B\u9009", + "common.export": "\u5BFC\u51FA", + "common.back": "\u8FD4\u56DE", + "common.confirm": "\u786E\u8BA4", + "nav.sales": "\u9500\u552E", + "nav.service": "\u670D\u52A1", + "nav.marketing": "\u8425\u9500", + "nav.products": "\u4EA7\u54C1", + "nav.analytics": "\u6570\u636E\u5206\u6790", + "success.saved": "\u8BB0\u5F55\u4FDD\u5B58\u6210\u529F", + "success.converted": "\u7EBF\u7D22\u8F6C\u5316\u6210\u529F", + "confirm.delete": "\u786E\u5B9A\u8981\u5220\u9664\u6B64\u8BB0\u5F55\u5417\uFF1F", + "confirm.convert_lead": "\u5C06\u6B64\u7EBF\u7D22\u8F6C\u5316\u4E3A\u5BA2\u6237\u3001\u8054\u7CFB\u4EBA\u548C\u5546\u673A\uFF1F", + "error.required": "\u6B64\u5B57\u6BB5\u4E3A\u5FC5\u586B\u9879", + "error.load_failed": "\u6570\u636E\u52A0\u8F7D\u5931\u8D25" + }, + dashboards: { + sales_activity_dashboard: { + label: "\u9500\u552E\u6D3B\u52A8", + description: "\u8C01\u5728\u548C\u5BA2\u6237\u6C9F\u901A\u3001\u9891\u7387\u5982\u4F55\uFF0C\u4EE5\u53CA\u54EA\u4E9B\u5BA2\u6237\u5DF2\u7ECF\u6C89\u9ED8", + widgets: { + interactions_held: { title: "\u5DF2\u8BB0\u5F55\u4E92\u52A8", description: "\u771F\u5B9E\u53D1\u751F\u8FC7\u7684\u901A\u8BDD\u4E0E\u4F1A\u8BAE" }, + meetings_booked: { title: "\u5DF2\u9884\u7EA6\u4F1A\u8BAE", description: "\u5DF2\u6392\u5165\u65E5\u5386\u4F46\u5C1A\u672A\u4E3E\u884C\u7684\u4F1A\u8BAE" }, + customer_minutes: { title: "\u5BA2\u6237\u63A5\u89E6\u5206\u949F\u6570", description: "\u9762\u5411\u5BA2\u6237\u7684\u603B\u65F6\u957F" }, + tasks_completed: { title: "\u5DF2\u5B8C\u6210\u4EFB\u52A1", description: "\u5DF2\u95ED\u73AF\u7684\u8DDF\u8FDB\u4E8B\u9879\u2014\u2014\u6D3B\u52A8\u7684\u53E6\u4E00\u534A" }, + activity_by_rep: { title: "\u6309\u9500\u552E\u4EE3\u8868\u7EDF\u8BA1\u7684\u6D3B\u52A8", description: "\u6BCF\u4F4D\u8D1F\u8D23\u4EBA\u8BB0\u5F55\u7684\u4E92\u52A8\u6570" }, + activity_by_week: { title: "\u6BCF\u5468\u6D3B\u52A8\u91CF", description: "\u6BCF\u5468\u4E92\u52A8\u6570" }, + activity_mix: { title: "\u6D3B\u52A8\u6784\u6210", description: "\u901A\u8BDD\u3001\u4F1A\u8BAE\u4E0E\u6F14\u793A\u7684\u5360\u6BD4" }, + activity_by_record_type: { title: "\u6D3B\u52A8\u843D\u5728\u54EA\u91CC", description: "\u6F0F\u6597\u7684\u54EA\u4E2A\u73AF\u8282\u83B7\u5F97\u4E86\u5173\u6CE8" }, + deal_activity: { title: "\u5546\u673A\u4E0A\u7684\u4E92\u52A8", description: "\u5173\u8054\u5230\u5546\u673A\u7684\u5DF2\u8BB0\u5F55\u4E92\u52A8" }, + open_deals_for_activity: { title: "\u8FDB\u884C\u4E2D\u7684\u5546\u673A", description: "\u4ECD\u5728\u63A8\u8FDB\u7684\u5546\u673A\u6570" }, + quiet_accounts_30: { title: "\u6C89\u9ED8 30 \u5929\u4EE5\u4E0A", description: "\u4E00\u4E2A\u6708\u5185\u6CA1\u6709\u4EFB\u4F55\u4E92\u52A8\u8BB0\u5F55\u7684\u6D3B\u8DC3\u5BA2\u6237" }, + quiet_accounts_60: { title: "\u6C89\u9ED8 60 \u5929\u4EE5\u4E0A", description: "\u4E24\u4E2A\u6708\u65E0\u8054\u7CFB\u2014\u2014\u98CE\u9669\u9608\u503C" }, + quiet_accounts_90: { title: "\u6C89\u9ED8 90 \u5929\u4EE5\u4E0A", description: "\u6574\u6574\u4E00\u4E2A\u5B63\u5EA6\u6CA1\u6709\u8054\u7CFB" } + } + }, + crm_overview_dashboard: { + label: "CRM \u603B\u89C8", + description: "\u6536\u5165\u6307\u6807\u3001\u7BA1\u9053\u5206\u6790\u4E0E\u5546\u673A\u6D1E\u5BDF", + widgets: { + total_revenue: { title: "\u603B\u6536\u5165", description: "\u672C\u671F\u5DF2\u6210\u4EA4\u6536\u5165" }, + active_deals: { title: "\u6D3B\u8DC3\u5546\u673A", description: "\u7BA1\u9053\u4E2D\u8FDB\u884C\u4E2D\u7684\u5546\u673A" }, + won_deals: { title: "\u8D62\u5355\u6570", description: "\u672C\u671F\u5DF2\u7ED3\u6848\u5546\u673A\u4E2D\u8D62\u5355\u7684\u603B\u6570" }, + avg_deal_size: { title: "\u5E73\u5747\u8BA2\u5355\u91D1\u989D", description: "\u5DF2\u6210\u4EA4\u5546\u673A\u7684\u5E73\u5747\u91D1\u989D" }, + revenue_trends: { title: "\u6536\u5165\u8D8B\u52BF", description: "\u8FC7\u53BB 12 \u4E2A\u6708\u7684\u5DF2\u6210\u4EA4\u6536\u5165" }, + lead_source: { title: "\u7EBF\u7D22\u6765\u6E90", description: "\u6309\u83B7\u5BA2\u6E20\u9053\u7EDF\u8BA1\u7684\u7BA1\u9053\u91D1\u989D" }, + pipeline_by_stage: { title: "\u9636\u6BB5\u7BA1\u9053\u5206\u5E03", description: "\u6309\u9636\u6BB5\u7EDF\u8BA1\u7684\u8FDB\u884C\u4E2D\u5546\u673A\u91D1\u989D" }, + top_products: { title: "\u70ED\u95E8\u4EA7\u54C1", description: "\u6309\u4EA7\u54C1\u7C7B\u522B\u7EDF\u8BA1\u7684\u76EE\u5F55\u4EF7\u6536\u5165" }, + pipeline_by_owner: { title: "\u6309\u8D1F\u8D23\u4EBA\u7EDF\u8BA1\u7BA1\u9053", description: "\u5404\u9500\u552E\u8D1F\u8D23\u4EBA\u7684\u8FDB\u884C\u4E2D\u7BA1\u9053\u91D1\u989D\u4E0E\u5546\u673A\u6570" } + } + }, + executive_dashboard: { + label: "\u9AD8\u7BA1\u603B\u89C8", + description: "\u9762\u5411\u7BA1\u7406\u5C42\u7684\u6536\u5165\u3001\u5BA2\u6237\u4E0E\u7BA1\u9053\u9AD8\u9636\u6307\u6807", + widgets: { + total_revenue_ytd: { title: "\u5E74\u5EA6\u7D2F\u8BA1\u6536\u5165", description: "\u672C\u5E74\u5EA6\u5DF2\u6210\u4EA4\u6536\u5165" }, + total_accounts: { title: "\u6D3B\u8DC3\u5BA2\u6237", description: "\u81F3\u5C11\u5B58\u5728\u4E00\u9879\u6D3B\u8DC3\u5173\u7CFB\u7684\u5BA2\u6237" }, + total_contacts: { title: "\u8054\u7CFB\u4EBA\u603B\u6570", description: "\u901A\u8BAF\u5F55\u4E2D\u7684\u8054\u7CFB\u4EBA" }, + open_leads: { title: "\u672A\u8F6C\u5316\u7EBF\u7D22", description: "\u6F0F\u6597\u4E2D\u5C1A\u672A\u8F6C\u5316\u7684\u7EBF\u7D22" }, + revenue_trend: { title: "\u6536\u5165\u8D8B\u52BF", description: "\u8FC7\u53BB 12 \u4E2A\u6708\u7684\u5DF2\u6210\u4EA4\u6536\u5165" }, + revenue_by_industry: { title: "\u884C\u4E1A\u6536\u5165\u5206\u5E03", description: "\u672C\u5E74\u5EA6\u5DF2\u6210\u4EA4\u6536\u5165\u6309\u5BA2\u6237\u884C\u4E1A\u62C6\u5206" }, + pipeline_by_stage: { title: "\u9636\u6BB5\u7BA1\u9053\u5206\u5E03", description: "\u6309\u9636\u6BB5\u7EDF\u8BA1\u7684\u8FDB\u884C\u4E2D\u5546\u673A\u91D1\u989D" }, + new_accounts_by_month: { title: "\u65B0\u589E\u5BA2\u6237", description: "\u8FC7\u53BB 6 \u4E2A\u6708\u7684\u5BA2\u6237\u521B\u5EFA\u8282\u594F" }, + accounts_by_industry: { title: "\u6309\u884C\u4E1A\u7EDF\u8BA1\u5BA2\u6237", description: "\u5404\u884C\u4E1A\u7684\u5E74\u8425\u6536\u603B\u989D\u4E0E\u5BA2\u6237\u6570" } + } + }, + sales_dashboard: { + label: "\u9500\u552E\u4E1A\u7EE9", + description: "\u7BA1\u9053\u5206\u6790\u3001\u8D62\u7387\u8D8B\u52BF\u53CA\u9500\u552E\u4EE3\u8868\u7EE9\u6548", + widgets: { + total_pipeline_value: { title: "\u7BA1\u9053\u603B\u989D", description: "\u6240\u6709\u8FDB\u884C\u4E2D\u5546\u673A\u91D1\u989D\u5408\u8BA1" }, + closed_won_qtd: { title: "\u672C\u5B63\u5EA6\u5DF2\u6210\u4EA4", description: "\u672C\u5B63\u5EA6\u5DF2\u8D62\u5F97\u7684\u6536\u5165" }, + open_opportunities: { title: "\u8FDB\u884C\u4E2D\u5546\u673A", description: "\u6B63\u5728\u63A8\u8FDB\u7684\u6D3B\u8DC3\u5546\u673A" }, + avg_deal_size: { title: "\u5E73\u5747\u8BA2\u5355\u91D1\u989D", description: "\u672C\u5B63\u5EA6\u5DF2\u6210\u4EA4\u5546\u673A\u7684\u5E73\u5747\u91D1\u989D" }, + pipeline_by_stage: { title: "\u9636\u6BB5\u7BA1\u9053\u5206\u5E03", description: "\u6309\u9636\u6BB5\u7EDF\u8BA1\u7684\u8FDB\u884C\u4E2D\u5546\u673A\u91D1\u989D" }, + monthly_revenue_trend: { title: "\u6708\u5EA6\u6536\u5165\u8D8B\u52BF", description: "\u8FC7\u53BB 12 \u4E2A\u6708\u7684\u5DF2\u6210\u4EA4\u6536\u5165" }, + pipeline_by_forecast_category: { title: "\u9884\u6D4B\u7C7B\u522B\u7BA1\u9053\u5206\u5E03", description: "\u6309\u9884\u6D4B\u7C7B\u522B\u7EDF\u8BA1\u7684\u8FDB\u884C\u4E2D\u7BA1\u9053\u91D1\u989D" }, + lead_source_breakdown: { title: "\u7EBF\u7D22\u6765\u6E90\u5206\u5E03", description: "\u6309\u6765\u6E90\u7EDF\u8BA1\u7684\u7EBF\u7D22\u6570\u91CF" }, + open_pipeline_by_owner: { title: "\u6309\u8D1F\u8D23\u4EBA\u7EDF\u8BA1\u8FDB\u884C\u4E2D\u7BA1\u9053", description: "\u5404\u9500\u552E\u8D1F\u8D23\u4EBA\u7684\u8FDB\u884C\u4E2D\u7BA1\u9053\u91D1\u989D\u3001\u5546\u673A\u6570\u4E0E\u5E73\u5747\u8D62\u5355\u6982\u7387" }, + quota_attainment_by_rep: { title: "\u6309\u9500\u552E\u4EE3\u8868\u7EDF\u8BA1\u914D\u989D\u8FBE\u6210", description: "\u6765\u81EA\u9884\u6D4B\u5FEB\u7167\u7684\u5404\u9500\u552E\u4EE3\u8868\u672C\u5B63\u5EA6\u914D\u989D\u3001\u5DF2\u6210\u4EA4\u6536\u5165\u4E0E\u8FBE\u6210\u7387" }, + pipeline_stage_by_source: { title: "\u9636\u6BB5 \xD7 \u7EBF\u7D22\u6765\u6E90", description: "\u6309\u9636\u6BB5\u548C\u6765\u6E90\u4EA4\u53C9\u7EDF\u8BA1\u8FDB\u884C\u4E2D\u5546\u673A\u91D1\u989D" }, + win_rate_12m: { title: "\u8D62\u7387\uFF08\u8FD1 12 \u4E2A\u6708\uFF09", description: "\u8FD1 12 \u4E2A\u6708\u5DF2\u7ED3\u5355\u5546\u673A\u4E2D\u8D62\u5355\u6240\u5360\u7684\u6BD4\u4F8B" }, + won_deals_12m: { title: "\u8D62\u5355\u6570\uFF08\u8FD1 12 \u4E2A\u6708\uFF09", description: "\u8D62\u7387\u7684\u5206\u5B50" }, + lost_deals_12m: { title: "\u4E22\u5355\u6570\uFF08\u8FD1 12 \u4E2A\u6708\uFF09", description: "\u8D62\u7387\u5206\u6BCD\u7684\u53E6\u4E00\u534A" }, + win_rate_by_owner: { title: "\u6309\u9500\u552E\u4EE3\u8868\u7EDF\u8BA1\u8D62/\u4E22\u5355", description: "\u8FD1 12 \u4E2A\u6708\u5404\u9500\u552E\u4EE3\u8868\u7684\u8D62\u5355\u6570\u3001\u4E22\u5355\u6570\u4E0E\u8D62\u7387" }, + win_rate_by_lead_source: { title: "\u6309\u7EBF\u7D22\u6765\u6E90\u7EDF\u8BA1\u8D62/\u4E22\u5355", description: "\u8FD1 12 \u4E2A\u6708\u54EA\u4E9B\u6765\u6E90\u5E26\u6765\u7684\u5546\u673A\u771F\u6B63\u6210\u4EA4" }, + loss_reason_breakdown: { title: "\u4E22\u5355\u539F\u56E0\u5206\u6790", description: "\u8FD1 12 \u4E2A\u6708\u4E22\u5355\u6309\u539F\u56E0\u5206\u5E03" } + } + }, + service_dashboard: { + label: "\u5BA2\u6237\u670D\u52A1", + description: "\u5DE5\u5355\u8D1F\u8F7D\u3001SLA \u5065\u5EB7\u5EA6\u4E0E\u5904\u7406\u7EE9\u6548", + widgets: { + open_cases: { title: "\u672A\u5173\u95ED\u5DE5\u5355", description: "\u5C1A\u672A\u5173\u95ED\u7684\u5DE5\u5355" }, + critical_cases: { title: "\u4E25\u91CD\u5DE5\u5355", description: "\u6807\u8BB0\u4E3A\u4E25\u91CD\u4F18\u5148\u7EA7\u7684\u672A\u5173\u95ED\u5DE5\u5355" }, + avg_resolution_time: { title: "\u5E73\u5747\u89E3\u51B3\u65F6\u957F", description: "\u5173\u95ED\u5DE5\u5355\u7684\u5E73\u5747\u5904\u7406\u65F6\u957F\uFF08\u5C0F\u65F6\uFF09" }, + sla_violations: { title: "SLA \u8FDD\u7EA6", description: "\u5DF2\u8D85\u51FA SLA \u7684\u5DE5\u5355" }, + cases_by_status: { title: "\u6309\u72B6\u6001\u5206\u5E03", description: "\u5DE5\u5355\u5728\u5404\u5904\u7406\u9636\u6BB5\u7684\u5206\u5E03" }, + cases_by_priority: { title: "\u6309\u4F18\u5148\u7EA7\u5206\u5E03", description: "\u672A\u5173\u95ED\u5DE5\u5355\u6309\u7D27\u6025\u7A0B\u5EA6\u7684\u5206\u5E03" }, + cases_by_origin: { title: "\u6309\u6765\u6E90\u5206\u5E03", description: "\u5DE5\u5355\u7684\u6765\u6E90\u6E20\u9053" }, + daily_case_volume: { title: "\u6BCF\u65E5\u5DE5\u5355\u91CF", description: "\u8FC7\u53BB 30 \u5929\u7684\u65B0\u5EFA\u5DE5\u5355" }, + sla_compliance_gauge: { title: "SLA \u8FBE\u6210\u7387", description: "\u672C\u671F SLA \u5185\u89E3\u51B3\u5DE5\u5355\u7684\u5360\u6BD4" }, + kb_deflection_rate: { title: "\u77E5\u8BC6\u5E93\u8F6C\u79FB\u7387", description: "\u5DF2\u5173\u95ED\u5DE5\u5355\u4E2D\u7531\u77E5\u8BC6\u6587\u7AE0\u89E3\u51B3\u7684\u5360\u6BD4" }, + kb_resolved_cases: { title: "\u77E5\u8BC6\u5E93\u89E3\u51B3\u6570", description: "\u5DF2\u5173\u8054\u89E3\u51B3\u6587\u7AE0\u7684\u5DF2\u5173\u95ED\u5DE5\u5355" }, + closed_cases_total: { title: "\u5DF2\u5173\u95ED\u5DE5\u5355", description: "\u8F6C\u79FB\u7387\u7684\u5206\u6BCD" }, + top_resolving_articles: { title: "\u89E3\u51B3\u5DE5\u5355\u6700\u591A\u7684\u6587\u7AE0", description: "\u6309\u89E3\u51B3\u7684\u5DF2\u5173\u95ED\u5DE5\u5355\u6570\u6392\u540D\u7684\u77E5\u8BC6\u6587\u7AE0" }, + my_open_cases_by_priority: { title: "\u6211\u7684\u672A\u5173\u95ED\u5DE5\u5355\uFF08\u6309\u4F18\u5148\u7EA7\uFF09", description: "\u4F60\u7684\u672A\u5173\u95ED\u5DE5\u5355\u53CA\u5176 SLA \u8FDD\u7EA6\u7387\uFF0C\u6309\u4F18\u5148\u7EA7\u7EC6\u5206" } + } + } + }, + // `title` / `subtitle` translate the page's `page:header`; `title` falls back + // to `label` when omitted, so it is authored only where the two differ. + // Header strings carrying `{field}` tokens keep the token spelling verbatim — + // the console substitutes on the raw key, so a translated token resolves to + // nothing and the header renders blank. + datasets: { + account_metrics: { + label: "\u5BA2\u6237\u6307\u6807", + description: "\u6309\u884C\u4E1A\u4E0E\u7C7B\u578B\u7EDF\u8BA1\u5BA2\u6237\u6570\u91CF\u7684\u8BED\u4E49\u5C42", + dimensions: { + industry: { + label: "\u884C\u4E1A" + }, + type: { + label: "\u7C7B\u578B" + }, + created_at: { + label: "\u521B\u5EFA\u65F6\u95F4" + } + }, + measures: { + account_count: { + label: "\u5BA2\u6237\u6570" + }, + annual_revenue_sum: { + label: "\u5E74\u8425\u6536" + } + } + }, + case_metrics: { + label: "\u5DE5\u5355\u6307\u6807", + description: "\u7EDF\u8BA1\u5DE5\u5355\u6570\u91CF\u3001\u89E3\u51B3\u65F6\u957F\u4E0E SLA \u7684\u8BED\u4E49\u5C42", + dimensions: { + created_at: { + label: "\u521B\u5EFA\u65F6\u95F4" + }, + origin: { + label: "\u6765\u6E90" + }, + priority: { + label: "\u4F18\u5148\u7EA7" + }, + resolved_article: { + label: "\u89E3\u51B3\u7528\u77E5\u8BC6\u6587\u7AE0" + }, + status: { + label: "\u72B6\u6001" + }, + type: { + label: "\u7C7B\u578B" + } + }, + measures: { + avg_resolution: { + label: "\u5E73\u5747\u89E3\u51B3\u65F6\u957F\uFF08\u5C0F\u65F6\uFF09" + }, + avg_sla_violated: { + label: "SLA \u8FDD\u7EA6\u7387" + }, + case_count: { + label: "\u5DE5\u5355\u6570" + }, + closed_count: { + label: "\u5DF2\u5173\u95ED\u5DE5\u5355" + }, + kb_deflection_rate: { + label: "\u77E5\u8BC6\u5E93\u81EA\u52A9\u89E3\u51B3\u7387" + }, + kb_resolved_count: { + label: "\u77E5\u8BC6\u5E93\u89E3\u51B3\u6570" + }, + sla_compliance_rate: { + label: "SLA \u8FBE\u6807\u7387" + }, + sla_met_count: { + label: "SLA \u8FBE\u6807\u5DE5\u5355" + } + } + }, + contact_metrics: { + label: "\u8054\u7CFB\u4EBA\u6307\u6807", + description: "\u7EDF\u8BA1\u8054\u7CFB\u4EBA\u6570\u91CF\u7684\u8BED\u4E49\u5C42", + measures: { + contact_count: { + label: "\u8054\u7CFB\u4EBA\u6570" + } + } + }, + event_metrics: { + label: "\u6D3B\u52A8\u6307\u6807", + description: "\u7EDF\u8BA1\u4F1A\u8BAE\u3001\u901A\u8BDD\u4E0E\u4E92\u52A8\u65B0\u8FD1\u5EA6\u7684\u8BED\u4E49\u5C42", + dimensions: { + owner: { + label: "\u8D1F\u8D23\u4EBA" + }, + related_to_type: { + label: "\u5173\u8054\u5BF9\u8C61" + }, + start_datetime: { + label: "\u6D3B\u52A8\u5468" + }, + status: { + label: "\u72B6\u6001" + }, + type: { + label: "\u6D3B\u52A8\u7C7B\u578B" + } + }, + measures: { + avg_minutes: { + label: "\u5E73\u5747\u65F6\u957F" + }, + event_count: { + label: "\u6D3B\u52A8\u6570" + }, + total_minutes: { + label: "\u603B\u5206\u949F\u6570" + } + } + }, + forecast_metrics: { + label: "\u9500\u552E\u9884\u6D4B\u6307\u6807", + description: "\u6309\u8D1F\u8D23\u4EBA\u7EDF\u8BA1\u914D\u989D\u3001\u8FBE\u6210\u7387\u4E0E\u7BA1\u9053\u8986\u76D6\u500D\u6570\u7684\u8BED\u4E49\u5C42", + dimensions: { + owner: { + label: "\u8D1F\u8D23\u4EBA" + }, + period: { + label: "\u5468\u671F\u7C7B\u578B" + }, + period_label: { + label: "\u5468\u671F" + }, + period_start: { + label: "\u5468\u671F\u5F00\u59CB" + } + }, + measures: { + attainment: { + label: "\u8FBE\u6210\u7387" + }, + closed_sum: { + label: "\u5DF2\u6210\u4EA4" + }, + commit_sum: { + label: "\u627F\u8BFA" + }, + pipeline_sum: { + label: "\u9500\u552E\u7BA1\u9053" + }, + quota_sum: { + label: "\u914D\u989D" + } + } + }, + lead_metrics: { + label: "\u7EBF\u7D22\u6307\u6807", + description: "\u7EDF\u8BA1\u7EBF\u7D22\u6570\u91CF\u7684\u8BED\u4E49\u5C42", + dimensions: { + created_at: { + label: "\u521B\u5EFA\u65F6\u95F4" + }, + last_contacted_date: { + label: "\u6700\u8FD1\u8054\u7CFB" + }, + lead_source: { + label: "\u6765\u6E90" + }, + status: { + label: "\u72B6\u6001" + } + }, + measures: { + lead_count: { + label: "\u7EBF\u7D22\u6570" + } + } + }, + opportunity_metrics: { + label: "\u5546\u673A\u6307\u6807", + description: "\u7EDF\u8BA1\u9500\u552E\u7BA1\u9053\u6570\u91CF\u4E0E\u91D1\u989D\u7684\u8BED\u4E49\u5C42", + dimensions: { + account_industry: { + label: "\u5BA2\u6237\u884C\u4E1A" + }, + close_date: { + label: "\u9884\u8BA1\u6210\u4EA4\u65E5" + }, + close_quarter: { + label: "\u6210\u4EA4\u5B63\u5EA6" + }, + forecast_category: { + label: "\u9884\u6D4B\u7C7B\u522B" + }, + lead_source: { + label: "\u7EBF\u7D22\u6765\u6E90" + }, + loss_reason: { + label: "\u5931\u5355\u539F\u56E0" + }, + owner: { + label: "\u8D1F\u8D23\u4EBA" + }, + stage: { + label: "\u9636\u6BB5" + }, + type: { + label: "\u5546\u673A\u7C7B\u578B" + }, + win_reason: { + label: "\u8D62\u5355\u539F\u56E0" + } + }, + measures: { + avg_amount: { + label: "\u5E73\u5747\u5355\u7B14\u91D1\u989D" + }, + avg_probability: { + label: "\u5E73\u5747\u8D62\u5355\u6982\u7387" + }, + decided_count: { + label: "\u5DF2\u5B9A\u5C40\u5546\u673A" + }, + lost_amount: { + label: "\u5931\u5355\u91D1\u989D" + }, + lost_count: { + label: "\u5931\u5355\u6570" + }, + opp_count: { + label: "\u5546\u673A\u6570" + }, + total_amount: { + label: "\u603B\u91D1\u989D" + }, + win_rate: { + label: "\u8D62\u5355\u7387" + }, + won_amount: { + label: "\u8D62\u5355\u91D1\u989D" + }, + won_count: { + label: "\u8D62\u5355\u6570" + } + } + }, + product_metrics: { + label: "\u4EA7\u54C1\u6307\u6807", + description: "\u7EDF\u8BA1\u4EA7\u54C1\u76EE\u5F55\u6570\u91CF\u4E0E\u6807\u4EF7\u7684\u8BED\u4E49\u5C42", + dimensions: { + category: { + label: "\u7C7B\u522B" + } + }, + measures: { + list_price_sum: { + label: "\u6807\u4EF7\u5408\u8BA1" + }, + product_count: { + label: "\u4EA7\u54C1\u6570" + } + } + }, + task_metrics: { + label: "\u4EFB\u52A1\u6307\u6807", + description: "\u7EDF\u8BA1\u4EFB\u52A1\u5DE5\u4F5C\u91CF\u4E0E\u5B8C\u6210\u60C5\u51B5\u7684\u8BED\u4E49\u5C42", + dimensions: { + due_date: { + label: "\u622A\u6B62\u65E5\u671F" + }, + is_completed: { + label: "\u5DF2\u5B8C\u6210" + }, + is_overdue: { + label: "\u5DF2\u903E\u671F" + }, + priority: { + label: "\u4F18\u5148\u7EA7" + }, + priority_rank: { + label: "\u7D27\u6025\u5EA6" + }, + status: { + label: "\u72B6\u6001" + }, + type: { + label: "\u7C7B\u578B" + } + }, + measures: { + avg_progress: { + label: "\u5E73\u5747\u8FDB\u5EA6" + }, + task_count: { + label: "\u4EFB\u52A1\u6570" + } + } + } + }, + pages: { + account_detail_page: { + label: "\u5BA2\u6237\u8BE6\u60C5", + description: "\u63D2\u69FD\u5F0F\u5BA2\u6237\u8BB0\u5F55\u9875\u2014\u2014\u81EA\u5B9A\u4E49\u9875\u5934 + \u5E38\u9A7B\u8BA8\u8BBA\u533A\u3002", + title: "{name}", + subtitle: "{industry} \xB7 {type}", + components: { + account_chatter: { label: "\u8BA8\u8BBA" } + } + }, + account_workbench: { + label: "\u5BA2\u6237\u5DE5\u4F5C\u53F0", + description: "\u9762\u5411\u9500\u552E\u56E2\u961F\u7684\u7CBE\u9009\u5BA2\u6237\u5217\u8868\uFF1A\u4EC5\u63D0\u4F9B\u5FEB\u6377\u7B5B\u9009\uFF0C\u4E0D\u542B\u89C6\u56FE\u7BA1\u7406\u3002" + }, + app_launcher_page: { + label: "\u5E94\u7528\u4E2D\u5FC3", + description: "\u8BBF\u95EE\u5168\u90E8\u5E94\u7528\u7684\u7EDF\u4E00\u5165\u53E3", + subtitle: "\u9009\u62E9\u4E00\u4E2A\u5E94\u7528\u5F00\u59CB\u4F7F\u7528", + components: { + app_search: { label: "\u641C\u7D22\u5E94\u7528" }, + app_grid: { label: "\u5E94\u7528\u7F51\u683C" } + } + }, + case_detail_page: { + label: "\u5DE5\u5355\u8BE6\u60C5", + description: "\u5BA2\u670D\u5DE5\u5355\u8BB0\u5F55\u9875\uFF1A\u5173\u952E\u4FE1\u606F\u3001SLA \u8FDB\u5EA6\u3001\u660E\u7EC6\u4E0E\u6D3B\u52A8\u65F6\u95F4\u7EBF\u3002", + title: "{case_number} \xB7 {subject}", + subtitle: "{crm_account}", + components: { + case_highlights: { label: "\u5173\u952E\u4FE1\u606F" }, + case_status_path: { label: "\u5DE5\u5355\u72B6\u6001\u8FDB\u5EA6" }, + case_details: { label: "\u5DE5\u5355\u660E\u7EC6" } + } + }, + lead_detail_page: { + label: "\u7EBF\u7D22\u8BE6\u60C5", + description: "\u5B8C\u6574\u7684\u7EBF\u7D22\u8BE6\u60C5\u9875\uFF0C\u5305\u542B\u5173\u952E\u4FE1\u606F\u3001\u660E\u7EC6\u4E0E\u76F8\u5173\u8BB0\u5F55\u3002", + title: "{first_name} {last_name}", + subtitle: "{company}", + components: { + lead_duplicate_alert_confirmed: { label: "\u5DF2\u786E\u8BA4\u91CD\u590D\u63D0\u9192" }, + lead_duplicate_alert_suspected: { label: "\u7591\u4F3C\u91CD\u590D\u63D0\u9192" }, + lead_highlights: { label: "\u5173\u952E\u4FE1\u606F" }, + lead_path: { label: "\u7EBF\u7D22\u72B6\u6001\u8FDB\u5EA6" }, + main_tabs: { label: "\u7EBF\u7D22\u4FE1\u606F\u6807\u7B7E\u9875" }, + lead_details: { label: "\u7EBF\u7D22\u660E\u7EC6" }, + related_accordion: { label: "\u76F8\u5173\u8BB0\u5F55" }, + related_tasks: { title: "\u5F85\u529E\u4EFB\u52A1", label: "\u4EFB\u52A1" }, + lead_activity: { label: "\u6D3B\u52A8\u65F6\u95F4\u7EBF" }, + lead_history: { label: "\u5B57\u6BB5\u5386\u53F2" } + } + }, + opportunity_detail_page: { + label: "\u5546\u673A\u8BE6\u60C5", + description: "\u5B8C\u6574\u7684\u5546\u673A\u8BE6\u60C5\u9875\uFF0C\u5305\u542B\u9636\u6BB5\u8FDB\u5EA6\u3001\u5173\u952E\u4FE1\u606F\u3001\u660E\u7EC6\u4E0E\u76F8\u5173\u5217\u8868\u3002", + title: "{name}", + subtitle: "{crm_account}", + components: { + opp_highlights: { label: "\u5173\u952E\u4FE1\u606F" }, + opp_stage_path: { label: "\u5546\u673A\u9636\u6BB5\u8FDB\u5EA6" }, + opp_details: { label: "\u5546\u673A\u660E\u7EC6" } + } + }, + sales_home_page: { + label: "\u9500\u552E\u4E3B\u9875", + description: "\u9500\u552E\u56E2\u961F\u4E3B\u9875\uFF0C\u6C47\u603B\u5173\u952E\u6307\u6807\u4E0E\u5FEB\u6377\u64CD\u4F5C", + title: "\u9500\u552E\u770B\u677F", + subtitle: "\u6B22\u8FCE\u56DE\u6765", + components: { + kpi_revenue_won: { + label: "\u8D62\u5355\u8425\u6536" + }, + kpi_deals_won: { + label: "\u8D62\u5355\u6570" + }, + kpi_pipeline_value: { + label: "\u9500\u552E\u7BA1\u9053\u91D1\u989D" + }, + kpi_open_leads: { + label: "\u5F00\u653E\u7EBF\u7D22" + }, + home_upcoming_events: { + label: "\u{1F4C5} \u5373\u5C06\u5F00\u59CB \xB7 \u6700\u8FD1\u4F18\u5148" + }, + quick_create: { title: "\u5FEB\u901F\u521B\u5EFA", label: "\u5FEB\u901F\u521B\u5EFA" }, + key_metrics: { title: "\u5173\u952E\u7EE9\u6548\u6307\u6807", label: "\u5173\u952E\u6307\u6807" }, + home_tabs: { label: "\u4E3B\u9875\u6807\u7B7E\u9875" }, + home_my_leads: { label: "\u6211\u7684\u7EBF\u7D22" }, + home_my_deals: { label: "\u6211\u7684\u8FDB\u884C\u4E2D\u5546\u673A" }, + home_my_tasks: { label: "\u6211\u7684\u5F85\u529E\u4EFB\u52A1" }, + ai_briefing: { + title: "\u8BE2\u95EE AI \u52A9\u624B", + label: "AI \u52A9\u624B\u4ECA\u65E5\u901F\u89C8" + }, + upcoming_events: { title: "\u5373\u5C06\u5F00\u59CB\u7684\u6D3B\u52A8", label: "\u5373\u5C06\u5F00\u59CB\u7684\u6D3B\u52A8" } + } + }, + utility_bar_page: { + label: "\u5DE5\u5177\u680F", + description: "\u60AC\u6D6E\u5DE5\u5177\u7684\u5FEB\u6377\u8BBF\u95EE\u680F", + components: { + notifications_panel: { label: "\u901A\u77E5" }, + quick_notes: { title: "\u5FEB\u901F\u7B14\u8BB0", label: "\u5FEB\u901F\u7B14\u8BB0" }, + quick_search: { label: "\u5FEB\u901F\u641C\u7D22" } + } + } + }, + // Screen-flow copy (#1210, #1975). Keyed `flows..label`, + // `screens..title` and `screens..fields..{label,placeholder}` + // — the keys `os lint`'s `i18n/missing-flow` names, read by the console's + // flow runner since @objectstack 17.7.0 (the spec's `flows` liveness row is + // `live` there). A screen with no authored `title` shows its flow's label in + // every locale, so each `screen_1.title` repeats the flow label. Since + // 18.0.0-next.0 three more surfaces are keys the engine reads in the run's + // locale, and `i18n/missing-flow` names each missing one: a select field's + // `options.` (worded as the object field's own option in this pack), + // an authored screen `description`, and a refusing `end` node's + // `refusals..message`. A translated description or message is a text + // slot like the one it translates, so a hole in it is `{{ }}`. + // The discount ceiling is interpolated from `QUOTE_DISCOUNT_CEILING`, never + // retyped: the number lives in `_thresholds.ts` alone (#1711). + flows: { + campaign_enrollment: { + label: "\u5C06\u6210\u5458\u52A0\u5165\u8425\u9500\u6D3B\u52A8", + screens: { + screen_1: { + title: "\u5C06\u6210\u5458\u52A0\u5165\u8425\u9500\u6D3B\u52A8", + fields: { + memberSource: { label: "\u52A0\u5165\u7684\u6210\u5458\u7C7B\u578B", options: { leads: "\u7EBF\u7D22", contacts: "\u8054\u7CFB\u4EBA" } }, + leadStatus: { label: "\u52A0\u5165\u4EE5\u4E0B\u72B6\u6001\u7684\u7EBF\u7D22", options: { new: "\u65B0\u5EFA", contacted: "\u5DF2\u8054\u7CFB", qualified: "\u5DF2\u786E\u8BA4" } }, + contactDepartment: { + label: "\u52A0\u5165\u4EE5\u4E0B\u90E8\u95E8\u7684\u8054\u7CFB\u4EBA", + options: { executive: "\u7BA1\u7406\u5C42", sales: "\u9500\u552E\u90E8", marketing: "\u5E02\u573A\u90E8", engineering: "\u5DE5\u7A0B\u90E8", support: "\u652F\u6301\u90E8", finance: "\u8D22\u52A1\u90E8", hr: "\u4EBA\u529B\u8D44\u6E90", operations: "\u8FD0\u8425\u90E8" } + } + } + } + } + }, + escalate_case: { + label: "\u5347\u7EA7\u5DE5\u5355", + screens: { screen_1: { title: "\u5347\u7EA7\u5DE5\u5355", fields: { reason: { label: "\u5347\u7EA7\u539F\u56E0" } } } } + }, + close_case: { + label: "\u5173\u95ED\u5DE5\u5355", + screens: { + screen_1: { + title: "\u5173\u95ED\u5DE5\u5355", + fields: { + resolution: { label: "\u89E3\u51B3\u65B9\u6848" }, + resolved_by_article: { label: "\u901A\u8FC7\u77E5\u8BC6\u6587\u7AE0\u89E3\u51B3\uFF08\u53EF\u9009\uFF09" } + } + } + } + }, + claim_case: { + label: "\u8BA4\u9886\u5DE5\u5355", + screens: { + screen_1: { + title: "\u8BA4\u9886\u5DE5\u5355", + fields: { + claimStatus: { + label: "\u5904\u7406\u72B6\u6001", + options: { in_progress: "\u5904\u7406\u4E2D", waiting_customer: "\u7B49\u5F85\u5BA2\u6237\u56DE\u590D", waiting_support: "\u7B49\u5F85\u652F\u6301\u56DE\u590D" } + } + } + } + } + }, + lead_conversion: { + label: "\u7EBF\u7D22\u8F6C\u5316\u6D41\u7A0B", + screens: { + screen_1: { + title: "\u7EBF\u7D22\u8F6C\u5316\u6D41\u7A0B", + // The duplicate warning's text is a variable the flow assigns; this + // key can only carry the hole that shows it. + description: "{{duplicateWarning}}", + fields: { + createOpportunity: { label: "\u662F\u5426\u521B\u5EFA\u5546\u673A\uFF1F" }, + opportunityName: { label: "\u5546\u673A\u540D\u79F0" }, + opportunityAmount: { label: "\u5546\u673A\u91D1\u989D" }, + closeDate: { label: "\u9884\u8BA1\u6210\u4EA4\u65E5\u671F" } + } + }, + refuse_confirmed_duplicate: { + title: "\u8F6C\u5316\u88AB\u62D2\u7EDD", + description: "\u8BE5\u7EBF\u7D22\u7684\u300C\u91CD\u590D\u72B6\u6001\u300D\u4E3A\u300C\u5DF2\u786E\u8BA4\u91CD\u590D\u300D\uFF1A\u5BA1\u6838\u4EBA\u5DF2\u5C06\u5176\u4E0E\u73B0\u6709\u8BB0\u5F55\u6BD4\u5BF9\uFF0C\u5E76\u8BB0\u5F55\u4E3A\u91CD\u590D\u3002\u8F6C\u5316\u4F1A\u4E3A\u540C\u4E00\u4E70\u5BB6\u518D\u521B\u5EFA\u4E00\u4E2A\u5BA2\u6237\u3001\u8054\u7CFB\u4EBA\u548C\u5546\u673A\u3002\u672C\u7EBF\u7D22\u7684\u300C\u91CD\u590D\u7EBF\u7D22\u7BA1\u7406\u300D\u90E8\u5206\u5217\u51FA\u4E86\u4FDD\u7559\u7684\u8BB0\u5F55\uFF1B\u8BF7\u6539\u4E3A\u4EE5\u91CD\u590D\u4E3A\u7531\u5C06\u6B64\u7EBF\u7D22\u8BBE\u4E3A\u300C\u672A\u901A\u8FC7\u300D\u3002\u53EA\u6709\u5BA1\u6838\u4EBA\u4FEE\u6539\u8BE5\u7ED3\u8BBA\u540E\u624D\u80FD\u91CD\u65B0\u8F6C\u5316\u3002" + }, + refuse_unapproved: { + title: "\u8F6C\u5316\u88AB\u62D2\u7EDD", + description: "\u8BE5\u7EBF\u7D22\u5C1A\u672A\u83B7\u51C6\u8F6C\u5316\u3002\u5FC5\u987B\u7531\u5BA1\u6279\u4EBA\u6279\u51C6\u540E\uFF0C\u624D\u80FD\u8F6C\u5316\u4E3A\u5BA2\u6237\u3001\u8054\u7CFB\u4EBA\u548C\u5546\u673A\uFF1B\u7EBF\u7D22\u4E0A\u7684\u300C\u8F6C\u5316\u5BA1\u6279\u300D\u5B57\u6BB5\u663E\u793A\u8BE5\u51B3\u5B9A\u4ECD\u5728\u5F85\u5BA1\u6279\u8FD8\u662F\u5DF2\u88AB\u9A73\u56DE\u3002\u5728\u6B64\u671F\u95F4\u8BF7\u7EE7\u7EED\u8DDF\u8FDB\u8BE5\u7EBF\u7D22\u2014\u2014\u5B83\u7684\u4EFB\u4F55\u5185\u5BB9\u90FD\u6CA1\u6709\u88AB\u51BB\u7ED3\u3002" + }, + refuse_no_match_key: { + title: "\u8F6C\u5316\u88AB\u62D2\u7EDD", + description: "\u8BE5\u7EBF\u7D22\u7684\u516C\u53F8\u6CA1\u6709\u5339\u914D\u952E\uFF0C\u56E0\u6B64\u8F6C\u5316\u65E0\u6CD5\u5224\u65AD\u5B83\u5C5E\u4E8E\u54EA\u4E2A\u5BA2\u6237\uFF0C\u4E5F\u4E0D\u4F1A\u53BB\u731C\u6D4B\uFF1A\u731C\u6D4B\u53EF\u80FD\u4F1A\u628A\u8054\u7CFB\u4EBA\u548C\u5546\u673A\u5F52\u5230\u53E6\u4E00\u4E2A\u5BA2\u6237\u540D\u4E0B\u3002\u4FDD\u5B58\u7EBF\u7D22\u7684\u300C\u516C\u53F8\u300D\u4F1A\u91CD\u65B0\u751F\u6210\u5339\u914D\u952E\uFF0C\u8BF7\u91CD\u65B0\u4FDD\u5B58\u540E\u518D\u8F6C\u5316\u3002\u5C1A\u672A\u521B\u5EFA\u4EFB\u4F55\u8BB0\u5F55\u3002" + } + } + }, + schedule_followup: { + label: "\u5B89\u6392\u8DDF\u8FDB", + screens: { + screen_1: { + title: "\u5B89\u6392\u8DDF\u8FDB", + fields: { + subject: { label: "\u4E0B\u4E00\u6B65\u505A\u4EC0\u4E48\uFF1F" }, + dueDate: { label: "\u622A\u6B62\u65E5\u671F" }, + activityType: { + label: "\u6D3B\u52A8\u7C7B\u578B", + options: { call: "\u7535\u8BDD", email: "\u90AE\u4EF6", meeting: "\u4F1A\u8BAE", follow_up: "\u8DDF\u8FDB", demo: "\u6F14\u793A", other: "\u5176\u4ED6" } + }, + priority: { label: "\u4F18\u5148\u7EA7", options: { low: "\u4F4E", normal: "\u666E\u901A", high: "\u9AD8", urgent: "\u7D27\u6025" } }, + notes: { label: "\u5907\u6CE8" } + } + } + } + }, + quote_generation: { + label: "\u4ECE\u5546\u673A\u751F\u6210\u62A5\u4EF7\u5355", + refusals: { refuse_held: { message: "\u9700\u5148\u5B8C\u6210\u7ACB\u9879\u5BA1\u6279\uFF1A\u8BF7\u52FE\u9009\u300C\u7533\u8BF7\u7ACB\u9879\u5BA1\u6279\u300D\u3002\u5C1A\u672A\u521B\u5EFA\u4EFB\u4F55\u5185\u5BB9\u3002" } }, + screens: { + screen_1: { + title: "\u4ECE\u5546\u673A\u751F\u6210\u62A5\u4EF7\u5355", + fields: { + quoteName: { label: "\u62A5\u4EF7\u540D\u79F0" }, + expirationDays: { label: "\u6709\u6548\u671F\uFF08\u5929\uFF09" }, + discount: { label: `\u6298\u6263 % (\u2264 ${QUOTE_DISCOUNT_CEILING})`, placeholder: `0-${QUOTE_DISCOUNT_CEILING}` } + } + } + } + } + } +}; + +// src/sales/translations/zh-CN/_shared.ts +var activityActions2 = { + log_call: { + label: "\u8BB0\u5F55\u901A\u8BDD", + successMessage: "\u901A\u8BDD\u8BB0\u5F55\u6210\u529F\uFF01", + params: { + subject: { label: "\u901A\u8BDD\u4E3B\u9898" }, + duration: { label: "\u65F6\u957F\uFF08\u5206\u949F\uFF09" }, + attendee_contacts: { label: "\u8054\u7CFB\u4EBA\u53C2\u4E0E\u8005" }, + attendee_users: { label: "\u5185\u90E8\u53C2\u4E0E\u8005" }, + notes: { label: "\u901A\u8BDD\u8BB0\u5F55" } + } + }, + log_meeting: { + label: "\u8BB0\u5F55\u4F1A\u8BAE", + successMessage: "\u4F1A\u8BAE\u8BB0\u5F55\u6210\u529F\uFF01", + params: { + subject: { label: "\u4F1A\u8BAE\u4E3B\u9898" }, + duration: { label: "\u65F6\u957F\uFF08\u5206\u949F\uFF09" }, + attendee_contacts: { label: "\u8054\u7CFB\u4EBA\u53C2\u4F1A\u4EBA" }, + attendee_users: { label: "\u5185\u90E8\u53C2\u4F1A\u4EBA" }, + notes: { label: "\u4F1A\u8BAE\u7EAA\u8981" } + } + }, + schedule_meeting: { + label: "\u5B89\u6392\u4F1A\u8BAE", + successMessage: "\u4F1A\u8BAE\u5DF2\u5B89\u6392\uFF01", + params: { + subject: { label: "\u4F1A\u8BAE\u4E3B\u9898" }, + start_date: { label: "\u5F00\u59CB\u65E5\u671F\uFF08UTC\uFF09" }, + start_time: { label: "\u5F00\u59CB\u65F6\u95F4\uFF08UTC\uFF09" }, + location: { label: "\u5730\u70B9" }, + duration: { label: "\u65F6\u957F\uFF08\u5206\u949F\uFF09" }, + attendee_contacts: { label: "\u8054\u7CFB\u4EBA\u53C2\u4F1A\u4EBA" }, + attendee_users: { label: "\u5185\u90E8\u53C2\u4F1A\u4EBA" }, + notes: { label: "\u4F1A\u8BAE\u8BAE\u7A0B" } + } + } +}; + +// src/sales/translations/zh-CN/objects.customer.ts +var customer2 = { + crm_account: { + label: "\u5BA2\u6237", + pluralLabel: "\u5BA2\u6237", + description: "\u4E0E\u6211\u4EEC\u6709\u4E1A\u52A1\u5F80\u6765\u7684\u516C\u53F8\u548C\u7EC4\u7EC7", + fields: { + account_number: { label: "\u5BA2\u6237\u7F16\u53F7" }, + registration_number: { + label: "\u767B\u8BB0\u8BC1\u4EF6\u53F7", + help: "\u5BF9\u65B9\u5728\u5176\u6240\u5C5E\u653F\u5E9C\u767B\u8BB0\u673A\u5173\u53D6\u5F97\u7684\u767B\u8BB0\u6807\u8BC6\u3002\u4E0D\u540C\u4E8E\u7531\u6211\u65B9\u53D1\u653E\u7684\u5BA2\u6237\u7F16\u53F7\u3002" + }, + commercial_capability: { + label: "\u5546\u52A1\u80FD\u529B", + help: "\u8BE5\u5BA2\u6237\u662F\u5426\u53EF\u4EE5\u627F\u63A5\u65B0\u4E1A\u52A1\u3002\u4EC5\u7ED3\u7B97\u7C7B\u5BA2\u6237\u4F9D\u7136\u53EF\u7528\u4E8E\u5F00\u7968\u4E0E\u6536\u4ED8\u6B3E\uFF0C\u4F46\u4E0D\u80FD\u5173\u8054\u65B0\u7684\u5546\u673A\u3002", + options: { full: "\u5B8C\u6574", settlement_only: "\u4EC5\u7ED3\u7B97" } + }, + incumbent_vendor: { label: "\u73B0\u6709\u4F9B\u5E94\u5546", help: "\u5F53\u524D\u627F\u63A5\u8BE5\u5BA2\u6237\u8FD9\u90E8\u5206\u652F\u51FA\u7684\u4F9B\u5E94\u5546\u3002" }, + annual_purchasing_budget: { label: "\u5E74\u5EA6\u91C7\u8D2D\u9884\u7B97", help: "\u8BE5\u5BA2\u6237\u672C\u5E74\u5EA6\u9884\u8BA1\u5411\u4F9B\u5E94\u5546\u652F\u51FA\u7684\u91D1\u989D\uFF0C\u800C\u975E\u5176\u81EA\u8EAB\u8425\u6536\u3002" }, + payment_cycle: { + label: "\u4ED8\u6B3E\u5468\u671F", + options: { prepaid: "\u9884\u4ED8", net_30: "30 \u5929", net_60: "60 \u5929", net_90: "90 \u5929" } + }, + approval_status: { + label: "\u5BA1\u6279\u72B6\u6001", + help: "\u8BE5\u5BA2\u6237\u7684\u5BA1\u6279\u8FDB\u5C55\u3002\u65B0\u5EFA\u5BA2\u6237\u521D\u59CB\u4E3A\u5F85\u5BA1\u6279\uFF0C\u5E76\u5728\u5BA1\u6279\u6536\u4EF6\u7BB1\u4E2D\u88C1\u5B9A\u3002", + options: { pending: "\u5F85\u5BA1\u6279", approved: "\u5DF2\u901A\u8FC7", rejected: "\u5DF2\u9A73\u56DE" } + }, + name: { label: "\u5BA2\u6237\u540D\u79F0", help: "\u516C\u53F8\u6216\u7EC4\u7EC7\u7684\u6CD5\u5B9A\u540D\u79F0" }, + type: { + label: "\u7C7B\u578B", + options: { prospect: "\u6F5C\u5728\u5BA2\u6237", customer: "\u6B63\u5F0F\u5BA2\u6237", partner: "\u5408\u4F5C\u4F19\u4F34", former: "\u524D\u5BA2\u6237" } + }, + industry: { + label: "\u884C\u4E1A", + options: { + technology: "\u79D1\u6280", + software: "\u8F6F\u4EF6 / SaaS", + finance: "\u91D1\u878D", + healthcare: "\u533B\u7597", + retail: "\u96F6\u552E", + manufacturing: "\u5236\u9020", + education: "\u6559\u80B2", + real_estate: "\u623F\u5730\u4EA7", + media: "\u4F20\u5A92\u5A31\u4E50", + logistics: "\u7269\u6D41", + hospitality: "\u9152\u5E97\u65C5\u6E38", + energy: "\u80FD\u6E90\u516C\u7528\u4E8B\u4E1A", + government: "\u653F\u5E9C", + nonprofit: "\u975E\u8425\u5229", + other: "\u5176\u4ED6" + } + }, + annual_revenue: { label: "\u5E74\u8425\u6536" }, + child_account_revenue: { label: "\u5B50\u516C\u53F8\u5E74\u8425\u6536\u5408\u8BA1", help: "\u672C\u5BA2\u6237\u76F4\u5C5E\u5B50\u516C\u53F8\u7684\u5E74\u8425\u6536\u5408\u8BA1\u3002" }, + number_of_employees: { label: "\u5458\u5DE5\u4EBA\u6570" }, + phone: { label: "\u7535\u8BDD" }, + website: { label: "\u7F51\u7AD9" }, + billing_address: { label: "\u8D26\u5355\u5730\u5740" }, + billing_country: { + label: "\u8D26\u5355\u56FD\u5BB6", + help: "\u7531\u8D26\u5355\u5730\u5740\u63A8\u5BFC\u2014\u2014\u6309\u5F55\u5165\u539F\u6837\u53BB\u9664\u9996\u5C3E\u7A7A\u683C\u5E76\u8F6C\u4E3A\u5927\u5199\u3002" + }, + territory: { + label: "\u9500\u552E\u533A\u57DF", + help: "\u7531\u8D26\u5355\u5730\u5740\u63A8\u5BFC\u2014\u2014\u533A\u57DF\u5171\u4EAB\u89C4\u5219\u636E\u6B64\u5339\u914D\u3002\u4E0D\u5C5E\u4E8E\u5DF2\u914D\u7F6E\u533A\u57DF\u7684\u5BA2\u6237\u4E3A\u201C\u5176\u4ED6\u201D\u3002", + options: { na: "\u5317\u7F8E", emea: "\u6B27\u6D32\u3001\u4E2D\u4E1C\u4E0E\u975E\u6D32", other: "\u5176\u4ED6" } + }, + office_location: { label: "\u529E\u516C\u5730\u70B9" }, + owner_id: { label: "\u5BA2\u6237\u8D1F\u8D23\u4EBA" }, + parent_account: { label: "\u6BCD\u516C\u53F8", help: "\u5C42\u7EA7\u7ED3\u6784\u4E2D\u7684\u6BCD\u516C\u53F8" }, + description: { label: "\u63CF\u8FF0" }, + is_active: { label: "\u662F\u5426\u6D3B\u8DC3" }, + last_activity_date: { label: "\u6700\u8FD1\u6D3B\u52A8\u65E5\u671F" }, + brand_color: { label: "\u54C1\u724C\u8272" }, + logo: { label: "\u516C\u53F8\u6807\u8BC6" }, + tier: { + label: "\u5BA2\u6237\u5206\u5C42", + options: { strategic: "\u6218\u7565\u5BA2\u6237", enterprise: "\u4F01\u4E1A\u5BA2\u6237", mid_market: "\u4E2D\u578B\u5BA2\u6237", smb: "\u4E2D\u5C0F\u5BA2\u6237" } + }, + segment: { + label: "\u5BA2\u6237\u7EC6\u5206", + options: { net_new: "\u5168\u65B0\u5BA2\u6237", growth: "\u589E\u957F\u5BA2\u6237", at_risk: "\u98CE\u9669\u5BA2\u6237", stable: "\u7A33\u5B9A\u5BA2\u6237" } + }, + health_score: { + label: "\u5065\u5EB7\u5EA6", + help: "\u5BA2\u6237\u6210\u529F\u7ECF\u7406\u7EF4\u62A4\u7684\u5065\u5EB7\u5EA6\u6307\u6807", + options: { healthy: "\u5065\u5EB7", watching: "\u5173\u6CE8", at_risk: "\u98CE\u9669", churning: "\u6D41\u5931\u4E2D" } + }, + name_normalized: { label: "\u5BA2\u6237\u540D\u79F0\uFF08\u89C4\u8303\u5316\uFF09", help: "\u7EBF\u7D22\u8F6C\u5316\u7684\u5339\u914D\u952E\uFF1A\u5BA2\u6237\u540D\u79F0\u8F6C\u5C0F\u5199\u3001\u53BB\u9664\u9996\u5C3E\u7A7A\u683C\u3001\u5185\u90E8\u8FDE\u7EED\u7A7A\u767D\u5408\u5E76\u4E3A\u4E00\u4E2A\u7A7A\u683C\u3002\u7531 account_protection \u94A9\u5B50\u7EF4\u62A4\u2014\u2014\u8BF7\u52FF\u76F4\u63A5\u7F16\u8F91\u3002" }, + display_title: { label: "\u663E\u793A\u540D\u79F0" } + }, + _views: { + all_accounts: { + label: "\u5168\u90E8\u5BA2\u6237", + description: "\u5BA2\u6237\u4E3B\u5217\u8868\uFF0C\u5305\u542B\u8425\u6536\u4E0E\u884C\u4E1A\u6458\u8981", + bulkActions: { + delete: { + label: "\u5220\u9664", + confirmLabel: "\u5220\u9664", + confirmText: "\u786E\u5B9A\u8981\u6C38\u4E45\u5220\u9664 {{count}} \u4E2A\u5BA2\u6237\u5417\uFF1F\u6B64\u64CD\u4F5C\u65E0\u6CD5\u64A4\u9500\u3002" + }, + transfer_owner: { + label: "\u8F6C\u79FB\u8D1F\u8D23\u4EBA", + confirmText: "\u786E\u5B9A\u8981\u8F6C\u79FB {{count}} \u4E2A\u5BA2\u6237\u7684\u8D1F\u8D23\u4EBA\u5417\uFF1F", + params: { + owner_id: { + label: "\u65B0\u8D1F\u8D23\u4EBA" + } + } + }, + update_tier: { + label: "\u66F4\u65B0\u5BA2\u6237\u7B49\u7EA7", + confirmText: "\u786E\u5B9A\u8981\u5C06 {{count}} \u4E2A\u5BA2\u6237\u7684\u7B49\u7EA7\u66F4\u65B0\u4E3A {{tier}} \u5417\uFF1F", + params: { + tier: { + label: "\u5BA2\u6237\u7B49\u7EA7" + } + } + } + } + }, + account_gallery: { label: "\u5BA2\u6237\u5361\u7247", description: "\u4F7F\u7528\u54C1\u724C\u8272\u9AD8\u4EAE\u7684\u5BA2\u6237\u5361\u7247\u89C6\u56FE" }, + account_map: { label: "\u5BA2\u6237\u5730\u56FE", description: "\u5BA2\u6237\u7684\u5730\u7406\u5206\u5E03" }, + enterprise_accounts: { label: "\u4F01\u4E1A\u5BA2\u6237", description: "\u5E74\u8425\u6536\u6700\u9AD8\u7684\u5927\u5BA2\u6237" }, + my_accounts: { label: "\u6211\u7684\u5BA2\u6237", description: "\u7531\u5F53\u524D\u7528\u6237\u8D1F\u8D23\u7684\u5BA2\u6237" }, + at_risk_accounts: { label: "\u26A0\uFE0F \u98CE\u9669\u5BA2\u6237" } + }, + _sections: { + basic: { label: "\u57FA\u672C\u4FE1\u606F" }, + financials: { label: "\u8D22\u52A1\u4FE1\u606F" }, + business_profile: { label: "\u4E1A\u52A1\u4FE1\u606F" }, + contact_info: { label: "\u8054\u7CFB\u4FE1\u606F" }, + ownership: { label: "\u5F52\u5C5E\u4E0E\u72B6\u6001" }, + branding: { label: "\u54C1\u724C" }, + system: { label: "\u7CFB\u7EDF" }, + // account.view.ts 表单区块名称 (#1100) + profile: { label: "\u8D44\u6599" }, + customer_success: { label: "\u5BA2\u6237\u6210\u529F" }, + locations: { label: "\u5730\u5740\u4FE1\u606F" }, + description: { label: "\u63CF\u8FF0" } + }, + _actions: { ...activityActions2 } + }, + crm_contact: { + label: "\u8054\u7CFB\u4EBA", + pluralLabel: "\u8054\u7CFB\u4EBA", + description: "\u5BA2\u6237\u4E0E\u5546\u673A\u7684\u5173\u952E\u4EBA\u7269\u8054\u7CFB\u4EBA", + fields: { + salutation: { + label: "\u79F0\u8C13", + options: { mr: "\u5148\u751F", ms: "\u5973\u58EB", mrs: "\u592B\u4EBA", dr: "\u535A\u58EB", prof: "\u6559\u6388" } + }, + first_name: { label: "\u540D" }, + last_name: { label: "\u59D3" }, + full_name: { label: "\u5168\u540D" }, + crm_account: { label: "\u6240\u5C5E\u5BA2\u6237" }, + email: { label: "\u90AE\u7BB1" }, + phone: { label: "\u7535\u8BDD" }, + mobile: { label: "\u624B\u673A" }, + title: { label: "\u804C\u4F4D" }, + department: { + label: "\u90E8\u95E8", + options: { + executive: "\u7BA1\u7406\u5C42", + sales: "\u9500\u552E\u90E8", + marketing: "\u5E02\u573A\u90E8", + engineering: "\u5DE5\u7A0B\u90E8", + support: "\u652F\u6301\u90E8", + finance: "\u8D22\u52A1\u90E8", + hr: "\u4EBA\u529B\u8D44\u6E90", + operations: "\u8FD0\u8425\u90E8" + } + }, + // 采购决策圈 (REQ-0004)。英文标签是 'Buying Function' 而非 'Buying Role'： + // 平台的 security-role-word 规则在对象声明上保留了英文 role 一词（ADR-0090 D3）。 + // 该规则只匹配英文，不读语言包，所以中文这里用本地读者真正在说的词。 + buying_function: { + label: "\u91C7\u8D2D\u89D2\u8272", + options: { + decision_maker: "\u51B3\u7B56\u8005", + economic_buyer: "\u9884\u7B97\u51B3\u7B56\u4EBA", + technical_evaluator: "\u6280\u672F\u8BC4\u4F30\u4EBA", + user: "\u4F7F\u7528\u8005", + influencer: "\u5F71\u54CD\u8005", + gatekeeper: "\u5B88\u95E8\u4EBA" + } + }, + attitude: { + label: "\u5BF9\u6211\u53F8\u6001\u5EA6", + options: { + champion: "\u62E5\u62A4\u8005", + supportive: "\u652F\u6301", + neutral: "\u4E2D\u7ACB", + skeptical: "\u5B58\u7591", + blocker: "\u53CD\u5BF9\u8005" + } + }, + relationship_strength: { + label: "\u4E0E\u9500\u552E\u5173\u7CFB\u5F3A\u5EA6", + options: { + distant: "\u758F\u8FDC", + acquaintance: "\u4E00\u822C\u8BA4\u8BC6", + working: "\u5DE5\u4F5C\u5F80\u6765", + strong: "\u5173\u7CFB\u7D27\u5BC6", + trusted_advisor: "\u53EF\u4FE1\u987E\u95EE" + } + }, + owner_id: { label: "\u8054\u7CFB\u4EBA\u8D1F\u8D23\u4EBA" }, + description: { label: "\u63CF\u8FF0" }, + is_primary: { label: "\u4E3B\u8981\u8054\u7CFB\u4EBA", help: "\u662F\u5426\u4E3A\u8BE5\u5BA2\u6237\u7684\u4E3B\u8981\u8054\u7CFB\u4EBA\uFF1F" }, + mailing_address: { label: "\u90AE\u5BC4\u5730\u5740" }, + lead_source: { + label: "\u7EBF\u7D22\u6765\u6E90", + options: { + web: "\u7F51\u7AD9", + referral: "\u63A8\u8350", + event: "\u6D3B\u52A8 / \u5C55\u4F1A", + webinar: "\u7EBF\u4E0A\u7814\u8BA8\u4F1A", + partner: "\u5408\u4F5C\u4F19\u4F34", + advertisement: "\u5E7F\u544A", + paid_search: "\u4ED8\u8D39\u641C\u7D22", + social: "\u793E\u4EA4\u5A92\u4F53", + content: "\u5185\u5BB9 / \u535A\u5BA2", + cold_call: "\u964C\u751F\u62DC\u8BBF", + email_campaign: "\u90AE\u4EF6\u8425\u9500", + other: "\u5176\u4ED6" + } + }, + do_not_call: { label: "\u7981\u6B62\u81F4\u7535" }, + email_opt_out: { label: "\u62D2\u7EDD\u90AE\u4EF6" }, + last_contacted_date: { label: "\u6700\u8FD1\u8054\u7CFB\u65F6\u95F4" }, + avatar: { label: "\u5934\u50CF" } + }, + _views: { + all_contacts: { label: "\u5168\u90E8\u8054\u7CFB\u4EBA" }, + contact_directory: { label: "\u8054\u7CFB\u4EBA\u76EE\u5F55" }, + primary_contacts: { label: "\u4E3B\u8981\u8054\u7CFB\u4EBA" } + }, + _actions: { + ...activityActions2, + mark_primary: { + label: "\u8BBE\u4E3A\u4E3B\u8981\u8054\u7CFB\u4EBA", + confirmText: "\u662F\u5426\u5C06\u6B64\u8054\u7CFB\u4EBA\u8BBE\u4E3A\u8BE5\u5BA2\u6237\u7684\u4E3B\u8981\u8054\u7CFB\u4EBA\uFF1F", + successMessage: "\u5DF2\u8BBE\u4E3A\u4E3B\u8981\u8054\u7CFB\u4EBA\uFF01" + }, + send_email: { + label: "\u53D1\u9001\u90AE\u4EF6", + params: { + subject: { label: "\u4E3B\u9898" }, + body: { label: "\u6B63\u6587" } + } + }, + add_contact_to_campaign: { + label: "\u52A0\u5165\u8425\u9500\u6D3B\u52A8", + successMessage: "\u8054\u7CFB\u4EBA\u5DF2\u52A0\u5165\u8425\u9500\u6D3B\u52A8\uFF01", + params: { + crm_campaign: { label: "\u8425\u9500\u6D3B\u52A8" } + } + } + }, + _sections: { + identity: { label: "\u8EAB\u4EFD\u4FE1\u606F" }, + account_info: { label: "\u5BA2\u6237\u4E0E\u804C\u52A1" }, + buying_centre: { label: "\u91C7\u8D2D\u51B3\u7B56\u5708" }, + contact_info: { label: "\u8054\u7CFB\u65B9\u5F0F" }, + mailing_address: { label: "\u90AE\u5BC4\u5730\u5740" }, + additional: { label: "\u9644\u52A0\u4FE1\u606F" }, + preferences: { label: "\u6C9F\u901A\u504F\u597D" }, + // contact.view.ts 表单区块名称 (#1100) + contact_details: { label: "\u8054\u7CFB\u4FE1\u606F" }, + comm_preferences: { label: "\u504F\u597D\u8BBE\u7F6E" } + } + } +}; + +// src/sales/translations/zh-CN/objects.pipeline.ts +var pipeline2 = { + crm_lead: { + _validations: { + disqualification_reason_required: { + message: "\u7EBF\u7D22\u6807\u8BB0\u4E3A\u4E0D\u5408\u683C\u65F6\u5FC5\u987B\u586B\u5199\u53D6\u6D88\u8D44\u683C\u539F\u56E0" + }, + duplicate_disqualification_requires_survivor: { + message: "\u4EE5\u91CD\u590D\u4E3A\u7531\u53D6\u6D88\u7EBF\u7D22\u8D44\u683C\u65F6\uFF0C\u5FC5\u987B\u6307\u660E\u4FDD\u7559\u7684\u8BB0\u5F55\u5E76\u5C06\u91CD\u590D\u72B6\u6001\u8BBE\u4E3A\u5DF2\u786E\u8BA4" + }, + email_required: { + message: "\u7535\u5B50\u90AE\u4EF6\u4E3A\u5FC5\u586B\u9879" + }, + lead_status_progression: { + message: "\u65E0\u6548\u7684\u7EBF\u7D22\u72B6\u6001\u6D41\u8F6C" + } + }, + label: "\u7EBF\u7D22", + pluralLabel: "\u7EBF\u7D22", + description: "\u5C1A\u672A\u786E\u8BA4\u7684\u6F5C\u5728\u5BA2\u6237", + fields: { + salutation: { + label: "\u79F0\u8C13", + options: { mr: "\u5148\u751F", ms: "\u5973\u58EB", mrs: "\u592B\u4EBA", dr: "\u535A\u58EB", prof: "\u6559\u6388" } + }, + first_name: { label: "\u540D" }, + last_name: { label: "\u59D3" }, + full_name: { label: "\u5168\u540D" }, + company: { label: "\u516C\u53F8" }, + title: { label: "\u804C\u4F4D" }, + email: { label: "\u90AE\u7BB1" }, + phone: { label: "\u7535\u8BDD" }, + industry: { + label: "\u884C\u4E1A", + options: { + technology: "\u79D1\u6280", + software: "\u8F6F\u4EF6 / SaaS", + finance: "\u91D1\u878D", + healthcare: "\u533B\u7597", + retail: "\u96F6\u552E", + manufacturing: "\u5236\u9020", + education: "\u6559\u80B2", + real_estate: "\u623F\u5730\u4EA7", + media: "\u4F20\u5A92\u5A31\u4E50", + logistics: "\u7269\u6D41", + hospitality: "\u9152\u5E97\u65C5\u6E38", + energy: "\u80FD\u6E90\u516C\u7528\u4E8B\u4E1A", + government: "\u653F\u5E9C", + nonprofit: "\u975E\u8425\u5229", + other: "\u5176\u4ED6" + } + }, + status: { + label: "\u72B6\u6001", + options: { + // 已确认 / 未通过 是同一个动作(线索确认)的正反两面;原先的 + // 已确认 / 不合格 出自两套说法,在状态条上并排时读起来不成对。 + new: "\u65B0\u5EFA", + contacted: "\u5DF2\u8054\u7CFB", + qualified: "\u5DF2\u786E\u8BA4", + unqualified: "\u672A\u901A\u8FC7", + converted: "\u5DF2\u8F6C\u5316" + } + }, + lead_source: { + label: "\u7EBF\u7D22\u6765\u6E90", + options: { + web: "\u7F51\u7AD9", + referral: "\u63A8\u8350", + event: "\u6D3B\u52A8 / \u5C55\u4F1A", + webinar: "\u7EBF\u4E0A\u7814\u8BA8\u4F1A", + partner: "\u5408\u4F5C\u4F19\u4F34", + advertisement: "\u5E7F\u544A", + paid_search: "\u4ED8\u8D39\u641C\u7D22", + social: "\u793E\u4EA4\u5A92\u4F53", + content: "\u5185\u5BB9 / \u535A\u5BA2", + cold_call: "\u964C\u751F\u62DC\u8BBF", + email_campaign: "\u90AE\u4EF6\u8425\u9500", + other: "\u5176\u4ED6" + } + }, + owner_id: { label: "\u7EBF\u7D22\u8D1F\u8D23\u4EBA" }, + is_converted: { label: "\u5DF2\u8F6C\u5316" }, + description: { label: "\u63CF\u8FF0" }, + mobile: { label: "\u624B\u673A" }, + website: { label: "\u7F51\u7AD9" }, + rating: { label: "\u7EBF\u7D22\u8BC4\u5206", help: "\u7EBF\u7D22\u8D28\u91CF\u8BC4\u5206\uFF081-5 \u661F\uFF09" }, + converted_account: { label: "\u8F6C\u5316\u5BA2\u6237" }, + converted_contact: { label: "\u8F6C\u5316\u8054\u7CFB\u4EBA" }, + converted_opportunity: { label: "\u8F6C\u5316\u5546\u673A" }, + converted_date: { label: "\u8F6C\u5316\u65E5\u671F" }, + address: { label: "\u5730\u5740" }, + annual_revenue: { label: "\u5E74\u8425\u6536" }, + number_of_employees: { label: "\u5458\u5DE5\u4EBA\u6570" }, + notes: { label: "\u5907\u6CE8", help: "\u672C\u7EBF\u7D22\u7684\u5DE5\u4F5C\u5907\u6CE8\u2014\u2014\u652F\u6301\u683C\u5F0F\u6392\u7248\u3002" }, + do_not_call: { label: "\u7981\u6B62\u81F4\u7535" }, + email_opt_out: { label: "\u62D2\u6536\u90AE\u4EF6" }, + disqualification_reason: { + // 状态里的 unqualified 译作「未通过」,所以这里跟着叫「未通过原因」 + // 而不是「取消资格原因」—— 两个字段在同一张表单上下相邻,用词必须成对。 + label: "\u672A\u901A\u8FC7\u539F\u56E0", + help: "\u72B6\u6001\u4E3A\u300C\u672A\u901A\u8FC7\u300D\u65F6\u5FC5\u586B", + options: { + not_a_fit: "\u9700\u6C42\u4E0D\u5339\u914D", + no_budget: "\u9884\u7B97\u4E0D\u8DB3", + wrong_persona: "\u8054\u7CFB\u4EBA\u89D2\u8272\u4E0D\u7B26", + unreachable: "\u65E0\u6CD5\u8054\u7CFB", + duplicate: "\u91CD\u590D\u7EBF\u7D22", + competitor: "\u9009\u62E9\u4E86\u7ADE\u4E89\u5BF9\u624B", + other: "\u5176\u4ED6" + } + }, + duplicate_of_type: { + help: "\u4FDD\u7559\u4E0B\u6765\u7684\u90A3\u6761\u8BB0\u5F55\u6240\u5C5E\u7684\u5BF9\u8C61\u7C7B\u578B\u3002", + label: "\u91CD\u590D\u4E8E", + // `erased` 是墓碑值，不是可选项：表单不提供它（见 + // `src/sales/views/lead.view.ts`），但幸存记录被删除后线索会带着它， + // 所以凡是读取记录的地方都需要标签，否则会显示原始值 `erased`。 + options: { crm_lead: "\u7EBF\u7D22", crm_contact: "\u8054\u7CFB\u4EBA", erased: "\u8BB0\u5F55\u5DF2\u5220\u9664" } + }, + duplicate_of_lead: { label: "\u91CD\u590D\u7684\u7EBF\u7D22" }, + duplicate_of_contact: { label: "\u91CD\u590D\u7684\u8054\u7CFB\u4EBA" }, + duplicate_status: { + help: "\u7591\u4F3C = \u5F55\u5165\u65F6\u81EA\u52A8\u6807\u8BB0\uFF1B\u5DF2\u786E\u8BA4 = \u4EBA\u5DE5\u6838\u5B9E\u8FC7\u5339\u914D\u3002", + // 疑似 = 录入时自动标记;已确认 = 人工核对后的判定。两者是同一 + // 判断的两个阶段,所以共用一个字段而不是各占一套链接字段。 + label: "\u91CD\u590D\u72B6\u6001", + options: { suspected: "\u7591\u4F3C\u91CD\u590D", confirmed: "\u5DF2\u786E\u8BA4\u91CD\u590D" } + }, + display_title: { label: "\u663E\u793A\u540D\u79F0" }, + company_normalized: { label: "\u516C\u53F8\u540D\u79F0\uFF08\u89C4\u8303\u5316\uFF09", help: "\u7EBF\u7D22\u8F6C\u5316\u7684\u5339\u914D\u952E\uFF1A\u516C\u53F8\u540D\u79F0\u8F6C\u5C0F\u5199\u3001\u53BB\u9664\u9996\u5C3E\u7A7A\u683C\u3001\u5185\u90E8\u8FDE\u7EED\u7A7A\u767D\u5408\u5E76\u4E3A\u4E00\u4E2A\u7A7A\u683C\u3002\u7531 lead_duplicate_check \u94A9\u5B50\u7EF4\u62A4\u2014\u2014\u8BF7\u52FF\u76F4\u63A5\u7F16\u8F91\u3002" }, + next_followup_date: { label: "\u4E0B\u6B21\u8DDF\u8FDB\u65E5\u671F" }, + last_contacted_date: { label: "\u6700\u8FD1\u8054\u7CFB\u65F6\u95F4" }, + need_type: { + label: "\u9700\u6C42\u7C7B\u578B", + help: "\u5BA2\u6237\u60F3\u8981\u4EC0\u4E48\u3002\u7EBF\u7D22\u5206\u6D3E\u3001\u4F18\u5148\u7EA7\u6392\u5E8F\u548C\u9700\u6C42\u5206\u6790\u90FD\u8BFB\u8FD9\u4E2A\u5B57\u6BB5\u3002", + options: { + new_implementation: "\u65B0\u5EFA\u5B9E\u65BD", + expansion: "\u6269\u5BB9\u589E\u8D2D", + replacement: "\u66FF\u6362\u8FC1\u79FB", + renewal: "\u7EED\u7EA6", + consulting: "\u54A8\u8BE2\u670D\u52A1", + support: "\u8FD0\u7EF4\u652F\u6301", + other: "\u5176\u4ED6" + } + }, + estimated_amount: { + label: "\u9884\u8BA1\u91D1\u989D", + help: "\u8D44\u683C\u5224\u5B9A\u4E4B\u524D\u5BF9\u8BE5\u9700\u6C42\u91D1\u989D\u7684\u4F30\u7B97\u3002\u8F6C\u5316\u65F6\u7528\u4E8E\u9884\u586B\u5546\u673A\u91D1\u989D\u3002" + }, + conversion_approval_status: { + label: "\u8F6C\u5316\u5BA1\u6279", + help: "\u8BE5\u7EBF\u7D22\u662F\u5426\u5DF2\u83B7\u51C6\u8F6C\u5316\u3002\u300C\u65E0\u9700\u5BA1\u6279\u300D\u8868\u793A\u4E0D\u8D70\u5BA1\u6279\u6D41\u7A0B\u2014\u2014\u8FD9\u662F\u4EA7\u54C1\u7684\u51FA\u5382\u9ED8\u8BA4\u503C\u3002", + options: { + not_required: "\u65E0\u9700\u5BA1\u6279", + pending: "\u5F85\u5BA1\u6279", + approved: "\u5BA1\u6279\u901A\u8FC7", + rejected: "\u5BA1\u6279\u9A73\u56DE" + } + } + }, + _views: { + all_leads: { + label: "\u5168\u90E8\u7EBF\u7D22", + emptyState: { title: "\u8FD8\u6CA1\u6709\u7EBF\u7D22", message: "\u521B\u5EFA\u7B2C\u4E00\u6761\u7EBF\u7D22\uFF0C\u4ECE\u8FD9\u91CC\u5F00\u59CB" } + }, + kanban_by_status: { label: "\u7EBF\u7D22\u6D41\u6C34\u7EBF" }, + calendar_by_created: { label: "\u7EBF\u7D22\u65E5\u5386" }, + gallery_view: { label: "\u7EBF\u7D22\u5361\u7247" }, + my_leads: { label: "\u6211\u7684\u7EBF\u7D22" }, + high_priority: { label: "\u9AD8\u4F18\u5148\u7EA7" }, + hot_leads: { label: "\u{1F525} \u9AD8\u70ED\u5EA6\u7EBF\u7D22" }, + suspected_duplicates: { + label: "\u7591\u4F3C\u91CD\u590D\u7EBF\u7D22", + emptyState: { title: "\u6CA1\u6709\u7591\u4F3C\u91CD\u590D", message: "\u65E0\u9700\u590D\u6838\u2014\u2014\u6BCF\u4E2A\u91CD\u590D\u5F55\u5165\u7684\u90AE\u7BB1\u90FD\u5DF2\u68C0\u67E5\u8FC7\u3002" } + } + }, + _sections: { + // Object-level section keys (lead.object.ts), used by record forms and + // by the detail page, whose sections reference these groups (#806) + address: { label: "\u5730\u5740" }, + identity: { label: "\u8EAB\u4EFD\u4FE1\u606F" }, + company_info: { label: "\u516C\u53F8\u4FE1\u606F" }, + contact_info: { label: "\u8054\u7CFB\u65B9\u5F0F" }, + qualification: { label: "\u8D44\u683C\u8BC4\u4F30" }, + assignment: { label: "\u5206\u914D" }, + additional: { label: "\u9644\u52A0\u4FE1\u606F" }, + preferences: { label: "\u6C9F\u901A\u504F\u597D" }, + conversion: { label: "\u8F6C\u5316" }, + duplicates: { label: "\u91CD\u590D\u7EBF\u7D22\u7BA1\u7406" }, + // lead.view.ts 表单区块名称 (#1100) —— 默认表单与每一个具名 formView + // 的区块名字都住在这里：那边新增一个表单，这里就补上它的区块名。 + contact_information: { label: "\u8054\u7CFB\u4FE1\u606F" }, + lead_classification: { label: "\u7EBF\u7D22\u5206\u7C7B" }, + company_information: { label: "\u516C\u53F8\u4FE1\u606F" }, + additional_information: { label: "\u9644\u52A0\u4FE1\u606F" }, + privacy: { label: "\u9690\u79C1" }, + general: { label: "\u5E38\u89C4\u4FE1\u606F" }, + details: { label: "\u8BE6\u60C5" }, + step_1_contact_details: { label: "\u7B2C\u4E00\u6B65\uFF1A\u8054\u7CFB\u65B9\u5F0F" }, + step_2_company_information: { label: "\u7B2C\u4E8C\u6B65\uFF1A\u516C\u53F8\u4FE1\u606F" }, + step_3_qualification: { label: "\u7B2C\u4E09\u6B65\uFF1A\u8D44\u8D28\u5BA1\u6838" }, + step_4_review_and_convert: { label: "\u7B2C\u56DB\u6B65\uFF1A\u5BA1\u6838\u5E76\u8F6C\u5316" }, + primary_information: { label: "\u4E3B\u8981\u4FE1\u606F" }, + extended_details: { label: "\u6269\u5C55\u4FE1\u606F" }, + quick_edit: { label: "\u5FEB\u901F\u7F16\u8F91" }, + update_lead_status: { label: "\u66F4\u65B0\u7EBF\u7D22\u72B6\u6001" }, + tell_us_about_yourself: { label: "\u8BF7\u4ECB\u7ECD\u4E00\u4E0B\u60A8\u81EA\u5DF1" }, + about_your_company: { label: "\u60A8\u7684\u516C\u53F8\u4FE1\u606F" }, + how_can_we_help: { label: "\u6211\u4EEC\u80FD\u5E2E\u60A8\u4EC0\u4E48\uFF1F" }, + lead_information: { label: "\u7EBF\u7D22\u4FE1\u606F" }, + address_information: { label: "\u5730\u5740\u4FE1\u606F" }, + privacy_preferences: { label: "\u9690\u79C1\u504F\u597D" } + }, + _actions: { + ...activityActions2, + convert_lead: { + label: "\u8F6C\u5316\u7EBF\u7D22", + successMessage: "\u7EBF\u7D22\u8F6C\u5316\u6210\u529F\uFF01" + }, + create_campaign: { + label: "\u52A0\u5165\u8425\u9500\u6D3B\u52A8", + successMessage: "\u5DF2\u5C06\u7EBF\u7D22\u52A0\u5165\u8425\u9500\u6D3B\u52A8\uFF01", + params: { + crm_campaign: { label: "\u8425\u9500\u6D3B\u52A8" } + } + }, + schedule_followup: { + label: "\u5B89\u6392\u8DDF\u8FDB", + successMessage: "\u8DDF\u8FDB\u4EFB\u52A1\u5DF2\u521B\u5EFA\u3002" + } + } + }, + crm_opportunity: { + _validations: { + amount_positive: { + message: "\u91D1\u989D\u5FC5\u987B\u5927\u4E8E\u96F6" + }, + close_date_future: { + message: "\u9664\u975E\u5546\u673A\u5DF2\u7ED3\u675F\uFF0C\u5426\u5219\u9884\u8BA1\u6210\u4EA4\u65E5\u4E0D\u5E94\u65E9\u4E8E\u4ECA\u5929" + }, + opportunity_stage_progression: { + message: "\u65E0\u6548\u7684\u5546\u673A\u9636\u6BB5\u6D41\u8F6C" + } + }, + label: "\u5546\u673A", + pluralLabel: "\u5546\u673A", + description: "\u9500\u552E\u6D41\u7A0B\u4E2D\u7684\u5546\u673A\u4E0E\u4EA4\u6613", + fields: { + name: { label: "\u5546\u673A\u540D\u79F0" }, + crm_account: { label: "\u6240\u5C5E\u5BA2\u6237" }, + primary_contact: { label: "\u4E3B\u8981\u8054\u7CFB\u4EBA" }, + owner_id: { label: "\u5546\u673A\u8D1F\u8D23\u4EBA" }, + amount: { label: "\u91D1\u989D" }, + expected_revenue: { label: "\u9884\u671F\u6536\u5165" }, + stage: { + label: "\u9636\u6BB5", + options: { + prospecting: "\u5BFB\u627E\u5BA2\u6237", + qualification: "\u8D44\u683C\u5BA1\u67E5", + needs_analysis: "\u9700\u6C42\u5206\u6790", + proposal: "\u63D0\u6848", + negotiation: "\u8C08\u5224", + closed_won: "\u6210\u4EA4", + closed_lost: "\u5931\u8D25" + } + }, + probability: { label: "\u6210\u4EA4\u6982\u7387 (%)" }, + close_date: { label: "\u9884\u8BA1\u6210\u4EA4\u65E5\u671F" }, + type: { + label: "\u7C7B\u578B", + options: { + new_business: "\u65B0\u4E1A\u52A1", + existing_upgrade: "\u8001\u5BA2\u6237\u5347\u7EA7", + existing_renewal: "\u8001\u5BA2\u6237\u7EED\u7EA6", + existing_expansion: "\u8001\u5BA2\u6237\u62D3\u5C55" + } + }, + forecast_category: { + label: "\u9884\u6D4B\u7C7B\u522B", + options: { + pipeline: "\u7BA1\u9053", + best_case: "\u6700\u4F73\u60C5\u51B5", + commit: "\u627F\u8BFA", + omitted: "\u5DF2\u6392\u9664", + closed: "\u5DF2\u5173\u95ED" + } + }, + description: { label: "\u63CF\u8FF0" }, + next_step: { label: "\u4E0B\u4E00\u6B65" }, + lead_source: { + label: "\u7EBF\u7D22\u6765\u6E90", + options: { + web: "\u7F51\u7AD9", + referral: "\u63A8\u8350", + event: "\u6D3B\u52A8 / \u5C55\u4F1A", + webinar: "\u7EBF\u4E0A\u7814\u8BA8\u4F1A", + partner: "\u5408\u4F5C\u4F19\u4F34", + advertisement: "\u5E7F\u544A", + paid_search: "\u4ED8\u8D39\u641C\u7D22", + social: "\u793E\u4EA4\u5A92\u4F53", + content: "\u5185\u5BB9 / \u535A\u5BA2", + cold_call: "\u964C\u751F\u62DC\u8BBF", + email_campaign: "\u90AE\u4EF6\u8425\u9500", + other: "\u5176\u4ED6" + } + }, + crm_campaign: { label: "\u8425\u9500\u6D3B\u52A8", help: "\u5E26\u6765\u6B64\u5546\u673A\u7684\u8425\u9500\u6D3B\u52A8" }, + days_in_stage: { label: "\u5F53\u524D\u9636\u6BB5\u5929\u6570" }, + stage_entry_date: { label: "\u8FDB\u5165\u5F53\u524D\u9636\u6BB5\u65E5\u671F", help: "\u672C\u5546\u673A\u8FDB\u5165\u5F53\u524D\u9636\u6BB5\u7684\u65E5\u671F\u3002" }, + is_private: { label: "\u79C1\u5BC6" }, + approval_status: { + label: "\u5BA1\u6279\u72B6\u6001", + options: { not_required: "\u65E0\u9700\u5BA1\u6279", pending: "\u5BA1\u6279\u4E2D", approved: "\u5DF2\u6279\u51C6", rejected: "\u5DF2\u9A73\u56DE" } + }, + approved_date: { label: "\u6279\u51C6\u65F6\u95F4" }, + win_reason: { + help: '\u8D62\u5355\u539F\u56E0\u3002\u5C06\u5546\u673A\u5173\u95ED\u4E3A"\u6210\u4EA4"\u65F6\u5FC5\u586B\u3002', + label: "\u8D62\u5355\u539F\u56E0", + options: { + better_product: "\u4EA7\u54C1\u66F4\u4F18", + better_price: "\u4EF7\u683C\u66F4\u4F18", + relationship: "\u5BA2\u6237\u5173\u7CFB", + better_support: "\u652F\u6301\u66F4\u597D", + best_fit: "\u6700\u4F73\u5951\u5408", + quote_accepted: "\u62A5\u4EF7\u88AB\u63A5\u53D7", + other: "\u5176\u4ED6" + } + }, + loss_reason: { + help: '\u4E22\u5355\u539F\u56E0\u3002\u5C06\u5546\u673A\u5173\u95ED\u4E3A"\u5931\u8D25"\u65F6\u5FC5\u586B\u3002', + label: "\u4E22\u5355\u539F\u56E0", + options: { + price: "\u4EF7\u683C\u8FC7\u9AD8", + competitor: "\u8F93\u7ED9\u7ADE\u4E89\u5BF9\u624B", + no_budget: "\u65E0\u9884\u7B97", + no_decision: "\u672A\u51B3\u7B56", + timing: "\u65F6\u673A\u4E0D\u5408\u9002", + features: "\u529F\u80FD\u7F3A\u5931", + other: "\u5176\u4ED6" + } + }, + loss_details: { label: "\u8D62/\u4E22\u5355\u8BE6\u60C5", help: "\u8D62\u5355\u6216\u4E22\u5355\u539F\u56E0\u7684\u8865\u5145\u8BF4\u660E\u3002" }, + // REQ-0006 — 资格评估、客户侧采购日程、商机叙述、业务线与状态变更审批。 + will_bid: { label: "\u662F\u5426\u6295\u6807", help: "\u6211\u65B9\u662F\u5426\u6253\u7B97\u6295\u6807\u3002\u7559\u7A7A\u8868\u793A\u5C1A\u672A\u51B3\u5B9A\u3002" }, + controllability: { label: "\u53EF\u63A7\u6027", options: { high: "\u9AD8", medium: "\u4E2D", low: "\u4F4E" } }, + priority: { label: "\u4F18\u5148\u7EA7", options: { high: "\u9AD8", medium: "\u4E2D", low: "\u4F4E" } }, + deal_level: { label: "\u5546\u673A\u7EA7\u522B", options: { strategic: "\u6218\u7565\u7EA7", key: "\u91CD\u70B9", standard: "\u666E\u901A" } }, + is_subcontracted: { label: "\u6D89\u53CA\u5206\u5305" }, + subcontracting_note: { label: "\u5206\u5305\u8BF4\u660E" }, + customer_initiation_date: { label: "\u5BA2\u6237\u7ACB\u9879\u65E5\u671F" }, + expected_tender_date: { label: "\u9884\u8BA1\u62DB\u6807\u65E5\u671F" }, + expected_signing_date: { label: "\u9884\u8BA1\u7B7E\u7EA6\u65E5\u671F" }, + expected_tender_amount: { label: "\u9884\u8BA1\u62DB\u6807\u91D1\u989D" }, + expected_signing_amount: { label: "\u9884\u8BA1\u7B7E\u7EA6\u91D1\u989D" }, + business_line: { + label: "\u4E1A\u52A1\u7EBF", + options: { product: "\u4EA7\u54C1", services: "\u4E13\u4E1A\u670D\u52A1", consulting: "\u54A8\u8BE2\u670D\u52A1", support: "\u8FD0\u7EF4\u652F\u6301", other: "\u5176\u4ED6" } + }, + customer_background: { label: "\u5BA2\u6237\u7B80\u4ECB" }, + project_background: { label: "\u9879\u76EE\u80CC\u666F" }, + risk_analysis: { label: "\u98CE\u9669\u5206\u6790" }, + payment_terms: { label: "\u4ED8\u6B3E\u6761\u6B3E" }, + requested_status: { label: "\u7533\u8BF7\u53D8\u66F4\u72B6\u6001", options: { closed_won: "\u8D62\u5355", closed_lost: "\u4E22\u5355" } }, + status_change_approval_status: { + label: "\u72B6\u6001\u53D8\u66F4\u5BA1\u6279", + options: { not_required: "\u65E0\u9700\u5BA1\u6279", pending: "\u5BA1\u6279\u4E2D", approved: "\u5DF2\u6279\u51C6", rejected: "\u5DF2\u9A73\u56DE" } + }, + // REQ-0006 第 11 步 — 立项审批。 + qualification_requested: { + label: "\u7533\u8BF7\u7ACB\u9879\u5BA1\u6279", + help: "\u52FE\u9009\u540E\u63D0\u4EA4\u7ACB\u9879\u5BA1\u6279\u3002\u5BA1\u6279\u88AB\u9A73\u56DE\u65F6\u4F1A\u81EA\u52A8\u53D6\u6D88\u52FE\u9009\uFF1B\u518D\u6B21\u52FE\u9009\u5373\u53EF\u91CD\u65B0\u7533\u8BF7\u3002" + }, + qualification_approval_status: { + label: "\u7ACB\u9879\u5BA1\u6279", + options: { not_required: "\u65E0\u9700\u5BA1\u6279", pending: "\u5BA1\u6279\u4E2D", approved: "\u5DF2\u6279\u51C6", rejected: "\u5DF2\u9A73\u56DE" } + } + }, + _views: { + tender_this_quarter: { + label: "\u672C\u5B63\u5EA6\u9884\u8BA1\u62DB\u6807", + emptyState: { + title: "\u672C\u5B63\u5EA6\u6682\u65E0\u9884\u8BA1\u62DB\u6807\u7684\u5546\u673A", + message: "\u672C\u6807\u7B7E\u9875\u5217\u51FA\u5BA2\u6237\u4FA7\u9884\u8BA1\u62DB\u6807\u65E5\u671F\u843D\u5728\u5F53\u524D\u5B63\u5EA6\u5185\u7684\u8FDB\u884C\u4E2D\u5546\u673A\u3002\u5728\u5546\u673A\u4E0A\u586B\u5199\u201C\u9884\u8BA1\u62DB\u6807\u65E5\u671F\u201D\u540E\uFF0C\u5B83\u5C31\u4F1A\u51FA\u73B0\u5728\u8FD9\u91CC\u3002" + } + }, + open_opportunities: { label: "\u8FDB\u884C\u4E2D\u5546\u673A" }, + all_opportunities: { label: "\u5168\u90E8\u5546\u673A" }, + pipeline_kanban: { label: "\u9500\u552E\u6D41\u6C34\u7EBF" }, + close_date_calendar: { label: "\u9884\u6D4B\u65E5\u5386" }, + deal_timeline: { label: "\u5546\u673A\u65F6\u95F4\u7EBF" }, + deal_gallery: { label: "\u5546\u673A\u5361\u7247" }, + my_open_deals: { label: "\u6211\u7684\u8FDB\u884C\u4E2D\u5546\u673A" }, + stale_opportunities: { label: "\u26A0\uFE0F \u505C\u6EDE\u5546\u673A \xB7 \u6309\u9636\u6BB5\u505C\u7559\u65F6\u95F4\u6392\u5E8F" }, + closing_this_quarter: { + label: "\u672C\u5B63\u5EA6\u5F85\u6210\u4EA4\u5546\u673A", + emptyState: { + title: "\u672C\u5B63\u5EA6\u6682\u65E0\u5F85\u6210\u4EA4\u5546\u673A", + message: "\u672C\u6807\u7B7E\u9875\u5217\u51FA\u9884\u8BA1\u6210\u4EA4\u65E5\u671F\u843D\u5728\u5F53\u524D\u5B63\u5EA6\u5185\u3001\u4E14\u5904\u4E8E\u627F\u8BFA\uFF08Commit\uFF09\u6216\u6700\u4F73\u53EF\u80FD\uFF08Best Case\uFF09\u7684\u8FDB\u884C\u4E2D\u5546\u673A\u3002\u5F53\u524D\u6CA1\u6709\u7B26\u5408\u6761\u4EF6\u7684\u8BB0\u5F55\u2014\u2014\u9884\u8BA1\u6210\u4EA4\u65E5\u671F\u66F4\u665A\u7684\u5546\u673A\u8BF7\u89C1\u201C\u8FDB\u884C\u4E2D\u5546\u673A\u201D\u6807\u7B7E\u9875\u3002" + } + } + }, + _sections: { + // Object-level section keys (opportunity.object.ts), used by record forms + // and by the detail page, whose sections reference these groups (#1452) + crm_forecast: { label: "\u9636\u6BB5\u4E0E\u9884\u6D4B" }, + basic: { label: "\u57FA\u672C\u4FE1\u606F" }, + financials: { label: "\u8D22\u52A1\u4FE1\u606F" }, + sales_process: { label: "\u9500\u552E\u6D41\u7A0B" }, + classification: { label: "\u5206\u7C7B" }, + campaign: { label: "\u8425\u9500\u6D3B\u52A8" }, + notes: { label: "\u5907\u6CE8\u4E0E\u4E0B\u4E00\u6B65" }, + qualification: { label: "\u8D44\u683C\u8BC4\u4F30" }, + narrative: { label: "\u5546\u673A\u53D9\u8FF0" }, + // opportunity.view.ts 表单区块名称 (#1100) + overview: { label: "\u6982\u89C8" }, + forecast: { label: "\u9884\u6D4B" }, + sales_strategy: { label: "\u9500\u552E\u7B56\u7565" }, + win_loss: { label: "\u8D62\u5355/\u8F93\u5355" } + }, + _actions: { + ...activityActions2, + clone_opportunity: { + label: "\u514B\u9686\u5546\u673A", + successMessage: "\u5546\u673A\u514B\u9686\u6210\u529F\uFF01" + }, + generate_quote: { + label: "\u751F\u6210\u62A5\u4EF7\u5355", + successMessage: "\u5DF2\u6839\u636E\u5546\u673A\u521B\u5EFA\u62A5\u4EF7\u5355\uFF01" + }, + mass_update_stage: { + label: "\u66F4\u65B0\u9636\u6BB5", + successMessage: "\u5546\u673A\u9636\u6BB5\u5DF2\u66F4\u65B0\uFF01", + params: { + stage: { + label: "\u65B0\u9636\u6BB5", + options: { + prospecting: "\u5BFB\u627E\u5BA2\u6237", + qualification: "\u8D44\u683C\u5BA1\u67E5", + needs_analysis: "\u9700\u6C42\u5206\u6790", + proposal: "\u63D0\u6848", + negotiation: "\u8C08\u5224", + closed_won: "\u6210\u4EA4", + closed_lost: "\u5931\u8D25" + } + } + } + } + } + }, + crm_opportunity_line_item: { + _validations: { + unit_price_positive: { + message: "\u9500\u552E\u4EF7\u683C\u4E0D\u80FD\u4E3A\u8D1F\u6570" + } + }, + label: "\u5546\u673A\u4EA7\u54C1\u660E\u7EC6", + pluralLabel: "\u5546\u673A\u4EA7\u54C1\u660E\u7EC6", + description: "\u5546\u673A\u4E0B\u6309\u4EA7\u54C1\u62C6\u5206\u7684\u62A5\u4EF7\u884C", + fields: { + crm_opportunity: { label: "\u5173\u8054\u5546\u673A" }, + crm_product: { label: "\u4EA7\u54C1" }, + description: { label: "\u63CF\u8FF0" }, + quantity: { label: "\u6570\u91CF" }, + list_price: { label: "\u6807\u4EF7", help: "\u81EA\u52A8\u53D6\u81EA\u4EA7\u54C1\u7684\u76EE\u5F55\u4EF7" }, + unit_price: { label: "\u9500\u552E\u5355\u4EF7", help: "\u534F\u5546\u540E\u7684\u5355\u4EF7\uFF08\u53EF\u4E0E\u76EE\u5F55\u4EF7\u4E0D\u540C\uFF09" }, + discount: { label: "\u6298\u6263\uFF08%\uFF09" }, + total_price: { label: "\u603B\u8BA1" }, + line_number: { label: "\u884C\u53F7" } + }, + _sections: { + basic: { label: "\u660E\u7EC6\u884C" }, + pricing: { label: "\u4EF7\u683C" } + } + }, + crm_forecast: { + _validations: { + period_end_after_start: { + message: "\u5468\u671F\u7ED3\u675F\u5FC5\u987B\u665A\u4E8E\u5468\u671F\u5F00\u59CB\u3002" + }, + period_end_matches_calendar_period: { + message: "\u5468\u671F\u7ED3\u675F\u5FC5\u987B\u662F\u8BE5\u5468\u671F\u7684\u6700\u540E\u4E00\u5929\u2014\u2014\u4F8B\u5982\u4EE5 2026-07-01 \u5F00\u59CB\u7684\u5B63\u5EA6\u5BF9\u5E94 2026-09-30\uFF0C2026 \u5E74 8 \u6708\u5BF9\u5E94 2026-08-31\u3002" + }, + period_start_first_of_period: { + message: "\u5468\u671F\u5F00\u59CB\u5FC5\u987B\u662F\u8BE5\u5468\u671F\u7684\u7B2C\u4E00\u5929\u2014\u2014\u4F8B\u5982 2026 \u5E74 8 \u6708\u5BF9\u5E94 2026-08-01\u3002" + }, + quarter_starts_on_quarter_boundary: { + message: "\u5B63\u5EA6\u9884\u6D4B\u5FC5\u987B\u4ECE\u5B63\u5EA6\u8FB9\u754C\u5F00\u59CB\u2014\u20141 \u6708 1 \u65E5\u30014 \u6708 1 \u65E5\u30017 \u6708 1 \u65E5\u6216 10 \u6708 1 \u65E5\u3002" + }, + snapshot_amounts_non_negative: { + message: "\u5FEB\u7167\u91D1\u989D\u4E0D\u80FD\u4E3A\u8D1F\u6570\u3002" + } + }, + label: "\u9500\u552E\u9884\u6D4B", + pluralLabel: "\u9500\u552E\u9884\u6D4B", + description: "\u6309\u9500\u552E\u8D1F\u8D23\u4EBA\u5B9A\u671F\u8BB0\u5F55\u7684\u7BA1\u9053\u5FEB\u7167\uFF0C\u7528\u4E8E\u6536\u5165\u9884\u6D4B", + fields: { + owner_id: { label: "\u8D1F\u8D23\u4EBA" }, + period: { label: "\u5468\u671F", options: { month: "\u6708\u5EA6", quarter: "\u5B63\u5EA6" } }, + period_start: { + label: "\u5468\u671F\u8D77\u59CB", + help: "\u5FC5\u987B\u662F\u6240\u5728\u5468\u671F\u7684\u7B2C\u4E00\u5929\u2014\u2014\u4F8B\u5982 2026 \u5E74 8 \u6708\u5BF9\u5E94 2026-08-01\u3002\u5B63\u5EA6\u9884\u6D4B\u8FD8\u5FC5\u987B\u843D\u5728\u5B63\u5EA6\u8FB9\u754C\u4E0A\uFF1A1 \u6708 1 \u65E5\u30014 \u6708 1 \u65E5\u30017 \u6708 1 \u65E5\u6216 10 \u6708 1 \u65E5\u3002" + }, + period_end: { + label: "\u5468\u671F\u622A\u6B62", + help: '\u901A\u5E38\u6839\u636E"\u5468\u671F"\u548C"\u5468\u671F\u8D77\u59CB"\u81EA\u52A8\u63A8\u7B97\u3002\u5982\u624B\u52A8\u586B\u5199\uFF0C\u5FC5\u987B\u662F\u8BE5\u5468\u671F\u7684\u6700\u540E\u4E00\u5929\u2014\u2014\u4F8B\u5982\u8D77\u59CB\u4E3A 2026-07-01 \u7684\u5B63\u5EA6\u5BF9\u5E94 2026-09-30\uFF0C2026 \u5E74 8 \u6708\u5BF9\u5E94 2026-08-31\u3002' + }, + period_label: { label: "\u5468\u671F\u6807\u7B7E", help: '\u6613\u8BFB\u7684\u5468\u671F\u6807\u7B7E\uFF0C\u4F8B\u5982"2026 \u5E74\u7B2C\u4E09\u5B63\u5EA6"\u6216"2026 \u5E74 8 \u6708"\u3002' }, + snapshot_date: { label: "\u5FEB\u7167\u65E5\u671F", help: "\u672C\u6B21\u5FEB\u7167\u7684\u91C7\u96C6\u65E5\u671F\u3002" }, + source: { + label: "\u6765\u6E90", + options: { scheduled: "\u5B9A\u65F6\u5FEB\u7167", ai: "AI \u6280\u80FD", manual: "\u624B\u5DE5\u5F55\u5165" } + }, + quota: { label: "\u914D\u989D" }, + pipeline_amount: { label: "\u7BA1\u9053\u91D1\u989D", help: "\u672C\u5468\u671F\u5185\u6240\u6709\u9884\u8BA1\u7ED3\u5355\u7684\u8FDB\u884C\u4E2D\u5546\u673A\u91D1\u989D\u5408\u8BA1\uFF08\u4E0D\u9650\u9636\u6BB5\uFF09\u3002" }, + best_case_amount: { label: "\u6700\u4F73\u60C5\u51B5", help: '\u9884\u6D4B\u7C7B\u522B\u4E3A"\u6700\u4F73\u60C5\u51B5"\u6216"\u627F\u8BFA"\u7684\u8FDB\u884C\u4E2D\u5546\u673A\u3002' }, + commit_amount: { label: "\u627F\u8BFA\u91D1\u989D", help: '\u9884\u6D4B\u7C7B\u522B\u4E3A"\u627F\u8BFA"\u7684\u8FDB\u884C\u4E2D\u5546\u673A\uFF08\u8D1F\u8D23\u4EBA\u5DF2\u627F\u8BFA\uFF09\u3002' }, + closed_amount: { label: "\u5DF2\u6210\u4EA4\u91D1\u989D", help: "\u672C\u5468\u671F\u5185\u5DF2\u8D62\u5355\u7684\u91D1\u989D\u3002" }, + expected_amount: { label: "\u9884\u671F\u91D1\u989D", help: "\u5DF2\u6210\u4EA4 + \u627F\u8BFA\u2014\u2014\u8D1F\u8D23\u4EBA\u5408\u7406\u9884\u671F\u80FD\u62FF\u4E0B\u7684\u91D1\u989D\u3002" }, + attainment_pct: { label: "\u8FBE\u6210\u7387\uFF08%\uFF09", help: "\u5DF2\u6210\u4EA4 \xF7 \u914D\u989D \xD7 100\u3002\u914D\u989D\u4E3A\u6B63\u6570\u4E4B\u524D\u663E\u793A 0%\u3002" }, + coverage_ratio: { label: "\u8986\u76D6\u500D\u6570", help: "\u7BA1\u9053\u91D1\u989D \xF7\uFF08\u914D\u989D \u2212 \u5DF2\u6210\u4EA4\uFF09\u2014\u2014\u5224\u65AD\u5269\u4F59\u7F3A\u53E3\u662F\u5426\u6709\u8DB3\u591F\u7BA1\u9053\u8986\u76D6\u3002\u914D\u989D\u5DF2\u8FBE\u6210\u65F6\u663E\u793A 0\u3002" }, + notes: { label: "\u5907\u6CE8" }, + display_title: { label: "\u663E\u793A\u540D\u79F0" }, + seed_key: { label: "\u79CD\u5B50\u6807\u8BC6", help: "\u6F14\u793A\u6570\u636E\u6807\u8BC6\u3002\u4EC5\u7531\u79CD\u5B50\u52A0\u8F7D\u5668\u5199\u5165\uFF1B\u771F\u5B9E\u5FEB\u7167\u4E0A\u59CB\u7EC8\u4E3A\u7A7A\u3002" } + }, + _views: { + all_forecasts: { label: "\u5168\u90E8\u9884\u6D4B" }, + this_quarter_forecasts: { + label: "\u672C\u5B63\u5EA6", + emptyState: { + title: "\u672C\u5B63\u5EA6\u5C1A\u65E0\u5FEB\u7167", + message: "\u5B63\u5EA6\u5FEB\u7167\u7531\u6BCF\u665A\u7684\u9884\u6D4B\u626B\u63CF\u4EFB\u52A1\u5199\u5165\u3002\u5728\u5B83\u4E3A\u5F53\u524D\u5B63\u5EA6\u9996\u6B21\u8DD1\u5B8C\u4E4B\u524D\uFF0C\u672C\u89C6\u56FE\u4E3A\u7A7A\u2014\u2014\u5DF2\u7ED3\u675F\u7684\u5B63\u5EA6\u8BF7\u89C1\u201C\u5168\u90E8\u201D\u6807\u7B7E\u9875\u3002" + } + }, + my_forecast: { label: "\u6211\u7684\u9884\u6D4B" } + }, + _sections: { + basic: { label: "\u5FEB\u7167" }, + amounts: { label: "\u91D1\u989D" }, + meta: { label: "\u6765\u6E90" }, + // forecast.view.ts 表单区块名称 (#1100) + snapshot: { label: "\u5FEB\u7167" }, + notes: { label: "\u5907\u6CE8" } + } + } +}; + +// src/sales/translations/zh-CN/objects.commerce.ts +var commerce2 = { + crm_quote: { + _validations: { + discount_within_ceiling: { + message: "\u6298\u6263\u4E0D\u80FD\u8D85\u8FC7 60%" + }, + expiration_after_quote: { + message: "\u5931\u6548\u65E5\u671F\u5FC5\u987B\u665A\u4E8E\u62A5\u4EF7\u65E5\u671F" + }, + quote_status_progression: { + message: "\u65E0\u6548\u7684\u62A5\u4EF7\u5355\u72B6\u6001\u6D41\u8F6C" + } + }, + label: "\u62A5\u4EF7\u5355", + pluralLabel: "\u62A5\u4EF7\u5355", + description: "\u53D1\u9001\u7ED9\u5BA2\u6237\u7684\u4EF7\u683C\u62A5\u4EF7", + fields: { + quote_number: { label: "\u62A5\u4EF7\u5355\u7F16\u53F7" }, + name: { label: "\u62A5\u4EF7\u540D\u79F0" }, + crm_account: { label: "\u6240\u5C5E\u5BA2\u6237" }, + crm_opportunity: { label: "\u5173\u8054\u5546\u673A" }, + status: { + label: "\u72B6\u6001", + options: { + draft: "\u8349\u7A3F", + in_review: "\u5BA1\u6838\u4E2D", + presented: "\u5DF2\u63D0\u4EA4", + accepted: "\u5DF2\u63A5\u53D7", + rejected: "\u5DF2\u62D2\u7EDD", + expired: "\u5DF2\u8FC7\u671F" + } + }, + total_price: { label: "\u603B\u91D1\u989D" }, + discount: { label: "\u6298\u6263 (%)" }, + expiration_date: { label: "\u5230\u671F\u65E5\u671F" }, + description: { label: "\u63CF\u8FF0" }, + crm_contact: { + label: "\u8054\u7CFB\u4EBA", + help: "\u62A5\u4EF7\u8FDB\u5165\u300C\u5DF2\u63D0\u4EA4\u300D\u6216\u300C\u5DF2\u63A5\u53D7\u300D\u540E\u5FC5\u586B \u2014\u2014 \u8D77\u8349\u7684\u5408\u540C\u4ECE\u8FD9\u91CC\u53D6\u4E3B\u8981\u8054\u7CFB\u4EBA\u3002" + }, + owner_id: { label: "\u62A5\u4EF7\u8D1F\u8D23\u4EBA" }, + quote_date: { label: "\u62A5\u4EF7\u65E5\u671F" }, + subtotal: { label: "\u5C0F\u8BA1" }, + discount_amount: { label: "\u6298\u6263\u91D1\u989D" }, + tax: { label: "\u7A0E\u989D" }, + shipping_handling: { label: "\u8FD0\u8D39\u53CA\u624B\u7EED\u8D39" }, + payment_terms: { + label: "\u4ED8\u6B3E\u6761\u6B3E", + options: { + net_15: "15 \u5929\u8D26\u671F", + net_30: "30 \u5929\u8D26\u671F", + net_60: "60 \u5929\u8D26\u671F", + net_90: "90 \u5929\u8D26\u671F", + due_on_receipt: "\u8D27\u5230\u4ED8\u6B3E" + } + }, + shipping_terms: { label: "\u8FD0\u8F93\u6761\u6B3E" }, + billing_address: { label: "\u8D26\u5355\u5730\u5740" }, + shipping_address: { label: "\u6536\u8D27\u5730\u5740" }, + internal_notes: { label: "\u5185\u90E8\u5907\u6CE8" }, + display_title: { label: "\u663E\u793A\u540D\u79F0" } + }, + _views: { + all_quotes: { label: "\u5168\u90E8\u62A5\u4EF7\u5355" }, + quote_pipeline: { label: "\u62A5\u4EF7\u6D41\u6C34\u7EBF" }, + quote_calendar: { label: "\u62A5\u4EF7\u65E5\u5386" } + }, + _sections: { + basic: { label: "\u62A5\u4EF7\u4FE1\u606F" }, + pricing: { label: "\u4EF7\u683C" }, + terms: { label: "\u6761\u6B3E\u4E0E\u6709\u6548\u671F" }, + address: { label: "\u5730\u5740" }, + system: { label: "\u7CFB\u7EDF" }, + // quote.view.ts 表单区块名称 (#1100) + quote: { label: "\u62A5\u4EF7\u5355" }, + totals: { label: "\u5408\u8BA1" }, + quote_terms: { label: "\u6761\u6B3E" }, + addresses_and_notes: { label: "\u5730\u5740\u4E0E\u5907\u6CE8" } + } + }, + crm_quote_line_item: { + _validations: { + discount_within_ceiling: { + message: "\u884C\u6298\u6263\u4E0D\u80FD\u8D85\u8FC7 60%" + }, + unit_price_positive: { + message: "\u9500\u552E\u4EF7\u683C\u4E0D\u80FD\u4E3A\u8D1F\u6570" + } + }, + label: "\u62A5\u4EF7\u5355\u660E\u7EC6", + pluralLabel: "\u62A5\u4EF7\u5355\u660E\u7EC6", + description: "\u62A5\u4EF7\u5355\u4E0B\u6309\u4EA7\u54C1\u62C6\u5206\u7684\u62A5\u4EF7\u884C", + fields: { + crm_quote: { label: "\u5173\u8054\u62A5\u4EF7\u5355" }, + crm_product: { label: "\u4EA7\u54C1" }, + description: { label: "\u63CF\u8FF0" }, + quantity: { label: "\u6570\u91CF" }, + list_price: { label: "\u6807\u4EF7" }, + unit_price: { label: "\u9500\u552E\u5355\u4EF7" }, + discount: { label: "\u6298\u6263\uFF08%\uFF09" }, + subtotal: { label: "\u5C0F\u8BA1" }, + total_price: { label: "\u603B\u8BA1" }, + line_number: { label: "\u884C\u53F7" } + }, + _sections: { + basic: { label: "\u660E\u7EC6\u884C" }, + pricing: { label: "\u4EF7\u683C" } + } + }, + crm_contract: { + _validations: { + end_after_start: { + message: "\u7ED3\u675F\u65E5\u671F\u5FC5\u987B\u665A\u4E8E\u5F00\u59CB\u65E5\u671F" + }, + contract_status_progression: { + message: "\u65E0\u6548\u7684\u5408\u540C\u72B6\u6001\u6D41\u8F6C" + } + }, + label: "\u5408\u540C", + pluralLabel: "\u5408\u540C", + description: "\u4E0E\u5BA2\u6237\u7B7E\u7F72\u7684\u6CD5\u5F8B\u5408\u540C", + fields: { + contract_number: { label: "\u5408\u540C\u7F16\u53F7" }, + crm_account: { label: "\u6240\u5C5E\u5BA2\u6237" }, + status: { + label: "\u72B6\u6001", + options: { + draft: "\u8349\u7A3F", + in_approval: "\u5BA1\u6279\u4E2D", + activated: "\u5DF2\u6FC0\u6D3B", + expired: "\u5DF2\u8FC7\u671F", + terminated: "\u5DF2\u7EC8\u6B62" + } + }, + start_date: { label: "\u5F00\u59CB\u65E5\u671F" }, + end_date: { label: "\u7ED3\u675F\u65E5\u671F" }, + contract_value: { label: "\u5408\u540C\u91D1\u989D" }, + description: { label: "\u63CF\u8FF0" }, + crm_contact: { label: "\u4E3B\u8981\u8054\u7CFB\u4EBA" }, + crm_opportunity: { label: "\u5173\u8054\u5546\u673A" }, + owner_id: { label: "\u5408\u540C\u8D1F\u8D23\u4EBA" }, + contract_term_months: { label: "\u5408\u540C\u671F\u9650\uFF08\u6708\uFF09" }, + billing_frequency: { + label: "\u8BA1\u8D39\u5468\u671F", + options: { monthly: "\u6309\u6708", quarterly: "\u6309\u5B63\u5EA6", annually: "\u6309\u5E74", one_time: "\u4E00\u6B21\u6027" } + }, + payment_terms: { + label: "\u4ED8\u6B3E\u6761\u6B3E", + options: { + net_15: "15 \u5929\u8D26\u671F", + net_30: "30 \u5929\u8D26\u671F", + net_60: "60 \u5929\u8D26\u671F", + net_90: "90 \u5929\u8D26\u671F", + due_on_receipt: "\u8D27\u5230\u4ED8\u6B3E" + } + }, + auto_renewal: { label: "\u81EA\u52A8\u7EED\u7EA6" }, + renewal_notice_days: { label: "\u7EED\u7EA6\u901A\u77E5\uFF08\u5929\uFF09" }, + contract_type: { + label: "\u5408\u540C\u7C7B\u578B", + options: { + subscription: "\u8BA2\u9605\u5408\u540C", + service: "\u670D\u52A1\u534F\u8BAE", + license: "\u6388\u6743\u8BB8\u53EF", + partnership: "\u5408\u4F5C\u534F\u8BAE", + nda: "\u4FDD\u5BC6\u534F\u8BAE", + msa: "\u4E3B\u670D\u52A1\u534F\u8BAE" + } + }, + signed_date: { label: "\u7B7E\u7F72\u65E5\u671F" }, + signed_by: { label: "\u7B7E\u7F72\u4EBA" }, + document_url: { label: "\u5408\u540C\u6587\u6863" }, + special_terms: { label: "\u7279\u6B8A\u6761\u6B3E" }, + billing_address: { label: "\u8D26\u5355\u5730\u5740" } + }, + _views: { + all_contracts: { label: "\u5168\u90E8\u5408\u540C" }, + renewal_calendar: { label: "\u7EED\u7EA6\u65E5\u5386" }, + contract_gantt: { label: "\u5408\u540C\u6761\u6B3E" }, + contract_timeline: { label: "\u5408\u540C\u65F6\u95F4\u7EBF" } + }, + _sections: { + basic: { label: "\u5408\u540C\u4FE1\u606F" }, + parties: { label: "\u7B7E\u7EA6\u65B9" }, + terms: { label: "\u6761\u6B3E\u4E0E\u65E5\u671F" }, + value: { label: "\u5408\u540C\u91D1\u989D" }, + status: { label: "\u72B6\u6001\u4E0E\u5BA1\u6279" }, + renewal: { label: "\u7EED\u7EA6" }, + // contract.view.ts 表单区块名称 (#1100) + contract_terms: { label: "\u6761\u6B3E" }, + signing_and_documents: { label: "\u7B7E\u7F72\u4E0E\u6587\u4EF6" }, + notes: { label: "\u5907\u6CE8" } + } + }, + crm_product: { + _validations: { + cost_less_than_price: { + message: "\u6210\u672C\u5E94\u4F4E\u4E8E\u6807\u4EF7" + }, + price_positive: { + message: "\u6807\u4EF7\u5FC5\u987B\u4E3A\u6B63\u6570" + } + }, + label: "\u4EA7\u54C1", + pluralLabel: "\u4EA7\u54C1", + description: "\u516C\u53F8\u63D0\u4F9B\u7684\u4EA7\u54C1\u4E0E\u670D\u52A1", + fields: { + product_code: { label: "\u4EA7\u54C1\u4EE3\u7801" }, + name: { label: "\u4EA7\u54C1\u540D\u79F0" }, + category: { + label: "\u4EA7\u54C1\u7C7B\u522B", + options: { + software: "\u8F6F\u4EF6", + hardware: "\u786C\u4EF6", + service: "\u670D\u52A1", + subscription: "\u8BA2\u9605", + support: "\u652F\u6301\u670D\u52A1" + } + }, + cost: { label: "\u6210\u672C" }, + is_active: { label: "\u662F\u5426\u542F\u7528" }, + description: { label: "\u63CF\u8FF0" }, + family: { + label: "\u4EA7\u54C1\u7CFB\u5217", + options: { + enterprise: "\u4F01\u4E1A\u7EA7\u65B9\u6848", + smb: "\u4E2D\u5C0F\u4F01\u4E1A\u65B9\u6848", + services: "\u4E13\u4E1A\u670D\u52A1", + cloud: "\u4E91\u670D\u52A1" + } + }, + list_price: { label: "\u6807\u4EF7" }, + sku: { label: "SKU" }, + product_manager: { label: "\u4EA7\u54C1\u7ECF\u7406" }, + image: { label: "\u4EA7\u54C1\u56FE\u7247" }, + datasheet: { label: "\u89C4\u683C\u4E66" }, + display_title: { label: "\u663E\u793A\u540D\u79F0" } + }, + _views: { + all_products: { label: "\u5168\u90E8\u4EA7\u54C1" }, + product_catalog: { label: "\u4EA7\u54C1\u76EE\u5F55" } + }, + _sections: { + basic: { label: "\u4EA7\u54C1\u4FE1\u606F" }, + pricing: { label: "\u4EF7\u683C" }, + metadata: { label: "\u8D44\u6E90" }, + // product.view.ts 表单区块名称 (#1100) + product_info: { label: "\u4EA7\u54C1\u4FE1\u606F" }, + pricing_info: { label: "\u5B9A\u4EF7" }, + media: { label: "\u5A92\u4F53" } + } + } +}; + +// src/sales/translations/zh-CN/objects.service.ts +var service2 = { + crm_case: { + _validations: { + resolution_required_for_closed: { + message: "\u5173\u95ED\u5DE5\u5355\u65F6\u5FC5\u987B\u586B\u5199\u89E3\u51B3\u65B9\u6848" + }, + escalation_reason_required: { + message: "\u5347\u7EA7\u5DE5\u5355\u65F6\u5FC5\u987B\u586B\u5199\u5347\u7EA7\u539F\u56E0" + }, + case_status_progression: { + message: "\u65E0\u6548\u7684\u72B6\u6001\u6D41\u8F6C" + } + }, + label: "\u5DE5\u5355", + pluralLabel: "\u5DE5\u5355", + description: "\u5BA2\u6237\u652F\u6301\u5DE5\u5355\u4E0E\u670D\u52A1\u8BF7\u6C42", + fields: { + case_number: { label: "\u5DE5\u5355\u7F16\u53F7" }, + subject: { label: "\u4E3B\u9898" }, + description: { label: "\u63CF\u8FF0" }, + crm_account: { label: "\u6240\u5C5E\u5BA2\u6237" }, + crm_contact: { label: "\u8054\u7CFB\u4EBA" }, + status: { + label: "\u72B6\u6001", + options: { + new: "\u65B0\u5EFA", + in_progress: "\u5904\u7406\u4E2D", + waiting_customer: "\u7B49\u5F85\u5BA2\u6237\u56DE\u590D", + waiting_support: "\u7B49\u5F85\u652F\u6301\u56DE\u590D", + escalated: "\u5DF2\u5347\u7EA7", + resolved: "\u5DF2\u89E3\u51B3", + closed: "\u5DF2\u5173\u95ED" + } + }, + priority: { + // `critical` MUST NOT render 紧急 — that word belongs to + // `crm_task.priority.urgent`, and the two vocabularies are different + // sets (case: low/medium/high/critical · task: low/normal/high/urgent). + // When both rendered 紧急 the screen showed one word for two values the + // model treats as distinct, which is how a case value ends up in a task + // predicate (`src/sales/views/task.view.ts` carries the tombstone of that + // crossing). Maintainer ruling 2026-08-31, #1342: case `critical` is + // 严重, task `urgent` keeps 紧急. en/es-ES/ja-JP already separate them + // (Critical/Urgent · Crítica/Urgente · 重大/緊急); zh-CN was the outlier. + label: "\u4F18\u5148\u7EA7", + options: { low: "\u4F4E", medium: "\u4E2D", high: "\u9AD8", critical: "\u4E25\u91CD" } + }, + type: { + label: "\u7C7B\u578B", + options: { + question: "\u54A8\u8BE2", + problem: "\u6545\u969C", + feature_request: "\u529F\u80FD\u9700\u6C42", + bug: "\u7F3A\u9677" + } + }, + owner_id: { label: "\u8D1F\u8D23\u4EBA" }, + origin: { + label: "\u5DE5\u5355\u6765\u6E90", + options: { email: "\u90AE\u4EF6", phone: "\u7535\u8BDD", web: "\u7F51\u7AD9", chat: "\u5728\u7EBF\u5BA2\u670D", social_media: "\u793E\u4EA4\u5A92\u4F53" } + }, + closed_date: { label: "\u5173\u95ED\u65E5\u671F" }, + first_response_date: { label: "\u9996\u6B21\u54CD\u5E94\u65E5\u671F" }, + resolution_time_hours: { label: "\u89E3\u51B3\u8017\u65F6\uFF08\u5C0F\u65F6\uFF09" }, + sla_due_date: { label: "SLA \u5230\u671F", help: "\u6309\u5DE5\u5355\u4F18\u5148\u7EA7\u4E0E\u6240\u5C5E\u5BA2\u6237\u7684\u5BA2\u6237\u5206\u5C42\u8BBE\u5B9A\uFF0C\u4EE5\u65E5\u5386\u5C0F\u65F6\u8BA1\uFF1A\u591C\u95F4\u3001\u5468\u672B\u4E0E\u8282\u5047\u65E5\u90FD\u8BA1\u5165\u3002" }, + is_sla_violated: { label: "SLA \u8FDD\u53CD" }, + is_escalated: { label: "\u5DF2\u5347\u7EA7" }, + escalation_reason: { label: "\u5347\u7EA7\u539F\u56E0" }, + resolution: { label: "\u89E3\u51B3\u65B9\u6848" }, + resolved_by_article: { label: "\u89E3\u51B3\u8BE5\u5DE5\u5355\u7684\u77E5\u8BC6\u6587\u7AE0", help: "\u89E3\u51B3\u6B64\u5DE5\u5355\u7684\u77E5\u8BC6\u5E93\u6587\u7AE0 \u2014\u2014 \u8F6C\u79FB\u7387\u7684\u7EDF\u8BA1\u53E3\u5F84\u3002" }, + internal_notes: { label: "\u5185\u90E8\u5907\u6CE8", help: "\u5185\u90E8\u5907\u6CE8\uFF0C\u5BA2\u6237\u4E0D\u53EF\u89C1" }, + is_closed: { label: "\u662F\u5426\u5173\u95ED" }, + display_title: { label: "\u663E\u793A\u540D\u79F0" }, + priority_rank: { label: "\u4F18\u5148\u7EA7\u6392\u5E8F" }, + escalated_date: { label: "\u5347\u7EA7\u65E5\u671F" } + }, + _views: { + all_cases: { label: "\u5168\u90E8\u5DE5\u5355" }, + case_workflow: { label: "\u670D\u52A1\u6D41\u8F6C" }, + sla_calendar: { label: "SLA \u65E5\u5386" }, + case_timeline: { label: "\u5DE5\u5355\u65F6\u95F4\u7EBF" }, + unassigned_triage: { + label: "\u672A\u5206\u6D3E \u2014 \u5F85\u5206\u8BCA", + emptyState: { + title: "\u6CA1\u6709\u5F85\u5206\u8BCA\u7684\u5DE5\u5355", + message: "\u6240\u6709\u5DE5\u5355\u90FD\u6709\u8D1F\u8D23\u4EBA\u3002\u5F53\u5DE5\u5355\u5230\u8FBE\u65F6\u6CA1\u6709\u8D1F\u8D23\u4EBA\uFF0C\u5C31\u4F1A\u51FA\u73B0\u5728\u8FD9\u91CC \u2014\u2014 \u901A\u5E38\u662F\u5728\u65E0\u4EBA\u62C5\u4EFB\u300C\u5BA2\u670D\u4E13\u5458\u300D\u804C\u4F4D\u671F\u95F4\u63D0\u4EA4\u7684\u7F51\u9875\u8F6C\u5DE5\u5355\u3002" + } + }, + escalated_cases: { label: "\u5DF2\u5347\u7EA7\u5DE5\u5355" }, + my_open_cases: { label: "\u6211\u7684\u5F85\u5904\u7406\u5DE5\u5355" }, + sla_at_risk: { label: "\u23F0 SLA \u98CE\u9669\u9884\u8B66" } + }, + _actions: { + ...activityActions2, + escalate_case: { + label: "\u5347\u7EA7\u5DE5\u5355", + confirmText: "\u6B64\u64CD\u4F5C\u4F1A\u5C06\u5DE5\u5355\u5347\u7EA7\u5230\u5347\u7EA7\u5904\u7406\u56E2\u961F\uFF0C\u662F\u5426\u7EE7\u7EED\uFF1F", + successMessage: "\u5DE5\u5355\u5347\u7EA7\u6210\u529F\uFF01" + }, + close_case: { + label: "\u5173\u95ED\u5DE5\u5355", + confirmText: "\u786E\u5B9A\u8981\u5173\u95ED\u6B64\u5DE5\u5355\u5417\uFF1F", + successMessage: "\u5DE5\u5355\u5DF2\u6210\u529F\u5173\u95ED\uFF01" + }, + claim_case: { + label: "\u8BA4\u9886\u5DE5\u5355", + successMessage: "\u5DE5\u5355\u5DF2\u8BA4\u9886\uFF0C\u73B0\u5728\u5F52\u4F60\u8D1F\u8D23\u3002" + } + }, + _sections: { + // case.view.ts 表单区块名称 (#1100)。 + case: { label: "\u5DE5\u5355" }, + how_can_we_help: { label: "\u6211\u4EEC\u80FD\u5E2E\u60A8\u4EC0\u4E48\uFF1F" }, + // Object-level section keys (case.object.ts), used by record forms and + // by the detail page, whose sections reference these groups (#970) + basic: { label: "\u5DE5\u5355\u4FE1\u606F" }, + origin: { label: "\u6765\u6E90\u4E0E\u8DEF\u7531" }, + sla: { label: "SLA \u4E0E\u4F18\u5148\u7EA7" }, + resolution: { label: "\u89E3\u51B3\u65B9\u6848" }, + escalation: { label: "\u5347\u7EA7" }, + system: { label: "\u7CFB\u7EDF" } + } + }, + crm_knowledge_article: { + _validations: { + published_requires_body: { + message: "\u6CA1\u6709\u6B63\u6587\u7684\u6587\u7AE0\u65E0\u6CD5\u53D1\u5E03\u3002" + }, + published_requires_summary: { + message: "\u5DF2\u53D1\u5E03\u7684\u6587\u7AE0\u5E94\u586B\u5199\u6458\u8981\uFF0C\u4F9B\u641C\u7D22\u7ED3\u679C\u4E0E AI \u5F15\u7528\u4F7F\u7528\u3002" + } + }, + label: "\u77E5\u8BC6\u6587\u7AE0", + pluralLabel: "\u77E5\u8BC6\u5E93", + description: "\u9762\u5411\u5BA2\u6237\u548C\u5750\u5E2D\u7684\u53EF\u590D\u7528\u95EE\u7B54\u4E0E\u64CD\u4F5C\u6307\u5357", + fields: { + article_number: { label: "\u6587\u7AE0\u7F16\u53F7" }, + title: { label: "\u6807\u9898" }, + summary: { label: "\u6458\u8981", help: "\u4E00\u6BB5\u8BDD\u6458\u8981\uFF0C\u663E\u793A\u5728\u641C\u7D22\u7ED3\u679C\u548C AI \u5F15\u7528\u4E2D\u3002" }, + body: { label: "\u6B63\u6587", help: "\u6587\u7AE0\u6B63\u6587\uFF08Markdown\uFF09\u3002" }, + category: { + label: "\u5206\u7C7B", + options: { + getting_started: "\u5165\u95E8\u6307\u5357", + how_to: "\u64CD\u4F5C\u6307\u5357", + troubleshooting: "\u6545\u969C\u6392\u67E5", + billing: "\u8D26\u52A1\u4E0E\u4EF7\u683C", + api: "API \u4E0E\u96C6\u6210", + release_notes: "\u7248\u672C\u8BF4\u660E", + policy: "\u653F\u7B56\u5236\u5EA6" + } + }, + tags: { + label: "\u6807\u7B7E", + options: { + auth: "\u8EAB\u4EFD\u8BA4\u8BC1", + sso: "\u5355\u70B9\u767B\u5F55", + mobile: "\u79FB\u52A8\u7AEF", + email: "\u90AE\u4EF6", + reports: "\u62A5\u8868", + performance: "\u6027\u80FD", + data_import: "\u6570\u636E\u5BFC\u5165", + webhooks: "Webhook" + } + }, + status: { + label: "\u72B6\u6001", + options: { draft: "\u8349\u7A3F", in_review: "\u5BA1\u6838\u4E2D", published: "\u5DF2\u53D1\u5E03", archived: "\u5DF2\u5F52\u6863" } + }, + audience: { label: "\u53D7\u4F17", options: { public: "\u516C\u5F00", internal: "\u4EC5\u5185\u90E8" }, help: "\u516C\u5F00\u6587\u7AE0\u5728\u5BA2\u6237\u95E8\u6237\u53EF\u89C1\uFF1B\u5185\u90E8\u6587\u7AE0\u4EC5\u5BA2\u670D\u53EF\u89C1\u3002" }, + language: { + label: "\u8BED\u8A00", + options: { en: "\u82F1\u8BED", zh_cn: "\u7B80\u4F53\u4E2D\u6587", es_es: "\u897F\u73ED\u7259\u8BED", ja_jp: "\u65E5\u8BED" } + }, + owner_id: { label: "\u8D1F\u8D23\u4EBA" }, + related_to_case: { label: "\u6765\u6E90\u5DE5\u5355", help: "\u672C\u6587\u6240\u4F9D\u636E\u7684\u5DE5\u5355\uFF08\u53EF\u9009\uFF09\u3002" }, + published_at: { label: "\u53D1\u5E03\u65F6\u95F4" }, + last_reviewed_at: { label: "\u6700\u8FD1\u590D\u6838" }, + helpful_count: { label: "\u6709\u7528", help: "\u7531 crm_article_feedback \u91CD\u65B0\u7EDF\u8BA1\u5F97\u51FA\uFF0C\u4E0D\u53EF\u624B\u5DE5\u586B\u5199\u3002" }, + not_helpful_count: { label: "\u6CA1\u7528", help: "\u7531 crm_article_feedback \u91CD\u65B0\u7EDF\u8BA1\u5F97\u51FA\uFF0C\u4E0D\u53EF\u624B\u5DE5\u586B\u5199\u3002" }, + display_title: { label: "\u663E\u793A\u540D\u79F0" } + }, + _views: { + all_articles: { label: "\u5168\u90E8\u6587\u7AE0" }, + published_articles: { label: "\u5DF2\u53D1\u5E03" }, + my_drafts: { label: "\u6211\u7684\u8349\u7A3F" } + }, + _sections: { + basic: { label: "\u6587\u7AE0\u4FE1\u606F" }, + content: { label: "\u5185\u5BB9" }, + taxonomy: { label: "\u5206\u7C7B" }, + metrics: { label: "\u4E92\u52A8\u6570\u636E" }, + engagement: { label: "\u4E92\u52A8\u6570\u636E" }, + // knowledge_article.view.ts 表单区块名称 (#1100) + article: { label: "\u6587\u7AE0" } + }, + _actions: { + mark_article_helpful: { + label: "\u6709\u7528", + successMessage: "\u5DF2\u8BB0\u5F55\u4E3A\u300C\u6709\u7528\u300D\uFF0C\u8C22\u8C22\u53CD\u9988\u3002" + }, + mark_article_not_helpful: { + label: "\u6CA1\u7528", + successMessage: "\u5DF2\u8BB0\u5F55\u4E3A\u300C\u6CA1\u7528\u300D\uFF0C\u8C22\u8C22\u53CD\u9988\u3002" + } + } + }, + crm_article_feedback: { + label: "\u6587\u7AE0\u53CD\u9988", + pluralLabel: "\u6587\u7AE0\u53CD\u9988", + description: "\u8BFB\u8005\u5BF9\u67D0\u7BC7\u77E5\u8BC6\u6587\u7AE0\u7684\u300C\u6709\u7528 / \u6CA1\u7528\u300D\u8BC4\u4EF7", + fields: { + feedback_number: { label: "\u53CD\u9988\u7F16\u53F7" }, + owner_id: { label: "\u8BFB\u8005" }, + crm_knowledge_article: { label: "\u6587\u7AE0", help: "\u672C\u6761\u53CD\u9988\u9488\u5BF9\u7684\u77E5\u8BC6\u6587\u7AE0\u3002" }, + verdict: { + label: "\u8BC4\u4EF7", + options: { helpful: "\u6709\u7528", not_helpful: "\u6CA1\u7528" } + }, + comment: { label: "\u5907\u6CE8", help: "\u53EF\u9009\u8BF4\u660E\uFF0C\u4F5C\u8005\u53EF\u89C1\u3002" } + }, + _sections: { + basic: { label: "\u53CD\u9988" } + } + } +}; + +// src/sales/translations/zh-CN/objects.activity.ts +var activity2 = { + crm_task: { + _validations: { + completed_date_required: { + message: "\u72B6\u6001\u4E3A\u5DF2\u5B8C\u6210\u65F6\u5FC5\u987B\u586B\u5199\u5B8C\u6210\u65E5\u671F" + }, + recurrence_fields_required: { + message: "\u91CD\u590D\u4EFB\u52A1\u5FC5\u987B\u586B\u5199\u91CD\u590D\u7C7B\u578B" + }, + related_to_required: { + message: "\u81F3\u5C11\u9700\u8981\u9009\u62E9\u4E00\u6761\u5173\u8054\u8BB0\u5F55" + } + }, + label: "\u4EFB\u52A1", + pluralLabel: "\u4EFB\u52A1", + description: "\u6D3B\u52A8\u4E0E\u5F85\u529E\u4E8B\u9879", + fields: { + subject: { label: "\u4E3B\u9898" }, + description: { label: "\u63CF\u8FF0" }, + status: { + label: "\u72B6\u6001", + options: { + not_started: "\u672A\u5F00\u59CB", + in_progress: "\u8FDB\u884C\u4E2D", + waiting: "\u7B49\u5F85\u4E2D", + completed: "\u5DF2\u5B8C\u6210", + deferred: "\u5DF2\u63A8\u8FDF" + } + }, + priority: { + // `urgent` KEEPS 紧急, and ⛔ nothing may re-point it at `crm_case`'s + // top value: the two vocabularies are different sets (task: + // low/normal/high/urgent · case: low/medium/high/critical), so the two + // zh-CN words must stay different or the screen stops distinguishing + // two values the model treats as distinct — the crossing + // `src/sales/views/task.view.ts` carries the tombstone of. Maintainer ruling + // 2026-08-31, #1342: 紧急 stays here (urgent is this object's literal + // word) and case `critical` moved to 严重. + label: "\u4F18\u5148\u7EA7", + options: { low: "\u4F4E", normal: "\u666E\u901A", high: "\u9AD8", urgent: "\u7D27\u6025" } + }, + due_date: { label: "\u622A\u6B62\u65E5\u671F" }, + type: { + label: "\u4EFB\u52A1\u7C7B\u578B", + options: { + call: "\u7535\u8BDD", + email: "\u90AE\u4EF6", + meeting: "\u4F1A\u8BAE", + follow_up: "\u8DDF\u8FDB", + demo: "\u6F14\u793A", + other: "\u5176\u4ED6" + } + }, + reminder_date: { label: "\u63D0\u9192\u65F6\u95F4" }, + completed_date: { label: "\u5B8C\u6210\u65E5\u671F" }, + owner_id: { label: "\u8D1F\u8D23\u4EBA" }, + related_to_type: { + label: "\u5173\u8054\u5BF9\u8C61\u7C7B\u578B", + options: { + crm_account: "\u5BA2\u6237", + crm_contact: "\u8054\u7CFB\u4EBA", + crm_opportunity: "\u5546\u673A", + crm_lead: "\u7EBF\u7D22", + crm_case: "\u5DE5\u5355" + } + }, + related_to_account: { label: "\u5173\u8054\u5BA2\u6237" }, + related_to_contact: { label: "\u5173\u8054\u8054\u7CFB\u4EBA" }, + related_to_opportunity: { label: "\u5173\u8054\u5546\u673A" }, + related_to_lead: { label: "\u5173\u8054\u7EBF\u7D22" }, + related_to_case: { label: "\u5173\u8054\u5DE5\u5355" }, + is_recurring: { label: "\u91CD\u590D\u4EFB\u52A1" }, + recurrence_type: { + label: "\u91CD\u590D\u7C7B\u578B", + options: { daily: "\u6BCF\u65E5", weekly: "\u6BCF\u5468", monthly: "\u6BCF\u6708", yearly: "\u6BCF\u5E74" } + }, + recurrence_interval: { label: "\u91CD\u590D\u95F4\u9694" }, + recurrence_end_date: { label: "\u91CD\u590D\u7ED3\u675F\u65E5\u671F" }, + is_completed: { label: "\u662F\u5426\u5B8C\u6210" }, + is_overdue: { label: "\u662F\u5426\u903E\u671F" }, + progress_percent: { label: "\u8FDB\u5EA6\uFF08%\uFF09" }, + priority_rank: { label: "\u4F18\u5148\u7EA7\u6392\u5E8F" }, + reminder_sent: { label: "\u63D0\u9192\u5DF2\u53D1\u9001" } + }, + _sections: { + basic: { label: "\u4EFB\u52A1\u4FE1\u606F" }, + scheduling: { label: "\u65E5\u7A0B\u5B89\u6392" }, + related: { label: "\u5173\u8054\u8BB0\u5F55" }, + recurrence: { label: "\u91CD\u590D\u89C4\u5219" }, + system: { label: "\u7CFB\u7EDF" }, + effort: { label: "\u8FDB\u5EA6\u4E0E\u5DE5\u65F6" }, + // task.view.ts 表单区块名称 (#1100) + task: { label: "\u4EFB\u52A1" }, + related_records: { label: "\u5173\u8054\u8BB0\u5F55" }, + recurrence_and_effort: { label: "\u91CD\u590D\u4E0E\u5DE5\u65F6" } + }, + _views: { + all_tasks: { label: "\u5168\u90E8\u4EFB\u52A1" }, + task_board: { label: "\u4EFB\u52A1\u770B\u677F" }, + task_calendar: { label: "\u4EFB\u52A1\u65E5\u7A0B" }, + task_gantt: { label: "\u6267\u884C\u8BA1\u5212" }, + task_timeline: { label: "\u5DE5\u65F6\u65F6\u95F4\u7EBF" }, + my_open_tasks: { label: "\u6211\u7684\u5F85\u529E\u4EFB\u52A1" }, + todays_tasks: { label: "\u{1F4C5} \u6211\u7684\u4F18\u5148\u4EFB\u52A1" }, + overdue_tasks: { label: "\u23F0 \u5F85\u529E\u4EFB\u52A1 \xB7 \u6309\u903E\u671F\u65F6\u957F\u6392\u5E8F" } + } + }, + crm_event: { + _validations: { + end_after_start: { + message: "\u7ED3\u675F\u65F6\u95F4\u5FC5\u987B\u665A\u4E8E\u5F00\u59CB\u65F6\u95F4" + }, + related_to_required: { + message: "\u81F3\u5C11\u9700\u8981\u9009\u62E9\u4E00\u6761\u5173\u8054\u8BB0\u5F55" + } + }, + label: "\u6D3B\u52A8", + pluralLabel: "\u6D3B\u52A8", + description: "\u4E0E\u5BA2\u6237\u7684\u4F1A\u8BAE\u3001\u901A\u8BDD\u53CA\u5176\u4ED6\u5DF2\u5B89\u6392\u7684\u4E92\u52A8", + fields: { + subject: { label: "\u4E3B\u9898" }, + description: { label: "\u63CF\u8FF0" }, + type: { + label: "\u6D3B\u52A8\u7C7B\u578B", + options: { + meeting: "\u4F1A\u8BAE", + call: "\u7535\u8BDD", + demo: "\u6F14\u793A", + webinar: "\u7EBF\u4E0A\u7814\u8BA8\u4F1A", + onsite_visit: "\u4E0A\u95E8\u62DC\u8BBF", + other: "\u5176\u4ED6" + } + }, + status: { + label: "\u72B6\u6001", + options: { + planned: "\u5DF2\u8BA1\u5212", + held: "\u5DF2\u4E3E\u884C", + cancelled: "\u5DF2\u53D6\u6D88", + no_show: "\u5BA2\u6237\u672A\u5230" + } + }, + owner_id: { label: "\u8D1F\u8D23\u4EBA" }, + start_datetime: { label: "\u5F00\u59CB\u65F6\u95F4" }, + end_datetime: { label: "\u7ED3\u675F\u65F6\u95F4" }, + all_day: { label: "\u5168\u5929\u6D3B\u52A8" }, + duration_minutes: { label: "\u65F6\u957F\uFF08\u5206\u949F\uFF09" }, + location: { label: "\u5730\u70B9", help: "\u4F1A\u8BAE\u5BA4\u3001\u5730\u5740\u6216\u4F1A\u8BAE\u94FE\u63A5" }, + related_to_type: { + label: "\u5173\u8054\u5BF9\u8C61\u7C7B\u578B", + options: { + crm_account: "\u5BA2\u6237", + crm_contact: "\u8054\u7CFB\u4EBA", + crm_opportunity: "\u5546\u673A", + crm_lead: "\u7EBF\u7D22", + crm_case: "\u5DE5\u5355" + } + }, + related_to_account: { label: "\u5173\u8054\u5BA2\u6237" }, + related_to_contact: { label: "\u5173\u8054\u8054\u7CFB\u4EBA" }, + related_to_opportunity: { label: "\u5173\u8054\u5546\u673A" }, + related_to_lead: { label: "\u5173\u8054\u7EBF\u7D22" }, + related_to_case: { label: "\u5173\u8054\u5DE5\u5355" }, + outcome_notes: { label: "\u4F1A\u540E\u7EAA\u8981", help: "\u8FBE\u6210\u4E86\u4EC0\u4E48\u5171\u8BC6\uFF0C\u4E0B\u4E00\u6B65\u505A\u4EC0\u4E48" } + }, + _sections: { + basic: { label: "\u6D3B\u52A8\u4FE1\u606F" }, + schedule: { label: "\u65E5\u7A0B\u5B89\u6392" }, + related: { label: "\u5173\u8054\u8BB0\u5F55" }, + outcome: { label: "\u7ED3\u679C" }, + // event.view.ts 表单区块名称 (#1100) + event: { label: "\u6D3B\u52A8" }, + related_records: { label: "\u5173\u8054\u8BB0\u5F55" } + }, + _views: { + all_events: { label: "\u5168\u90E8\u6D3B\u52A8" }, + event_calendar: { label: "\u6D3B\u52A8\u65E5\u5386" }, + event_timeline: { label: "\u56E2\u961F\u65E5\u7A0B" }, + my_events: { label: "\u6211\u7684\u65E5\u5386" }, + upcoming_events: { label: "\u{1F4C5} \u5373\u5C06\u5F00\u59CB \xB7 \u6309\u65F6\u95F4\u5347\u5E8F" }, + held_events: { label: "\u2705 \u4E92\u52A8\u5386\u53F2" } + } + }, + crm_event_attendee: { + _validations: { + attendee_resolves: { + message: "\u53C2\u4E0E\u8005\u5FC5\u987B\u586B\u5199\u5176\u53C2\u4E0E\u8005\u7C7B\u578B\u6240\u6307\u7684\u4E00\u65B9\u2014\u2014\u8054\u7CFB\u4EBA\u7C7B\u578B\u9700\u8981\u586B\u5199\u8054\u7CFB\u4EBA\uFF0C\u5916\u90E8\u7C7B\u578B\u9700\u8981\u586B\u5199\u5916\u90E8\u53C2\u4E0E\u8005\u59D3\u540D" + }, + attendee_type_exclusive: { + message: "\u53C2\u4E0E\u8005\u53EA\u80FD\u6307\u5B9A\u4E00\u65B9\u2014\u2014\u8BF7\u6E05\u7A7A\u5176\u53C2\u4E0E\u8005\u7C7B\u578B\u672A\u6307\u660E\u7684\u6240\u6709\u5B57\u6BB5" + } + }, + label: "\u6D3B\u52A8\u53C2\u4E0E\u8005", + pluralLabel: "\u6D3B\u52A8\u53C2\u4E0E\u8005", + description: "\u53D7\u9080\u53C2\u52A0\u6216\u5B9E\u9645\u51FA\u5E2D\u6D3B\u52A8\u7684\u4EBA\u5458", + fields: { + attendee_number: { label: "\u53C2\u4E0E\u8005\u7F16\u53F7" }, + crm_event: { label: "\u6D3B\u52A8" }, + attendee_type: { + label: "\u53C2\u4E0E\u8005\u7C7B\u578B", + options: { contact: "\u8054\u7CFB\u4EBA", lead: "\u7EBF\u7D22", user: "\u5185\u90E8\u7528\u6237", external: "\u5916\u90E8\u6765\u5BBE" } + }, + crm_contact: { label: "\u8054\u7CFB\u4EBA", help: "\u53C2\u4E0E\u8005\u662F\u5DF2\u6709\u5BA2\u6237\u8054\u7CFB\u4EBA\u65F6\u586B\u5199" }, + crm_lead: { label: "\u7EBF\u7D22", help: "\u53C2\u4E0E\u8005\u4ECD\u662F\u672A\u8F6C\u5316\u7EBF\u7D22\u65F6\u586B\u5199" }, + sys_user: { label: "\u5185\u90E8\u7528\u6237", help: "\u53C2\u4E0E\u8005\u662F\u540C\u4E8B\u65F6\u586B\u5199" }, + external_name: { label: "\u5916\u90E8\u53C2\u4E0E\u8005", help: "\u4E0D\u5728\u4EFB\u4F55 CRM \u5BF9\u8C61\u4E2D\u7684\u53C2\u4E0E\u8005\u59D3\u540D\u2014\u2014\u53C2\u4E0E\u8005\u7C7B\u578B\u4E3A\u300C\u5916\u90E8\u6765\u5BBE\u300D\u65F6\u586B\u5199" }, + response: { + label: "\u56DE\u590D", + options: { + no_response: "\u672A\u56DE\u590D", + accepted: "\u5DF2\u63A5\u53D7", + declined: "\u5DF2\u62D2\u7EDD", + tentative: "\u5F85\u5B9A" + } + }, + is_organizer: { label: "\u7EC4\u7EC7\u8005" }, + invited_date: { label: "\u9080\u8BF7\u65F6\u95F4" } + }, + _sections: { + basic: { label: "\u53C2\u4E0E\u8005" }, + response: { label: "\u9080\u8BF7" }, + // event_attendee.view.ts 表单区块名称 (#1100) + attendee: { label: "\u53C2\u4E0E\u8005" }, + invitation: { label: "\u9080\u8BF7" } + }, + _views: { + all_event_attendees: { label: "\u6D3B\u52A8\u53C2\u4E0E\u8005" } + } + } +}; + +// src/sales/translations/zh-CN/objects.marketing.ts +var marketing2 = { + crm_campaign: { + _validations: { + end_after_start: { + message: "\u7ED3\u675F\u65E5\u671F\u5FC5\u987B\u665A\u4E8E\u5F00\u59CB\u65E5\u671F" + }, + actual_cost_within_budget: { + message: "\u5B9E\u9645\u6210\u672C\u8D85\u51FA\u9884\u7B97\u6210\u672C" + } + }, + label: "\u8425\u9500\u6D3B\u52A8", + pluralLabel: "\u8425\u9500\u6D3B\u52A8", + description: "\u5E02\u573A\u8425\u9500\u6D3B\u52A8\u4E0E\u63A8\u5E7F", + fields: { + campaign_code: { label: "\u6D3B\u52A8\u4EE3\u7801" }, + name: { label: "\u6D3B\u52A8\u540D\u79F0" }, + type: { + label: "\u7C7B\u578B", + options: { + email: "\u90AE\u4EF6\u8425\u9500", + webinar: "\u7EBF\u4E0A\u7814\u8BA8\u4F1A", + trade_show: "\u5C55\u4F1A", + conference: "\u884C\u4E1A\u4F1A\u8BAE", + direct_mail: "\u76F4\u90AE", + social_media: "\u793E\u4EA4\u5A92\u4F53", + content: "\u5185\u5BB9\u8425\u9500", + partner: "\u4F19\u4F34\u8054\u5408\u8425\u9500" + } + }, + status: { + label: "\u72B6\u6001", + options: { + planning: "\u89C4\u5212\u4E2D", + in_progress: "\u8FDB\u884C\u4E2D", + completed: "\u5DF2\u5B8C\u6210", + aborted: "\u5DF2\u4E2D\u6B62" + } + }, + start_date: { label: "\u5F00\u59CB\u65E5\u671F" }, + end_date: { label: "\u7ED3\u675F\u65E5\u671F" }, + expected_revenue: { label: "\u9884\u671F\u6536\u5165" }, + description: { label: "\u63CF\u8FF0" }, + channel: { + label: "\u4E3B\u8981\u6E20\u9053", + options: { digital: "\u6570\u5B57\u6E20\u9053", social: "\u793E\u4EA4\u5A92\u4F53", email: "\u90AE\u4EF6", events: "\u7EBF\u4E0B\u6D3B\u52A8", partner: "\u5408\u4F5C\u4F19\u4F34" } + }, + budgeted_cost: { label: "\u9884\u7B97\u6210\u672C" }, + actual_cost: { label: "\u5B9E\u9645\u6210\u672C" }, + actual_revenue: { label: "\u5B9E\u9645\u6536\u5165" }, + target_size: { label: "\u76EE\u6807\u4EBA\u6570", help: "\u76EE\u6807\u7EBF\u7D22/\u8054\u7CFB\u4EBA\u6570\u91CF" }, + num_sent: { label: "\u53D1\u9001\u6570\u91CF" }, + num_responses: { label: "\u54CD\u5E94\u6570\u91CF" }, + num_leads: { label: "\u7EBF\u7D22\u6570\u91CF" }, + num_converted_leads: { label: "\u5DF2\u8F6C\u5316\u7EBF\u7D22\u6570" }, + num_opportunities: { label: "\u5DF2\u521B\u5EFA\u5546\u673A\u6570" }, + num_won_opportunities: { label: "\u5DF2\u8D62\u5F97\u5546\u673A" }, + response_rate: { label: "\u54CD\u5E94\u7387\uFF08%\uFF09" }, + roi: { label: "\u6295\u8D44\u56DE\u62A5\u7387\uFF08%\uFF09" }, + owner_id: { label: "\u6D3B\u52A8\u8D1F\u8D23\u4EBA" }, + landing_page_url: { label: "\u7740\u9646\u9875" }, + is_active: { label: "\u662F\u5426\u542F\u7528" }, + display_title: { label: "\u663E\u793A\u540D\u79F0" } + }, + _sections: { + basic: { label: "\u6D3B\u52A8\u4FE1\u606F" }, + schedule: { label: "\u65E5\u7A0B\u5B89\u6392" }, + budget: { label: "\u9884\u7B97\u4E0E\u6295\u8D44\u56DE\u62A5" }, + metrics: { label: "\u6548\u679C\u6570\u636E" }, + assignment: { label: "\u5F52\u5C5E" }, + assets: { label: "\u6D3B\u52A8\u7D20\u6750" } + }, + _views: { + all_campaigns: { label: "\u5168\u90E8\u8425\u9500\u6D3B\u52A8" }, + campaign_gantt: { label: "\u6D3B\u52A8\u6392\u671F" }, + campaign_calendar: { label: "\u6D3B\u52A8\u65E5\u5386" }, + campaign_timeline: { label: "\u8425\u9500\u65F6\u95F4\u7EBF" } + }, + _actions: { + enroll_leads: { + label: "\u6279\u91CF\u52A0\u5165\u6210\u5458", + successMessage: "\u7B26\u5408\u6761\u4EF6\u7684\u6210\u5458\u5DF2\u52A0\u5165\u8425\u9500\u6D3B\u52A8\u3002" + } + } + }, + crm_campaign_member: { + _validations: { + lead_or_contact_required: { + message: "\u8425\u9500\u6D3B\u52A8\u6210\u5458\u5FC5\u987B\u5173\u8054\u7EBF\u7D22\u6216\u8054\u7CFB\u4EBA\u4E4B\u4E00" + } + }, + // 「营销活动成员」, not 「活动成员」: this object's master is `crm_campaign` + // (营销活动), while 「活动」 is already this pack's label for `crm_event` and + // 「活动参与者」 its child `crm_event_attendee`. Dropping 「营销」 put a + // marketing object inside the calendar family's name space (#810). + label: "\u8425\u9500\u6D3B\u52A8\u6210\u5458", + pluralLabel: "\u8425\u9500\u6D3B\u52A8\u6210\u5458", + description: "\u8425\u9500\u6D3B\u52A8\u6240\u89E6\u8FBE\u7684\u7EBF\u7D22\u4E0E\u8054\u7CFB\u4EBA\u53CA\u5176\u54CD\u5E94\u72B6\u6001", + fields: { + member_number: { label: "\u6210\u5458\u7F16\u53F7" }, + crm_campaign: { label: "\u8425\u9500\u6D3B\u52A8" }, + crm_lead: { label: "\u7EBF\u7D22", help: "\u6210\u5458\u52A0\u5165\u65F6\u8EAB\u4EFD\u4E3A\u7EBF\u7D22\u7684\uFF0C\u8BB0\u5F55\u5728\u6B64" }, + crm_contact: { label: "\u8054\u7CFB\u4EBA", help: "\u6210\u5458\u4E3A\u5DF2\u6709\u8054\u7CFB\u4EBA\u7684\uFF0C\u8BB0\u5F55\u5728\u6B64" }, + status: { + label: "\u72B6\u6001", + options: { + sent: "\u5DF2\u53D1\u9001", + responded: "\u5DF2\u54CD\u5E94", + converted: "\u5DF2\u8F6C\u5316", + unsubscribed: "\u5DF2\u9000\u8BA2" + } + }, + added_date: { label: "\u52A0\u5165\u65F6\u95F4" }, + response_date: { label: "\u54CD\u5E94\u65F6\u95F4" }, + has_responded: { label: "\u5DF2\u54CD\u5E94" } + }, + _sections: { + basic: { label: "\u57FA\u672C\u4FE1\u606F" }, + response: { label: "\u54CD\u5E94\u8DDF\u8E2A" } + }, + _actions: { + mark_responded: { + label: "\u6807\u8BB0\u4E3A\u5DF2\u54CD\u5E94", + successMessage: "\u5DF2\u8BB0\u5F55\u8BE5\u8425\u9500\u6D3B\u52A8\u6210\u5458\u7684\u54CD\u5E94\u3002" + } + } + } +}; + +// src/sales/translations/zh-CN.ts +var zhCN2 = { + objects: { + crm_account: customer2.crm_account, + crm_contact: customer2.crm_contact, + crm_knowledge_article: service2.crm_knowledge_article, + crm_forecast: pipeline2.crm_forecast, + crm_lead: pipeline2.crm_lead, + crm_quote: commerce2.crm_quote, + crm_contract: commerce2.crm_contract, + crm_case: service2.crm_case, + crm_task: activity2.crm_task, + crm_campaign: marketing2.crm_campaign, + crm_product: commerce2.crm_product, + crm_opportunity: pipeline2.crm_opportunity, + crm_event: activity2.crm_event, + crm_event_attendee: activity2.crm_event_attendee, + crm_article_feedback: service2.crm_article_feedback, + crm_campaign_member: marketing2.crm_campaign_member, + crm_opportunity_line_item: pipeline2.crm_opportunity_line_item, + crm_quote_line_item: commerce2.crm_quote_line_item + }, + ...appSurface2 +}; + +// src/sales/translations/ja-JP/app.ts +var appSurface3 = { + apps: { + crm_enterprise: { + label: "HotCRM", + description: "\u55B6\u696D\u30FB\u30B5\u30FC\u30D3\u30B9\u30FB\u30DE\u30FC\u30B1\u30C6\u30A3\u30F3\u30B0\u5411\u3051\u9867\u5BA2\u95A2\u4FC2\u7BA1\u7406\u30B7\u30B9\u30C6\u30E0", + // Keyed by navigation-node `id` (a flat keyspace regardless of depth). + navigation: { + nav_home: { label: "\u30DB\u30FC\u30E0" }, + group_sales: { label: "\u55B6\u696D" }, + nav_lead: { label: "\u30EA\u30FC\u30C9" }, + nav_account: { label: "\u53D6\u5F15\u5148" }, + nav_account_workbench: { label: "\u53D6\u5F15\u5148\u30EF\u30FC\u30AF\u30D9\u30F3\u30C1" }, + nav_contact: { label: "\u53D6\u5F15\u5148\u8CAC\u4EFB\u8005" }, + nav_opportunity: { label: "\u5546\u8AC7" }, + nav_quote: { label: "\u898B\u7A4D" }, + nav_contract: { label: "\u5951\u7D04" }, + nav_product: { label: "\u88FD\u54C1" }, + nav_sales_dashboard: { label: "\u55B6\u696D\u5B9F\u7E3E" }, + group_work: { label: "\u30DE\u30A4\u30EF\u30FC\u30AF" }, + nav_my_tasks: { label: "\u79C1\u306E\u30BF\u30B9\u30AF" }, + nav_my_deals: { label: "\u79C1\u306E\u5546\u8AC7" }, + nav_my_leads: { label: "\u79C1\u306E\u30EA\u30FC\u30C9" }, + nav_my_cases: { label: "\u79C1\u306E\u30B1\u30FC\u30B9" }, + nav_my_calendar: { label: "\u30DE\u30A4\u30AB\u30EC\u30F3\u30C0\u30FC" }, + nav_approval_requests: { label: "\u53D7\u4FE1\u30C8\u30EC\u30A4" }, + group_activity: { label: "\u6D3B\u52D5" }, + nav_event: { label: "\u30A4\u30D9\u30F3\u30C8" }, + nav_activity_dashboard: { label: "\u55B6\u696D\u6D3B\u52D5" }, + group_marketing: { label: "\u30DE\u30FC\u30B1\u30C6\u30A3\u30F3\u30B0" }, + nav_campaign: { label: "\u30AD\u30E3\u30F3\u30DA\u30FC\u30F3" }, + group_service: { label: "\u30B5\u30FC\u30D3\u30B9" }, + nav_case: { label: "\u30B1\u30FC\u30B9" }, + nav_knowledge: { label: "\u30CA\u30EC\u30C3\u30B8\u30D9\u30FC\u30B9" }, + nav_service_dashboard: { label: "\u30B5\u30FC\u30D3\u30B9\u6982\u8981" }, + group_insights: { label: "\u30A4\u30F3\u30B5\u30A4\u30C8" }, + nav_crm_dashboard: { label: "CRM \u6982\u8981" }, + nav_forecast: { label: "\u30D5\u30A9\u30FC\u30AD\u30E3\u30B9\u30C8" }, + nav_report_pipeline_coverage: { label: "\u30D1\u30A4\u30D7\u30E9\u30A4\u30F3\u30AB\u30D0\u30EC\u30C3\u30B8" }, + nav_report_lead_inflow: { label: "\u30EA\u30FC\u30C9\u6D41\u5165" }, + nav_report_sla: { label: "SLA \u5B9F\u7E3E" } + } + } + }, + messages: { + "common.save": "\u4FDD\u5B58", + "common.cancel": "\u30AD\u30E3\u30F3\u30BB\u30EB", + "common.delete": "\u524A\u9664", + "common.edit": "\u7DE8\u96C6", + "common.create": "\u65B0\u898F\u4F5C\u6210", + "common.search": "\u691C\u7D22", + "common.filter": "\u30D5\u30A3\u30EB\u30BF\u30FC", + "common.export": "\u30A8\u30AF\u30B9\u30DD\u30FC\u30C8", + "common.back": "\u623B\u308B", + "common.confirm": "\u78BA\u8A8D", + "nav.sales": "\u55B6\u696D", + "nav.service": "\u30B5\u30FC\u30D3\u30B9", + "nav.marketing": "\u30DE\u30FC\u30B1\u30C6\u30A3\u30F3\u30B0", + "nav.products": "\u88FD\u54C1", + "nav.analytics": "\u30A2\u30CA\u30EA\u30C6\u30A3\u30AF\u30B9", + "success.saved": "\u30EC\u30B3\u30FC\u30C9\u3092\u4FDD\u5B58\u3057\u307E\u3057\u305F", + "success.converted": "\u30EA\u30FC\u30C9\u3092\u5909\u63DB\u3057\u307E\u3057\u305F", + "confirm.delete": "\u3053\u306E\u30EC\u30B3\u30FC\u30C9\u3092\u524A\u9664\u3057\u3066\u3082\u3088\u308D\u3057\u3044\u3067\u3059\u304B\uFF1F", + "confirm.convert_lead": "\u3053\u306E\u30EA\u30FC\u30C9\u3092\u53D6\u5F15\u5148\u30FB\u53D6\u5F15\u5148\u8CAC\u4EFB\u8005\u30FB\u5546\u8AC7\u306B\u5909\u63DB\u3057\u307E\u3059\u304B\uFF1F", + "error.required": "\u3053\u306E\u9805\u76EE\u306F\u5FC5\u9808\u3067\u3059", + "error.load_failed": "\u30C7\u30FC\u30BF\u306E\u8AAD\u307F\u8FBC\u307F\u306B\u5931\u6557\u3057\u307E\u3057\u305F" + }, + dashboards: { + sales_activity_dashboard: { + label: "\u55B6\u696D\u6D3B\u52D5", + description: "\u8AB0\u304C\u3069\u308C\u3060\u3051\u9867\u5BA2\u3068\u8A71\u3057\u3066\u3044\u308B\u304B\u3001\u3069\u306E\u53D6\u5F15\u5148\u304C\u6C88\u9ED9\u3057\u3066\u3044\u308B\u304B", + widgets: { + interactions_held: { title: "\u8A18\u9332\u6E08\u307F\u306E\u5BFE\u8A71", description: "\u5B9F\u969B\u306B\u884C\u308F\u308C\u305F\u96FB\u8A71\u3068\u4F1A\u8B70" }, + meetings_booked: { title: "\u8A2D\u5B9A\u6E08\u307F\u306E\u4F1A\u8B70", description: "\u30AB\u30EC\u30F3\u30C0\u30FC\u4E0A\u306B\u3042\u308A\u672A\u5B9F\u65BD\u306E\u4F1A\u8B70" }, + customer_minutes: { title: "\u9867\u5BA2\u63A5\u89E6\u6642\u9593\uFF08\u5206\uFF09", description: "\u9867\u5BA2\u3068\u5411\u304D\u5408\u3063\u305F\u7DCF\u6642\u9593" }, + tasks_completed: { title: "\u5B8C\u4E86\u30BF\u30B9\u30AF", description: "\u30AF\u30ED\u30FC\u30BA\u3057\u305F\u30D5\u30A9\u30ED\u30FC\u30A2\u30C3\u30D7" }, + activity_by_rep: { title: "\u62C5\u5F53\u8005\u5225\u306E\u6D3B\u52D5", description: "\u62C5\u5F53\u8005\u3054\u3068\u306E\u8A18\u9332\u6E08\u307F\u5BFE\u8A71\u6570" }, + activity_by_week: { title: "\u9031\u6B21\u306E\u6D3B\u52D5\u91CF", description: "\u9031\u3042\u305F\u308A\u306E\u5BFE\u8A71\u6570" }, + activity_mix: { title: "\u6D3B\u52D5\u306E\u5185\u8A33", description: "\u96FB\u8A71\u30FB\u4F1A\u8B70\u30FB\u30C7\u30E2\u306E\u6BD4\u7387" }, + activity_by_record_type: { title: "\u6D3B\u52D5\u306E\u5BFE\u8C61", description: "\u30D5\u30A1\u30CD\u30EB\u306E\u3069\u3053\u306B\u6CE8\u529B\u3057\u3066\u3044\u308B\u304B" }, + deal_activity: { title: "\u5546\u8AC7\u4E0A\u306E\u5BFE\u8A71", description: "\u5546\u8AC7\u306B\u7D10\u3065\u304F\u8A18\u9332\u6E08\u307F\u5BFE\u8A71" }, + open_deals_for_activity: { title: "\u30AA\u30FC\u30D7\u30F3\u5546\u8AC7", description: "\u9032\u884C\u4E2D\u306E\u5546\u8AC7\u6570" }, + quiet_accounts_30: { title: "30 \u65E5\u4EE5\u4E0A\u6C88\u9ED9", description: "1 \u304B\u6708\u9593\u5BFE\u8A71\u8A18\u9332\u306E\u306A\u3044\u30A2\u30AF\u30C6\u30A3\u30D6\u53D6\u5F15\u5148" }, + quiet_accounts_60: { title: "60 \u65E5\u4EE5\u4E0A\u6C88\u9ED9", description: "2 \u304B\u6708\u306E\u6C88\u9ED9 \u2014 \u30EA\u30B9\u30AF\u95BE\u5024" }, + quiet_accounts_90: { title: "90 \u65E5\u4EE5\u4E0A\u6C88\u9ED9", description: "\u56DB\u534A\u671F\u306B\u308F\u305F\u308A\u63A5\u89E6\u306A\u3057" } + } + }, + crm_overview_dashboard: { + label: "CRM \u6982\u8981", + description: "\u58F2\u4E0A\u6307\u6A19\u3001\u30D1\u30A4\u30D7\u30E9\u30A4\u30F3\u5206\u6790\u3001\u5546\u8AC7\u30A4\u30F3\u30B5\u30A4\u30C8", + widgets: { + total_revenue: { title: "\u7DCF\u58F2\u4E0A", description: "\u5F53\u671F\u306E\u6210\u7ACB\u6E08\u307F\u58F2\u4E0A" }, + active_deals: { title: "\u9032\u884C\u4E2D\u306E\u5546\u8AC7", description: "\u30D1\u30A4\u30D7\u30E9\u30A4\u30F3\u4E0A\u306E\u30AA\u30FC\u30D7\u30F3\u5546\u8AC7" }, + won_deals: { title: "\u6210\u7ACB\u5546\u8AC7\u6570", description: "\u5F53\u671F\u306B\u6210\u7ACB\u3057\u305F\u5546\u8AC7\u306E\u7DCF\u6570" }, + avg_deal_size: { title: "\u5E73\u5747\u5546\u8AC7\u898F\u6A21", description: "\u6210\u7ACB\u6E08\u307F\u5546\u8AC7\u306E\u5E73\u5747\u91D1\u984D" }, + revenue_trends: { title: "\u58F2\u4E0A\u30C8\u30EC\u30F3\u30C9", description: "\u904E\u53BB12\u304B\u6708\u306E\u6210\u7ACB\u6E08\u307F\u58F2\u4E0A" }, + lead_source: { title: "\u30EA\u30FC\u30C9\u30BD\u30FC\u30B9", description: "\u7372\u5F97\u30C1\u30E3\u30CD\u30EB\u5225\u306E\u30D1\u30A4\u30D7\u30E9\u30A4\u30F3\u91D1\u984D" }, + pipeline_by_stage: { title: "\u30B9\u30C6\u30FC\u30B8\u5225\u30D1\u30A4\u30D7\u30E9\u30A4\u30F3", description: "\u5404\u55B6\u696D\u30B9\u30C6\u30FC\u30B8\u306E\u30AA\u30FC\u30D7\u30F3\u5546\u8AC7\u91D1\u984D" }, + top_products: { title: "\u58F2\u308C\u7B4B\u88FD\u54C1", description: "\u88FD\u54C1\u30AB\u30C6\u30B4\u30EA\u5225\u306E\u5B9A\u4FA1\u30D9\u30FC\u30B9\u58F2\u4E0A" }, + pipeline_by_owner: { title: "\u62C5\u5F53\u8005\u5225\u30D1\u30A4\u30D7\u30E9\u30A4\u30F3", description: "\u55B6\u696D\u62C5\u5F53\u8005\u3054\u3068\u306E\u30AA\u30FC\u30D7\u30F3\u30D1\u30A4\u30D7\u30E9\u30A4\u30F3\u91D1\u984D\u3068\u5546\u8AC7\u6570" } + } + }, + executive_dashboard: { + label: "\u30A8\u30B0\u30BC\u30AF\u30C6\u30A3\u30D6\u6982\u8981", + description: "\u7D4C\u55B6\u5C64\u5411\u3051\u306E\u58F2\u4E0A\u30FB\u9867\u5BA2\u30FB\u30D1\u30A4\u30D7\u30E9\u30A4\u30F3\u306E\u4E3B\u8981KPI", + widgets: { + total_revenue_ytd: { title: "\u5E74\u5EA6\u7D2F\u8A08\u58F2\u4E0A", description: "\u672C\u5E74\u5EA6\u306E\u6210\u7ACB\u6E08\u307F\u58F2\u4E0A" }, + total_accounts: { title: "\u30A2\u30AF\u30C6\u30A3\u30D6\u53D6\u5F15\u5148", description: "\u5C11\u306A\u304F\u3068\u30821\u3064\u306E\u6709\u52B9\u306A\u95A2\u4FC2\u3092\u6301\u3064\u9867\u5BA2" }, + total_contacts: { title: "\u53D6\u5F15\u5148\u8CAC\u4EFB\u8005\u6570", description: "\u540D\u7C3F\u306B\u767B\u9332\u3055\u308C\u305F\u53D6\u5F15\u5148\u8CAC\u4EFB\u8005" }, + open_leads: { title: "\u30AA\u30FC\u30D7\u30F3\u30EA\u30FC\u30C9", description: "\u672A\u5909\u63DB\u306E\u30EA\u30FC\u30C9" }, + revenue_trend: { title: "\u58F2\u4E0A\u30C8\u30EC\u30F3\u30C9", description: "\u904E\u53BB12\u304B\u6708\u306E\u6210\u7ACB\u6E08\u307F\u58F2\u4E0A" }, + revenue_by_industry: { title: "\u696D\u7A2E\u5225\u58F2\u4E0A", description: "\u672C\u5E74\u5EA6\u306E\u6210\u7ACB\u6E08\u307F\u58F2\u4E0A\u3092\u696D\u7A2E\u5225\u306B\u5206\u985E" }, + pipeline_by_stage: { title: "\u30B9\u30C6\u30FC\u30B8\u5225\u30D1\u30A4\u30D7\u30E9\u30A4\u30F3", description: "\u5404\u55B6\u696D\u30B9\u30C6\u30FC\u30B8\u306E\u30AA\u30FC\u30D7\u30F3\u5546\u8AC7\u91D1\u984D" }, + new_accounts_by_month: { title: "\u65B0\u898F\u53D6\u5F15\u5148", description: "\u904E\u53BB6\u304B\u6708\u306E\u53D6\u5F15\u5148\u4F5C\u6210\u30DA\u30FC\u30B9" }, + accounts_by_industry: { title: "\u696D\u7A2E\u5225\u53D6\u5F15\u5148", description: "\u696D\u7A2E\u3054\u3068\u306E\u5E74\u9593\u58F2\u4E0A\u5408\u8A08\u3068\u53D6\u5F15\u5148\u6570" } + } + }, + sales_dashboard: { + label: "\u55B6\u696D\u5B9F\u7E3E", + description: "\u30D1\u30A4\u30D7\u30E9\u30A4\u30F3\u5206\u6790\u3001\u52DD\u7387\u30C8\u30EC\u30F3\u30C9\u3001\u62C5\u5F53\u8005\u5225\u30D1\u30D5\u30A9\u30FC\u30DE\u30F3\u30B9", + widgets: { + total_pipeline_value: { title: "\u30D1\u30A4\u30D7\u30E9\u30A4\u30F3\u5408\u8A08", description: "\u30AA\u30FC\u30D7\u30F3\u5546\u8AC7\u91D1\u984D\u306E\u5408\u8A08" }, + closed_won_qtd: { title: "\u4ECA\u56DB\u534A\u671F\u6210\u7ACB\u984D", description: "\u4ECA\u56DB\u534A\u671F\u306B\u6210\u7ACB\u3057\u305F\u58F2\u4E0A" }, + open_opportunities: { title: "\u30AA\u30FC\u30D7\u30F3\u5546\u8AC7", description: "\u9032\u884C\u4E2D\u306E\u30A2\u30AF\u30C6\u30A3\u30D6\u5546\u8AC7" }, + avg_deal_size: { title: "\u5E73\u5747\u5546\u8AC7\u898F\u6A21", description: "\u4ECA\u56DB\u534A\u671F\u306E\u6210\u7ACB\u6E08\u307F\u5546\u8AC7\u306E\u5E73\u5747\u91D1\u984D" }, + pipeline_by_stage: { title: "\u30B9\u30C6\u30FC\u30B8\u5225\u30D1\u30A4\u30D7\u30E9\u30A4\u30F3", description: "\u5404\u55B6\u696D\u30B9\u30C6\u30FC\u30B8\u306E\u30AA\u30FC\u30D7\u30F3\u5546\u8AC7\u91D1\u984D" }, + monthly_revenue_trend: { title: "\u6708\u6B21\u58F2\u4E0A\u30C8\u30EC\u30F3\u30C9", description: "\u904E\u53BB12\u304B\u6708\u306E\u6210\u7ACB\u6E08\u307F\u58F2\u4E0A" }, + pipeline_by_forecast_category: { title: "\u4E88\u6E2C\u30AB\u30C6\u30B4\u30EA\u5225\u30D1\u30A4\u30D7\u30E9\u30A4\u30F3", description: "\u58F2\u4E0A\u4E88\u6E2C\u30AB\u30C6\u30B4\u30EA\u5225\u306E\u30AA\u30FC\u30D7\u30F3\u30D1\u30A4\u30D7\u30E9\u30A4\u30F3\u91D1\u984D" }, + lead_source_breakdown: { title: "\u30EA\u30FC\u30C9\u30BD\u30FC\u30B9", description: "\u30D1\u30A4\u30D7\u30E9\u30A4\u30F3\u306E\u6D41\u5165\u5143" }, + open_pipeline_by_owner: { title: "\u62C5\u5F53\u8005\u5225\u30AA\u30FC\u30D7\u30F3\u30D1\u30A4\u30D7\u30E9\u30A4\u30F3", description: "\u55B6\u696D\u62C5\u5F53\u8005\u3054\u3068\u306E\u9032\u884C\u4E2D\u30D1\u30A4\u30D7\u30E9\u30A4\u30F3\u91D1\u984D\u30FB\u5546\u8AC7\u6570\u30FB\u5E73\u5747\u52DD\u7387" }, + quota_attainment_by_rep: { title: "\u62C5\u5F53\u8005\u5225\u30CE\u30EB\u30DE\u9054\u6210\u72B6\u6CC1", description: "\u4E88\u6E2C\u30B9\u30CA\u30C3\u30D7\u30B7\u30E7\u30C3\u30C8\u306B\u57FA\u3065\u304F\u62C5\u5F53\u8005\u5225\u306E\u4ECA\u56DB\u534A\u671F\u30CE\u30EB\u30DE\u30FB\u6210\u7D04\u53CE\u76CA\u30FB\u9054\u6210\u7387" }, + pipeline_stage_by_source: { title: "\u30B9\u30C6\u30FC\u30B8 \xD7 \u30EA\u30FC\u30C9\u30BD\u30FC\u30B9", description: "\u30B9\u30C6\u30FC\u30B8\u3068\u30BD\u30FC\u30B9\u5225\u306E\u9032\u884C\u4E2D\u5546\u8AC7\u91D1\u984D\u306E\u30AF\u30ED\u30B9\u96C6\u8A08" }, + win_rate_12m: { title: "\u52DD\u7387\uFF08\u76F4\u8FD112\u304B\u6708\uFF09", description: "\u76F4\u8FD112\u304B\u6708\u306B\u6C7A\u7740\u3057\u305F\u5546\u8AC7\u306E\u3046\u3061\u6210\u7ACB\u3057\u305F\u5272\u5408" }, + won_deals_12m: { title: "\u6210\u7ACB\u5546\u8AC7\u6570\uFF08\u76F4\u8FD112\u304B\u6708\uFF09", description: "\u52DD\u7387\u306E\u5206\u5B50" }, + lost_deals_12m: { title: "\u5931\u6CE8\u5546\u8AC7\u6570\uFF08\u76F4\u8FD112\u304B\u6708\uFF09", description: "\u52DD\u7387\u306E\u5206\u6BCD\u306E\u3082\u3046\u534A\u5206" }, + win_rate_by_owner: { title: "\u62C5\u5F53\u8005\u5225 \u53D7\u6CE8\uFF0F\u5931\u6CE8", description: "\u76F4\u8FD112\u304B\u6708\u306E\u62C5\u5F53\u8005\u3054\u3068\u306E\u6210\u7ACB\u6570\u30FB\u5931\u6CE8\u6570\u30FB\u52DD\u7387" }, + win_rate_by_lead_source: { title: "\u30EA\u30FC\u30C9\u30BD\u30FC\u30B9\u5225 \u53D7\u6CE8\uFF0F\u5931\u6CE8", description: "\u5B9F\u969B\u306B\u6210\u7ACB\u306B\u3064\u306A\u304C\u308B\u306E\u306F\u3069\u306E\u30BD\u30FC\u30B9\u304B \u2014 \u76F4\u8FD112\u304B\u6708" }, + loss_reason_breakdown: { title: "\u5931\u6CE8\u306E\u7406\u7531", description: "\u76F4\u8FD112\u304B\u6708\u306E\u5931\u6CE8\u5546\u8AC7\u3092\u7406\u7531\u5225\u306B\u96C6\u8A08" } + } + }, + service_dashboard: { + label: "\u30AB\u30B9\u30BF\u30DE\u30FC\u30B5\u30FC\u30D3\u30B9", + description: "\u30B1\u30FC\u30B9\u8CA0\u8377\u3001SLA\u5065\u5168\u6027\u3001\u89E3\u6C7A\u30D1\u30D5\u30A9\u30FC\u30DE\u30F3\u30B9", + widgets: { + open_cases: { title: "\u30AA\u30FC\u30D7\u30F3\u30B1\u30FC\u30B9", description: "\u307E\u3060\u30AF\u30ED\u30FC\u30BA\u3055\u308C\u3066\u3044\u306A\u3044\u30B1\u30FC\u30B9" }, + critical_cases: { title: "\u91CD\u5927\u30B1\u30FC\u30B9", description: "\u512A\u5148\u5EA6\u300C\u91CD\u5927\u300D\u306E\u30AA\u30FC\u30D7\u30F3\u30B1\u30FC\u30B9" }, + avg_resolution_time: { title: "\u5E73\u5747\u89E3\u6C7A\u6642\u9593", description: "\u30AF\u30ED\u30FC\u30BA\u307E\u3067\u306E\u5E73\u5747\u6642\u9593\uFF08\u6642\uFF09" }, + sla_violations: { title: "SLA \u9055\u53CD", description: "SLA \u3092\u8D85\u904E\u3057\u305F\u30B1\u30FC\u30B9" }, + cases_by_status: { title: "\u30B9\u30C6\u30FC\u30BF\u30B9\u5225\u30B1\u30FC\u30B9", description: "\u30D1\u30A4\u30D7\u30E9\u30A4\u30F3\u5168\u4F53\u306E\u30EF\u30FC\u30AF\u30ED\u30FC\u30C9\u5206\u5E03" }, + cases_by_priority: { title: "\u512A\u5148\u5EA6\u5225\u30B1\u30FC\u30B9", description: "\u7DCA\u6025\u5EA6\u5225\u306E\u30AA\u30FC\u30D7\u30F3\u30B1\u30FC\u30B9\u69CB\u6210" }, + cases_by_origin: { title: "\u767A\u751F\u6E90\u5225\u30B1\u30FC\u30B9", description: "\u30B1\u30FC\u30B9\u306E\u6D41\u5165\u30C1\u30E3\u30CD\u30EB" }, + daily_case_volume: { title: "\u65E5\u6B21\u30B1\u30FC\u30B9\u4EF6\u6570", description: "\u904E\u53BB30\u65E5\u9593\u306E\u65B0\u898F\u30B1\u30FC\u30B9" }, + sla_compliance_gauge: { title: "SLA \u9054\u6210\u7387", description: "\u5F53\u671F SLA \u5185\u306B\u89E3\u6C7A\u3057\u305F\u30B1\u30FC\u30B9\u306E\u5272\u5408" }, + kb_deflection_rate: { title: "\u30CA\u30EC\u30C3\u30B8\u89E3\u6C7A\u7387", description: "\u30AF\u30ED\u30FC\u30BA\u3057\u305F\u30B1\u30FC\u30B9\u306E\u3046\u3061\u30CA\u30EC\u30C3\u30B8\u8A18\u4E8B\u3067\u89E3\u6C7A\u3057\u305F\u5272\u5408" }, + kb_resolved_cases: { title: "\u30CA\u30EC\u30C3\u30B8\u3067\u89E3\u6C7A", description: "\u89E3\u6C7A\u3057\u305F\u8A18\u4E8B\u304C\u7D10\u3065\u304F\u30AF\u30ED\u30FC\u30BA\u6E08\u307F\u30B1\u30FC\u30B9" }, + closed_cases_total: { title: "\u30AF\u30ED\u30FC\u30BA\u6E08\u307F\u30B1\u30FC\u30B9", description: "\u30CA\u30EC\u30C3\u30B8\u89E3\u6C7A\u7387\u306E\u5206\u6BCD" }, + top_resolving_articles: { title: "\u89E3\u6C7A\u4EF6\u6570\u306E\u591A\u3044\u8A18\u4E8B", description: "\u89E3\u6C7A\u3057\u305F\u30AF\u30ED\u30FC\u30BA\u6E08\u307F\u30B1\u30FC\u30B9\u6570\u3067\u4E26\u3079\u305F\u30CA\u30EC\u30C3\u30B8\u8A18\u4E8B" }, + my_open_cases_by_priority: { title: "\u512A\u5148\u5EA6\u5225\u306E\u79C1\u306E\u30AA\u30FC\u30D7\u30F3\u30B1\u30FC\u30B9", description: "\u3042\u306A\u305F\u306E\u30AA\u30FC\u30D7\u30F3\u30B1\u30FC\u30B9\u3068\u305D\u306ESLA\u9055\u53CD\u7387\u3092\u512A\u5148\u5EA6\u5225\u306B\u96C6\u8A08" } + } + } + }, + // `title` / `subtitle` translate the page's `page:header`; `title` falls back + // to `label` when omitted, so it is authored only where the two differ. + // Header strings carrying `{field}` tokens keep the token spelling verbatim — + // the console substitutes on the raw key, so a translated token resolves to + // nothing and the header renders blank. + datasets: { + account_metrics: { + label: "\u53D6\u5F15\u5148\u6307\u6A19", + description: "\u696D\u7A2E\u30FB\u7A2E\u5225\u3054\u3068\u306B\u53D6\u5F15\u5148\u6570\u3092\u96C6\u8A08\u3059\u308B\u30BB\u30DE\u30F3\u30C6\u30A3\u30C3\u30AF\u30EC\u30A4\u30E4\u30FC", + dimensions: { + industry: { + label: "\u696D\u7A2E" + }, + type: { + label: "\u7A2E\u5225" + }, + created_at: { + label: "\u4F5C\u6210\u65E5" + } + }, + measures: { + account_count: { + label: "\u53D6\u5F15\u5148\u6570" + }, + annual_revenue_sum: { + label: "\u5E74\u9593\u58F2\u4E0A" + } + } + }, + case_metrics: { + label: "\u30B1\u30FC\u30B9\u6307\u6A19", + description: "\u30B1\u30FC\u30B9\u6570\u30FB\u89E3\u6C7A\u6642\u9593\u30FBSLA \u3092\u96C6\u8A08\u3059\u308B\u30BB\u30DE\u30F3\u30C6\u30A3\u30C3\u30AF\u30EC\u30A4\u30E4\u30FC", + dimensions: { + created_at: { + label: "\u4F5C\u6210\u65E5" + }, + origin: { + label: "\u767A\u751F\u5143" + }, + priority: { + label: "\u512A\u5148\u5EA6" + }, + resolved_article: { + label: "\u89E3\u6C7A\u306B\u4F7F\u7528\u3057\u305F\u30CA\u30EC\u30C3\u30B8\u8A18\u4E8B" + }, + status: { + label: "\u30B9\u30C6\u30FC\u30BF\u30B9" + }, + type: { + label: "\u7A2E\u5225" + } + }, + measures: { + avg_resolution: { + label: "\u5E73\u5747\u89E3\u6C7A\u6642\u9593\uFF08\u6642\u9593\uFF09" + }, + avg_sla_violated: { + label: "SLA \u9055\u53CD\u7387" + }, + case_count: { + label: "\u30B1\u30FC\u30B9\u6570" + }, + closed_count: { + label: "\u30AF\u30ED\u30FC\u30BA\u6E08\u307F\u30B1\u30FC\u30B9" + }, + kb_deflection_rate: { + label: "\u30CA\u30EC\u30C3\u30B8\u30D9\u30FC\u30B9\u81EA\u5DF1\u89E3\u6C7A\u7387" + }, + kb_resolved_count: { + label: "\u30CA\u30EC\u30C3\u30B8\u30D9\u30FC\u30B9\u3067\u89E3\u6C7A\u3057\u305F\u4EF6\u6570" + }, + sla_compliance_rate: { + label: "SLA \u9075\u5B88\u7387" + }, + sla_met_count: { + label: "SLA \u3092\u6E80\u305F\u3057\u305F\u30B1\u30FC\u30B9" + } + } + }, + contact_metrics: { + label: "\u53D6\u5F15\u5148\u8CAC\u4EFB\u8005\u6307\u6A19", + description: "\u53D6\u5F15\u5148\u8CAC\u4EFB\u8005\u6570\u3092\u96C6\u8A08\u3059\u308B\u30BB\u30DE\u30F3\u30C6\u30A3\u30C3\u30AF\u30EC\u30A4\u30E4\u30FC", + measures: { + contact_count: { + label: "\u53D6\u5F15\u5148\u8CAC\u4EFB\u8005\u6570" + } + } + }, + event_metrics: { + label: "\u6D3B\u52D5\u6307\u6A19", + description: "\u4F1A\u8B70\u30FB\u901A\u8A71\u30FB\u63A5\u89E6\u306E\u65B0\u3057\u3055\u3092\u96C6\u8A08\u3059\u308B\u30BB\u30DE\u30F3\u30C6\u30A3\u30C3\u30AF\u30EC\u30A4\u30E4\u30FC", + dimensions: { + owner: { + label: "\u6240\u6709\u8005" + }, + related_to_type: { + label: "\u95A2\u9023\u5148" + }, + start_datetime: { + label: "\u6D3B\u52D5\u9031" + }, + status: { + label: "\u30B9\u30C6\u30FC\u30BF\u30B9" + }, + type: { + label: "\u6D3B\u52D5\u7A2E\u5225" + } + }, + measures: { + avg_minutes: { + label: "\u5E73\u5747\u6240\u8981\u6642\u9593" + }, + event_count: { + label: "\u6D3B\u52D5\u4EF6\u6570" + }, + total_minutes: { + label: "\u5408\u8A08\u5206\u6570" + } + } + }, + forecast_metrics: { + label: "\u30D5\u30A9\u30FC\u30AD\u30E3\u30B9\u30C8\u6307\u6A19", + description: "\u62C5\u5F53\u8005\u3054\u3068\u306E\u76EE\u6A19\u30FB\u9054\u6210\u7387\u30FB\u30D1\u30A4\u30D7\u30E9\u30A4\u30F3\u30AB\u30D0\u30EC\u30C3\u30B8\u3092\u96C6\u8A08\u3059\u308B\u30BB\u30DE\u30F3\u30C6\u30A3\u30C3\u30AF\u30EC\u30A4\u30E4\u30FC", + dimensions: { + owner: { + label: "\u6240\u6709\u8005" + }, + period: { + label: "\u671F\u9593\u7A2E\u5225" + }, + period_label: { + label: "\u671F\u9593" + }, + period_start: { + label: "\u671F\u9593\u958B\u59CB" + } + }, + measures: { + attainment: { + label: "\u9054\u6210\u7387" + }, + closed_sum: { + label: "\u30AF\u30ED\u30FC\u30BA\u6E08\u307F" + }, + commit_sum: { + label: "\u30B3\u30DF\u30C3\u30C8" + }, + pipeline_sum: { + label: "\u30D1\u30A4\u30D7\u30E9\u30A4\u30F3" + }, + quota_sum: { + label: "\u76EE\u6A19" + } + } + }, + lead_metrics: { + label: "\u30EA\u30FC\u30C9\u6307\u6A19", + description: "\u30EA\u30FC\u30C9\u6570\u3092\u96C6\u8A08\u3059\u308B\u30BB\u30DE\u30F3\u30C6\u30A3\u30C3\u30AF\u30EC\u30A4\u30E4\u30FC", + dimensions: { + created_at: { + label: "\u4F5C\u6210\u65E5" + }, + last_contacted_date: { + label: "\u6700\u7D42\u63A5\u89E6\u65E5" + }, + lead_source: { + label: "\u30BD\u30FC\u30B9" + }, + status: { + label: "\u30B9\u30C6\u30FC\u30BF\u30B9" + } + }, + measures: { + lead_count: { + label: "\u30EA\u30FC\u30C9\u6570" + } + } + }, + opportunity_metrics: { + label: "\u5546\u8AC7\u6307\u6A19", + description: "\u55B6\u696D\u30D1\u30A4\u30D7\u30E9\u30A4\u30F3\u306E\u4EF6\u6570\u3068\u91D1\u984D\u3092\u96C6\u8A08\u3059\u308B\u30BB\u30DE\u30F3\u30C6\u30A3\u30C3\u30AF\u30EC\u30A4\u30E4\u30FC", + dimensions: { + account_industry: { + label: "\u53D6\u5F15\u5148\u306E\u696D\u7A2E" + }, + close_date: { + label: "\u5B8C\u4E86\u4E88\u5B9A\u65E5" + }, + close_quarter: { + label: "\u5B8C\u4E86\u56DB\u534A\u671F" + }, + forecast_category: { + label: "\u30D5\u30A9\u30FC\u30AD\u30E3\u30B9\u30C8\u533A\u5206" + }, + lead_source: { + label: "\u30EA\u30FC\u30C9\u30BD\u30FC\u30B9" + }, + loss_reason: { + label: "\u5931\u6CE8\u7406\u7531" + }, + owner: { + label: "\u6240\u6709\u8005" + }, + stage: { + label: "\u30B9\u30C6\u30FC\u30B8" + }, + type: { + label: "\u5546\u8AC7\u7A2E\u5225" + }, + win_reason: { + label: "\u53D7\u6CE8\u7406\u7531" + } + }, + measures: { + avg_amount: { + label: "\u5E73\u5747\u5546\u8AC7\u91D1\u984D" + }, + avg_probability: { + label: "\u5E73\u5747\u78BA\u5EA6" + }, + decided_count: { + label: "\u6C7A\u7740\u3057\u305F\u5546\u8AC7" + }, + lost_amount: { + label: "\u5931\u6CE8\u91D1\u984D" + }, + lost_count: { + label: "\u5931\u6CE8\u4EF6\u6570" + }, + opp_count: { + label: "\u5546\u8AC7\u6570" + }, + total_amount: { + label: "\u5408\u8A08\u91D1\u984D" + }, + win_rate: { + label: "\u53D7\u6CE8\u7387" + }, + won_amount: { + label: "\u53D7\u6CE8\u91D1\u984D" + }, + won_count: { + label: "\u53D7\u6CE8\u4EF6\u6570" + } + } + }, + product_metrics: { + label: "\u88FD\u54C1\u6307\u6A19", + description: "\u88FD\u54C1\u30AB\u30BF\u30ED\u30B0\u306E\u4EF6\u6570\u3068\u5B9A\u4FA1\u3092\u96C6\u8A08\u3059\u308B\u30BB\u30DE\u30F3\u30C6\u30A3\u30C3\u30AF\u30EC\u30A4\u30E4\u30FC", + dimensions: { + category: { + label: "\u30AB\u30C6\u30B4\u30EA" + } + }, + measures: { + list_price_sum: { + label: "\u5B9A\u4FA1\u5408\u8A08" + }, + product_count: { + label: "\u88FD\u54C1\u6570" + } + } + }, + task_metrics: { + label: "\u30BF\u30B9\u30AF\u6307\u6A19", + description: "\u30BF\u30B9\u30AF\u306E\u4F5C\u696D\u91CF\u3068\u5B8C\u4E86\u72B6\u6CC1\u3092\u96C6\u8A08\u3059\u308B\u30BB\u30DE\u30F3\u30C6\u30A3\u30C3\u30AF\u30EC\u30A4\u30E4\u30FC", + dimensions: { + due_date: { + label: "\u671F\u9650" + }, + is_completed: { + label: "\u5B8C\u4E86\u6E08\u307F" + }, + is_overdue: { + label: "\u671F\u9650\u8D85\u904E" + }, + priority: { + label: "\u512A\u5148\u5EA6" + }, + priority_rank: { + label: "\u7DCA\u6025\u5EA6" + }, + status: { + label: "\u30B9\u30C6\u30FC\u30BF\u30B9" + }, + type: { + label: "\u7A2E\u5225" + } + }, + measures: { + avg_progress: { + label: "\u5E73\u5747\u9032\u6357" + }, + task_count: { + label: "\u30BF\u30B9\u30AF\u6570" + } + } + } + }, + pages: { + account_detail_page: { + label: "\u53D6\u5F15\u5148\u8A73\u7D30", + description: "\u30B9\u30ED\u30C3\u30C8\u69CB\u6210\u306E\u53D6\u5F15\u5148\u30EC\u30B3\u30FC\u30C9\u30DA\u30FC\u30B8 \u2014 \u30AB\u30B9\u30BF\u30E0\u30D8\u30C3\u30C0\u30FC\u3068\u5E38\u8A2D\u306E\u30C7\u30A3\u30B9\u30AB\u30C3\u30B7\u30E7\u30F3\u30D5\u30A3\u30FC\u30C9\u3002", + title: "{name}", + subtitle: "{industry} \xB7 {type}", + components: { + account_chatter: { label: "\u30C7\u30A3\u30B9\u30AB\u30C3\u30B7\u30E7\u30F3" } + } + }, + account_workbench: { + label: "\u53D6\u5F15\u5148\u30EF\u30FC\u30AF\u30D9\u30F3\u30C1", + description: "\u55B6\u696D\u30C1\u30FC\u30E0\u5411\u3051\u306B\u53B3\u9078\u3057\u305F\u53D6\u5F15\u5148\u30EA\u30B9\u30C8\u3002\u30AF\u30A4\u30C3\u30AF\u30D5\u30A3\u30EB\u30BF\u30FC\u306E\u307F\u3067\u3001\u30D3\u30E5\u30FC\u7BA1\u7406\u306F\u884C\u3044\u307E\u305B\u3093\u3002" + }, + app_launcher_page: { + label: "\u30A2\u30D7\u30EA\u30E9\u30F3\u30C1\u30E3\u30FC", + description: "\u3059\u3079\u3066\u306E\u30A2\u30D7\u30EA\u30B1\u30FC\u30B7\u30E7\u30F3\u306B\u30A2\u30AF\u30BB\u30B9\u3059\u308B\u305F\u3081\u306E\u7D71\u5408\u30CF\u30D6", + subtitle: "\u958B\u59CB\u3059\u308B\u30A2\u30D7\u30EA\u3092\u9078\u629E\u3057\u3066\u304F\u3060\u3055\u3044", + components: { + app_search: { label: "\u30A2\u30D7\u30EA\u3092\u691C\u7D22" }, + app_grid: { label: "\u30A2\u30D7\u30EA\u30B0\u30EA\u30C3\u30C9" } + } + }, + case_detail_page: { + label: "\u30B1\u30FC\u30B9\u8A73\u7D30", + description: "\u30B5\u30FC\u30D3\u30B9\u62C5\u5F53\u8005\u5411\u3051\u306E\u30B1\u30FC\u30B9\u30EC\u30B3\u30FC\u30C9\u30DA\u30FC\u30B8\uFF1A\u30CF\u30A4\u30E9\u30A4\u30C8\u3001SLA \u30D1\u30B9\u3001\u8A73\u7D30\u3001\u6D3B\u52D5\u30BF\u30A4\u30E0\u30E9\u30A4\u30F3\u3002", + title: "{case_number} \xB7 {subject}", + subtitle: "{crm_account}", + components: { + case_highlights: { label: "\u91CD\u8981\u60C5\u5831" }, + case_status_path: { label: "\u30B1\u30FC\u30B9\u30B9\u30C6\u30FC\u30BF\u30B9\u306E\u9032\u6357" }, + case_details: { label: "\u30B1\u30FC\u30B9\u8A73\u7D30\u60C5\u5831" } + } + }, + lead_detail_page: { + label: "\u30EA\u30FC\u30C9\u8A73\u7D30", + description: "\u30CF\u30A4\u30E9\u30A4\u30C8\u30FB\u8A73\u7D30\u30FB\u95A2\u9023\u60C5\u5831\u3092\u5099\u3048\u305F\u30EA\u30FC\u30C9\u306E\u7DCF\u5408\u8A73\u7D30\u30DA\u30FC\u30B8\u3002", + title: "{first_name} {last_name}", + subtitle: "{company}", + components: { + lead_duplicate_alert_confirmed: { label: "\u91CD\u8907\u78BA\u5B9A\u306E\u8B66\u544A" }, + lead_duplicate_alert_suspected: { label: "\u91CD\u8907\u306E\u7591\u3044\u306E\u8B66\u544A" }, + lead_highlights: { label: "\u91CD\u8981\u60C5\u5831" }, + lead_path: { label: "\u30EA\u30FC\u30C9\u30B9\u30C6\u30FC\u30BF\u30B9\u306E\u9032\u6357" }, + main_tabs: { label: "\u30EA\u30FC\u30C9\u60C5\u5831\u30BF\u30D6" }, + lead_details: { label: "\u30EA\u30FC\u30C9\u8A73\u7D30\u60C5\u5831" }, + related_accordion: { label: "\u95A2\u9023\u30EC\u30B3\u30FC\u30C9" }, + related_tasks: { title: "\u672A\u5B8C\u4E86\u306E\u30BF\u30B9\u30AF", label: "\u30BF\u30B9\u30AF" }, + lead_activity: { label: "\u6D3B\u52D5\u30BF\u30A4\u30E0\u30E9\u30A4\u30F3" }, + lead_history: { label: "\u9805\u76EE\u5C65\u6B74" } + } + }, + opportunity_detail_page: { + label: "\u5546\u8AC7\u8A73\u7D30", + description: "\u30B9\u30C6\u30FC\u30B8\u30D1\u30B9\u30FB\u30CF\u30A4\u30E9\u30A4\u30C8\u30FB\u8A73\u7D30\u30FB\u95A2\u9023\u30EA\u30B9\u30C8\u3092\u5099\u3048\u305F\u5546\u8AC7\u306E\u7DCF\u5408\u8A73\u7D30\u30DA\u30FC\u30B8\u3002", + title: "{name}", + subtitle: "{crm_account}", + components: { + opp_highlights: { label: "\u91CD\u8981\u60C5\u5831" }, + opp_stage_path: { label: "\u5546\u8AC7\u30B9\u30C6\u30FC\u30B8\u306E\u9032\u6357" }, + opp_details: { label: "\u5546\u8AC7\u8A73\u7D30\u60C5\u5831" } + } + }, + sales_home_page: { + label: "\u55B6\u696D\u30DB\u30FC\u30E0", + description: "\u4E3B\u8981\u6307\u6A19\u3068\u30AF\u30A4\u30C3\u30AF\u30A2\u30AF\u30B7\u30E7\u30F3\u3092\u307E\u3068\u3081\u305F\u55B6\u696D\u30C1\u30FC\u30E0\u306E\u30DB\u30FC\u30E0\u30DA\u30FC\u30B8", + title: "\u55B6\u696D\u30C0\u30C3\u30B7\u30E5\u30DC\u30FC\u30C9", + subtitle: "\u304A\u304B\u3048\u308A\u306A\u3055\u3044", + components: { + kpi_revenue_won: { + label: "\u53D7\u6CE8\u58F2\u4E0A" + }, + kpi_deals_won: { + label: "\u53D7\u6CE8\u4EF6\u6570" + }, + kpi_pipeline_value: { + label: "\u30D1\u30A4\u30D7\u30E9\u30A4\u30F3\u91D1\u984D" + }, + kpi_open_leads: { + label: "\u30AA\u30FC\u30D7\u30F3\u30EA\u30FC\u30C9" + }, + home_upcoming_events: { + label: "\u{1F4C5} \u958B\u50AC\u4E88\u5B9A \xB7 \u76F4\u8FD1\u9806" + }, + quick_create: { title: "\u30AF\u30A4\u30C3\u30AF\u4F5C\u6210", label: "\u30AF\u30A4\u30C3\u30AF\u4F5C\u6210" }, + key_metrics: { title: "\u4E3B\u8981\u696D\u7E3E\u8A55\u4FA1\u6307\u6A19", label: "\u4E3B\u8981\u6307\u6A19" }, + home_tabs: { label: "\u30DB\u30FC\u30E0\u30BF\u30D6" }, + home_my_leads: { label: "\u79C1\u306E\u30EA\u30FC\u30C9" }, + home_my_deals: { label: "\u79C1\u306E\u30AA\u30FC\u30D7\u30F3\u5546\u8AC7" }, + home_my_tasks: { label: "\u79C1\u306E\u30AA\u30FC\u30D7\u30F3\u30BF\u30B9\u30AF" }, + ai_briefing: { + title: "AI \u30A2\u30B7\u30B9\u30BF\u30F3\u30C8\u306B\u8CEA\u554F", + label: "\u4ECA\u65E5\u306E AI \u30A2\u30B7\u30B9\u30BF\u30F3\u30C8" + }, + upcoming_events: { title: "\u4ECA\u5F8C\u306E\u4E88\u5B9A", label: "\u4ECA\u5F8C\u306E\u4E88\u5B9A" } + } + }, + utility_bar_page: { + label: "\u30E6\u30FC\u30C6\u30A3\u30EA\u30C6\u30A3\u30D0\u30FC", + description: "\u30D5\u30ED\u30FC\u30C6\u30A3\u30F3\u30B0\u30C4\u30FC\u30EB\u3078\u306E\u30AF\u30A4\u30C3\u30AF\u30A2\u30AF\u30BB\u30B9\u30D0\u30FC", + components: { + notifications_panel: { label: "\u901A\u77E5" }, + quick_notes: { title: "\u30AF\u30A4\u30C3\u30AF\u30E1\u30E2", label: "\u30AF\u30A4\u30C3\u30AF\u30E1\u30E2" }, + quick_search: { label: "\u30AF\u30A4\u30C3\u30AF\u691C\u7D22" } + } + } + }, + // Screen-flow copy (#1210, #1975). Keyed `flows..label`, + // `screens..title` and `screens..fields..{label,placeholder}` + // — the keys `os lint`'s `i18n/missing-flow` names, read by the console's + // flow runner since @objectstack 17.7.0 (the spec's `flows` liveness row is + // `live` there). A screen with no authored `title` shows its flow's label in + // every locale, so each `screen_1.title` repeats the flow label. Since + // 18.0.0-next.0 three more surfaces are keys the engine reads in the run's + // locale, and `i18n/missing-flow` names each missing one: a select field's + // `options.` (worded as the object field's own option in this pack), + // an authored screen `description`, and a refusing `end` node's + // `refusals..message`. A translated description or message is a text + // slot like the one it translates, so a hole in it is `{{ }}`. + // The discount ceiling is interpolated from `QUOTE_DISCOUNT_CEILING`, never + // retyped: the number lives in `_thresholds.ts` alone (#1711). + flows: { + campaign_enrollment: { + label: "\u30AD\u30E3\u30F3\u30DA\u30FC\u30F3\u306B\u30E1\u30F3\u30D0\u30FC\u3092\u767B\u9332", + screens: { + screen_1: { + title: "\u30AD\u30E3\u30F3\u30DA\u30FC\u30F3\u306B\u30E1\u30F3\u30D0\u30FC\u3092\u767B\u9332", + fields: { + memberSource: { label: "\u767B\u9332\u3059\u308B\u30E1\u30F3\u30D0\u30FC\u306E\u7A2E\u985E", options: { leads: "\u30EA\u30FC\u30C9", contacts: "\u53D6\u5F15\u5148\u8CAC\u4EFB\u8005" } }, + leadStatus: { label: "\u767B\u9332\u3059\u308B\u30EA\u30FC\u30C9\u306E\u30B9\u30C6\u30FC\u30BF\u30B9", options: { new: "\u65B0\u898F", contacted: "\u30B3\u30F3\u30BF\u30AF\u30C8\u6E08\u307F", qualified: "\u9069\u683C" } }, + contactDepartment: { + label: "\u767B\u9332\u3059\u308B\u53D6\u5F15\u5148\u8CAC\u4EFB\u8005\u306E\u90E8\u9580", + options: { executive: "\u7D4C\u55B6\u5C64", sales: "\u55B6\u696D\u90E8", marketing: "\u30DE\u30FC\u30B1\u30C6\u30A3\u30F3\u30B0\u90E8", engineering: "\u30A8\u30F3\u30B8\u30CB\u30A2\u30EA\u30F3\u30B0\u90E8", support: "\u30B5\u30DD\u30FC\u30C8\u90E8", finance: "\u7D4C\u7406\u90E8", hr: "\u4EBA\u4E8B\u90E8", operations: "\u30AA\u30DA\u30EC\u30FC\u30B7\u30E7\u30F3\u90E8" } + } + } + } + } + }, + escalate_case: { + label: "\u30B1\u30FC\u30B9\u3092\u30A8\u30B9\u30AB\u30EC\u30FC\u30C8", + screens: { screen_1: { title: "\u30B1\u30FC\u30B9\u3092\u30A8\u30B9\u30AB\u30EC\u30FC\u30C8", fields: { reason: { label: "\u30A8\u30B9\u30AB\u30EC\u30FC\u30B7\u30E7\u30F3\u7406\u7531" } } } } + }, + close_case: { + label: "\u30B1\u30FC\u30B9\u3092\u30AF\u30ED\u30FC\u30BA", + screens: { + screen_1: { + title: "\u30B1\u30FC\u30B9\u3092\u30AF\u30ED\u30FC\u30BA", + fields: { + resolution: { label: "\u89E3\u6C7A\u5185\u5BB9" }, + resolved_by_article: { label: "\u89E3\u6C7A\u306B\u4F7F\u3063\u305F\u30CA\u30EC\u30C3\u30B8\u8A18\u4E8B\uFF08\u4EFB\u610F\uFF09" } + } + } + } + }, + claim_case: { + label: "\u30B1\u30FC\u30B9\u3092\u5F15\u304D\u53D7\u3051\u308B", + screens: { + screen_1: { + title: "\u30B1\u30FC\u30B9\u3092\u5F15\u304D\u53D7\u3051\u308B", + fields: { + claimStatus: { + label: "\u5BFE\u5FDC\u72B6\u6CC1", + options: { in_progress: "\u5BFE\u5FDC\u4E2D", waiting_customer: "\u9867\u5BA2\u306E\u56DE\u7B54\u5F85\u3061", waiting_support: "\u30B5\u30DD\u30FC\u30C8\u306E\u56DE\u7B54\u5F85\u3061" } + } + } + } + } + }, + lead_conversion: { + label: "\u30EA\u30FC\u30C9\u5909\u63DB\u30D7\u30ED\u30BB\u30B9", + screens: { + screen_1: { + title: "\u30EA\u30FC\u30C9\u5909\u63DB\u30D7\u30ED\u30BB\u30B9", + // The duplicate warning's text is a variable the flow assigns; this + // key can only carry the hole that shows it. + description: "{{duplicateWarning}}", + fields: { + createOpportunity: { label: "\u5546\u8AC7\u3092\u4F5C\u6210\u3057\u307E\u3059\u304B\uFF1F" }, + opportunityName: { label: "\u5546\u8AC7\u540D" }, + opportunityAmount: { label: "\u5546\u8AC7\u91D1\u984D" }, + closeDate: { label: "\u5B8C\u4E86\u4E88\u5B9A\u65E5" } + } + }, + refuse_confirmed_duplicate: { + title: "\u5909\u63DB\u306F\u62D2\u5426\u3055\u308C\u307E\u3057\u305F", + description: "\u3053\u306E\u30EA\u30FC\u30C9\u306E\u91CD\u8907\u30B9\u30C6\u30FC\u30BF\u30B9\u306F\u300C\u91CD\u8907\u78BA\u5B9A\u300D\u3067\u3059\u3002\u30EC\u30D3\u30E5\u30FC\u62C5\u5F53\u8005\u304C\u65E2\u5B58\u306E\u30EC\u30B3\u30FC\u30C9\u3068\u7167\u5408\u3057\u3001\u91CD\u8907\u3067\u3042\u308B\u3068\u8A18\u9332\u3057\u307E\u3057\u305F\u3002\u5909\u63DB\u3059\u308B\u3068\u3001\u540C\u3058\u8CFC\u5165\u8005\u306B\u5BFE\u3057\u3066\u53D6\u5F15\u5148\u30FB\u53D6\u5F15\u5148\u8CAC\u4EFB\u8005\u30FB\u5546\u8AC7\u304C\u3082\u3046 1 \u4EF6\u305A\u3064\u4F5C\u6210\u3055\u308C\u307E\u3059\u3002\u6B8B\u3059\u30EC\u30B3\u30FC\u30C9\u306F\u3053\u306E\u30EA\u30FC\u30C9\u306E\u300C\u91CD\u8907\u7BA1\u7406\u300D\u30BB\u30AF\u30B7\u30E7\u30F3\u306B\u8868\u793A\u3055\u308C\u3066\u3044\u307E\u3059\u3002\u4EE3\u308F\u308A\u306B\u3001\u3053\u306E\u30EA\u30FC\u30C9\u3092\u91CD\u8907\u3068\u3057\u3066\u4E0D\u9069\u683C\u306B\u3057\u3066\u304F\u3060\u3055\u3044\u3002\u5909\u63DB\u3092\u518D\u3073\u53EF\u80FD\u306B\u3067\u304D\u308B\u306E\u306F\u3001\u305D\u306E\u5224\u5B9A\u3092\u898B\u76F4\u3059\u30EC\u30D3\u30E5\u30FC\u62C5\u5F53\u8005\u3060\u3051\u3067\u3059\u3002" + }, + refuse_unapproved: { + title: "\u5909\u63DB\u306F\u62D2\u5426\u3055\u308C\u307E\u3057\u305F", + description: "\u3053\u306E\u30EA\u30FC\u30C9\u306F\u307E\u3060\u5909\u63DB\u306E\u627F\u8A8D\u3092\u5F97\u3066\u3044\u307E\u305B\u3093\u3002\u53D6\u5F15\u5148\u30FB\u53D6\u5F15\u5148\u8CAC\u4EFB\u8005\u30FB\u5546\u8AC7\u306B\u5909\u63DB\u3059\u308B\u306B\u306F\u3001\u5148\u306B\u627F\u8A8D\u8005\u306E\u627F\u8A8D\u304C\u5FC5\u8981\u3067\u3059\u3002\u30EA\u30FC\u30C9\u306E\u300C\u30B3\u30F3\u30D0\u30FC\u30B8\u30E7\u30F3\u627F\u8A8D\u300D\u9805\u76EE\u3067\u3001\u5224\u65AD\u304C\u307E\u3060\u627F\u8A8D\u5F85\u3061\u304B\u3001\u5374\u4E0B\u3055\u308C\u305F\u304B\u3092\u78BA\u8A8D\u3067\u304D\u307E\u3059\u3002\u305D\u308C\u307E\u3067\u306E\u9593\u3082\u30EA\u30FC\u30C9\u3078\u306E\u5BFE\u5FDC\u306F\u7D9A\u3051\u3066\u304F\u3060\u3055\u3044\u3002\u51CD\u7D50\u3055\u308C\u308B\u3082\u306E\u306F\u3042\u308A\u307E\u305B\u3093\u3002" + }, + refuse_no_match_key: { + title: "\u5909\u63DB\u306F\u62D2\u5426\u3055\u308C\u307E\u3057\u305F", + description: "\u3053\u306E\u30EA\u30FC\u30C9\u306E\u4F1A\u793E\u540D\u306B\u306F\u7167\u5408\u30AD\u30FC\u304C\u306A\u3044\u305F\u3081\u3001\u5909\u63DB\u3067\u306F\u3069\u306E\u53D6\u5F15\u5148\u306B\u5C5E\u3059\u308B\u304B\u3092\u5224\u65AD\u3067\u304D\u305A\u3001\u63A8\u6E2C\u3082\u3057\u307E\u305B\u3093\u3002\u63A8\u6E2C\u3059\u308B\u3068\u3001\u53D6\u5F15\u5148\u8CAC\u4EFB\u8005\u3068\u5546\u8AC7\u304C\u5225\u306E\u9867\u5BA2\u306E\u4E0B\u306B\u767B\u9332\u3055\u308C\u308B\u304A\u305D\u308C\u304C\u3042\u308A\u307E\u3059\u3002\u30EA\u30FC\u30C9\u306E\u300C\u4F1A\u793E\u540D\u300D\u3092\u4FDD\u5B58\u3059\u308B\u3068\u30AD\u30FC\u304C\u518D\u4F5C\u6210\u3055\u308C\u308B\u306E\u3067\u3001\u3082\u3046\u4E00\u5EA6\u4FDD\u5B58\u3057\u3066\u304B\u3089\u5909\u63DB\u3057\u3066\u304F\u3060\u3055\u3044\u3002\u4F55\u3082\u4F5C\u6210\u3055\u308C\u3066\u3044\u307E\u305B\u3093\u3002" + } + } + }, + schedule_followup: { + label: "\u30D5\u30A9\u30ED\u30FC\u30A2\u30C3\u30D7\u3092\u8A2D\u5B9A", + screens: { + screen_1: { + title: "\u30D5\u30A9\u30ED\u30FC\u30A2\u30C3\u30D7\u3092\u8A2D\u5B9A", + fields: { + subject: { label: "\u6B21\u306E\u30B9\u30C6\u30C3\u30D7\u306F\uFF1F" }, + dueDate: { label: "\u671F\u9650" }, + activityType: { + label: "\u6D3B\u52D5\u7A2E\u5225", + options: { call: "\u96FB\u8A71", email: "\u30E1\u30FC\u30EB", meeting: "\u4F1A\u8B70", follow_up: "\u30D5\u30A9\u30ED\u30FC\u30A2\u30C3\u30D7", demo: "\u30C7\u30E2", other: "\u305D\u306E\u4ED6" } + }, + priority: { label: "\u512A\u5148\u5EA6", options: { low: "\u4F4E", normal: "\u901A\u5E38", high: "\u9AD8", urgent: "\u7DCA\u6025" } }, + notes: { label: "\u30E1\u30E2" } + } + } + } + }, + quote_generation: { + label: "\u5546\u8AC7\u304B\u3089\u898B\u7A4D\u3092\u4F5C\u6210", + refusals: { refuse_held: { message: "\u5148\u306B\u6848\u4EF6\u5316\u627F\u8A8D\u304C\u5FC5\u8981\u3067\u3059\u3002\u300C\u6848\u4EF6\u5316\u627F\u8A8D\u3092\u7533\u8ACB\u300D\u306B\u30C1\u30A7\u30C3\u30AF\u3092\u5165\u308C\u3066\u304F\u3060\u3055\u3044\u3002\u4F55\u3082\u4F5C\u6210\u3055\u308C\u3066\u3044\u307E\u305B\u3093\u3002" } }, + screens: { + screen_1: { + title: "\u5546\u8AC7\u304B\u3089\u898B\u7A4D\u3092\u4F5C\u6210", + fields: { + quoteName: { label: "\u898B\u7A4D\u540D" }, + expirationDays: { label: "\u6709\u52B9\u671F\u9593\uFF08\u65E5\uFF09" }, + discount: { label: `\u5272\u5F15\u7387 % (\u2264 ${QUOTE_DISCOUNT_CEILING})`, placeholder: `0-${QUOTE_DISCOUNT_CEILING}` } + } + } + } + } + } +}; + +// src/sales/translations/ja-JP/_shared.ts +var activityActions3 = { + log_call: { + label: "\u96FB\u8A71\u3092\u8A18\u9332", + successMessage: "\u96FB\u8A71\u3092\u8A18\u9332\u3057\u307E\u3057\u305F\uFF01", + params: { + subject: { label: "\u96FB\u8A71\u306E\u4EF6\u540D" }, + duration: { label: "\u6240\u8981\u6642\u9593\uFF08\u5206\uFF09" }, + attendee_contacts: { label: "\u53D6\u5F15\u5148\u8CAC\u4EFB\u8005\u306E\u53C2\u52A0\u8005" }, + attendee_users: { label: "\u793E\u5185\u53C2\u52A0\u8005" }, + notes: { label: "\u901A\u8A71\u30E1\u30E2" } + } + }, + log_meeting: { + label: "\u4F1A\u8B70\u3092\u8A18\u9332", + successMessage: "\u4F1A\u8B70\u3092\u8A18\u9332\u3057\u307E\u3057\u305F\uFF01", + params: { + subject: { label: "\u4F1A\u8B70\u306E\u4EF6\u540D" }, + duration: { label: "\u6240\u8981\u6642\u9593\uFF08\u5206\uFF09" }, + attendee_contacts: { label: "\u53D6\u5F15\u5148\u8CAC\u4EFB\u8005\u306E\u53C2\u52A0\u8005" }, + attendee_users: { label: "\u793E\u5185\u53C2\u52A0\u8005" }, + notes: { label: "\u8B70\u4E8B\u30E1\u30E2" } + } + }, + schedule_meeting: { + label: "\u4F1A\u8B70\u3092\u8A2D\u5B9A", + successMessage: "\u4F1A\u8B70\u3092\u8A2D\u5B9A\u3057\u307E\u3057\u305F\uFF01", + params: { + subject: { label: "\u4F1A\u8B70\u306E\u4EF6\u540D" }, + start_date: { label: "\u958B\u59CB\u65E5 (UTC)" }, + start_time: { label: "\u958B\u59CB\u6642\u523B (UTC)" }, + location: { label: "\u5834\u6240" }, + duration: { label: "\u6240\u8981\u6642\u9593\uFF08\u5206\uFF09" }, + attendee_contacts: { label: "\u53D6\u5F15\u5148\u8CAC\u4EFB\u8005\u306E\u53C2\u52A0\u8005" }, + attendee_users: { label: "\u793E\u5185\u53C2\u52A0\u8005" }, + notes: { label: "\u30A2\u30B8\u30A7\u30F3\u30C0" } + } + } +}; +var salutationOptions = { mr: "Mr.", ms: "Ms.", mrs: "Mrs.", dr: "\u535A\u58EB", prof: "\u6559\u6388" }; +var industryOptions = { + technology: "\u30C6\u30AF\u30CE\u30ED\u30B8\u30FC", + software: "\u30BD\u30D5\u30C8\u30A6\u30A7\u30A2 / SaaS", + finance: "\u91D1\u878D", + healthcare: "\u30D8\u30EB\u30B9\u30B1\u30A2", + retail: "\u5C0F\u58F2", + manufacturing: "\u88FD\u9020", + education: "\u6559\u80B2", + real_estate: "\u4E0D\u52D5\u7523", + media: "\u30E1\u30C7\u30A3\u30A2\u30FB\u30A8\u30F3\u30BF\u30E1", + logistics: "\u7269\u6D41", + hospitality: "\u30DB\u30B9\u30D4\u30BF\u30EA\u30C6\u30A3", + energy: "\u30A8\u30CD\u30EB\u30AE\u30FC\u30FB\u516C\u76CA", + government: "\u653F\u5E9C\u30FB\u884C\u653F", + nonprofit: "\u975E\u55B6\u5229", + other: "\u305D\u306E\u4ED6" +}; +var leadSourceOptions = { + web: "\u30A6\u30A7\u30D6", + referral: "\u7D39\u4ECB", + event: "\u30A4\u30D9\u30F3\u30C8\u30FB\u5C55\u793A\u4F1A", + webinar: "\u30A6\u30A7\u30D3\u30CA\u30FC", + partner: "\u30D1\u30FC\u30C8\u30CA\u30FC", + advertisement: "\u5E83\u544A", + paid_search: "\u6709\u6599\u691C\u7D22", + social: "\u30BD\u30FC\u30B7\u30E3\u30EB\u30E1\u30C7\u30A3\u30A2", + content: "\u30B3\u30F3\u30C6\u30F3\u30C4\u30FB\u30D6\u30ED\u30B0", + cold_call: "\u30B3\u30FC\u30EB\u30C9\u30B3\u30FC\u30EB", + email_campaign: "\u30E1\u30FC\u30EB\u30AD\u30E3\u30F3\u30DA\u30FC\u30F3", + other: "\u305D\u306E\u4ED6" +}; + +// src/sales/translations/ja-JP/objects.customer.ts +var customer3 = { + crm_account: { + label: "\u53D6\u5F15\u5148", + pluralLabel: "\u53D6\u5F15\u5148", + description: "\u5F53\u793E\u3068\u53D6\u5F15\u306E\u3042\u308B\u4F01\u696D\u30FB\u7D44\u7E54", + fields: { + account_number: { label: "\u53D6\u5F15\u5148\u756A\u53F7" }, + registration_number: { + label: "\u767B\u8A18\u756A\u53F7", + help: "\u53D6\u5F15\u5148\u304C\u81EA\u56FD\u306E\u767B\u8A18\u6A5F\u95A2\u304B\u3089\u4EA4\u4ED8\u3055\u308C\u305F\u767B\u8A18\u4E0A\u306E\u8B58\u5225\u756A\u53F7\u3002\u5F53\u793E\u304C\u63A1\u756A\u3059\u308B\u53D6\u5F15\u5148\u756A\u53F7\u3068\u306F\u7570\u306A\u308A\u307E\u3059\u3002" + }, + commercial_capability: { + label: "\u5546\u8AC7\u53EF\u5426\u533A\u5206", + help: "\u3053\u306E\u53D6\u5F15\u5148\u306B\u5BFE\u3057\u3066\u65B0\u898F\u306E\u5546\u8AC7\u3092\u958B\u59CB\u3067\u304D\u308B\u304B\u3069\u3046\u304B\u3002\u6C7A\u6E08\u306E\u307F\u306E\u53D6\u5F15\u5148\u306F\u8ACB\u6C42\u30FB\u5165\u91D1\u306B\u306F\u5F15\u304D\u7D9A\u304D\u5229\u7528\u3067\u304D\u307E\u3059\u304C\u3001\u65B0\u898F\u5546\u8AC7\u3092\u95A2\u9023\u4ED8\u3051\u308B\u3053\u3068\u306F\u3067\u304D\u307E\u305B\u3093\u3002", + options: { full: "\u5236\u9650\u306A\u3057", settlement_only: "\u6C7A\u6E08\u306E\u307F" } + }, + incumbent_vendor: { label: "\u73FE\u884C\u30D9\u30F3\u30C0\u30FC", help: "\u5F53\u793E\u304C\u72D9\u3063\u3066\u3044\u308B\u652F\u51FA\u3092\u73FE\u5728\u53D7\u6CE8\u3057\u3066\u3044\u308B\u30D9\u30F3\u30C0\u30FC\u3002" }, + annual_purchasing_budget: { label: "\u5E74\u9593\u8ABF\u9054\u4E88\u7B97", help: "\u3053\u306E\u53D6\u5F15\u5148\u304C\u4ECA\u5E74\u5EA6\u30D9\u30F3\u30C0\u30FC\u306B\u652F\u51FA\u3059\u308B\u898B\u8FBC\u307F\u984D\u3067\u3042\u308A\u3001\u81EA\u793E\u306E\u58F2\u4E0A\u9AD8\u3067\u306F\u3042\u308A\u307E\u305B\u3093\u3002" }, + payment_cycle: { + label: "\u652F\u6255\u30B5\u30A4\u30AF\u30EB", + options: { prepaid: "\u524D\u6255\u3044", net_30: "30\u65E5", net_60: "60\u65E5", net_90: "90\u65E5" } + }, + approval_status: { + label: "\u627F\u8A8D\u30B9\u30C6\u30FC\u30BF\u30B9", + help: "\u3053\u306E\u53D6\u5F15\u5148\u306E\u627F\u8A8D\u72B6\u6CC1\u3002\u65B0\u898F\u53D6\u5F15\u5148\u306F\u627F\u8A8D\u5F85\u3061\u3067\u4F5C\u6210\u3055\u308C\u3001\u627F\u8A8D\u30C8\u30EC\u30A4\u3067\u5224\u65AD\u3055\u308C\u307E\u3059\u3002", + options: { pending: "\u627F\u8A8D\u5F85\u3061", approved: "\u627F\u8A8D\u6E08\u307F", rejected: "\u5374\u4E0B" } + }, + name: { label: "\u53D6\u5F15\u5148\u540D", help: "\u4F1A\u793E\u307E\u305F\u306F\u7D44\u7E54\u306E\u6B63\u5F0F\u540D\u79F0" }, + name_normalized: { + label: "\u53D6\u5F15\u5148\u540D\uFF08\u6B63\u898F\u5316\uFF09", + help: "\u30EA\u30FC\u30C9\u5909\u63DB\u306E\u7167\u5408\u30AD\u30FC\u3002\u53D6\u5F15\u5148\u540D\u3092\u5C0F\u6587\u5B57\u5316\u3057\u3001\u524D\u5F8C\u306E\u7A7A\u767D\u3092\u9664\u53BB\u3057\u3066\u3001\u5185\u90E8\u306E\u9023\u7D9A\u3059\u308B\u7A7A\u767D\u3092 1 \u3064\u306B\u307E\u3068\u3081\u305F\u3082\u306E\u3002account_protection \u30D5\u30C3\u30AF\u304C\u81EA\u52D5\u3067\u7DAD\u6301\u3057\u307E\u3059 \u2014 \u76F4\u63A5\u7DE8\u96C6\u3057\u306A\u3044\u3067\u304F\u3060\u3055\u3044\u3002" + }, + display_title: { label: "\u8868\u793A\u540D" }, + type: { + label: "\u30BF\u30A4\u30D7", + options: { prospect: "\u898B\u8FBC\u307F\u5BA2", customer: "\u9867\u5BA2", partner: "\u30D1\u30FC\u30C8\u30CA\u30FC", former: "\u904E\u53BB\u306E\u53D6\u5F15\u5148" } + }, + industry: { + label: "\u696D\u7A2E", + options: { ...industryOptions } + }, + annual_revenue: { label: "\u5E74\u9593\u58F2\u4E0A" }, + child_account_revenue: { label: "\u5B50\u4F1A\u793E\u5E74\u9593\u58F2\u4E0A\u5408\u8A08", help: "\u76F4\u5C5E\u306E\u5B50\u53D6\u5F15\u5148\u306E\u5E74\u9593\u58F2\u4E0A\u306E\u5408\u8A08\u3002" }, + number_of_employees: { label: "\u5F93\u696D\u54E1\u6570" }, + phone: { label: "\u96FB\u8A71\u756A\u53F7" }, + website: { label: "Web\u30B5\u30A4\u30C8" }, + billing_address: { label: "\u8ACB\u6C42\u5148\u4F4F\u6240" }, + billing_country: { + label: "\u8ACB\u6C42\u5148\u56FD", + help: "\u8ACB\u6C42\u5148\u4F4F\u6240\u304B\u3089\u5C0E\u51FA \u2014 \u5165\u529B\u3055\u308C\u305F\u56FD\u540D\u3092\u305D\u306E\u307E\u307E\u3001\u524D\u5F8C\u306E\u7A7A\u767D\u3092\u9664\u53BB\u3057\u5927\u6587\u5B57\u5316\u3057\u305F\u5024\u3002" + }, + territory: { + label: "\u30C6\u30EA\u30C8\u30EA\u30FC", + help: "\u8ACB\u6C42\u5148\u4F4F\u6240\u304B\u3089\u5C0E\u51FA \u2014 \u30C6\u30EA\u30C8\u30EA\u30FC\u5171\u6709\u30EB\u30FC\u30EB\u304C\u7167\u5408\u3059\u308B\u55B6\u696D\u30C6\u30EA\u30C8\u30EA\u30FC\u3002\u62C5\u5F53\u30C1\u30FC\u30E0\u306E\u306A\u3044\u30C6\u30EA\u30C8\u30EA\u30FC\u306E\u53D6\u5F15\u5148\u306F\u300C\u305D\u306E\u4ED6\u300D\u3002", + options: { na: "\u5317\u7C73", emea: "EMEA", other: "\u305D\u306E\u4ED6" } + }, + office_location: { label: "\u30AA\u30D5\u30A3\u30B9\u6240\u5728\u5730" }, + owner_id: { label: "\u53D6\u5F15\u5148\u6240\u6709\u8005" }, + parent_account: { label: "\u89AA\u53D6\u5F15\u5148", help: "\u968E\u5C64\u69CB\u9020\u306B\u304A\u3051\u308B\u89AA\u4F1A\u793E" }, + description: { label: "\u8AAC\u660E" }, + is_active: { label: "\u6709\u52B9" }, + last_activity_date: { label: "\u6700\u7D42\u6D3B\u52D5\u65E5" }, + brand_color: { label: "\u30D6\u30E9\u30F3\u30C9\u30AB\u30E9\u30FC" }, + logo: { label: "\u4F1A\u793E\u30ED\u30B4" }, + tier: { + label: "\u9867\u5BA2\u30E9\u30F3\u30AF", + options: { + strategic: "\u6226\u7565\u9867\u5BA2", + enterprise: "\u30A8\u30F3\u30BF\u30FC\u30D7\u30E9\u30A4\u30BA", + mid_market: "\u30DF\u30C3\u30C9\u30DE\u30FC\u30B1\u30C3\u30C8", + smb: "\u4E2D\u5C0F\u4F01\u696D" + } + }, + segment: { + label: "\u9867\u5BA2\u30BB\u30B0\u30E1\u30F3\u30C8", + options: { net_new: "\u65B0\u898F\u7372\u5F97", growth: "\u6210\u9577", at_risk: "\u30EA\u30B9\u30AF\u3042\u308A", stable: "\u5B89\u5B9A" } + }, + health_score: { + label: "\u30D8\u30EB\u30B9\u30B9\u30B3\u30A2", + help: "\u30AB\u30B9\u30BF\u30DE\u30FC\u30B5\u30AF\u30BB\u30B9\u62C5\u5F53\uFF08CSM\uFF09\u304C\u7BA1\u7406\u3059\u308B\u5065\u5168\u6027\u306E\u6307\u6A19", + options: { healthy: "\u826F\u597D", watching: "\u8981\u89B3\u5BDF", at_risk: "\u30EA\u30B9\u30AF\u3042\u308A", churning: "\u89E3\u7D04\u9032\u884C\u4E2D" } + } + }, + _views: { + all_accounts: { + label: "\u5168\u53D6\u5F15\u5148", + description: "\u58F2\u4E0A\u3068\u696D\u7A2E\u3092\u542B\u3080\u53D6\u5F15\u5148\u306E\u4E00\u89A7", + bulkActions: { + delete: { + label: "\u524A\u9664", + confirmLabel: "\u524A\u9664", + confirmText: "{{count}} \u4EF6\u306E\u53D6\u5F15\u5148\u3092\u5B8C\u5168\u306B\u524A\u9664\u3057\u307E\u3059\u304B\uFF1F\u3053\u306E\u64CD\u4F5C\u306F\u53D6\u308A\u6D88\u305B\u307E\u305B\u3093\u3002" + }, + transfer_owner: { + label: "\u6240\u6709\u8005\u306E\u5909\u66F4", + confirmText: "{{count}} \u4EF6\u306E\u53D6\u5F15\u5148\u306E\u6240\u6709\u8005\u3092\u5909\u66F4\u3057\u307E\u3059\u304B\uFF1F", + params: { + owner_id: { + label: "\u65B0\u3057\u3044\u6240\u6709\u8005" + } + } + }, + update_tier: { + label: "\u9867\u5BA2\u30E9\u30F3\u30AF\u306E\u66F4\u65B0", + confirmText: "{{count}} \u4EF6\u306E\u53D6\u5F15\u5148\u306E\u9867\u5BA2\u30E9\u30F3\u30AF\u3092 {{tier}} \u306B\u66F4\u65B0\u3057\u307E\u3059\u304B\uFF1F", + params: { + tier: { + label: "\u9867\u5BA2\u30E9\u30F3\u30AF" + } + } + } + } + }, + account_gallery: { label: "\u53D6\u5F15\u5148\u30AB\u30FC\u30C9", description: "\u30D6\u30E9\u30F3\u30C9\u30AB\u30E9\u30FC\u4ED8\u304D\u306E\u30AB\u30FC\u30C9\u30D3\u30E5\u30FC" }, + account_map: { label: "\u53D6\u5F15\u5148\u30DE\u30C3\u30D7", description: "\u53D6\u5F15\u5148\u306E\u5730\u7406\u7684\u5206\u5E03" }, + enterprise_accounts: { label: "\u30A8\u30F3\u30BF\u30FC\u30D7\u30E9\u30A4\u30BA\u53D6\u5F15\u5148", description: "\u5E74\u5546\u6700\u4E0A\u4F4D\u306E\u4E3B\u8981\u9867\u5BA2" }, + my_accounts: { label: "\u79C1\u306E\u53D6\u5F15\u5148", description: "\u81EA\u5206\u304C\u6240\u6709\u3059\u308B\u53D6\u5F15\u5148" }, + at_risk_accounts: { label: "\u26A0\uFE0F \u30EA\u30B9\u30AF\u306E\u3042\u308B\u53D6\u5F15\u5148" } + }, + _sections: { + basic: { label: "\u57FA\u672C\u60C5\u5831" }, + financials: { label: "\u8CA1\u52D9\u60C5\u5831" }, + business_profile: { label: "\u30D3\u30B8\u30CD\u30B9\u60C5\u5831" }, + contact_info: { label: "\u9023\u7D61\u5148\u60C5\u5831" }, + ownership: { label: "\u6240\u6709\u8005\u30FB\u30B9\u30C6\u30FC\u30BF\u30B9" }, + branding: { label: "\u30D6\u30E9\u30F3\u30C7\u30A3\u30F3\u30B0" }, + system: { label: "\u30B7\u30B9\u30C6\u30E0" }, + // account.view.ts のフォームセクション名 (#1100) + profile: { label: "\u30D7\u30ED\u30D5\u30A3\u30FC\u30EB" }, + customer_success: { label: "\u30AB\u30B9\u30BF\u30DE\u30FC\u30B5\u30AF\u30BB\u30B9" }, + locations: { label: "\u6240\u5728\u5730" }, + description: { label: "\u8AAC\u660E" } + }, + _actions: { ...activityActions3 } + }, + crm_contact: { + label: "\u53D6\u5F15\u5148\u8CAC\u4EFB\u8005", + pluralLabel: "\u53D6\u5F15\u5148\u8CAC\u4EFB\u8005", + description: "\u53D6\u5F15\u5148\u306B\u6240\u5C5E\u3059\u308B\u62C5\u5F53\u8005", + fields: { + salutation: { label: "\u656C\u79F0", options: { ...salutationOptions } }, + first_name: { label: "\u540D" }, + last_name: { label: "\u59D3" }, + full_name: { label: "\u6C0F\u540D" }, + crm_account: { label: "\u53D6\u5F15\u5148" }, + email: { label: "\u30E1\u30FC\u30EB" }, + phone: { label: "\u96FB\u8A71" }, + mobile: { label: "\u643A\u5E2F\u96FB\u8A71" }, + title: { label: "\u5F79\u8077" }, + department: { + label: "\u90E8\u9580", + options: { + executive: "\u7D4C\u55B6\u5C64", + sales: "\u55B6\u696D\u90E8", + marketing: "\u30DE\u30FC\u30B1\u30C6\u30A3\u30F3\u30B0\u90E8", + engineering: "\u30A8\u30F3\u30B8\u30CB\u30A2\u30EA\u30F3\u30B0\u90E8", + support: "\u30B5\u30DD\u30FC\u30C8\u90E8", + finance: "\u7D4C\u7406\u90E8", + hr: "\u4EBA\u4E8B\u90E8", + operations: "\u30AA\u30DA\u30EC\u30FC\u30B7\u30E7\u30F3\u90E8" + } + }, + // バイイングセンター (REQ-0004) — 意思決定のマップ。英語ラベルは + // 'Buying Role' ではなく 'Buying Function'：security-role-word ルールが + // 宣言側で英単語 role を予約している (ADR-0090 D3)。同ルールは英語のみを + // 読み言語パックには及ばないため、ここでは日本語として自然な語を使う。 + buying_function: { + label: "\u8CFC\u8CB7\u5F79\u5272", + options: { + decision_maker: "\u6C7A\u88C1\u8005", + economic_buyer: "\u4E88\u7B97\u6C7A\u88C1\u8005", + technical_evaluator: "\u6280\u8853\u8A55\u4FA1\u8005", + user: "\u5229\u7528\u8005", + influencer: "\u5F71\u97FF\u8005", + gatekeeper: "\u30B2\u30FC\u30C8\u30AD\u30FC\u30D1\u30FC" + } + }, + attitude: { + label: "\u81EA\u793E\u3078\u306E\u614B\u5EA6", + options: { + champion: "\u63A8\u9032\u8005", + supportive: "\u597D\u610F\u7684", + neutral: "\u4E2D\u7ACB", + skeptical: "\u61D0\u7591\u7684", + blocker: "\u53CD\u5BFE\u8005" + } + }, + relationship_strength: { + label: "\u95A2\u4FC2\u306E\u5F37\u3055", + options: { + distant: "\u758E\u9060", + acquaintance: "\u9854\u898B\u77E5\u308A", + working: "\u696D\u52D9\u4E0A\u306E\u95A2\u4FC2", + strong: "\u5F37\u3044", + trusted_advisor: "\u4FE1\u983C\u3055\u308C\u308B\u30A2\u30C9\u30D0\u30A4\u30B6\u30FC" + } + }, + owner_id: { label: "\u53D6\u5F15\u5148\u8CAC\u4EFB\u8005\u306E\u6240\u6709\u8005" }, + description: { label: "\u8AAC\u660E" }, + is_primary: { label: "\u4E3B\u62C5\u5F53\u8005", help: "\u3053\u306E\u53D6\u5F15\u5148\u306E\u4E3B\u62C5\u5F53\u8005\u304B\u3069\u3046\u304B" }, + avatar: { label: "\u30D7\u30ED\u30D5\u30A3\u30FC\u30EB\u753B\u50CF" }, + mailing_address: { label: "\u90F5\u9001\u5148\u4F4F\u6240" }, + lead_source: { label: "\u30EA\u30FC\u30C9\u30BD\u30FC\u30B9", options: { ...leadSourceOptions } }, + do_not_call: { label: "\u96FB\u8A71\u62D2\u5426" }, + email_opt_out: { label: "\u30E1\u30FC\u30EB\u914D\u4FE1\u505C\u6B62" }, + last_contacted_date: { label: "\u6700\u7D42\u63A5\u89E6\u65E5\u6642" } + }, + _views: { + all_contacts: { label: "\u5168\u53D6\u5F15\u5148\u8CAC\u4EFB\u8005" }, + contact_directory: { label: "\u8CAC\u4EFB\u8005\u30C7\u30A3\u30EC\u30AF\u30C8\u30EA" }, + primary_contacts: { label: "\u4E3B\u62C5\u5F53\u8005" } + }, + _sections: { + identity: { label: "\u57FA\u672C\u60C5\u5831" }, + account_info: { label: "\u53D6\u5F15\u5148\u30FB\u5F79\u8077" }, + buying_centre: { label: "\u30D0\u30A4\u30A4\u30F3\u30B0\u30BB\u30F3\u30BF\u30FC" }, + contact_info: { label: "\u9023\u7D61\u5148\u60C5\u5831" }, + mailing_address: { label: "\u90F5\u9001\u5148\u4F4F\u6240" }, + additional: { label: "\u305D\u306E\u4ED6\u306E\u60C5\u5831" }, + preferences: { label: "\u30B3\u30DF\u30E5\u30CB\u30B1\u30FC\u30B7\u30E7\u30F3\u8A2D\u5B9A" }, + // contact.view.ts のフォームセクション名 (#1100) + contact_details: { label: "\u9023\u7D61\u5148\u60C5\u5831" }, + comm_preferences: { label: "\u8A2D\u5B9A" } + }, + _actions: { + ...activityActions3, + mark_primary: { + label: "\u4E3B\u62C5\u5F53\u8005\u306B\u8A2D\u5B9A", + confirmText: "\u3053\u306E\u8CAC\u4EFB\u8005\u3092\u53D6\u5F15\u5148\u306E\u4E3B\u62C5\u5F53\u8005\u306B\u8A2D\u5B9A\u3057\u307E\u3059\u304B\uFF1F", + successMessage: "\u4E3B\u62C5\u5F53\u8005\u306B\u8A2D\u5B9A\u3057\u307E\u3057\u305F\uFF01" + }, + send_email: { + label: "\u30E1\u30FC\u30EB\u9001\u4FE1", + params: { + subject: { label: "\u4EF6\u540D" }, + body: { label: "\u672C\u6587" } + } + }, + add_contact_to_campaign: { + label: "\u30AD\u30E3\u30F3\u30DA\u30FC\u30F3\u306B\u8FFD\u52A0", + successMessage: "\u53D6\u5F15\u5148\u8CAC\u4EFB\u8005\u3092\u30AD\u30E3\u30F3\u30DA\u30FC\u30F3\u306B\u8FFD\u52A0\u3057\u307E\u3057\u305F\uFF01", + params: { + crm_campaign: { label: "\u30AD\u30E3\u30F3\u30DA\u30FC\u30F3" } + } + } + } + } +}; + +// src/sales/translations/ja-JP/objects.pipeline.ts +var opportunityStageOptions = { + prospecting: "\u898B\u8FBC\u307F\u8ABF\u67FB", + qualification: "\u9078\u5B9A", + needs_analysis: "\u30CB\u30FC\u30BA\u5206\u6790", + proposal: "\u63D0\u6848", + negotiation: "\u4EA4\u6E09", + closed_won: "\u6210\u7ACB", + closed_lost: "\u4E0D\u6210\u7ACB" +}; +var pipeline3 = { + crm_lead: { + _validations: { + disqualification_reason_required: { + message: "\u30EA\u30FC\u30C9\u3092\u300C\u5BFE\u8C61\u5916\u300D\u306B\u3059\u308B\u5834\u5408\u306F\u5931\u683C\u7406\u7531\u304C\u5FC5\u8981\u3067\u3059" + }, + duplicate_disqualification_requires_survivor: { + message: "\u91CD\u8907\u3092\u7406\u7531\u306B\u30EA\u30FC\u30C9\u3092\u5931\u683C\u3068\u3059\u308B\u5834\u5408\u306F\u3001\u6B8B\u3059\u30EC\u30B3\u30FC\u30C9\u3092\u6307\u5B9A\u3057\u3001\u91CD\u8907\u30B9\u30C6\u30FC\u30BF\u30B9\u3092\u300C\u78BA\u8A8D\u6E08\u307F\u300D\u306B\u3059\u308B\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059" + }, + email_required: { + message: "\u30E1\u30FC\u30EB\u30A2\u30C9\u30EC\u30B9\u306F\u5FC5\u9808\u3067\u3059" + }, + lead_status_progression: { + message: "\u7121\u52B9\u306A\u30EA\u30FC\u30C9\u30B9\u30C6\u30FC\u30BF\u30B9\u9077\u79FB\u3067\u3059" + } + }, + label: "\u30EA\u30FC\u30C9", + pluralLabel: "\u30EA\u30FC\u30C9", + description: "\u307E\u3060\u9069\u683C\u5224\u5B9A\u3092\u53D7\u3051\u3066\u3044\u306A\u3044\u898B\u8FBC\u307F\u5BA2", + fields: { + salutation: { label: "\u656C\u79F0", options: { ...salutationOptions } }, + first_name: { label: "\u540D" }, + last_name: { label: "\u59D3" }, + full_name: { label: "\u6C0F\u540D" }, + display_title: { label: "\u8868\u793A\u540D" }, + company: { label: "\u4F1A\u793E\u540D" }, + company_normalized: { + label: "\u4F1A\u793E\u540D\uFF08\u6B63\u898F\u5316\uFF09", + help: "\u30EA\u30FC\u30C9\u5909\u63DB\u306E\u7167\u5408\u30AD\u30FC\u3002\u4F1A\u793E\u540D\u3092\u5C0F\u6587\u5B57\u5316\u3057\u3001\u524D\u5F8C\u306E\u7A7A\u767D\u3092\u9664\u53BB\u3057\u3066\u3001\u5185\u90E8\u306E\u9023\u7D9A\u3059\u308B\u7A7A\u767D\u3092 1 \u3064\u306B\u307E\u3068\u3081\u305F\u3082\u306E\u3002lead_duplicate_check \u30D5\u30C3\u30AF\u304C\u81EA\u52D5\u3067\u7DAD\u6301\u3057\u307E\u3059 \u2014 \u76F4\u63A5\u7DE8\u96C6\u3057\u306A\u3044\u3067\u304F\u3060\u3055\u3044\u3002" + }, + title: { label: "\u5F79\u8077" }, + email: { label: "\u30E1\u30FC\u30EB" }, + phone: { label: "\u96FB\u8A71" }, + industry: { + label: "\u696D\u7A2E", + options: { ...industryOptions } + }, + status: { + label: "\u30B9\u30C6\u30FC\u30BF\u30B9", + options: { + new: "\u65B0\u898F", + contacted: "\u30B3\u30F3\u30BF\u30AF\u30C8\u6E08\u307F", + qualified: "\u9069\u683C", + unqualified: "\u4E0D\u9069\u683C", + converted: "\u5909\u63DB\u6E08\u307F" + } + }, + lead_source: { label: "\u30EA\u30FC\u30C9\u30BD\u30FC\u30B9", options: { ...leadSourceOptions } }, + owner_id: { label: "\u30EA\u30FC\u30C9\u6240\u6709\u8005" }, + is_converted: { label: "\u5909\u63DB\u6E08\u307F" }, + description: { label: "\u8AAC\u660E" }, + mobile: { label: "\u643A\u5E2F\u96FB\u8A71" }, + website: { label: "Web\u30B5\u30A4\u30C8" }, + rating: { label: "\u30EA\u30FC\u30C9\u30B9\u30B3\u30A2", help: "\u30EA\u30FC\u30C9\u306E\u54C1\u8CEA\u30B9\u30B3\u30A2\uFF081\u301C5 \u6BB5\u968E\uFF09" }, + converted_account: { label: "\u5909\u63DB\u5F8C\u306E\u53D6\u5F15\u5148" }, + converted_contact: { label: "\u5909\u63DB\u5F8C\u306E\u53D6\u5F15\u5148\u8CAC\u4EFB\u8005" }, + converted_opportunity: { label: "\u5909\u63DB\u5F8C\u306E\u5546\u8AC7" }, + converted_date: { label: "\u5909\u63DB\u65E5" }, + address: { label: "\u4F4F\u6240" }, + annual_revenue: { label: "\u5E74\u9593\u58F2\u4E0A" }, + number_of_employees: { label: "\u5F93\u696D\u54E1\u6570" }, + notes: { label: "\u30E1\u30E2", help: "\u3053\u306E\u30EA\u30FC\u30C9\u306B\u95A2\u3059\u308B\u4F5C\u696D\u30E1\u30E2 \u2014 \u66F8\u5F0F\u8A2D\u5B9A\u306B\u5BFE\u5FDC\u3002" }, + do_not_call: { label: "\u96FB\u8A71\u62D2\u5426" }, + email_opt_out: { label: "\u30E1\u30FC\u30EB\u914D\u4FE1\u505C\u6B62" }, + next_followup_date: { label: "\u6B21\u56DE\u30D5\u30A9\u30ED\u30FC\u30A2\u30C3\u30D7\u65E5" }, + last_contacted_date: { label: "\u6700\u7D42\u63A5\u89E6\u65E5\u6642" }, + need_type: { + label: "\u30CB\u30FC\u30BA\u7A2E\u5225", + help: "\u3053\u306E\u898B\u8FBC\u5BA2\u304C\u4F55\u3092\u6C42\u3081\u3066\u3044\u308B\u304B\u3002\u5272\u308A\u5F53\u3066\u30FB\u512A\u5148\u9806\u4F4D\u4ED8\u3051\u30FB\u9700\u8981\u5206\u6790\u304C\u3053\u306E\u9805\u76EE\u3092\u53C2\u7167\u3057\u307E\u3059\u3002", + options: { + new_implementation: "\u65B0\u898F\u5C0E\u5165", + expansion: "\u62E1\u5F35\u30FB\u8FFD\u52A0", + replacement: "\u5165\u308C\u66FF\u3048\u30FB\u79FB\u884C", + renewal: "\u66F4\u65B0", + consulting: "\u30B3\u30F3\u30B5\u30EB\u30C6\u30A3\u30F3\u30B0", + support: "\u4FDD\u5B88\u30FB\u30B5\u30DD\u30FC\u30C8", + other: "\u305D\u306E\u4ED6" + } + }, + estimated_amount: { + label: "\u4E88\u60F3\u91D1\u984D", + help: "\u30AF\u30AA\u30EA\u30D5\u30A3\u30B1\u30FC\u30B7\u30E7\u30F3\u524D\u306E\u9700\u8981\u91D1\u984D\u306E\u898B\u7A4D\u308A\u3002\u30B3\u30F3\u30D0\u30FC\u30B8\u30E7\u30F3\u6642\u306B\u5546\u8AC7\u91D1\u984D\u3078\u521D\u671F\u5024\u3068\u3057\u3066\u5165\u308A\u307E\u3059\u3002" + }, + conversion_approval_status: { + label: "\u30B3\u30F3\u30D0\u30FC\u30B8\u30E7\u30F3\u627F\u8A8D", + help: "\u3053\u306E\u898B\u8FBC\u5BA2\u304C\u30B3\u30F3\u30D0\u30FC\u30B8\u30E7\u30F3\u306E\u627F\u8A8D\u3092\u5F97\u3066\u3044\u308B\u304B\u3002\u300C\u627F\u8A8D\u4E0D\u8981\u300D\u306F\u627F\u8A8D\u3092\u6C42\u3081\u306A\u3044\u72B6\u614B\u3067\u3001\u51FA\u8377\u6642\u306E\u65E2\u5B9A\u5024\u3067\u3059\u3002", + options: { + not_required: "\u627F\u8A8D\u4E0D\u8981", + pending: "\u627F\u8A8D\u5F85\u3061", + approved: "\u627F\u8A8D\u6E08\u307F", + rejected: "\u5374\u4E0B" + } + }, + disqualification_reason: { + label: "\u4E0D\u9069\u683C\u7406\u7531", + help: "\u30B9\u30C6\u30FC\u30BF\u30B9\u304C\u300C\u4E0D\u9069\u683C\u300D\u306E\u5834\u5408\u306F\u5FC5\u9808", + options: { + not_a_fit: "\u30CB\u30FC\u30BA\u304C\u5408\u308F\u306A\u3044", + no_budget: "\u4E88\u7B97\u306A\u3057", + wrong_persona: "\u62C5\u5F53\u8005\u304C\u7570\u306A\u308B", + unreachable: "\u9023\u7D61\u4E0D\u80FD", + duplicate: "\u91CD\u8907\u30EA\u30FC\u30C9", + competitor: "\u7AF6\u5408\u4ED6\u793E\u306B\u6C7A\u5B9A", + other: "\u305D\u306E\u4ED6" + } + }, + duplicate_of_type: { + label: "\u91CD\u8907\u5BFE\u8C61", + help: "\u91CD\u8907\u5143\u3068\u3057\u3066\u6B8B\u308B\u30EC\u30B3\u30FC\u30C9\u304C\u5C5E\u3059\u308B\u30AA\u30D6\u30B8\u30A7\u30AF\u30C8\u306E\u7A2E\u5225\u3002", + // `erased` は墓碑値であり選択肢ではない。フォームには表示しない + // （`src/sales/views/lead.view.ts` を参照）が、残存レコードが削除された + // リードはこの値を保持するため、レコードを読む場所ではラベルが要る。 + options: { crm_lead: "\u30EA\u30FC\u30C9", crm_contact: "\u53D6\u5F15\u5148\u8CAC\u4EFB\u8005", erased: "\u524A\u9664\u6E08\u307F\u30EC\u30B3\u30FC\u30C9" } + }, + duplicate_of_lead: { label: "\u91CD\u8907\u3059\u308B\u30EA\u30FC\u30C9" }, + duplicate_of_contact: { label: "\u91CD\u8907\u3059\u308B\u53D6\u5F15\u5148\u8CAC\u4EFB\u8005" }, + duplicate_status: { + label: "\u91CD\u8907\u30B9\u30C6\u30FC\u30BF\u30B9", + help: "\u300C\u91CD\u8907\u306E\u7591\u3044\u300D= \u767B\u9332\u6642\u306B\u81EA\u52D5\u3067\u4ED8\u4E0E\u3002\u300C\u91CD\u8907\u78BA\u5B9A\u300D= \u62C5\u5F53\u8005\u304C\u4E00\u81F4\u3092\u78BA\u8A8D\u6E08\u307F\u3002", + options: { suspected: "\u91CD\u8907\u306E\u7591\u3044", confirmed: "\u91CD\u8907\u78BA\u5B9A" } + } + }, + _views: { + all_leads: { + label: "\u5168\u30EA\u30FC\u30C9", + emptyState: { title: "\u30EA\u30FC\u30C9\u304C\u307E\u3060\u3042\u308A\u307E\u305B\u3093", message: "\u6700\u521D\u306E\u30EA\u30FC\u30C9\u3092\u4F5C\u6210\u3057\u3066\u59CB\u3081\u307E\u3057\u3087\u3046" } + }, + kanban_by_status: { label: "\u30EA\u30FC\u30C9\u30D1\u30A4\u30D7\u30E9\u30A4\u30F3" }, + calendar_by_created: { label: "\u30EA\u30FC\u30C9\u30AB\u30EC\u30F3\u30C0\u30FC" }, + gallery_view: { label: "\u30EA\u30FC\u30C9\u30AB\u30FC\u30C9" }, + my_leads: { label: "\u79C1\u306E\u30EA\u30FC\u30C9" }, + high_priority: { label: "\u512A\u5148\u5EA6\u9AD8" }, + hot_leads: { label: "\u{1F525} \u30DB\u30C3\u30C8\u30EA\u30FC\u30C9" }, + suspected_duplicates: { + label: "\u91CD\u8907\u306E\u7591\u3044\u304C\u3042\u308B\u30EA\u30FC\u30C9", + emptyState: { + title: "\u91CD\u8907\u306E\u7591\u3044\u306F\u3042\u308A\u307E\u305B\u3093", + message: "\u78BA\u8A8D\u306F\u4E0D\u8981\u3067\u3059 \u2014 \u518D\u767B\u9332\u3055\u308C\u305F\u30E1\u30FC\u30EB\u30A2\u30C9\u30EC\u30B9\u306F\u3059\u3079\u3066\u30C1\u30A7\u30C3\u30AF\u6E08\u307F\u3067\u3059\u3002" + } + } + }, + _sections: { + // オブジェクト定義のセクションキー（lead.object.ts）— 入力フォームと、 + // これらのグループを参照する詳細ページのセクション（#806）で使用 + address: { label: "\u4F4F\u6240" }, + identity: { label: "\u57FA\u672C\u60C5\u5831" }, + company_info: { label: "\u4F1A\u793E\u60C5\u5831" }, + contact_info: { label: "\u9023\u7D61\u5148\u60C5\u5831" }, + qualification: { label: "\u9069\u683C\u5224\u5B9A" }, + assignment: { label: "\u62C5\u5F53\u8005" }, + additional: { label: "\u305D\u306E\u4ED6\u306E\u60C5\u5831" }, + preferences: { label: "\u30B3\u30DF\u30E5\u30CB\u30B1\u30FC\u30B7\u30E7\u30F3\u8A2D\u5B9A" }, + conversion: { label: "\u5909\u63DB" }, + duplicates: { label: "\u91CD\u8907\u7BA1\u7406" }, + // lead.view.ts のフォームセクション名 (#1100) — デフォルトフォームと + // 名前付き formView すべてのセクション名がここに集まる。あちらにフォームを + // 追加したら、そのセクション名をここに追加する。 + contact_information: { label: "\u9023\u7D61\u5148\u60C5\u5831" }, + lead_classification: { label: "\u30EA\u30FC\u30C9\u5206\u985E" }, + company_information: { label: "\u4F1A\u793E\u60C5\u5831" }, + additional_information: { label: "\u8FFD\u52A0\u60C5\u5831" }, + privacy: { label: "\u30D7\u30E9\u30A4\u30D0\u30B7\u30FC" }, + general: { label: "\u4E00\u822C" }, + details: { label: "\u8A73\u7D30" }, + step_1_contact_details: { label: "\u30B9\u30C6\u30C3\u30D71\uFF1A\u9023\u7D61\u5148\u60C5\u5831" }, + step_2_company_information: { label: "\u30B9\u30C6\u30C3\u30D72\uFF1A\u4F1A\u793E\u60C5\u5831" }, + step_3_qualification: { label: "\u30B9\u30C6\u30C3\u30D73\uFF1A\u8CC7\u683C\u8A55\u4FA1" }, + step_4_review_and_convert: { label: "\u30B9\u30C6\u30C3\u30D74\uFF1A\u78BA\u8A8D\u3068\u5909\u63DB" }, + primary_information: { label: "\u4E3B\u8981\u60C5\u5831" }, + extended_details: { label: "\u8A73\u7D30\u60C5\u5831" }, + quick_edit: { label: "\u30AF\u30A4\u30C3\u30AF\u7DE8\u96C6" }, + update_lead_status: { label: "\u30EA\u30FC\u30C9\u30B9\u30C6\u30FC\u30BF\u30B9\u3092\u66F4\u65B0" }, + tell_us_about_yourself: { label: "\u3042\u306A\u305F\u306B\u3064\u3044\u3066\u6559\u3048\u3066\u304F\u3060\u3055\u3044" }, + about_your_company: { label: "\u8CB4\u793E\u306B\u3064\u3044\u3066" }, + how_can_we_help: { label: "\u3069\u306E\u3088\u3046\u306A\u3054\u7528\u4EF6\u3067\u3057\u3087\u3046\u304B\uFF1F" }, + lead_information: { label: "\u30EA\u30FC\u30C9\u60C5\u5831" }, + address_information: { label: "\u4F4F\u6240\u60C5\u5831" }, + privacy_preferences: { label: "\u30D7\u30E9\u30A4\u30D0\u30B7\u30FC\u8A2D\u5B9A" } + }, + _actions: { + ...activityActions3, + convert_lead: { + label: "\u30EA\u30FC\u30C9\u5909\u63DB", + successMessage: "\u30EA\u30FC\u30C9\u306E\u5909\u63DB\u306B\u6210\u529F\u3057\u307E\u3057\u305F\uFF01" + }, + create_campaign: { + label: "\u30AD\u30E3\u30F3\u30DA\u30FC\u30F3\u306B\u8FFD\u52A0", + successMessage: "\u30AD\u30E3\u30F3\u30DA\u30FC\u30F3\u306B\u8FFD\u52A0\u3057\u307E\u3057\u305F\uFF01", + params: { + crm_campaign: { label: "\u30AD\u30E3\u30F3\u30DA\u30FC\u30F3" } + } + }, + schedule_followup: { + label: "\u30D5\u30A9\u30ED\u30FC\u30A2\u30C3\u30D7\u3092\u8A2D\u5B9A", + successMessage: "\u30D5\u30A9\u30ED\u30FC\u30A2\u30C3\u30D7\u3092\u8A2D\u5B9A\u3057\u307E\u3057\u305F\u3002" + } + } + }, + crm_opportunity: { + _validations: { + amount_positive: { + message: "\u91D1\u984D\u306F 0 \u3088\u308A\u5927\u304D\u3044\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059" + }, + close_date_future: { + message: "\u5546\u8AC7\u304C\u30AF\u30ED\u30FC\u30BA\u3057\u3066\u3044\u308B\u5834\u5408\u3092\u9664\u304D\u3001\u5B8C\u4E86\u4E88\u5B9A\u65E5\u3092\u904E\u53BB\u306B\u8A2D\u5B9A\u3059\u308B\u3053\u3068\u306F\u3067\u304D\u307E\u305B\u3093" + }, + opportunity_stage_progression: { + message: "\u7121\u52B9\u306A\u5546\u8AC7\u30B9\u30C6\u30FC\u30B8\u9077\u79FB\u3067\u3059" + } + }, + label: "\u5546\u8AC7", + pluralLabel: "\u5546\u8AC7", + description: "\u30D1\u30A4\u30D7\u30E9\u30A4\u30F3\u4E0A\u306E\u5546\u8AC7\u30FB\u6848\u4EF6", + fields: { + name: { label: "\u5546\u8AC7\u540D" }, + crm_account: { label: "\u53D6\u5F15\u5148" }, + primary_contact: { label: "\u4E3B\u62C5\u5F53\u8005" }, + owner_id: { label: "\u5546\u8AC7\u6240\u6709\u8005" }, + amount: { label: "\u91D1\u984D" }, + expected_revenue: { label: "\u671F\u5F85\u53CE\u76CA" }, + stage: { + label: "\u30B9\u30C6\u30FC\u30B8", + options: { ...opportunityStageOptions } + }, + probability: { label: "\u78BA\u5EA6 (%)" }, + close_date: { label: "\u5B8C\u4E86\u4E88\u5B9A\u65E5" }, + type: { + label: "\u30BF\u30A4\u30D7", + options: { + new_business: "\u65B0\u898F\u30D3\u30B8\u30CD\u30B9", + existing_upgrade: "\u65E2\u5B58\u9867\u5BA2 - \u30A2\u30C3\u30D7\u30B0\u30EC\u30FC\u30C9", + existing_renewal: "\u65E2\u5B58\u9867\u5BA2 - \u66F4\u65B0", + existing_expansion: "\u65E2\u5B58\u9867\u5BA2 - \u62E1\u5927" + } + }, + forecast_category: { + label: "\u58F2\u4E0A\u4E88\u6E2C\u30AB\u30C6\u30B4\u30EA", + options: { + pipeline: "\u30D1\u30A4\u30D7\u30E9\u30A4\u30F3", + best_case: "\u30D9\u30B9\u30C8\u30B1\u30FC\u30B9", + commit: "\u30B3\u30DF\u30C3\u30C8", + omitted: "\u9664\u5916", + closed: "\u5B8C\u4E86" + } + }, + description: { label: "\u8AAC\u660E" }, + next_step: { label: "\u6B21\u306E\u30B9\u30C6\u30C3\u30D7" }, + lead_source: { label: "\u30EA\u30FC\u30C9\u30BD\u30FC\u30B9", options: { ...leadSourceOptions } }, + crm_campaign: { label: "\u30AD\u30E3\u30F3\u30DA\u30FC\u30F3", help: "\u3053\u306E\u5546\u8AC7\u3092\u751F\u307F\u51FA\u3057\u305F\u30DE\u30FC\u30B1\u30C6\u30A3\u30F3\u30B0\u30AD\u30E3\u30F3\u30DA\u30FC\u30F3" }, + days_in_stage: { label: "\u73FE\u30B9\u30C6\u30FC\u30B8\u6EDE\u5728\u65E5\u6570" }, + stage_entry_date: { label: "\u30B9\u30C6\u30FC\u30B8\u958B\u59CB\u65E5", help: "\u3053\u306E\u5546\u8AC7\u304C\u73FE\u5728\u306E\u30B9\u30C6\u30FC\u30B8\u306B\u5165\u3063\u305F\u65E5\u3002" }, + is_private: { label: "\u975E\u516C\u958B" }, + approval_status: { + label: "\u627F\u8A8D\u30B9\u30C6\u30FC\u30BF\u30B9", + options: { not_required: "\u627F\u8A8D\u4E0D\u8981", pending: "\u627F\u8A8D\u5F85\u3061", approved: "\u627F\u8A8D\u6E08\u307F", rejected: "\u5374\u4E0B" } + }, + approved_date: { label: "\u627F\u8A8D\u65E5" }, + // #593 — 商談クローズ時に必須。失注理由は営業ダッシュボードの + // 内訳ウィジェットにも出るため、保存値がそのまま画面に出てはいけない。 + win_reason: { + label: "\u53D7\u6CE8\u7406\u7531", + help: "\u53D7\u6CE8\u306B\u81F3\u3063\u305F\u7406\u7531\u3002\u5546\u8AC7\u3092\u300C\u6210\u7ACB\u300D\u3067\u30AF\u30ED\u30FC\u30BA\u3059\u308B\u969B\u306B\u5FC5\u9808\u3067\u3059\u3002", + options: { + better_product: "\u88FD\u54C1\u304C\u512A\u308C\u3066\u3044\u308B", + better_price: "\u4FA1\u683C\u304C\u512A\u308C\u3066\u3044\u308B", + relationship: "\u65E2\u5B58\u306E\u95A2\u4FC2", + better_support: "\u30B5\u30DD\u30FC\u30C8\u304C\u512A\u308C\u3066\u3044\u308B", + best_fit: "\u6700\u9069\u306A\u6A5F\u80FD\u30FB\u9069\u5408\u6027", + quote_accepted: "\u898B\u7A4D\u627F\u8A8D", + other: "\u305D\u306E\u4ED6" + } + }, + loss_reason: { + label: "\u5931\u6CE8\u7406\u7531", + help: "\u5931\u6CE8\u3057\u305F\u7406\u7531\u3002\u5546\u8AC7\u3092\u300C\u4E0D\u6210\u7ACB\u300D\u3067\u30AF\u30ED\u30FC\u30BA\u3059\u308B\u969B\u306B\u5FC5\u9808\u3067\u3059\u3002", + options: { + price: "\u4FA1\u683C\u304C\u9AD8\u3059\u304E\u308B", + competitor: "\u7AF6\u5408\u4ED6\u793E\u306B\u6557\u5317", + no_budget: "\u4E88\u7B97\u306A\u3057", + no_decision: "\u610F\u601D\u6C7A\u5B9A\u306A\u3057", + timing: "\u30BF\u30A4\u30DF\u30F3\u30B0\u4E0D\u9069", + features: "\u6A5F\u80FD\u4E0D\u8DB3", + other: "\u305D\u306E\u4ED6" + } + }, + loss_details: { label: "\u53D7\u6CE8\u30FB\u5931\u6CE8\u306E\u8A73\u7D30", help: "\u53D7\u6CE8\u30FB\u5931\u6CE8\u7406\u7531\u306E\u88DC\u8DB3\u8AAC\u660E\uFF08\u81EA\u7531\u8A18\u8FF0\uFF09\u3002" }, + // REQ-0006 — 適格判定、顧客側の調達スケジュール、商談の経緯、事業区分、ステータス変更承認。 + will_bid: { label: "\u5165\u672D\u4E88\u5B9A", help: "\u5165\u672D\u3059\u308B\u610F\u5411\u304C\u3042\u308B\u304B\u3069\u3046\u304B\u3002\u672A\u8A2D\u5B9A\u306F\u5224\u65AD\u304C\u4FDD\u7559\u4E2D\u3067\u3042\u308B\u3053\u3068\u3092\u793A\u3057\u307E\u3059\u3002" }, + controllability: { label: "\u30B3\u30F3\u30C8\u30ED\u30FC\u30EB\u5EA6", options: { high: "\u9AD8", medium: "\u4E2D", low: "\u4F4E" } }, + priority: { label: "\u512A\u5148\u5EA6", options: { high: "\u9AD8", medium: "\u4E2D", low: "\u4F4E" } }, + deal_level: { label: "\u5546\u8AC7\u30E9\u30F3\u30AF", options: { strategic: "\u6226\u7565", key: "\u91CD\u70B9", standard: "\u6A19\u6E96" } }, + is_subcontracted: { label: "\u5916\u6CE8\u3042\u308A" }, + subcontracting_note: { label: "\u5916\u6CE8\u30E1\u30E2" }, + customer_initiation_date: { label: "\u9867\u5BA2\u306E\u6848\u4EF6\u5316\u65E5" }, + expected_tender_date: { label: "\u5165\u672D\u4E88\u5B9A\u65E5" }, + expected_signing_date: { label: "\u5951\u7D04\u7DE0\u7D50\u4E88\u5B9A\u65E5" }, + expected_tender_amount: { label: "\u5165\u672D\u4E88\u5B9A\u91D1\u984D" }, + expected_signing_amount: { label: "\u5951\u7D04\u4E88\u5B9A\u91D1\u984D" }, + business_line: { + label: "\u4E8B\u696D\u533A\u5206", + options: { + product: "\u88FD\u54C1", + services: "\u30D7\u30ED\u30D5\u30A7\u30C3\u30B7\u30E7\u30CA\u30EB\u30B5\u30FC\u30D3\u30B9", + consulting: "\u30B3\u30F3\u30B5\u30EB\u30C6\u30A3\u30F3\u30B0", + support: "\u4FDD\u5B88\u30FB\u30B5\u30DD\u30FC\u30C8", + other: "\u305D\u306E\u4ED6" + } + }, + customer_background: { label: "\u9867\u5BA2\u6982\u8981" }, + project_background: { label: "\u30D7\u30ED\u30B8\u30A7\u30AF\u30C8\u80CC\u666F" }, + risk_analysis: { label: "\u30EA\u30B9\u30AF\u5206\u6790" }, + payment_terms: { label: "\u652F\u6255\u6761\u4EF6" }, + requested_status: { label: "\u7533\u8ACB\u30B9\u30C6\u30FC\u30BF\u30B9", options: { closed_won: "\u53D7\u6CE8", closed_lost: "\u5931\u6CE8" } }, + status_change_approval_status: { + label: "\u30B9\u30C6\u30FC\u30BF\u30B9\u5909\u66F4\u627F\u8A8D", + options: { not_required: "\u627F\u8A8D\u4E0D\u8981", pending: "\u627F\u8A8D\u5F85\u3061", approved: "\u627F\u8A8D\u6E08\u307F", rejected: "\u5374\u4E0B" } + }, + // REQ-0006 ステップ 11 — 案件化（立项）承認。 + qualification_requested: { + label: "\u6848\u4EF6\u5316\u627F\u8A8D\u3092\u7533\u8ACB", + help: "\u30C1\u30A7\u30C3\u30AF\u3059\u308B\u3068\u3053\u306E\u5546\u8AC7\u3092\u6848\u4EF6\u5316\u627F\u8A8D\u306B\u56DE\u3057\u307E\u3059\u3002\u5374\u4E0B\u3055\u308C\u308B\u3068\u30C1\u30A7\u30C3\u30AF\u304C\u5916\u308C\u307E\u3059\u3002\u518D\u5EA6\u30C1\u30A7\u30C3\u30AF\u3059\u308B\u3068\u6539\u3081\u3066\u7533\u8ACB\u3067\u304D\u307E\u3059\u3002" + }, + qualification_approval_status: { + label: "\u6848\u4EF6\u5316\u627F\u8A8D", + options: { not_required: "\u627F\u8A8D\u4E0D\u8981", pending: "\u627F\u8A8D\u5F85\u3061", approved: "\u627F\u8A8D\u6E08\u307F", rejected: "\u5374\u4E0B" } + } + }, + _views: { + tender_this_quarter: { + label: "\u4ECA\u56DB\u534A\u671F\u306B\u5165\u672D\u4E88\u5B9A", + emptyState: { + title: "\u4ECA\u56DB\u534A\u671F\u306B\u5165\u672D\u4E88\u5B9A\u306E\u5546\u8AC7\u306F\u3042\u308A\u307E\u305B\u3093", + message: "\u3053\u306E\u30BF\u30D6\u306B\u306F\u3001\u9867\u5BA2\u5074\u306E\u5165\u672D\u4E88\u5B9A\u65E5\u304C\u4ECA\u56DB\u534A\u671F\u5185\u306B\u3042\u308B\u30AA\u30FC\u30D7\u30F3\u5546\u8AC7\u304C\u8868\u793A\u3055\u308C\u307E\u3059\u3002\u5546\u8AC7\u306B\u300C\u5165\u672D\u4E88\u5B9A\u65E5\u300D\u3092\u5165\u529B\u3059\u308B\u3068\u3001\u3053\u3053\u306B\u8868\u793A\u3055\u308C\u307E\u3059\u3002" + } + }, + open_opportunities: { label: "\u9032\u884C\u4E2D\u306E\u5546\u8AC7" }, + all_opportunities: { label: "\u5168\u5546\u8AC7" }, + pipeline_kanban: { label: "\u30BB\u30FC\u30EB\u30B9\u30D1\u30A4\u30D7\u30E9\u30A4\u30F3" }, + close_date_calendar: { label: "\u4E88\u6E2C\u30AB\u30EC\u30F3\u30C0\u30FC" }, + deal_timeline: { label: "\u5546\u8AC7\u30BF\u30A4\u30E0\u30E9\u30A4\u30F3" }, + deal_gallery: { label: "\u5546\u8AC7\u30AB\u30FC\u30C9" }, + my_open_deals: { label: "\u79C1\u306E\u30AA\u30FC\u30D7\u30F3\u5546\u8AC7" }, + stale_opportunities: { label: "\u26A0\uFE0F \u505C\u6EDE\u5546\u8AC7 \xB7 \u30B9\u30C6\u30FC\u30B8\u6EDE\u5728\u304C\u9577\u3044\u9806" }, + closing_this_quarter: { + label: "\u4ECA\u56DB\u534A\u671F\u306B\u30AF\u30ED\u30FC\u30BA\u4E88\u5B9A", + emptyState: { + title: "\u4ECA\u56DB\u534A\u671F\u306B\u30AF\u30ED\u30FC\u30BA\u4E88\u5B9A\u306E\u5546\u8AC7\u306F\u3042\u308A\u307E\u305B\u3093", + message: "\u3053\u306E\u30BF\u30D6\u306B\u306F\u3001\u5B8C\u4E86\u4E88\u5B9A\u65E5\u304C\u4ECA\u56DB\u534A\u671F\u5185\u306B\u3042\u308B\u30B3\u30DF\u30C3\u30C8\uFF0F\u30D9\u30B9\u30C8\u30B1\u30FC\u30B9\u306E\u30AA\u30FC\u30D7\u30F3\u5546\u8AC7\u304C\u8868\u793A\u3055\u308C\u307E\u3059\u3002\u73FE\u5728\u8A72\u5F53\u3059\u308B\u5546\u8AC7\u306F\u3042\u308A\u307E\u305B\u3093\u3002\u305D\u308C\u4EE5\u964D\u306B\u30AF\u30ED\u30FC\u30BA\u3059\u308B\u5546\u8AC7\u306F\u300C\u30AA\u30FC\u30D7\u30F3\u5546\u8AC7\u300D\u30BF\u30D6\u306B\u3042\u308A\u307E\u3059\u3002" + } + } + }, + _sections: { + // オブジェクト定義のセクションキー（opportunity.object.ts）— 入力フォームと、 + // これらのグループを参照する詳細ページのセクション（#1452）で使用 + crm_forecast: { label: "\u30B9\u30C6\u30FC\u30B8\u30FB\u58F2\u4E0A\u4E88\u6E2C" }, + basic: { label: "\u57FA\u672C\u60C5\u5831" }, + financials: { label: "\u8CA1\u52D9\u60C5\u5831" }, + sales_process: { label: "\u55B6\u696D\u30D7\u30ED\u30BB\u30B9" }, + classification: { label: "\u5206\u985E" }, + campaign: { label: "\u30AD\u30E3\u30F3\u30DA\u30FC\u30F3" }, + notes: { label: "\u30E1\u30E2\u30FB\u6B21\u306E\u30B9\u30C6\u30C3\u30D7" }, + qualification: { label: "\u9069\u683C\u5224\u5B9A" }, + narrative: { label: "\u5546\u8AC7\u306E\u7D4C\u7DEF" }, + // opportunity.view.ts のフォームセクション名 (#1100) + overview: { label: "\u6982\u8981" }, + forecast: { label: "\u4E88\u6E2C" }, + sales_strategy: { label: "\u55B6\u696D\u6226\u7565" }, + win_loss: { label: "\u53D7\u6CE8\uFF0F\u5931\u6CE8" } + }, + _actions: { + ...activityActions3, + clone_opportunity: { + label: "\u5546\u8AC7\u3092\u8907\u88FD", + successMessage: "\u5546\u8AC7\u3092\u8907\u88FD\u3057\u307E\u3057\u305F\uFF01" + }, + mass_update_stage: { + label: "\u30B9\u30C6\u30FC\u30B8\u66F4\u65B0", + successMessage: "\u5546\u8AC7\u30B9\u30C6\u30FC\u30B8\u3092\u66F4\u65B0\u3057\u307E\u3057\u305F\uFF01", + params: { + stage: { + label: "\u65B0\u3057\u3044\u30B9\u30C6\u30FC\u30B8", + options: { ...opportunityStageOptions } + } + } + }, + generate_quote: { + label: "\u898B\u7A4D\u3092\u4F5C\u6210", + successMessage: "\u5546\u8AC7\u304B\u3089\u898B\u7A4D\u3092\u4F5C\u6210\u3057\u307E\u3057\u305F\uFF01" + } + } + }, + crm_opportunity_line_item: { + _validations: { + unit_price_positive: { + message: "\u8CA9\u58F2\u4FA1\u683C\u3092\u8CA0\u306E\u5024\u306B\u3059\u308B\u3053\u3068\u306F\u3067\u304D\u307E\u305B\u3093" + } + }, + label: "\u5546\u8AC7\u5546\u54C1\u660E\u7D30", + pluralLabel: "\u5546\u8AC7\u5546\u54C1\u660E\u7D30", + description: "\u5546\u8AC7\u914D\u4E0B\u306E\u88FD\u54C1\u5225\u4FA1\u683C\u660E\u7D30\u884C", + fields: { + crm_opportunity: { label: "\u5546\u8AC7" }, + crm_product: { label: "\u88FD\u54C1" }, + description: { label: "\u8AAC\u660E" }, + quantity: { label: "\u6570\u91CF" }, + list_price: { label: "\u5B9A\u4FA1", help: "\u88FD\u54C1\u306E\u30AB\u30BF\u30ED\u30B0\u4FA1\u683C\u304B\u3089\u81EA\u52D5\u5165\u529B\u3055\u308C\u307E\u3059" }, + unit_price: { label: "\u8CA9\u58F2\u4FA1\u683C", help: "\u4EA4\u6E09\u5F8C\u306E\u5358\u4FA1\uFF08\u5B9A\u4FA1\u3068\u7570\u306A\u308B\u5834\u5408\u304C\u3042\u308A\u307E\u3059\uFF09" }, + discount: { label: "\u5272\u5F15\u7387\uFF08%\uFF09" }, + total_price: { label: "\u5408\u8A08" }, + line_number: { label: "\u884C\u756A\u53F7" } + }, + _sections: { + basic: { label: "\u660E\u7D30\u884C" }, + pricing: { label: "\u4FA1\u683C" } + } + }, + crm_forecast: { + _validations: { + period_end_after_start: { + message: "\u671F\u9593\u7D42\u4E86\u306F\u671F\u9593\u958B\u59CB\u3088\u308A\u5F8C\u3067\u3042\u308B\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059\u3002" + }, + period_end_matches_calendar_period: { + message: "\u671F\u9593\u7D42\u4E86\u306F\u305D\u306E\u671F\u9593\u306E\u6700\u7D42\u65E5\u3067\u3042\u308B\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059\u3002\u4F8B\uFF1A2026-07-01 \u958B\u59CB\u306E\u56DB\u534A\u671F\u306A\u3089 2026-09-30\u30012026 \u5E74 8 \u6708\u306A\u3089 2026-08-31\u3002" + }, + period_start_first_of_period: { + message: "\u671F\u9593\u958B\u59CB\u306F\u305D\u306E\u671F\u9593\u306E\u521D\u65E5\u3067\u3042\u308B\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059\u3002\u4F8B\uFF1A2026 \u5E74 8 \u6708\u306A\u3089 2026-08-01\u3002" + }, + quarter_starts_on_quarter_boundary: { + message: "\u56DB\u534A\u671F\u30D5\u30A9\u30FC\u30AD\u30E3\u30B9\u30C8\u306F\u56DB\u534A\u671F\u306E\u5883\u754C\uFF081 \u6708 1 \u65E5\u30014 \u6708 1 \u65E5\u30017 \u6708 1 \u65E5\u300110 \u6708 1 \u65E5\uFF09\u304B\u3089\u958B\u59CB\u3059\u308B\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059\u3002" + }, + snapshot_amounts_non_negative: { + message: "\u30B9\u30CA\u30C3\u30D7\u30B7\u30E7\u30C3\u30C8\u91D1\u984D\u306F\u8CA0\u306E\u5024\u306B\u3067\u304D\u307E\u305B\u3093\u3002" + } + }, + label: "\u30D5\u30A9\u30FC\u30AD\u30E3\u30B9\u30C8", + pluralLabel: "\u30D5\u30A9\u30FC\u30AD\u30E3\u30B9\u30C8", + description: "\u62C5\u5F53\u8005\u3054\u3068\u306E\u5B9A\u671F\u30D1\u30A4\u30D7\u30E9\u30A4\u30F3\u30B9\u30CA\u30C3\u30D7\u30B7\u30E7\u30C3\u30C8\u3067\u53CE\u76CA\u4E88\u6E2C\u306B\u4F7F\u7528", + fields: { + owner_id: { label: "\u62C5\u5F53\u8005" }, + period: { label: "\u671F\u9593", options: { month: "\u6708\u6B21", quarter: "\u56DB\u534A\u671F" } }, + period_start: { + label: "\u671F\u9593\u958B\u59CB", + help: "\u671F\u9593\u306E\u521D\u65E5\u3067\u3042\u308B\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059 \u2014 \u4F8B: 2026 \u5E74 8 \u6708\u306A\u3089 2026-08-01\u3002\u56DB\u534A\u671F\u306E\u30D5\u30A9\u30FC\u30AD\u30E3\u30B9\u30C8\u306F\u3055\u3089\u306B\u56DB\u534A\u671F\u306E\u5883\u754C\uFF081 \u6708 1 \u65E5\u30FB4 \u6708 1 \u65E5\u30FB7 \u6708 1 \u65E5\u30FB10 \u6708 1 \u65E5\uFF09\u3067\u958B\u59CB\u3059\u308B\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059\u3002" + }, + period_end: { + label: "\u671F\u9593\u7D42\u4E86", + help: "\u901A\u5E38\u306F\u300C\u671F\u9593\u300D\u3068\u300C\u671F\u9593\u958B\u59CB\u300D\u304B\u3089\u81EA\u52D5\u7684\u306B\u7B97\u51FA\u3055\u308C\u307E\u3059\u3002\u624B\u52D5\u3067\u5165\u529B\u3059\u308B\u5834\u5408\u306F\u3001\u305D\u306E\u671F\u9593\u306E\u6700\u7D42\u65E5\u3067\u3042\u308B\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059 \u2014 \u4F8B: 2026-07-01 \u958B\u59CB\u306E\u56DB\u534A\u671F\u306A\u3089 2026-09-30\u30012026 \u5E74 8 \u6708\u306A\u3089 2026-08-31\u3002" + }, + period_label: { + label: "\u671F\u9593", + help: "\u300C2026 \u5E74\u7B2C 3 \u56DB\u534A\u671F\u300D\u300C2026 \u5E74 8 \u6708\u300D\u306E\u3088\u3046\u306A\u8AAD\u307F\u3084\u3059\u3044\u671F\u9593\u30E9\u30D9\u30EB\u3002" + }, + display_title: { label: "\u8868\u793A\u540D" }, + snapshot_date: { label: "\u30B9\u30CA\u30C3\u30D7\u30B7\u30E7\u30C3\u30C8\u65E5", help: "\u3053\u306E\u30B9\u30CA\u30C3\u30D7\u30B7\u30E7\u30C3\u30C8\u3092\u53D6\u5F97\u3057\u305F\u65E5\u3002" }, + source: { + label: "\u30BD\u30FC\u30B9", + options: { scheduled: "\u5B9A\u671F\u30B9\u30CA\u30C3\u30D7\u30B7\u30E7\u30C3\u30C8", ai: "AI \u30B9\u30AD\u30EB", manual: "\u624B\u52D5\u5165\u529B" } + }, + quota: { label: "\u30AF\u30A9\u30FC\u30BF" }, + pipeline_amount: { + label: "\u30D1\u30A4\u30D7\u30E9\u30A4\u30F3", + help: "\u3053\u306E\u671F\u9593\u306B\u30AF\u30ED\u30FC\u30BA\u4E88\u5B9A\u306E\u30AA\u30FC\u30D7\u30F3\u5546\u8AC7\u306E\u5408\u8A08\u91D1\u984D\uFF08\u30B9\u30C6\u30FC\u30B8\u3092\u554F\u308F\u306A\u3044\uFF09\u3002" + }, + best_case_amount: { + label: "\u30D9\u30B9\u30C8\u30B1\u30FC\u30B9", + help: "\u58F2\u4E0A\u4E88\u6E2C\u30AB\u30C6\u30B4\u30EA\u304C\u300C\u30D9\u30B9\u30C8\u30B1\u30FC\u30B9\u300D\u307E\u305F\u306F\u300C\u30B3\u30DF\u30C3\u30C8\u300D\u306E\u30AA\u30FC\u30D7\u30F3\u5546\u8AC7\u3002" + }, + commit_amount: { + label: "\u30B3\u30DF\u30C3\u30C8", + help: "\u58F2\u4E0A\u4E88\u6E2C\u30AB\u30C6\u30B4\u30EA\u304C\u300C\u30B3\u30DF\u30C3\u30C8\u300D\u306E\u30AA\u30FC\u30D7\u30F3\u5546\u8AC7\uFF08\u62C5\u5F53\u8005\u304C\u30B3\u30DF\u30C3\u30C8\u6E08\u307F\uFF09\u3002" + }, + closed_amount: { label: "\u30AF\u30ED\u30FC\u30BA", help: "\u3053\u306E\u671F\u9593\u306B\u3059\u3067\u306B\u6210\u7ACB\u3057\u305F\u91D1\u984D\u3002" }, + expected_amount: { + label: "\u4E88\u60F3", + help: "\u30AF\u30ED\u30FC\u30BA + \u30B3\u30DF\u30C3\u30C8 \u2014 \u62C5\u5F53\u8005\u304C\u7121\u7406\u306A\u304F\u7740\u5730\u3092\u898B\u8FBC\u3081\u308B\u91D1\u984D\u3002" + }, + attainment_pct: { + label: "\u9054\u6210\u7387 %", + help: "\u30AF\u30ED\u30FC\u30BA \xF7 \u30AF\u30A9\u30FC\u30BF \xD7 100\u3002\u30AF\u30A9\u30FC\u30BF\u304C\u6B63\u306E\u5024\u306B\u306A\u308B\u307E\u3067\u306F 0% \u3068\u8868\u793A\u3055\u308C\u307E\u3059\u3002" + }, + coverage_ratio: { + label: "\u30AB\u30D0\u30EC\u30C3\u30B8", + help: "\u30D1\u30A4\u30D7\u30E9\u30A4\u30F3 \xF7\uFF08\u30AF\u30A9\u30FC\u30BF \u2212 \u30AF\u30ED\u30FC\u30BA\uFF09\u2014 \u6B8B\u308A\u306E\u5DEE\u5206\u3092\u57CB\u3081\u308B\u30D1\u30A4\u30D7\u30E9\u30A4\u30F3\u304C\u5341\u5206\u304B\u3069\u3046\u304B\u3002\u30AF\u30A9\u30FC\u30BF\u9054\u6210\u6E08\u307F\u306E\u5834\u5408\u306F 0 \u3068\u8868\u793A\u3055\u308C\u307E\u3059\u3002" + }, + notes: { label: "\u30E1\u30E2" }, + seed_key: { + label: "\u30B7\u30FC\u30C9\u30AD\u30FC", + help: "\u30C7\u30E2\u30C7\u30FC\u30BF\u306E\u8B58\u5225\u5B50\u3002\u30B7\u30FC\u30C9\u30ED\u30FC\u30C0\u30FC\u3060\u3051\u304C\u66F8\u304D\u8FBC\u307F\u3001\u5B9F\u969B\u306E\u30B9\u30CA\u30C3\u30D7\u30B7\u30E7\u30C3\u30C8\u3067\u306F\u5E38\u306B\u7A7A\u3067\u3059\u3002" + } + }, + _views: { + all_forecasts: { label: "\u3059\u3079\u3066\u306E\u30D5\u30A9\u30FC\u30AD\u30E3\u30B9\u30C8" }, + this_quarter_forecasts: { + label: "\u4ECA\u56DB\u534A\u671F", + emptyState: { + title: "\u4ECA\u56DB\u534A\u671F\u306E\u30B9\u30CA\u30C3\u30D7\u30B7\u30E7\u30C3\u30C8\u306F\u307E\u3060\u3042\u308A\u307E\u305B\u3093", + message: "\u56DB\u534A\u671F\u30B9\u30CA\u30C3\u30D7\u30B7\u30E7\u30C3\u30C8\u306F\u591C\u9593\u306E\u30D5\u30A9\u30FC\u30AD\u30E3\u30B9\u30C8\u96C6\u8A08\u304C\u66F8\u304D\u8FBC\u307F\u307E\u3059\u3002\u4ECA\u56DB\u534A\u671F\u5206\u304C\u4E00\u5EA6\u5B9F\u884C\u3055\u308C\u308B\u307E\u3067\u3053\u306E\u30D3\u30E5\u30FC\u306F\u7A7A\u3067\u3059\u3002\u78BA\u5B9A\u6E08\u307F\u306E\u56DB\u534A\u671F\u306F\u300C\u3059\u3079\u3066\u300D\u30BF\u30D6\u306B\u3042\u308A\u307E\u3059\u3002" + } + }, + my_forecast: { label: "\u81EA\u5206\u306E\u30D5\u30A9\u30FC\u30AD\u30E3\u30B9\u30C8" } + }, + _sections: { + basic: { label: "\u30B9\u30CA\u30C3\u30D7\u30B7\u30E7\u30C3\u30C8" }, + amounts: { label: "\u91D1\u984D" }, + meta: { label: "\u30BD\u30FC\u30B9" }, + // forecast.view.ts のフォームセクション名 (#1100) + snapshot: { label: "\u30B9\u30CA\u30C3\u30D7\u30B7\u30E7\u30C3\u30C8" }, + notes: { label: "\u30E1\u30E2" } + } + } +}; + +// src/sales/translations/ja-JP/objects.commerce.ts +var paymentTermsOptions = { + net_15: "15 \u65E5\u4EE5\u5185\u6255\u3044", + net_30: "30 \u65E5\u4EE5\u5185\u6255\u3044", + net_60: "60 \u65E5\u4EE5\u5185\u6255\u3044", + net_90: "90 \u65E5\u4EE5\u5185\u6255\u3044", + due_on_receipt: "\u8ACB\u6C42\u66F8\u53D7\u9818\u6642\u6255\u3044" +}; +var commerce3 = { + crm_quote: { + _validations: { + discount_within_ceiling: { + message: "\u5272\u5F15\u7387\u306F 60% \u3092\u8D85\u3048\u3089\u308C\u307E\u305B\u3093" + }, + expiration_after_quote: { + message: "\u6709\u52B9\u671F\u9650\u306F\u898B\u7A4D\u65E5\u3088\u308A\u5F8C\u3067\u3042\u308B\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059" + }, + quote_status_progression: { + message: "\u7121\u52B9\u306A\u898B\u7A4D\u30B9\u30C6\u30FC\u30BF\u30B9\u9077\u79FB\u3067\u3059" + } + }, + label: "\u898B\u7A4D", + pluralLabel: "\u898B\u7A4D", + description: "\u9867\u5BA2\u306B\u63D0\u793A\u3059\u308B\u4FA1\u683C\u898B\u7A4D", + fields: { + quote_number: { label: "\u898B\u7A4D\u756A\u53F7" }, + name: { label: "\u898B\u7A4D\u540D" }, + display_title: { label: "\u8868\u793A\u540D" }, + crm_account: { label: "\u53D6\u5F15\u5148" }, + crm_contact: { + label: "\u53D6\u5F15\u5148\u8CAC\u4EFB\u8005", + help: "\u898B\u7A4D\u304C\u300C\u63D0\u793A\u6E08\u307F\u300D\u307E\u305F\u306F\u300C\u627F\u8A8D\u6E08\u307F\u300D\u306B\u306A\u3063\u305F\u6642\u70B9\u3067\u5FC5\u9808\u3067\u3059\u3002\u4F5C\u6210\u3055\u308C\u308B\u5951\u7D04\u306E\u4E3B\u62C5\u5F53\u8005\u306F\u3053\u3053\u304B\u3089\u5F15\u304D\u7D99\u304C\u308C\u307E\u3059\u3002" + }, + crm_opportunity: { label: "\u5546\u8AC7" }, + owner_id: { label: "\u898B\u7A4D\u62C5\u5F53\u8005" }, + status: { + label: "\u30B9\u30C6\u30FC\u30BF\u30B9", + options: { + draft: "\u4E0B\u66F8\u304D", + in_review: "\u30EC\u30D3\u30E5\u30FC\u4E2D", + presented: "\u63D0\u793A\u6E08\u307F", + accepted: "\u627F\u8A8D\u6E08\u307F", + rejected: "\u5374\u4E0B", + expired: "\u671F\u9650\u5207\u308C" + } + }, + quote_date: { label: "\u898B\u7A4D\u65E5" }, + expiration_date: { label: "\u6709\u52B9\u671F\u9650" }, + subtotal: { label: "\u5C0F\u8A08" }, + discount: { label: "\u5272\u5F15\u7387(%)" }, + discount_amount: { label: "\u5272\u5F15\u984D" }, + tax: { label: "\u7A0E\u984D" }, + shipping_handling: { label: "\u914D\u9001\u30FB\u624B\u6570\u6599" }, + total_price: { label: "\u5408\u8A08\u91D1\u984D" }, + payment_terms: { label: "\u652F\u6255\u6761\u4EF6", options: { ...paymentTermsOptions } }, + shipping_terms: { label: "\u914D\u9001\u6761\u4EF6" }, + billing_address: { label: "\u8ACB\u6C42\u5148\u4F4F\u6240" }, + shipping_address: { label: "\u914D\u9001\u5148\u4F4F\u6240" }, + description: { label: "\u8AAC\u660E" }, + internal_notes: { label: "\u5185\u90E8\u30E1\u30E2" } + }, + _views: { + all_quotes: { label: "\u5168\u898B\u7A4D" }, + quote_pipeline: { label: "\u898B\u7A4D\u30D1\u30A4\u30D7\u30E9\u30A4\u30F3" }, + quote_calendar: { label: "\u898B\u7A4D\u30AB\u30EC\u30F3\u30C0\u30FC" } + }, + _sections: { + basic: { label: "\u898B\u7A4D\u60C5\u5831" }, + pricing: { label: "\u4FA1\u683C" }, + terms: { label: "\u6761\u4EF6\u30FB\u6709\u52B9\u671F\u9650" }, + address: { label: "\u4F4F\u6240" }, + system: { label: "\u30B7\u30B9\u30C6\u30E0" }, + // quote.view.ts のフォームセクション名 (#1100) + quote: { label: "\u898B\u7A4D\u66F8" }, + totals: { label: "\u5408\u8A08" }, + quote_terms: { label: "\u5951\u7D04\u6761\u4EF6" }, + addresses_and_notes: { label: "\u4F4F\u6240\u3068\u5099\u8003" } + } + }, + crm_quote_line_item: { + _validations: { + discount_within_ceiling: { + message: "\u660E\u7D30\u306E\u5272\u5F15\u7387\u306F 60% \u3092\u8D85\u3048\u3089\u308C\u307E\u305B\u3093" + }, + unit_price_positive: { + message: "\u8CA9\u58F2\u4FA1\u683C\u3092\u8CA0\u306E\u5024\u306B\u3059\u308B\u3053\u3068\u306F\u3067\u304D\u307E\u305B\u3093" + } + }, + label: "\u898B\u7A4D\u660E\u7D30", + pluralLabel: "\u898B\u7A4D\u660E\u7D30", + description: "\u898B\u7A4D\u914D\u4E0B\u306E\u88FD\u54C1\u5225\u4FA1\u683C\u660E\u7D30\u884C", + fields: { + crm_quote: { label: "\u898B\u7A4D" }, + crm_product: { label: "\u88FD\u54C1" }, + description: { label: "\u8AAC\u660E" }, + quantity: { label: "\u6570\u91CF" }, + list_price: { label: "\u5B9A\u4FA1" }, + unit_price: { label: "\u8CA9\u58F2\u4FA1\u683C" }, + discount: { label: "\u5272\u5F15\u7387\uFF08%\uFF09" }, + subtotal: { label: "\u5C0F\u8A08" }, + total_price: { label: "\u5408\u8A08" }, + line_number: { label: "\u884C\u756A\u53F7" } + }, + _sections: { + basic: { label: "\u660E\u7D30\u884C" }, + pricing: { label: "\u4FA1\u683C" } + } + }, + crm_contract: { + _validations: { + end_after_start: { + message: "\u7D42\u4E86\u65E5\u306F\u958B\u59CB\u65E5\u3088\u308A\u5F8C\u3067\u3042\u308B\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059" + }, + contract_status_progression: { + message: "\u7121\u52B9\u306A\u5951\u7D04\u30B9\u30C6\u30FC\u30BF\u30B9\u9077\u79FB\u3067\u3059" + } + }, + label: "\u5951\u7D04", + pluralLabel: "\u5951\u7D04", + description: "\u9867\u5BA2\u3068\u7DE0\u7D50\u3057\u305F\u6CD5\u7684\u306A\u5951\u7D04\u30FB\u5408\u610F", + fields: { + contract_number: { label: "\u5951\u7D04\u756A\u53F7" }, + crm_account: { label: "\u53D6\u5F15\u5148" }, + crm_contact: { label: "\u4E3B\u62C5\u5F53\u8005" }, + crm_opportunity: { label: "\u95A2\u9023\u5546\u8AC7" }, + owner_id: { label: "\u5951\u7D04\u62C5\u5F53\u8005" }, + status: { + label: "\u30B9\u30C6\u30FC\u30BF\u30B9", + options: { + draft: "\u4E0B\u66F8\u304D", + in_approval: "\u627F\u8A8D\u4E2D", + activated: "\u6709\u52B9", + expired: "\u671F\u9650\u5207\u308C", + terminated: "\u89E3\u7D04" + } + }, + contract_term_months: { label: "\u5951\u7D04\u671F\u9593\uFF08\u6708\uFF09" }, + start_date: { label: "\u958B\u59CB\u65E5" }, + end_date: { label: "\u7D42\u4E86\u65E5" }, + contract_value: { label: "\u5951\u7D04\u91D1\u984D" }, + billing_frequency: { + label: "\u8ACB\u6C42\u983B\u5EA6", + options: { monthly: "\u6708\u6B21", quarterly: "\u56DB\u534A\u671F", annually: "\u5E74\u6B21", one_time: "\u4E00\u62EC" } + }, + payment_terms: { label: "\u652F\u6255\u6761\u4EF6", options: { ...paymentTermsOptions } }, + auto_renewal: { label: "\u81EA\u52D5\u66F4\u65B0" }, + renewal_notice_days: { label: "\u66F4\u65B0\u901A\u77E5\uFF08\u65E5\uFF09" }, + contract_type: { + label: "\u5951\u7D04\u7A2E\u5225", + options: { + subscription: "\u30B5\u30D6\u30B9\u30AF\u30EA\u30D7\u30B7\u30E7\u30F3\u5951\u7D04", + service: "\u30B5\u30FC\u30D3\u30B9\u5951\u7D04", + license: "\u30E9\u30A4\u30BB\u30F3\u30B9\u5951\u7D04", + partnership: "\u30D1\u30FC\u30C8\u30CA\u30FC\u30B7\u30C3\u30D7\u5951\u7D04", + nda: "\u79D8\u5BC6\u4FDD\u6301\u5951\u7D04 (NDA)", + msa: "\u57FA\u672C\u5951\u7D04 (MSA)" + } + }, + signed_date: { label: "\u7F72\u540D\u65E5" }, + signed_by: { label: "\u7F72\u540D\u8005" }, + document_url: { label: "\u5951\u7D04\u66F8\u985E" }, + special_terms: { label: "\u7279\u7D04\u4E8B\u9805" }, + description: { label: "\u8AAC\u660E" }, + billing_address: { label: "\u8ACB\u6C42\u5148\u4F4F\u6240" } + }, + _views: { + all_contracts: { label: "\u5168\u5951\u7D04" }, + renewal_calendar: { label: "\u66F4\u65B0\u30AB\u30EC\u30F3\u30C0\u30FC" }, + contract_gantt: { label: "\u5951\u7D04\u671F\u9593" }, + contract_timeline: { label: "\u5951\u7D04\u30BF\u30A4\u30E0\u30E9\u30A4\u30F3" } + }, + _sections: { + basic: { label: "\u5951\u7D04\u60C5\u5831" }, + parties: { label: "\u5951\u7D04\u5F53\u4E8B\u8005" }, + terms: { label: "\u5951\u7D04\u6761\u4EF6\u30FB\u671F\u9593" }, + value: { label: "\u5951\u7D04\u91D1\u984D" }, + status: { label: "\u30B9\u30C6\u30FC\u30BF\u30B9\u30FB\u627F\u8A8D" }, + renewal: { label: "\u66F4\u65B0" }, + // contract.view.ts のフォームセクション名 (#1100) + contract_terms: { label: "\u5951\u7D04\u6761\u4EF6" }, + signing_and_documents: { label: "\u7F72\u540D\u3068\u66F8\u985E" }, + notes: { label: "\u5099\u8003" } + } + }, + crm_product: { + _validations: { + cost_less_than_price: { + message: "\u539F\u4FA1\u306F\u5B9A\u4FA1\u3088\u308A\u4F4E\u304F\u3057\u3066\u304F\u3060\u3055\u3044" + }, + price_positive: { + message: "\u5B9A\u4FA1\u306F\u6B63\u306E\u5024\u3067\u3042\u308B\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059" + } + }, + label: "\u88FD\u54C1", + pluralLabel: "\u88FD\u54C1", + description: "\u81EA\u793E\u304C\u63D0\u4F9B\u3059\u308B\u88FD\u54C1\u30FB\u30B5\u30FC\u30D3\u30B9", + fields: { + product_code: { label: "\u88FD\u54C1\u30B3\u30FC\u30C9" }, + name: { label: "\u88FD\u54C1\u540D" }, + display_title: { label: "\u8868\u793A\u540D" }, + description: { label: "\u8AAC\u660E" }, + category: { + label: "\u30AB\u30C6\u30B4\u30EA", + options: { + software: "\u30BD\u30D5\u30C8\u30A6\u30A7\u30A2", + hardware: "\u30CF\u30FC\u30C9\u30A6\u30A7\u30A2", + service: "\u30B5\u30FC\u30D3\u30B9", + subscription: "\u30B5\u30D6\u30B9\u30AF\u30EA\u30D7\u30B7\u30E7\u30F3", + support: "\u30B5\u30DD\u30FC\u30C8" + } + }, + family: { + label: "\u88FD\u54C1\u30D5\u30A1\u30DF\u30EA", + options: { + enterprise: "\u30A8\u30F3\u30BF\u30FC\u30D7\u30E9\u30A4\u30BA\u5411\u3051\u30BD\u30EA\u30E5\u30FC\u30B7\u30E7\u30F3", + smb: "\u4E2D\u5C0F\u4F01\u696D\u5411\u3051\u30BD\u30EA\u30E5\u30FC\u30B7\u30E7\u30F3", + services: "\u30D7\u30ED\u30D5\u30A7\u30C3\u30B7\u30E7\u30CA\u30EB\u30B5\u30FC\u30D3\u30B9", + cloud: "\u30AF\u30E9\u30A6\u30C9\u30B5\u30FC\u30D3\u30B9" + } + }, + list_price: { label: "\u5B9A\u4FA1" }, + cost: { label: "\u30B3\u30B9\u30C8" }, + sku: { label: "SKU" }, + is_active: { label: "\u6709\u52B9" }, + product_manager: { label: "\u30D7\u30ED\u30C0\u30AF\u30C8\u30DE\u30CD\u30FC\u30B8\u30E3\u30FC" }, + image: { label: "\u88FD\u54C1\u753B\u50CF" }, + datasheet: { label: "\u30C7\u30FC\u30BF\u30B7\u30FC\u30C8" } + }, + _views: { + all_products: { label: "\u5168\u88FD\u54C1" }, + product_catalog: { label: "\u88FD\u54C1\u30AB\u30BF\u30ED\u30B0" } + }, + _sections: { + basic: { label: "\u88FD\u54C1\u60C5\u5831" }, + pricing: { label: "\u4FA1\u683C" }, + metadata: { label: "\u95A2\u9023\u8CC7\u6599" }, + // product.view.ts のフォームセクション名 (#1100) + product_info: { label: "\u88FD\u54C1\u60C5\u5831" }, + pricing_info: { label: "\u4FA1\u683C" }, + media: { label: "\u30E1\u30C7\u30A3\u30A2" } + } + } +}; + +// src/sales/translations/ja-JP/objects.service.ts +var service3 = { + crm_case: { + _validations: { + resolution_required_for_closed: { + message: "\u30B1\u30FC\u30B9\u3092\u30AF\u30ED\u30FC\u30BA\u3059\u308B\u306B\u306F\u89E3\u6C7A\u5185\u5BB9\u304C\u5FC5\u8981\u3067\u3059" + }, + escalation_reason_required: { + message: "\u30B1\u30FC\u30B9\u3092\u30A8\u30B9\u30AB\u30EC\u30FC\u30B7\u30E7\u30F3\u3059\u308B\u306B\u306F\u7406\u7531\u304C\u5FC5\u8981\u3067\u3059" + }, + case_status_progression: { + message: "\u7121\u52B9\u306A\u30B9\u30C6\u30FC\u30BF\u30B9\u9077\u79FB\u3067\u3059" + } + }, + label: "\u30B1\u30FC\u30B9", + pluralLabel: "\u30B1\u30FC\u30B9", + description: "\u30AB\u30B9\u30BF\u30DE\u30FC\u30B5\u30DD\u30FC\u30C8\u306E\u30B1\u30FC\u30B9\u3068\u30B5\u30FC\u30D3\u30B9\u4F9D\u983C", + fields: { + case_number: { label: "\u30B1\u30FC\u30B9\u756A\u53F7" }, + subject: { label: "\u4EF6\u540D" }, + display_title: { label: "\u8868\u793A\u540D" }, + description: { label: "\u8AAC\u660E" }, + crm_account: { label: "\u53D6\u5F15\u5148" }, + crm_contact: { label: "\u53D6\u5F15\u5148\u8CAC\u4EFB\u8005" }, + status: { + label: "\u30B9\u30C6\u30FC\u30BF\u30B9", + options: { + new: "\u65B0\u898F", + in_progress: "\u5BFE\u5FDC\u4E2D", + waiting_customer: "\u9867\u5BA2\u306E\u56DE\u7B54\u5F85\u3061", + waiting_support: "\u30B5\u30DD\u30FC\u30C8\u306E\u56DE\u7B54\u5F85\u3061", + escalated: "\u30A8\u30B9\u30AB\u30EC\u30FC\u30B7\u30E7\u30F3\u6E08", + resolved: "\u89E3\u6C7A\u6E08", + closed: "\u30AF\u30ED\u30FC\u30BA\u6E08" + } + }, + priority: { + label: "\u512A\u5148\u5EA6", + options: { low: "\u4F4E", medium: "\u4E2D", high: "\u9AD8", critical: "\u91CD\u5927" } + }, + priority_rank: { label: "\u512A\u5148\u5EA6\u30E9\u30F3\u30AF" }, + type: { + label: "\u30B1\u30FC\u30B9\u7A2E\u5225", + options: { + question: "\u554F\u3044\u5408\u308F\u305B", + problem: "\u4E0D\u5177\u5408", + feature_request: "\u6A5F\u80FD\u8981\u671B", + bug: "\u30D0\u30B0" + } + }, + origin: { + label: "\u30B1\u30FC\u30B9\u767A\u751F\u5143", + options: { email: "\u30E1\u30FC\u30EB", phone: "\u96FB\u8A71", web: "\u30A6\u30A7\u30D6", chat: "\u30C1\u30E3\u30C3\u30C8", social_media: "\u30BD\u30FC\u30B7\u30E3\u30EB\u30E1\u30C7\u30A3\u30A2" } + }, + owner_id: { label: "\u30B1\u30FC\u30B9\u62C5\u5F53\u8005" }, + closed_date: { label: "\u30AF\u30ED\u30FC\u30BA\u65E5" }, + first_response_date: { label: "\u521D\u56DE\u5FDC\u7B54\u65E5" }, + resolution_time_hours: { label: "\u89E3\u6C7A\u6642\u9593\uFF08\u6642\u9593\uFF09" }, + sla_due_date: { label: "SLA\u671F\u9650", help: "\u30B1\u30FC\u30B9\u306E\u512A\u5148\u5EA6\u3068\u53D6\u5F15\u5148\u306E\u9867\u5BA2\u30E9\u30F3\u30AF\u304B\u3089\u8A2D\u5B9A\u3055\u308C\u3001\u66A6\u6642\u9593\u3067\u6570\u3048\u307E\u3059\u3002\u591C\u9593\u30FB\u9031\u672B\u30FB\u795D\u65E5\u3082\u3059\u3079\u3066\u542B\u307E\u308C\u307E\u3059\u3002" }, + is_sla_violated: { label: "SLA\u9055\u53CD" }, + is_escalated: { label: "\u30A8\u30B9\u30AB\u30EC\u30FC\u30B7\u30E7\u30F3\u6E08" }, + escalated_date: { label: "\u30A8\u30B9\u30AB\u30EC\u30FC\u30B7\u30E7\u30F3\u65E5" }, + escalation_reason: { label: "\u30A8\u30B9\u30AB\u30EC\u30FC\u30B7\u30E7\u30F3\u7406\u7531" }, + resolution: { label: "\u89E3\u6C7A\u5185\u5BB9" }, + resolved_by_article: { label: "\u89E3\u6C7A\u3057\u305F\u30CA\u30EC\u30C3\u30B8\u8A18\u4E8B", help: "\u3053\u306E\u30B1\u30FC\u30B9\u3092\u89E3\u6C7A\u3057\u305F\u30CA\u30EC\u30C3\u30B8\u8A18\u4E8B \u2014 \u9038\u3089\u3057\u7387\u306E\u6307\u6A19\u3002" }, + internal_notes: { label: "\u5185\u90E8\u30E1\u30E2", help: "\u9867\u5BA2\u306B\u306F\u8868\u793A\u3055\u308C\u306A\u3044\u793E\u5185\u5411\u3051\u30E1\u30E2" }, + is_closed: { label: "\u30AF\u30ED\u30FC\u30BA\u6E08" } + }, + _views: { + all_cases: { label: "\u5168\u30B1\u30FC\u30B9" }, + case_workflow: { label: "\u30B5\u30FC\u30D3\u30B9\u30D5\u30ED\u30FC" }, + sla_calendar: { label: "SLA \u30AB\u30EC\u30F3\u30C0\u30FC" }, + case_timeline: { label: "\u30B1\u30FC\u30B9\u30BF\u30A4\u30E0\u30E9\u30A4\u30F3" }, + unassigned_triage: { + label: "\u672A\u5272\u308A\u5F53\u3066 \u2014 \u30C8\u30EA\u30A2\u30FC\u30B8", + emptyState: { + title: "\u30C8\u30EA\u30A2\u30FC\u30B8\u5F85\u3061\u306F\u3042\u308A\u307E\u305B\u3093", + message: "\u3059\u3079\u3066\u306E\u30B1\u30FC\u30B9\u306B\u6240\u6709\u8005\u304C\u3044\u307E\u3059\u3002\u6240\u6709\u8005\u306E\u306A\u3044\u30B1\u30FC\u30B9\u306F\u3053\u3053\u306B\u8868\u793A\u3055\u308C\u307E\u3059 \u2014 \u901A\u5E38\u306F\u3001\u30B5\u30FC\u30D3\u30B9\u30A8\u30FC\u30B8\u30A7\u30F3\u30C8\u306E\u8077\u4F4D\u3092\u8AB0\u3082\u4FDD\u6301\u3057\u3066\u3044\u306A\u3044\u9593\u306B\u5C4A\u3044\u305F Web-to-Case \u306E\u9001\u4FE1\u3067\u3059\u3002" + } + }, + escalated_cases: { label: "\u30A8\u30B9\u30AB\u30EC\u30FC\u30C8\u3057\u305F\u30B1\u30FC\u30B9" }, + my_open_cases: { label: "\u79C1\u306E\u30AA\u30FC\u30D7\u30F3\u30B1\u30FC\u30B9" }, + sla_at_risk: { label: "\u23F0 SLA \u30EA\u30B9\u30AF\u3042\u308A" } + }, + _sections: { + // case.view.ts のフォームセクション名 (#1100)。 + case: { label: "\u30B1\u30FC\u30B9" }, + how_can_we_help: { label: "\u3069\u306E\u3088\u3046\u306A\u3054\u7528\u4EF6\u3067\u3057\u3087\u3046\u304B\uFF1F" }, + // オブジェクト定義のセクションキー（case.object.ts）— 入力フォームと、 + // これらのグループを参照する詳細ページのセクション（#970）で使用 + basic: { label: "\u30B1\u30FC\u30B9\u60C5\u5831" }, + origin: { label: "\u767A\u751F\u5143\u30FB\u632F\u308A\u5206\u3051" }, + sla: { label: "SLA\u30FB\u512A\u5148\u5EA6" }, + resolution: { label: "\u89E3\u6C7A" }, + escalation: { label: "\u30A8\u30B9\u30AB\u30EC\u30FC\u30B7\u30E7\u30F3" }, + system: { label: "\u30B7\u30B9\u30C6\u30E0" } + }, + _actions: { + ...activityActions3, + escalate_case: { + label: "\u30B1\u30FC\u30B9\u3092\u30A8\u30B9\u30AB\u30EC\u30FC\u30C8", + confirmText: "\u3053\u306E\u30B1\u30FC\u30B9\u3092\u30A8\u30B9\u30AB\u30EC\u30FC\u30B7\u30E7\u30F3\u30C1\u30FC\u30E0\u3078\u5F15\u304D\u7D99\u304E\u307E\u3059\u3002\u7D9A\u884C\u3057\u307E\u3059\u304B\uFF1F", + successMessage: "\u30B1\u30FC\u30B9\u3092\u30A8\u30B9\u30AB\u30EC\u30FC\u30C8\u3057\u307E\u3057\u305F\uFF01" + }, + close_case: { + label: "\u30B1\u30FC\u30B9\u3092\u30AF\u30ED\u30FC\u30BA", + confirmText: "\u3053\u306E\u30B1\u30FC\u30B9\u3092\u30AF\u30ED\u30FC\u30BA\u3057\u3066\u3082\u3088\u308D\u3057\u3044\u3067\u3059\u304B\uFF1F", + successMessage: "\u30B1\u30FC\u30B9\u3092\u30AF\u30ED\u30FC\u30BA\u3057\u307E\u3057\u305F\uFF01" + }, + claim_case: { + label: "\u30B1\u30FC\u30B9\u3092\u5F15\u304D\u53D7\u3051\u308B", + successMessage: "\u30B1\u30FC\u30B9\u3092\u5F15\u304D\u53D7\u3051\u307E\u3057\u305F\u3002\u62C5\u5F53\u8005\u306F\u3042\u306A\u305F\u3067\u3059\u3002" + } + } + }, + crm_knowledge_article: { + _validations: { + published_requires_body: { + message: "\u672C\u6587\u306E\u306A\u3044\u8A18\u4E8B\u306F\u516C\u958B\u3067\u304D\u307E\u305B\u3093\u3002" + }, + published_requires_summary: { + message: "\u516C\u958B\u6E08\u307F\u306E\u8A18\u4E8B\u306B\u306F\u3001\u691C\u7D22\u7D50\u679C\u3068 AI \u306E\u5F15\u7528\u306E\u305F\u3081\u306B\u6982\u8981\u3092\u8A18\u8F09\u3057\u3066\u304F\u3060\u3055\u3044\u3002" + } + }, + label: "\u30CA\u30EC\u30C3\u30B8\u8A18\u4E8B", + pluralLabel: "\u30CA\u30EC\u30C3\u30B8\u30D9\u30FC\u30B9", + description: "\u9867\u5BA2\u3068\u30A8\u30FC\u30B8\u30A7\u30F3\u30C8\u304C\u518D\u5229\u7528\u3067\u304D\u308B\u56DE\u7B54\u3068\u30CF\u30A6\u30C4\u30FC\u30AC\u30A4\u30C9", + fields: { + article_number: { label: "\u8A18\u4E8B\u756A\u53F7" }, + title: { label: "\u30BF\u30A4\u30C8\u30EB" }, + display_title: { label: "\u8868\u793A\u540D" }, + summary: { label: "\u8981\u7D04", help: "\u691C\u7D22\u7D50\u679C\u3084 AI \u306E\u5F15\u7528\u306B\u8868\u793A\u3055\u308C\u308B 1 \u6BB5\u843D\u306E\u8981\u7D04\u3002" }, + body: { label: "\u672C\u6587", help: "\u8A18\u4E8B\u306E\u672C\u6587\uFF08Markdown\uFF09\u3002" }, + category: { + label: "\u30AB\u30C6\u30B4\u30EA", + options: { + getting_started: "\u306F\u3058\u3081\u306B", + how_to: "\u30CF\u30A6\u30C4\u30FC", + troubleshooting: "\u30C8\u30E9\u30D6\u30EB\u30B7\u30E5\u30FC\u30C6\u30A3\u30F3\u30B0", + billing: "\u8ACB\u6C42\u3068\u6599\u91D1", + api: "API \u3068\u9023\u643A", + release_notes: "\u30EA\u30EA\u30FC\u30B9\u30CE\u30FC\u30C8", + policy: "\u30DD\u30EA\u30B7\u30FC" + } + }, + tags: { + label: "\u30BF\u30B0", + options: { + auth: "\u8A8D\u8A3C", + sso: "SSO", + mobile: "\u30E2\u30D0\u30A4\u30EB", + email: "\u30E1\u30FC\u30EB", + reports: "\u30EC\u30DD\u30FC\u30C8", + performance: "\u30D1\u30D5\u30A9\u30FC\u30DE\u30F3\u30B9", + data_import: "\u30C7\u30FC\u30BF\u30A4\u30F3\u30DD\u30FC\u30C8", + webhooks: "Webhook" + } + }, + status: { + label: "\u30B9\u30C6\u30FC\u30BF\u30B9", + options: { draft: "\u4E0B\u66F8\u304D", in_review: "\u30EC\u30D3\u30E5\u30FC\u4E2D", published: "\u516C\u958B\u6E08\u307F", archived: "\u30A2\u30FC\u30AB\u30A4\u30D6" } + }, + audience: { + label: "\u5BFE\u8C61", + help: "\u516C\u958B\u8A18\u4E8B\u306F\u30AB\u30B9\u30BF\u30DE\u30FC\u30DD\u30FC\u30BF\u30EB\u306B\u8868\u793A\u3055\u308C\u3001\u793E\u5185\u8A18\u4E8B\u306F\u30A8\u30FC\u30B8\u30A7\u30F3\u30C8\u306E\u307F\u304C\u95B2\u89A7\u3067\u304D\u307E\u3059\u3002", + options: { public: "\u516C\u958B", internal: "\u793E\u5185" } + }, + language: { + label: "\u8A00\u8A9E", + options: { en: "\u82F1\u8A9E", zh_cn: "\u7C21\u4F53\u5B57\u4E2D\u56FD\u8A9E", es_es: "\u30B9\u30DA\u30A4\u30F3\u8A9E", ja_jp: "\u65E5\u672C\u8A9E" } + }, + owner_id: { label: "\u6240\u6709\u8005" }, + related_to_case: { label: "\u5143\u306E\u30B1\u30FC\u30B9", help: "\u3053\u306E\u8A18\u4E8B\u306E\u5143\u306B\u306A\u3063\u305F\u30B1\u30FC\u30B9\uFF08\u4EFB\u610F\uFF09\u3002" }, + published_at: { label: "\u516C\u958B\u65E5\u6642" }, + last_reviewed_at: { label: "\u6700\u7D42\u30EC\u30D3\u30E5\u30FC" }, + helpful_count: { label: "\u5F79\u306B\u7ACB\u3063\u305F", help: "crm_article_feedback \u304B\u3089\u518D\u96C6\u8A08\u3055\u308C\u307E\u3059\u3002\u624B\u5165\u529B\u306F\u3067\u304D\u307E\u305B\u3093\u3002" }, + not_helpful_count: { label: "\u5F79\u306B\u7ACB\u305F\u306A\u304B\u3063\u305F", help: "crm_article_feedback \u304B\u3089\u518D\u96C6\u8A08\u3055\u308C\u307E\u3059\u3002\u624B\u5165\u529B\u306F\u3067\u304D\u307E\u305B\u3093\u3002" } + }, + _views: { + all_articles: { label: "\u3059\u3079\u3066\u306E\u8A18\u4E8B" }, + published_articles: { label: "\u516C\u958B\u6E08\u307F" }, + my_drafts: { label: "\u81EA\u5206\u306E\u4E0B\u66F8\u304D" } + }, + _sections: { + basic: { label: "\u8A18\u4E8B\u60C5\u5831" }, + content: { label: "\u30B3\u30F3\u30C6\u30F3\u30C4" }, + taxonomy: { label: "\u5206\u985E" }, + metrics: { label: "\u5229\u7528\u72B6\u6CC1" }, + engagement: { label: "\u5229\u7528\u72B6\u6CC1" }, + // knowledge_article.view.ts のフォームセクション名 (#1100) + article: { label: "\u8A18\u4E8B" } + }, + _actions: { + mark_article_helpful: { + label: "\u5F79\u306B\u7ACB\u3063\u305F", + successMessage: "\u300C\u5F79\u306B\u7ACB\u3063\u305F\u300D\u3068\u3057\u3066\u8A18\u9332\u3057\u307E\u3057\u305F\u3002\u3042\u308A\u304C\u3068\u3046\u3054\u3056\u3044\u307E\u3059\u3002" + }, + mark_article_not_helpful: { + label: "\u5F79\u306B\u7ACB\u305F\u306A\u304B\u3063\u305F", + successMessage: "\u300C\u5F79\u306B\u7ACB\u305F\u306A\u304B\u3063\u305F\u300D\u3068\u3057\u3066\u8A18\u9332\u3057\u307E\u3057\u305F\u3002\u3042\u308A\u304C\u3068\u3046\u3054\u3056\u3044\u307E\u3059\u3002" + } + } + }, + crm_article_feedback: { + label: "\u8A18\u4E8B\u30D5\u30A3\u30FC\u30C9\u30D0\u30C3\u30AF", + pluralLabel: "\u8A18\u4E8B\u30D5\u30A3\u30FC\u30C9\u30D0\u30C3\u30AF", + description: "\u30CA\u30EC\u30C3\u30B8\u8A18\u4E8B\u306B\u5BFE\u3059\u308B\u8AAD\u8005\u306E\u300C\u5F79\u306B\u7ACB\u3063\u305F / \u5F79\u306B\u7ACB\u305F\u306A\u304B\u3063\u305F\u300D\u8A55\u4FA1", + fields: { + feedback_number: { label: "\u30D5\u30A3\u30FC\u30C9\u30D0\u30C3\u30AF\u756A\u53F7" }, + owner_id: { label: "\u8AAD\u8005" }, + crm_knowledge_article: { label: "\u8A18\u4E8B", help: "\u3053\u306E\u30D5\u30A3\u30FC\u30C9\u30D0\u30C3\u30AF\u306E\u5BFE\u8C61\u3068\u306A\u308B\u30CA\u30EC\u30C3\u30B8\u8A18\u4E8B\u3002" }, + verdict: { + label: "\u8A55\u4FA1", + options: { helpful: "\u5F79\u306B\u7ACB\u3063\u305F", not_helpful: "\u5F79\u306B\u7ACB\u305F\u306A\u304B\u3063\u305F" } + }, + comment: { label: "\u30B3\u30E1\u30F3\u30C8", help: "\u8A55\u4FA1\u306E\u7406\u7531\uFF08\u4EFB\u610F\uFF09 \u2014 \u8A18\u4E8B\u306E\u4F5C\u6210\u8005\u304C\u8AAD\u307F\u307E\u3059\u3002" } + }, + _sections: { + basic: { label: "\u30D5\u30A3\u30FC\u30C9\u30D0\u30C3\u30AF" } + } + } +}; + +// src/sales/translations/ja-JP/objects.activity.ts +var relatedToTypeOptions = { + crm_account: "\u53D6\u5F15\u5148", + crm_contact: "\u53D6\u5F15\u5148\u8CAC\u4EFB\u8005", + crm_opportunity: "\u5546\u8AC7", + crm_lead: "\u30EA\u30FC\u30C9", + crm_case: "\u30B1\u30FC\u30B9" +}; +var activity3 = { + crm_task: { + _validations: { + completed_date_required: { + message: "\u30B9\u30C6\u30FC\u30BF\u30B9\u304C\u300C\u5B8C\u4E86\u300D\u306E\u5834\u5408\u306F\u5B8C\u4E86\u65E5\u304C\u5FC5\u8981\u3067\u3059" + }, + recurrence_fields_required: { + message: "\u7E70\u308A\u8FD4\u3057\u30BF\u30B9\u30AF\u306B\u306F\u7E70\u308A\u8FD4\u3057\u7A2E\u5225\u304C\u5FC5\u8981\u3067\u3059" + }, + related_to_required: { + message: "\u95A2\u9023\u30EC\u30B3\u30FC\u30C9\u3092\u5C11\u306A\u304F\u3068\u3082 1 \u4EF6\u9078\u629E\u3057\u3066\u304F\u3060\u3055\u3044" + } + }, + label: "\u30BF\u30B9\u30AF", + pluralLabel: "\u30BF\u30B9\u30AF", + description: "\u6D3B\u52D5\u3068 ToDo", + fields: { + subject: { label: "\u4EF6\u540D" }, + description: { label: "\u8AAC\u660E" }, + status: { + label: "\u30B9\u30C6\u30FC\u30BF\u30B9", + options: { + not_started: "\u672A\u7740\u624B", + in_progress: "\u9032\u884C\u4E2D", + waiting: "\u5F85\u6A5F\u4E2D", + completed: "\u5B8C\u4E86", + deferred: "\u4FDD\u7559" + } + }, + priority: { + label: "\u512A\u5148\u5EA6", + options: { low: "\u4F4E", normal: "\u901A\u5E38", high: "\u9AD8", urgent: "\u7DCA\u6025" } + }, + priority_rank: { label: "\u512A\u5148\u5EA6\u30E9\u30F3\u30AF" }, + type: { + label: "\u30BF\u30B9\u30AF\u7A2E\u5225", + options: { + call: "\u96FB\u8A71", + email: "\u30E1\u30FC\u30EB", + meeting: "\u4F1A\u8B70", + follow_up: "\u30D5\u30A9\u30ED\u30FC\u30A2\u30C3\u30D7", + demo: "\u30C7\u30E2", + other: "\u305D\u306E\u4ED6" + } + }, + due_date: { label: "\u671F\u9650" }, + reminder_date: { label: "\u30EA\u30DE\u30A4\u30F3\u30C0\u30FC\u65E5\u6642" }, + reminder_sent: { label: "\u30EA\u30DE\u30A4\u30F3\u30C0\u30FC\u9001\u4FE1\u6E08\u307F" }, + completed_date: { label: "\u5B8C\u4E86\u65E5" }, + owner_id: { label: "\u62C5\u5F53\u8005" }, + related_to_type: { + label: "\u95A2\u9023\u30AA\u30D6\u30B8\u30A7\u30AF\u30C8\u7A2E\u5225", + options: { ...relatedToTypeOptions } + }, + related_to_account: { label: "\u95A2\u9023\u53D6\u5F15\u5148" }, + related_to_contact: { label: "\u95A2\u9023\u53D6\u5F15\u5148\u8CAC\u4EFB\u8005" }, + related_to_opportunity: { label: "\u95A2\u9023\u5546\u8AC7" }, + related_to_lead: { label: "\u95A2\u9023\u30EA\u30FC\u30C9" }, + related_to_case: { label: "\u95A2\u9023\u30B1\u30FC\u30B9" }, + is_recurring: { label: "\u7E70\u308A\u8FD4\u3057\u30BF\u30B9\u30AF" }, + recurrence_type: { + label: "\u7E70\u308A\u8FD4\u3057\u7A2E\u5225", + options: { daily: "\u6BCE\u65E5", weekly: "\u6BCE\u9031", monthly: "\u6BCE\u6708", yearly: "\u6BCE\u5E74" } + }, + recurrence_interval: { label: "\u7E70\u308A\u8FD4\u3057\u9593\u9694" }, + recurrence_end_date: { label: "\u7E70\u308A\u8FD4\u3057\u7D42\u4E86\u65E5" }, + is_completed: { label: "\u5B8C\u4E86\u6E08" }, + is_overdue: { label: "\u671F\u9650\u8D85\u904E" }, + progress_percent: { label: "\u9032\u6357\uFF08%\uFF09" } + }, + _views: { + all_tasks: { label: "\u5168\u30BF\u30B9\u30AF" }, + task_board: { label: "\u30BF\u30B9\u30AF\u30DC\u30FC\u30C9" }, + task_calendar: { label: "\u30BF\u30B9\u30AF\u30AB\u30EC\u30F3\u30C0\u30FC" }, + task_gantt: { label: "\u5B9F\u884C\u8A08\u753B" }, + task_timeline: { label: "\u5DE5\u6570\u30BF\u30A4\u30E0\u30E9\u30A4\u30F3" }, + my_open_tasks: { label: "\u79C1\u306E\u30AA\u30FC\u30D7\u30F3\u30BF\u30B9\u30AF" }, + todays_tasks: { label: "\u{1F4C5} \u79C1\u306E\u512A\u5148\u30BF\u30B9\u30AF" }, + overdue_tasks: { label: "\u23F0 \u30AA\u30FC\u30D7\u30F3\u30BF\u30B9\u30AF \xB7 \u671F\u9650\u8D85\u904E\u304C\u9577\u3044\u9806" } + }, + _sections: { + basic: { label: "\u30BF\u30B9\u30AF\u60C5\u5831" }, + scheduling: { label: "\u30B9\u30B1\u30B8\u30E5\u30FC\u30EB" }, + related: { label: "\u95A2\u9023\u30EC\u30B3\u30FC\u30C9" }, + recurrence: { label: "\u7E70\u308A\u8FD4\u3057" }, + effort: { label: "\u9032\u6357\u30FB\u5DE5\u6570" }, + system: { label: "\u30B7\u30B9\u30C6\u30E0" }, + // task.view.ts のフォームセクション名 (#1100) + task: { label: "\u30BF\u30B9\u30AF" }, + related_records: { label: "\u95A2\u9023\u30EC\u30B3\u30FC\u30C9" }, + recurrence_and_effort: { label: "\u7E70\u308A\u8FD4\u3057\u3068\u5DE5\u6570" } + } + }, + crm_event: { + _validations: { + end_after_start: { + message: "\u7D42\u4E86\u6642\u523B\u306F\u958B\u59CB\u6642\u523B\u3088\u308A\u5F8C\u3067\u3042\u308B\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059" + }, + related_to_required: { + message: "\u95A2\u9023\u30EC\u30B3\u30FC\u30C9\u3092\u5C11\u306A\u304F\u3068\u3082 1 \u4EF6\u9078\u629E\u3057\u3066\u304F\u3060\u3055\u3044" + } + }, + label: "\u30A4\u30D9\u30F3\u30C8", + pluralLabel: "\u30A4\u30D9\u30F3\u30C8", + description: "\u9867\u5BA2\u3068\u306E\u4F1A\u8B70\u30FB\u96FB\u8A71\u306A\u3069\u306E\u4E88\u5B9A\u3055\u308C\u305F\u5BFE\u8A71", + fields: { + subject: { label: "\u4EF6\u540D" }, + description: { label: "\u8AAC\u660E" }, + type: { + label: "\u30A4\u30D9\u30F3\u30C8\u7A2E\u5225", + options: { + meeting: "\u4F1A\u8B70", + call: "\u96FB\u8A71", + demo: "\u30C7\u30E2", + webinar: "\u30A6\u30A7\u30D3\u30CA\u30FC", + onsite_visit: "\u8A2A\u554F", + other: "\u305D\u306E\u4ED6" + } + }, + status: { + label: "\u30B9\u30C6\u30FC\u30BF\u30B9", + options: { + planned: "\u4E88\u5B9A", + held: "\u5B9F\u65BD\u6E08\u307F", + cancelled: "\u30AD\u30E3\u30F3\u30BB\u30EB", + no_show: "\u7121\u65AD\u6B20\u5E2D" + } + }, + owner_id: { label: "\u62C5\u5F53\u8005" }, + start_datetime: { label: "\u958B\u59CB" }, + end_datetime: { label: "\u7D42\u4E86" }, + all_day: { label: "\u7D42\u65E5\u30A4\u30D9\u30F3\u30C8" }, + duration_minutes: { label: "\u6240\u8981\u6642\u9593\uFF08\u5206\uFF09" }, + location: { label: "\u5834\u6240", help: "\u4F1A\u8B70\u5BA4\u30FB\u4F4F\u6240\u30FB\u4F1A\u8B70\u30EA\u30F3\u30AF" }, + related_to_type: { + label: "\u95A2\u9023\u30EC\u30B3\u30FC\u30C9\u7A2E\u5225", + options: { ...relatedToTypeOptions } + }, + related_to_account: { label: "\u95A2\u9023\u53D6\u5F15\u5148" }, + related_to_contact: { label: "\u95A2\u9023\u53D6\u5F15\u5148\u8CAC\u4EFB\u8005" }, + related_to_opportunity: { label: "\u95A2\u9023\u5546\u8AC7" }, + related_to_lead: { label: "\u95A2\u9023\u30EA\u30FC\u30C9" }, + related_to_case: { label: "\u95A2\u9023\u30B1\u30FC\u30B9" }, + outcome_notes: { label: "\u7D50\u679C\u30E1\u30E2", help: "\u5408\u610F\u4E8B\u9805\u3068\u6B21\u306E\u30A2\u30AF\u30B7\u30E7\u30F3" } + }, + _views: { + all_events: { label: "\u3059\u3079\u3066\u306E\u30A4\u30D9\u30F3\u30C8" }, + event_calendar: { label: "\u30A4\u30D9\u30F3\u30C8\u30AB\u30EC\u30F3\u30C0\u30FC" }, + event_timeline: { label: "\u30C1\u30FC\u30E0\u30B9\u30B1\u30B8\u30E5\u30FC\u30EB" }, + my_events: { label: "\u30DE\u30A4\u30AB\u30EC\u30F3\u30C0\u30FC" }, + upcoming_events: { label: "\u{1F4C5} \u958B\u50AC\u4E88\u5B9A \xB7 \u76F4\u8FD1\u9806" }, + held_events: { label: "\u2705 \u5BFE\u8A71\u5C65\u6B74" } + }, + _sections: { + basic: { label: "\u30A4\u30D9\u30F3\u30C8\u60C5\u5831" }, + schedule: { label: "\u30B9\u30B1\u30B8\u30E5\u30FC\u30EB" }, + related: { label: "\u95A2\u9023\u30EC\u30B3\u30FC\u30C9" }, + outcome: { label: "\u5B9F\u65BD\u7D50\u679C" }, + // event.view.ts のフォームセクション名 (#1100) + event: { label: "\u30A4\u30D9\u30F3\u30C8" }, + related_records: { label: "\u95A2\u9023\u30EC\u30B3\u30FC\u30C9" } + } + }, + crm_event_attendee: { + _validations: { + attendee_resolves: { + message: "\u53C2\u52A0\u8005\u306F\u53C2\u52A0\u8005\u7A2E\u5225\u304C\u793A\u3059\u76F8\u624B\u3092\u6307\u5B9A\u3059\u308B\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059\u3002\u53D6\u5F15\u5148\u8CAC\u4EFB\u8005\u306E\u5834\u5408\u306F\u53D6\u5F15\u5148\u8CAC\u4EFB\u8005\u3092\u3001\u793E\u5916\u306E\u5834\u5408\u306F\u793E\u5916\u53C2\u52A0\u8005\u540D\u3092\u5165\u529B\u3057\u3066\u304F\u3060\u3055\u3044" + }, + attendee_type_exclusive: { + message: "\u53C2\u52A0\u8005\u304C\u6307\u5B9A\u3067\u304D\u308B\u76F8\u624B\u306F 1 \u3064\u3060\u3051\u3067\u3059\u3002\u53C2\u52A0\u8005\u7A2E\u5225\u304C\u793A\u3055\u306A\u3044\u9805\u76EE\u306F\u3059\u3079\u3066\u7A7A\u306B\u3057\u3066\u304F\u3060\u3055\u3044" + } + }, + label: "\u30A4\u30D9\u30F3\u30C8\u53C2\u52A0\u8005", + pluralLabel: "\u30A4\u30D9\u30F3\u30C8\u53C2\u52A0\u8005", + description: "\u30A4\u30D9\u30F3\u30C8\u306B\u62DB\u5F85\u3055\u308C\u305F\u3001\u307E\u305F\u306F\u51FA\u5E2D\u3057\u305F\u4EBA", + fields: { + attendee_number: { label: "\u53C2\u52A0\u8005\u756A\u53F7" }, + crm_event: { label: "\u30A4\u30D9\u30F3\u30C8" }, + attendee_type: { + label: "\u53C2\u52A0\u8005\u7A2E\u5225", + options: { contact: "\u53D6\u5F15\u5148\u8CAC\u4EFB\u8005", lead: "\u30EA\u30FC\u30C9", user: "\u793E\u5185\u30E6\u30FC\u30B6\u30FC", external: "\u793E\u5916\u30B2\u30B9\u30C8" } + }, + crm_contact: { label: "\u53D6\u5F15\u5148\u8CAC\u4EFB\u8005", help: "\u53C2\u52A0\u8005\u304C\u65E2\u5B58\u306E\u53D6\u5F15\u5148\u8CAC\u4EFB\u8005\u3067\u3042\u308B\u5834\u5408\u306B\u8A2D\u5B9A\u3057\u307E\u3059" }, + crm_lead: { label: "\u30EA\u30FC\u30C9", help: "\u53C2\u52A0\u8005\u304C\u307E\u3060\u5909\u63DB\u3055\u308C\u3066\u3044\u306A\u3044\u30EA\u30FC\u30C9\u3067\u3042\u308B\u5834\u5408\u306B\u8A2D\u5B9A\u3057\u307E\u3059" }, + sys_user: { label: "\u793E\u5185\u30E6\u30FC\u30B6\u30FC", help: "\u53C2\u52A0\u8005\u304C\u793E\u5185\u306E\u540C\u50DA\u3067\u3042\u308B\u5834\u5408\u306B\u8A2D\u5B9A\u3057\u307E\u3059" }, + external_name: { label: "\u793E\u5916\u53C2\u52A0\u8005", help: "CRM \u306E\u3069\u306E\u30AA\u30D6\u30B8\u30A7\u30AF\u30C8\u306B\u3082\u5B58\u5728\u3057\u306A\u3044\u53C2\u52A0\u8005\u306E\u6C0F\u540D \u2014 \u53C2\u52A0\u8005\u7A2E\u5225\u304C\u300C\u793E\u5916\u30B2\u30B9\u30C8\u300D\u306E\u3068\u304D\u306B\u8A2D\u5B9A\u3057\u307E\u3059" }, + response: { + label: "\u56DE\u7B54", + options: { + no_response: "\u672A\u56DE\u7B54", + accepted: "\u627F\u8AFE", + declined: "\u8F9E\u9000", + tentative: "\u4EEE\u627F\u8AFE" + } + }, + is_organizer: { label: "\u4E3B\u50AC\u8005" }, + invited_date: { label: "\u62DB\u5F85\u65E5\u6642" } + }, + _views: { + all_event_attendees: { label: "\u30A4\u30D9\u30F3\u30C8\u53C2\u52A0\u8005" } + }, + _sections: { + basic: { label: "\u53C2\u52A0\u8005" }, + response: { label: "\u62DB\u5F85" }, + // event_attendee.view.ts のフォームセクション名 (#1100) + attendee: { label: "\u53C2\u52A0\u8005" }, + invitation: { label: "\u62DB\u5F85" } + } + } +}; + +// src/sales/translations/ja-JP/objects.marketing.ts +var marketing3 = { + crm_campaign: { + _validations: { + end_after_start: { + message: "\u7D42\u4E86\u65E5\u306F\u958B\u59CB\u65E5\u3088\u308A\u5F8C\u3067\u3042\u308B\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059" + }, + actual_cost_within_budget: { + message: "\u5B9F\u7E3E\u30B3\u30B9\u30C8\u304C\u4E88\u7B97\u30B3\u30B9\u30C8\u3092\u8D85\u3048\u3066\u3044\u307E\u3059" + } + }, + label: "\u30AD\u30E3\u30F3\u30DA\u30FC\u30F3", + pluralLabel: "\u30AD\u30E3\u30F3\u30DA\u30FC\u30F3", + description: "\u30DE\u30FC\u30B1\u30C6\u30A3\u30F3\u30B0\u30AD\u30E3\u30F3\u30DA\u30FC\u30F3\u3068\u65BD\u7B56", + fields: { + campaign_code: { label: "\u30AD\u30E3\u30F3\u30DA\u30FC\u30F3\u30B3\u30FC\u30C9" }, + name: { label: "\u30AD\u30E3\u30F3\u30DA\u30FC\u30F3\u540D" }, + display_title: { label: "\u8868\u793A\u540D" }, + description: { label: "\u8AAC\u660E" }, + type: { + label: "\u30AD\u30E3\u30F3\u30DA\u30FC\u30F3\u7A2E\u5225", + options: { + email: "\u30E1\u30FC\u30EB", + webinar: "\u30A6\u30A7\u30D3\u30CA\u30FC", + trade_show: "\u5C55\u793A\u4F1A", + conference: "\u30AB\u30F3\u30D5\u30A1\u30EC\u30F3\u30B9", + direct_mail: "\u30C0\u30A4\u30EC\u30AF\u30C8\u30E1\u30FC\u30EB", + social_media: "\u30BD\u30FC\u30B7\u30E3\u30EB\u30E1\u30C7\u30A3\u30A2", + content: "\u30B3\u30F3\u30C6\u30F3\u30C4\u30DE\u30FC\u30B1\u30C6\u30A3\u30F3\u30B0", + partner: "\u30D1\u30FC\u30C8\u30CA\u30FC\u30DE\u30FC\u30B1\u30C6\u30A3\u30F3\u30B0" + } + }, + channel: { + label: "\u4E3B\u8981\u30C1\u30E3\u30CD\u30EB", + options: { + digital: "\u30C7\u30B8\u30BF\u30EB", + social: "\u30BD\u30FC\u30B7\u30E3\u30EB", + email: "\u30E1\u30FC\u30EB", + events: "\u30A4\u30D9\u30F3\u30C8", + partner: "\u30D1\u30FC\u30C8\u30CA\u30FC" + } + }, + status: { + label: "\u30B9\u30C6\u30FC\u30BF\u30B9", + options: { + planning: "\u8A08\u753B\u4E2D", + in_progress: "\u5B9F\u65BD\u4E2D", + completed: "\u5B8C\u4E86", + aborted: "\u4E2D\u6B62" + } + }, + start_date: { label: "\u958B\u59CB\u65E5" }, + end_date: { label: "\u7D42\u4E86\u65E5" }, + budgeted_cost: { label: "\u4E88\u7B97\u30B3\u30B9\u30C8" }, + actual_cost: { label: "\u5B9F\u30B3\u30B9\u30C8" }, + expected_revenue: { label: "\u4E88\u6E2C\u58F2\u4E0A" }, + actual_revenue: { label: "\u5B9F\u53CE\u76CA" }, + target_size: { label: "\u30BF\u30FC\u30B2\u30C3\u30C8\u898F\u6A21", help: "\u5BFE\u8C61\u3068\u3059\u308B\u30EA\u30FC\u30C9\u30FB\u53D6\u5F15\u5148\u8CAC\u4EFB\u8005\u306E\u76EE\u6A19\u4EF6\u6570" }, + num_sent: { label: "\u9001\u4FE1\u6570" }, + num_responses: { label: "\u5FDC\u7B54\u6570" }, + num_leads: { label: "\u30EA\u30FC\u30C9\u6570" }, + num_converted_leads: { label: "\u5909\u63DB\u6E08\u30EA\u30FC\u30C9\u6570" }, + num_opportunities: { label: "\u4F5C\u6210\u6E08\u5546\u8AC7\u6570" }, + num_won_opportunities: { label: "\u53D7\u6CE8\u5546\u8AC7" }, + response_rate: { label: "\u5FDC\u7B54\u7387\uFF08%\uFF09" }, + roi: { label: "ROI\uFF08%\uFF09" }, + owner_id: { label: "\u30AD\u30E3\u30F3\u30DA\u30FC\u30F3\u62C5\u5F53\u8005" }, + landing_page_url: { label: "\u30E9\u30F3\u30C7\u30A3\u30F3\u30B0\u30DA\u30FC\u30B8" }, + is_active: { label: "\u6709\u52B9" } + }, + _views: { + all_campaigns: { label: "\u5168\u30AD\u30E3\u30F3\u30DA\u30FC\u30F3" }, + campaign_gantt: { label: "\u30AD\u30E3\u30F3\u30DA\u30FC\u30F3\u65E5\u7A0B" }, + campaign_calendar: { label: "\u30AD\u30E3\u30F3\u30DA\u30FC\u30F3\u30AB\u30EC\u30F3\u30C0\u30FC" }, + campaign_timeline: { label: "\u30DE\u30FC\u30B1\u30C6\u30A3\u30F3\u30B0\u30BF\u30A4\u30E0\u30E9\u30A4\u30F3" } + }, + _sections: { + basic: { label: "\u30AD\u30E3\u30F3\u30DA\u30FC\u30F3\u60C5\u5831" }, + schedule: { label: "\u30B9\u30B1\u30B8\u30E5\u30FC\u30EB" }, + budget: { label: "\u4E88\u7B97\u30FBROI" }, + metrics: { label: "\u5B9F\u7E3E" }, + assignment: { label: "\u62C5\u5F53\u8005" }, + assets: { label: "\u30AD\u30E3\u30F3\u30DA\u30FC\u30F3\u30A2\u30BB\u30C3\u30C8" } + }, + _actions: { + enroll_leads: { + label: "\u30E1\u30F3\u30D0\u30FC\u3092\u4E00\u62EC\u767B\u9332", + successMessage: "\u5BFE\u8C61\u30E1\u30F3\u30D0\u30FC\u3092\u30AD\u30E3\u30F3\u30DA\u30FC\u30F3\u306B\u767B\u9332\u3057\u307E\u3057\u305F\u3002" + } + } + }, + crm_campaign_member: { + _validations: { + lead_or_contact_required: { + message: "\u30AD\u30E3\u30F3\u30DA\u30FC\u30F3\u30E1\u30F3\u30D0\u30FC\u306F\u30EA\u30FC\u30C9\u307E\u305F\u306F\u53D6\u5F15\u5148\u8CAC\u4EFB\u8005\u306E\u3044\u305A\u308C\u304B\u3092\u53C2\u7167\u3059\u308B\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059" + } + }, + label: "\u30AD\u30E3\u30F3\u30DA\u30FC\u30F3\u30E1\u30F3\u30D0\u30FC", + pluralLabel: "\u30AD\u30E3\u30F3\u30DA\u30FC\u30F3\u30E1\u30F3\u30D0\u30FC", + description: "\u30AD\u30E3\u30F3\u30DA\u30FC\u30F3\u306E\u5BFE\u8C61\u3068\u306A\u3063\u305F\u30EA\u30FC\u30C9\u30FB\u53D6\u5F15\u5148\u8CAC\u4EFB\u8005\u3068\u305D\u306E\u53CD\u5FDC\u72B6\u6CC1", + fields: { + member_number: { label: "\u30E1\u30F3\u30D0\u30FC\u756A\u53F7" }, + crm_campaign: { label: "\u30AD\u30E3\u30F3\u30DA\u30FC\u30F3" }, + crm_lead: { label: "\u30EA\u30FC\u30C9", help: "\u767B\u9332\u6642\u70B9\u3067\u30EA\u30FC\u30C9\u3060\u3063\u305F\u30E1\u30F3\u30D0\u30FC\u306B\u8A2D\u5B9A\u3055\u308C\u307E\u3059" }, + crm_contact: { label: "\u53D6\u5F15\u5148\u8CAC\u4EFB\u8005", help: "\u65E2\u5B58\u306E\u53D6\u5F15\u5148\u8CAC\u4EFB\u8005\u3067\u3042\u308B\u30E1\u30F3\u30D0\u30FC\u306B\u8A2D\u5B9A\u3055\u308C\u307E\u3059" }, + status: { + label: "\u30B9\u30C6\u30FC\u30BF\u30B9", + options: { + sent: "\u9001\u4FE1\u6E08", + responded: "\u5FDC\u7B54\u6E08", + converted: "\u5909\u63DB\u6E08", + unsubscribed: "\u914D\u4FE1\u505C\u6B62" + } + }, + added_date: { label: "\u8FFD\u52A0\u65E5\u6642" }, + response_date: { label: "\u5FDC\u7B54\u65E5\u6642" }, + has_responded: { label: "\u5FDC\u7B54\u6E08" } + }, + _sections: { + basic: { label: "\u57FA\u672C\u60C5\u5831" }, + response: { label: "\u53CD\u5FDC\u30C8\u30E9\u30C3\u30AD\u30F3\u30B0" } + }, + _actions: { + mark_responded: { + label: "\u5FDC\u7B54\u6E08\u306B\u3059\u308B", + successMessage: "\u3053\u306E\u30AD\u30E3\u30F3\u30DA\u30FC\u30F3\u30E1\u30F3\u30D0\u30FC\u306E\u5FDC\u7B54\u3092\u8A18\u9332\u3057\u307E\u3057\u305F\u3002" + } + } + } +}; + +// src/sales/translations/ja-JP.ts +var jaJP2 = { + objects: { + crm_account: customer3.crm_account, + crm_contact: customer3.crm_contact, + crm_knowledge_article: service3.crm_knowledge_article, + crm_forecast: pipeline3.crm_forecast, + crm_lead: pipeline3.crm_lead, + crm_opportunity: pipeline3.crm_opportunity, + crm_case: service3.crm_case, + crm_contract: commerce3.crm_contract, + crm_product: commerce3.crm_product, + crm_quote: commerce3.crm_quote, + crm_task: activity3.crm_task, + crm_campaign: marketing3.crm_campaign, + crm_event: activity3.crm_event, + crm_event_attendee: activity3.crm_event_attendee, + crm_article_feedback: service3.crm_article_feedback, + crm_campaign_member: marketing3.crm_campaign_member, + crm_opportunity_line_item: pipeline3.crm_opportunity_line_item, + crm_quote_line_item: commerce3.crm_quote_line_item + }, + ...appSurface3 +}; + +// src/sales/translations/es-ES/app.ts +var appSurface4 = { + apps: { + crm_enterprise: { + label: "HotCRM", + description: "Gesti\xF3n de relaciones con clientes para ventas, servicio y marketing", + // Indexado por el `id` del nodo de navegación (espacio de nombres plano, + // sea cual sea la profundidad del nodo). + navigation: { + group_activity: { label: "Actividad" }, + nav_event: { label: "Eventos" }, + nav_activity_dashboard: { label: "Actividad de Ventas" }, + nav_my_calendar: { label: "Mi Calendario" }, + nav_home: { label: "Inicio" }, + group_sales: { label: "Ventas" }, + nav_lead: { label: "Prospectos" }, + nav_account: { label: "Cuentas" }, + nav_account_workbench: { label: "Mesa de Trabajo de Cuentas" }, + nav_contact: { label: "Contactos" }, + nav_opportunity: { label: "Oportunidades" }, + nav_quote: { label: "Cotizaciones" }, + nav_contract: { label: "Contratos" }, + nav_product: { label: "Productos" }, + nav_sales_dashboard: { label: "Rendimiento de Ventas" }, + group_work: { label: "Mi Trabajo" }, + nav_my_tasks: { label: "Mis Tareas" }, + nav_my_deals: { label: "Mis Negocios" }, + nav_my_leads: { label: "Mis Prospectos" }, + nav_my_cases: { label: "Mis Casos" }, + nav_approval_requests: { label: "Bandeja de Entrada" }, + group_service: { label: "Servicio" }, + nav_case: { label: "Casos" }, + nav_knowledge: { label: "Conocimiento" }, + nav_service_dashboard: { label: "Resumen de Servicio" }, + group_marketing: { label: "Marketing" }, + nav_campaign: { label: "Campa\xF1as" }, + group_insights: { label: "An\xE1lisis" }, + nav_crm_dashboard: { label: "Resumen CRM" }, + nav_forecast: { label: "Previsiones" }, + nav_report_pipeline_coverage: { label: "Cobertura del Pipeline" }, + nav_report_lead_inflow: { label: "Entrada de Prospectos" }, + nav_report_sla: { label: "Cumplimiento de SLA" } + } + } + }, + messages: { + "common.save": "Guardar", + "common.cancel": "Cancelar", + "common.delete": "Eliminar", + "common.edit": "Editar", + "common.create": "Crear", + "common.search": "Buscar", + "common.filter": "Filtrar", + "common.export": "Exportar", + "common.back": "Volver", + "common.confirm": "Confirmar", + "nav.sales": "Ventas", + "nav.service": "Servicio", + "nav.marketing": "Marketing", + "nav.products": "Productos", + "nav.analytics": "Anal\xEDtica", + "success.saved": "Registro guardado exitosamente", + "success.converted": "Prospecto convertido exitosamente", + "confirm.delete": "\xBFEst\xE1 seguro de que desea eliminar este registro?", + "confirm.convert_lead": "\xBFConvertir este prospecto en cuenta, contacto y oportunidad?", + "error.required": "Este campo es obligatorio", + "error.load_failed": "Error al cargar los datos" + }, + dashboards: { + sales_activity_dashboard: { + label: "Actividad de ventas", + description: "Qui\xE9n habla con los clientes, con qu\xE9 frecuencia y qu\xE9 cuentas se han quedado en silencio", + widgets: { + interactions_held: { title: "Interacciones registradas", description: "Llamadas y reuniones que realmente ocurrieron" }, + meetings_booked: { title: "Reuniones agendadas", description: "Reuniones en el calendario que a\xFAn no ocurren" }, + customer_minutes: { title: "Minutos con clientes", description: "Tiempo total frente a clientes" }, + tasks_completed: { title: "Tareas completadas", description: "Seguimientos cerrados \u2014 la otra mitad de la actividad" }, + activity_by_rep: { title: "Actividad por representante", description: "Interacciones registradas por responsable" }, + activity_by_week: { title: "Volumen de actividad por semana", description: "Interacciones por semana" }, + activity_mix: { title: "Composici\xF3n de la actividad", description: "Llamadas vs reuniones vs demostraciones" }, + activity_by_record_type: { title: "D\xF3nde cae la actividad", description: "Qu\xE9 parte del embudo recibe atenci\xF3n" }, + deal_activity: { title: "Interacciones en oportunidades", description: "Interacciones vinculadas a una oportunidad" }, + open_deals_for_activity: { title: "Oportunidades abiertas", description: "Oportunidades a\xFAn en juego" }, + quiet_accounts_30: { title: "Silencio 30+ d\xEDas", description: "Cuentas activas sin interacci\xF3n en un mes" }, + quiet_accounts_60: { title: "Silencio 60+ d\xEDas", description: "Dos meses de silencio \u2014 el umbral de riesgo" }, + quiet_accounts_90: { title: "Silencio 90+ d\xEDas", description: "Un trimestre sin contacto" } + } + }, + crm_overview_dashboard: { + label: "Resumen CRM", + description: "M\xE9tricas de ingresos, anal\xEDtica de pipeline e informaci\xF3n de oportunidades", + widgets: { + total_revenue: { title: "Ingresos totales", description: "Ingresos cerrados ganados en este per\xEDodo" }, + active_deals: { title: "Negocios activos", description: "Oportunidades abiertas en el pipeline" }, + won_deals: { title: "Negocios ganados", description: "Negocios cerrados ganados en este per\xEDodo" }, + avg_deal_size: { title: "Tama\xF1o medio del negocio", description: "Valor medio de los negocios cerrados ganados" }, + revenue_trends: { title: "Tendencia de ingresos", description: "Ingresos cerrados ganados de los \xFAltimos 12 meses" }, + lead_source: { title: "Origen del prospecto", description: "Valor del pipeline por canal de adquisici\xF3n" }, + pipeline_by_stage: { title: "Pipeline por etapa", description: "Valor de oportunidades abiertas en cada etapa de venta" }, + top_products: { title: "Productos principales", description: "Ingresos a precio de lista por categor\xEDa de producto" }, + pipeline_by_owner: { title: "Pipeline por responsable", description: "Valor del pipeline abierto y n\xFAmero de negocios por comercial" } + } + }, + executive_dashboard: { + label: "Vista ejecutiva", + description: "KPI de alto nivel sobre ingresos, clientes y pipeline para la direcci\xF3n", + widgets: { + total_revenue_ytd: { title: "Ingresos totales (YTD)", description: "Ingresos cerrados ganados en lo que va del a\xF1o" }, + total_accounts: { title: "Cuentas activas", description: "Clientes con al menos una relaci\xF3n activa" }, + total_contacts: { title: "Total de contactos", description: "Personas en nuestra agenda" }, + open_leads: { title: "Prospectos abiertos", description: "Prospectos sin convertir en el embudo" }, + revenue_trend: { title: "Tendencia de ingresos", description: "Ingresos cerrados ganados de los \xFAltimos 12 meses" }, + revenue_by_industry: { title: "Ingresos por industria", description: "Ingresos YTD ganados separados por industria del cliente" }, + pipeline_by_stage: { title: "Pipeline por etapa", description: "Valor de oportunidades abiertas en cada etapa de venta" }, + new_accounts_by_month: { title: "Cuentas nuevas", description: "Ritmo de creaci\xF3n de cuentas en los \xFAltimos 6 meses" }, + accounts_by_industry: { title: "Cuentas por sector", description: "Ingreso anual total y n\xFAmero de cuentas por sector" } + } + }, + sales_dashboard: { + label: "Rendimiento de ventas", + description: "Anal\xEDtica de pipeline, tendencias de tasa de \xE9xito y rendimiento de los representantes", + widgets: { + total_pipeline_value: { title: "Pipeline total", description: "Suma del valor de las oportunidades abiertas" }, + closed_won_qtd: { title: "Cerrado ganado (trimestre)", description: "Ingresos cerrados este trimestre" }, + open_opportunities: { title: "Oportunidades abiertas", description: "Negocios activos en curso" }, + avg_deal_size: { title: "Tama\xF1o medio del negocio", description: "Valor medio de los negocios cerrados ganados este trimestre" }, + pipeline_by_stage: { title: "Pipeline por etapa", description: "Valor de oportunidades abiertas en cada etapa de venta" }, + monthly_revenue_trend: { title: "Tendencia mensual de ingresos", description: "Ingresos cerrados ganados de los \xFAltimos 12 meses" }, + pipeline_by_forecast_category: { title: "Pipeline por categor\xEDa de pron\xF3stico", description: "Pipeline abierto agrupado por categor\xEDa de pron\xF3stico de ventas" }, + lead_source_breakdown: { title: "Origen del prospecto", description: "De d\xF3nde proviene nuestro pipeline" }, + open_pipeline_by_owner: { title: "Pipeline abierto por responsable", description: "Valor del pipeline en curso, n\xFAmero de negocios y probabilidad media de cierre por comercial" }, + quota_attainment_by_rep: { title: "Cumplimiento de cuota por representante", description: "Cuota del trimestre actual, ingresos cerrados y cumplimiento por representante, seg\xFAn instant\xE1neas de pron\xF3stico" }, + pipeline_stage_by_source: { title: "Pipeline por Etapa \xD7 Origen", description: "Tabla cruzada del importe de oportunidades abiertas por etapa y origen" }, + win_rate_12m: { title: "Tasa de \xE9xito (12M)", description: "Negocios ganados como porcentaje de todos los negocios resueltos en los \xFAltimos 12 meses" }, + won_deals_12m: { title: "Negocios ganados (12M)", description: "El numerador de la tasa de \xE9xito" }, + lost_deals_12m: { title: "Negocios perdidos (12M)", description: "La otra mitad del denominador de la tasa de \xE9xito" }, + win_rate_by_owner: { title: "Ganados / perdidos por representante", description: "Negocios ganados, negocios perdidos y tasa de \xE9xito por representante \u2014 \xFAltimos 12 meses" }, + win_rate_by_lead_source: { title: "Ganados / perdidos por origen del prospecto", description: "Qu\xE9 or\xEDgenes producen negocios que realmente se cierran \u2014 \xFAltimos 12 meses" }, + loss_reason_breakdown: { title: "Por qu\xE9 perdemos", description: "Negocios perdidos por motivo \u2014 \xFAltimos 12 meses" } + } + }, + service_dashboard: { + label: "Servicio al cliente", + description: "Carga de casos, salud del SLA y rendimiento de resoluci\xF3n", + widgets: { + open_cases: { title: "Casos abiertos", description: "Casos que a\xFAn no se han cerrado" }, + critical_cases: { title: "Casos cr\xEDticos", description: "Casos abiertos marcados como prioridad cr\xEDtica" }, + avg_resolution_time: { title: "Tiempo medio de resoluci\xF3n", description: "Tiempo medio hasta el cierre, en horas" }, + sla_violations: { title: "Incumplimientos de SLA", description: "Casos que incumplieron su SLA" }, + cases_by_status: { title: "Casos por estado", description: "Distribuci\xF3n de la carga a lo largo del pipeline" }, + cases_by_priority: { title: "Casos por prioridad", description: "Mezcla de casos abiertos por urgencia" }, + cases_by_origin: { title: "Casos por origen", description: "De d\xF3nde provienen nuestros casos" }, + daily_case_volume: { title: "Volumen diario de casos", description: "Casos nuevos creados en los \xFAltimos 30 d\xEDas" }, + sla_compliance_gauge: { title: "Cumplimiento de SLA", description: "Porcentaje de casos resueltos dentro del SLA en este per\xEDodo" }, + kb_deflection_rate: { title: "Tasa de Desv\xEDo por KB", description: "Proporci\xF3n de casos cerrados resueltos con un art\xEDculo de la base de conocimiento" }, + kb_resolved_cases: { title: "Resueltos por KB", description: "Casos cerrados que se\xF1alan el art\xEDculo que los resolvi\xF3" }, + closed_cases_total: { title: "Casos Cerrados", description: "El denominador de la tasa de desv\xEDo" }, + top_resolving_articles: { title: "Art\xEDculos que M\xE1s Resuelven", description: "Art\xEDculos de la base de conocimiento ordenados por los casos cerrados que resolvieron" }, + my_open_cases_by_priority: { title: "Mis casos abiertos por prioridad", description: "Tus casos abiertos y su tasa de incumplimiento de SLA, desglosados por prioridad" } + } + } + }, + // `title` / `subtitle` son las propiedades del componente `page:header`. + // Los marcadores `{…}` se sustituyen sobre la cadena TRADUCIDA, así que el + // token debe conservarse tal cual: traducido, no resuelve y se ve vacío. + datasets: { + account_metrics: { + label: "M\xE9tricas de cuentas", + description: "Capa sem\xE1ntica para el recuento de cuentas por sector y tipo", + dimensions: { + industry: { + label: "Sector" + }, + type: { + label: "Tipo" + }, + created_at: { + label: "Creado" + } + }, + measures: { + account_count: { + label: "Cuentas" + }, + annual_revenue_sum: { + label: "Ingresos anuales" + } + } + }, + case_metrics: { + label: "M\xE9tricas de casos", + description: "Capa sem\xE1ntica para el recuento de casos, el tiempo de resoluci\xF3n y el SLA", + dimensions: { + created_at: { + label: "Creado" + }, + origin: { + label: "Origen" + }, + priority: { + label: "Prioridad" + }, + resolved_article: { + label: "Art\xEDculo de resoluci\xF3n" + }, + status: { + label: "Estado" + }, + type: { + label: "Tipo" + } + }, + measures: { + avg_resolution: { + label: "Resoluci\xF3n media (h)" + }, + avg_sla_violated: { + label: "Tasa de incumplimiento del SLA" + }, + case_count: { + label: "Casos" + }, + closed_count: { + label: "Casos cerrados" + }, + kb_deflection_rate: { + label: "Tasa de desv\xEDo por base de conocimiento" + }, + kb_resolved_count: { + label: "Resueltos por base de conocimiento" + }, + sla_compliance_rate: { + label: "Tasa de cumplimiento del SLA" + }, + sla_met_count: { + label: "Casos dentro del SLA" + } + } + }, + contact_metrics: { + label: "M\xE9tricas de contactos", + description: "Capa sem\xE1ntica para el recuento de contactos", + measures: { + contact_count: { + label: "Contactos" + } + } + }, + event_metrics: { + label: "M\xE9tricas de actividad", + description: "Capa sem\xE1ntica para reuniones, llamadas y recencia de interacci\xF3n", + dimensions: { + owner: { + label: "Propietario" + }, + related_to_type: { + label: "Relacionado con" + }, + start_datetime: { + label: "Semana de actividad" + }, + status: { + label: "Estado" + }, + type: { + label: "Tipo de actividad" + } + }, + measures: { + avg_minutes: { + label: "Duraci\xF3n media" + }, + event_count: { + label: "Actividades" + }, + total_minutes: { + label: "Minutos" + } + } + }, + forecast_metrics: { + label: "M\xE9tricas de previsi\xF3n", + description: "Capa sem\xE1ntica para cuota, cumplimiento y cobertura de pipeline por propietario", + dimensions: { + owner: { + label: "Propietario" + }, + period: { + label: "Tipo de periodo" + }, + period_label: { + label: "Periodo" + }, + period_start: { + label: "Inicio del periodo" + } + }, + measures: { + attainment: { + label: "Cumplimiento" + }, + closed_sum: { + label: "Cerrado" + }, + commit_sum: { + label: "Comprometido" + }, + pipeline_sum: { + label: "Pipeline" + }, + quota_sum: { + label: "Cuota" + } + } + }, + lead_metrics: { + label: "M\xE9tricas de prospectos", + description: "Capa sem\xE1ntica para el recuento de prospectos", + dimensions: { + created_at: { + label: "Creado" + }, + last_contacted_date: { + label: "\xDAltimo contacto" + }, + lead_source: { + label: "Origen" + }, + status: { + label: "Estado" + } + }, + measures: { + lead_count: { + label: "Prospectos" + } + } + }, + opportunity_metrics: { + label: "M\xE9tricas de oportunidades", + description: "Capa sem\xE1ntica para el recuento y los importes del pipeline de ventas", + dimensions: { + account_industry: { + label: "Sector de la cuenta" + }, + close_date: { + label: "Fecha de cierre" + }, + close_quarter: { + label: "Trimestre de cierre" + }, + forecast_category: { + label: "Categor\xEDa de previsi\xF3n" + }, + lead_source: { + label: "Origen del prospecto" + }, + loss_reason: { + label: "Motivo de p\xE9rdida" + }, + owner: { + label: "Propietario" + }, + stage: { + label: "Etapa" + }, + type: { + label: "Tipo de negocio" + }, + win_reason: { + label: "Motivo de ganancia" + } + }, + measures: { + avg_amount: { + label: "Tama\xF1o medio del negocio" + }, + avg_probability: { + label: "Probabilidad media" + }, + decided_count: { + label: "Negocios resueltos" + }, + lost_amount: { + label: "Ingresos perdidos" + }, + lost_count: { + label: "Negocios perdidos" + }, + opp_count: { + label: "Oportunidades" + }, + total_amount: { + label: "Importe total" + }, + win_rate: { + label: "Tasa de ganancia" + }, + won_amount: { + label: "Ingresos ganados" + }, + won_count: { + label: "Negocios ganados" + } + } + }, + product_metrics: { + label: "M\xE9tricas de productos", + description: "Capa sem\xE1ntica para el recuento del cat\xE1logo y el precio de lista", + dimensions: { + category: { + label: "Categor\xEDa" + } + }, + measures: { + list_price_sum: { + label: "Precio de lista total" + }, + product_count: { + label: "Productos" + } + } + }, + task_metrics: { + label: "M\xE9tricas de tareas", + description: "Capa sem\xE1ntica para la carga de trabajo y la finalizaci\xF3n de tareas", + dimensions: { + due_date: { + label: "Fecha de vencimiento" + }, + is_completed: { + label: "Completada" + }, + is_overdue: { + label: "Vencida" + }, + priority: { + label: "Prioridad" + }, + priority_rank: { + label: "Urgencia" + }, + status: { + label: "Estado" + }, + type: { + label: "Tipo" + } + }, + measures: { + avg_progress: { + label: "Progreso medio" + }, + task_count: { + label: "Tareas" + } + } + } + }, + pages: { + account_detail_page: { + label: "Detalle de Cuenta", + description: "P\xE1gina de registro de cuenta por slots: cabecera personalizada + feed de discusi\xF3n permanente.", + title: "{name}", + subtitle: "{industry} \xB7 {type}", + components: { + account_chatter: { label: "Discusi\xF3n" } + } + }, + account_workbench: { + label: "Mesa de Trabajo de Cuentas", + description: "Lista de cuentas curada para el equipo comercial: solo filtros r\xE1pidos, sin gesti\xF3n de vistas." + }, + app_launcher_page: { + label: "Lanzador de Aplicaciones", + description: "Punto de acceso central a todas las aplicaciones", + subtitle: "Seleccione una aplicaci\xF3n para empezar", + components: { + app_search: { label: "Buscar Aplicaciones" }, + app_grid: { label: "Cuadr\xEDcula de Aplicaciones" } + } + }, + case_detail_page: { + label: "Detalle de Caso", + description: "P\xE1gina de caso para el agente de servicio: datos destacados, progreso del SLA, detalles y cronolog\xEDa de actividad.", + title: "{case_number} \xB7 {subject}", + subtitle: "{crm_account}", + components: { + case_highlights: { label: "Informaci\xF3n Clave" }, + case_status_path: { label: "Progreso del Estado del Caso" }, + case_details: { label: "Detalles del Caso" } + } + }, + lead_detail_page: { + label: "Detalle de Prospecto", + description: "P\xE1gina completa de detalle del prospecto, con datos destacados, detalles e informaci\xF3n relacionada", + title: "{first_name} {last_name}", + subtitle: "{company}", + components: { + lead_duplicate_alert_confirmed: { label: "Aviso de duplicado confirmado" }, + lead_duplicate_alert_suspected: { label: "Aviso de duplicado sospechoso" }, + lead_highlights: { label: "Informaci\xF3n Clave" }, + lead_path: { label: "Progreso del Estado del Prospecto" }, + main_tabs: { label: "Pesta\xF1as de Informaci\xF3n del Prospecto" }, + lead_details: { label: "Detalles del Prospecto" }, + related_accordion: { label: "Registros Relacionados" }, + related_tasks: { title: "Tareas Abiertas", label: "Tareas" }, + lead_activity: { label: "Cronolog\xEDa de Actividad" }, + lead_history: { label: "Historial de Campos" } + } + }, + opportunity_detail_page: { + label: "Detalle de Oportunidad", + description: "P\xE1gina completa de detalle de la oportunidad, con recorrido de etapas, datos destacados, detalles y listas relacionadas", + title: "{name}", + subtitle: "{crm_account}", + components: { + opp_highlights: { label: "Informaci\xF3n Clave" }, + opp_stage_path: { label: "Progreso de Etapa de la Oportunidad" }, + opp_details: { label: "Detalles de la Oportunidad" } + } + }, + sales_home_page: { + label: "Inicio de Ventas", + description: "P\xE1gina de inicio del equipo comercial con m\xE9tricas clave y acciones r\xE1pidas", + title: "Panel de Ventas", + subtitle: "Bienvenido de nuevo", + components: { + kpi_revenue_won: { + label: "Ingresos (ganados)" + }, + kpi_deals_won: { + label: "Negocios ganados" + }, + kpi_pipeline_value: { + label: "Valor del pipeline" + }, + kpi_open_leads: { + label: "Prospectos abiertos" + }, + home_upcoming_events: { + label: "\u{1F4C5} Pr\xF3ximos \xB7 M\xE1s cercanos primero" + }, + quick_create: { title: "Creaci\xF3n R\xE1pida", label: "Creaci\xF3n R\xE1pida" }, + key_metrics: { title: "Indicadores Clave de Rendimiento", label: "M\xE9tricas Clave" }, + home_tabs: { label: "Pesta\xF1as de Inicio" }, + home_my_leads: { label: "Mis Prospectos" }, + home_my_deals: { label: "Mis Negocios Abiertos" }, + home_my_tasks: { label: "Mis Tareas Abiertas" }, + ai_briefing: { + title: "Preg\xFAntale al Asistente de IA", + label: "Hoy con el Asistente de IA" + }, + upcoming_events: { title: "Pr\xF3ximos Eventos", label: "Pr\xF3ximos Eventos" } + } + }, + utility_bar_page: { + label: "Barra de Utilidades", + description: "Barra de acceso r\xE1pido con herramientas flotantes", + components: { + notifications_panel: { label: "Notificaciones" }, + quick_notes: { title: "Notas R\xE1pidas", label: "Notas R\xE1pidas" }, + quick_search: { label: "B\xFAsqueda R\xE1pida" } + } + } + }, + // Screen-flow copy (#1210, #1975). Keyed `flows..label`, + // `screens..title` and `screens..fields..{label,placeholder}` + // — the keys `os lint`'s `i18n/missing-flow` names, read by the console's + // flow runner since @objectstack 17.7.0 (the spec's `flows` liveness row is + // `live` there). A screen with no authored `title` shows its flow's label in + // every locale, so each `screen_1.title` repeats the flow label. Since + // 18.0.0-next.0 three more surfaces are keys the engine reads in the run's + // locale, and `i18n/missing-flow` names each missing one: a select field's + // `options.` (worded as the object field's own option in this pack), + // an authored screen `description`, and a refusing `end` node's + // `refusals..message`. A translated description or message is a text + // slot like the one it translates, so a hole in it is `{{ }}`. + // The discount ceiling is interpolated from `QUOTE_DISCOUNT_CEILING`, never + // retyped: the number lives in `_thresholds.ts` alone (#1711). + flows: { + campaign_enrollment: { + label: "Inscribir miembros en la campa\xF1a", + screens: { + screen_1: { + title: "Inscribir miembros en la campa\xF1a", + fields: { + memberSource: { label: "Tipo de miembro a inscribir", options: { leads: "Prospectos", contacts: "Contactos" } }, + leadStatus: { label: "Inscribir prospectos con estado", options: { new: "Nuevo", contacted: "Contactado", qualified: "Calificado" } }, + contactDepartment: { + label: "Inscribir contactos del departamento", + options: { executive: "Ejecutivo", sales: "Ventas", marketing: "Marketing", engineering: "Ingenier\xEDa", support: "Soporte", finance: "Finanzas", hr: "Recursos Humanos", operations: "Operaciones" } + } + } + } + } + }, + escalate_case: { + label: "Escalar Caso", + screens: { screen_1: { title: "Escalar Caso", fields: { reason: { label: "Motivo de Escalaci\xF3n" } } } } + }, + close_case: { + label: "Cerrar Caso", + screens: { + screen_1: { + title: "Cerrar Caso", + fields: { + resolution: { label: "Resoluci\xF3n" }, + resolved_by_article: { label: "Resuelto con art\xEDculo (opcional)" } + } + } + } + }, + claim_case: { + label: "Tomar Caso", + screens: { + screen_1: { + title: "Tomar Caso", + fields: { + claimStatus: { + label: "Estado de trabajo", + options: { in_progress: "En Curso", waiting_customer: "Esperando al Cliente", waiting_support: "Esperando a Soporte" } + } + } + } + } + }, + lead_conversion: { + label: "Proceso de conversi\xF3n de prospecto", + screens: { + screen_1: { + title: "Proceso de conversi\xF3n de prospecto", + // The duplicate warning's text is a variable the flow assigns; this + // key can only carry the hole that shows it. + description: "{{duplicateWarning}}", + fields: { + createOpportunity: { label: "\xBFCrear oportunidad?" }, + opportunityName: { label: "Nombre de Oportunidad" }, + opportunityAmount: { label: "Monto de la Oportunidad" }, + closeDate: { label: "Fecha de Cierre" } + } + }, + refuse_confirmed_duplicate: { + title: "Conversi\xF3n rechazada", + description: "El Estado del Duplicado de este prospecto es Confirmado: un revisor lo compar\xF3 con un registro existente y registr\xF3 que lo repite. Convertirlo crear\xEDa una segunda cuenta, contacto y oportunidad para el mismo comprador. La secci\xF3n Gesti\xF3n de Duplicados de este prospecto indica el registro que se conserva; descalifique este prospecto como duplicado. Solo un revisor que cambie ese veredicto vuelve a habilitar la conversi\xF3n." + }, + refuse_unapproved: { + title: "Conversi\xF3n rechazada", + description: "Este prospecto no ha sido aprobado para la conversi\xF3n. Un aprobador debe darle el visto bueno antes de que pueda convertirse en una cuenta, un contacto y una oportunidad; el campo Aprobaci\xF3n de Conversi\xF3n del prospecto muestra si la decisi\xF3n sigue pendiente o fue rechazada. Mientras tanto, siga trabajando el prospecto: nada de \xE9l queda bloqueado." + }, + refuse_no_match_key: { + title: "Conversi\xF3n rechazada", + description: "La empresa de este prospecto no tiene clave de coincidencia, as\xED que la conversi\xF3n no puede saber a qu\xE9 cuenta pertenece y no lo va a adivinar: una suposici\xF3n podr\xEDa archivar el contacto y la oportunidad bajo otro cliente. Guardar la Empresa del prospecto reconstruye la clave, as\xED que gu\xE1rdela de nuevo y luego convi\xE9rtalo. No se ha creado nada." + } + } + }, + schedule_followup: { + label: "Programar Seguimiento", + screens: { + screen_1: { + title: "Programar Seguimiento", + fields: { + subject: { label: "\xBFCu\xE1l es el siguiente paso?" }, + dueDate: { label: "Fecha L\xEDmite" }, + activityType: { + label: "Tipo de Actividad", + options: { call: "Llamada", email: "Email", meeting: "Reuni\xF3n", follow_up: "Seguimiento", demo: "Demostraci\xF3n", other: "Otro" } + }, + priority: { label: "Prioridad", options: { low: "Baja", normal: "Normal", high: "Alta", urgent: "Urgente" } }, + notes: { label: "Notas" } + } + } + } + }, + quote_generation: { + label: "Generar cotizaci\xF3n desde la oportunidad", + refusals: { refuse_held: { message: "Primero va la aprobaci\xF3n de calificaci\xF3n: marque Solicitar Aprobaci\xF3n de Calificaci\xF3n. No se cre\xF3 nada." } }, + screens: { + screen_1: { + title: "Generar cotizaci\xF3n desde la oportunidad", + fields: { + quoteName: { label: "Nombre de Cotizaci\xF3n" }, + expirationDays: { label: "V\xE1lida por (d\xEDas)" }, + discount: { label: `Descuento % (\u2264 ${QUOTE_DISCOUNT_CEILING})`, placeholder: `0-${QUOTE_DISCOUNT_CEILING}` } + } + } + } + } + } +}; + +// src/sales/translations/es-ES/_shared.ts +var activityActions4 = { + log_call: { + label: "Registrar llamada", + successMessage: "\xA1Llamada registrada exitosamente!", + params: { + subject: { label: "Asunto de la llamada" }, + duration: { label: "Duraci\xF3n (minutos)" }, + attendee_contacts: { label: "Contactos participantes" }, + attendee_users: { label: "Participantes internos" }, + notes: { label: "Notas de la llamada" } + } + }, + log_meeting: { + label: "Registrar reuni\xF3n", + successMessage: "\xA1Reuni\xF3n registrada exitosamente!", + params: { + subject: { label: "Asunto de la reuni\xF3n" }, + duration: { label: "Duraci\xF3n (minutos)" }, + attendee_contacts: { label: "Contactos participantes" }, + attendee_users: { label: "Participantes internos" }, + notes: { label: "Notas de la reuni\xF3n" } + } + }, + schedule_meeting: { + label: "Programar reuni\xF3n", + successMessage: "\xA1Reuni\xF3n programada!", + params: { + subject: { label: "Asunto de la reuni\xF3n" }, + start_date: { label: "Fecha de inicio (UTC)" }, + start_time: { label: "Hora de inicio (UTC)" }, + location: { label: "Ubicaci\xF3n" }, + duration: { label: "Duraci\xF3n (minutos)" }, + attendee_contacts: { label: "Contactos participantes" }, + attendee_users: { label: "Participantes internos" }, + notes: { label: "Agenda" } + } + } +}; + +// src/sales/translations/es-ES/objects.customer.ts +var customer4 = { + crm_account: { + label: "Cuenta", + pluralLabel: "Cuentas", + description: "Empresas y organizaciones con las que mantenemos relaci\xF3n comercial", + fields: { + account_number: { label: "N\xFAmero de Cuenta" }, + registration_number: { + label: "N\xFAmero de Registro", + help: "La identidad registrada de la contraparte, emitida por su propio registro gubernamental. No es el N\xFAmero de Cuenta, que emitimos nosotros." + }, + commercial_capability: { + label: "Capacidad Comercial", + help: "Si se puede abrir nuevo negocio con esta cuenta. Las cuentas de Solo Liquidaci\xF3n siguen siendo utilizables para facturaci\xF3n y pagos, pero no se les puede vincular ninguna oportunidad nueva.", + options: { full: "Completa", settlement_only: "Solo Liquidaci\xF3n" } + }, + incumbent_vendor: { label: "Proveedor Actual", help: "El proveedor que actualmente atiende el gasto que perseguimos en esta cuenta." }, + annual_purchasing_budget: { label: "Presupuesto Anual de Compras", help: "Lo que esta cuenta espera gastar con proveedores este a\xF1o, no sus propios ingresos." }, + payment_cycle: { + label: "Ciclo de Pago", + options: { prepaid: "Prepago", net_30: "30 d\xEDas", net_60: "60 d\xEDas", net_90: "90 d\xEDas" } + }, + approval_status: { + label: "Estado de Aprobaci\xF3n", + help: "En qu\xE9 punto de su aprobaci\xF3n est\xE1 esta cuenta. Una cuenta nueva comienza Pendiente y se decide en la bandeja de aprobaciones.", + options: { pending: "Pendiente", approved: "Aprobada", rejected: "Rechazada" } + }, + name: { label: "Nombre de Cuenta", help: "Nombre legal de la empresa u organizaci\xF3n" }, + name_normalized: { + label: "Nombre de Cuenta (Normalizado)", + help: "Clave de coincidencia para la conversi\xF3n de prospectos: el Nombre de Cuenta en min\xFAsculas, sin espacios sobrantes y con los espacios internos reducidos a uno. Lo mantiene el hook account_protection \u2014 nunca lo edite directamente." + }, + display_title: { label: "T\xEDtulo Mostrado" }, + type: { + label: "Tipo", + // `former` is 'Former Customer' in account.object.ts; the `en` bundle + // had truncated it to 'Former', and translating that truncation gave + // a bare 'Anterior' — an adjective with no noun, next to three option + // labels that are all nouns. + options: { prospect: "Prospecto", customer: "Cliente", partner: "Socio", former: "Cliente Anterior" } + }, + industry: { + label: "Industria", + options: { + technology: "Tecnolog\xEDa", + software: "Software / SaaS", + finance: "Finanzas", + healthcare: "Salud", + retail: "Comercio", + manufacturing: "Manufactura", + education: "Educaci\xF3n", + real_estate: "Inmobiliaria", + media: "Medios y Entretenimiento", + logistics: "Log\xEDstica", + hospitality: "Hosteler\xEDa", + energy: "Energ\xEDa y Servicios P\xFAblicos", + government: "Gobierno", + nonprofit: "Sin \xC1nimo de Lucro", + other: "Otro" + } + }, + annual_revenue: { label: "Ingresos Anuales" }, + child_account_revenue: { label: "Ingresos de Cuentas Hijas", help: "Suma de los ingresos anuales de las cuentas hijas directas." }, + number_of_employees: { label: "N\xFAmero de Empleados" }, + phone: { label: "Tel\xE9fono" }, + website: { label: "Sitio Web" }, + billing_address: { label: "Direcci\xF3n de Facturaci\xF3n" }, + billing_country: { + label: "Pa\xEDs de Facturaci\xF3n", + help: "Derivado de la Direcci\xF3n de Facturaci\xF3n \u2014 el pa\xEDs tal como se introdujo, sin espacios y en may\xFAsculas." + }, + territory: { + label: "Territorio", + help: "Derivado de la Direcci\xF3n de Facturaci\xF3n \u2014 el territorio de ventas que usan las reglas de compartici\xF3n. Las cuentas fuera de los territorios con equipo asignado son Otro.", + options: { na: "Norteam\xE9rica", emea: "EMEA", other: "Otro" } + }, + office_location: { label: "Ubicaci\xF3n de Oficina" }, + owner_id: { label: "Propietario de Cuenta" }, + parent_account: { label: "Cuenta Matriz", help: "Empresa matriz en la jerarqu\xEDa" }, + description: { label: "Descripci\xF3n" }, + is_active: { label: "Activo" }, + last_activity_date: { label: "Fecha de \xDAltima Actividad" }, + brand_color: { label: "Color de Marca" }, + logo: { label: "Logo de la Empresa" }, + tier: { + label: "Nivel de Cliente", + options: { + strategic: "Estrat\xE9gico", + enterprise: "Gran Empresa", + mid_market: "Mediana Empresa", + smb: "PYME" + } + }, + segment: { + label: "Segmento", + options: { + net_new: "Cliente Nuevo", + growth: "Crecimiento", + at_risk: "En Riesgo", + stable: "Estable" + } + }, + health_score: { + label: "\xCDndice de Salud", + help: "Indicador de salud mantenido por el CSM", + options: { + healthy: "Saludable", + watching: "En Observaci\xF3n", + at_risk: "En Riesgo", + churning: "En Fuga" + } + } + }, + _views: { + all_accounts: { + label: "Todas las Cuentas", + description: "Lista maestra de cuentas con ingresos e industria", + bulkActions: { + delete: { + label: "Eliminar", + confirmLabel: "Eliminar", + confirmText: "\xBFEliminar permanentemente {{count}} cuenta(s)? Esta acci\xF3n no se puede deshacer." + }, + transfer_owner: { + label: "Transferir propietario", + confirmText: "\xBFTransferir la propiedad de {{count}} cuenta(s)?", + params: { + owner_id: { + label: "Nuevo propietario" + } + } + }, + update_tier: { + label: "Actualizar nivel", + confirmText: "\xBFActualizar el nivel de {{count}} cuenta(s) a {{tier}}?", + params: { + tier: { + label: "Nivel de cliente" + } + } + } + } + }, + account_gallery: { label: "Galer\xEDa de Cuentas", description: "Vista de tarjetas con colores de marca" }, + account_map: { label: "Mapa de Cuentas", description: "Distribuci\xF3n geogr\xE1fica de cuentas" }, + enterprise_accounts: { label: "Cuentas Empresariales", description: "Cuentas con mayores ingresos anuales" }, + my_accounts: { label: "Mis Cuentas", description: "Cuentas asignadas al usuario actual" }, + at_risk_accounts: { label: "\u26A0\uFE0F Cuentas en Riesgo" } + }, + _sections: { + basic: { label: "Informaci\xF3n B\xE1sica" }, + financials: { label: "Datos Financieros" }, + business_profile: { label: "Perfil de Negocio" }, + contact_info: { label: "Informaci\xF3n de Contacto" }, + ownership: { label: "Propiedad y Estado" }, + branding: { label: "Identidad de Marca" }, + system: { label: "Sistema" }, + // Nombres de sección del formulario en account.view.ts (#1100) + profile: { label: "Perfil" }, + customer_success: { label: "\xC9xito del Cliente" }, + locations: { label: "Ubicaciones" }, + description: { label: "Descripci\xF3n" } + }, + _actions: { ...activityActions4 } + }, + crm_contact: { + label: "Contacto", + pluralLabel: "Contactos", + description: "Personas asociadas a las cuentas", + fields: { + // Mismo juego de valores que `crm_lead.salutation` — tradúzcanse igual. + salutation: { + label: "T\xEDtulo", + options: { mr: "Sr.", ms: "Srta.", mrs: "Sra.", dr: "Dr.", prof: "Prof." } + }, + first_name: { label: "Nombre" }, + last_name: { label: "Apellido" }, + full_name: { label: "Nombre Completo" }, + crm_account: { label: "Cuenta" }, + email: { label: "Correo Electr\xF3nico" }, + phone: { label: "Tel\xE9fono" }, + mobile: { label: "M\xF3vil" }, + title: { label: "Cargo" }, + department: { + label: "Departamento", + options: { + executive: "Ejecutivo", + sales: "Ventas", + marketing: "Marketing", + engineering: "Ingenier\xEDa", + support: "Soporte", + finance: "Finanzas", + hr: "Recursos Humanos", + operations: "Operaciones" + } + }, + // Centro de compra (REQ-0004) — el mapa de la decisión. La etiqueta + // inglesa es 'Buying Function' y no 'Buying Role': la regla + // security-role-word reserva la palabra inglesa `role` en las + // declaraciones (ADR-0090 D3). Esa regla sólo lee inglés y no alcanza + // los paquetes de idioma, así que aquí va el término natural. + buying_function: { + label: "Rol de Compra", + options: { + decision_maker: "Decisor", + economic_buyer: "Comprador Econ\xF3mico", + technical_evaluator: "Evaluador T\xE9cnico", + user: "Usuario", + influencer: "Influenciador", + gatekeeper: "Guardi\xE1n" + } + }, + attitude: { + label: "Actitud hacia Nosotros", + options: { + champion: "Defensor", + supportive: "Favorable", + neutral: "Neutral", + skeptical: "Esc\xE9ptico", + blocker: "Bloqueador" + } + }, + relationship_strength: { + label: "Fuerza de la Relaci\xF3n", + options: { + distant: "Distante", + acquaintance: "Conocido", + working: "Relaci\xF3n de Trabajo", + strong: "Fuerte", + trusted_advisor: "Asesor de Confianza" + } + }, + owner_id: { label: "Propietario de Contacto" }, + description: { label: "Descripci\xF3n" }, + is_primary: { label: "Contacto Principal", help: "\xBFEs este el contacto principal de la cuenta?" }, + avatar: { label: "Foto de Perfil" }, + mailing_address: { label: "Direcci\xF3n de Correo" }, + // Juego compartido con `crm_lead.lead_source` y + // `crm_opportunity.lead_source` — los tres deben coincidir literalmente. + lead_source: { + label: "Origen del Prospecto", + options: { + web: "Web", + referral: "Referencia", + event: "Evento / Feria", + webinar: "Seminario Web", + partner: "Socio", + advertisement: "Publicidad", + paid_search: "B\xFAsqueda de Pago", + social: "Redes Sociales", + content: "Contenido / Blog", + cold_call: "Llamada en Fr\xEDo", + email_campaign: "Campa\xF1a de Email", + other: "Otro" + } + }, + do_not_call: { label: "No Llamar" }, + email_opt_out: { label: "Excluir de Correos" }, + last_contacted_date: { label: "\xDAltimo contacto" } + }, + _views: { + all_contacts: { label: "Todos los Contactos" }, + contact_directory: { label: "Directorio de Contactos" }, + primary_contacts: { label: "Contactos Principales" } + }, + _sections: { + identity: { label: "Identidad" }, + account_info: { label: "Cuenta y Cargo" }, + buying_centre: { label: "Centro de Compra" }, + contact_info: { label: "Informaci\xF3n de Contacto" }, + mailing_address: { label: "Direcci\xF3n de Correo" }, + additional: { label: "Informaci\xF3n Adicional" }, + preferences: { label: "Preferencias de Comunicaci\xF3n" }, + // Nombres de sección del formulario en contact.view.ts (#1100) + contact_details: { label: "Informaci\xF3n de Contacto" }, + comm_preferences: { label: "Preferencias" } + }, + _actions: { + ...activityActions4, + mark_primary: { + label: "Marcar como Principal", + confirmText: "\xBFEstablecer este contacto como contacto principal de la cuenta?", + successMessage: "\xA1Establecido como contacto principal!" + }, + send_email: { + label: "Enviar Correo", + params: { + subject: { label: "Asunto" }, + body: { label: "Cuerpo" } + } + }, + add_contact_to_campaign: { + label: "A\xF1adir a Campa\xF1a", + successMessage: "\xA1Contactos a\xF1adidos a la campa\xF1a!", + params: { + crm_campaign: { label: "Campa\xF1a" } + } + } + } + } +}; + +// src/sales/translations/es-ES/objects.pipeline.ts +var pipeline4 = { + crm_lead: { + _validations: { + disqualification_reason_required: { + message: "El motivo de descalificaci\xF3n es obligatorio cuando un prospecto no est\xE1 cualificado" + }, + duplicate_disqualification_requires_survivor: { + message: "Descalificar un prospecto como duplicado exige nombrar el registro superviviente y marcar el estado de duplicado como Confirmado" + }, + email_required: { + message: "El correo electr\xF3nico es obligatorio" + }, + lead_status_progression: { + message: "Transici\xF3n de estado de prospecto no v\xE1lida" + } + }, + label: "Prospecto", + pluralLabel: "Prospectos", + description: "Clientes potenciales todav\xEDa sin calificar", + fields: { + first_name: { label: "Nombre" }, + last_name: { label: "Apellido" }, + company: { label: "Empresa" }, + company_normalized: { + label: "Empresa (Normalizado)", + help: "Clave de coincidencia para la conversi\xF3n de prospectos: la Empresa en min\xFAsculas, sin espacios sobrantes y con los espacios internos reducidos a uno. Lo mantiene el hook lead_duplicate_check \u2014 nunca lo edite directamente." + }, + display_title: { label: "T\xEDtulo Mostrado" }, + title: { label: "Cargo" }, + email: { label: "Correo Electr\xF3nico" }, + phone: { label: "Tel\xE9fono" }, + status: { + label: "Estado", + options: { + new: "Nuevo", + contacted: "Contactado", + qualified: "Calificado", + unqualified: "No Calificado", + converted: "Convertido" + } + }, + lead_source: { + label: "Origen del Prospecto", + options: { + web: "Web", + referral: "Referencia", + event: "Evento / Feria", + webinar: "Seminario Web", + partner: "Socio", + advertisement: "Publicidad", + paid_search: "B\xFAsqueda de Pago", + social: "Redes Sociales", + content: "Contenido / Blog", + cold_call: "Llamada en Fr\xEDo", + email_campaign: "Campa\xF1a de Email", + other: "Otro" + } + }, + owner_id: { label: "Propietario" }, + is_converted: { label: "Convertido" }, + description: { label: "Descripci\xF3n" }, + // Mismo juego de valores que `crm_contact.salutation` — tradúzcanse igual. + salutation: { + label: "Tratamiento", + options: { mr: "Sr.", ms: "Srta.", mrs: "Sra.", dr: "Dr.", prof: "Prof." } + }, + full_name: { label: "Nombre Completo" }, + // Los 15 valores son los mismos que en `crm_account.industry` — deben + // coincidir literalmente entre ambas pantallas. + industry: { + label: "Industria", + options: { + technology: "Tecnolog\xEDa", + software: "Software / SaaS", + finance: "Finanzas", + healthcare: "Salud", + retail: "Comercio", + manufacturing: "Manufactura", + education: "Educaci\xF3n", + real_estate: "Inmobiliaria", + media: "Medios y Entretenimiento", + logistics: "Log\xEDstica", + hospitality: "Hosteler\xEDa", + energy: "Energ\xEDa y Servicios P\xFAblicos", + government: "Gobierno", + nonprofit: "Sin \xC1nimo de Lucro", + other: "Otro" + } + }, + mobile: { label: "M\xF3vil" }, + website: { label: "Sitio Web" }, + rating: { label: "Puntuaci\xF3n de Prospecto", help: "Puntuaci\xF3n de calidad del prospecto (1-5 estrellas)" }, + next_followup_date: { label: "Pr\xF3xima Fecha de Seguimiento" }, + last_contacted_date: { label: "\xDAltimo Contacto" }, + need_type: { + label: "Tipo de Necesidad", + help: "Qu\xE9 est\xE1 pidiendo este prospecto. La asignaci\xF3n, la priorizaci\xF3n y los informes de demanda leen este campo.", + options: { + new_implementation: "Nueva Implantaci\xF3n", + expansion: "Ampliaci\xF3n", + replacement: "Sustituci\xF3n", + renewal: "Renovaci\xF3n", + consulting: "Consultor\xEDa", + support: "Soporte y Mantenimiento", + other: "Otro" + } + }, + estimated_amount: { + label: "Importe Estimado", + help: "Valor estimado de esta necesidad, antes de la cualificaci\xF3n. Precarga el importe de la oportunidad al convertir." + }, + conversion_approval_status: { + label: "Aprobaci\xF3n de Conversi\xF3n", + help: "Si este prospecto tiene el visto bueno para convertirse. \xABNo Requerida\xBB significa que no se pide aprobaci\xF3n: es el valor predeterminado de f\xE1brica.", + options: { + not_required: "No Requerida", + pending: "Pendiente", + approved: "Aprobada", + rejected: "Rechazada" + } + }, + converted_account: { label: "Cuenta Convertida" }, + converted_contact: { label: "Contacto Convertido" }, + converted_opportunity: { label: "Oportunidad Convertida" }, + converted_date: { label: "Fecha de Conversi\xF3n" }, + address: { label: "Direcci\xF3n" }, + annual_revenue: { label: "Ingresos Anuales" }, + number_of_employees: { label: "N\xFAmero de Empleados" }, + notes: { label: "Notas", help: "Notas de trabajo sobre este cliente potencial: admite formato." }, + do_not_call: { label: "No Llamar" }, + email_opt_out: { label: "Excluir de Correos" }, + disqualification_reason: { + label: "Motivo de No Calificaci\xF3n", + help: "Obligatorio cuando el estado es No Calificado", + options: { + not_a_fit: "No Encaja", + no_budget: "Sin Presupuesto", + wrong_persona: "Perfil Incorrecto", + unreachable: "Ilocalizable", + duplicate: "Duplicado", + competitor: "Competidor", + other: "Otro" + } + }, + duplicate_of_type: { + label: "Duplicado De", + help: "Qu\xE9 objeto contiene el registro superviviente que este prospecto repite.", + // `erased` es una lápida, no una opción: el formulario no la ofrece + // (ver `src/sales/views/lead.view.ts`), pero un prospecto cuyo superviviente + // fue eliminado la lleva, así que necesita etiqueta allí donde el + // registro se LEE; sin traducir se mostraría el valor crudo `erased`. + options: { crm_lead: "Prospecto", crm_contact: "Contacto", erased: "Registro Eliminado" } + }, + duplicate_of_lead: { label: "Prospecto Duplicado" }, + duplicate_of_contact: { label: "Contacto Duplicado" }, + duplicate_status: { + label: "Estado del Duplicado", + help: "Sospechoso = marcado autom\xE1ticamente en la captura. Confirmado = una persona verific\xF3 la coincidencia.", + options: { suspected: "Sospechoso", confirmed: "Confirmado" } + } + }, + _views: { + all_leads: { + label: "Todos los Prospectos", + emptyState: { title: "Todav\xEDa no hay prospectos", message: "Empiece creando su primer prospecto" } + }, + kanban_by_status: { label: "Pipeline de Prospectos" }, + calendar_by_created: { label: "Calendario de Prospectos" }, + gallery_view: { label: "Galer\xEDa de Prospectos" }, + my_leads: { label: "Mis Prospectos" }, + high_priority: { label: "Alta Prioridad" }, + hot_leads: { label: "\u{1F525} Prospectos Calientes" }, + suspected_duplicates: { + label: "Duplicados Sospechosos", + emptyState: { + title: "Sin duplicados sospechosos", + message: "Nada que revisar: se han comprobado todos los correos recapturados." + } + } + }, + _sections: { + // Claves de sección del objeto (lead.object.ts) que usan los + // formularios de registro y la página de detalle, cuyas secciones + // hacen referencia a estos grupos (#806). + address: { label: "Direcci\xF3n" }, + identity: { label: "Identidad" }, + company_info: { label: "Informaci\xF3n de la Empresa" }, + contact_info: { label: "Informaci\xF3n de Contacto" }, + qualification: { label: "Calificaci\xF3n" }, + assignment: { label: "Asignaci\xF3n" }, + conversion: { label: "Conversi\xF3n" }, + additional: { label: "Informaci\xF3n Adicional" }, + preferences: { label: "Preferencias de Comunicaci\xF3n" }, + duplicates: { label: "Gesti\xF3n de Duplicados" }, + // Nombres de sección del formulario en lead.view.ts (#1100) — aquí + // viven las secciones del formulario por defecto y las de cada formView + // con nombre: si se añade un formulario allí, se añaden aquí sus + // nombres de sección. + contact_information: { label: "Informaci\xF3n de Contacto" }, + lead_classification: { label: "Clasificaci\xF3n del Lead" }, + company_information: { label: "Informaci\xF3n de la Empresa" }, + additional_information: { label: "Informaci\xF3n Adicional" }, + privacy: { label: "Privacidad" }, + general: { label: "General" }, + details: { label: "Detalles" }, + step_1_contact_details: { label: "Paso 1: Datos de Contacto" }, + step_2_company_information: { label: "Paso 2: Informaci\xF3n de la Empresa" }, + step_3_qualification: { label: "Paso 3: Calificaci\xF3n" }, + step_4_review_and_convert: { label: "Paso 4: Revisar y Convertir" }, + primary_information: { label: "Informaci\xF3n Principal" }, + extended_details: { label: "Detalles Ampliados" }, + quick_edit: { label: "Edici\xF3n R\xE1pida" }, + update_lead_status: { label: "Actualizar Estado del Lead" }, + tell_us_about_yourself: { label: "Cu\xE9ntanos sobre ti" }, + about_your_company: { label: "Sobre tu empresa" }, + how_can_we_help: { label: "\xBFC\xF3mo podemos ayudarte?" }, + lead_information: { label: "Informaci\xF3n del Lead" }, + address_information: { label: "Informaci\xF3n de Direcci\xF3n" }, + privacy_preferences: { label: "Preferencias de Privacidad" } + }, + _actions: { + ...activityActions4, + convert_lead: { + label: "Convertir Prospecto", + successMessage: "\xA1Prospecto convertido con \xE9xito!" + }, + create_campaign: { + label: "Agregar a Campa\xF1a", + successMessage: "\xA1Prospecto agregado a la campa\xF1a!", + params: { + crm_campaign: { label: "Campa\xF1a" } + } + }, + schedule_followup: { + label: "Programar Seguimiento", + successMessage: "Seguimiento programado." + } + } + }, + crm_opportunity: { + _validations: { + amount_positive: { + message: "El importe debe ser mayor que cero" + }, + close_date_future: { + message: "La fecha de cierre no deber\xEDa estar en el pasado salvo que la oportunidad est\xE9 cerrada" + }, + opportunity_stage_progression: { + message: "Transici\xF3n de etapa de oportunidad no v\xE1lida" + } + }, + label: "Oportunidad", + pluralLabel: "Oportunidades", + description: "Oportunidades de venta y negocios en el pipeline", + fields: { + name: { label: "Nombre de Oportunidad" }, + crm_account: { label: "Cuenta" }, + primary_contact: { label: "Contacto Principal" }, + owner_id: { label: "Propietario de Oportunidad" }, + amount: { label: "Monto" }, + expected_revenue: { label: "Ingreso Esperado" }, + stage: { + label: "Etapa", + options: { + prospecting: "Prospecci\xF3n", + qualification: "Calificaci\xF3n", + needs_analysis: "An\xE1lisis de Necesidades", + proposal: "Propuesta", + negotiation: "Negociaci\xF3n", + closed_won: "Cerrada Ganada", + closed_lost: "Cerrada Perdida" + } + }, + probability: { label: "Probabilidad (%)" }, + close_date: { label: "Fecha de Cierre" }, + type: { + label: "Tipo", + options: { + new_business: "Nuevo Negocio", + existing_upgrade: "Cliente Existente - Mejora", + existing_renewal: "Cliente Existente - Renovaci\xF3n", + existing_expansion: "Cliente Existente - Expansi\xF3n" + } + }, + forecast_category: { + label: "Categor\xEDa de Pron\xF3stico", + options: { + pipeline: "Pipeline", + best_case: "Mejor Caso", + commit: "Compromiso", + omitted: "Omitida", + closed: "Cerrada" + } + }, + description: { label: "Descripci\xF3n" }, + next_step: { label: "Pr\xF3ximo Paso" }, + lead_source: { + label: "Origen del Prospecto", + options: { + web: "Web", + referral: "Referencia", + event: "Evento / Feria", + webinar: "Seminario Web", + partner: "Socio", + advertisement: "Publicidad", + paid_search: "B\xFAsqueda de Pago", + social: "Redes Sociales", + content: "Contenido / Blog", + cold_call: "Llamada en Fr\xEDo", + email_campaign: "Campa\xF1a de Email", + other: "Otro" + } + }, + crm_campaign: { label: "Campa\xF1a", help: "Campa\xF1a de marketing que gener\xF3 esta oportunidad" }, + days_in_stage: { label: "D\xEDas en Etapa Actual" }, + stage_entry_date: { label: "Fecha de Entrada a la Etapa", help: "Fecha en la que esta oportunidad entr\xF3 en su etapa actual." }, + is_private: { label: "Privado" }, + approval_status: { + label: "Estado de Aprobaci\xF3n", + options: { + not_required: "No Requerida", + pending: "Pendiente", + approved: "Aprobada", + rejected: "Rechazada" + } + }, + approved_date: { label: "Fecha de Aprobaci\xF3n" }, + // #593 — obligatorias al cerrar la oportunidad, y el desglose de + // motivos de pérdida las muestra en el panel de ventas, así que el + // valor almacenado nunca debe llegar crudo al selector. + win_reason: { + label: "Motivo de Ganancia", + help: "Por qu\xE9 se gan\xF3 este negocio. Obligatorio para cerrar una oportunidad como Ganada.", + options: { + better_product: "Mejor Producto", + better_price: "Mejor Precio", + relationship: "Relaci\xF3n Existente", + better_support: "Mejor Soporte", + best_fit: "Mejor Ajuste / Funcionalidades", + quote_accepted: "Cotizaci\xF3n Aceptada", + other: "Otro" + } + }, + loss_reason: { + label: "Motivo de P\xE9rdida", + help: "Por qu\xE9 se perdi\xF3 este negocio. Obligatorio para cerrar una oportunidad como Perdida.", + options: { + price: "Precio Demasiado Alto", + competitor: "Perdida ante Competidor", + no_budget: "Sin Presupuesto", + no_decision: "Sin Decisi\xF3n", + timing: "Momento Inadecuado", + features: "Funcionalidades Faltantes", + other: "Otro" + } + }, + loss_details: { + label: "Detalles de Ganancia/P\xE9rdida", + help: "Contexto en texto libre detr\xE1s del motivo de ganancia o p\xE9rdida." + }, + // REQ-0006 — calificación, calendario de compra del cliente, narrativa + // del negocio, línea de negocio y aprobación del cambio de estado. + will_bid: { + label: "Presentaremos Oferta", + help: "Si tenemos intenci\xF3n de presentar oferta. Sin valor significa que la decisi\xF3n sigue abierta." + }, + controllability: { label: "Controlabilidad", options: { high: "Alta", medium: "Media", low: "Baja" } }, + priority: { label: "Prioridad", options: { high: "Alta", medium: "Media", low: "Baja" } }, + deal_level: { label: "Nivel del Negocio", options: { strategic: "Estrat\xE9gico", key: "Clave", standard: "Est\xE1ndar" } }, + is_subcontracted: { label: "Incluye Subcontrataci\xF3n" }, + subcontracting_note: { label: "Nota de Subcontrataci\xF3n" }, + customer_initiation_date: { label: "Fecha de Inicio del Proyecto (Cliente)" }, + expected_tender_date: { label: "Fecha Prevista de Licitaci\xF3n" }, + expected_signing_date: { label: "Fecha Prevista de Firma" }, + expected_tender_amount: { label: "Importe Previsto de Licitaci\xF3n" }, + expected_signing_amount: { label: "Importe Previsto de Firma" }, + business_line: { + label: "L\xEDnea de Negocio", + options: { + product: "Producto", + services: "Servicios Profesionales", + consulting: "Consultor\xEDa", + support: "Soporte y Mantenimiento", + other: "Otro" + } + }, + customer_background: { label: "Antecedentes del Cliente" }, + project_background: { label: "Antecedentes del Proyecto" }, + risk_analysis: { label: "An\xE1lisis de Riesgos" }, + payment_terms: { label: "Condiciones de Pago" }, + requested_status: { label: "Estado Solicitado", options: { closed_won: "Ganada", closed_lost: "Perdida" } }, + status_change_approval_status: { + label: "Aprobaci\xF3n del Cambio de Estado", + options: { + not_required: "No Requerida", + pending: "Pendiente", + approved: "Aprobada", + rejected: "Rechazada" + } + }, + // REQ-0006 paso 11 — la aprobación de calificación (立项). + qualification_requested: { + label: "Solicitar Aprobaci\xF3n de Calificaci\xF3n", + help: "M\xE1rquelo para enviar este negocio a aprobaci\xF3n de calificaci\xF3n. Un rechazo lo desmarca; vuelva a marcarlo para solicitarla de nuevo." + }, + qualification_approval_status: { + label: "Aprobaci\xF3n de Calificaci\xF3n", + options: { + not_required: "No Requerida", + pending: "Pendiente", + approved: "Aprobada", + rejected: "Rechazada" + } + } + }, + _views: { + tender_this_quarter: { + label: "Licitaciones de Este Trimestre", + emptyState: { + title: "No hay licitaciones previstas este trimestre", + message: "Esta pesta\xF1a muestra los negocios abiertos cuya fecha de licitaci\xF3n del cliente cae dentro del trimestre actual. Registra la Fecha Prevista de Licitaci\xF3n en un negocio para verlo aqu\xED." + } + }, + open_opportunities: { label: "Oportunidades Abiertas" }, + all_opportunities: { label: "Todas las Oportunidades" }, + pipeline_kanban: { label: "Pipeline de Ventas" }, + close_date_calendar: { label: "Calendario de Pron\xF3stico" }, + deal_timeline: { label: "L\xEDnea de Tiempo" }, + deal_gallery: { label: "Galer\xEDa de Negocios" }, + my_open_deals: { label: "Mis Negocios Abiertos" }, + closing_this_quarter: { + label: "Cierres de Este Trimestre", + emptyState: { + title: "No hay negocios que cierren este trimestre", + message: "Esta pesta\xF1a muestra los negocios abiertos en categor\xEDa Compromiso o Mejor Caso cuya fecha de cierre cae dentro del trimestre actual. Ahora mismo no hay ninguno; los negocios que cierran m\xE1s adelante est\xE1n en la pesta\xF1a Negocios Abiertos." + } + }, + stale_opportunities: { label: "\u26A0\uFE0F Oportunidades Estancadas \xB7 M\xE1s Tiempo en Etapa Primero" } + }, + _sections: { + // Claves de sección del objeto (opportunity.object.ts) que usan los + // formularios de registro y la página de detalle, cuyas secciones + // hacen referencia a estos grupos (#1452). + // + // `crm_forecast` es la clave del grupo de campos («Forecast & Metrics» + // en inglés). Esta traducción es anterior a #1452, cuando una sección + // de la página de detalle con el mismo nombre se titulaba «Stage & + // Forecast»; desde entonces solo la lee el grupo. + crm_forecast: { label: "Etapa y Previsi\xF3n" }, + basic: { label: "Informaci\xF3n B\xE1sica" }, + financials: { label: "Datos Financieros" }, + sales_process: { label: "Proceso de Venta" }, + classification: { label: "Clasificaci\xF3n" }, + campaign: { label: "Campa\xF1as" }, + notes: { label: "Notas y Pr\xF3ximos Pasos" }, + qualification: { label: "Calificaci\xF3n" }, + narrative: { label: "Narrativa del Negocio" }, + // Nombres de sección del formulario en opportunity.view.ts (#1100) + overview: { label: "Resumen" }, + forecast: { label: "Previsi\xF3n" }, + sales_strategy: { label: "Estrategia de Ventas" }, + win_loss: { label: "Ganada / Perdida" } + }, + _actions: { + ...activityActions4, + clone_opportunity: { + label: "Clonar Oportunidad", + successMessage: "\xA1Oportunidad clonada con \xE9xito!" + }, + mass_update_stage: { + label: "Actualizar Etapa", + successMessage: "\xA1Etapa de oportunidad actualizada!", + params: { + // Mismos valores que `fields.stage` — deben coincidir literalmente. + stage: { + label: "Nueva Etapa", + options: { + prospecting: "Prospecci\xF3n", + qualification: "Calificaci\xF3n", + needs_analysis: "An\xE1lisis de Necesidades", + proposal: "Propuesta", + negotiation: "Negociaci\xF3n", + closed_won: "Cerrada Ganada", + closed_lost: "Cerrada Perdida" + } + } + } + }, + generate_quote: { + label: "Generar Cotizaci\xF3n", + successMessage: "\xA1Cotizaci\xF3n creada desde la oportunidad!" + } + } + }, + crm_opportunity_line_item: { + _validations: { + unit_price_positive: { + message: "El precio de venta no puede ser negativo" + } + }, + label: "L\xEDnea de Oportunidad", + pluralLabel: "L\xEDneas de Oportunidad", + description: "L\xEDneas de precio por producto dentro de una oportunidad", + fields: { + crm_opportunity: { label: "Oportunidad" }, + crm_product: { label: "Producto" }, + description: { label: "Descripci\xF3n" }, + quantity: { label: "Cantidad" }, + list_price: { label: "Precio de Lista", help: "Se rellena autom\xE1ticamente desde el Precio de Lista del producto." }, + unit_price: { label: "Precio de Venta", help: "Precio unitario negociado (puede diferir del precio de lista)" }, + discount: { label: "Descuento (%)" }, + total_price: { label: "Total" }, + line_number: { label: "N\xBA de L\xEDnea" } + }, + _sections: { + basic: { label: "L\xEDnea" }, + pricing: { label: "Precios" } + } + }, + crm_forecast: { + _validations: { + period_end_after_start: { + message: "El fin del periodo debe ser posterior a su inicio." + }, + period_end_matches_calendar_period: { + message: "El fin del periodo debe ser el \xFAltimo d\xEDa del periodo: p. ej. 2026-09-30 para un trimestre que empieza el 2026-07-01, o 2026-08-31 para agosto de 2026." + }, + period_start_first_of_period: { + message: "El inicio del periodo debe ser el primer d\xEDa del periodo: p. ej. 2026-08-01 para agosto de 2026." + }, + quarter_starts_on_quarter_boundary: { + message: "Una previsi\xF3n trimestral debe comenzar en un l\xEDmite de trimestre: 1 de enero, 1 de abril, 1 de julio o 1 de octubre." + }, + snapshot_amounts_non_negative: { + message: "Los importes de la instant\xE1nea no pueden ser negativos." + } + }, + label: "Previsi\xF3n", + pluralLabel: "Previsiones", + description: "Instant\xE1nea peri\xF3dica del pipeline por propietario para previsi\xF3n de ingresos", + fields: { + owner_id: { label: "Propietario" }, + period: { label: "Periodo", options: { month: "Mes", quarter: "Trimestre" } }, + period_start: { + label: "Inicio del periodo", + help: "Debe ser el primer d\xEDa del periodo \u2014 p. ej. 2026-08-01 para agosto de 2026. Adem\xE1s, una previsi\xF3n trimestral debe comenzar en un l\xEDmite de trimestre: 1 de enero, 1 de abril, 1 de julio o 1 de octubre." + }, + period_end: { + label: "Fin del periodo", + help: "Normalmente se calcula autom\xE1ticamente a partir de Periodo e Inicio del periodo. Si se introduce a mano, debe ser el \xFAltimo d\xEDa de ese periodo \u2014 p. ej. 2026-09-30 para un trimestre que empieza el 2026-07-01, o 2026-08-31 para agosto de 2026." + }, + period_label: { label: "Periodo", help: "Etiqueta legible, p. ej. \xABT3 2026\xBB o \xABAgo 2026\xBB." }, + display_title: { label: "T\xEDtulo Mostrado" }, + snapshot_date: { label: "Fecha de instant\xE1nea", help: "El d\xEDa en que se captur\xF3 esta instant\xE1nea." }, + source: { + label: "Origen", + options: { scheduled: "Instant\xE1nea programada", ai: "Skill de IA", manual: "Entrada manual" } + }, + quota: { label: "Cuota" }, + pipeline_amount: { label: "Pipeline", help: "Suma de todas las oportunidades abiertas que cierran en este periodo (en cualquier etapa)." }, + best_case_amount: { label: "Mejor caso", help: "Oportunidades abiertas en la categor\xEDa de pron\xF3stico Mejor caso o Compromiso." }, + commit_amount: { label: "Compromiso", help: "Oportunidades abiertas en la categor\xEDa de pron\xF3stico Compromiso (comprometidas por el propietario)." }, + closed_amount: { label: "Cerrado", help: "Importe ya cerrado ganado en este periodo." }, + expected_amount: { label: "Esperado", help: "Cerrado + Compromiso: lo que el propietario espera razonablemente cerrar." }, + attainment_pct: { label: "Cumplimiento %", help: "Cerrado \xF7 Cuota \xD7 100. Muestra 0 % hasta que se fija una cuota positiva." }, + coverage_ratio: { label: "Cobertura", help: "Pipeline \xF7 (Cuota \u2212 Cerrado): si queda pipeline suficiente para cubrir la diferencia. Muestra 0 cuando ya se ha alcanzado la cuota." }, + notes: { label: "Notas" }, + seed_key: { + label: "Clave de semilla", + help: "Identidad del juego de datos de demostraci\xF3n. Solo la escribe el cargador de semillas; est\xE1 vac\xEDa en cualquier instant\xE1nea real." + } + }, + _views: { + all_forecasts: { label: "Todas las previsiones" }, + this_quarter_forecasts: { + label: "Este trimestre", + emptyState: { + title: "A\xFAn no hay instant\xE1neas de este trimestre", + message: "Las instant\xE1neas trimestrales las escribe el barrido nocturno de previsiones. Hasta que se ejecute una vez para el trimestre actual, esta vista est\xE1 vac\xEDa; los trimestres cerrados est\xE1n en la pesta\xF1a Todas." + } + }, + my_forecast: { label: "Mi previsi\xF3n" } + }, + _sections: { + basic: { label: "Instant\xE1nea" }, + amounts: { label: "Importes" }, + meta: { label: "Origen" }, + // Nombres de sección del formulario en forecast.view.ts (#1100) + snapshot: { label: "Instant\xE1nea" }, + notes: { label: "Notas" } + } + } +}; + +// src/sales/translations/es-ES/objects.commerce.ts +var commerce4 = { + crm_quote: { + _validations: { + discount_within_ceiling: { + message: "El descuento no puede superar el 60 %" + }, + expiration_after_quote: { + message: "La fecha de vencimiento debe ser posterior a la de la cotizaci\xF3n" + }, + quote_status_progression: { + message: "Transici\xF3n de estado de cotizaci\xF3n no v\xE1lida" + } + }, + label: "Cotizaci\xF3n", + pluralLabel: "Cotizaciones", + description: "Cotizaciones de precios para clientes", + fields: { + quote_number: { label: "N\xFAmero de Cotizaci\xF3n" }, + display_title: { label: "T\xEDtulo Mostrado" }, + name: { label: "Nombre de Cotizaci\xF3n" }, + crm_account: { label: "Cuenta" }, + crm_contact: { + label: "Contacto", + help: "Obligatorio en cuanto la cotizaci\xF3n pasa a Presentada o Aceptada: el contrato generado toma de aqu\xED su Contacto principal." + }, + crm_opportunity: { label: "Oportunidad" }, + owner_id: { label: "Propietario de Cotizaci\xF3n" }, + status: { + label: "Estado", + options: { + draft: "Borrador", + in_review: "En Revisi\xF3n", + presented: "Presentada", + accepted: "Aceptada", + rejected: "Rechazada", + expired: "Expirada" + } + }, + quote_date: { label: "Fecha de Cotizaci\xF3n" }, + expiration_date: { label: "Fecha de Expiraci\xF3n" }, + subtotal: { label: "Subtotal" }, + discount: { label: "Descuento %" }, + discount_amount: { label: "Monto de Descuento" }, + tax: { label: "Impuesto" }, + shipping_handling: { label: "Env\xEDo y Manipulaci\xF3n" }, + total_price: { label: "Precio Total" }, + // Mismo juego de valores que `crm_contract.payment_terms` — tradúzcanse igual. + payment_terms: { + label: "T\xE9rminos de Pago", + options: { + net_15: "Neto 15", + net_30: "Neto 30", + net_60: "Neto 60", + net_90: "Neto 90", + due_on_receipt: "Pago a la Recepci\xF3n" + } + }, + shipping_terms: { label: "T\xE9rminos de Env\xEDo" }, + billing_address: { label: "Direcci\xF3n de Facturaci\xF3n" }, + shipping_address: { label: "Direcci\xF3n de Env\xEDo" }, + description: { label: "Descripci\xF3n" }, + internal_notes: { label: "Notas Internas" } + }, + _views: { + all_quotes: { label: "Todas las Cotizaciones" }, + quote_pipeline: { label: "Pipeline de Cotizaciones" }, + quote_calendar: { label: "Calendario de Cotizaciones" } + }, + _sections: { + basic: { label: "Informaci\xF3n de la Cotizaci\xF3n" }, + pricing: { label: "Precios" }, + terms: { label: "T\xE9rminos y Vigencia" }, + address: { label: "Direcciones" }, + system: { label: "Sistema" }, + // Nombres de sección del formulario en quote.view.ts (#1100) + quote: { label: "Cotizaci\xF3n" }, + totals: { label: "Totales" }, + quote_terms: { label: "T\xE9rminos" }, + addresses_and_notes: { label: "Direcciones y Notas" } + } + }, + crm_quote_line_item: { + _validations: { + discount_within_ceiling: { + message: "El descuento de l\xEDnea no puede superar el 60 %" + }, + unit_price_positive: { + message: "El precio de venta no puede ser negativo" + } + }, + label: "L\xEDnea de Cotizaci\xF3n", + pluralLabel: "L\xEDneas de Cotizaci\xF3n", + description: "L\xEDneas de precio por producto dentro de una cotizaci\xF3n", + fields: { + crm_quote: { label: "Cotizaci\xF3n" }, + crm_product: { label: "Producto" }, + description: { label: "Descripci\xF3n" }, + quantity: { label: "Cantidad" }, + list_price: { label: "Precio de Lista" }, + unit_price: { label: "Precio de Venta" }, + discount: { label: "Descuento (%)" }, + subtotal: { label: "Subtotal" }, + total_price: { label: "Total" }, + line_number: { label: "N\xBA de L\xEDnea" } + }, + _sections: { + basic: { label: "L\xEDnea" }, + pricing: { label: "Precios" } + } + }, + crm_contract: { + _validations: { + end_after_start: { + message: "La fecha de fin debe ser posterior a la de inicio" + }, + contract_status_progression: { + message: "Transici\xF3n de estado de contrato no v\xE1lida" + } + }, + label: "Contrato", + pluralLabel: "Contratos", + description: "Contratos y acuerdos legales", + fields: { + contract_number: { label: "N\xFAmero de Contrato" }, + crm_account: { label: "Cuenta" }, + crm_contact: { label: "Contacto Principal" }, + crm_opportunity: { label: "Oportunidad Relacionada" }, + owner_id: { label: "Propietario del Contrato" }, + status: { + label: "Estado", + options: { + draft: "Borrador", + in_approval: "En Aprobaci\xF3n", + activated: "Activado", + expired: "Expirado", + terminated: "Rescindido" + } + }, + contract_term_months: { label: "Plazo del Contrato (Meses)" }, + start_date: { label: "Fecha de Inicio" }, + end_date: { label: "Fecha de Fin" }, + contract_value: { label: "Valor del Contrato" }, + billing_frequency: { + label: "Frecuencia de Facturaci\xF3n", + options: { monthly: "Mensual", quarterly: "Trimestral", annually: "Anual", one_time: "Pago \xDAnico" } + }, + // Mismo juego de valores que `crm_quote.payment_terms` — tradúzcanse igual. + payment_terms: { + label: "T\xE9rminos de Pago", + options: { + net_15: "Neto 15", + net_30: "Neto 30", + net_60: "Neto 60", + net_90: "Neto 90", + due_on_receipt: "Pago a la Recepci\xF3n" + } + }, + auto_renewal: { label: "Renovaci\xF3n Autom\xE1tica" }, + renewal_notice_days: { label: "Aviso de Renovaci\xF3n (D\xEDas)" }, + contract_type: { + label: "Tipo de Contrato", + options: { + subscription: "Suscripci\xF3n", + service: "Acuerdo de Servicio", + license: "Licencia", + partnership: "Asociaci\xF3n", + nda: "Acuerdo de Confidencialidad (NDA)", + msa: "Acuerdo Marco de Servicios (MSA)" + } + }, + signed_date: { label: "Fecha de Firma" }, + signed_by: { label: "Firmado Por" }, + document_url: { label: "Documento de Contrato" }, + special_terms: { label: "T\xE9rminos Especiales" }, + description: { label: "Descripci\xF3n" }, + billing_address: { label: "Direcci\xF3n de Facturaci\xF3n" } + }, + _views: { + all_contracts: { label: "Todos los Contratos" }, + renewal_calendar: { label: "Calendario de Renovaci\xF3n" }, + contract_gantt: { label: "Plazos del Contrato" }, + contract_timeline: { label: "L\xEDnea de Tiempo" } + }, + _sections: { + basic: { label: "Informaci\xF3n del Contrato" }, + parties: { label: "Partes" }, + terms: { label: "T\xE9rminos y Fechas" }, + value: { label: "Valor del Contrato" }, + status: { label: "Estado y Aprobaci\xF3n" }, + renewal: { label: "Renovaci\xF3n" }, + // Nombres de sección del formulario en contract.view.ts (#1100) + contract_terms: { label: "T\xE9rminos" }, + signing_and_documents: { label: "Firma y Documentos" }, + notes: { label: "Notas" } + } + }, + crm_product: { + _validations: { + cost_less_than_price: { + message: "El coste deber\xEDa ser inferior al precio de lista" + }, + price_positive: { + message: "El precio de lista debe ser positivo" + } + }, + label: "Producto", + pluralLabel: "Productos", + description: "Productos y servicios que ofrece la empresa", + fields: { + product_code: { label: "C\xF3digo de Producto" }, + display_title: { label: "T\xEDtulo Mostrado" }, + name: { label: "Nombre de Producto" }, + description: { label: "Descripci\xF3n" }, + category: { + label: "Categor\xEDa", + options: { + software: "Software", + hardware: "Hardware", + service: "Servicio", + subscription: "Suscripci\xF3n", + support: "Soporte" + } + }, + family: { + label: "Familia de Producto", + options: { + enterprise: "Soluciones para Gran Empresa", + smb: "Soluciones para PYMEs", + services: "Servicios Profesionales", + cloud: "Servicios en la Nube" + } + }, + list_price: { label: "Precio de Lista" }, + cost: { label: "Costo" }, + sku: { label: "SKU" }, + is_active: { label: "Activo" }, + product_manager: { label: "Gerente de Producto" }, + image: { label: "Imagen de Producto" }, + datasheet: { label: "Ficha T\xE9cnica" } + }, + _views: { + all_products: { label: "Todos los Productos" }, + product_catalog: { label: "Cat\xE1logo de Productos" } + }, + _sections: { + basic: { label: "Informaci\xF3n del Producto" }, + pricing: { label: "Precios" }, + metadata: { label: "Recursos" }, + // Nombres de sección del formulario en product.view.ts (#1100) + product_info: { label: "Informaci\xF3n del Producto" }, + pricing_info: { label: "Precios" }, + media: { label: "Multimedia" } + } + } +}; + +// src/sales/translations/es-ES/objects.service.ts +var service4 = { + crm_case: { + _validations: { + resolution_required_for_closed: { + message: "La resoluci\xF3n es obligatoria al cerrar un caso" + }, + escalation_reason_required: { + message: "El motivo de escalado es obligatorio al escalar un caso" + }, + case_status_progression: { + message: "Transici\xF3n de estado no v\xE1lida" + } + }, + label: "Caso", + pluralLabel: "Casos", + description: "Casos de soporte y solicitudes de servicio de clientes", + fields: { + case_number: { label: "N\xFAmero de Caso" }, + display_title: { label: "T\xEDtulo Mostrado" }, + subject: { label: "Asunto" }, + description: { label: "Descripci\xF3n" }, + crm_account: { label: "Cuenta" }, + crm_contact: { label: "Contacto" }, + status: { + label: "Estado", + options: { + new: "Nuevo", + in_progress: "En Curso", + waiting_customer: "Esperando al Cliente", + waiting_support: "Esperando a Soporte", + escalated: "Escalado", + resolved: "Resuelto", + closed: "Cerrado" + } + }, + priority: { + label: "Prioridad", + options: { low: "Baja", medium: "Media", high: "Alta", critical: "Cr\xEDtica" } + }, + priority_rank: { label: "Rango de Prioridad" }, + type: { + label: "Tipo de Caso", + options: { + question: "Consulta", + problem: "Problema", + feature_request: "Solicitud de Funcionalidad", + bug: "Error" + } + }, + // `email` y `chat` se dejan como préstamos: son el término habitual en + // español de negocios y concuerdan con `crm_campaign.channel`. + origin: { + label: "Origen del Caso", + options: { email: "Email", phone: "Tel\xE9fono", web: "Web", chat: "Chat", social_media: "Redes Sociales" } + }, + owner_id: { label: "Propietario del Caso" }, + closed_date: { label: "Fecha de Cierre" }, + first_response_date: { label: "Fecha de Primera Respuesta" }, + resolution_time_hours: { label: "Tiempo de Resoluci\xF3n (Horas)" }, + sla_due_date: { label: "Fecha L\xEDmite SLA", help: "Se fija seg\xFAn la prioridad del caso y el Nivel de Cliente de la cuenta, en horas naturales: las noches, los fines de semana y los festivos cuentan." }, + is_sla_violated: { label: "SLA Incumplido" }, + is_escalated: { label: "Escalado" }, + escalated_date: { label: "Fecha de Escalaci\xF3n" }, + escalation_reason: { label: "Motivo de Escalaci\xF3n" }, + resolution: { label: "Resoluci\xF3n" }, + resolved_by_article: { label: "Resuelto por Art\xEDculo", help: "Art\xEDculo de la base de conocimiento que resolvi\xF3 este caso \u2014 la se\xF1al de desv\xEDo." }, + internal_notes: { label: "Notas Internas", help: "Notas internas no visibles para el cliente" }, + is_closed: { label: "Est\xE1 Cerrado" } + }, + _views: { + all_cases: { label: "Todos los Casos" }, + case_workflow: { label: "Flujo de Servicio" }, + sla_calendar: { label: "Calendario SLA" }, + case_timeline: { label: "L\xEDnea de Tiempo de Casos" }, + unassigned_triage: { + label: "Sin asignar \u2014 triaje", + emptyState: { + title: "Nada pendiente de triaje", + message: "Todos los casos tienen propietario. Los casos aparecen aqu\xED cuando llegan sin propietario \u2014 normalmente un env\xEDo web-a-caso recibido mientras nadie ocupaba el puesto de Agente de Servicio." + } + }, + escalated_cases: { label: "Casos Escalados" }, + my_open_cases: { label: "Mis Casos Abiertos" }, + sla_at_risk: { label: "\u23F0 SLA en Riesgo" } + }, + _sections: { + // Nombres de sección del formulario en case.view.ts (#1100). + case: { label: "Caso" }, + how_can_we_help: { label: "\xBFC\xF3mo podemos ayudarte?" }, + // Claves de sección del objeto (case.object.ts) que usan los + // formularios de registro y la página de detalle, cuyas secciones + // hacen referencia a estos grupos (#970). + basic: { label: "Informaci\xF3n del Caso" }, + origin: { label: "Origen y Asignaci\xF3n" }, + sla: { label: "SLA y Prioridad" }, + resolution: { label: "Resoluci\xF3n" }, + escalation: { label: "Escalaci\xF3n" }, + system: { label: "Sistema" } + }, + _actions: { + ...activityActions4, + escalate_case: { + label: "Escalar Caso", + confirmText: "Esto enviar\xE1 el caso al equipo de escalaci\xF3n. \xBFContinuar?", + successMessage: "\xA1Caso escalado con \xE9xito!" + }, + close_case: { + label: "Cerrar Caso", + confirmText: "\xBFEst\xE1 seguro de querer cerrar este caso?", + successMessage: "\xA1Caso cerrado con \xE9xito!" + }, + claim_case: { + label: "Tomar Caso", + successMessage: "Caso tomado: ahora es suyo." + } + } + }, + crm_knowledge_article: { + _validations: { + published_requires_body: { + message: "No se pueden publicar art\xEDculos sin cuerpo." + }, + published_requires_summary: { + message: "Los art\xEDculos publicados deben tener un resumen para los resultados de b\xFAsqueda y las citas de IA." + } + }, + label: "Art\xEDculo de Conocimiento", + pluralLabel: "Base de Conocimiento", + description: "Respuestas y gu\xEDas reutilizables para clientes y agentes", + fields: { + article_number: { label: "N.\xBA Art\xEDculo" }, + display_title: { label: "T\xEDtulo Mostrado" }, + title: { label: "T\xEDtulo" }, + summary: { label: "Resumen", help: "Resumen de un p\xE1rrafo que se muestra en los resultados de b\xFAsqueda y en las citas de la IA." }, + body: { label: "Contenido", help: "Contenido completo del art\xEDculo (Markdown)." }, + category: { + label: "Categor\xEDa", + options: { + getting_started: "Primeros pasos", + how_to: "C\xF3mo hacerlo", + troubleshooting: "Resoluci\xF3n de problemas", + billing: "Facturaci\xF3n", + api: "API e Integraciones", + release_notes: "Notas de versi\xF3n", + policy: "Pol\xEDticas" + } + }, + tags: { + label: "Etiquetas", + options: { + auth: "Autenticaci\xF3n", + sso: "SSO", + mobile: "M\xF3vil", + email: "Correo", + reports: "Informes", + performance: "Rendimiento", + data_import: "Importaci\xF3n de datos", + webhooks: "Webhooks" + } + }, + status: { + label: "Estado", + options: { draft: "Borrador", in_review: "En revisi\xF3n", published: "Publicado", archived: "Archivado" } + }, + audience: { + label: "Audiencia", + help: "Los art\xEDculos p\xFAblicos son visibles en el portal de clientes; los internos solo los ven los agentes.", + options: { public: "P\xFAblico", internal: "Interno" } + }, + language: { + label: "Idioma", + options: { en: "Ingl\xE9s", zh_cn: "Chino simplificado", es_es: "Espa\xF1ol", ja_jp: "Japon\xE9s" } + }, + owner_id: { label: "Propietario" }, + related_to_case: { label: "Caso de origen", help: "Caso a partir del cual se redact\xF3 este art\xEDculo (opcional)." }, + published_at: { label: "Publicado el" }, + last_reviewed_at: { label: "\xDAltima revisi\xF3n" }, + helpful_count: { label: "\xDAtil", help: "Recontado desde crm_article_feedback \u2014 nunca se escribe a mano." }, + not_helpful_count: { label: "No \xFAtil", help: "Recontado desde crm_article_feedback \u2014 nunca se escribe a mano." } + }, + _views: { + all_articles: { label: "Todos los art\xEDculos" }, + published_articles: { label: "Publicados" }, + my_drafts: { label: "Mis borradores" } + }, + _sections: { + basic: { label: "Informaci\xF3n del Art\xEDculo" }, + content: { label: "Contenido" }, + taxonomy: { label: "Categorizaci\xF3n" }, + metrics: { label: "Interacci\xF3n" }, + engagement: { label: "Interacci\xF3n" }, + // Nombre de sección del formulario en knowledge_article.view.ts (#1100) + article: { label: "Art\xEDculo" } + }, + _actions: { + mark_article_helpful: { + label: "\xDAtil", + successMessage: "Gracias \u2014 registrado como \xFAtil." + }, + mark_article_not_helpful: { + label: "No \xFAtil", + successMessage: "Gracias \u2014 registrado como no \xFAtil." + } + } + }, + crm_article_feedback: { + label: "Opini\xF3n sobre el Art\xEDculo", + pluralLabel: "Opiniones sobre Art\xEDculos", + description: "El veredicto \xFAtil / no \xFAtil de un lector sobre un art\xEDculo de la base de conocimiento", + fields: { + feedback_number: { label: "N.\xBA de Opini\xF3n" }, + owner_id: { label: "Lector" }, + crm_knowledge_article: { label: "Art\xEDculo", help: "Art\xEDculo de la base de conocimiento al que se refiere esta opini\xF3n." }, + verdict: { + label: "Veredicto", + options: { helpful: "\xDAtil", not_helpful: "No \xFAtil" } + }, + comment: { label: "Comentario", help: "Nota opcional que explica el veredicto \u2014 la lee el autor del art\xEDculo." } + }, + _sections: { + basic: { label: "Opini\xF3n" } + } + } +}; + +// src/sales/translations/es-ES/objects.activity.ts +var activity4 = { + crm_task: { + _validations: { + completed_date_required: { + message: "La fecha de finalizaci\xF3n es obligatoria cuando el estado es Completada" + }, + recurrence_fields_required: { + message: "El tipo de recurrencia es obligatorio para las tareas recurrentes" + }, + related_to_required: { + message: "Debe seleccionarse al menos un registro relacionado" + } + }, + label: "Tarea", + pluralLabel: "Tareas", + description: "Actividades y tareas pendientes", + fields: { + subject: { label: "Asunto" }, + description: { label: "Descripci\xF3n" }, + status: { + label: "Estado", + options: { + not_started: "No Iniciada", + in_progress: "En Curso", + waiting: "En Espera", + completed: "Completada", + deferred: "Aplazada" + } + }, + priority: { + label: "Prioridad", + options: { low: "Baja", normal: "Normal", high: "Alta", urgent: "Urgente" } + }, + priority_rank: { label: "Rango de Prioridad" }, + type: { + label: "Tipo de Tarea", + options: { + call: "Llamada", + email: "Email", + meeting: "Reuni\xF3n", + follow_up: "Seguimiento", + demo: "Demostraci\xF3n", + other: "Otro" + } + }, + due_date: { label: "Fecha L\xEDmite" }, + reminder_date: { label: "Fecha/Hora de Recordatorio" }, + reminder_sent: { label: "Recordatorio Enviado" }, + completed_date: { label: "Fecha de Finalizaci\xF3n" }, + owner_id: { label: "Asignado A" }, + // Los valores son nombres de objeto: se reutilizan las etiquetas ya + // traducidas de cada objeto en este mismo paquete (igual que + // `crm_event.related_to_type`). + related_to_type: { + label: "Tipo de Objeto Relacionado", + options: { + crm_account: "Cuenta", + crm_contact: "Contacto", + crm_opportunity: "Oportunidad", + crm_lead: "Prospecto", + crm_case: "Caso" + } + }, + related_to_account: { label: "Cuenta Relacionada" }, + related_to_contact: { label: "Contacto Relacionado" }, + related_to_opportunity: { label: "Oportunidad Relacionada" }, + related_to_lead: { label: "Prospecto Relacionado" }, + related_to_case: { label: "Caso Relacionado" }, + is_recurring: { label: "Tarea Recurrente" }, + recurrence_type: { + label: "Tipo de Recurrencia", + options: { daily: "Diaria", weekly: "Semanal", monthly: "Mensual", yearly: "Anual" } + }, + recurrence_interval: { label: "Intervalo de Recurrencia" }, + recurrence_end_date: { label: "Fecha Fin de Recurrencia" }, + is_completed: { label: "Est\xE1 Completado" }, + is_overdue: { label: "Est\xE1 Vencido" }, + progress_percent: { label: "Progreso (%)" } + }, + _views: { + all_tasks: { label: "Todas las Tareas" }, + task_board: { label: "Tablero de Tareas" }, + task_calendar: { label: "Calendario de Tareas" }, + task_gantt: { label: "Plan de Ejecuci\xF3n" }, + task_timeline: { label: "L\xEDnea de Tiempo" }, + my_open_tasks: { label: "Mis Tareas Abiertas" }, + todays_tasks: { label: "\u{1F4C5} Mis Tareas Prioritarias" }, + overdue_tasks: { label: "\u23F0 Tareas Abiertas \xB7 M\xE1s Vencidas Primero" } + }, + _sections: { + basic: { label: "Informaci\xF3n de la Tarea" }, + scheduling: { label: "Programaci\xF3n" }, + related: { label: "Registros Relacionados" }, + recurrence: { label: "Recurrencia" }, + effort: { label: "Progreso y Esfuerzo" }, + system: { label: "Sistema" }, + // Nombres de sección del formulario en task.view.ts (#1100) + task: { label: "Tarea" }, + related_records: { label: "Registros Relacionados" }, + recurrence_and_effort: { label: "Recurrencia y Esfuerzo" } + } + }, + crm_event: { + _validations: { + end_after_start: { + message: "La hora de fin debe ser posterior a la de inicio" + }, + related_to_required: { + message: "Debe seleccionarse al menos un registro relacionado" + } + }, + label: "Evento", + pluralLabel: "Eventos", + description: "Reuniones, llamadas y otras interacciones programadas con clientes", + fields: { + subject: { label: "Asunto" }, + description: { label: "Descripci\xF3n" }, + type: { + label: "Tipo de evento", + options: { + meeting: "Reuni\xF3n", + call: "Llamada", + demo: "Demostraci\xF3n", + webinar: "Seminario web", + onsite_visit: "Visita presencial", + other: "Otro" + } + }, + status: { + label: "Estado", + options: { + planned: "Planificado", + held: "Realizado", + cancelled: "Cancelado", + no_show: "No asisti\xF3" + } + }, + owner_id: { label: "Asignado a" }, + start_datetime: { label: "Inicio" }, + end_datetime: { label: "Fin" }, + all_day: { label: "Evento de todo el d\xEDa" }, + duration_minutes: { label: "Duraci\xF3n (minutos)" }, + location: { label: "Ubicaci\xF3n", help: "Sala, direcci\xF3n o enlace de la reuni\xF3n" }, + related_to_type: { + label: "Tipo de registro relacionado", + options: { + crm_account: "Cuenta", + crm_contact: "Contacto", + crm_opportunity: "Oportunidad", + crm_lead: "Prospecto", + crm_case: "Caso" + } + }, + related_to_account: { label: "Cuenta relacionada" }, + related_to_contact: { label: "Contacto relacionado" }, + related_to_opportunity: { label: "Oportunidad relacionada" }, + related_to_lead: { label: "Prospecto relacionado" }, + related_to_case: { label: "Caso relacionado" }, + outcome_notes: { label: "Notas de resultado", help: "Qu\xE9 se acord\xF3 y qu\xE9 sigue" } + }, + _views: { + all_events: { label: "Todos los eventos" }, + event_calendar: { label: "Calendario de eventos" }, + event_timeline: { label: "Agenda del equipo" }, + my_events: { label: "Mi calendario" }, + upcoming_events: { label: "\u{1F4C5} Pr\xF3ximos \xB7 M\xE1s cercanos primero" }, + held_events: { label: "\u2705 Historial de interacciones" } + }, + _sections: { + basic: { label: "Informaci\xF3n del Evento" }, + schedule: { label: "Programaci\xF3n" }, + related: { label: "Registros Relacionados" }, + outcome: { label: "Resultado" }, + // Nombres de sección del formulario en event.view.ts (#1100) + event: { label: "Evento" }, + related_records: { label: "Registros Relacionados" } + } + }, + crm_event_attendee: { + _validations: { + attendee_resolves: { + message: "Un asistente debe indicar la parte que nombra su tipo: el tipo Contacto requiere un contacto y el tipo Externo requiere un nombre de asistente externo" + }, + attendee_type_exclusive: { + message: "Un asistente nombra exactamente una parte: borre las columnas que su tipo de asistente no nombra" + } + }, + label: "Asistente al evento", + pluralLabel: "Asistentes al evento", + description: "Persona invitada o presente en un evento", + fields: { + attendee_number: { label: "N\xFAmero de asistente" }, + crm_event: { label: "Evento" }, + attendee_type: { + label: "Tipo de asistente", + options: { contact: "Contacto", lead: "Prospecto", user: "Usuario", external: "Externo" } + }, + crm_contact: { label: "Contacto", help: "Se rellena cuando el asistente es un contacto de cliente ya existente" }, + crm_lead: { label: "Prospecto", help: "Se rellena cuando el asistente sigue siendo un prospecto sin convertir" }, + sys_user: { label: "Usuario", help: "Se rellena cuando el asistente es un compa\xF1ero de la empresa" }, + external_name: { label: "Asistente externo", help: "Nombre de un asistente que no est\xE1 en ning\xFAn objeto del CRM: se rellena cuando el tipo de asistente es Externo" }, + response: { + label: "Respuesta", + options: { + no_response: "Sin respuesta", + accepted: "Aceptado", + declined: "Rechazado", + tentative: "Tentativo" + } + }, + is_organizer: { label: "Organizador" }, + invited_date: { label: "Invitado el" } + }, + _views: { + all_event_attendees: { label: "Asistentes al evento" } + }, + _sections: { + // El inglés es «Attendee» / «Invitation», no el par + // «Basic Information» / «Response Tracking» de crm_campaign_member. + basic: { label: "Asistente" }, + response: { label: "Invitaci\xF3n" }, + // Nombres de sección del formulario en event_attendee.view.ts (#1100) + attendee: { label: "Asistente" }, + invitation: { label: "Invitaci\xF3n" } + } + } +}; + +// src/sales/translations/es-ES/objects.marketing.ts +var marketing4 = { + crm_campaign: { + _validations: { + end_after_start: { + message: "La fecha de fin debe ser posterior a la de inicio" + }, + actual_cost_within_budget: { + message: "El coste real supera el coste presupuestado" + } + }, + label: "Campa\xF1a", + pluralLabel: "Campa\xF1as", + description: "Campa\xF1as e iniciativas de marketing", + fields: { + campaign_code: { label: "C\xF3digo de Campa\xF1a" }, + display_title: { label: "T\xEDtulo Mostrado" }, + name: { label: "Nombre de Campa\xF1a" }, + description: { label: "Descripci\xF3n" }, + type: { + label: "Tipo de Campa\xF1a", + options: { + email: "Email", + webinar: "Seminario Web", + trade_show: "Feria Comercial", + conference: "Conferencia", + direct_mail: "Correo Postal", + social_media: "Redes Sociales", + content: "Marketing de Contenidos", + partner: "Marketing con Socios" + } + }, + channel: { + label: "Canal Principal", + options: { + digital: "Digital", + social: "Redes Sociales", + email: "Email", + events: "Eventos", + partner: "Socios" + } + }, + status: { + label: "Estado", + options: { + planning: "Planificaci\xF3n", + in_progress: "En Curso", + completed: "Completada", + aborted: "Cancelada" + } + }, + start_date: { label: "Fecha de Inicio" }, + end_date: { label: "Fecha de Fin" }, + budgeted_cost: { label: "Costo Presupuestado" }, + actual_cost: { label: "Costo Real" }, + expected_revenue: { label: "Ingresos Previstos" }, + actual_revenue: { label: "Ingresos Reales" }, + target_size: { label: "Tama\xF1o Objetivo", help: "N\xFAmero objetivo de prospectos/contactos" }, + num_sent: { label: "Cantidad Enviada" }, + num_responses: { label: "N\xFAmero de Respuestas" }, + num_leads: { label: "N\xFAmero de Prospectos" }, + num_converted_leads: { label: "Prospectos Convertidos" }, + num_opportunities: { label: "Oportunidades Creadas" }, + num_won_opportunities: { label: "Oportunidades Ganadas" }, + response_rate: { label: "Tasa de Respuesta %" }, + roi: { label: "ROI %" }, + owner_id: { label: "Propietario de Campa\xF1a" }, + landing_page_url: { label: "P\xE1gina de Aterrizaje" }, + is_active: { label: "Activo" } + }, + _views: { + all_campaigns: { label: "Todas las Campa\xF1as" }, + campaign_gantt: { label: "Programaci\xF3n de Campa\xF1as" }, + campaign_calendar: { label: "Calendario de Campa\xF1as" }, + campaign_timeline: { label: "L\xEDnea de Tiempo de Marketing" } + }, + _sections: { + basic: { label: "Informaci\xF3n de Campa\xF1a" }, + schedule: { label: "Programaci\xF3n" }, + budget: { label: "Presupuesto y ROI" }, + metrics: { label: "Rendimiento" }, + // El inglés de este grupo es «Ownership», no «Assignment»: agrupa al + // propietario de la campaña, igual que `crm_account.ownership`. + assignment: { label: "Propiedad" }, + assets: { label: "Recursos de Campa\xF1a" } + }, + _actions: { + enroll_leads: { + label: "Inscribir Miembros", + successMessage: "Miembros elegibles inscritos en la campa\xF1a." + } + } + }, + crm_campaign_member: { + _validations: { + lead_or_contact_required: { + message: "Un miembro de campa\xF1a debe referenciar un prospecto o un contacto" + } + }, + label: "Miembro de Campa\xF1a", + pluralLabel: "Miembros de Campa\xF1a", + description: "Prospectos y contactos alcanzados por una campa\xF1a, con su estado de respuesta", + fields: { + member_number: { label: "N\xFAmero de Miembro" }, + crm_campaign: { label: "Campa\xF1a" }, + crm_lead: { label: "Prospecto", help: "Se rellena cuando el miembro era un Prospecto en el momento de la inscripci\xF3n" }, + crm_contact: { label: "Contacto", help: "Se rellena cuando el miembro es un Contacto existente" }, + status: { + label: "Estado", + options: { + sent: "Enviado", + responded: "Respondido", + converted: "Convertido", + unsubscribed: "Dado de Baja" + } + }, + added_date: { label: "Fecha de Alta" }, + response_date: { label: "Fecha de Respuesta" }, + has_responded: { label: "Ha Respondido" } + }, + _sections: { + basic: { label: "Informaci\xF3n B\xE1sica" }, + response: { label: "Seguimiento de Respuesta" } + }, + _actions: { + mark_responded: { + label: "Marcar como Respondido", + successMessage: "Respuesta registrada en este miembro de campa\xF1a." + } + } + } +}; + +// src/sales/translations/es-ES.ts +var esES2 = { + objects: { + crm_account: customer4.crm_account, + crm_contact: customer4.crm_contact, + crm_knowledge_article: service4.crm_knowledge_article, + crm_forecast: pipeline4.crm_forecast, + crm_lead: pipeline4.crm_lead, + crm_opportunity: pipeline4.crm_opportunity, + crm_case: service4.crm_case, + crm_contract: commerce4.crm_contract, + crm_product: commerce4.crm_product, + crm_quote: commerce4.crm_quote, + crm_task: activity4.crm_task, + crm_campaign: marketing4.crm_campaign, + crm_event: activity4.crm_event, + crm_event_attendee: activity4.crm_event_attendee, + crm_article_feedback: service4.crm_article_feedback, + crm_campaign_member: marketing4.crm_campaign_member, + crm_opportunity_line_item: pipeline4.crm_opportunity_line_item, + crm_quote_line_item: commerce4.crm_quote_line_item + }, + ...appSurface4 +}; + +// src/sales/translations/crm.translation.ts +var CrmTranslations = { + en: en2, + "zh-CN": zhCN2, + "ja-JP": jaJP2, + "es-ES": esES2 +}; + +// src/sales/views/index.ts +var views_exports = {}; +__export(views_exports, { + AccountViews: () => AccountViews, + ContactViews: () => ContactViews, + EventAttendeeViews: () => EventAttendeeViews, + EventViews: () => EventViews, + ForecastViews: () => ForecastViews, + LeadViews: () => LeadViews, + OpportunityViews: () => OpportunityViews, + TaskViews: () => TaskViews +}); + +// src/sales/views/lead.view.ts +import { P as P24 } from "@objectstack/spec"; +import { defineView as defineView3 } from "@objectstack/spec/ui"; +var DUPLICATE_LINK_FIELDS = [ + { + field: "duplicate_of_type", + required: true, + // The picker offers the AUTHORABLE half of the vocabulary only (#1164). + // `crm_lead.duplicate_of_type` also accepts `erased`, a tombstone + // `lead_duplicate_check` stamps when the engine's reference cleanup nulls + // the pointer — "confirmed duplicate of a record that has since been + // erased". Nobody authors that: it is an observation about a deletion that + // already happened, and offering it would let a reviewer close a lead as a + // duplicate of nothing while satisfying every rule that exists to stop + // exactly that. Narrowing here rather than deleting the value is the point + // — the record can still SAY it, and the field keeps its label in all four + // locales, so a tombstoned lead reads as "Erased Record" on the detail page + // instead of as a raw enum nobody can explain. + // + // Spread from `_picklists.ts` rather than retyped: the authorable set is + // the source both lists derive from, so a future object type added there + // reaches this picker automatically and the tombstone never can. + options: [...DUPLICATE_OF_TYPE_AUTHORABLE_OPTIONS], + visibleOn: P24`has(record.disqualification_reason) && record.disqualification_reason == "duplicate"` + }, + { + field: "duplicate_of_lead", + required: true, + visibleOn: P24`has(record.duplicate_of_type) && record.duplicate_of_type == "crm_lead"` + }, + { + field: "duplicate_of_contact", + required: true, + visibleOn: P24`has(record.duplicate_of_type) && record.duplicate_of_type == "crm_contact"` + }, + { + field: "duplicate_status", + required: true, + visibleOn: P24`has(record.disqualification_reason) && record.disqualification_reason == "duplicate"`, + helpText: "Confirmed means a human checked the two records and they are the same person." + } +]; +var LeadViews = defineView3({ + /** + * Default List View - Grid with Advanced Features + */ + list: { + type: "grid", + name: "all_leads", + label: "All Leads", + userActions: { editInline: true }, + data: { + provider: "object", + object: "crm_lead" + }, + // Column Configuration with Enhanced Features + columns: [ + { + // One name column, not two. Splitting first/last spent 300px to say + // what "Alice Martinez" says in one, and hung the record link off the + // given name alone — so opening a person meant aiming at their first + // name specifically. + field: "full_name", + label: "Name", + width: 200, + sortable: true, + link: true + // Primary navigation link + }, + { + field: "company", + label: "Company", + width: 200, + sortable: true + }, + { + field: "email", + label: "Email", + width: 200 + }, + { + field: "status", + label: "Status", + width: 120, + sortable: true + }, + { + field: "rating", + label: "Score", + width: 100, + align: "center" + }, + { + field: "lead_source", + label: "Source", + width: 120 + }, + // REQ-0005 acceptance 1: what the prospect wants and what it is worth, + // on the roster a rep opens every morning. Columns are also what the + // list's own filter and grouping controls offer, which is what makes the + // two FILTERABLE and GROUPABLE here rather than only readable — the same + // reading `contact.view.ts` records for the buying-centre columns. + // `need_type` is single-valued for exactly that reason (see + // `_picklists.ts`): a grouped list answers with one aggregate per raw + // stored value, so a multi-valued column would group by the combination. + { + field: "need_type", + label: "Need Type", + width: 160, + sortable: true + }, + { + field: "estimated_amount", + label: "Est. Amount", + width: 130, + align: "right", + sortable: true + }, + { + field: "owner_id", + label: "Owner", + width: 150 + } + ], + sort: [ + { field: "created_at", order: "desc" } + ], + // A row click opens the record page. There is deliberately no + // `navigation.view` here: measured in the browser on console 17.3.0 + // (#1716), the key is not resolved as a form-view name. The navigation + // hook reads it into the SECOND argument of `onNavigate` — the slot that + // otherwise carries the literal mode string, `r(t, d ?? 'view')` — so it + // named nothing and selected nothing. The record page here is rendered by + // `lead_detail_page` (`src/sales/pages/lead_detail.page.ts`), not by a named + // form view, and clicking a row behaved identically with the key present, + // with it absent, and on a list that never declared it. `detail_form` + // below stays: it is this file's one TABBED layout example, and it was + // already reachable by no path. + navigation: { + mode: "page" + }, + // `convert_lead` / `schedule_followup` declare `locations: ['list_item']` + // and are auto-injected into the menu. Do not add strings here: the legacy + // rowActions surface only dispatches defined stack actions. + // Built-in `exportOptions` covers CSV export; no export action needed. + bulkActions: ["create_campaign"], + // Features + pagination: { pageSize: 25, pageSizeOptions: [10, 25, 50, 100] }, + rowHeight: "medium", + exportOptions: { formats: ["csv", "xlsx"] }, + // Empty State + emptyState: { + title: "No Leads Yet", + message: "Get started by creating your first lead", + icon: "user-plus" + } + }, + /** + * Default Form View - SIMPLE Layout + * Basic sectioned form with collapsible sections and column layouts + */ + form: { + type: "simple", + sections: [ + { + name: "contact_information", + label: "Contact Information", + collapsible: true, + collapsed: false, + columns: 2, + // 2-column layout + fields: [ + { + field: "salutation" + }, + { + field: "first_name", + required: true + }, + { + field: "last_name", + required: true, + span: "full" + }, + "company", + "title", + "email", + "phone", + "mobile", + "website" + ] + }, + { + name: "lead_classification", + label: "Lead Classification", + collapsible: true, + collapsed: false, + columns: 3, + // 3-column layout + fields: [ + { + field: "status", + required: true + }, + { + field: "rating", + widget: "star_rating" + // Custom widget + }, + "lead_source", + "industry", + // Offered, ⛔ not `required` (#2097): an insert that leaves it empty is + // stamped to the creator by the platform (see `lead.hook.ts`), so a + // rep's new lead is theirs without a pick, and a manager can still + // choose another owner. `required` blocked that save client-side. + "owner_id", + // `disqualification_reason` is enforced by the + // `disqualification_reason_required` validation on crm_lead, so every + // form that lets a user pick "Unqualified" must also offer the reason + // — otherwise the save fails with an error the form gives you no way + // to clear. Hidden until it applies. + { + field: "disqualification_reason", + required: true, + visibleOn: P24`has(record.status) && record.status == "unqualified"` + }, + // REQ-0005 step 6: 「填写…需求类型…预计金额」. A rep types these at + // intake, so they need an authoring surface — and this form IS the + // create dialog (`RecordFormPage` and `useActionModal` both resolve + // `view.form ?? view.formViews?.default`, see `case.view.ts`). + // + // ⚠️ Named rather than reached through a group reference, and the + // AGENTS.md ladder's rung 3 asks for the reason in writing. Both + // fields declare `group: 'qualification'` on the object, so every + // DERIVED surface — the page synthesizer, an auto-derived form — + // already carries them from `fieldGroups` alone with nothing authored. + // This form is not one of those: it authors `sections`, and an + // authored `sections` array wins outright over the auto-derived path. + // The rung-2 fix, a `{ group: 'qualification' }` section, cannot be + // used HERE specifically: this section is a CURATED cross-group set, + // not a mirror of that group. It already names four of the group's + // members with per-field overrides a group reference cannot carry + // (`status` required, `rating`'s star widget, and + // `disqualification_reason`'s `required` + `visibleOn` directly + // above), and it borrows `industry` and `owner_id` from two other + // groups. Adding a group reference beside it would render those four + // a second time and pull in `next_followup_date` / + // `last_contacted_date`, which are machine-written and deliberately + // absent from every form. ⇒ The customer need is real, the group + // reference genuinely cannot express it, and the two lines below are + // what that leaves. + "need_type", + "estimated_amount", + ...DUPLICATE_LINK_FIELDS + ] + }, + { + name: "company_information", + label: "Company Information", + collapsible: true, + collapsed: true, + // Collapsed by default + columns: 2, + fields: [ + "annual_revenue", + "number_of_employees" + ] + }, + { + name: "address", + label: "Address", + collapsible: true, + collapsed: true, + columns: 2, + // `crm_lead` stores the location in one composite `Field.address`; + // the discrete street/city/state/postal_code/country columns this + // section used to list do not exist on the object, so the whole + // section rendered blank. + fields: [ + { + field: "address", + span: "full" + } + ] + }, + { + name: "additional_information", + label: "Additional Information", + collapsible: true, + collapsed: true, + columns: 1, + // Single column for text areas + fields: [ + "description", + "notes" + ] + }, + { + name: "privacy", + label: "Privacy", + collapsible: true, + collapsed: true, + columns: 2, + fields: [ + "do_not_call", + "email_opt_out" + ] + } + ] + }, + /** + * Additional Named List Views + */ + listViews: { + // Declaration order IS tab order in the console. These three working + // queues used to sit AFTER the kanban / calendar / gallery views, which + // pushed all of them into the "3 more" overflow menu — so the one screen + // a rep opens this list for was the one they had to go hunting for, while + // three presentation modes held the front row. + /** + * My Leads — a rep's own queue, hottest first. + */ + my_leads: { + name: "my_leads", + type: "grid", + label: "My Leads", + userActions: { editInline: true }, + data: { + provider: "object", + object: "crm_lead" + }, + columns: ["full_name", "company", "email", "status", "rating"], + filter: [ + { field: "owner_id", operator: "equals", value: "{current_user_id}" } + ], + sort: [ + { field: "rating", order: "desc" }, + { field: "created_at", order: "desc" } + ] + }, + /** + * Hot Leads — the working queue for the leads routing declared HOT. + * + * "Hot" is defined in exactly ONE place: the `lead_assignment` flow's + * `check_hot` decision (edge `e2`, `record.rating >= 4`). Crossing that + * line is what stamps the 1-day follow-up SLA and fires the "Hot lead — + * assign within 24h" alert at the owner, so this queue must hold precisely + * the leads that alert is about. (An earlier comment here credited a + * flagging workflow that has never existed in this repo — dead name + * removed, the routing flow is the producer.) + * + * The cut was `rating >= 4.5` (#766). `rating` is a WHOLE-star field — + * `lead.hook.ts` rounds its computed score ("round to WHOLE stars"), the + * `star_rating` widget offers nothing finer, and the one seeded 4.5 was + * deleted for the same reason (#591) — so `>= 4.5` meant `== 5` on every + * row that can actually exist. A 4-star lead was routed hot, alerted on, + * and then missing from the queue its owner was sent to. + * + * Sharing the population with "High Priority" is the deliberate cost of + * having one definition of hot, not an oversight: both views now show + * rating >= 4, still New or Contacted. What differs is what they are FOR. + * Hot Leads is the work order — sorted by next-follow-up (the SLA that + * routing just stamped), with phone, email and owner on the row so it can + * be dialled top to bottom. High Priority is the scan list — score-tinted + * rows and lead source, no SLA column, no time ordering. A 5-star-only + * queue, if it is ever a real need, gets its own view under its own name + * instead of squatting on "Hot". + * + * `test/hot-lead-threshold-parity.test.ts` derives this threshold and the + * flow's from the metadata and fails if they drift apart again. + */ + hot_leads: { + name: "hot_leads", + type: "grid", + label: "\u{1F525} Hot Leads", + userActions: { editInline: true }, + data: { provider: "object", object: "crm_lead" }, + columns: ["full_name", "company", "phone", "email", "rating", "next_followup_date", "owner_id"], + // Same rating cut as the `lead_assignment` hot branch, scoped to the + // statuses still worth working. (Operator-only filters; the view runtime + // does not resolve date template strings.) + filter: [ + { field: "rating", operator: "greater_than_or_equal", value: 4 }, + { field: "status", operator: "in", value: ["new", "contacted"] } + ], + sort: [{ field: "next_followup_date", order: "asc" }] + }, + /** + * High Priority Leads + */ + high_priority: { + name: "high_priority", + type: "grid", + label: "High Priority", + userActions: { editInline: true }, + data: { + provider: "object", + object: "crm_lead" + }, + columns: ["full_name", "company", "email", "status", "rating", "lead_source"], + filter: [ + { field: "rating", operator: "greater_than_or_equal", value: 4 }, + { field: "status", operator: "in", value: ["new", "contacted"] } + ], + rowColor: { + field: "rating", + colors: { + "5": "green", + "4": "orange" + } + } + }, + /** + * Suspected Duplicates — the review queue behind the intake flag (#598). + * + * `lead_duplicate_check` marks a re-captured email `suspected` and links it + * to the record it repeats. Without a place to SEE that set, the flag would + * be a column nobody reads: the reviewer opens this queue, compares the two + * records, and either clears the flag or disqualifies the lead as a + * confirmed duplicate. `confirmed` rows drop out of the queue, so it drains. + */ + suspected_duplicates: { + name: "suspected_duplicates", + type: "grid", + label: "Suspected Duplicates", + userActions: { editInline: true }, + data: { provider: "object", object: "crm_lead" }, + columns: [ + "full_name", + "company", + "email", + "duplicate_of_type", + "duplicate_of_lead", + "duplicate_of_contact", + "status", + "owner_id" + ], + filter: [ + { field: "duplicate_status", operator: "equals", value: "suspected" } + ], + // Oldest suspicion first: an unreviewed duplicate is a second rep working + // the same person, so the queue is worked front to back. + sort: [{ field: "created_at", order: "asc" }], + emptyState: { + title: "No Suspected Duplicates", + message: "Nothing to review \u2014 every re-captured email has been checked.", + icon: "copy" + } + }, + /** + * Kanban Board View + */ + kanban_by_status: { + name: "kanban_by_status", + type: "kanban", + label: "Lead Pipeline", + data: { + provider: "object", + object: "crm_lead" + }, + columns: ["first_name", "last_name", "company", "email"], + kanban: { + groupByField: "status", + summarizeField: "annual_revenue", + columns: ["first_name", "last_name", "company", "rating"] + }, + navigation: { + mode: "drawer", + // Open in drawer instead of new page + width: "600px" + } + }, + /** + * Calendar View + */ + calendar_by_created: { + name: "calendar_by_created", + type: "calendar", + label: "Lead Calendar", + data: { + provider: "object", + object: "crm_lead" + }, + columns: ["first_name", "last_name", "company"], + calendar: { + startDateField: "created_at", + titleField: "company", + colorField: "status" + } + }, + /** + * Gallery/Card View + */ + gallery_view: { + name: "gallery_view", + type: "gallery", + label: "Lead Cards", + data: { + provider: "object", + object: "crm_lead" + }, + columns: ["first_name", "last_name", "company", "email", "status"], + gallery: { + cardSize: "medium", + titleField: "company", + visibleFields: ["first_name", "last_name", "email", "phone", "status", "rating"] + } + } + }, + /** + * Additional Named Form Views - Demonstrating All 6 Layout Types + * + * One example per layout type. The SIMPLE one is the default `form` + * above, so this block carries the other five, plus the public and the + * conditional-visibility examples. Every layout is demonstrated exactly + * once across the file: each entry below is the only example of its own. + */ + formViews: { + /** + * 2. TABBED Layout + * Organize complex forms with tabs + */ + detail_form: { + type: "tabbed", + sections: [ + { + name: "general", + label: "General", + columns: 2, + fields: [ + "salutation", + "first_name", + "last_name", + "company", + "title", + "email", + "phone", + "mobile" + ] + }, + { + name: "qualification", + label: "Qualification", + columns: 2, + fields: [ + { field: "status", required: true }, + { field: "rating", widget: "star_rating" }, + "lead_source", + "industry", + "annual_revenue", + "number_of_employees", + // See the default form: `unqualified` requires a reason. + { + field: "disqualification_reason", + required: true, + visibleOn: P24`has(record.status) && record.status == "unqualified"` + }, + ...DUPLICATE_LINK_FIELDS + ] + }, + { + name: "address", + label: "Address", + columns: 2, + // Single composite `Field.address` — see the note on the default + // form's Address section. + fields: [ + { field: "address", span: "full" } + ] + }, + { + name: "details", + label: "Details", + columns: 1, + fields: [ + "description", + "notes", + "do_not_call", + "email_opt_out" + ] + } + ] + }, + /** + * 3. WIZARD Layout + * Step-by-step guided process + */ + lead_conversion_wizard: { + type: "wizard", + data: { + provider: "object", + object: "crm_lead" + }, + sections: [ + { + name: "step_1_contact_details", + label: "Step 1: Contact Details", + columns: 2, + fields: [ + { field: "first_name", required: true, readonly: true }, + { field: "last_name", required: true, readonly: true }, + { field: "email", readonly: true, span: "full" }, + "phone", + "mobile" + ] + }, + { + name: "step_2_company_information", + label: "Step 2: Company Information", + columns: 2, + fields: [ + { field: "company", required: true, readonly: true }, + "title", + "industry", + "annual_revenue", + "number_of_employees", + "website" + ] + }, + { + name: "step_3_qualification", + label: "Step 3: Qualification", + columns: 2, + fields: [ + { field: "status", required: true }, + // See the default form: `unqualified` requires a reason. The status + // is editable in this step, so the wizard can land there too. + { + field: "disqualification_reason", + required: true, + visibleOn: P24`has(record.status) && record.status == "unqualified"` + }, + ...DUPLICATE_LINK_FIELDS, + { field: "rating", widget: "star_rating" }, + "lead_source", + { + field: "owner_id", + // Conditional visibility. `!= null` on top of `has(...)`: strict + // CEL aborts on `dyn < int`, which `has()` alone allows. + visibleOn: P24`has(record.rating) && record.rating != null && record.rating >= 4` + } + ] + }, + { + name: "step_4_review_and_convert", + label: "Step 4: Review & Convert", + columns: 1, + fields: [ + { + field: "description", + helpText: "Review all information before converting to Account and Contact" + } + ] + } + ] + }, + /** + * 4. SPLIT Layout + * Master-detail split view + */ + split_edit: { + type: "split", + data: { + provider: "object", + object: "crm_lead" + }, + sections: [ + { + name: "primary_information", + label: "Primary Information", + columns: 1, + fields: [ + "first_name", + "last_name", + "company", + "email", + { field: "status", required: true }, + "owner_id", + // See the default form: `unqualified` requires a reason. + { + field: "disqualification_reason", + required: true, + visibleOn: P24`has(record.status) && record.status == "unqualified"` + }, + ...DUPLICATE_LINK_FIELDS + ] + }, + { + name: "extended_details", + label: "Extended Details", + columns: 2, + fields: [ + "phone", + "mobile", + "title", + "industry", + "lead_source", + { field: "rating", widget: "star_rating" }, + "annual_revenue", + "number_of_employees" + ] + } + ] + }, + /** + * 5. DRAWER Layout + * Side panel form (typically opened from list view) + */ + quick_edit_drawer: { + type: "drawer", + data: { + provider: "object", + object: "crm_lead" + }, + sections: [ + { + name: "quick_edit", + label: "Quick Edit", + columns: 1, + // Drawers typically use single column + fields: [ + { field: "first_name", required: true }, + { field: "last_name", required: true }, + "company", + "email", + "phone", + { field: "status", required: true }, + { field: "rating", widget: "star_rating" }, + "lead_source", + { + field: "owner_id", + // Only show owner after initial contact. A record with no status + // yet has not been contacted, so `!isBlank` keeps the blank case + // on the "hidden" side rather than letting `null != "new"` show it. + visibleOn: P24`has(record.status) && !isBlank(record.status) && record.status != "new"` + }, + // See the default form: `unqualified` requires a reason. + { + field: "disqualification_reason", + required: true, + visibleOn: P24`has(record.status) && record.status == "unqualified"` + }, + ...DUPLICATE_LINK_FIELDS + ] + } + ] + }, + /** + * 6. MODAL Layout + * Dialog-based form for quick actions + */ + status_update_modal: { + type: "modal", + data: { + provider: "object", + object: "crm_lead" + }, + sections: [ + { + name: "update_lead_status", + label: "Update Lead Status", + columns: 1, + fields: [ + { field: "first_name", readonly: true }, + { field: "last_name", readonly: true }, + { field: "company", readonly: true }, + { + field: "status", + required: true, + helpText: "Select the new status for this lead" + }, + { + field: "rating", + widget: "star_rating", + // Only show rating for qualified leads + visibleOn: P24`has(record.status) && record.status == "qualified"` + }, + // The reason picklist, not just free-text notes: it is what the + // `disqualification_reason_required` validation checks, and this + // modal is the main place a rep flips a lead to Unqualified. + { + field: "disqualification_reason", + required: true, + visibleOn: P24`has(record.status) && record.status == "unqualified"` + }, + ...DUPLICATE_LINK_FIELDS, + { + field: "notes", + placeholder: "Add notes about this status change", + // Free-text context alongside the reason + visibleOn: P24`has(record.status) && record.status == "unqualified"` + } + ] + } + ] + }, + /** + * 7. PUBLIC / ANONYMOUS — "Web-to-Lead" + * + * Airtable-style public form hosted at `/forms/contact-us`. Embeddable + * via iframe on a marketing site. Guests can ONLY submit (insert) — the + * `guest_portal` profile denies read/edit/delete on `crm_lead`. + * + * Fields not on the form (status, lead_source, owner_id, rating) are stamped + * by the `lead_automation` hook in `lead.hook.ts` after a guest submission. + */ + web_to_lead: { + type: "simple", + data: { + provider: "object", + object: "crm_lead" + }, + sections: [ + { + name: "tell_us_about_yourself", + label: "Tell us about yourself", + columns: 2, + fields: [ + { field: "first_name", required: true }, + { field: "last_name", required: true }, + { field: "email", required: true, span: "full" }, + "phone", + "title" + ] + }, + { + name: "about_your_company", + label: "About your company", + columns: 2, + fields: [ + { field: "company", required: true, span: "full" }, + "website", + "industry", + "number_of_employees", + "annual_revenue" + ] + }, + { + name: "how_can_we_help", + label: "How can we help?", + columns: 1, + fields: [ + { + field: "description", + required: true, + placeholder: "Briefly describe what you are looking for...", + helpText: "A sales representative will get back to you within one business day." + } + ] + } + ], + sharing: { + enabled: true, + allowAnonymous: true, + publicLink: "/forms/contact-us" + } + }, + /** + * Advanced Example: Conditional Field Visibility & Dependencies + */ + advanced_conditional: { + type: "simple", + data: { + provider: "object", + object: "crm_lead" + }, + sections: [ + { + name: "lead_information", + label: "Lead Information", + columns: 2, + fields: [ + "first_name", + "last_name", + "company", + "email", + "status", + "lead_source", + { + field: "rating", + widget: "star_rating", + // Only show after first contact — see the drawer form's note on + // why blank stays on the "hidden" side. + visibleOn: P24`has(record.status) && !isBlank(record.status) && record.status != "new"` + }, + { + field: "industry", + dependsOn: "company" + // Industry options depend on company + }, + { + field: "annual_revenue", + // Only for qualified leads + visibleOn: P24`has(record.rating) && record.rating != null && record.rating >= 3` + }, + { + field: "number_of_employees", + visibleOn: P24`has(record.rating) && record.rating != null && record.rating >= 3` + }, + { + field: "owner_id", + required: true, + visibleOn: P24`has(record.status) && (record.status == "contacted" || record.status == "qualified")` + }, + // See the default form: `unqualified` requires a reason. + { + field: "disqualification_reason", + required: true, + visibleOn: P24`has(record.status) && record.status == "unqualified"` + }, + ...DUPLICATE_LINK_FIELDS, + { + field: "notes", + span: "full", + required: true, + // Require explanation for unqualified + visibleOn: P24`has(record.status) && record.status == "unqualified"` + } + ] + }, + { + name: "address_information", + label: "Address Information", + collapsible: true, + collapsed: true, + columns: 2, + // Single composite `Field.address` — the discrete street/city/state/ + // postal_code/country columns do not exist on crm_lead. + fields: [ + { field: "address", span: "full" } + ] + }, + { + name: "privacy_preferences", + label: "Privacy Preferences", + collapsible: true, + collapsed: true, + columns: 2, + fields: [ + { + field: "do_not_call", + helpText: "Check if this lead has requested not to be called" + }, + { + field: "email_opt_out", + helpText: "Check if this lead has opted out of email communications" + } + ] + } + ] + } + } +}); + +// src/sales/views/account.view.ts +import { defineView as defineView4 } from "@objectstack/spec/ui"; +var AccountViews = defineView4({ + list: { + type: "grid", + name: "all_accounts", + label: "All Accounts", + userActions: { editInline: true }, + data: { provider: "object", object: "crm_account" }, + columns: [ + { field: "name", width: 240, sortable: true, link: true, pinned: "left" }, + { field: "industry", width: 140, sortable: true }, + { field: "type", width: 130 }, + { field: "annual_revenue", width: 160, align: "right", summary: "sum" }, + { field: "number_of_employees", width: 130, align: "right", summary: "avg" }, + { field: "health_score", width: 140 } + ], + sort: [{ field: "annual_revenue", order: "desc" }], + rowColor: { field: "is_active", colors: { true: "green", false: "slate" } }, + selection: { type: "multiple" }, + pagination: { pageSize: 50, pageSizeOptions: [25, 50, 100] }, + exportOptions: { formats: ["csv", "xlsx"] }, + compactToolbar: true, + bulkActionDefs: [ + { + name: "update_tier", + label: "Update Tier", + icon: "tag", + operation: "update", + params: [ + { + name: "tier", + label: "Customer Tier", + type: "select", + required: true, + options: [ + { label: "Strategic", value: "strategic" }, + { label: "Enterprise", value: "enterprise" }, + { label: "Mid-Market", value: "mid_market" }, + { label: "SMB", value: "smb" } + ] + } + ], + confirmText: "Update tier on {{count}} account(s) to {{tier}}?" + }, + { + name: "transfer_owner", + label: "Transfer Owner", + icon: "user-check", + operation: "update", + params: [ + { + name: "owner_id", + label: "New Owner", + type: "lookup", + // The platform registers `sys_user` — `user` matches no object and + // rendered an empty picker. + object: "sys_user", + required: true + } + ], + confirmText: "Transfer ownership of {{count}} account(s)?" + }, + { + name: "delete", + label: "Delete", + icon: "trash-2", + variant: "danger", + operation: "delete", + confirmText: "Permanently delete {{count}} account(s)? This cannot be undone.", + confirmLabel: "Delete" + } + ], + appearance: { + showDescription: true, + allowedVisualizations: ["grid", "gallery", "map"] + } + }, + listViews: { + /** Branded account cards */ + account_gallery: { + name: "account_gallery", + type: "gallery", + label: "Account Cards", + data: { provider: "object", object: "crm_account" }, + // `logo` rides in the projection for the same reason the timeline view + // carries its date fields: the list data source projects the configured + // columns, and `coverField` reads off that projection. + columns: ["name", "industry", "annual_revenue", "phone", "logo"], + gallery: { + // The card art this view was named for. "Branded account cards" had a + // brand COLOUR and no brand IMAGE — `crm_account.logo` is the object's + // only image field and nothing displayed it, so every card drew the + // same blank cover. `coverFit` is left unstated: the schema's default + // is the crop these cards want, and materialising a default rewrites + // "the author said nothing" into "the author asked for this". + coverField: "logo", + cardSize: "medium", + titleField: "name", + visibleFields: ["industry", "annual_revenue", "number_of_employees", "phone", "website", "owner_id"] + } + }, + /** + * Geospatial distribution. + * + * The `map` block is what BINDS the view to a coordinate source. Without it + * the renderer falls back to literal default field names, which resolve on + * `crm_account` only by luck — the view draws no marker while authoring + * reports success (`view/layout-without-binding`). `office_location` is the + * object's `Field.location(...)`, which is the one field on `crm_account` + * carrying coordinates; `billing_address` is an `address` field and is a + * postal shape, not a coordinate one, so it stays a column rather than the + * binding. `titleField` names the marker label — `name`, not the object's + * `nameField` (`display_title`), because the map's own `columns` show + * `name` and the two should agree. + */ + account_map: { + name: "account_map", + type: "map", + label: "Accounts by Location", + data: { provider: "object", object: "crm_account" }, + columns: ["name", "industry", "office_location", "billing_address"], + map: { locationField: "office_location", titleField: "name" } + }, + /** Tier accounts: Enterprise (>= $10M ARR) */ + enterprise_accounts: { + name: "enterprise_accounts", + type: "grid", + label: "Enterprise Accounts", + userActions: { editInline: true }, + data: { provider: "object", object: "crm_account" }, + columns: ["name", "industry", "annual_revenue", "number_of_employees", "owner_id"], + filter: [{ field: "annual_revenue", operator: "greater_than_or_equal", value: 1e7 }], + sort: [{ field: "annual_revenue", order: "desc" }], + // ADR-0047 end-user quick filters (Airtable "User filters", Elements: + // dropdowns). `element: 'dropdown'`, deliberately — on an object list + // the view SWITCHER owns the tab bar (it builds one entry per `list` / + // `listViews` descriptor), so a quick-filter block shaped as tabs is + // dropped there: the console logs `defines userFilters (element: + // "tabs"), which are ignored on an object list view (ADR-0047 "views" + // mode — the view switcher owns the tab bar here)` and renders nothing. + // Dropdowns sit beside the switcher and are unaffected. + // `owner_id` is the platform ownership lookup (#548) — it renders as a + // record-picker dropdown. + // NOTE: requires @objectstack/spec > 9.2.0 (ADR-0047 UserFiltersSchema); + // on older specs defineStack strips this block — harmless no-op. + ...{ + userFilters: { + element: "dropdown", + fields: [ + { field: "industry", showCount: true }, + { field: "type" }, + { field: "owner_id" } + ] + } + // typed via spread-as-any until @objectstack/spec ships ADR-0047 + // (UserFiltersSchema is in framework main, > 9.2.0) + } + }, + my_accounts: { + name: "my_accounts", + type: "grid", + label: "My Accounts", + userActions: { editInline: true }, + data: { provider: "object", object: "crm_account" }, + columns: ["name", "industry", "annual_revenue", "phone", "last_activity_date"], + filter: [{ field: "owner_id", operator: "equals", value: "{current_user_id}" }], + sort: [{ field: "last_activity_date", order: "desc" }] + }, + // The `renewals_due` view is gone with the fields it was built on (#1181): + // both its `is_not_null` filter and its sort key were + // `crm_account.next_renewal_date`, so the view could not outlive the field. + // Nothing is lost — `crm_contract` ships the renewals queue that the daily + // sweep actually acts on (`renewal_calendar`, over `end_date`). + /** At-risk customers — CSM action queue */ + at_risk_accounts: { + name: "at_risk_accounts", + type: "grid", + label: "\u26A0\uFE0F At-Risk Accounts", + userActions: { editInline: true }, + data: { provider: "object", object: "crm_account" }, + columns: ["name", "tier", "health_score", "segment", "last_activity_date"], + filter: [ + { field: "type", operator: "equals", value: "customer" }, + { field: "health_score", operator: "in", value: ["at_risk", "churning"] } + ], + sort: [{ field: "health_score", order: "desc" }] + } + }, + form: { + type: "tabbed", + sections: [ + { + name: "profile", + label: "Profile", + columns: 2, + fields: [ + { field: "name", required: true, span: "full" }, + "account_number", + // `type` (prospect / customer / partner …) drives the Renewals and + // At-Risk views' `type = customer` filter — with no form field it + // could never be set, so those views matched nothing. + "type", + "industry", + "phone", + "website", + "owner_id", + "parent_account", + "is_active", + "brand_color", + // The other half of the `branding` group. Without a form field there + // is no upload control anywhere in the app, so the logo the gallery + // cards now cover with could never have been set. Full span: an + // image drop target in a half-width cell is a thumbnail-sized one. + { field: "logo", span: "full" } + ] + }, + { + // `child_account_revenue` is a roll-up the engine maintains, so it is + // read-only on the form by construction — it is here because a hierarchy + // nobody can see the effect of is the decoration this field replaced. + name: "financials", + label: "Financials", + columns: 2, + fields: ["annual_revenue", "number_of_employees", "child_account_revenue"] + }, + { + // The customer-success fields the at_risk_accounts view lists and + // filters on. They existed on the object but no form offered them, so + // the CS working queue stayed permanently empty. (`renewal_owner` and + // `next_renewal_date` were removed from this section with the fields + // themselves — #1181.) + name: "customer_success", + label: "Customer Success", + columns: 2, + fields: ["tier", "segment", "health_score"] + }, + { + name: "locations", + label: "Locations", + columns: 1, + // `billing_country` and `territory` are readonly and derived, but both + // are on the form on purpose: an admin asking "why does the NA team not + // see this account?" reads the answer off the record instead of + // guessing at the address blob (#621). `territory` is what the rules + // actually match (#639) and `billing_country` is the input it was + // classified from, so the two together show the whole derivation — + // including the case the picklist alone cannot explain, an account + // sitting in `Other` because its country was typed in a spelling the + // mapping does not know. + fields: ["billing_address", "billing_country", "territory", "office_location"] + }, + { + name: "description", + label: "Description", + columns: 1, + fields: ["description"] + } + ] + } +}); + +// src/sales/views/contact.view.ts +import { defineView as defineView5 } from "@objectstack/spec/ui"; +var ContactViews = defineView5({ + list: { + type: "grid", + name: "all_contacts", + label: "All Contacts", + userActions: { editInline: true }, + data: { provider: "object", object: "crm_contact" }, + columns: [ + { field: "avatar", width: 64, align: "center" }, + { field: "first_name", width: 140, sortable: true, link: true }, + { field: "last_name", width: 140, sortable: true }, + { field: "crm_account", width: 200 }, + { field: "title", width: 180 }, + { field: "department", width: 140 }, + // REQ-0004 acceptance 2: the three buying-centre attributes are columns + // on the landing roster, which is already grouped by account with the + // groups collapsed — so expanding one account reads as a MAP (who + // decides, who is on our side) instead of a directory. Columns are also + // what the list's own filter and grouping controls offer. + { field: "buying_function", width: 160 }, + { field: "attitude", width: 140 }, + { field: "relationship_strength", width: 180 }, + { field: "email", width: 220 }, + { field: "phone", width: 150 }, + { field: "owner_id", width: 150 } + ], + sort: [{ field: "last_name", order: "asc" }], + grouping: { fields: [{ field: "crm_account", order: "asc", collapsed: true }] }, + selection: { type: "multiple" }, + // The selection-bar entry point for campaigning at existing customers + // (#597), mirroring `bulkActions: ['create_campaign']` on the lead grid. + // The bare-string form fans the action out once per selected row; do not + // add strings for `mark_primary` / `send_email`, which declare + // `locations: ['list_item']` and are auto-injected into the row menu. + bulkActions: ["add_contact_to_campaign"], + pagination: { pageSize: 50, pageSizeOptions: [25, 50, 100] }, + exportOptions: { formats: ["csv", "xlsx"] }, + appearance: { + showDescription: true, + allowedVisualizations: ["grid", "gallery"] + } + }, + listViews: { + /** People directory */ + contact_directory: { + name: "contact_directory", + type: "gallery", + label: "People Directory", + data: { provider: "object", object: "crm_contact" }, + columns: ["first_name", "last_name", "title", "email"], + gallery: { + coverField: "avatar", + coverFit: "cover", + cardSize: "small", + titleField: "last_name", + visibleFields: ["first_name", "title", "department", "email", "phone", "crm_account"] + } + }, + primary_contacts: { + name: "primary_contacts", + type: "grid", + label: "Primary Contacts", + userActions: { editInline: true }, + data: { provider: "object", object: "crm_contact" }, + columns: ["first_name", "last_name", "crm_account", "title", "email", "phone"], + filter: [{ field: "is_primary", operator: "equals", value: true }], + sort: [{ field: "crm_account", order: "asc" }] + } + }, + form: { + type: "tabbed", + sections: [ + { + name: "identity", + label: "Identity", + columns: 2, + fields: [ + "salutation", + { field: "first_name", required: true }, + { field: "last_name", required: true, span: "full" }, + { field: "crm_account", required: true }, + "title", + "department", + "owner_id" + ] + }, + { + // REQ-0004 acceptance 1: the buying-centre group is rendered FROM + // `fieldGroups`, with no per-field enumeration authored anywhere. + // + // This form authors `sections`, and an authored `sections` array wins + // outright over the renderer's `fieldGroups` auto-derivation (the + // mechanism is written up at length in `case.view.ts`), so a group + // declared on the object alone would reach the SYNTHESIZED detail + // page and never this form — which is also the create dialog. The + // group-reference form is rung 2 of the AGENTS.md ladder, for exactly + // this "partial arrangement is genuinely needed" case: `group:` + // inherits the object's `buying_centre` members (every field pointing + // at it, in declaration order) and its presentation, so adding a + // fourth attribute to the group later reaches this form by itself. + // + // ⛔ `group:` is mutually exclusive with `fields:` and with every key + // the group itself declares (`name`, `label`, `description`, + // `visibleWhen`, `collapsible`/`collapsed: true`) — `columns` is not + // one of those, because the group declares nothing about layout. + group: "buying_centre", + columns: 2 + }, + { + // Named `contact_details`, not `contact_info` — `contact_info` is + // already a distinct fieldGroup key on `crm_contact` ("Contact + // Information"), and reusing it here would make this section's + // translated heading follow that group's wording instead of its own + // "Contact Info". + name: "contact_details", + label: "Contact Info", + columns: 2, + fields: ["email", "phone", "mobile", "avatar"] + }, + { + // Named `mailing_address` — deliberately the SAME key as the + // `mailing_address` fieldGroup on `crm_contact`, which is the opposite + // call from the two sections either side of it and for the same + // reason. Reusing a group key makes the section's translated heading + // follow that group's wording; `contact_details` and + // `comm_preferences` wanted their own shorter wording, so they had to + // avoid the collision. This section wants exactly the group's wording + // ("Mailing Address"), which every locale already carries under + // `objects.crm_contact._sections.mailing_address`, so the collision is + // the feature: one heading, one translation, four locales, no new row. + // + // Why the section exists at all: an authored `sections` array wins + // outright over the renderer's `fieldGroups` auto-derivation (the + // mechanism is written up at length in `case.view.ts`), and this form + // is also the CREATE dialog. Without this section the address was + // readable on the SYNTHESIZED detail page — which does derive from + // `fieldGroups` — while no form in the app could enter or edit it, + // even though `contact_import.mapping.ts` writes it from the shipped + // CSV template. This tab is the authoring half of the import path. + name: "mailing_address", + label: "Mailing Address", + columns: 2, + fields: [ + // One structured `address` field; full width, so its parts lay out + // as a unit rather than in half a grid column. + { field: "mailing_address", span: "full" } + ] + }, + { + // Named `comm_preferences`, not `preferences` — `preferences` is + // already a distinct fieldGroup key on `crm_contact` ("Communication + // Preferences"), and reusing it here would make this section's + // translated heading follow that group's wording instead of its own + // "Preferences". + name: "comm_preferences", + label: "Preferences", + columns: 2, + fields: ["lead_source", "is_primary", "do_not_call", "email_opt_out"] + } + ] + } +}); + +// src/sales/views/opportunity.view.ts +import { defineView as defineView6 } from "@objectstack/spec/ui"; +var OpportunityViews = defineView6({ + // The landing view is OPEN deals, not every deal ever recorded. + // + // Sorted by close_date ascending and unfiltered, "All Opportunities" opened + // on settled history: the first screen was 7 closed-won and 4 closed-lost + // records, and a rep had to scroll past months of finished business to reach + // anything they could still act on. The full unfiltered list is still one + // click away on the "All Opportunities" tab. + list: { + type: "grid", + name: "open_opportunities", + label: "Open Deals", + userActions: { editInline: true }, + data: { provider: "object", object: "crm_opportunity" }, + filter: [ + { field: "stage", operator: "not_in", value: ["closed_won", "closed_lost"] } + ], + columns: [ + { field: "name", width: 220, sortable: true, link: true }, + { field: "crm_account", label: "Account", width: 180 }, + { field: "stage", width: 140, sortable: true }, + { field: "amount", width: 140, align: "right", sortable: true, summary: "sum" }, + { field: "probability", width: 110, align: "right" }, + { field: "expected_revenue", width: 160, align: "right", summary: "sum" }, + { field: "close_date", width: 140, sortable: true } + ], + sort: [{ field: "close_date", order: "asc" }], + rowColor: { + field: "stage", + colors: { + prospecting: "slate", + qualification: "sky", + // Teal sits between the cool qualification blue and the warm proposal + // amber, keeping the cool→warm funnel ramp readable. NOT the gold + // `#FFD700` this option carries in `_picklists.ts`: gold is one hue + // step from proposal's amber, so the two adjacent stages would tint + // rows the same. + // + // Values are colour NAMES, not hex: objectui's `useRowColor` resolves + // only a name from its own vocabulary (or a full `bg-*` class) and + // turns a hex into no colour at all — so until 17.6.0's lint said so, + // this map tinted nothing. + needs_analysis: "teal", + proposal: "amber", + negotiation: "purple", + closed_won: "green", + closed_lost: "red" + } + }, + pagination: { pageSize: 25, pageSizeOptions: [25, 50, 100] }, + selection: { type: "multiple" }, + showRecordCount: true, + exportOptions: { formats: ["csv", "xlsx"] }, + appearance: { + showDescription: true, + allowedVisualizations: ["grid", "kanban", "calendar", "timeline", "gallery"] + }, + // Binds the 'calendar' entry above: the same forecast dates the dedicated + // `close_date_calendar` view shows, on the field this list sorts by. + // `close_date` is required + notNull on crm_opportunity. + calendar: { + startDateField: "close_date", + titleField: "name", + colorField: "stage" + }, + // List-level entry points: generate_quote reaches the row menu via its + // own `locations: ['list_item']`. Built-in `exportOptions` covers CSV + // export. + // + // `mass_update_stage` is wired as an AGGREGATE bulk def, not as a bare + // `bulkActions: ['mass_update_stage']` string (#508). The two forms are + // different dispatch contracts, and only this one moves a whole selection: + // + // - bare string → per-record fan-out: the action is dispatched ONCE PER + // selected row with `recordId` set. N requests, N stage moves. + // - aggregate def → ONE dispatch for the whole selection, carrying every + // id in the builtin `params._selectedIds` and no `recordId`. One + // request, N stage moves, one audit entry. + // + // Aggregate is the right shape here because the body already loops over the + // selection itself, and because the run is all-or-nothing: a partial result + // rejects instead of leaving the bar reporting per-row success it cannot + // honour (see the body in `src/sales/actions/opportunity.actions.ts`). + // + // `execution: 'aggregate'` is REQUIRED on an `operation: 'custom'` def and + // is not boilerplate: a custom def without it has no dispatcher, so the + // button ticks green once per row and does nothing at all. The spec refuses + // that shape at parse time (#4457) — which is also what makes this + // declaration safe to trust rather than merely present. + // + // History: this list carried the bare-string form until #588 removed it as + // a silent no-op, and the removal was read as "the platform cannot deliver + // a selection" for two release candidates. It could: the channel is + // `params._selectedIds`, the underscore is load-bearing, and nothing was + // injecting it precisely BECAUSE this declaration was gone + // (objectstack-ai/objectstack#5568, closed works-as-declared). + // + // The def deliberately carries only the three keys that choose the dispatch + // contract. Label, icon, params (the New Stage picker) and `visible` are + // promoted from the action itself by the renderer, so the dialog and the + // toolbar button cannot drift apart — and the label stays i18n-resolved, + // which an inline `label:` here would not be. + bulkActionDefs: [ + { name: "mass_update_stage", operation: "custom", execution: "aggregate" } + ] + }, + listViews: { + /** + * All Opportunities — the unfiltered book, including closed business. + * + * Demoted from the landing view (see the note on `list` above) but kept + * whole: reporting, audits and win/loss reviews all need the closed rows, + * and a manager reaches this in one click. + */ + all_opportunities: { + name: "all_opportunities", + type: "grid", + label: "All Opportunities", + userActions: { editInline: true }, + data: { provider: "object", object: "crm_opportunity" }, + columns: [ + { field: "name", width: 220, sortable: true, link: true }, + { field: "crm_account", label: "Account", width: 180 }, + { field: "stage", width: 140, sortable: true }, + { field: "amount", width: 140, align: "right", sortable: true, summary: "sum" }, + { field: "probability", width: 110, align: "right" }, + { field: "expected_revenue", width: 160, align: "right", summary: "sum" }, + { field: "close_date", width: 140, sortable: true }, + { field: "owner_id", width: 150 } + ], + sort: [{ field: "close_date", order: "desc" }], + showRecordCount: true + }, + /** Drag-and-drop sales pipeline */ + pipeline_kanban: { + name: "pipeline_kanban", + type: "kanban", + label: "Sales Pipeline", + data: { provider: "object", object: "crm_opportunity" }, + columns: ["name", "crm_account", "amount", "close_date", "owner_id"], + kanban: { + groupByField: "stage", + summarizeField: "amount", + columns: ["name", "crm_account", "amount", "close_date"] + }, + // The board is the active working pipeline. Closed business remains in + // the full book and the dashboard, while excluding it here keeps all + // five active stages visible at a presentation-friendly width. + filter: [{ field: "stage", operator: "not_in", value: ["closed_won", "closed_lost"] }], + sort: [{ field: "close_date", order: "asc" }], + navigation: { mode: "drawer", width: "640px" } + }, + /** Close-date forecasting calendar */ + close_date_calendar: { + name: "close_date_calendar", + type: "calendar", + label: "Forecast Calendar", + data: { provider: "object", object: "crm_opportunity" }, + columns: ["name", "amount", "stage", "owner_id"], + calendar: { + startDateField: "close_date", + titleField: "name", + colorField: "stage" + } + }, + /** Chronological deal flow */ + deal_timeline: { + name: "deal_timeline", + type: "timeline", + label: "Deal Timeline", + data: { provider: "object", object: "crm_opportunity" }, + columns: ["name", "crm_account", "amount"], + timeline: { + // `created_at`, the platform's own creation stamp — the object's + // duplicate `created_date` was removed in #575 B2 because nothing ever + // wrote it, so this timeline started every bar at null. Same spelling + // as the lead activity calendar. + startDateField: "created_at", + endDateField: "close_date", + titleField: "name", + groupByField: "owner_id", + colorField: "stage", + scale: "month" + } + }, + /** Executive review cards */ + deal_gallery: { + name: "deal_gallery", + type: "gallery", + label: "Deal Cards", + data: { provider: "object", object: "crm_opportunity" }, + columns: ["name", "crm_account", "amount", "stage", "close_date"], + gallery: { + cardSize: "medium", + titleField: "name", + visibleFields: ["crm_account", "amount", "stage", "probability", "close_date", "owner_id"] + } + }, + /** Personal pipeline */ + my_open_deals: { + name: "my_open_deals", + type: "grid", + label: "My Open Deals", + userActions: { editInline: true }, + data: { provider: "object", object: "crm_opportunity" }, + columns: ["name", "crm_account", "stage", "amount", "close_date"], + // "Open" has to exclude BOTH closed stages. Excluding only closed_won + // meant a rep's own queue opened on their lost deals, sorted to the top + // by close_date — the least actionable rows in the system. + filter: [ + { field: "owner_id", operator: "equals", value: "{current_user_id}" }, + { field: "stage", operator: "not_in", value: ["closed_won", "closed_lost"] } + ], + sort: [{ field: "close_date", order: "asc" }] + }, + /** Stale Opportunities — still-open deals, longest-parked first */ + stale_opportunities: { + name: "stale_opportunities", + type: "grid", + // Honest label: this view does not apply the 14-day cut its automation + // twin (`opportunity_stagnation`, STALE_THRESHOLD_DAYS = 14) uses, and + // does not claim to. Two independent reasons were recorded for that; one + // still holds and one has expired, so they are separated here. + // + // STILL TRUE — `days_in_stage` is a FORMULA (#489), evaluated in JS after + // the query, so the data engine can neither filter nor sort on it. Any + // filter phrased in terms of `days_in_stage` remains impossible. + // + // EXPIRED (#744) — the second reason said the list data path resolves no + // date macros, so `stage_entry_date < {14_days_ago}` would ship the token + // as a literal and invert the comparison lexicographically ('2026-…' sorts + // below '{', so every row matched). That was measured on @objectstack + // 16.1.0 and stopped being true at 17.0.0-rc.0, when `resolveFilterTokens()` + // was wired into the ObjectQL read path (objectql #3582). `{14_days_ago}` + // is a first-class vocabulary member — it matches the parameterised + // grammar `DATE_MACRO_PARAM_RE`, `{N_(minutes|hours|days|weeks|months| + // years)_(ago|from_now)}` — and it reaches the driver already substituted + // for an ISO date. Measured on 17.0.0-rc.2, RE-MEASURED 2026-09-03 on + // 17.2.0 (#1467), RE-RUN on 17.3.0 (#1676, after the PR #1577 bump) and + // RE-RUN again on 17.4.0 (#1883, after the PR #1814 bump; not yet on + // 17.5.0), unchanged at every taking: over four rows parked + // 30d / 15d / 13d / 1d, `stage_entry_date < {14_days_ago}` returned the + // 30d and 15d rows — the same two the equivalent day-start literal + // returns, and not all four, which is what an unsubstituted token would + // have matched. It is the same seam + // `closing_this_quarter` — the very next view in this file — relies on, + // pinned against a real engine in + // `test/forecast-current-quarter-view.test.ts`. + // + // Correcting that half of the comment does not decide anything about the + // filter, and is deliberately not a licence to change it: expressing the + // cut as `stage_entry_date <= {14_days_ago}` would drop `days_in_stage` + // from the question entirely and change which rows this view returns — + // hiding today's 13-day-old deals from a manager's queue. That is a + // BEHAVIOUR change with its own issue (#770), where the open question is + // whether this queue should be a cut or a ranking at all — this label + // promises a ranking and honours it. `stale_articles` in + // `src/views/knowledge_article.view.ts` carried the same expired premise + // and was corrected in the same pass (#769); that tab was then DELETED + // outright (#781, the review queue ruled out of the product), so it is no + // longer a comparison available in this tree — the surviving precedent + // for "ranking, not cut" is this view. Nothing below was touched. + // + // As shipped: operator-only filter, ordered by the stored + // `stage_entry_date` ascending — longest-parked on top, which is the + // queue a manager works. The `days_in_stage` column puts the + // `opportunity_stagnation` threshold in plain sight on every row. + label: "\u26A0\uFE0F Stale Opportunities \xB7 Longest in Stage First", + userActions: { editInline: true }, + data: { provider: "object", object: "crm_opportunity" }, + columns: ["name", "crm_account", "stage", "amount", "stage_entry_date", "days_in_stage", "close_date", "owner_id"], + filter: [ + { field: "stage", operator: "not_in", value: ["closed_won", "closed_lost"] } + ], + sort: [{ field: "stage_entry_date", order: "asc" }, { field: "close_date", order: "asc" }] + }, + /** + * Tender expected this quarter — REQ-0006 acceptance 2 in one view. + * + * The point of the view is the predicate: it windows + * `expected_tender_date`, the CUSTOMER's procurement calendar, and touches + * `close_date` nowhere — which is what "reportable independently of + * `close_date`" means and what a single forecast date could never express. + * + * Same inclusive `{current_quarter_*}` bounds as `closing_this_quarter` + * below, exact for the same measured reason: both bounds are date macros + * resolved server-side, and `expected_tender_date` is a `Field.date()` + * stored as `YYYY-MM-DD` TEXT, so the inclusive upper bound drops no rows. + */ + tender_this_quarter: { + name: "tender_this_quarter", + type: "grid", + label: "Tender This Quarter", + userActions: { editInline: true }, + data: { provider: "object", object: "crm_opportunity" }, + columns: ["name", "crm_account", "expected_tender_date", "expected_tender_amount", "expected_signing_date", "stage", "owner_id"], + filter: [ + { field: "stage", operator: "not_in", value: ["closed_won", "closed_lost"] }, + { field: "expected_tender_date", operator: "greater_than_or_equal", value: "{current_quarter_start}" }, + { field: "expected_tender_date", operator: "less_than_or_equal", value: "{current_quarter_end}" } + ], + sort: [{ field: "expected_tender_date", order: "asc" }], + // Empty is the legitimate state on a fresh install: no seed row carries + // a customer-side tender date, so this tab opens on nothing until a rep + // records one. Unexplained, that reads as broken. + emptyState: { + title: "No Tenders Expected This Quarter", + message: "This tab lists open deals whose customer-side tender date falls inside the current quarter. Record Expected Tender Date on a deal to see it here.", + icon: "calendar-clock" + } + }, + /** Closing this quarter (commit + best_case) — sales-manager forecast */ + closing_this_quarter: { + name: "closing_this_quarter", + type: "grid", + label: "Closing This Quarter", + userActions: { editInline: true }, + data: { provider: "object", object: "crm_opportunity" }, + columns: ["name", "crm_account", "amount", "forecast_category", "probability", "close_date", "owner_id"], + // The `close_date` window is what makes the label true (#743). Without + // it this view returned EVERY open commit/best-case deal whenever it + // closed — a deal slated for next March sat under a heading that said + // "Closing This Quarter", and summing the Amount column gave a number + // that was not this quarter's commit. + // + // Both bounds are date macros resolved server-side: `resolveFilterTokens()` + // was wired into the ObjectQL read path in 17.0.0-rc.0 (objectql #3582, + // covering find/findOne/count/aggregate ahead of the middleware chain), + // so a saved-view filter value reaches the driver already substituted. + // Measured on 17.0.0-rc.2, RE-MEASURED 2026-09-03 on 17.2.0 (#1467), + // RE-RUN on 17.3.0 (#1676, after the PR #1577 bump) and RE-RUN again on + // 17.4.0 (#1883, after the PR #1814 bump), unchanged at + // every taking — see the runtime block in + // `test/forecast-current-quarter-view.test.ts`, which is that + // re-measurement (not yet re-run on 17.5.0). + // + // The upper bound is INCLUSIVE against `{current_quarter_end}` rather + // than half-open against `{next_quarter_start}`, and that choice is + // deliberate: a `*_end` token resolves to the period's last calendar DAY + // (2026-09-30), which on a `datetime` column would stop at midnight and + // silently drop that day's rows — the spec says to use the half-open + // form there. `close_date` is `Field.date()`, stored as `YYYY-MM-DD` + // TEXT on both sides of the comparison, so the inclusive bound is exact. + // That is the same field-type property `metadata-references.test.ts` + // relies on for why the CRM/Sales/Executive dashboards may window + // `close_date` at all (#460). Both forms were measured to return the + // identical row set here; the inclusive one reads as what it means. + filter: [ + { field: "forecast_category", operator: "in", value: ["commit", "best_case"] }, + { field: "stage", operator: "not_in", value: ["closed_won", "closed_lost"] }, + { field: "close_date", operator: "greater_than_or_equal", value: "{current_quarter_start}" }, + { field: "close_date", operator: "less_than_or_equal", value: "{current_quarter_end}" } + ], + sort: [{ field: "close_date", order: "asc" }], + // Scoping the list makes "empty" a state a real user meets, so it needs + // copy. Unlike the forecast view's (#745, where the sweep owns the + // window and a fresh install is ALWAYS empty until it runs), the seeds + // here do produce rows for most of a quarter — six seeded deals qualify + // on forecast_category + stage, at `daysFromNow` offsets 11/14/24/30/38/45. + // But every one of those offsets is relative to the INSTALL day, so once + // fewer than 11 days remain in the quarter all six land in the next one + // and a freshly seeded demo opens this tab on nothing. A real org meets + // the same state whenever a quarter's commit slips out. Empty is + // legitimate here; unexplained, it reads as broken. + emptyState: { + title: "No Deals Closing This Quarter", + message: "This tab lists open commit and best-case deals with a close date inside the current quarter. Nothing matches right now \u2014 deals closing later are on the Open Deals tab.", + icon: "calendar-check" + } + } + }, + form: { + type: "tabbed", + sections: [ + { + name: "overview", + label: "Overview", + columns: 2, + fields: [ + { field: "name", required: true, span: "full" }, + { field: "crm_account", required: true }, + "primary_contact", + { field: "stage", required: true }, + { field: "amount", required: true }, + "probability", + "close_date", + "owner_id" + ] + }, + { + name: "forecast", + label: "Forecast", + columns: 2, + fields: [ + "expected_revenue", + "forecast_category", + "type", + "lead_source", + "crm_campaign", + "stage_entry_date", + "days_in_stage", + "is_private", + // REQ-0006 step 8 — the customer's own procurement calendar. Named + // here (AGENTS.md ladder rung 3), and the reason in writing: + // `tender_this_quarter` filters on `expected_tender_date`, and a + // filtered field no form offers is a view that can never match a + // deal a rep created through the UI (`test/metadata-references + // .test.ts`). The fields declare `group: 'sales_process'`, so every + // DERIVED surface — the record page's Details tab — already carries + // them; this form authors `sections`, which win outright over + // derivation. A `{ group: 'sales_process' }` reference cannot stand + // in: it would render `stage`, `probability` and `close_date` + // (curated in Overview, `stage` `required`) and `stage_entry_date` + // (above) a second time, and pull the approval verdict columns and + // the inert-by-default `requested_status` into the create dialog. + "customer_initiation_date", + "expected_tender_date", + "expected_tender_amount", + "expected_signing_date", + "expected_signing_amount" + ] + }, + // REQ-0006 acceptance 1, FROM `fieldGroups` (AGENTS.md ladder rung 2), + // the way `contact.view.ts` references REQ-0004's buying centre: this + // form authors `sections`, which win outright over the renderer's + // `fieldGroups` derivation, so a group declared on the object alone + // never reaches this form — the Edit and New dialog. A group reference + // enumerates nothing; members, label and icon come from the object. + // + // ⚠️ Measured on the 17.6.0 console: the tabbed dialog renders NO tab + // for a `{ group }` section — this one, and the contact form's buying + // centre on `main` alike. That is the platform's to fix, and these two + // lines are the contract-correct form waiting for it (AGENTS.md: a + // platform defect is waited for, never routed around). Until then every + // REQ-0006 field is edited through the Details tab's edit mode — which + // offers no markdown editor, the reason the narrative fields are + // textareas (see the note above `customer_background`). + { group: "qualification", columns: 2 }, + { group: "narrative", columns: 1 }, + { + name: "sales_strategy", + label: "Sales Strategy", + columns: 1, + // `competitors` sat here until #1061 retired it — this form section was + // the field's ONLY surface anywhere in the app (nothing read it back). + fields: ["next_step"] + }, + { + // Win/loss capture at close time. The fields existed on the object for + // reporting but no form offered them, so every closed deal lost its + // why-we-won / why-we-lost data. + name: "win_loss", + label: "Win / Loss", + collapsible: true, + collapsed: true, + columns: 2, + fields: ["win_reason", "loss_reason", { field: "loss_details", span: "full" }] + } + ] + } +}); + +// src/sales/views/task.view.ts +import { defineView as defineView7 } from "@objectstack/spec/ui"; +var TaskViews = defineView7({ + list: { + type: "grid", + name: "all_tasks", + label: "All Tasks", + userActions: { editInline: true }, + data: { provider: "object", object: "crm_task" }, + // NO `progress_percent` column here (#1214 item 5). The default grid used + // to render completion THREE times on one row — 是否完成 (tick), 状态, and + // 进度(%) — and the percent was the one that carried nothing. + // + // ⚠️ The card justified the removal as "every seeded row is 0%". That is + // FALSE as stated and was re-measured before deleting: two of the seven + // seeded tasks carry 100. What is TRUE is the claim underneath it — nobody + // maintains a percent per task — and the seed shows it more sharply than + // the card did: + // · every value that exists is 100, and every one of those rows is + // `status: 'completed'` (`service.seed.ts` mirrors what the hook would + // stamp, since hooks do not run over seeds); + // · `task_completion` stamps 100 on the completed transition and writes + // the field at no other time; + // · both `in_progress` rows sit at 0 — the one status where a percent + // could say something a status cannot, and it says nothing. + // ⇒ On this grid the column is `status` re-rendered at LOWER resolution: it + // cannot tell `not_started` from `in_progress` (both 0), while the `status` + // column beside it can. Dropping it loses no fact this row does not already + // carry twice. + // + // ⛔ The FIELD stays, and so does every other reader — this is one column + // on one view, not a retirement: `task_gantt` fills its bars from + // `gantt.progressField`, `task_board` and `my_open_tasks` show it (neither + // carries `status` AND `is_completed`, so there it is not a third spelling), + // `avg_progress` in `task.dataset.ts` aggregates it, and the Effort section + // of this file's form still lets a user author one. + // + // ⛔ `is_completed` STAYS, and is not the second half of this cleanup: it is + // not an independent shadow that can contradict `status` — `task_completion` + // recomputes it from status on every insert and update + // (`input.is_completed = effStatus === 'completed'`), which is precisely the + // "render completion from status" the card asks for, already done at the + // data layer. It is also this list's first sort key and its completion + // control. + columns: [ + { field: "is_completed", width: 60, align: "center" }, + { field: "subject", width: 280, sortable: true, link: true }, + { field: "status", width: 130, sortable: true }, + { field: "priority", width: 110, sortable: true }, + { field: "due_date", width: 140, sortable: true }, + { field: "owner_id", width: 150 }, + { field: "is_overdue", width: 100, align: "center" } + ], + sort: [ + { field: "is_completed", order: "asc" }, + { field: "due_date", order: "asc" } + ], + rowColor: { + // Task priority is low/normal/high/urgent — the previous critical/medium + // keys were Case values, so urgent and normal rows got no color at all. + // Colors mirror the option colors on crm_task.priority. + field: "priority", + colors: { urgent: "red", high: "orange", normal: "green", low: "slate" } + }, + selection: { type: "multiple" }, + pagination: { pageSize: 50 }, + appearance: { + showDescription: true, + allowedVisualizations: ["grid", "kanban", "calendar", "gantt", "timeline"] + }, + // Binds the 'calendar' entry above: the same schedule the dedicated + // `task_calendar` view shows, on the field this list sorts by. `due_date` + // is optional — an undated task stays off the calendar instead of being + // dropped on today by a guessed field. + calendar: { + startDateField: "due_date", + titleField: "subject", + colorField: "priority" + } + }, + listViews: { + /** Work board */ + task_board: { + name: "task_board", + type: "kanban", + label: "Task Board", + data: { provider: "object", object: "crm_task" }, + columns: ["subject", "priority", "due_date", "owner_id"], + kanban: { + groupByField: "status", + columns: ["subject", "priority", "due_date", "progress_percent"] + }, + filter: [{ field: "is_completed", operator: "equals", value: false }], + navigation: { mode: "drawer", width: "520px" } + }, + /** Schedule view */ + task_calendar: { + name: "task_calendar", + type: "calendar", + label: "Task Schedule", + data: { provider: "object", object: "crm_task" }, + columns: ["subject", "priority", "owner_id"], + calendar: { + startDateField: "due_date", + titleField: "subject", + colorField: "priority" + } + }, + /** Execution plan */ + task_gantt: { + name: "task_gantt", + type: "gantt", + label: "Execution Plan", + data: { provider: "object", object: "crm_task" }, + columns: ["subject", "owner_id", "progress_percent"], + gantt: { + startDateField: "reminder_date", + endDateField: "due_date", + titleField: "subject", + progressField: "progress_percent" + } + }, + /** Worklog timeline */ + task_timeline: { + name: "task_timeline", + type: "timeline", + label: "Worklog Timeline", + data: { provider: "object", object: "crm_task" }, + columns: ["subject", "status"], + timeline: { + startDateField: "reminder_date", + endDateField: "due_date", + titleField: "subject", + groupByField: "owner_id", + colorField: "status", + scale: "week" + } + }, + my_open_tasks: { + name: "my_open_tasks", + type: "grid", + label: "My Open Tasks", + userActions: { editInline: true }, + data: { provider: "object", object: "crm_task" }, + columns: ["subject", "priority", "due_date", "progress_percent"], + filter: [ + { field: "owner_id", operator: "equals", value: "{current_user_id}" }, + { field: "is_completed", operator: "equals", value: false } + ], + sort: [{ field: "due_date", order: "asc" }] + }, + /** My open priority tasks — daily morning queue */ + todays_tasks: { + name: "todays_tasks", + type: "grid", + label: "\u{1F4C5} My Priority Tasks", + userActions: { editInline: true }, + data: { provider: "object", object: "crm_task" }, + columns: ["subject", "priority", "status", "due_date", "related_to_type", "owner_id"], + // Operator-only filter — priority and status, no tokens — and the reason + // recorded here for that has expired (#782). Two claims stood here; both + // were wrong already on 17.0.0-rc.2 — the version this repo pinned AT + // THE TIME they were measured, not the current pin — in different + // ways. "Wrong" is about those two + // retired claims, not about the engine: nothing in this block reports + // broken platform behaviour. + // + // ⚠️ READ THE VERSION ON EACH READING BELOW. They were taken at + // several different pins and are labelled individually; a reading + // labelled 17.2.0 was taken there and has NOT been re-taken on any later + // pin unless it says so. + // + // `{current_user_id}` DOES interpolate. `resolveFilterTokens()` was wired + // into the ObjectQL READ path at 17.0.0-rc.0 (objectql #3582) ahead of + // the middleware chain, covering `find` / `findOne` / `count` / + // `aggregate` — saved-view filters included. `my_open_tasks`, the view + // directly above, ships that exact token. Measured in #784 with two probes + // that separate the three possible outcomes: `owner_id = + // {current_org_id}` returned 0 rows (the filter is not being dropped) + // while `owner_id = {current_user_id}` returned every seeded task (not a + // literal-string compare either — the literal matches no owner at all). + // RE-MEASURED 2026-09-03 on 17.2.0 (#1467), unchanged: both probes + // reported exactly those results there. NOT re-run on 17.3.0 (#1676) — + // the two-probe result is a 17.2.0 reading, and the seam it rests on + // (`resolveFilterTokens()` on the read path) was re-confirmed on 17.4.0 + // by `test/flow-filter-today-token.test.ts` (not yet re-run on 17.5.0). + // + // `{TODAY()}` is not a spelling of anything and never was. The vocabulary + // is `{today}` / `{yesterday}` / `{tomorrow}` / `{now}`, the period + // tokens, and the parameterised `{N_days_ago}` family. + // + // ⚠️ WHAT CHANGED between rc.2 and 17.4.0 — the one reading in + // this block that did NOT survive re-measurement, and the reason the + // version qualifiers here are load-bearing rather than bookkeeping. On + // rc.2 `{TODAY()}` was not REJECTED either: the placeholder grammar was + // `/^\$?\{([a-zA-Z0-9_]+)\}$/`, parentheses fell outside it, + // `classifyFilterToken('{TODAY()}')` returned null, and the string + // reached the driver verbatim and compared as text. From 17.2.0 on — + // re-confirmed on 17.3.0 (#1676) and again on 17.4.0 + // (#1883) by the PREMISE case in + // `test/flow-filter-today-token.test.ts`, which drives a real engine — + // that is FALSE: `FILTER_TOKEN_WRAPPED_RE` in `@objectstack/spec/data` + // now reads `/^\$?\{([^{}]+)\}$/`, which DOES match `TODAY()`, so it + // classifies as `kind: 'unknown'` and `resolveFilterTokens()` throws + // `UnknownFilterTokenError` (`FILTER_TOKEN_UNKNOWN`, HTTP 400) — the same + // envelope `{TODAY}` gets. The change landed at 17.0.0-rc.6 and this repo + // already pins it elsewhere: `test/flow-filter-today-token.test.ts` + // (#1107). That is also why the `src/*/flows` sweeps that still spell + // `{TODAY()}` work — `interpolateFilter()` resolves it before ObjectQL + // sees the filter at all. + // + // Measured on rc.2 over a four-row `crm_task` fixture (due 30d ago / 1d + // ago / today / in 7d), and RE-MEASURED 2026-09-03 on 17.2.0 (#1467) + // over the same fixture — three rows unchanged, the fourth not. ⛔ The + // row COUNTS below are a 17.2.0 reading and were NOT re-taken on 17.3.0 + // (#1676); what WAS re-confirmed there is the throw/resolve verdict in + // the right-hand column, by `test/flow-filter-today-token.test.ts`: + // + // rc.2 17.2.0 + // due_date < '{today}' -> 2 rows (past-due) 2 rows + // due_date <= '{today}' -> 3 rows 3 rows + // due_date < '{TODAY}' -> throws throws + // due_date < '{TODAY()}' -> ALL 4 rows throws + // + // (Both throws are `UnknownFilterTokenError`, `FILTER_TOKEN_UNKNOWN`.) + // + // So the #744 lexicographic inversion ('2026-…' sorts below '{') is NOT + // still live on this path, and ⛔ nothing here should carry a workaround + // for it: on rc.2 it reached every spelling the grammar could not see, + // and the 17.2.0 grammar sees them all. The author-time guard in + // `test/metadata-references.test.ts` — it scans the broader + // `/\{([^{}]+)\}/` and rejects any token neither path resolves — still + // earns its keep, by failing at authoring time rather than as a 400 in a + // user's face, and by covering the analytics path the engine gate does + // not. + // + // Correcting the comment is not a licence to change the filter. Whether + // this view should carry a date bound at all — and whether a label + // reading "My Priority Tasks" over a filter with no owner condition is + // the right name — are BEHAVIOUR decisions on #770's line for the task + // views, not this one's. + // + // The sort below is due_date-MAJOR, not priority-major: `priority_rank + // desc` only breaks ties inside a single due date, so a high task due + // tomorrow outranks an urgent one due next week. Measured on rc.2 with + // the shipped sort over four rows — soon/urgent, soon/high, later/urgent, + // later/high, in that order. What stood here said the sort "puts urgent + // at top", which is what the OTHER key order would do. + filter: [ + { field: "status", operator: "in", value: ["not_started", "in_progress"] }, + { field: "priority", operator: "in", value: ["high", "urgent"] } + ], + sort: [{ field: "due_date", order: "asc" }, { field: "priority_rank", order: "desc" }] + }, + /** Overdue / open tasks across the team — sorted oldest-due first */ + overdue_tasks: { + name: "overdue_tasks", + type: "grid", + // Honest label. Two independent reasons were recorded for it; one still + // holds and one has expired (#782), so they are separated here. + // + // STILL TRUE — `is_overdue` is a WRITE-TIME snapshot. `task.hook.ts:68` + // stamps it in `beforeSave` off that moment's clock (`effDue < todayStr` + // and not completed) and nothing re-stamps it afterwards, so a task that + // was on time when it was last saved still reads `is_overdue = false` the + // day after its due date passes. A filter on that column would hand back + // the wrong rows, and it would go wrong silently. + // + // EXPIRED — the other reason said the view layer cannot resolve + // `due_date < {TODAY()}`, and that only `{current_user_id}` interpolates. + // Both halves were wrong already on 17.0.0-rc.2 — the version this repo + // pinned AT THE TIME they were measured, not the current pin — and the + // file said the opposite of + // itself: the note on `todays_tasks` above asserted that + // `{current_user_id}` does NOT interpolate. It does. + // That comment carries the measurements with their versions, INCLUDING + // the one that moved: `{TODAY()}` is REJECTED from 17.2.0 on + // (`FILTER_TOKEN_UNKNOWN`, re-confirmed on 17.3.0 and again on + // 17.4.0 by + // `test/flow-filter-today-token.test.ts`) where on rc.2 it shipped to + // the driver as text, so "cannot resolve `{TODAY()}`" is wrong on the + // current pin for a different reason than it was wrong on rc.2. The + // canonical `{today}` resolves on the read path either way, so a + // strictly past-due filter IS expressible: `due_date < '{today}'` + // selected exactly the past-due rows out of four on rc.2, and did again + // on 17.2.0 (RE-MEASURED 2026-09-03; that row count was not re-taken on + // 17.3.0, where the token's resolution is re-confirmed by the test file + // named above). + // + // So the honest statement is narrower than the one that stood here: this + // view CAN be given a strictly past-due cut through `{today}`, and is not + // given one. Adding it is a BEHAVIOUR change, not a comment correction — + // it would drop today's due-today work out of the queue and turn an + // "Open Tasks" backlog into a strict overdue list, which is the + // cut-versus-ranking question already open on #770 for the task views. + // That also retires the follow-up this comment used to end on: an hourly + // flow re-stamping `is_overdue` was proposed as the ONLY route to a + // truly-overdue gauge, because the filter route was believed closed. + // There are two routes now, and choosing between them belongs to #770. + // + // As shipped: the open-task backlog ordered most-overdue-first (oldest + // due date on top), which is the actionable queue a manager works. + label: "\u23F0 Open Tasks \xB7 Most Overdue First", + userActions: { editInline: true }, + data: { provider: "object", object: "crm_task" }, + columns: ["subject", "priority", "status", "due_date", "owner_id"], + filter: [ + { field: "is_completed", operator: "equals", value: false } + ], + sort: [{ field: "due_date", order: "asc" }] + } + }, + form: { + type: "simple", + sections: [ + { + name: "task", + label: "Task", + columns: 2, + // `type` (call / email / meeting / demo) is what makes an activity + // history readable and is the first thing a rep reaches for after the + // subject — it was missing entirely. `description` captures what was + // actually said on the call. `progress_percent` moved to the Effort + // section: a task being filed is 0% by definition, so a percentage + // slider on the create form is noise. + fields: [ + { field: "subject", required: true, span: "full" }, + { field: "type", required: false }, + { field: "status", required: true }, + "priority", + "due_date", + "owner_id", + "reminder_date", + { field: "description", span: "full" } + ] + }, + { + name: "related_records", + label: "Related Records", + collapsible: true, + columns: 2, + fields: [ + "related_to_account", + "related_to_contact", + "related_to_opportunity", + "related_to_lead", + "related_to_case" + ] + }, + { + name: "recurrence_and_effort", + label: "Recurrence & Effort", + collapsible: true, + collapsed: true, + columns: 2, + fields: [ + "is_recurring", + "recurrence_type", + "recurrence_interval", + "recurrence_end_date", + "progress_percent" + ] + } + ] + } +}); + +// src/sales/views/event.view.ts +import { defineView as defineView8 } from "@objectstack/spec/ui"; +var EventViews = defineView8({ + list: { + type: "grid", + name: "all_events", + label: "All Events", + userActions: { editInline: true }, + data: { provider: "object", object: "crm_event" }, + columns: [ + { field: "subject", width: 280, sortable: true, link: true }, + { field: "type", width: 120, sortable: true }, + { field: "status", width: 120, sortable: true }, + { field: "start_datetime", width: 180, sortable: true }, + { field: "duration_minutes", width: 120, align: "right" }, + { field: "location", width: 180 }, + { field: "owner_id", width: 150 } + ], + sort: [{ field: "start_datetime", order: "desc" }], + rowColor: { + // Mirrors the option colors on crm_event.status. + field: "status", + colors: { planned: "blue", held: "green", cancelled: "slate", no_show: "orange" } + }, + selection: { type: "multiple" }, + pagination: { pageSize: 50 }, + appearance: { + showDescription: true, + allowedVisualizations: ["grid", "calendar", "timeline", "kanban"] + }, + // Binds the 'calendar' entry above: the same span the dedicated + // `event_calendar` view shows. `start_datetime` is required + notNull; + // `end_datetime` is optional, so an event without one stays a single point + // in time rather than borrowing a neighbour's end. + calendar: { + startDateField: "start_datetime", + endDateField: "end_datetime", + titleField: "subject", + colorField: "type" + } + }, + listViews: { + /** The calendar the issue asks for — start → end, coloured by kind. */ + event_calendar: { + name: "event_calendar", + type: "calendar", + label: "Event Calendar", + data: { provider: "object", object: "crm_event" }, + columns: ["subject", "type", "owner_id"], + calendar: { + startDateField: "start_datetime", + endDateField: "end_datetime", + titleField: "subject", + colorField: "type" + } + }, + /** Who is booked when — one lane per rep. */ + event_timeline: { + name: "event_timeline", + type: "timeline", + label: "Team Schedule", + data: { provider: "object", object: "crm_event" }, + columns: ["subject", "status"], + timeline: { + startDateField: "start_datetime", + endDateField: "end_datetime", + titleField: "subject", + groupByField: "owner_id", + colorField: "type", + scale: "day" + } + }, + my_events: { + name: "my_events", + type: "calendar", + label: "My Calendar", + data: { provider: "object", object: "crm_event" }, + columns: ["subject", "type", "location"], + // `{current_user_id}` is the one token the list-view data path really + // interpolates (see crm.app.ts's "My Work" note). + filter: [{ field: "owner_id", operator: "equals", value: "{current_user_id}" }], + calendar: { + startDateField: "start_datetime", + endDateField: "end_datetime", + titleField: "subject", + colorField: "type" + } + }, + /** Booked, not yet held — soonest first. */ + upcoming_events: { + name: "upcoming_events", + type: "grid", + label: "\u{1F4C5} Upcoming \xB7 Soonest First", + userActions: { editInline: true }, + data: { provider: "object", object: "crm_event" }, + columns: ["subject", "type", "start_datetime", "location", "related_to_type", "owner_id"], + filter: [{ field: "status", operator: "equals", value: "planned" }], + sort: [{ field: "start_datetime", order: "asc" }] + }, + /** What actually happened — the interaction history the CRM could not show. */ + held_events: { + name: "held_events", + type: "grid", + label: "\u2705 Interaction History", + userActions: { editInline: true }, + data: { provider: "object", object: "crm_event" }, + columns: ["subject", "type", "start_datetime", "duration_minutes", "related_to_type", "owner_id"], + filter: [{ field: "status", operator: "equals", value: "held" }], + sort: [{ field: "start_datetime", order: "desc" }] + } + }, + form: { + type: "simple", + sections: [ + { + name: "event", + label: "Event", + columns: 2, + fields: [ + { field: "subject", required: true, span: "full" }, + { field: "type", required: true }, + { field: "status", required: true }, + "owner_id", + "location", + { field: "description", span: "full" } + ] + }, + { + name: "schedule", + label: "Schedule", + columns: 2, + fields: [ + { field: "start_datetime", required: true }, + "end_datetime", + "all_day", + "duration_minutes" + ] + }, + { + name: "related_records", + label: "Related Records", + collapsible: true, + columns: 2, + fields: [ + "related_to_account", + "related_to_contact", + "related_to_opportunity", + "related_to_lead", + "related_to_case" + ] + }, + { + name: "outcome", + label: "Outcome", + collapsible: true, + collapsed: true, + columns: 1, + fields: ["outcome_notes"] + } + ] + } +}); + +// src/sales/views/event_attendee.view.ts +import { defineView as defineView9 } from "@objectstack/spec/ui"; +var EventAttendeeViews = defineView9({ + list: { + type: "grid", + name: "all_event_attendees", + label: "Event Attendees", + userActions: { editInline: true }, + data: { provider: "object", object: "crm_event_attendee" }, + columns: [ + { field: "attendee_type", width: 120, sortable: true }, + { field: "crm_contact", width: 200 }, + { field: "crm_lead", width: 200 }, + { field: "sys_user", width: 200 }, + { field: "external_name", width: 200 }, + { field: "response", width: 140, sortable: true }, + { field: "is_organizer", width: 100, align: "center" } + ], + sort: [{ field: "is_organizer", order: "desc" }], + rowColor: { + // Mirrors the option colors on crm_event_attendee.response. + field: "response", + colors: { accepted: "green", declined: "red", tentative: "orange", no_response: "slate" } + }, + pagination: { pageSize: 25 } + }, + form: { + type: "simple", + sections: [ + { + name: "attendee", + label: "Attendee", + columns: 2, + fields: [ + { field: "crm_event", required: true }, + { field: "attendee_type", required: true }, + "crm_contact", + "crm_lead", + "sys_user", + "external_name" + ] + }, + { + name: "invitation", + label: "Invitation", + columns: 2, + fields: ["response", "is_organizer", "invited_date"] + } + ] + } +}); + +// src/sales/views/forecast.view.ts +import { defineView as defineView10 } from "@objectstack/spec/ui"; +var ForecastViews = defineView10({ + list: { + type: "grid", + name: "all_forecasts", + label: "All Forecasts", + userActions: { editInline: true }, + data: { provider: "object", object: "crm_forecast" }, + columns: [ + { field: "owner_id", width: 160, pinned: "left", link: true }, + { field: "period_label", width: 130, sortable: true }, + { field: "period_start", width: 130, sortable: true }, + { field: "snapshot_date", width: 130, sortable: true }, + { field: "quota", width: 130, align: "right", summary: "sum" }, + { field: "closed_amount", width: 140, align: "right", summary: "sum" }, + { field: "commit_amount", width: 140, align: "right", summary: "sum" }, + { field: "best_case_amount", width: 140, align: "right", summary: "sum" }, + { field: "pipeline_amount", width: 140, align: "right", summary: "sum" }, + // No total here: a formula has no stored column to aggregate, so the spec refuses `sum` on a `formula` field (#1980). + { field: "expected_amount", width: 140, align: "right" }, + { field: "attainment_pct", width: 130, align: "right" }, + { field: "coverage_ratio", width: 130, align: "right" }, + { field: "source", width: 130 } + ], + sort: [ + { field: "period_start", order: "desc" }, + { field: "owner_id", order: "asc" } + ], + grouping: { fields: [{ field: "period_label", order: "desc" }] }, + pagination: { pageSize: 50 }, + appearance: { allowedVisualizations: ["grid"] } + }, + listViews: { + this_quarter_forecasts: { + name: "this_quarter_forecasts", + type: "grid", + // The label promises the CURRENT quarter, and the filter delivers it. + // + // The restriction was dropped in #515 on the measurement that "the list + // data path resolves no date macro". That measurement was taken on + // @objectstack 16.1.0 and has since expired: `resolveFilterTokens()` was + // wired into the ObjectQL READ path in 17.0.0-rc.0 (objectql + // `feat(filters): evaluate {filter-token} placeholders server-side`, + // #3582) — `find`/`findOne`/`count`/`aggregate`, ahead of the middleware + // chain, which is the one gate every server-side read passes through, + // saved-view filters included. Measured rather than inferred; + // `test/forecast-current-quarter-view.test.ts` runs THIS filter through a + // real engine and pins the three-way outcome (one quarter selected, not + // zero and not all of them). First taken on 17.0.0-rc.2, RE-RUN + // 2026-09-03 on 17.2.0 (#1467), RE-RUN on 17.3.0 (#1676, after the PR + // #1577 bump) and RE-RUN again on 17.4.0 (#1883, after the PR #1814 + // bump), green all four times. Not yet re-run on 17.5.0; the test is + // what re-takes the reading on each new pin. + // + // Both halves of the key are load-bearing, same as the quota-attainment + // widget in `src/sales/dashboards/sales.dashboard.ts`: `period: 'quarter'` + // alone returns every quarter ever snapshotted (the #730 defect), and + // `period_start` alone merges the quarter row with the MONTH row that + // opens the same quarter — Q3 and July both start on the 1st. + // + // The old `{this_quarter_start}` spelling is not merely unresolved now, + // it is rejected: the resolver throws `Unresolvable filter placeholder` + // and names `{current_quarter_start}` as the fix, so the silent-empty + // failure mode that removal was reacting to is no longer reachable. + label: "This Quarter", + userActions: { editInline: true }, + data: { provider: "object", object: "crm_forecast" }, + columns: ["owner_id", "quota", "closed_amount", "commit_amount", "best_case_amount", "pipeline_amount", "attainment_pct", "coverage_ratio"], + filter: [ + { field: "period", operator: "equals", value: "quarter" }, + { field: "period_start", operator: "equals", value: "{current_quarter_start}" } + ], + // One sort key, because the filter pins `period_start` to a single value + // — the `period_start desc` key that ranked quarters against each other + // existed only to float the current quarter to the top of an unscoped + // list, and is provably inert now that the list holds one quarter. + // + // The tiebreaker is NOT `attainment_pct desc`, which is a FORMULA — the + // engine computes it in JS after the query, so the data engine never saw + // that sort key and the ordering within a quarter was arbitrary (same + // class of defect as #489's `days_in_stage` filter). `closed_amount` is + // the stored numerator behind attainment and ranks the same direction. + sort: [ + { field: "closed_amount", order: "desc" } + ], + // Empty is the honest state, and it needs to say so. The seeds ship no + // current-quarter row on purpose (#702 — the sweep owns that window, and + // two producers in one window is what left a phantom ownerless + // duplicate), so on a fresh install this view is empty until the 03:00 + // `forecast_snapshot` sweep has run once. That is the same trade the + // quota-attainment widget already takes; without this copy the user + // cannot tell it apart from a broken view. + emptyState: { + title: "This Quarter Has No Snapshots Yet", + message: "Quarterly snapshots are written by the nightly forecast sweep. Until it has run once for the current quarter this view is empty \u2014 settled quarters are on the All tab.", + icon: "calendar" + } + }, + my_forecast: { + name: "my_forecast", + type: "grid", + label: "My Forecast", + userActions: { editInline: true }, + data: { provider: "object", object: "crm_forecast" }, + columns: ["period_label", "snapshot_date", "quota", "closed_amount", "commit_amount", "pipeline_amount", "attainment_pct"], + // `{current_user_id}` is the only user token the view runtime resolves + // (`{current_user}` silently never matches). + filter: [{ field: "owner_id", operator: "equals", value: "{current_user_id}" }], + sort: [{ field: "period_start", order: "desc" }] + } + }, + form: { + type: "simple", + sections: [ + { + name: "snapshot", + label: "Snapshot", + columns: 2, + fields: ["owner_id", "period", "period_start", "period_end", "period_label", "snapshot_date", "source"] + }, + { + name: "amounts", + label: "Amounts", + columns: 2, + fields: ["quota", "closed_amount", "commit_amount", "best_case_amount", "pipeline_amount", "expected_amount", "attainment_pct", "coverage_ratio"] + }, + { + name: "notes", + label: "Notes", + columns: 1, + fields: ["notes"] + } + ] + } +}); + +// src/revenue/views/index.ts +var views_exports2 = {}; +__export(views_exports2, { + ContractViews: () => ContractViews, + ProductViews: () => ProductViews, + QuoteViews: () => QuoteViews +}); + +// src/revenue/views/contract.view.ts +import { defineView as defineView11 } from "@objectstack/spec/ui"; +var ContractViews = defineView11({ + list: { + type: "grid", + name: "all_contracts", + label: "All Contracts", + userActions: { editInline: true }, + data: { provider: "object", object: "crm_contract" }, + columns: [ + { field: "contract_number", width: 150, link: true, pinned: "left" }, + { field: "crm_account", width: 200 }, + { field: "crm_opportunity", width: 200 }, + { field: "status", width: 130, sortable: true }, + { field: "contract_value", width: 140, align: "right", summary: "sum" }, + { field: "contract_term_months", width: 130, align: "right" }, + { field: "start_date", width: 130, sortable: true }, + { field: "end_date", width: 130, sortable: true }, + { field: "auto_renewal", width: 110, align: "center" }, + { field: "owner_id", width: 150 } + ], + sort: [{ field: "end_date", order: "asc" }], + pagination: { pageSize: 25 }, + selection: { type: "multiple" }, + appearance: { + allowedVisualizations: ["grid", "calendar", "gantt", "timeline"] + }, + // Binds the 'calendar' entry above: renewal dates, same as the dedicated + // `renewal_calendar` view and the field this list sorts by. A contract + // calendar answers "what renews when" — the start -> end term SPAN is + // already carried by `contract_gantt` and `contract_timeline`, which is + // why `end_date` is the start of the event here rather than an end. + calendar: { + startDateField: "end_date", + titleField: "contract_number", + colorField: "status" + } + }, + listViews: { + /** Renewal calendar (highlights upcoming end dates) */ + renewal_calendar: { + name: "renewal_calendar", + type: "calendar", + label: "Renewal Calendar", + data: { provider: "object", object: "crm_contract" }, + columns: ["contract_number", "crm_account", "status"], + calendar: { + startDateField: "end_date", + titleField: "contract_number", + colorField: "status" + } + }, + /** Contract terms gantt */ + contract_gantt: { + name: "contract_gantt", + type: "gantt", + label: "Contract Terms", + data: { provider: "object", object: "crm_contract" }, + columns: ["contract_number", "crm_account", "contract_value"], + gantt: { + startDateField: "start_date", + endDateField: "end_date", + titleField: "contract_number" + } + }, + /** Chronological timeline */ + contract_timeline: { + name: "contract_timeline", + type: "timeline", + label: "Contract Timeline", + data: { provider: "object", object: "crm_contract" }, + columns: ["contract_number", "crm_account"], + timeline: { + startDateField: "start_date", + endDateField: "end_date", + titleField: "contract_number", + groupByField: "crm_account", + colorField: "status", + scale: "quarter" + } + } + }, + form: { + type: "tabbed", + sections: [ + { + name: "parties", + label: "Parties", + columns: 2, + fields: ["contract_number", "crm_account", "crm_contact", "crm_opportunity", "owner_id", "status"] + }, + { + // Named `contract_terms`, not `terms` — `terms` is already a distinct + // fieldGroup key on `crm_contract` ("Terms & Dates"), and reusing it + // here would make this section's translated heading follow that + // group's wording instead of its own "Terms". + name: "contract_terms", + label: "Terms", + columns: 2, + fields: [ + "contract_term_months", + "start_date", + "end_date", + "contract_value", + "billing_frequency", + "payment_terms", + "auto_renewal", + "renewal_notice_days" + ] + }, + { + name: "signing_and_documents", + label: "Signing & Documents", + columns: 2, + fields: ["signed_date", "signed_by", "document_url"] + }, + { + // The contract's two markdown bodies, together and in the order a + // reader needs them — the question #1826 asked this form to answer. + // They are not redundant, and `content/docs/revenue/contracts.mdx` + // already rules which is which: **Description** is the plain summary + // of what this contract is (declared on the `basic` group, listed + // there under "Contract Information"), while **Special Terms** is + // where every free-text TERM goes — the doc sends renewal + // instructions, an unlisted billing cadence and an unlisted payment + // arrangement to Special Terms by name, three separate times. + // Description was the one field in that inventory no form offered, so + // the summary a reader was told the record carries could not be + // written. One column, because both are long-form. + name: "notes", + label: "Notes", + columns: 1, + fields: ["description", "special_terms", "billing_address"] + } + ] + } +}); + +// src/revenue/views/product.view.ts +import { defineView as defineView12 } from "@objectstack/spec/ui"; +var ProductViews = defineView12({ + list: { + type: "grid", + name: "all_products", + label: "All Products", + userActions: { editInline: true }, + data: { provider: "object", object: "crm_product" }, + columns: [ + { field: "product_code", width: 140, link: true, pinned: "left" }, + { field: "name", width: 240, sortable: true }, + { field: "category", width: 140 }, + { field: "family", width: 140 }, + { field: "sku", width: 140 }, + { field: "list_price", width: 130, align: "right", summary: "avg" }, + { field: "cost", width: 130, align: "right" }, + { field: "is_active", width: 100, align: "center" } + ], + sort: [{ field: "name", order: "asc" }], + grouping: { fields: [{ field: "category", order: "asc" }] }, + pagination: { pageSize: 50 }, + selection: { type: "multiple" }, + appearance: { + allowedVisualizations: ["grid", "gallery"] + } + }, + listViews: { + /** Visual catalog */ + product_catalog: { + name: "product_catalog", + type: "gallery", + label: "Product Catalog", + data: { provider: "object", object: "crm_product" }, + columns: ["name", "category", "list_price"], + gallery: { + coverField: "image", + coverFit: "cover", + cardSize: "medium", + titleField: "name", + visibleFields: ["product_code", "category", "family", "list_price", "sku"] + } + } + }, + form: { + type: "simple", + sections: [ + { + name: "product_info", + label: "Product Info", + columns: 2, + fields: [ + "product_code", + { field: "name", required: true, span: "full" }, + "category", + "family", + "sku", + "product_manager", + "is_active" + ] + }, + { + name: "pricing_info", + label: "Pricing", + columns: 2, + fields: ["list_price", "cost"] + }, + { + name: "media", + label: "Media", + columns: 1, + fields: ["image", "datasheet", "description"] + } + ] + } +}); + +// src/revenue/views/quote.view.ts +import { defineView as defineView13 } from "@objectstack/spec/ui"; +var QuoteViews = defineView13({ + list: { + type: "grid", + name: "all_quotes", + label: "All Quotes", + userActions: { editInline: true }, + data: { provider: "object", object: "crm_quote" }, + columns: [ + { field: "quote_number", width: 140, link: true, pinned: "left" }, + { field: "crm_account", width: 200 }, + { field: "crm_opportunity", width: 200 }, + { field: "status", width: 130, sortable: true }, + { field: "quote_date", width: 130, sortable: true }, + { field: "expiration_date", width: 140, sortable: true }, + { field: "subtotal", width: 130, align: "right", summary: "sum" }, + { field: "discount", width: 110, align: "right" }, + { field: "tax", width: 110, align: "right", summary: "sum" }, + { field: "total_price", width: 140, align: "right", summary: "sum" }, + { field: "owner_id", width: 150 } + ], + sort: [{ field: "quote_date", order: "desc" }], + pagination: { pageSize: 25 }, + selection: { type: "multiple" }, + appearance: { + allowedVisualizations: ["grid", "kanban", "calendar"] + }, + // Binds the 'calendar' entry above: the same span the dedicated + // `quote_calendar` view shows. `quote_date` and `expiration_date` are both + // required + notNull on crm_quote, so every quote lands on a real window. + calendar: { + startDateField: "quote_date", + endDateField: "expiration_date", + titleField: "quote_number", + colorField: "status" + } + }, + listViews: { + /** Quote workflow board */ + quote_pipeline: { + name: "quote_pipeline", + type: "kanban", + label: "Quote Pipeline", + data: { provider: "object", object: "crm_quote" }, + columns: ["quote_number", "crm_account", "total_price", "expiration_date"], + kanban: { + groupByField: "status", + summarizeField: "total_price", + columns: ["quote_number", "crm_account", "total_price", "expiration_date"] + } + }, + /** Quote-date calendar */ + quote_calendar: { + name: "quote_calendar", + type: "calendar", + label: "Quote Calendar", + data: { provider: "object", object: "crm_quote" }, + columns: ["quote_number", "crm_account", "total_price"], + calendar: { + startDateField: "quote_date", + endDateField: "expiration_date", + titleField: "quote_number", + colorField: "status" + } + } + }, + form: { + type: "tabbed", + sections: [ + { + name: "quote", + label: "Quote", + columns: 2, + // `name` is required on crm_quote with no default — omitting it made + // quote creation through this form impossible. + fields: [{ field: "name", required: true, span: "full" }, "quote_number", "crm_account", "crm_contact", "crm_opportunity", "owner_id", "status", "quote_date", "expiration_date"] + }, + { + name: "totals", + label: "Totals", + columns: 2, + fields: ["subtotal", "discount", "discount_amount", "tax", "shipping_handling", "total_price"] + }, + { + // Named `quote_terms`, not `terms` — `terms` is already a distinct + // fieldGroup key on `crm_quote` ("Terms & Validity"), and reusing it + // here would make this section's translated heading follow that + // group's wording instead of its own "Terms". + name: "quote_terms", + label: "Terms", + columns: 2, + fields: ["payment_terms", "shipping_terms"] + }, + { + name: "addresses_and_notes", + label: "Addresses & Notes", + columns: 1, + fields: ["billing_address", "shipping_address", "internal_notes"] + } + ] + } +}); + +// src/marketing/views/index.ts +var views_exports3 = {}; +__export(views_exports3, { + CampaignViews: () => CampaignViews +}); + +// src/marketing/views/campaign.view.ts +import { defineView as defineView14 } from "@objectstack/spec/ui"; +var CampaignViews = defineView14({ + list: { + type: "grid", + name: "all_campaigns", + label: "All Campaigns", + userActions: { editInline: true }, + data: { provider: "object", object: "crm_campaign" }, + columns: [ + { field: "name", width: 240, sortable: true, link: true, pinned: "left" }, + { field: "channel", width: 130 }, + { field: "status", width: 130, sortable: true }, + { field: "start_date", width: 130, sortable: true }, + { field: "end_date", width: 130, sortable: true }, + { field: "budgeted_cost", width: 140, align: "right", summary: "sum" }, + { field: "expected_revenue", width: 160, align: "right", summary: "sum" } + ], + sort: [{ field: "start_date", order: "asc" }], + pagination: { pageSize: 25 }, + selection: { type: "multiple" }, + appearance: { + showDescription: true, + allowedVisualizations: ["grid", "gantt", "calendar", "timeline"] + }, + // Binds the 'calendar' entry above: the switcher opens the same schedule + // the dedicated `campaign_calendar` view shows. Both dates are required + + // notNull on crm_campaign, so every campaign spans a truthful range. + calendar: { + startDateField: "start_date", + endDateField: "end_date", + titleField: "name", + colorField: "channel" + } + }, + listViews: { + /** Campaign schedule */ + campaign_gantt: { + name: "campaign_gantt", + type: "gantt", + label: "Campaign Schedule", + data: { provider: "object", object: "crm_campaign" }, + columns: ["name", "channel"], + gantt: { + startDateField: "start_date", + endDateField: "end_date", + titleField: "name" + } + }, + /** Launch calendar */ + campaign_calendar: { + name: "campaign_calendar", + type: "calendar", + label: "Launch Calendar", + data: { provider: "object", object: "crm_campaign" }, + columns: ["name", "channel", "status"], + calendar: { + startDateField: "start_date", + endDateField: "end_date", + titleField: "name", + colorField: "channel" + } + }, + /** Marketing timeline */ + campaign_timeline: { + name: "campaign_timeline", + type: "timeline", + label: "Marketing Timeline", + data: { provider: "object", object: "crm_campaign" }, + // The list data source projects configured columns. Keep the date + // fields in that projection so the timeline renderer can bucket and + // order campaigns from the same schedule data as the calendar/Gantt. + columns: ["name", "channel", "start_date", "end_date"], + timeline: { + startDateField: "start_date", + endDateField: "end_date", + titleField: "name", + groupByField: "channel", + colorField: "status", + scale: "month" + } + } + }, + form: { + type: "tabbed", + sections: [ + { + // Every form section here carries a `name` matching the object's + // fieldGroup key, so the heading resolves through + // `objects.crm_campaign._sections..label` in all four packs. A + // nameless section has no key a bundle can carry and renders its + // English label in every locale — the platform warns about exactly this + // during `objectstack validate`, and this form was carrying four of + // those warnings before the #597 restructure gave it a reason to move. + name: "basic", + label: "Campaign Information", + columns: 2, + fields: [ + { field: "name", required: true, span: "full" }, + "campaign_code", + "type", + "channel", + { field: "status", required: true }, + "owner_id", + "is_active", + "landing_page_url", + // The markdown body of the campaign brief. Declared on the `basic` + // group and filled by seven of the seed campaigns, but omitted from + // this enumeration — so the only surface that could show it did not, + // and a marketer could neither read nor write the brief they wrote. + { field: "description", span: "full" } + ] + }, + { + name: "schedule", + label: "Schedule", + columns: 2, + fields: ["start_date", "end_date"] + }, + { + /** + * Budget & ROI — a SECTION OF ITS OWN, deliberately (#597). + * + * `budgeted_cost` and `actual_cost` are the only two campaign numbers + * that are manual-entry by design: nothing on the platform knows what a + * trade-show booth cost. They used to sit seventh and eighth in a + * seven-field "Schedule & Budget" row, below the dates and beside two + * revenue figures one of which the metric hooks own — so the two fields + * a marketer must type were the least visible things on the form, and + * `actual_cost` in particular went untyped. + * + * That is not a cosmetic complaint: `roi` divides by `actual_cost`, and + * its formula answers a flat `0.0` for any campaign where that field is + * blank. An empty cost field renders as 0% ROI on every campaign — the + * one number the whole Performance section exists to produce, reading + * as a real measurement rather than as missing input. + * + * So the costs get their own heading, and `roi` is displayed HERE with + * them rather than at the bottom of Performance, where its dependency + * on two fields three sections away was invisible. The heading matches + * the object's `budget` fieldGroup, so the form and the detail page + * agree on what this group is called. + */ + name: "budget", + label: "Budget & ROI", + columns: 2, + fields: ["budgeted_cost", "actual_cost", "expected_revenue", "actual_revenue", "roi"] + }, + { + name: "metrics", + label: "Performance", + columns: 2, + fields: [ + "target_size", + "num_sent", + "num_responses", + "num_leads", + "num_converted_leads", + "num_opportunities", + "num_won_opportunities", + "response_rate" + ] + } + ] + } +}); + +// src/sales/pages/index.ts +var pages_exports = {}; +__export(pages_exports, { + AccountDetailPage: () => AccountDetailPage, + AccountWorkbenchPage: () => AccountWorkbenchPage, + AppLauncherPage: () => AppLauncherPage, + LeadDetailPage: () => LeadDetailPage, + OpportunityDetailPage: () => OpportunityDetailPage, + SalesHomePage: () => SalesHomePage, + UtilityBarPage: () => UtilityBarPage +}); + +// src/sales/pages/lead_detail.page.ts +import { P as P25 } from "@objectstack/spec"; +var LeadDetailPage = { + name: "lead_detail_page", + label: "Lead Detail", + description: "Comprehensive lead detail page with highlights, details, and related information", + type: "record", + object: "crm_lead", + // Template defines the overall layout structure. We use `full-width` + // (single column) because the previous `header-sidebar-main` layout + // sandwiched the highlights strip into a cramped sidebar with no other + // meaningful sidebar content — Salesforce Lightning record pages + // similarly default to a stacked column for medium-density objects. + template: "full-width", + kind: "full", + // Page-level state variables + variables: [ + { + name: "showHistory", + type: "boolean", + defaultValue: false + }, + { + name: "activeTab", + type: "string", + defaultValue: "details" + } + ], + // Regions correspond to slots in the template + regions: [ + { + name: "header", + width: "full", + components: [ + // Title + subtitle + icon, with record-level actions rendered + // inline in the header's action slot via the first-class + // `actions` property (no sibling node, no visual offset hack). + { + type: "page:header", + id: "lead_header", + label: "Lead Information", + properties: { + title: "{first_name} {last_name}", + subtitle: "{company}", + // `icon` removed from `page:header` in @objectstack/spec 17.0.0 + // (#6946, ADR-0087 D2) — deleted, not renamed. See the full note on + // `account_detail.page.ts`; nothing ever drew it. + // `breadcrumb` retired from `page:header` in @objectstack/spec 17.6.0 + // (#20785, `page-header-breadcrumb-removed`) — deleted: no renderer + // ever drew a trail for it; the app shell's own trail is unchanged. + // Convert is the outcome; scheduling the next touch is the daily + // act. Both belong in the header — the follow-up used to be four + // clicks deep in the Related tab. + // + // The three activity actions are listed EXPLICITLY (#592): a custom + // record page replaces the synthesized header, so an object-scoped + // action that is not named here is unreachable from the record — + // only the list-row ⋮ menu can fire it. Logging the call you just + // made is the single most frequent thing a rep does on a lead, and + // it was two navigations away. + // + // Action IDs, not `ActionDef` objects: `PageHeaderProps.actions` is + // `z.array(z.string())` ("Action IDs to show in header") in + // @objectstack/spec 17.3.0, and this repo authors against the + // protocol (#1653). Each id is the `name` of a crm_lead-scoped + // action — `convert_lead` / `schedule_followup` in + // `src/sales/actions/lead.actions.ts`, the activity trio in + // `src/sales/actions/activity-actions.ts`. + actions: [ + "convert_lead", + "schedule_followup", + "log_call", + "log_meeting", + "schedule_meeting" + ] + } + }, + // Duplicate banners — ONE PER VERDICT (#1207 · widened by #1289 · + // split by #1628). + // + // `lead_duplicate_check` (lead.hook.ts, job 2) already writes + // `duplicate_status: 'suspected'` and links the record the lead repeats + // — the flag existed, and this page never read it. A rep opened a + // flagged lead, saw a page identical to a clean one, and converted it + // into a second account, contact and opportunity. These banners and the + // `duplicates` section on the Details tab are the record-page half of + // that fix — the banner is the alarm, the section is the link to + // compare against; the conversion screen carries the other half. + // + // ## Why there are TWO of them (#1628) + // + // #1207 shipped one banner gated on `== "suspected"`, which left the + // STRONGER state silent. #1289 widened the predicate to every verdict + // and, being one component, had to pick copy that named NEITHER state: + // a `record:alert` carries a single `visible` and a single title/body + // pair, and `pickLocalized` picks by LANGUAGE, not by row — so naming + // one verdict would have mislabelled every lead in the other. + // + // That was correct for one banner, and it is why one banner is not + // enough. Since #1288 the two verdicts have OPPOSITE next steps: + // + // suspected — the intake hook's guess. Conversion PROCEEDS; the rep + // should compare against the linked record first. + // confirmed — a reviewer's verdict. Conversion is REFUSED outright + // (`lead-conversion.flow.ts`, `refuse_confirmed_duplicate`). + // + // One sentence cannot state either without being false for the other, + // so it stated neither, and the rep had to scroll to the Duplicate + // Status chip to learn which situation they were in. A banner that + // announces something is wrong but not what to do is not doing the one + // job a banner has. Two components, two predicates, two next steps. + // + // ⚠️ Two sibling `record:alert` nodes really do BOTH render: a region + // renders as `components.map((node, i) => )` — read out of the shipped console bundle at the + // `.objectui-sha` pin — so each is mounted separately and evaluates its + // own `visible` against the same row. Their `id`s are their React keys, + // which is why the two ids differ rather than sharing one. + // + // ⚠️ `visible` is the ONE record component whose PROPS carry a real row + // predicate: `record-alert.tsx` evaluates `properties.visible` through + // `toPredicateInput` + `useCondition` against the row + // (`usePredicateRecordContext`), the same pipeline as an action button. + // A node-level `visibleWhen` is a different gate one tier up, + // evaluated by `SchemaRenderer`, and the two compose as AND. Measured + // on the 17.6.0 pin (#1887), that tier binds the page's row as + // `record` too (objectui#5454): this same predicate, moved there, + // gated correctly in both directions. `visible` stays because it is + // the gate `record:alert` declares in its own props. + // + // ⚠️ `has()` is load-bearing, and this surface is the WORST of the four + // this repo measures (cf. `test/view-predicate-dialect.test.ts`): the + // renderer's call site is FAIL-SOFT — an unevaluable predicate answers + // SHOWN. So a bare `record.duplicate_status == "suspected"` would abort + // with `No such key` on every clean lead whose driver omits the column + // (`driver-memory` / `driver-mongodb`; `driver-sql` returns it as null) + // and put a duplicate warning on leads that are not duplicates. The + // guard is what makes the predicate answer `false` instead of faulting. + // Pinned on the real engine in `test/lead-duplicate-visibility.test.ts`. + // + // ⛔ And the guard is NOT the whole predicate — `has()` ALONE is wrong + // here, in either shape. It is TRUE for a key that is PRESENT AND NULL, + // which is precisely what `driver-sql` hands back for a clean lead + // (measured: `has(record.duplicate_status)` against + // `{ duplicate_status: null }` answers `{ ok: true, value: true }`), so + // the guard needs a comparison beside it or the banner cries wolf on + // every clean lead. #1289, covering both verdicts at once, spelled that + // comparison `&& … != null`. A per-verdict banner spells it with the + // EQUALITY, which is strictly narrower and subsumes it: measured on + // this engine, `null == "suspected"` is a clean `false`, not a fault, + // and the two spellings agree on every record shape a driver can + // produce. Both halves of the shape #1289 ruled for are intact — the + // `has()` guard verbatim, and a comparison that makes "set" mean set — + // and the comparison got STRICTER, which is the point of the split. The + // same spelling already ships one file over, on this same field: the + // conversion flow's `e21` / `e25` edges (#1288) read + // `has(vars.leadRecord.duplicate_status) && … == "suspected"`. + // + // ⛔ Neither half may be simplified away. Both are pinned, shape by + // shape, including the reverse pin that the unguarded tail really does + // fault. + // + // `P` — an explicit `{ dialect: 'cel' }` envelope — is not decoration + // either: `ExpressionEvaluator.evaluateCondition` routes ONLY the + // envelope to `@objectstack/formula`'s CEL engine, where `has()` is a + // real function; a bare string takes the legacy JS path, whose + // `FormulaFunctions` has no CEL `has()`, so the guard would itself be + // the fault that fails soft to visible. + // + // `title` / `body` carry inline locale maps rather than plain strings: + // this renderer resolves both through `pickLocalized(…, language)` + // (the same capability `opportunity_detail.page.ts` records under + // #972), and `body` has no other channel — the i18n extractor's + // per-component copy keys (`PAGE_COMPONENT_COPY_KEYS`, read on 17.6.0) + // are title/description/label/placeholder/emptyText, so a plain-string + // `body` would ship English to all four locales. Keeping both halves of one banner's copy in one + // place beats splitting `title` into the locale packs. + // + // ⭐ Each banner's copy NAMES ITS OWN VERDICT, in the vocabulary the + // `duplicate_status` chip below publishes, and never the other one — + // pinned against the option labels read out of the locale packs in + // `test/lead-duplicate-visibility.test.ts`, so renaming an option + // re-aims the assertion rather than retiring it. + { + type: "record:alert", + id: "lead_duplicate_alert_suspected", + label: "Suspected Duplicate Alert", + properties: { + // `warning`, not `error`: conversion still PROCEEDS on this + // verdict, and the renderer maps `error` to `role="alert"` / + // `aria-live="assertive"` — an interruption this state has not + // earned. + severity: "warning", + visible: P25`has(record.duplicate_status) && record.duplicate_status == "suspected"`, + title: { + en: "Suspected duplicate \u2014 compare before you convert", + "zh-CN": "\u7591\u4F3C\u91CD\u590D\u2014\u2014\u8F6C\u6362\u524D\u8BF7\u5148\u6BD4\u5BF9", + "ja-JP": "\u91CD\u8907\u306E\u7591\u3044 \u2014 \u5909\u63DB\u3059\u308B\u524D\u306B\u7167\u5408\u3057\u3066\u304F\u3060\u3055\u3044", + "es-ES": "Duplicado Sospechoso: compare antes de convertir" + }, + body: { + en: "Intake matched this lead to a record this app already has. Duplicate Management below links that record \u2014 open it and compare. You can still convert this lead: this is the match intake guessed at, not a reviewer's decision. But if it is the same buyer, disqualify it instead, because converting creates a second account, contact and opportunity for them.", + "zh-CN": "\u5F55\u5165\u65F6\u53D1\u73B0\u8BE5\u7EBF\u7D22\u4E0E\u7CFB\u7EDF\u4E2D\u5DF2\u6709\u8BB0\u5F55\u5339\u914D\u3002\u4E0B\u65B9\u300C\u91CD\u590D\u7EBF\u7D22\u7BA1\u7406\u300D\u4E2D\u662F\u5B83\u91CD\u590D\u7684\u90A3\u6761\u8BB0\u5F55\uFF0C\u8BF7\u5148\u6253\u5F00\u6BD4\u5BF9\u3002\u8BE5\u7EBF\u7D22\u4ECD\u7136\u53EF\u4EE5\u8F6C\u6362\uFF1A\u8FD9\u662F\u5F55\u5165\u65F6\u7684\u81EA\u52A8\u5224\u65AD\uFF0C\u4E0D\u662F\u5BA1\u6838\u4EBA\u7684\u7ED3\u8BBA\u3002\u4F46\u82E5\u786E\u5C5E\u540C\u4E00\u5BA2\u6237\uFF0C\u8BF7\u6539\u4E3A\u53D6\u6D88\u8D44\u683C\u2014\u2014\u8F6C\u6362\u4F1A\u4E3A\u540C\u4E00\u5BA2\u6237\u518D\u521B\u5EFA\u4E00\u5957\u5BA2\u6237\u3001\u8054\u7CFB\u4EBA\u548C\u5546\u673A\u3002", + "ja-JP": "\u767B\u9332\u6642\u306B\u3001\u3053\u306E\u30EA\u30FC\u30C9\u304C\u65E2\u5B58\u30EC\u30B3\u30FC\u30C9\u3068\u4E00\u81F4\u3057\u307E\u3057\u305F\u3002\u4E0B\u306E\u300C\u91CD\u8907\u7BA1\u7406\u300D\u306B\u91CD\u8907\u5148\u306E\u30EC\u30B3\u30FC\u30C9\u304C\u3042\u308A\u307E\u3059\u3002\u307E\u305A\u958B\u3044\u3066\u7167\u5408\u3057\u3066\u304F\u3060\u3055\u3044\u3002\u3053\u306E\u30EA\u30FC\u30C9\u306F\u307E\u3060\u5909\u63DB\u3067\u304D\u307E\u3059\u3002\u3053\u308C\u306F\u767B\u9332\u6642\u306E\u81EA\u52D5\u5224\u5B9A\u3067\u3042\u308A\u3001\u62C5\u5F53\u8005\u306E\u7D50\u8AD6\u3067\u306F\u3042\u308A\u307E\u305B\u3093\u3002\u305F\u3060\u3057\u540C\u3058\u76F8\u624B\u3067\u3042\u308C\u3070\u3001\u5909\u63DB\u305B\u305A\u4E0D\u9069\u683C\u306B\u3057\u3066\u304F\u3060\u3055\u3044\u3002\u5909\u63DB\u3059\u308B\u3068\u540C\u3058\u76F8\u624B\u306B\u53D6\u5F15\u5148\u30FB\u53D6\u5F15\u5148\u8CAC\u4EFB\u8005\u30FB\u5546\u8AC7\u304C\u3082\u3046\u4E00\u7D44\u4F5C\u6210\u3055\u308C\u307E\u3059\u3002", + "es-ES": "La captura encontr\xF3 que este prospecto coincide con un registro que ya existe. Gesti\xF3n de Duplicados, m\xE1s abajo, enlaza ese registro: \xE1bralo y comp\xE1relo. Todav\xEDa puede convertir este prospecto, porque se trata de una coincidencia autom\xE1tica de la captura y no del veredicto de una persona. Pero si es el mismo comprador, descalif\xEDquelo en su lugar: convertirlo crea una segunda cuenta, contacto y oportunidad para \xE9l." + } + } + }, + { + type: "record:alert", + id: "lead_duplicate_alert_confirmed", + label: "Confirmed Duplicate Alert", + properties: { + // `error`, and the level is the message: this is the state on which + // the app REFUSES the rep's next click, and the renderer gives + // `error` `role="alert"` / `aria-live="assertive"` rather than the + // polite `role="status"` every other level gets. ⛔ The severity is + // presentation only — what the app refuses was ruled by #1288 and + // shipped by PR #1555, and nothing here changes it. + severity: "error", + visible: P25`has(record.duplicate_status) && record.duplicate_status == "confirmed"`, + title: { + en: "Confirmed duplicate \u2014 conversion will be refused", + "zh-CN": "\u5DF2\u786E\u8BA4\u91CD\u590D\u2014\u2014\u8F6C\u6362\u5C06\u88AB\u62D2\u7EDD", + "ja-JP": "\u91CD\u8907\u78BA\u5B9A \u2014 \u5909\u63DB\u306F\u62D2\u5426\u3055\u308C\u307E\u3059", + "es-ES": "Duplicado Confirmado: la conversi\xF3n ser\xE1 rechazada" + }, + body: { + // ⭐ The only place a rep learns the Convert button will refuse + // them BEFORE they press it — until this banner, the refusal + // dialog was the first they heard of it. + en: "A reviewer checked this lead and recorded that it repeats a record this app already has, so Convert Lead refuses it \u2014 this banner is the only warning you get before you press the button. Disqualify this lead instead, naming the surviving record from Duplicate Management below. If the verdict is wrong, a reviewer revises Duplicate Status; there is no override here.", + "zh-CN": "\u5BA1\u6838\u4EBA\u5DF2\u6838\u5B9E\u8BE5\u7EBF\u7D22\u4E0E\u7CFB\u7EDF\u4E2D\u5DF2\u6709\u8BB0\u5F55\u91CD\u590D\uFF0C\u56E0\u6B64\u300C\u8F6C\u6362\u7EBF\u7D22\u300D\u4F1A\u62D2\u7EDD\u6267\u884C\u2014\u2014\u672C\u63D0\u793A\u662F\u4F60\u6309\u4E0B\u6309\u94AE\u524D\u552F\u4E00\u7684\u9884\u8B66\u3002\u8BF7\u6539\u4E3A\u53D6\u6D88\u8BE5\u7EBF\u7D22\u7684\u8D44\u683C\uFF0C\u5E76\u5728\u4E0B\u65B9\u300C\u91CD\u590D\u7EBF\u7D22\u7BA1\u7406\u300D\u4E2D\u6CE8\u660E\u4FDD\u7559\u7684\u90A3\u6761\u8BB0\u5F55\u3002\u82E5\u5224\u5B9A\u6709\u8BEF\uFF0C\u5E94\u7531\u5BA1\u6838\u4EBA\u4FEE\u6539\u300C\u91CD\u590D\u72B6\u6001\u300D\uFF0C\u6B64\u5904\u4E0D\u63D0\u4F9B\u5F3A\u5236\u8F6C\u6362\u7684\u5165\u53E3\u3002", + "ja-JP": "\u62C5\u5F53\u8005\u304C\u78BA\u8A8D\u3057\u3001\u3053\u306E\u30EA\u30FC\u30C9\u306F\u65E2\u5B58\u30EC\u30B3\u30FC\u30C9\u306E\u91CD\u8907\u3067\u3042\u308B\u3068\u8A18\u9332\u3055\u308C\u307E\u3057\u305F\u3002\u305D\u306E\u305F\u3081\u300C\u30EA\u30FC\u30C9\u5909\u63DB\u300D\u306F\u62D2\u5426\u3055\u308C\u307E\u3059\u3002\u3053\u306E\u901A\u77E5\u304C\u3001\u30DC\u30BF\u30F3\u3092\u62BC\u3059\u524D\u306B\u5F97\u3089\u308C\u308B\u552F\u4E00\u306E\u8B66\u544A\u3067\u3059\u3002\u3053\u306E\u30EA\u30FC\u30C9\u306F\u4E0D\u9069\u683C\u306B\u3057\u305F\u3046\u3048\u3067\u3001\u4E0B\u306E\u300C\u91CD\u8907\u7BA1\u7406\u300D\u3067\u6B8B\u3059\u30EC\u30B3\u30FC\u30C9\u3092\u660E\u8A18\u3057\u3066\u304F\u3060\u3055\u3044\u3002\u5224\u5B9A\u304C\u8AA4\u3063\u3066\u3044\u308B\u5834\u5408\u306F\u62C5\u5F53\u8005\u304C\u300C\u91CD\u8907\u30B9\u30C6\u30FC\u30BF\u30B9\u300D\u3092\u4FEE\u6B63\u3057\u307E\u3059\u3002\u3053\u3053\u306B\u5F37\u5236\u5909\u63DB\u306E\u624B\u6BB5\u306F\u3042\u308A\u307E\u305B\u3093\u3002", + "es-ES": "Una persona verific\xF3 que este prospecto repite un registro que ya existe, por lo que Convertir Prospecto lo rechazar\xE1: este aviso es la \xFAnica advertencia antes de pulsar el bot\xF3n. Descalifique el prospecto e indique el registro que sobrevive desde Gesti\xF3n de Duplicados, m\xE1s abajo. Si el veredicto es incorrecto, una persona debe cambiar el Estado del Duplicado; aqu\xED no hay forma de forzar la conversi\xF3n." + } + } + }, + // Salesforce-style Highlights Panel: a horizontal strip of the + // most-important key facts directly under the header. Pulled out + // of the sidebar so it can use the full page width. + { + type: "record:highlights", + id: "lead_highlights", + label: "Key Information", + properties: { + fields: ["status", "rating", "lead_source", "owner_id", "email", "phone"] + } + }, + { + type: "record:path", + id: "lead_path", + label: "Lead Status Path", + properties: { + statusField: "status", + // `converted` is the terminal WIN state and must be on the path — + // without it the strip reads as if "Unqualified" were the goal, and + // a converted lead had no stage to light up at all. + stages: [ + { value: "new", label: "New" }, + { value: "contacted", label: "Contacted" }, + { value: "qualified", label: "Qualified" }, + { value: "converted", label: "Converted" }, + { value: "unqualified", label: "Unqualified" } + ] + } + } + ] + }, + { + name: "main", + width: "large", + components: [ + { + type: "page:tabs", + id: "main_tabs", + label: "Lead Information Tabs", + properties: { + // `type` → `tabStyle` (@objectstack/spec 17.0.0, #6776, ADR-0087 + // D2). Same three values; see the full note on `home.page.ts`. + tabStyle: "line", + position: "top", + items: [ + { + label: "Details", + icon: "info-circle", + children: [ + { + type: "record:details", + id: "lead_details", + label: "Lead Details", + properties: { + columns: "2", + // `layout` was REMOVED from `record:details` in + // @objectstack/spec 17.0.0 (#6946, ADR-0087 D2) and is + // deleted with no successor: its `auto` | `custom` + // semantics were never implemented. + // + // Every section is a GROUP REFERENCE (#806, maintainer + // ruling C, decision batch #21, 2026-09-03). `{ group }` + // names one of crm_lead's `fieldGroups`, and the renderer + // derives that section's members, label, icon and collapse + // state from the object (`deriveFieldGroupLayout`, + // ADR-0085 §5). Membership has ONE declaration site — the + // `group:` on each field in lead.object.ts — and this page + // curates only the ORDER, so a field added to a group shows + // up here with no edit to this file. ⛔ Do not enumerate + // `fields:` again, and do not restate a key the group owns + // (`name` / `label` / `icon` / `collapsible` / + // `defaultCollapsed`) beside `group`: the spec refuses both. + // + // ⛔ `sections` stays load-bearing. Omitting it renders an + // EMPTY Details tab, not a `fieldGroups` fallback (#806 R28 + // on 17.2.0, #1521); derivation is per section, through + // `group:`, never page-level. + // + // Measured on @objectstack/console 17.6.0 (#806 R70, + // headless Chromium, with a control leg; on 17.4.0 R61 + // measured this form crashing the component). What a + // group section does there is the renderer's, not ours: + // - it lays out its own column count (the page-level + // `columns` above does not reach it); + // - a group whose members are all empty renders nothing + // (`duplicates` on a clean lead), unless the section + // says `hideEmpty: false`; + // - members the highlights strip registered are dropped, + // so `assignment` (only `owner_id`) renders nothing on + // this page — the owner is in the strip; + // - a group declared `collapse: 'collapsed'` starts + // collapsed; changing that is a `fieldGroups` decision + // in lead.object.ts, not a key on this page. + // + // `hideEmpty: false` (#2003, the #1211 reasoning) sits on + // the groups whose every member a rep types and the + // create form asks for: `contact_info` (`mobile` and + // `website` once the strip takes `email` and `phone`), + // `address`, and `additional` (revenue, headcount, + // description, notes). Without it all three vanish on a + // fresh lead, so a rep cannot see what is left to fill. + // Not on `assignment`: its derived list is empty, and the + // renderer draws nothing for an empty list whatever + // `hideEmpty` says. Not on `duplicates`: the + // `lead_duplicate_check` hook writes it. + sections: [ + { group: "identity" }, + { group: "company_info" }, + { group: "contact_info", hideEmpty: false }, + // Do Not Call / Email Opt Out, right under the numbers + // a rep is about to dial (#806). + { group: "preferences" }, + { group: "qualification" }, + { group: "assignment" }, + { group: "address", hideEmpty: false }, + { group: "conversion" }, + // The LINK half of the duplicate banners (#1207): the + // group carries both survivor lookups, because + // `lead_duplicate_check` matches contacts before leads. + // On a clean lead every member is empty, so the section + // renders nothing. ⚠️ Not the highlights strip: + // `record:highlights` caps `fields` at 7 and holds 6. + { group: "duplicates" }, + // Description and Notes — kept last, where the page's + // Description section always sat. + { group: "additional", hideEmpty: false } + ] + } + } + ] + }, + { + label: "Related", + icon: "link", + children: [ + { + type: "page:accordion", + id: "related_accordion", + label: "Related Records", + properties: { + allowMultiple: true, + items: [ + { + label: "Tasks", + icon: "list-checks", + collapsed: false, + children: [ + { + type: "record:related_list", + id: "related_tasks", + label: "Tasks", + properties: { + objectName: "crm_task", + // crm_task links back through the polymorphic + // `related_to_lead` lookup; there is no `lead_id` + // column, so the old binding matched nothing and + // this list read "0" no matter how many follow-ups + // the rep had filed. + relationshipField: "related_to_lead", + columns: ["subject", "status", "priority", "due_date", "owner_id"], + sort: [ + { field: "due_date", order: "asc" } + ], + limit: 10, + title: "Open Tasks", + filter: [{ field: "status", operator: "not_equals", value: "completed" }], + showViewAll: true + } + } + ] + } + ] + } + } + ] + }, + { + label: "Activity", + icon: "clock", + children: [ + { + type: "record:activity", + id: "lead_activity", + label: "Activity Timeline", + properties: { + // `types` is keyed on FEED ITEM KIND, never on object name + // (#1209). The old `['crm_task']` was not one of the kinds + // the prop accepts, and nothing anywhere enforced that: the + // page schema's `properties` is an open bag + // (`z.record(z.string(), z.unknown())`) so the value was + // stored verbatim, and the renderer's own sanitiser drops + // members it does not recognise and then reads the EMPTY + // remainder as "no filter authored" — measured on the + // shipped bundle, `types: ['crm_task']`, `types: []` and + // omitting `types` all render the same unfiltered stream. + // That is why the tab showed `Created Lead` / `Updated + // Lead` audit rows, which the History tab already covers. + // + // What this component can actually show is `sys_activity` + // scoped to the record, through the renderer's own + // type map — measured, not inferred: + // + // sys_activity.type feed kind written by + // created/updated/… field_change platform audit + // system system platform + // completed task log_call / + // log_meeting / + // send_email + // scheduled (dropped) schedule_meeting + // + // So `task` is the kind that carries a rep's logged + // interactions, and it is the only reachable one worth + // filtering to. `event` is NOT added: it is a legal kind + // the prop accepts but no `sys_activity.type` maps to it, + // so it would be a declared value enforced by nothing. + // `scheduled` rows fall out of the map upstream — a + // platform gap, not something to work around here. + types: ["task"], + limit: 20, + // Load-bearing, not cosmetic: the renderer strips every + // `task` item BEFORE the `types` filter runs unless this is + // true, and `task` items are exactly the `completed` rows. + // `types: ['task']` with the old `showCompleted: false` + // renders an empty tab. + showCompleted: true + } + } + ] + }, + { + label: "History", + icon: "history", + children: [ + { + // `record:history` is the platform's own audit feed over the + // fields marked `trackHistory` (status / rating). Ownership + // moved to the platform's `owner_id` in #548, which carries no + // `trackHistory` flag — transfers land in the compliance audit + // log, not on this feed. + // The hand-rolled version queried an object named + // `field_history`, which this app does not define, so the + // tab could only ever render empty. + type: "record:history", + id: "lead_history", + label: "Field History", + properties: { + limit: 25 + } + } + ] + } + ] + } + } + ] + } + ], + // Make this the default page for leads + isDefault: true, + // ARIA accessibility + aria: { + ariaLabel: "Lead Detail Page", + ariaDescribedBy: "Detailed view of lead information with related records and activity" + } +}; + +// src/sales/pages/opportunity_detail.page.ts +var OpportunityDetailPage = { + name: "opportunity_detail_page", + label: "Opportunity Detail", + description: "Comprehensive opportunity detail page with path, highlights, details, and related lists", + type: "record", + object: "crm_opportunity", + template: "full-width", + kind: "full", + variables: [ + { name: "activeTab", type: "string", defaultValue: "details" } + ], + regions: [ + { + name: "header", + width: "full", + components: [ + { + type: "page:header", + id: "opp_header", + label: "Opportunity Information", + properties: { + title: "{name}", + // The lookup field is `crm_account` — `{account}` matched nothing + // and the subtitle rendered blank. + subtitle: "{crm_account}", + // `icon` removed from `page:header` in @objectstack/spec 17.0.0 + // (#6946, ADR-0087 D2) — deleted, not renamed. See the full note on + // `account_detail.page.ts`; nothing ever drew it. + // `breadcrumb` retired from `page:header` in @objectstack/spec 17.6.0 + // (#20785, `page-header-breadcrumb-removed`) — deleted: no renderer + // ever drew a trail for it; the app shell's own trail is unchanged. + // generate_quote is the CPQ entry point (opportunity → quote); a + // custom record page replaces the default header, so the action + // must be listed here explicitly or it is unreachable. The same + // sentence is why the three activity actions are named here (#592): + // without them a rep can log a call on the deal only from the list + // row's ⋮ menu, never from the deal itself. + // + // Action IDs, not `ActionDef` objects: `PageHeaderProps.actions` is + // `z.array(z.string())` ("Action IDs to show in header") in + // @objectstack/spec 17.3.0, and this repo authors against the + // protocol (#1653). Each id is the `name` of a + // crm_opportunity-scoped action — `generate_quote` / + // `clone_opportunity` in `src/sales/actions/opportunity.actions.ts`, the + // activity trio in `src/sales/actions/activity-actions.ts`. + actions: [ + "generate_quote", + "clone_opportunity", + "log_call", + "log_meeting", + "schedule_meeting" + ] + } + }, + { + type: "record:highlights", + id: "opp_highlights", + label: "Key Information", + properties: { + fields: ["amount", "close_date", "probability", "expected_revenue", "owner_id", "crm_account"] + } + }, + { + type: "record:path", + id: "opp_stage_path", + label: "Opportunity Stage Path", + properties: { + statusField: "stage", + // Every canonical value of `stage` must appear here, in funnel + // order — the path is the only place a rep reads "where is this + // deal". `needs_analysis` was missing, so a deal sitting in that + // stage lit up NO step at all and the strip read as if the deal + // had skipped from Qualification to Proposal. The two terminal + // stages stay last (won before lost), matching lead_detail's + // converted/unqualified tail. + stages: [ + { value: "prospecting", label: "Prospecting" }, + { value: "qualification", label: "Qualification" }, + { value: "needs_analysis", label: "Needs Analysis" }, + { value: "proposal", label: "Proposal" }, + { value: "negotiation", label: "Negotiation" }, + { value: "closed_won", label: "Closed Won" }, + { value: "closed_lost", label: "Closed Lost" } + ] + } + } + ] + }, + { + name: "main", + width: "large", + components: [ + { + type: "page:tabs", + id: "opp_main_tabs", + properties: { + // `type` → `tabStyle` (@objectstack/spec 17.0.0, #6776, ADR-0087 + // D2). Same three values; see the full note on `home.page.ts`. + tabStyle: "line", + position: "top", + items: [ + { + // Tab item `key` → `value` (#1269): `value` is the stable + // `?tab=` URL token the renderer reads, `key` is read by + // nothing. See the full note on `case_detail.page.ts`. + value: "details", + label: "Details", + children: [ + { + type: "record:details", + id: "opp_details", + label: "Opportunity Details", + properties: { + // `columns` is a STRING enum ('1'|'2'|'3'|'4') in + // @objectstack/spec 17. `layout` is gone (removed in spec + // 17.0.0, #6946 / ADR-0087 D2). + columns: "2", + // Every section references one of crm_opportunity's + // `fieldGroups` (#1452, the #806 class ruling C): the + // renderer derives members, label, icon and collapse state + // from the object, so this page curates only the order. + // The full note — what a group section does on 17.6.0 and + // what may not sit beside `group` — is on + // `lead_detail.page.ts`. + // + // The highlights strip still wins (#1211): the renderer + // drops every field `record:highlights` registered, and the + // record title, from the derived members. So `basic` shows + // `primary_contact` only, and `financials` (`amount`, + // `expected_revenue`, both in the strip) renders nothing + // here — it stays referenced so that a field added to the + // group reaches this tab without an edit to this file. + // + // `hideEmpty: false` keeps an ALL-empty section on screen + // (#1211). The platform default (objectui#8603 ruling A) + // renders such a section as nothing at all, so on a deal + // with only its required fields the deal's type and + // source (`classification`), its campaign (`campaign`) + // and its description and next step (`notes`) vanished — + // the very fields a seller fills in later. Kept, they + // show as labelled empty rows to fill. Measured on + // 17.6.0 on such a deal: 2 sections render without it, 5 + // with it. Not on `basic` (its only member outside the + // title and the strip is `primary_contact`), nor on + // `financials`: both members sit in the strip, the + // derived list is empty, and the renderer draws nothing + // for an empty list whatever `hideEmpty` says. + // + // `qualification` and `narrative` (REQ-0006) sit right + // after `sales_process`, the order the object declares + // them in, and both keep `hideEmpty: false` on the same + // reasoning: every member is a judgement or a piece of + // prose the seller is expected to write (bid / no-bid, + // controllability, priority, deal level, subcontracting; + // the four narrative fields), none sits in the strip, and + // no deal that predates REQ-0006 carries any of them — so + // without the key both sections vanish on every existing + // deal, which is exactly where a seller would fill them. + sections: [ + { group: "basic" }, + { group: "financials" }, + { group: "classification", hideEmpty: false }, + { group: "campaign", hideEmpty: false }, + { group: "sales_process" }, + { group: "qualification", hideEmpty: false }, + { group: "narrative", hideEmpty: false }, + { group: "crm_forecast" }, + { group: "notes", hideEmpty: false } + ] + } + } + ] + }, + { + value: "related", + label: "Related", + children: [ + { + type: "page:accordion", + id: "opp_related_accordion", + properties: { + items: [ + { + // Accordion item `key` is DELETED, not renamed to + // `value` — the opposite verdict to the tab items + // above, because this renderer overwrites `value` with + // `panel-`. See the full note on + // `case_detail.page.ts`. + label: "Quotes", + // OPEN on arrival (#1214 item 6). All three panels + // used to start shut, so the Related tab opened on + // three closed bars whose headers already carried the + // counts — the click bought the user nothing the page + // had not already told them. + // + // `collapsed: false` is the whole mechanism, and it is + // needed even though the schema DEFAULTS it to false: + // the renderer opens the panels it finds by strict + // identity — `items.filter(i => i.collapsed === false)` + // — so an item that simply omits the key is + // `undefined`, not `false`, and stays shut. Measured + // on the @objectstack/console 17.3.0 bundle — the pin + // at that taking, ⛔ NOT re-taken on 17.4.0 + // (#1814, #1807) or 17.5.0 — + // and the component's own designer text says the same + // ("collapsed: false opens a panel by default"). + // + // ⚠️ ONLY the first panel, and that is the renderer's + // choice rather than a preference: with `allowMultiple` + // absent (it defaults false) the accordion mounts as + // `type="single"` and takes `defaultValue={open[0]}` — + // one panel, the first in declaration order. Marking + // Products or Open Tasks too would change nothing on + // screen. Opening more than one means declaring + // `allowMultiple: true`, which changes the interaction + // model (panels stop closing each other) and is not + // this card's ask. + // + // ⛔ NOT "default-open the sections that have rows", + // which the card asked for first: that is not + // expressible here. `collapsed` is a static boolean on + // a strict item shape (`label` / `icon` / `collapsed` / + // `children` — nothing else parses), the page is + // authored metadata evaluated before any row is read, + // and the related lists below fetch their own rows + // after mount. Reported rather than worked around; ⛔ + // the component is not this repo's to change. + collapsed: false, + children: [ + { + type: "record:related_list", + id: "opp_quotes", + properties: { + objectName: "crm_quote", + relationshipField: "crm_opportunity", + columns: ["quote_number", "name", "status", "total_price", "expiration_date"], + limit: 10 + } + } + ] + }, + { + label: "Products", + children: [ + { + type: "record:related_list", + id: "opp_products", + properties: { + objectName: "crm_opportunity_line_item", + relationshipField: "crm_opportunity", + columns: ["crm_product", "quantity", "unit_price", "total_price"], + limit: 10, + // The entry point that was missing (#1731). Every + // OTHER surface already treated line items as + // live — three profiles grant `allowCreate`, the + // docs describe the amount rolling up from them, + // and `billing-handoff.flow.ts`'s + // `load_line_items` reads them on every won deal + // — while nothing in the app could create one: + // no action, no list view, no navigation entry, + // no seed. A rep who wanted to itemise a deal had + // to type the Amount by hand. Declared surface and + // reachable surface now coincide again. + // + // What `add` writes is the whole reason a picker + // is sufficient here. It creates a row carrying + // exactly two authored keys — + // `{ [relationshipField]: , + // [linkField]: }` — and + // nothing else. On this object that would leave + // `quantity` and `unit_price` unset, and both are + // `required` + `storage.notNull`, so the insert + // would be refused. It is not, because the two + // gaps are already filled by machinery that + // predates this list: + // + // quantity -> the field's own `defaultValue: 1` + // unit_price -> `_line-item-price-fill.ts`, which + // on `beforeInsert` stamps + // `list_price` from the chosen + // product and defaults the + // negotiated `unit_price` to it + // discount -> the field's own `defaultValue: 0` + // total_price-> the formula over the three above + // + // and `crm_product.list_price` is itself `required` + // + `notNull`, so the hook can never fail to find a + // source. Measured end-to-end, not reasoned: + // `test/opportunity-line-item-add-picker.test.ts` + // inserts the picker's exact two-key shape and + // asserts the complete priced row, with an ablation + // that unbinds the hook and shows the same insert + // rejected as "Sales Price is required" — so the + // assertion cannot pass vacuously. + // + // ⛔ Do not add a `label`. The button falls back to + // the platform's own localized "Add"; the + // translation bundles reach a page component through + // `pages..components.`, which carries + // `label`/`title`/`description` for the COMPONENT + // and has no route to a nested `add.label`. A + // hand-authored string here would ship English into + // the zh-CN / es-ES / ja-JP bundles with no key to + // translate it under. + // + // `valueField` and `labelField` are both omitted on + // purpose rather than restated: `valueField` + // defaults to `id`, which is what the `crm_product` + // lookup stores, and `labelField` defaults to the + // picked object's own title field — `crm_product` + // declares `nameField: 'display_title'` (ADR-0079), + // so the picker labels rows "PRD-0001 - Widget" and + // keeps ONE source of truth for a product's title. + // That formula title is searchable only because the + // object also declares `searchableFields`, which it + // already does for exactly this reason. + add: { + picker: { + object: "crm_product", + // A retired product must not be sellable onto a + // new deal. `product.hook.ts`'s `beforeDelete` + // defines retirement as precisely this flag + // ("Set is_active=false to retire instead"), + // so the catalog's own retirement mechanism is + // what scopes the picker. All 13 seeded + // products carry `is_active: true`, so this + // narrows without emptying. + filter: [{ field: "is_active", operator: "equals", value: true }] + }, + linkField: "crm_product" + } + } + } + ] + }, + { + label: "Open Tasks", + children: [ + { + type: "record:related_list", + id: "opp_tasks", + properties: { + objectName: "crm_task", + relationshipField: "related_to_opportunity", + columns: ["subject", "status", "priority", "due_date", "owner_id"], + filter: [{ field: "status", operator: "not_equals", value: "completed" }], + limit: 10 + } + } + ] + } + ] + } + } + ] + }, + { + value: "activity", + label: "Activity", + children: [ + { + type: "record:activity", + id: "opp_activity", + /** + * `filters` is deleted with nothing put in its place, and + * that is the whole finding (#1269). + * + * It used to read `['all', 'tasks', 'meetings', 'calls', + * 'emails']` — a vocabulary that exists nowhere in the + * contract. `RecordActivityProps` has exactly two filter + * channels and neither takes that list: + * + * `types` — an array of FEED ITEM KINDS + * (`comment` | `field_change` | `task` | + * `event` | `email` | `call` | …). Not + * these values: `all` is not a kind and + * `meetings` is not one either (the kind + * is `event`), and all five are plural + * where the enum is singular. + * `filterMode` — ONE default for the panel's dropdown, + * from `all` | `comments_only` | + * `changes_only` | `tasks_only`. The + * dropdown's option list is the renderer's, + * not authorable. + * + * So the list was reaching for a third thing — "offer these + * filter chips" — that the component does not expose. What + * it wanted is already delivered: `showFilterToggle` + * defaults on, so the panel renders its filter dropdown, and + * `filterMode` defaults to `all`, so it opens unfiltered. + * Neither is restated here, because materializing a default + * turns "the author said nothing" into "the author asked for + * the default" — a different fact, and the one a later + * liveness audit reads. + * + * Mapping it onto `types` instead was considered and + * rejected: #1209 corrected exactly that mistake one page + * over (the lead timeline's `types: ['crm_task']`), and the + * renderer sanitises out-of-enum members then reads the + * EMPTY remainder as "no filter authored" — so a bad `types` + * is indistinguishable from no `types` on screen while + * claiming otherwise in source. A `types` here would also + * be a NEW restriction nobody asked for: it would drop + * comments and field changes from a timeline that shows them + * today. + */ + properties: { + limit: 25, + // Load-bearing (#2071): a call or meeting logged on the + // deal is a `sys_activity` row of type `completed` (the + // `task` feed kind), and the renderer drops every such + // row unless this is true — so a rep's logged call never + // reached this tab. The deal's other `completed` writers + // are its own won / lost milestones + // (`opportunity.object.ts`), which belong here too. + // Completed crm_task rows do NOT arrive: their audit rows + // are keyed to the task, and this feed reads only rows + // keyed to the deal. Nor is this the `types` restriction + // the note above refuses: it adds rows and filters none. + showCompleted: true + } + } + ] + } + ] + } + } + ] + }, + { + name: "aside", + width: "small", + components: [ + { + type: "record:reference_rail", + id: "opp_reference_rail", + properties: { + /** + * No entry declares a `title` — deliberately (#972). + * + * The rail resolves a card's heading as + * `entry.title || i18n.objectLabel({ name: objectName, … })`, so a + * literal `title` does not merely provide a default: it WINS, and + * the locale bundle is never consulted. The three literals that + * used to sit here (`Quotes` / `Products` / `Open Tasks`) therefore + * printed English into every one of the four locales this app + * ships, on top of `objects..label` already being translated + * in all of them. Dropping them hands the heading back to the + * translation bundle — the single source of truth for what an + * object is called — so a locale added later is covered for free. + * + * A translated literal is not available as an alternative: unlike + * `record:alert`, whose `title` is run through the inline + * translation-map resolver, the rail renders `entry.title` as a + * raw React child. An `{ en, 'zh-CN' }` map here would not be + * resolved — it would be handed to React as an object. + * + * The third card losing the word "Open" is a correction, not a + * casualty. A rail entry has no filter at all — the rail queries + * `{ $filter: { [relationshipField]: parentId }, $top: limit }` and + * reads nothing else — so that card always counted and listed this + * deal's tasks whatever their status. The heading claimed a filter + * the component cannot apply. The genuinely filtered view is the + * `opp_tasks` related list on the *Related* tab above, which does + * carry `status neq completed`. + * + * Pinned by `test/metadata-references.test.ts` (entries resolve, + * no literal titles) and `test/i18n-references.test.ts` (every + * rail object has a `label` in every locale, so the fallback + * lands on a translation rather than on a humanized object name). + */ + entries: [ + { + objectName: "crm_quote", + relationshipField: "crm_opportunity", + limit: 3 + }, + { + objectName: "crm_opportunity_line_item", + relationshipField: "crm_opportunity", + limit: 3 + }, + { + objectName: "crm_task", + relationshipField: "related_to_opportunity", + limit: 3 + } + ] + } + } + ] + } + ], + isDefault: true, + aria: { + ariaLabel: "Opportunity Detail Page", + ariaDescribedBy: "Detailed view of opportunity information with related records and activity" + } +}; + +// src/sales/pages/account_detail.page.ts +var AccountDetailPage = { + name: "account_detail_page", + label: "Account Detail", + description: "Slotted account record page \u2014 custom header + persistent discussion feed.", + type: "record", + object: "crm_account", + kind: "slotted", + regions: [], + slots: { + header: { + type: "page:header", + id: "account_header_slotted", + label: "Account Header (slotted)", + properties: { + title: "{name}", + subtitle: "{industry} \xB7 {type}", + // `icon` and `eyebrow` are GONE, and for two different reasons — both + // measured against the contract rather than inferred from the warning + // text (#1269). + // + // `icon` was REMOVED from `page:header` in @objectstack/spec 17.0.0 + // (#6946, ADR-0087 D2). It is deleted rather than renamed because no + // renderer ever read it: objectui resolves `icon` per header ACTION + // (`action.icon`) and never off the header's own props bag, and the + // component registry never published it as an input — which is what put + // the key in objectui's `UNPUBLISHED_EXEMPTIONS` as a "spec declares it, + // NO renderer read point" entry. The header's own identity comes from + // the record chrome (`recordChrome`, on by default). + // + // `eyebrow` was never declared by anything. It is not in + // `PageHeaderProps`, it has no alias or tombstone there, and the string + // "eyebrow" does not occur anywhere in objectui — no schema, no + // registry input, no renderer. So the ACCOUNT kicker this page's + // docblock used to promise has never reached a screen: the props bag is + // `z.record(z.string(), z.unknown())`, so the key was carried into the + // artifact and dropped at render. Deleting it changes nothing a user + // sees; it only stops the source claiming a kicker exists. + // `breadcrumb` retired from `page:header` in @objectstack/spec 17.6.0 + // (#20785, `page-header-breadcrumb-removed`) — deleted: no renderer + // ever drew a trail for it; the app shell's own trail is unchanged. + // Overriding the `header` slot REPLACES the synthesized header, actions + // and all — so this slot has to re-state every action it wants to keep. + // Before #592 it named none, which is why an account record showed no + // activity buttons at all while the list row's ⋮ menu showed three. + // + // Action IDs, not `ActionDef` objects: `PageHeaderProps.actions` is + // `z.array(z.string())` ("Action IDs to show in header") in + // @objectstack/spec 17.3.0, and this repo authors against the protocol + // (#1653). Each id is the `name` of a crm_account-scoped action in + // `src/sales/actions/activity-actions.ts`. + actions: ["log_call", "log_meeting", "schedule_meeting"] + } + }, + discussion: { + type: "record:chatter", + id: "account_chatter", + label: "Discussion", + /** + * One `feed`, for one reason: `showCompleted` (#2071). + * + * This feed IS the account's activity timeline — the slotted page + * synthesizes no Activity tab, so the panel's "All Activity" stream is + * where an account's `sys_activity` rows surface. A call or meeting + * logged on the account is a row of type `completed` (the `task` feed + * kind), and the timeline drops every such row unless + * `feed.showCompleted` is true — so Log a Call / Log a Meeting on an + * account wrote a row that appeared nowhere on the account. + * + * Authoring a `feed` costs two more keys, and they are stated rather + * than left out. `RecordChatterRenderer` builds `{ position: 'bottom', + * collapsible: false, feed: { enableReactions: true, enableThreading: + * true, showCommentInput: true }, ...schema }` — one shallow spread — so + * a `feed` of our own REPLACES that default object wholesale, and + * `RecordActivityTimeline` reads `enableReactions ?? false` and + * `enableThreading ?? false` off what is left. Without the two keys + * below, reactions and threading would silently switch off. + * `showCommentInput` needs no restating: the timeline reads it as + * `!== false`. + * + * `feed.enableMentions` needs none either: the renderer reads it as + * `!== false` too. And the older note still holds (#1269): + * `enableComments` and a top-level `enableReactions` / `enableMentions` + * are not `record:chatter` keys — `RecordChatterProps` declares + * `position`, `width`, `collapsible`, `defaultCollapsed`, `feed` and + * `aria`, nothing else. + */ + properties: { + feed: { + showCompleted: true, + enableReactions: true, + enableThreading: true + } + } + } + } +}; + +// src/sales/pages/account_workbench.page.ts +var AccountWorkbenchPage = { + name: "account_workbench", + label: "Account Workbench", + description: "Curated account list for the sales team: quick filters only, no view management.", + type: "list", + object: "crm_account", + kind: "full", + template: "default", + isDefault: false, + // Interface pages carry no regions — the list surface is generated from + // `interfaceConfig` (ADR-0047), not composed from components. + regions: [], + interfaceConfig: { + source: "crm_account", + sourceView: "all_accounts", + ...{ + userFilters: { + element: "dropdown", + fields: [ + { field: "industry", showCount: true }, + { field: "type" }, + { field: "owner_id" } + ] + } + // typed via spread-as-any until @objectstack/spec ships ADR-0047 + // (UserFiltersSchema is in framework main, > 9.2.0) + }, + appearance: { + showDescription: true, + allowedVisualizations: ["grid"] + }, + userActions: { + sort: true, + search: true, + filter: false, + rowHeight: false, + addRecordForm: false + }, + showRecordCount: true + } +}; + +// src/sales/pages/home.page.ts +var embeddedListView = (id, objectName, views, viewKey) => { + const view = views.listViews?.[viewKey]; + if (!view) throw new Error(`home.page.ts: no saved view "${viewKey}" on ${objectName}`); + return { + type: "list-view", + id, + label: view.label, + properties: { + objectName, + viewType: "grid", + columns: view.columns, + filter: view.filter, + sort: view.sort + } + }; +}; +var SalesHomePage = { + name: "sales_home_page", + label: "Sales Home", + description: "Sales team home page with key metrics and quick actions", + type: "home", + template: "three-column", + kind: "full", + variables: [ + { + name: "selectedPeriod", + type: "string", + defaultValue: "this_month" + } + ], + regions: [ + { + name: "header", + width: "full", + components: [ + { + type: "page:header", + id: "home_header", + label: "Sales Home Header", + properties: { + title: "Sales Dashboard", + // Was `Welcome back, {current_user.first_name}`, which rendered as + // "Welcome back, " — the name was never going to arrive, because + // that one string mixes three vocabularies that do not compose: + // + // 1. `subtitle` is an `I18nLabel` (`ComponentPropsMap`, + // `@objectstack/spec/ui`) — a display string or an inline + // locale map, resolved by `resolveI18nLabel`. The field has no + // token pass and no expression pass of its own. + // 2. Braces DO resolve in a page header, but the vocabulary is the + // BOUND RECORD's own fields — `case_detail.page.ts` records the + // measurement, where `{account}` matched no field and the + // subtitle rendered blank until it was spelled `{crm_account}`. + // A `type: 'home'` page has no record, so no brace token can + // ever resolve here. + // 3. `current_user.first_name` is a CEL path, and CEL is written + // bare, never inside `{…}`. The one resolvable brace token in + // the filter vocabulary is `{current_user_id}` on its own. + // + // A greeting that names the user is not expressible on a + // translatable label, so the label now says the part that is true + // in every locale and the four bundles carry the translations + // (`pages.sales_home_page.subtitle`). Personalising it would need a + // component that takes user data — no shipped component does + // (`user:profile` and its neighbours are `emptyProps` rows), so + // this is a static greeting rather than a widened accept surface. + subtitle: "Welcome back" + // `icon` removed from `page:header` in @objectstack/spec 17.0.0 + // (#6946, ADR-0087 D2) — deleted, not renamed. See the full note on + // `account_detail.page.ts`; nothing ever drew it. + // `breadcrumb` retired from `page:header` in @objectstack/spec 17.6.0 + // (#20785, `page-header-breadcrumb-removed`) — deleted: no renderer + // ever drew a trail for it; the app shell's own trail is unchanged. + } + } + ] + }, + { + name: "left_sidebar", + width: "small", + components: [ + { + type: "page:card", + id: "quick_create", + label: "Quick Create", + properties: { + title: "Quick Create", + bordered: true, + children: [ + { + type: "nav:menu", + id: "create_menu", + properties: {} + } + ] + } + } + // There is no `Recent Items` card here any more, and re-adding one + // needs a data source that does not exist yet. + // + // It shipped as a `page:card` with a title and no body: a bordered box + // with the words "Recent Items" and nothing under them, on the landing + // page of every `sales_rep` / `sales_manager`. "Recent" is per-user + // access history across objects, and the platform publishes no source + // for it on 17.1.0 — `ComponentPropsMap` has no recent-records + // component, and the two that sound like one (`record:activity`, + // `record:history`) both read the page's BOUND RECORD, which a home + // page does not have. Binding it to one object's list view instead + // would have made the title lie, which is the defect #771 exists to + // prevent, so the card is removed rather than filled with something + // that is not recency. Recorded as #1217; when the platform ships a + // recent-records source, this is where the card goes back. + ] + }, + { + name: "main", + width: "large", + components: [ + { + type: "page:card", + id: "key_metrics", + label: "Key Metrics", + properties: { + title: "Key Performance Indicators", + bordered: false, + // `record:highlights` needs a bound record and real fields; a home + // page has neither, and the four names it listed (total_revenue, + // deals_won, …) exist on no object — the card rendered blank. + // `object-metric` widgets aggregate live data instead. + children: [ + { + type: "object-metric", + id: "kpi_revenue_won", + properties: { + objectName: "crm_opportunity", + label: "Revenue (Won)", + icon: "dollar-sign", + aggregate: { field: "amount", function: "sum" }, + filter: [{ field: "stage", operator: "equals", value: "closed_won" }] + } + }, + { + type: "object-metric", + id: "kpi_deals_won", + properties: { + objectName: "crm_opportunity", + label: "Deals Won", + icon: "trophy", + aggregate: { field: "id", function: "count" }, + filter: [{ field: "stage", operator: "equals", value: "closed_won" }] + } + }, + { + type: "object-metric", + id: "kpi_pipeline_value", + properties: { + objectName: "crm_opportunity", + label: "Pipeline Value", + icon: "briefcase", + aggregate: { field: "amount", function: "sum" }, + filter: [{ field: "stage", operator: "not_in", value: ["closed_won", "closed_lost"] }] + } + }, + { + type: "object-metric", + id: "kpi_open_leads", + properties: { + objectName: "crm_lead", + label: "Open Leads", + icon: "user-plus", + aggregate: { field: "id", function: "count" }, + filter: [{ field: "is_converted", operator: "equals", value: false }] + } + } + ] + } + }, + { + type: "page:tabs", + id: "home_tabs", + label: "Home Tabs", + properties: { + /** + * `type` → `tabStyle` (@objectstack/spec 17.0.0, #6776, ADR-0087 + * D2). The concept and the value vocabulary (`line` | `card` | + * `pill`) are unchanged; only the spelling moved, because a props + * key named `type` collides with the page component's own dispatch + * key: objectui's `SchemaRenderer` hoists `properties` onto the node + * but deliberately skips `type` and `id` (or the inner value would + * shadow which renderer to dispatch to), and `sdui-parser` lists + * `type` in `BASE_PROPS`, so a manifest input by that name is never + * validated at all. + * + * Renaming is behaviour-preserving on this page and on the three + * record pages: the renderer resolves + * `schema?.properties?.type || schema?.tabStyle || 'line'`, so it + * has been honouring the retired spelling as a back-compat read all + * along and picks up the canonical one through the same hoist. + */ + tabStyle: "card", + position: "top", + items: [ + { + label: "My Leads", + icon: "user-plus", + children: [embeddedListView("home_my_leads", "crm_lead", LeadViews, "my_leads")] + }, + { + // Was "My Opportunities", which promises every deal I own; the + // view behind it is the open-pipeline one (the nav's My Work > + // My Deals opens the same `my_open_deals`). The tab name now + // says what the panel shows. + label: "My Open Deals", + icon: "dollar-sign", + children: [embeddedListView("home_my_deals", "crm_opportunity", OpportunityViews, "my_open_deals")] + }, + { + // Same correction: `my_open_tasks` excludes completed tasks. + label: "My Open Tasks", + icon: "list-checks", + children: [embeddedListView("home_my_tasks", "crm_task", TaskViews, "my_open_tasks")] + } + ] + } + } + ] + }, + { + name: "right_sidebar", + width: "medium", + components: [ + { + type: "page:card", + id: "ai_briefing", + // The assistant is the PLATFORM's (`ask`), not an app-owned persona: + // HotCRM contributes skills, the agent lives in the cloud side + // (maintainer ruling on #612, 2026-08-04). The retired `sales_copilot` + // agent (#512, ADR-0063 §2) must not be named in live UI copy — and + // the entry point is the assistant panel the platform opens from the + // right edge of every page, which is the wording + // `content/docs/ai-copilot/index.mdx` landed in #611/PR #1001. + label: "Today with the AI Assistant", + properties: { + title: "Ask the AI Assistant", + bordered: true, + // The paragraph is an `element:text` child (#1581). It used to be + // `properties.description`, which `page:card` does not declare, so + // the card rendered as a title over nothing. `content` is not on + // the locale pack's page-component face, so the four languages + // live here as an inline locale map, the spec's route for page + // prose. The #1002 persona guard in + // `test/metadata-references.test.ts` reads this child. + children: [ + { + type: "element:text", + id: "ai_briefing_text", + properties: { + content: { + en: 'Open the assistant panel from the right edge of the page and ask "what should I focus on today?" \u2014 it sees your live pipeline, schema, and accounts.', + "zh-CN": '\u4ECE\u9875\u9762\u53F3\u4FA7\u6253\u5F00\u52A9\u624B\u9762\u677F\uFF0C\u8BE2\u95EE"\u6211\u4ECA\u5929\u5E94\u8BE5\u5173\u6CE8\u4EC0\u4E48\uFF1F"\u2014\u2014\u5B83\u53EF\u4EE5\u5B9E\u65F6\u67E5\u770B\u60A8\u7684\u9500\u552E\u7BA1\u9053\u3001\u67B6\u6784\u4E0E\u5BA2\u6237\u4FE1\u606F\u3002', + "es-ES": 'Abra el panel del asistente desde el borde derecho de la p\xE1gina y pregunte "\xBFen qu\xE9 deber\xEDa concentrarme hoy?" \u2014 ve su flujo de ventas, esquema y cuentas en tiempo real.', + "ja-JP": "\u30DA\u30FC\u30B8\u53F3\u7AEF\u304B\u3089\u30A2\u30B7\u30B9\u30BF\u30F3\u30C8\u30D1\u30CD\u30EB\u3092\u958B\u304D\u3001\u300C\u4ECA\u65E5\u306F\u4F55\u306B\u96C6\u4E2D\u3059\u3079\u304D\u304B\uFF1F\u300D\u3068\u5C0B\u306D\u3066\u304F\u3060\u3055\u3044 \u2014 \u30EA\u30A2\u30EB\u30BF\u30A4\u30E0\u306E\u30D1\u30A4\u30D7\u30E9\u30A4\u30F3\u3001\u30B9\u30AD\u30FC\u30DE\u3001\u53D6\u5F15\u5148\u60C5\u5831\u3092\u628A\u63E1\u3057\u3066\u3044\u307E\u3059\u3002" + } + } + } + ] + } + }, + { + type: "page:card", + id: "upcoming_events", + // Was `Calendar` / "Today's Schedule" over an empty bordered box — + // the card declared no body, so the renderer had nothing to draw. + // + // It is bound to `crm_event`'s saved `upcoming_events` view, read off + // the view exactly like the tabs above, and the name now matches what + // the panel shows. "Today's Schedule" is NOT what any existing view + // says: `my_events` is scoped to the current user but carries no date + // filter, no sort and no date column (27 seeded rows, mostly `held` + // interactions from the past), while `upcoming_events` is + // `status: 'planned'` sorted by `start_datetime` ascending with the + // date on the row. Narrowing either one to today would mean retyping + // a filter in this page — the second definition the helper above + // exists to prevent — so the title says "upcoming" instead of + // promising a day this page cannot compute. + label: "Upcoming Events", + properties: { + title: "Upcoming Events", + bordered: true, + children: [embeddedListView("home_upcoming_events", "crm_event", EventViews, "upcoming_events")] + } + } + ] + } + ], + isDefault: true, + aria: { + ariaLabel: "Sales Home Page", + ariaDescribedBy: "Sales team home page with metrics, leads, and quick actions" + } +}; + +// src/sales/pages/app_launcher.page.ts +var AppLauncherPage = { + name: "app_launcher_page", + label: "App Launcher", + description: "Central hub for accessing all applications", + type: "app", + template: "centered", + kind: "full", + regions: [ + { + name: "header", + width: "full", + components: [ + { + type: "global:search", + id: "app_search", + label: "Search Apps", + properties: {} + } + ] + }, + { + name: "main", + width: "large", + components: [ + { + type: "page:header", + id: "launcher_header", + label: "App Launcher Header", + properties: { + title: "App Launcher", + subtitle: "Select an app to get started" + // `icon` removed from `page:header` in @objectstack/spec 17.0.0 + // (#6946, ADR-0087 D2) — deleted, not renamed. See the full note on + // `account_detail.page.ts`; nothing ever drew it. + // `breadcrumb` retired from `page:header` in @objectstack/spec 17.6.0 + // (#20785, `page-header-breadcrumb-removed`) — deleted: no renderer + // ever drew a trail for it; the app shell's own trail is unchanged. + } + }, + { + type: "app:launcher", + id: "app_grid", + label: "Application Grid", + properties: {} + } + ] + } + ], + isDefault: false, + aria: { + ariaLabel: "App Launcher Page", + ariaDescribedBy: "Central application launcher for accessing all apps" + } +}; + +// src/sales/pages/utility_bar.page.ts +var UtilityBarPage = { + name: "utility_bar_page", + label: "Utility Bar", + description: "Quick access utility bar with floating tools", + type: "utility", + template: "utility-bar", + kind: "full", + regions: [ + { + name: "utilities", + width: "full", + components: [ + { + type: "global:notifications", + id: "notifications_panel", + label: "Notifications", + properties: {} + }, + { + type: "page:card", + id: "quick_notes", + label: "Quick Notes", + properties: { + title: "Quick Notes", + bordered: true + } + }, + { + type: "global:search", + id: "quick_search", + label: "Quick Search", + properties: {} + } + ] + } + ], + isDefault: false, + aria: { + ariaLabel: "Utility Bar", + ariaDescribedBy: "Quick access utility bar with floating tools and notifications" + } +}; + +// src/sales/email-templates/index.ts +var email_templates_exports = {}; +__export(email_templates_exports, { + SalesEmailTemplates: () => SalesEmailTemplates +}); + +// src/sales/email-templates/en.ts +var en3 = { + "crm.account_approved": { + label: "Account Approved", + subject: "Account approved: {{name}}", + bodyHtml: "

This account has been signed off and is now established data.

" + }, + "crm.account_rejected": { + label: "Account Not Approved", + subject: "Account not approved: {{name}}", + bodyHtml: "

This account was not signed off. Correct its details and ask for another review.

" + }, + "crm.contact_welcome": { + label: "New Contact", + subject: "New contact: {{first_name}} {{last_name}}", + bodyHtml: "

{{first_name}} {{last_name}} was added as a contact. Reach out to welcome them.

" + }, + "crm.deal_stalled": { + label: "Stalled Deal", + subject: "Stalled deal: {{name}}", + bodyHtml: "

Opportunity {{name}} has sat in {{stage}} for {{days_in_stage}} days. Time to advance or re-qualify it.

" + }, + "crm.large_deal_won": { + label: "Large Deal Won", + subject: "Large deal won: {{name}}", + bodyHtml: "

{{name}} closed at {{amount}}. Congratulations to the team.

" + }, + "crm.lead_conversion_approved": { + label: "Lead Approved for Conversion", + subject: "Lead approved for conversion: {{first_name}} {{last_name}}", + bodyHtml: "

This lead has been signed off. You can convert it into an account, contact and opportunity.

" + }, + "crm.lead_conversion_rejected": { + label: "Lead Not Approved", + subject: "Lead not approved: {{first_name}} {{last_name}}", + bodyHtml: "

Conversion of this lead was not approved. Keep working it, or disqualify it with a reason.

" + }, + "crm.lead_converted": { + label: "Lead Converted", + subject: "Lead converted: {{first_name}} {{last_name}}", + bodyHtml: "

Lead {{first_name}} {{last_name}} was converted into an account and contact.

" + }, + "crm.lead_routing_hot": { + label: "Hot Lead Routing", + subject: "Hot lead \u2014 assign within 24h: {{first_name}} {{last_name}}", + bodyHtml: "

{{first_name}} {{last_name}} from {{company}} (rating {{rating}}) needs an owner today.

" + }, + "crm.lead_routing_new": { + label: "New Lead Routing", + subject: "New lead to assign: {{first_name}} {{last_name}}", + bodyHtml: "

{{first_name}} {{last_name}} from {{company}} is awaiting assignment.

" + }, + "crm.opportunity_approved": { + label: "Deal Approved", + subject: "Deal approved: {{name}}", + bodyHtml: "

Your opportunity {{name}} has been approved.

" + }, + "crm.opportunity_rejected": { + label: "Deal Rejected", + subject: "Deal rejected: {{name}}", + bodyHtml: "

Your opportunity {{name}} was not approved. Review and revise before resubmitting.

" + }, + "crm.task_reminder": { + label: "Task Reminder", + subject: "Task reminder: {{subject}}", + bodyHtml: '

Your task "{{subject}}" is due (reminder set for {{reminder_date}}).

' + }, + "crm.urgent_task": { + label: "Urgent Task", + subject: "Urgent task: {{subject}}", + bodyHtml: '

An urgent task "{{subject}}" was assigned to you and needs attention.

' + } +}; + +// src/sales/email-templates/zh-CN.ts +var zhCN3 = { + "crm.account_approved": { + label: "\u5BA2\u6237\u5BA1\u6279\u901A\u8FC7", + subject: "\u5BA2\u6237\u5DF2\u5BA1\u6279\u901A\u8FC7\uFF1A{{name}}", + bodyHtml: "

\u8BE5\u5BA2\u6237\u5DF2\u5BA1\u6279\u901A\u8FC7\uFF0C\u73B0\u4E3A\u6B63\u5F0F\u6570\u636E\u3002

" + }, + "crm.account_rejected": { + label: "\u5BA2\u6237\u5BA1\u6279\u672A\u901A\u8FC7", + subject: "\u5BA2\u6237\u672A\u901A\u8FC7\u5BA1\u6279\uFF1A{{name}}", + bodyHtml: "

\u8BE5\u5BA2\u6237\u672A\u901A\u8FC7\u5BA1\u6279\u3002\u8BF7\u4FEE\u6B63\u5176\u4FE1\u606F\u540E\u518D\u6B21\u63D0\u4EA4\u5BA1\u6838\u3002

" + }, + "crm.contact_welcome": { + label: "\u65B0\u8054\u7CFB\u4EBA", + subject: "\u65B0\u8054\u7CFB\u4EBA\uFF1A{{first_name}} {{last_name}}", + bodyHtml: "

{{first_name}} {{last_name}} \u5DF2\u6DFB\u52A0\u4E3A\u8054\u7CFB\u4EBA\u3002\u8BF7\u4E3B\u52A8\u8054\u7CFB\u5E76\u8868\u793A\u6B22\u8FCE\u3002

" + }, + "crm.deal_stalled": { + label: "\u5546\u673A\u505C\u6EDE", + subject: "\u505C\u6EDE\u5546\u673A\uFF1A{{name}}", + bodyHtml: "

\u5546\u673A {{name}} \u5DF2\u5728\u201C{{stage}}\u201D\u9636\u6BB5\u505C\u7559 {{days_in_stage}} \u5929\u3002\u8BF7\u63A8\u8FDB\u6216\u91CD\u65B0\u8BC4\u4F30\u3002

" + }, + "crm.large_deal_won": { + label: "\u5927\u989D\u5546\u673A\u8D62\u5355", + subject: "\u5927\u989D\u5546\u673A\u8D62\u5355\uFF1A{{name}}", + bodyHtml: "

{{name}} \u4EE5 {{amount}} \u6210\u4EA4\u3002\u606D\u559C\u56E2\u961F\u3002

" + }, + "crm.lead_conversion_approved": { + label: "\u7EBF\u7D22\u8F6C\u6362\u5DF2\u6279\u51C6", + subject: "\u7EBF\u7D22\u8F6C\u6362\u5DF2\u6279\u51C6\uFF1A{{first_name}} {{last_name}}", + bodyHtml: "

\u8BE5\u7EBF\u7D22\u5DF2\u5BA1\u6279\u901A\u8FC7\u3002\u60A8\u53EF\u4EE5\u5C06\u5176\u8F6C\u6362\u4E3A\u5BA2\u6237\u3001\u8054\u7CFB\u4EBA\u548C\u5546\u673A\u3002

" + }, + "crm.lead_conversion_rejected": { + label: "\u7EBF\u7D22\u8F6C\u6362\u672A\u6279\u51C6", + subject: "\u7EBF\u7D22\u672A\u901A\u8FC7\u5BA1\u6279\uFF1A{{first_name}} {{last_name}}", + bodyHtml: "

\u8BE5\u7EBF\u7D22\u7684\u8F6C\u6362\u672A\u83B7\u6279\u51C6\u3002\u8BF7\u7EE7\u7EED\u8DDF\u8FDB\uFF0C\u6216\u6CE8\u660E\u539F\u56E0\u5C06\u5176\u53D6\u6D88\u8D44\u683C\u3002

" + }, + "crm.lead_converted": { + label: "\u7EBF\u7D22\u5DF2\u8F6C\u6362", + subject: "\u7EBF\u7D22\u5DF2\u8F6C\u6362\uFF1A{{first_name}} {{last_name}}", + bodyHtml: "

\u7EBF\u7D22 {{first_name}} {{last_name}} \u5DF2\u8F6C\u6362\u4E3A\u5BA2\u6237\u548C\u8054\u7CFB\u4EBA\u3002

" + }, + "crm.lead_routing_hot": { + label: "\u70ED\u95E8\u7EBF\u7D22\u5206\u914D", + subject: "\u70ED\u95E8\u7EBF\u7D22 \u2014 24 \u5C0F\u65F6\u5185\u5206\u914D\uFF1A{{first_name}} {{last_name}}", + bodyHtml: "

\u6765\u81EA {{company}} \u7684 {{first_name}} {{last_name}}\uFF08\u8BC4\u5206 {{rating}}\uFF09\u9700\u8981\u4ECA\u5929\u5C31\u6307\u5B9A\u8D1F\u8D23\u4EBA\u3002

" + }, + "crm.lead_routing_new": { + label: "\u65B0\u7EBF\u7D22\u5206\u914D", + subject: "\u5F85\u5206\u914D\u65B0\u7EBF\u7D22\uFF1A{{first_name}} {{last_name}}", + bodyHtml: "

\u6765\u81EA {{company}} \u7684 {{first_name}} {{last_name}} \u6B63\u5728\u7B49\u5F85\u5206\u914D\u3002

" + }, + "crm.opportunity_approved": { + label: "\u5546\u673A\u5BA1\u6279\u901A\u8FC7", + subject: "\u5546\u673A\u5DF2\u6279\u51C6\uFF1A{{name}}", + bodyHtml: "

\u60A8\u7684\u5546\u673A {{name}} \u5DF2\u83B7\u6279\u51C6\u3002

" + }, + "crm.opportunity_rejected": { + label: "\u5546\u673A\u5BA1\u6279\u672A\u901A\u8FC7", + subject: "\u5546\u673A\u672A\u6279\u51C6\uFF1A{{name}}", + bodyHtml: "

\u60A8\u7684\u5546\u673A {{name}} \u672A\u83B7\u6279\u51C6\u3002\u8BF7\u68C0\u67E5\u5E76\u4FEE\u6539\u540E\u91CD\u65B0\u63D0\u4EA4\u3002

" + }, + "crm.task_reminder": { + label: "\u4EFB\u52A1\u63D0\u9192", + subject: "\u4EFB\u52A1\u63D0\u9192\uFF1A{{subject}}", + bodyHtml: "

\u60A8\u7684\u4EFB\u52A1\u201C{{subject}}\u201D\u5DF2\u5230\u671F\uFF08\u63D0\u9192\u65F6\u95F4 {{reminder_date}}\uFF09\u3002

" + }, + "crm.urgent_task": { + label: "\u7D27\u6025\u4EFB\u52A1", + subject: "\u7D27\u6025\u4EFB\u52A1\uFF1A{{subject}}", + bodyHtml: "

\u4E00\u9879\u7D27\u6025\u4EFB\u52A1\u201C{{subject}}\u201D\u5DF2\u5206\u914D\u7ED9\u60A8\uFF0C\u9700\u8981\u5C3D\u5FEB\u5904\u7406\u3002

" + } +}; + +// src/sales/email-templates/ja-JP.ts +var jaJP3 = { + "crm.account_approved": { + label: "\u30A2\u30AB\u30A6\u30F3\u30C8\u627F\u8A8D\u6E08\u307F", + subject: "\u30A2\u30AB\u30A6\u30F3\u30C8\u304C\u627F\u8A8D\u3055\u308C\u307E\u3057\u305F: {{name}}", + bodyHtml: "

\u3053\u306E\u30A2\u30AB\u30A6\u30F3\u30C8\u306F\u627F\u8A8D\u3055\u308C\u3001\u6B63\u5F0F\u306A\u30C7\u30FC\u30BF\u306B\u306A\u308A\u307E\u3057\u305F\u3002

" + }, + "crm.account_rejected": { + label: "\u30A2\u30AB\u30A6\u30F3\u30C8\u672A\u627F\u8A8D", + subject: "\u30A2\u30AB\u30A6\u30F3\u30C8\u304C\u627F\u8A8D\u3055\u308C\u307E\u305B\u3093\u3067\u3057\u305F: {{name}}", + bodyHtml: "

\u3053\u306E\u30A2\u30AB\u30A6\u30F3\u30C8\u306F\u627F\u8A8D\u3055\u308C\u307E\u305B\u3093\u3067\u3057\u305F\u3002\u5185\u5BB9\u3092\u4FEE\u6B63\u306E\u3046\u3048\u3001\u518D\u5EA6\u627F\u8A8D\u3092\u4F9D\u983C\u3057\u3066\u304F\u3060\u3055\u3044\u3002

" + }, + "crm.contact_welcome": { + label: "\u65B0\u898F\u53D6\u5F15\u5148\u8CAC\u4EFB\u8005", + subject: "\u65B0\u3057\u3044\u53D6\u5F15\u5148\u8CAC\u4EFB\u8005: {{first_name}} {{last_name}}", + bodyHtml: "

{{first_name}} {{last_name}} \u304C\u53D6\u5F15\u5148\u8CAC\u4EFB\u8005\u3068\u3057\u3066\u8FFD\u52A0\u3055\u308C\u307E\u3057\u305F\u3002\u3054\u6328\u62F6\u306E\u9023\u7D61\u3092\u3057\u3066\u304F\u3060\u3055\u3044\u3002

" + }, + "crm.deal_stalled": { + label: "\u505C\u6EDE\u4E2D\u306E\u5546\u8AC7", + subject: "\u505C\u6EDE\u4E2D\u306E\u5546\u8AC7: {{name}}", + bodyHtml: "

\u5546\u8AC7 {{name}} \u306F\u300C{{stage}}\u300D\u306B {{days_in_stage}} \u65E5\u9593\u7559\u307E\u3063\u3066\u3044\u307E\u3059\u3002\u6B21\u306E\u6BB5\u968E\u306B\u9032\u3081\u308B\u304B\u3001\u518D\u8A55\u4FA1\u3057\u3066\u304F\u3060\u3055\u3044\u3002

" + }, + "crm.large_deal_won": { + label: "\u5927\u578B\u5546\u8AC7\u306E\u53D7\u6CE8", + subject: "\u5927\u578B\u5546\u8AC7\u3092\u53D7\u6CE8: {{name}}", + bodyHtml: "

{{name}} \u304C {{amount}} \u3067\u6210\u7D04\u3057\u307E\u3057\u305F\u3002\u30C1\u30FC\u30E0\u306E\u7686\u3055\u3093\u3001\u304A\u3081\u3067\u3068\u3046\u3054\u3056\u3044\u307E\u3059\u3002

" + }, + "crm.lead_conversion_approved": { + label: "\u30EA\u30FC\u30C9\u5909\u63DB\u306E\u627F\u8A8D", + subject: "\u30EA\u30FC\u30C9\u306E\u5909\u63DB\u304C\u627F\u8A8D\u3055\u308C\u307E\u3057\u305F: {{first_name}} {{last_name}}", + bodyHtml: "

\u3053\u306E\u30EA\u30FC\u30C9\u306F\u627F\u8A8D\u3055\u308C\u307E\u3057\u305F\u3002\u53D6\u5F15\u5148\u3001\u53D6\u5F15\u5148\u8CAC\u4EFB\u8005\u3001\u5546\u8AC7\u306B\u5909\u63DB\u3067\u304D\u307E\u3059\u3002

" + }, + "crm.lead_conversion_rejected": { + label: "\u30EA\u30FC\u30C9\u672A\u627F\u8A8D", + subject: "\u30EA\u30FC\u30C9\u304C\u627F\u8A8D\u3055\u308C\u307E\u305B\u3093\u3067\u3057\u305F: {{first_name}} {{last_name}}", + bodyHtml: "

\u3053\u306E\u30EA\u30FC\u30C9\u306E\u5909\u63DB\u306F\u627F\u8A8D\u3055\u308C\u307E\u305B\u3093\u3067\u3057\u305F\u3002\u5F15\u304D\u7D9A\u304D\u5BFE\u5FDC\u3059\u308B\u304B\u3001\u7406\u7531\u3092\u4ED8\u3051\u3066\u5BFE\u8C61\u5916\u306B\u3057\u3066\u304F\u3060\u3055\u3044\u3002

" + }, + "crm.lead_converted": { + label: "\u30EA\u30FC\u30C9\u5909\u63DB\u6E08\u307F", + subject: "\u30EA\u30FC\u30C9\u3092\u5909\u63DB\u3057\u307E\u3057\u305F: {{first_name}} {{last_name}}", + bodyHtml: "

\u30EA\u30FC\u30C9 {{first_name}} {{last_name}} \u3092\u53D6\u5F15\u5148\u3068\u53D6\u5F15\u5148\u8CAC\u4EFB\u8005\u306B\u5909\u63DB\u3057\u307E\u3057\u305F\u3002

" + }, + "crm.lead_routing_hot": { + label: "\u30DB\u30C3\u30C8\u30EA\u30FC\u30C9\u306E\u5272\u308A\u5F53\u3066", + subject: "\u30DB\u30C3\u30C8\u30EA\u30FC\u30C9 \u2014 24 \u6642\u9593\u4EE5\u5185\u306B\u5272\u308A\u5F53\u3066: {{first_name}} {{last_name}}", + bodyHtml: "

{{company}} \u306E {{first_name}} {{last_name}}\uFF08\u8A55\u4FA1 {{rating}}\uFF09\u306B\u672C\u65E5\u4E2D\u306B\u62C5\u5F53\u8005\u3092\u5272\u308A\u5F53\u3066\u3066\u304F\u3060\u3055\u3044\u3002

" + }, + "crm.lead_routing_new": { + label: "\u65B0\u898F\u30EA\u30FC\u30C9\u306E\u5272\u308A\u5F53\u3066", + subject: "\u5272\u308A\u5F53\u3066\u5F85\u3061\u306E\u65B0\u898F\u30EA\u30FC\u30C9: {{first_name}} {{last_name}}", + bodyHtml: "

{{company}} \u306E {{first_name}} {{last_name}} \u304C\u5272\u308A\u5F53\u3066\u3092\u5F85\u3063\u3066\u3044\u307E\u3059\u3002

" + }, + "crm.opportunity_approved": { + label: "\u5546\u8AC7\u627F\u8A8D\u6E08\u307F", + subject: "\u5546\u8AC7\u304C\u627F\u8A8D\u3055\u308C\u307E\u3057\u305F: {{name}}", + bodyHtml: "

\u5546\u8AC7 {{name}} \u304C\u627F\u8A8D\u3055\u308C\u307E\u3057\u305F\u3002

" + }, + "crm.opportunity_rejected": { + label: "\u5546\u8AC7\u672A\u627F\u8A8D", + subject: "\u5546\u8AC7\u304C\u627F\u8A8D\u3055\u308C\u307E\u305B\u3093\u3067\u3057\u305F: {{name}}", + bodyHtml: "

\u5546\u8AC7 {{name}} \u306F\u627F\u8A8D\u3055\u308C\u307E\u305B\u3093\u3067\u3057\u305F\u3002\u5185\u5BB9\u3092\u78BA\u8A8D\u30FB\u4FEE\u6B63\u306E\u3046\u3048\u3001\u518D\u7533\u8ACB\u3057\u3066\u304F\u3060\u3055\u3044\u3002

" + }, + "crm.task_reminder": { + label: "ToDo \u30EA\u30DE\u30A4\u30F3\u30C0\u30FC", + subject: "ToDo \u306E\u30EA\u30DE\u30A4\u30F3\u30C0\u30FC: {{subject}}", + bodyHtml: "

ToDo\u300C{{subject}}\u300D\u304C\u671F\u9650\u3092\u8FCE\u3048\u307E\u3057\u305F\uFF08\u30EA\u30DE\u30A4\u30F3\u30C0\u30FC\u8A2D\u5B9A: {{reminder_date}}\uFF09\u3002

" + }, + "crm.urgent_task": { + label: "\u7DCA\u6025 ToDo", + subject: "\u7DCA\u6025\u306E ToDo: {{subject}}", + bodyHtml: "

\u7DCA\u6025\u306E ToDo\u300C{{subject}}\u300D\u304C\u5272\u308A\u5F53\u3066\u3089\u308C\u307E\u3057\u305F\u3002\u5BFE\u5FDC\u3092\u304A\u9858\u3044\u3057\u307E\u3059\u3002

" + } +}; + +// src/sales/email-templates/es-ES.ts +var esES3 = { + "crm.account_approved": { + label: "Cuenta aprobada", + subject: "Cuenta aprobada: {{name}}", + bodyHtml: "

Esta cuenta ha sido aprobada y ya es un dato consolidado.

" + }, + "crm.account_rejected": { + label: "Cuenta no aprobada", + subject: "Cuenta no aprobada: {{name}}", + bodyHtml: "

Esta cuenta no fue aprobada. Corrige sus datos y solicita otra revisi\xF3n.

" + }, + "crm.contact_welcome": { + label: "Nuevo contacto", + subject: "Nuevo contacto: {{first_name}} {{last_name}}", + bodyHtml: "

{{first_name}} {{last_name}} se ha a\xF1adido como contacto. Ponte en contacto para darle la bienvenida.

" + }, + "crm.deal_stalled": { + label: "Oportunidad estancada", + subject: "Oportunidad estancada: {{name}}", + bodyHtml: "

La oportunidad {{name}} lleva {{days_in_stage}} d\xEDas en {{stage}}. Es hora de avanzarla o volver a cualificarla.

" + }, + "crm.large_deal_won": { + label: "Gran operaci\xF3n ganada", + subject: "Gran operaci\xF3n ganada: {{name}}", + bodyHtml: "

{{name}} se cerr\xF3 por {{amount}}. Enhorabuena al equipo.

" + }, + "crm.lead_conversion_approved": { + label: "Cliente potencial aprobado para conversi\xF3n", + subject: "Cliente potencial aprobado para conversi\xF3n: {{first_name}} {{last_name}}", + bodyHtml: "

Este cliente potencial ha sido aprobado. Puedes convertirlo en cuenta, contacto y oportunidad.

" + }, + "crm.lead_conversion_rejected": { + label: "Cliente potencial no aprobado", + subject: "Cliente potencial no aprobado: {{first_name}} {{last_name}}", + bodyHtml: "

La conversi\xF3n de este cliente potencial no fue aprobada. Sigue trabaj\xE1ndolo o descalif\xEDcalo indicando un motivo.

" + }, + "crm.lead_converted": { + label: "Cliente potencial convertido", + subject: "Cliente potencial convertido: {{first_name}} {{last_name}}", + bodyHtml: "

El cliente potencial {{first_name}} {{last_name}} se convirti\xF3 en cuenta y contacto.

" + }, + "crm.lead_routing_hot": { + label: "Asignaci\xF3n de cliente potencial caliente", + subject: "Cliente potencial caliente \u2014 asignar en 24 h: {{first_name}} {{last_name}}", + bodyHtml: "

{{first_name}} {{last_name}} de {{company}} (puntuaci\xF3n {{rating}}) necesita propietario hoy.

" + }, + "crm.lead_routing_new": { + label: "Asignaci\xF3n de cliente potencial", + subject: "Nuevo cliente potencial por asignar: {{first_name}} {{last_name}}", + bodyHtml: "

{{first_name}} {{last_name}} de {{company}} est\xE1 pendiente de asignaci\xF3n.

" + }, + "crm.opportunity_approved": { + label: "Oportunidad aprobada", + subject: "Oportunidad aprobada: {{name}}", + bodyHtml: "

Tu oportunidad {{name}} ha sido aprobada.

" + }, + "crm.opportunity_rejected": { + label: "Oportunidad rechazada", + subject: "Oportunidad rechazada: {{name}}", + bodyHtml: "

Tu oportunidad {{name}} no fue aprobada. Rev\xEDsala y corr\xEDgela antes de volver a enviarla.

" + }, + "crm.task_reminder": { + label: "Recordatorio de tarea", + subject: "Recordatorio de tarea: {{subject}}", + bodyHtml: '

Tu tarea "{{subject}}" vence (recordatorio fijado para {{reminder_date}}).

' + }, + "crm.urgent_task": { + label: "Tarea urgente", + subject: "Tarea urgente: {{subject}}", + bodyHtml: '

Se te ha asignado una tarea urgente "{{subject}}" que requiere atenci\xF3n.

' + } +}; + +// src/sales/email-templates/crm.email-template.ts +var SalesEmailTemplates = bundle({ + "en-US": en3, + "zh-CN": zhCN3, + "ja-JP": jaJP3, + "es-ES": esES3 +}); + +// src/revenue/email-templates/index.ts +var email_templates_exports2 = {}; +__export(email_templates_exports2, { + RevenueEmailTemplates: () => RevenueEmailTemplates +}); + +// src/revenue/email-templates/en.ts +var en4 = { + "crm.contract_expired": { + label: "Contract Expired", + subject: "Contract expired: {{contract_number}}", + bodyHtml: "

Contract {{contract_number}} reached its end date and has been marked expired.

" + }, + "crm.contract_renewal": { + label: "Contract Renewal Due", + subject: "Contract renewal due: {{contract_number}}", + bodyHtml: "

Contract {{contract_number}} ends on {{end_date}}. Start the renewal conversation now.

" + }, + "crm.quote_created": { + label: "Quote Created", + subject: "Quote created: {{quote_name}}", + bodyHtml: "

Your quote {{quote_name}} has been created from this opportunity.

" + } +}; + +// src/revenue/email-templates/zh-CN.ts +var zhCN4 = { + "crm.contract_expired": { + label: "\u5408\u540C\u5DF2\u5230\u671F", + subject: "\u5408\u540C\u5DF2\u5230\u671F\uFF1A{{contract_number}}", + bodyHtml: "

\u5408\u540C {{contract_number}} \u5DF2\u5230\u8FBE\u7ED3\u675F\u65E5\u671F\uFF0C\u5E76\u5DF2\u6807\u8BB0\u4E3A\u5230\u671F\u3002

" + }, + "crm.contract_renewal": { + label: "\u5408\u540C\u7EED\u7EA6\u63D0\u9192", + subject: "\u5408\u540C\u5F85\u7EED\u7EA6\uFF1A{{contract_number}}", + bodyHtml: "

\u5408\u540C {{contract_number}} \u5C06\u4E8E {{end_date}} \u7ED3\u675F\u3002\u8BF7\u7ACB\u5373\u542F\u52A8\u7EED\u7EA6\u6C9F\u901A\u3002

" + }, + "crm.quote_created": { + label: "\u62A5\u4EF7\u5355\u5DF2\u521B\u5EFA", + subject: "\u62A5\u4EF7\u5355\u5DF2\u521B\u5EFA\uFF1A{{quote_name}}", + bodyHtml: "

\u60A8\u7684\u62A5\u4EF7\u5355 {{quote_name}} \u5DF2\u4ECE\u8BE5\u5546\u673A\u521B\u5EFA\u3002

" + } +}; + +// src/revenue/email-templates/ja-JP.ts +var jaJP4 = { + "crm.contract_expired": { + label: "\u5951\u7D04\u306E\u6E80\u4E86", + subject: "\u5951\u7D04\u304C\u6E80\u4E86\u3057\u307E\u3057\u305F: {{contract_number}}", + bodyHtml: "

\u5951\u7D04 {{contract_number}} \u306F\u7D42\u4E86\u65E5\u306B\u9054\u3057\u3001\u6E80\u4E86\u3068\u3057\u3066\u8A18\u9332\u3055\u308C\u307E\u3057\u305F\u3002

" + }, + "crm.contract_renewal": { + label: "\u5951\u7D04\u66F4\u65B0\u306E\u6642\u671F", + subject: "\u5951\u7D04\u306E\u66F4\u65B0\u6642\u671F\u3067\u3059: {{contract_number}}", + bodyHtml: "

\u5951\u7D04 {{contract_number}} \u306F {{end_date}} \u306B\u7D42\u4E86\u3057\u307E\u3059\u3002\u66F4\u65B0\u306E\u76F8\u8AC7\u3092\u59CB\u3081\u3066\u304F\u3060\u3055\u3044\u3002

" + }, + "crm.quote_created": { + label: "\u898B\u7A4D\u306E\u4F5C\u6210", + subject: "\u898B\u7A4D\u3092\u4F5C\u6210\u3057\u307E\u3057\u305F: {{quote_name}}", + bodyHtml: "

\u3053\u306E\u5546\u8AC7\u304B\u3089\u898B\u7A4D {{quote_name}} \u304C\u4F5C\u6210\u3055\u308C\u307E\u3057\u305F\u3002

" + } +}; + +// src/revenue/email-templates/es-ES.ts +var esES4 = { + "crm.contract_expired": { + label: "Contrato vencido", + subject: "Contrato vencido: {{contract_number}}", + bodyHtml: "

El contrato {{contract_number}} alcanz\xF3 su fecha de fin y se ha marcado como vencido.

" + }, + "crm.contract_renewal": { + label: "Renovaci\xF3n de contrato pendiente", + subject: "Renovaci\xF3n de contrato pendiente: {{contract_number}}", + bodyHtml: "

El contrato {{contract_number}} finaliza el {{end_date}}. Inicia ya la conversaci\xF3n de renovaci\xF3n.

" + }, + "crm.quote_created": { + label: "Presupuesto creado", + subject: "Presupuesto creado: {{quote_name}}", + bodyHtml: "

Tu presupuesto {{quote_name}} se ha creado a partir de esta oportunidad.

" + } +}; + +// src/revenue/email-templates/crm.email-template.ts +var RevenueEmailTemplates = bundle({ + "en-US": en4, + "zh-CN": zhCN4, + "ja-JP": jaJP4, + "es-ES": esES4 +}); + +// src/sales/profiles/tenant-admin.profile.ts +var TenantAdminProfile = { + name: "tenant_admin", + label: "Tenant Administrator", + // Derived, never transcribed — see the note above. Spread rather than + // aliased so the two sets are independent values in the built artifact. + objects: { ...SystemAdminProfile.objects }, + systemPermissions: [ + "view_setup", + // The one substitution this profile exists for: org-scoped member + // management instead of platform-wide user management. + "manage_org_users", + // Org-bounded by the driver's tenant predicate — see the audit above. + "view_all_data", + "modify_all_data", + "manage_sharing" + ] +}; + +// src/sales/objects/account.hook.ts +var accountHook = { + name: "account_protection", + object: "crm_account", + events: ["beforeInsert", "beforeUpdate", "beforeDelete"], + priority: 200, + description: "Validate account fields and protect customer accounts with opportunities or activated contracts from deletion.", + handler: async (ctx) => { + function refuse(message, code, status, userMessage = message) { + const err = new Error(message); + err.code = code; + err.status = status; + err.userMessage = userMessage; + return err; + } + const { event, input } = ctx; + if (event === "beforeInsert" || event === "beforeUpdate") { + if (typeof input.website === "string" && input.website.length > 0) { + if (!/^https?:\/\//i.test(input.website)) { + throw refuse("Website must start with http:// or https://", "VALIDATION_FAILED", 400); + } + } + if (typeof input.annual_revenue === "number" && input.annual_revenue < 0) { + throw refuse("Annual Revenue must be greater than or equal to 0", "VALIDATION_FAILED", 400); + } + if ("billing_address" in input || event === "beforeInsert") { + const address = input.billing_address; + const country = address !== null && typeof address === "object" && !Array.isArray(address) ? address.country : void 0; + const normalized = typeof country === "string" ? country.trim().replace(/\s+/g, " ").toUpperCase() : ""; + if ("billing_address" in input) { + input.billing_country = normalized === "" ? null : normalized; + } + const TERRITORY_BY_COUNTRY = { + "US": "na", + "CA": "na", + "MX": "na", + "GB": "emea", + "DE": "emea", + "FR": "emea", + "IT": "emea", + "ES": "emea", + "UNITED STATES": "na", + "UNITED STATES OF AMERICA": "na", + "USA": "na", + "CANADA": "na", + "MEXICO": "na", + "UK": "emea", + "UNITED KINGDOM": "emea", + "GREAT BRITAIN": "emea", + "GERMANY": "emea", + "FRANCE": "emea", + "ITALY": "emea", + "SPAIN": "emea" + }; + input.territory = TERRITORY_BY_COUNTRY[normalized] || "other"; + } + if ("name" in input) { + const rawName = input.name; + const normalizedName = typeof rawName === "string" ? rawName.trim().toLowerCase().replace(/\s+/g, " ") : ""; + input.name_normalized = normalizedName === "" ? null : normalizedName; + } + } + if (event === "beforeUpdate" && ctx.user?.id && ctx.dispatch?.mode !== "per-row") { + const prev = ctx.previous ?? {}; + const ownerChanged = typeof input.owner_id !== "undefined" && input.owner_id !== prev.owner_id; + const typeChanged = typeof input.type !== "undefined" && input.type !== prev.type; + if (ownerChanged || typeChanged) { + input.last_activity_date = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10); + } + } + if (event === "beforeDelete") { + const previous = ctx.previous; + if (!previous || previous.type !== "customer") return; + const api = ctx.api; + if (!api) return; + const opportunities2 = await api.object("crm_opportunity").count({ + where: { crm_account: previous.id } + }); + if (opportunities2 > 0) { + throw refuse( + opportunities2 === 1 ? "Cannot delete customer account: 1 opportunity, open or closed, still references it. Delete the opportunity first, or mark the account inactive to retire it instead." : `Cannot delete customer account: ${opportunities2} opportunities, open or closed, still reference it. Delete the opportunities first, or mark the account inactive to retire it instead.`, + "DELETE_RESTRICTED", + 409 + ); + } + const activeContracts = await api.object("crm_contract").count({ + where: { crm_account: previous.id, status: "activated" } + }); + if (activeContracts > 0) { + throw refuse( + activeContracts === 1 ? "Cannot delete customer account: 1 activated contract still references it. Terminate or reassign it first." : `Cannot delete customer account: ${activeContracts} activated contracts still reference it. Terminate or reassign them first.`, + "DELETE_RESTRICTED", + 409 + ); + } + } + } +}; +var account_hook_default = accountHook; + +// src/sales/objects/contact.hook.ts +var contactHook = { + name: "contact_integrity", + object: "crm_contact", + events: ["beforeInsert", "beforeUpdate", "beforeDelete"], + priority: 200, + description: "Dedupe contacts by email and protect referenced contacts from deletion.", + handler: async (ctx) => { + function refuse(message, code, status, userMessage = message) { + const err = new Error(message); + err.code = code; + err.status = status; + err.userMessage = userMessage; + return err; + } + const { event, input } = ctx; + const api = ctx.api; + if ((event === "beforeInsert" || event === "beforeUpdate") && api) { + const email = typeof input.email === "string" ? input.email.toLowerCase() : ""; + if (email) { + input.email = email; + const organizationId = [ + ctx.user?.organizationId, + ctx.session?.organizationId, + input.organization_id, + ctx.previous?.organization_id + ].find((candidate) => typeof candidate === "string" && candidate !== ""); + if (organizationId || ctx.user?.id) { + const dup = await api.object("crm_contact").findOne({ + where: organizationId ? { organization_id: organizationId, email } : { email } + }); + const dupRow = dup; + const dupId = dupRow?.id; + const selfId = ctx.previous?.id ?? input.id; + if (dup && dupId !== selfId) { + const dupName = [dupRow?.first_name, dupRow?.last_name].filter((part) => typeof part === "string" && part.trim() !== "").join(" "); + throw refuse( + dupName ? `Another contact (${dupName}) with email ${email} already exists.` : `Another contact with email ${email} already exists.`, + "DUPLICATE_VALUE", + 409 + ); + } + } + } + } + if (event === "beforeDelete" && api) { + const id = ctx.previous?.id; + if (!id) return; + const [openOpps, openQuotes, activeContracts] = await Promise.all([ + api.object("crm_opportunity").count({ + where: { primary_contact: id, stage: { $nin: ["closed_won", "closed_lost"] } } + }), + api.object("crm_quote").count({ + where: { crm_contact: id, status: { $nin: ["rejected", "expired"] } } + }), + api.object("crm_contract").count({ + where: { crm_contact: id, status: "activated" } + }) + ]); + const total = openOpps + openQuotes + activeContracts; + if (total > 0) { + const name = [ctx.previous?.first_name, ctx.previous?.last_name].filter((part) => typeof part === "string" && part.trim() !== "").join(" "); + const subject = name ? `Contact ${name}` : "This contact"; + throw refuse( + `${subject} is still referenced by ${openOpps} open opportunity(ies), ${openQuotes} active quote(s), ${activeContracts} active contract(s), so it cannot be deleted \u2014 and neither can its account, because deleting an account deletes its contacts. Close or reassign the opportunities and quotes first, and give each contract another primary contact: a contract keeps its primary contact even after it ends.`, + "DELETE_RESTRICTED", + 409 + ); + } + } + } +}; +var contact_hook_default = contactHook; + +// src/sales/objects/event.hook.ts +var eventScheduleDerive = { + name: "event_schedule_derive", + object: "crm_event", + events: ["beforeInsert", "beforeUpdate"], + priority: 200, + description: "Keep start/end/duration coherent: derive whichever of end_datetime or duration_minutes was not supplied.", + handler: async (ctx) => { + if (ctx.event === "beforeUpdate" && ctx.dispatch?.mode === "per-row") return; + const { input } = ctx; + const previous = ctx.previous; + const effective = (key) => input[key] !== void 0 && input[key] !== null ? input[key] : previous?.[key]; + const start = effective("start_datetime"); + const end = effective("end_datetime"); + const durationRaw = effective("duration_minutes"); + const startMs = typeof start === "string" || start instanceof Date ? new Date(start).getTime() : NaN; + const endMs = typeof end === "string" || end instanceof Date ? new Date(end).getTime() : NaN; + const duration = typeof durationRaw === "number" && isFinite(durationRaw) ? durationRaw : NaN; + const allDay = effective("all_day") === true; + if (!isNaN(startMs) && !isNaN(endMs)) { + if (!allDay) input.duration_minutes = Math.max(0, Math.round((endMs - startMs) / 6e4)); + } else if (!isNaN(startMs) && isNaN(endMs) && !isNaN(duration) && duration > 0) { + input.end_datetime = new Date(startMs + duration * 6e4).toISOString(); + } + const status = effective("status"); + if (status === "cancelled" || status === "no_show") input.duration_minutes = 0; + } +}; +var eventActivityBubble = { + name: "event_activity_bubble", + object: "crm_event", + events: ["afterInsert", "afterUpdate"], + priority: 800, + async: true, + onError: "log", + runAs: "system", + description: "A held event stamps interaction recency on the related account (walking up from contact/opportunity/case), lead and contact, and the first-response time on a related case.", + handler: async (ctx) => { + const { input } = ctx; + const previous = ctx.previous; + const api = ctx.api; + if (!api) return; + const r = { ...previous ?? {}, ...input }; + if (r.status !== "held") return; + if (previous && previous.status === "held") return; + const nowIso = (/* @__PURE__ */ new Date()).toISOString(); + const today = nowIso.slice(0, 10); + const idOf = (key) => typeof r[key] === "string" && r[key].length > 0 ? r[key] : void 0; + const org = idOf("organization_id"); + const inOrg = org ? { organization_id: org } : {}; + const accountIds = /* @__PURE__ */ new Set(); + const contactIds = /* @__PURE__ */ new Set(); + const leadIds = /* @__PURE__ */ new Set(); + const direct = idOf("related_to_account"); + if (direct) accountIds.add(direct); + const contactId = idOf("related_to_contact"); + if (contactId) contactIds.add(contactId); + const leadId = idOf("related_to_lead"); + if (leadId) leadIds.add(leadId); + const parentLookups = [ + ["related_to_contact", "crm_contact"], + ["related_to_opportunity", "crm_opportunity"], + ["related_to_case", "crm_case"] + ]; + for (const [field, object] of parentLookups) { + const id = idOf(field); + if (!id) continue; + try { + const raw = await api.object(object).find({ + where: { id, ...inOrg }, + fields: ["crm_account"], + top: 1 + }); + const rows = Array.isArray(raw) ? raw : raw?.records ?? []; + const parent = rows.length ? rows[0].crm_account : void 0; + if (typeof parent === "string" && parent.length > 0) accountIds.add(parent); + } catch { + } + } + const targets = [ + ["crm_account", accountIds, { last_activity_date: today }], + ["crm_contact", contactIds, { last_contacted_date: nowIso }], + ["crm_lead", leadIds, { last_contacted_date: nowIso }] + ]; + for (const [object, ids, doc] of targets) { + let inside = [...ids]; + if (org && inside.length > 0) { + try { + const raw = await api.object(object).find({ where: { id: { $in: inside }, ...inOrg }, fields: ["id"], top: inside.length }); + inside = (Array.isArray(raw) ? raw : raw?.records ?? []).map((row) => String(row.id)); + } catch { + inside = []; + } + } + for (const id of inside) { + try { + await api.object(object).update({ ...doc, id }, { where: { id } }); + } catch { + } + } + } + const responseCaseId = idOf("related_to_case"); + if (responseCaseId) { + try { + const raw = await api.object("crm_case").find({ + where: { id: responseCaseId, ...inOrg }, + fields: ["first_response_date"], + top: 1 + }); + const rows = Array.isArray(raw) ? raw : raw?.records ?? []; + if (rows.length > 0 && !rows[0].first_response_date) { + await api.object("crm_case").update( + { id: responseCaseId, first_response_date: nowIso }, + { where: { id: responseCaseId } } + ); + } + } catch { + } + } + } +}; +var eventDoNotCallGuard = { + name: "event_do_not_call_guard", + object: "crm_event", + events: ["beforeInsert", "beforeUpdate"], + priority: 150, + description: "Refuse to book a planned Call event against a lead/contact flagged Do Not Call.", + handler: async (ctx) => { + function refuse(message, code, status, userMessage = message) { + const err = new Error(message); + err.code = code; + err.status = status; + err.userMessage = userMessage; + return err; + } + const { input } = ctx; + const previous = ctx.previous; + const api = ctx.api; + if (!api) return; + const effective = (key) => input[key] !== void 0 && input[key] !== null ? input[key] : previous?.[key]; + if (effective("type") !== "call") return; + if (effective("status") !== "planned") return; + const leadId = effective("related_to_lead"); + const contactId = effective("related_to_contact"); + const targets = []; + if (typeof leadId === "string" && leadId) { + targets.push({ object: "crm_lead", id: leadId, label: "lead" }); + } + if (typeof contactId === "string" && contactId) { + targets.push({ object: "crm_contact", id: contactId, label: "contact" }); + } + for (const t of targets) { + const raw = await api.object(t.object).find({ + where: { id: t.id }, + fields: ["id", "do_not_call"], + top: 1 + }); + const rows = Array.isArray(raw) ? raw : raw?.records ?? []; + const person = rows[0]; + if (person?.do_not_call === true) { + throw refuse( + `This ${t.label} is flagged Do Not Call, so a call cannot be scheduled against them. Log the call as held if it already happened, book a meeting instead, or clear Do Not Call on the record first.`, + "FORBIDDEN", + 403 + ); + } + } + } +}; +var event_hook_default = [eventScheduleDerive, eventDoNotCallGuard, eventActivityBubble]; + +// src/sales/objects/forecast.hook.ts +var forecastDerive = { + name: "forecast_derive_period", + object: "crm_forecast", + events: ["beforeInsert", "beforeUpdate"], + priority: 200, + description: "Derive period_start, period_end and period_label from period (+ snapshot_date).", + handler: async (ctx) => { + if (ctx.event === "beforeUpdate" && ctx.dispatch?.mode === "per-row") return; + const pad = (n) => String(n).padStart(2, "0"); + const isoDate = (d) => `${d.getUTCFullYear()}-${pad(d.getUTCMonth() + 1)}-${pad(d.getUTCDate())}`; + const MONTHS = ["Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"]; + const endOfMonth = (start) => new Date(Date.UTC(start.getUTCFullYear(), start.getUTCMonth() + 1, 0)); + const endOfQuarter = (start) => new Date(Date.UTC(start.getUTCFullYear(), start.getUTCMonth() + 3, 0)); + const startOfPeriod = (period2, d) => new Date(Date.UTC( + d.getUTCFullYear(), + period2 === "quarter" ? Math.floor(d.getUTCMonth() / 3) * 3 : d.getUTCMonth(), + 1 + )); + const labelFor = (period2, start) => { + if (period2 === "quarter") { + const q = Math.floor(start.getUTCMonth() / 3) + 1; + return `Q${q} ${start.getUTCFullYear()}`; + } + return `${MONTHS[start.getUTCMonth()]} ${start.getUTCFullYear()}`; + }; + const { input } = ctx; + const previous = ctx.previous; + const period = typeof input.period === "string" && input.period || typeof previous?.period === "string" && previous.period || "month"; + let startStr = typeof input.period_start === "string" && input.period_start || typeof previous?.period_start === "string" && previous.period_start || void 0; + if (!startStr) { + const anchorStr = typeof input.snapshot_date === "string" && input.snapshot_date || typeof previous?.snapshot_date === "string" && previous.snapshot_date || isoDate(/* @__PURE__ */ new Date()); + const anchor = /* @__PURE__ */ new Date(`${anchorStr.slice(0, 10)}T00:00:00Z`); + if (!Number.isNaN(anchor.getTime())) { + startStr = isoDate(startOfPeriod(period, anchor)); + input.period_start = startStr; + } + } + if (startStr) { + const start = /* @__PURE__ */ new Date(`${startStr}T00:00:00Z`); + if (!Number.isNaN(start.getTime())) { + const end = period === "quarter" ? endOfQuarter(start) : endOfMonth(start); + if (!input.period_end) input.period_end = isoDate(end); + if (!input.period_label) input.period_label = labelFor(period, start); + } + } + if (!input.snapshot_date && !previous?.snapshot_date) { + input.snapshot_date = isoDate(/* @__PURE__ */ new Date()); + } + } +}; +var forecast_hook_default = forecastDerive; + +// src/sales/objects/lead.hook.ts +var leadAutoAssignHook = { + name: "lead_auto_assign", + object: "crm_lead", + events: ["beforeInsert"], + priority: 250, + description: "Assign ownerless new leads to the least-loaded sales rep.", + handler: async (ctx) => { + const { input } = ctx; + if (typeof input.owner_id === "string" && input.owner_id) return; + const api = ctx.api; + if (!api) return; + try { + const holders = await api.object("sys_user_position").find({ + where: { position: "sales_rep" }, + fields: ["user_id"], + top: 1e3 + }); + const repIds = Array.from( + new Set( + (holders ?? []).map((r) => typeof r.user_id === "string" ? r.user_id : "").filter(Boolean) + ) + ); + if (repIds.length === 0) return; + let best; + let bestCount = Infinity; + for (const repId of repIds) { + const openCount = await api.object("crm_lead").count({ + where: { owner_id: repId, is_converted: false } + }); + if (openCount < bestCount) { + bestCount = openCount; + best = repId; + } + } + if (best) input.owner_id = best; + } catch { + } + } +}; +var leadHook = { + name: "lead_automation", + object: "crm_lead", + events: ["beforeInsert", "beforeUpdate", "afterUpdate"], + priority: 200, + description: "Score new leads, lock converted leads, and create follow-up task on qualification.", + handler: async (ctx) => { + function refuse(message, code, status, userMessage = message) { + const err = new Error(message); + err.code = code; + err.status = status; + err.userMessage = userMessage; + return err; + } + const { event, input } = ctx; + const HIGH_VALUE_INDUSTRIES = /* @__PURE__ */ new Set(["technology", "finance", "healthcare"]); + const SENIOR_TITLE_PATTERN = /\b(ceo|cto|cfo|cio|coo|founder|vp|vice president|director|head of)\b/i; + function computeRating(input2) { + let score = 0; + const email = typeof input2.email === "string" ? input2.email : ""; + const phone = typeof input2.phone === "string" ? input2.phone : ""; + const title = typeof input2.title === "string" ? input2.title : ""; + const industry = typeof input2.industry === "string" ? input2.industry : ""; + const employees = typeof input2.number_of_employees === "number" ? input2.number_of_employees : 0; + const revenue = typeof input2.annual_revenue === "number" ? input2.annual_revenue : 0; + if (email && !/(gmail|yahoo|hotmail|outlook|qq|163)\.com$/i.test(email)) score += 1; + if (phone.length > 0) score += 0.5; + if (SENIOR_TITLE_PATTERN.test(title)) score += 1.5; + if (HIGH_VALUE_INDUSTRIES.has(industry)) score += 1; + if (employees >= 200) score += 0.5; + if (revenue >= 1e7) score += 0.5; + const clamped = Math.max(1, Math.min(5, score)); + return Math.round(clamped); + } + if (event === "beforeInsert") { + const isGuestSubmission = !ctx.user?.id && !ctx.session?.isSystem; + if (isGuestSubmission) { + if (!input.lead_source) input.lead_source = "web"; + if (!input.status) input.status = "new"; + input.is_converted = false; + input.converted_account = null; + input.converted_contact = null; + input.converted_opportunity = null; + input.converted_date = null; + input.owner_id = null; + input.duplicate_of_type = null; + input.duplicate_of_lead = null; + input.duplicate_of_contact = null; + input.duplicate_status = null; + } + if (typeof input.rating !== "number") { + input.rating = computeRating(input); + } + } + if (event === "beforeUpdate") { + const previous = ctx.previous; + const wasConverted = previous?.is_converted === true || previous?.status === "converted"; + const isConverting = !wasConverted && (input.is_converted === true || input.status === "converted"); + const verdict = previous?.conversion_approval_status; + if (isConverting && (verdict === "pending" || verdict === "rejected")) { + const person = [previous?.first_name, previous?.last_name].filter((part) => typeof part === "string" && part.trim() !== "").join(" "); + const company = typeof previous?.company === "string" ? previous.company.trim() : ""; + const label = [person, company].filter(Boolean).join(" - "); + const state = verdict === "rejected" ? "was rejected" : "is still awaiting approval"; + throw refuse( + `Cannot convert ${label ? `lead ${label}` : "this lead"}: its conversion ${state}. Conversion opens once an approver signs it off \u2014 the Conversion Approval field on the lead shows where it stands.`, + "RECORD_LOCKED", + 409 + ); + } + } + if (event === "beforeUpdate" && ctx.user?.id) { + const previous = ctx.previous; + const wasConverted = previous?.is_converted === true || previous?.status === "converted"; + if (wasConverted) { + const ALLOWED = /* @__PURE__ */ new Set([ + "description", + "notes", + // Framework-managed / system columns (cf. opportunity.hook.ts). + "id", + "owner_id", + "created_at", + "updated_at", + "created_by", + "updated_by", + "space_id", + "organization_id", + "org_id", + "version" + ]); + const violating = Object.keys(input).filter( + (k) => !ALLOWED.has(k) && input[k] !== previous?.[k] + ); + if (violating.length > 0) { + const REFERENCE_FIELDS = /* @__PURE__ */ new Set([ + "converted_account", + "converted_contact", + "converted_opportunity", + "duplicate_of_lead", + "duplicate_of_contact" + ]); + const isReferenceCleanup = violating.every( + (k) => REFERENCE_FIELDS.has(k) && input[k] === null && previous?.[k] != null + ); + if (isReferenceCleanup) return; + const person = [previous?.first_name, previous?.last_name].filter((part) => typeof part === "string" && part.trim() !== "").join(" "); + const company = typeof previous?.company === "string" ? previous.company.trim() : ""; + const label = [person, company].filter(Boolean).join(" - "); + throw refuse( + `Cannot edit ${label ? `converted lead ${label}` : "a converted lead"} (attempted: ${violating.join(", ")}). Make changes on the converted records instead.`, + "RECORD_LOCKED", + 409 + ); + } + } + } + if (event === "afterUpdate") { + const previous = ctx.previous; + const becameQualified = input.status === "qualified" && previous?.status !== "qualified"; + if (!becameQualified) return; + const api = ctx.api; + if (!api) return; + const leadId = typeof input.id === "string" && input.id || typeof previous?.id === "string" && previous.id || void 0; + const ownerId = typeof input.owner_id === "string" && input.owner_id || typeof previous?.owner_id === "string" && previous.owner_id || ctx.user?.id; + const dueDate = /* @__PURE__ */ new Date(); + dueDate.setUTCDate(dueDate.getUTCDate() + 2); + const person = [ + typeof input.first_name === "string" && input.first_name || previous?.first_name, + typeof input.last_name === "string" && input.last_name || previous?.last_name + ].filter((part) => typeof part === "string" && part.trim() !== "").join(" "); + const company = typeof input.company === "string" && input.company.trim() || typeof previous?.company === "string" && previous.company.trim() || ""; + const label = [person, company].filter(Boolean).join(" - "); + const titled = label ? `Follow up with qualified lead: ${label}` : "Follow up with qualified lead"; + try { + await api.object("crm_task").insert({ + subject: titled.length > 255 ? `${titled.slice(0, 254)}\u2026` : titled, + status: "not_started", + priority: "high", + type: "follow_up", + due_date: dueDate.toISOString().slice(0, 10), + // Unlike `lead_auto_assign` above, this is a SEPARATE insert on + // `ctx.api` — a new operation carrying the caller's context, so the + // #3004 transfer guard does apply to it. When the qualifier is the + // lead's own rep (`owner_id` == caller) it is not a transfer at all; + // a manager qualifying a rep's lead holds `allowTransfer`. Any other + // caller is denied and the catch below drops the task rather than + // landing it on the wrong desk. + owner_id: ownerId, + related_to_type: "crm_lead", + related_to_lead: leadId + }); + } catch { + } + } + } +}; +var leadDuplicateCheckHook = { + name: "lead_duplicate_check", + object: "crm_lead", + events: ["beforeInsert", "beforeUpdate"], + priority: 300, + description: "Normalize lead email and company match key; flag a re-captured address as a suspected duplicate of the record it repeats.", + handler: async (ctx) => { + const { event, input } = ctx; + const SCAN_LIMIT = 50; + const isBlank = (value) => value === void 0 || value === null || typeof value === "string" && value.trim() === ""; + if (typeof input.email === "string") { + input.email = input.email.trim().toLowerCase(); + } + const email = typeof input.email === "string" ? input.email : ""; + if ("company" in input) { + const rawCompany = input.company; + const normalizedCompany = typeof rawCompany === "string" ? rawCompany.trim().toLowerCase().replace(/\s+/g, " ") : ""; + input.company_normalized = normalizedCompany === "" ? null : normalizedCompany; + } + if (event === "beforeUpdate" && ctx.dispatch?.mode !== "per-row") { + const previous = ctx.previous; + const LINK_OF_TYPE = { + crm_lead: "duplicate_of_lead", + crm_contact: "duplicate_of_contact" + }; + const restated = "duplicate_of_type" in input && !isBlank(input.duplicate_of_type); + const declared = previous?.duplicate_of_type; + const link = typeof declared === "string" ? LINK_OF_TYPE[declared] : void 0; + if (!restated && link && link in input && isBlank(input[link])) { + if (!("duplicate_status" in input) && previous?.duplicate_status === "confirmed") { + input.duplicate_of_type = "erased"; + } else { + input.duplicate_of_type = null; + input.duplicate_status = null; + } + } + } + if (event !== "beforeInsert" || !email) return; + if (!isBlank(input.duplicate_status) || !isBlank(input.duplicate_of_type)) return; + const api = ctx.api; + if (!api) return; + const original = (rows) => { + let best; + let bestKey = Infinity; + for (const row of rows) { + const id = typeof row.id === "string" ? row.id : ""; + if (!id) continue; + const raw = row.created_at; + const parsed = typeof raw === "string" || typeof raw === "number" || raw instanceof Date ? new Date(raw).getTime() : Number.NaN; + const key = Number.isFinite(parsed) ? parsed : Infinity; + if (best === void 0 || key < bestKey) { + best = id; + bestKey = key; + } + } + return best; + }; + try { + const contacts2 = await api.object("crm_contact").find({ + where: { email }, + fields: ["id", "created_at"], + top: SCAN_LIMIT + }); + const contactId = original(contacts2 ?? []); + if (contactId) { + input.duplicate_of_type = "crm_contact"; + input.duplicate_of_contact = contactId; + input.duplicate_status = "suspected"; + return; + } + const leads2 = await api.object("crm_lead").find({ + where: { email, is_converted: false }, + fields: ["id", "created_at"], + top: SCAN_LIMIT + }); + const leadId = original(leads2 ?? []); + if (leadId) { + input.duplicate_of_type = "crm_lead"; + input.duplicate_of_lead = leadId; + input.duplicate_status = "suspected"; + } + } catch { + } + } +}; +var lead_hook_default = [leadAutoAssignHook, leadHook, leadDuplicateCheckHook]; + +// src/sales/objects/lead.campaign-metrics.hook.ts +var campaignLeadConversionRefresh = { + name: "campaign_lead_conversion_refresh", + object: "crm_lead", + events: ["afterUpdate"], + priority: 810, + async: true, + onError: "log", + runAs: "system", + description: "Promote campaign members of a converting lead and recompute campaign metrics.", + handler: async (ctx) => { + const api = ctx.api; + if (!api) return; + const { input } = ctx; + const previous = ctx.previous; + if (input?.is_converted !== true) return; + if (previous?.is_converted === true) return; + const leadId = typeof input?.id === "string" && input.id || (typeof previous?.id === "string" ? previous.id : ""); + if (!leadId) return; + const memberships = await api.object("crm_campaign_member").find({ + where: { crm_lead: leadId }, + fields: ["id", "crm_campaign", "status"], + top: 500 + }); + for (const m of memberships) { + const memberId = typeof m.id === "string" ? m.id : ""; + if (!memberId) continue; + if (m.status !== "sent" && m.status !== "responded") continue; + await api.object("crm_campaign_member").update( + { id: memberId, status: "converted" }, + { where: { id: memberId } } + ); + } + const campaignIds = Array.from(new Set( + memberships.map((m) => typeof m.crm_campaign === "string" ? m.crm_campaign : "").filter(Boolean) + )); + for (const id of campaignIds) { + const memberRows = await api.object("crm_campaign_member").find({ + where: { crm_campaign: id }, + fields: ["crm_lead", "status"], + top: 5e3 + }); + const leadIds = Array.from(new Set( + memberRows.map((r) => typeof r.crm_lead === "string" ? r.crm_lead : "").filter(Boolean) + )); + const convertedLeads = leadIds.length > 0 ? await api.object("crm_lead").count({ where: { id: { $in: leadIds }, is_converted: true } }) : 0; + const numOpportunities = await api.object("crm_opportunity").count({ where: { crm_campaign: id } }); + const numWon = await api.object("crm_opportunity").count({ where: { crm_campaign: id, stage: "closed_won" } }); + const wonRows = await api.object("crm_opportunity").find({ + where: { crm_campaign: id, stage: "closed_won" }, + fields: ["amount"], + top: 5e3 + }); + const actualRevenue = wonRows.reduce( + (sum, row) => sum + (typeof row.amount === "number" ? row.amount : Number(row.amount) || 0), + 0 + ); + await api.object("crm_campaign").update({ + id, + num_sent: memberRows.length, + num_responses: memberRows.filter((r) => r.status === "responded" || r.status === "converted").length, + num_leads: leadIds.length, + num_converted_leads: convertedLeads, + num_opportunities: numOpportunities, + num_won_opportunities: numWon, + actual_revenue: actualRevenue + }, { where: { id } }); + } + } +}; +var lead_campaign_metrics_hook_default = [campaignLeadConversionRefresh]; + +// src/sales/objects/opportunity.hook.ts +var opportunityValidationHook = { + name: "opportunity_lifecycle", + object: "crm_opportunity", + events: ["beforeInsert", "beforeUpdate"], + priority: 200, + description: "Recompute expected_revenue, freeze closed opportunities except narrative fields.", + handler: async (ctx) => { + function refuse(message, code, status, userMessage = message) { + const err = new Error(message); + err.code = code; + err.status = status; + err.userMessage = userMessage; + return err; + } + const STAGE_PROBABILITY = { + prospecting: 10, + qualification: 25, + needs_analysis: 40, + proposal: 60, + negotiation: 80, + closed_won: 100, + closed_lost: 0 + }; + const NARRATIVE_FIELDS = /* @__PURE__ */ new Set(["description", "next_step", "notes"]); + const SYSTEM_FIELDS = /* @__PURE__ */ new Set([ + "id", + "owner_id", + "created_at", + "updated_at", + "created_by", + "updated_by", + "space_id", + "organization_id", + "org_id", + "version" + ]); + const APPROVAL_FIELDS = /* @__PURE__ */ new Set([ + "approval_status", + "approved_date", + "status_change_approval_status", + "requested_status", + "qualification_approval_status", + "qualification_requested" + ]); + const STAGE_FORECAST = { + prospecting: "pipeline", + qualification: "pipeline", + needs_analysis: "best_case", + proposal: "commit", + negotiation: "commit", + closed_won: "closed", + closed_lost: "omitted" + }; + const { event, input } = ctx; + const previous = ctx.previous; + if (event === "beforeUpdate" && previous && ctx.user?.id) { + const qualification = input.qualification_approval_status ?? previous.qualification_approval_status; + if (qualification === "pending" || qualification === "rejected") { + const held = []; + if (typeof input.stage === "string" && input.stage !== previous.stage) held.push("Stage"); + if (typeof input.requested_status === "string" && input.requested_status !== "" && input.requested_status !== previous.requested_status) { + held.push("Requested Status"); + } + if (held.length > 0) { + throw refuse( + `This deal needs qualification approval first: tick Request Qualification Approval. ${held.join(" and ")} can change once it is approved.`, + "RECORD_LOCKED", + 409 + ); + } + } + } + if (event === "beforeUpdate" && previous && ctx.user?.id) { + const gate = input.status_change_approval_status ?? previous.status_change_approval_status; + const next = input.stage; + const closing = (next === "closed_won" || next === "closed_lost") && next !== previous.stage; + if (closing && (gate === "pending" || gate === "rejected")) { + throw refuse( + "This deal's status change needs approval: set Requested Status (and the win/loss reason) instead. The stage takes effect when the request is approved.", + "RECORD_LOCKED", + 409 + ); + } + } + if (event === "beforeUpdate" && previous && ctx.user?.id) { + const prevStage = previous.stage; + const isClosed = prevStage === "closed_won" || prevStage === "closed_lost"; + if (isClosed) { + const violating = Object.keys(input).filter( + (k) => !NARRATIVE_FIELDS.has(k) && !SYSTEM_FIELDS.has(k) && !APPROVAL_FIELDS.has(k) && input[k] !== previous[k] + ); + if (violating.length > 0) { + const REFERENCE_FIELDS = /* @__PURE__ */ new Set(["crm_account", "primary_contact", "crm_campaign"]); + const isReferenceCleanup = violating.every( + (k) => REFERENCE_FIELDS.has(k) && input[k] === null && previous?.[k] != null + ); + if (isReferenceCleanup) return; + const name = typeof previous.name === "string" ? previous.name.trim() : ""; + const subject = name ? `Opportunity ${name}` : "Opportunity"; + throw refuse( + `${subject} is closed (${prevStage}); only ${[...NARRATIVE_FIELDS].join(", ")} may be edited. Attempted: ${violating.join(", ")}.`, + "RECORD_LOCKED", + 409 + ); + } + } + } + if (ctx.event === "beforeUpdate" && ctx.dispatch?.mode === "per-row") return; + const amount = typeof input.amount === "number" ? input.amount : typeof previous?.amount === "number" ? previous.amount : void 0; + const stage = typeof input.stage === "string" ? input.stage : typeof previous?.stage === "string" ? previous.stage : void 0; + if (typeof amount === "number" && stage && STAGE_PROBABILITY[stage] !== void 0) { + input.expected_revenue = Math.round(amount * STAGE_PROBABILITY[stage]) / 100; + } + if (stage && STAGE_PROBABILITY[stage] !== void 0) { + input.probability = STAGE_PROBABILITY[stage]; + } + if (stage && STAGE_FORECAST[stage] !== void 0) { + const stageChanged = event === "beforeInsert" || typeof input.stage === "string" && input.stage !== previous?.stage; + if (stageChanged) input.forecast_category = STAGE_FORECAST[stage]; + } + if (event === "beforeInsert" && !input.stage_entry_date) { + input.stage_entry_date = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10); + } + if (event === "beforeUpdate" && previous) { + if (input.stage === "closed_won" && previous.stage !== "closed_won" && !input.close_date) { + input.close_date = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10); + } + if (typeof input.stage === "string" && input.stage !== previous.stage) { + input.stage_entry_date = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10); + } + } + } +}; +var opportunityWonHook = { + name: "opportunity_promote_account", + object: "crm_opportunity", + events: ["afterUpdate"], + priority: 800, + async: true, + onError: "log", + runAs: "system", + description: "On closed_won: promote linked account to customer and create activation task.", + handler: async (ctx) => { + const { input } = ctx; + const previous = ctx.previous; + const becameWon = input.stage === "closed_won" && previous?.stage !== "closed_won"; + if (!becameWon) return; + const api = ctx.api; + if (!api) return; + const accountId = typeof input.crm_account === "string" && input.crm_account || typeof previous?.crm_account === "string" && previous.crm_account || void 0; + if (!accountId) return; + const account = await api.object("crm_account").findOne({ where: { id: accountId } }); + if (account && account.type !== "customer") { + await api.object("crm_account").update( + { id: accountId, type: "customer" }, + { where: { id: accountId } } + ); + } + const oppId = typeof input.id === "string" && input.id || previous?.id; + const ownerId = typeof input.owner_id === "string" && input.owner_id || typeof previous?.owner_id === "string" && previous.owner_id || ctx.user?.id; + const due = /* @__PURE__ */ new Date(); + due.setUTCDate(due.getUTCDate() + 3); + const oppName = typeof input.name === "string" && input.name.trim() || typeof previous?.name === "string" && previous.name.trim() || ""; + const titled = oppName ? `Activate new customer for opportunity ${oppName}` : "Activate new customer"; + await api.object("crm_task").insert({ + subject: titled.length > 255 ? `${titled.slice(0, 254)}\u2026` : titled, + status: "not_started", + priority: "high", + type: "follow_up", + due_date: due.toISOString().slice(0, 10), + owner_id: ownerId, + related_to_type: "crm_opportunity", + related_to_opportunity: oppId, + related_to_account: accountId + }); + } +}; +var opportunityAccountCapabilityHook = { + name: "opportunity_account_capability", + object: "crm_opportunity", + events: ["beforeInsert"], + priority: 150, + runAs: "system", + description: "Refuse a NEW opportunity linked to an account whose commercial capability is settlement only.", + handler: async (ctx) => { + function refuse(message, code, status, userMessage = message) { + const err = new Error(message); + err.code = code; + err.status = status; + err.userMessage = userMessage; + return err; + } + const api = ctx.api; + if (!api) return; + const accountId = ctx.input.crm_account; + if (typeof accountId !== "string" || accountId === "") return; + const org = ctx.input.organization_id; + const account = await api.object("crm_account").findOne({ + where: { id: accountId, ...typeof org === "string" && org ? { organization_id: org } : {} }, + fields: ["commercial_capability"] + }); + if (!account || account.commercial_capability !== "settlement_only") return; + throw refuse( + "Cannot open an opportunity against this account: its Commercial Capability is Settlement Only, so it is available for billing and payment but no new business may be booked against it. Pick a different account, or have the account reclassified to Full first.", + "VALIDATION_FAILED", + 400 + ); + } +}; +var opportunity_hook_default = [ + opportunityAccountCapabilityHook, + opportunityValidationHook, + opportunityWonHook +]; + +// src/sales/objects/opportunity.campaign-metrics.hook.ts +var campaignAttributionRefresh = { + name: "campaign_attribution_refresh", + object: "crm_opportunity", + events: ["afterInsert", "afterUpdate", "afterDelete"], + priority: 810, + async: true, + onError: "log", + runAs: "system", + description: "Recompute campaign metrics when an opportunity\u2019s campaign attribution changes.", + handler: async (ctx) => { + const api = ctx.api; + if (!api) return; + const { input } = ctx; + const previous = ctx.previous; + const campaignIds = Array.from(new Set([ + typeof input?.crm_campaign === "string" ? input.crm_campaign : "", + typeof previous?.crm_campaign === "string" ? previous.crm_campaign : "" + ].filter(Boolean))); + for (const id of campaignIds) { + const memberRows = await api.object("crm_campaign_member").find({ + where: { crm_campaign: id }, + fields: ["crm_lead", "status"], + top: 5e3 + }); + const leadIds = Array.from(new Set( + memberRows.map((r) => typeof r.crm_lead === "string" ? r.crm_lead : "").filter(Boolean) + )); + const convertedLeads = leadIds.length > 0 ? await api.object("crm_lead").count({ where: { id: { $in: leadIds }, is_converted: true } }) : 0; + const numOpportunities = await api.object("crm_opportunity").count({ where: { crm_campaign: id } }); + const numWon = await api.object("crm_opportunity").count({ where: { crm_campaign: id, stage: "closed_won" } }); + const wonRows = await api.object("crm_opportunity").find({ + where: { crm_campaign: id, stage: "closed_won" }, + fields: ["amount"], + top: 5e3 + }); + const actualRevenue = wonRows.reduce( + (sum, row) => sum + (typeof row.amount === "number" ? row.amount : Number(row.amount) || 0), + 0 + ); + await api.object("crm_campaign").update({ + id, + num_sent: memberRows.length, + num_responses: memberRows.filter((r) => r.status === "responded" || r.status === "converted").length, + num_leads: leadIds.length, + num_converted_leads: convertedLeads, + num_opportunities: numOpportunities, + num_won_opportunities: numWon, + actual_revenue: actualRevenue + }, { where: { id } }); + } + } +}; +var opportunity_campaign_metrics_hook_default = [campaignAttributionRefresh]; + +// src/sales/objects/task.hook.ts +var taskValidation = { + name: "task_completion", + object: "crm_task", + events: ["beforeInsert", "beforeUpdate"], + priority: 200, + description: "Stamp completed/overdue flags + dates on completion and validate reminder timing.", + handler: async (ctx) => { + if (ctx.event === "beforeUpdate" && ctx.dispatch?.mode === "per-row") return; + function refuse(message, code, status, userMessage = message) { + const err = new Error(message); + err.code = code; + err.status = status; + err.userMessage = userMessage; + return err; + } + const { input } = ctx; + const previous = ctx.previous; + if (!previous && input.reminder_sent == null) { + input.reminder_sent = false; + } + const effPriority = typeof input.priority === "string" && input.priority || typeof previous?.priority === "string" && previous.priority || void 0; + if (effPriority) { + const rank = { low: 1, normal: 2, high: 3, urgent: 4 }; + input.priority_rank = rank[effPriority] ?? 0; + } + if (input.status === "completed" && previous?.status !== "completed") { + if (!input.completed_date || !ctx.session?.isSystem) { + input.completed_date = (/* @__PURE__ */ new Date()).toISOString(); + } + if (typeof input.progress_percent !== "number") input.progress_percent = 100; + } + const effStatus = typeof input.status === "string" && input.status || typeof previous?.status === "string" && previous.status || void 0; + if (typeof effStatus === "string") input.is_completed = effStatus === "completed"; + const effDue = typeof input.due_date === "string" && input.due_date || typeof previous?.due_date === "string" && previous.due_date || void 0; + const todayStr = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10); + input.is_overdue = !!effDue && effDue.slice(0, 10) < todayStr && input.is_completed !== true; + const reminder = typeof input.reminder_date === "string" && input.reminder_date || typeof previous?.reminder_date === "string" && previous.reminder_date || void 0; + const due = typeof input.due_date === "string" && input.due_date || typeof previous?.due_date === "string" && previous.due_date || void 0; + if (reminder && due && reminder.slice(0, 10) > due.slice(0, 10)) { + throw refuse( + `Reminder (${reminder}) is after the due date (${due}); reminders should fire before the deadline.`, + "VALIDATION_FAILED", + 400 + ); + } + } +}; +var taskRecurrence = { + name: "task_recurrence", + object: "crm_task", + events: ["afterUpdate"], + priority: 700, + async: true, + onError: "log", + description: "On completion of a recurring task, spawn the next occurrence (dates advanced by recurrence_type \xD7 interval).", + handler: async (ctx) => { + function advanceDate(d, type2, interval2) { + const next = new Date(d); + if (type2 === "daily") { + next.setUTCDate(next.getUTCDate() + interval2); + return next; + } + if (type2 === "weekly") { + next.setUTCDate(next.getUTCDate() + 7 * interval2); + return next; + } + const months = type2 === "monthly" ? interval2 : type2 === "yearly" ? 12 * interval2 : 0; + if (months === 0) return next; + const day = next.getUTCDate(); + next.setUTCDate(1); + next.setUTCMonth(next.getUTCMonth() + months); + const lastDayOfTargetMonth = new Date(Date.UTC( + next.getUTCFullYear(), + next.getUTCMonth() + 1, + 0 + )).getUTCDate(); + next.setUTCDate(Math.min(day, lastDayOfTargetMonth)); + return next; + } + const { input } = ctx; + const previous = ctx.previous; + const api = ctx.api; + if (!api) return; + const nowDone = input.status === "completed" || input.is_completed === true; + const wasDone = previous?.status === "completed" || previous?.is_completed === true; + if (!nowDone || wasDone) return; + const r = { ...previous ?? {}, ...input }; + if (r.is_recurring !== true) return; + const type = typeof r.recurrence_type === "string" ? r.recurrence_type : void 0; + if (!type || !["daily", "weekly", "monthly", "yearly"].includes(type)) return; + const interval = Number(r.recurrence_interval) > 0 ? Number(r.recurrence_interval) : 1; + const baseDue = r.due_date ? new Date(r.due_date) : /* @__PURE__ */ new Date(); + if (isNaN(baseDue.getTime())) return; + const nextDue = advanceDate(baseDue, type, interval); + if (r.recurrence_end_date) { + const end = new Date(r.recurrence_end_date); + if (!isNaN(end.getTime()) && nextDue > end) return; + } + const doc = { + subject: r.subject, + description: r.description ?? null, + priority: r.priority, + type: r.type ?? null, + owner_id: r.owner_id ?? null, + status: "not_started", + is_completed: false, + reminder_sent: false, + due_date: nextDue.toISOString().slice(0, 10), + is_recurring: true, + recurrence_type: type, + recurrence_interval: interval, + recurrence_end_date: r.recurrence_end_date ?? null, + related_to_type: r.related_to_type ?? null, + related_to_account: r.related_to_account ?? null, + related_to_contact: r.related_to_contact ?? null, + related_to_opportunity: r.related_to_opportunity ?? null, + related_to_lead: r.related_to_lead ?? null, + related_to_case: r.related_to_case ?? null + }; + if (r.reminder_date) { + const baseRem = new Date(r.reminder_date); + if (!isNaN(baseRem.getTime())) doc.reminder_date = advanceDate(baseRem, type, interval).toISOString(); + } + try { + await api.object("crm_task").insert(doc); + } catch { + } + } +}; +var taskBubble = { + name: "task_activity_bubble", + object: "crm_task", + events: ["afterUpdate"], + priority: 800, + async: true, + onError: "log", + runAs: "system", + description: "A completed task stamps interaction recency on the related account (walking up from contact/opportunity/case), lead and contact.", + handler: async (ctx) => { + const { input } = ctx; + const previous = ctx.previous; + const api = ctx.api; + if (!api) return; + const nowDone = input.status === "completed" || input.is_completed === true; + const wasDone = previous?.status === "completed" || previous?.is_completed === true; + if (!nowDone || wasDone) return; + const r = { ...previous ?? {}, ...input }; + const nowIso = (/* @__PURE__ */ new Date()).toISOString(); + const today = nowIso.slice(0, 10); + const idOf = (key) => typeof r[key] === "string" && r[key].length > 0 ? r[key] : void 0; + const org = idOf("organization_id"); + const inOrg = org ? { organization_id: org } : {}; + const accountIds = /* @__PURE__ */ new Set(); + const contactIds = /* @__PURE__ */ new Set(); + const leadIds = /* @__PURE__ */ new Set(); + const direct = idOf("related_to_account"); + if (direct) accountIds.add(direct); + const contactId = idOf("related_to_contact"); + if (contactId) contactIds.add(contactId); + const leadId = idOf("related_to_lead"); + if (leadId) leadIds.add(leadId); + const parentLookups = [ + ["related_to_contact", "crm_contact"], + ["related_to_opportunity", "crm_opportunity"], + ["related_to_case", "crm_case"] + ]; + for (const [field, object] of parentLookups) { + const id = idOf(field); + if (!id) continue; + try { + const raw = await api.object(object).find({ + where: { id, ...inOrg }, + fields: ["crm_account"], + top: 1 + }); + const rows = Array.isArray(raw) ? raw : raw?.records ?? []; + const parent = rows.length ? rows[0].crm_account : void 0; + if (typeof parent === "string" && parent.length > 0) accountIds.add(parent); + } catch { + } + } + const targets = [ + ["crm_account", accountIds, { last_activity_date: today }], + ["crm_contact", contactIds, { last_contacted_date: nowIso }], + ["crm_lead", leadIds, { last_contacted_date: nowIso }] + ]; + for (const [object, ids, doc] of targets) { + let inside = [...ids]; + if (org && inside.length > 0) { + try { + const raw = await api.object(object).find({ where: { id: { $in: inside }, ...inOrg }, fields: ["id"], top: inside.length }); + inside = (Array.isArray(raw) ? raw : raw?.records ?? []).map((row) => String(row.id)); + } catch { + inside = []; + } + } + for (const id of inside) { + try { + await api.object(object).update({ ...doc, id }, { where: { id } }); + } catch { + } + } + } + } +}; +var taskDoNotCallGuard = { + name: "task_do_not_call_guard", + object: "crm_task", + events: ["beforeInsert", "beforeUpdate"], + priority: 150, + description: "Refuse to schedule an open Call task against a lead/contact flagged Do Not Call.", + handler: async (ctx) => { + function refuse(message, code, status, userMessage = message) { + const err = new Error(message); + err.code = code; + err.status = status; + err.userMessage = userMessage; + return err; + } + const { input } = ctx; + const previous = ctx.previous; + const api = ctx.api; + if (!api) return; + const effective = (key) => input[key] !== void 0 && input[key] !== null ? input[key] : previous?.[key]; + if (effective("type") !== "call") return; + if (effective("status") === "completed") return; + const leadId = effective("related_to_lead"); + const contactId = effective("related_to_contact"); + const targets = []; + if (typeof leadId === "string" && leadId) { + targets.push({ object: "crm_lead", id: leadId, label: "lead" }); + } + if (typeof contactId === "string" && contactId) { + targets.push({ object: "crm_contact", id: contactId, label: "contact" }); + } + for (const t of targets) { + const raw = await api.object(t.object).find({ + where: { id: t.id }, + fields: ["id", "do_not_call"], + top: 1 + }); + const rows = Array.isArray(raw) ? raw : raw?.records ?? []; + const person = rows[0]; + if (person?.do_not_call === true) { + throw refuse( + `This ${t.label} is flagged Do Not Call, so a Call task cannot be scheduled against them. Log a completed call if one already happened, choose a non-phone activity type, or clear Do Not Call on the record first.`, + "FORBIDDEN", + 403 + ); + } + } + } +}; +var task_hook_default = [taskValidation, taskDoNotCallGuard, taskRecurrence, taskBubble]; + +// src/revenue/objects/contract.hook.ts +var contractValidation = { + name: "contract_validation", + object: "crm_contract", + events: ["beforeInsert", "beforeUpdate"], + priority: 200, + description: "Enforce contract term math and prevent shrinking end_date once activated.", + handler: async (ctx) => { + function refuse(message, code, status, userMessage = message) { + const err = new Error(message); + err.code = code; + err.status = status; + err.userMessage = userMessage; + return err; + } + const { event, input, previous } = ctx; + function monthsBetween(startISO, endISO) { + const s = new Date(startISO); + const e = new Date(endISO); + return (e.getUTCFullYear() - s.getUTCFullYear()) * 12 + (e.getUTCMonth() - s.getUTCMonth()) + // Unchanged intent: has the end day-of-month reached the start's yet? + // If not, the last month is not complete and does not count. + (e.getUTCDate() >= s.getUTCDate() ? 0 : -1); + } + const startDate = [input.start_date, previous?.start_date].find((v) => typeof v === "string" && v !== ""); + const endDate = [input.end_date, previous?.end_date].find((v) => typeof v === "string" && v !== ""); + const term = [input.contract_term_months, previous?.contract_term_months].find((v) => typeof v === "number" && !!v); + if (startDate && endDate && term) { + const calc = monthsBetween(startDate, endDate); + if (Math.abs(calc - term) > 1) { + throw refuse( + `Contract term (${term} months) does not match date range (${calc} months from ${startDate} to ${endDate}).`, + "VALIDATION_FAILED", + 400 + ); + } + } + if (event === "beforeUpdate" && previous?.status === "activated") { + if (typeof input.end_date === "string" && typeof previous.end_date === "string" && input.end_date < previous.end_date) { + throw refuse( + `Cannot shrink end_date (${previous.end_date} \u2192 ${input.end_date}) after activation. Use a termination/amendment workflow instead.`, + "RECORD_LOCKED", + 409 + ); + } + } + } +}; +var contractActivation = { + name: "contract_on_activation", + object: "crm_contract", + events: ["afterUpdate"], + priority: 800, + async: true, + onError: "log", + description: "On activation: stamp signed_date, promote account.", + handler: async (ctx) => { + const { input, previous } = ctx; + if (input.status !== "activated" || previous?.status === "activated") return; + const api = ctx.api; + if (!api) return; + const id = [input.id, previous?.id].find((v) => typeof v === "string" && v !== ""); + const accountId = [input.crm_account, previous?.crm_account].find((v) => typeof v === "string" && v !== ""); + if (id && !input.signed_date && !previous?.signed_date) { + await api.object("crm_contract").update( + { id, signed_date: (/* @__PURE__ */ new Date()).toISOString().slice(0, 10) }, + { where: { id } } + ); + } + if (accountId) { + const account = await api.object("crm_account").findOne({ where: { id: accountId } }); + if (account && account.type !== "customer") { + await api.object("crm_account").update( + { id: accountId, type: "customer" }, + { where: { id: accountId } } + ); + } + } + } +}; +var contract_hook_default = [contractValidation, contractActivation]; + +// src/revenue/objects/_line-item-price-fill.ts +function createLineItemPriceFill(objectName, hookName) { + return { + name: hookName, + object: objectName, + events: ["beforeInsert", "beforeUpdate"], + priority: 100, + description: "Default list_price / unit_price from the chosen product.", + handler: async (ctx) => { + const { event, input } = ctx; + const api = ctx.api; + if (!api) return; + const productId = typeof input.crm_product === "string" ? input.crm_product : void 0; + if (!productId) return; + const product = await api.object("crm_product").findOne({ + where: { id: productId }, + fields: ["id", "list_price"] + }); + const listPrice = product && typeof product.list_price === "number" ? product.list_price : void 0; + if (listPrice === void 0) return; + input.list_price = listPrice; + if (event === "beforeInsert" && input.unit_price == null) { + input.unit_price = listPrice; + } + } + }; +} +function createLineItemNumbering(objectName, hookName) { + return { + name: hookName, + object: objectName, + events: ["beforeInsert", "beforeUpdate"], + priority: 110, + runAs: "system", + description: "Assign line_number = (max under the parent) + 1.", + handler: async (ctx) => { + const { event, input } = ctx; + const prev = ctx.previous; + const api = ctx.api; + if (!api) return; + if (!ctx.user?.id && typeof input.line_number === "number") return; + if (event === "beforeUpdate" && (ctx.dispatch?.mode === "per-row" || typeof prev?.line_number === "number")) return; + const parentKey = ctx.object === "crm_quote_line_item" ? "crm_quote" : "crm_opportunity"; + const parentId = input[parentKey] ?? prev?.[parentKey]; + if (typeof parentId !== "string" || !parentId) return; + const siblings = await api.object(ctx.object).find({ + where: { [parentKey]: parentId }, + fields: ["line_number"], + top: 5e3 + }); + let max = 0; + for (const s of siblings) { + if (typeof s.line_number === "number" && s.line_number > max) max = s.line_number; + } + const offset = event === "beforeInsert" && ctx.dispatch?.mode === "per-row" ? ctx.dispatch.index : 0; + input.line_number = max + 1 + offset; + } + }; +} + +// src/revenue/objects/opportunity_line_item.hook.ts +var opportunityLineItemPriceFill = createLineItemPriceFill( + "crm_opportunity_line_item", + "opportunity_line_item_price_fill" +); +var opportunityLineItemNumbering = createLineItemNumbering( + "crm_opportunity_line_item", + "opportunity_line_item_line_number" +); +var opportunityAmountRollup = { + name: "opportunity_amount_rollup", + object: "crm_opportunity_line_item", + events: ["afterInsert", "afterUpdate", "afterDelete"], + priority: 300, + async: true, + onError: "log", + description: "Recompute parent opportunity.amount from the sum of its line items.", + handler: async (ctx) => { + const api = ctx.api; + if (!api) return; + const { input, previous } = ctx; + const num = (v) => typeof v === "number" ? v : 0; + const oppIds = /* @__PURE__ */ new Set(); + for (const v of [input?.crm_opportunity, previous?.crm_opportunity]) { + if (typeof v === "string" && v) oppIds.add(v); + } + if (oppIds.size === 0) return; + for (const oppId of oppIds) { + const opp = await api.object("crm_opportunity").findOne({ + where: { id: oppId }, + fields: ["id", "stage"] + }); + const stage = opp && typeof opp.stage === "string" ? opp.stage : void 0; + if (stage === "closed_won" || stage === "closed_lost") continue; + const lines = await api.object("crm_opportunity_line_item").find({ + where: { crm_opportunity: oppId }, + fields: ["quantity", "unit_price", "discount"], + top: 5e3 + }); + if (!lines || lines.length === 0) continue; + let sum = 0; + for (const l of lines) sum += num(l.quantity) * num(l.unit_price) * (1 - num(l.discount) / 100); + sum = Math.round(sum * 100) / 100; + if (sum > 0) { + await api.object("crm_opportunity").update( + { id: oppId, amount: sum }, + { where: { id: oppId } } + ); + } + } + } +}; +var opportunity_line_item_hook_default = [opportunityLineItemPriceFill, opportunityLineItemNumbering, opportunityAmountRollup]; + +// src/revenue/objects/product.hook.ts +var productHook = { + name: "product_catalog", + object: "crm_product", + events: ["beforeInsert", "beforeUpdate", "beforeDelete"], + priority: 200, + description: "Pricing sanity, SKU normalization, and protect referenced products from deletion.", + handler: async (ctx) => { + function refuse(message, code, status, userMessage = message) { + const err = new Error(message); + err.code = code; + err.status = status; + err.userMessage = userMessage; + return err; + } + const { event, input, previous } = ctx; + if (event === "beforeInsert" || event === "beforeUpdate") { + const listPrice = [input.list_price, previous?.list_price].find((v) => typeof v === "number"); + const cost = [input.cost, previous?.cost].find((v) => typeof v === "number"); + if (typeof listPrice === "number" && typeof cost === "number" && listPrice < cost) { + throw refuse( + `List Price (${listPrice}) must be greater than or equal to Cost (${cost}).`, + "VALIDATION_FAILED", + 400 + ); + } + if (typeof input.sku === "string") { + input.sku = input.sku.toUpperCase(); + } + } + if (event === "beforeDelete") { + const api = ctx.api; + const id = previous?.id; + if (!api || !id) return; + const [oppRefs, quoteRefs] = await Promise.all([ + api.object("crm_opportunity_line_item").count({ where: { crm_product: id } }).catch(() => 0), + api.object("crm_quote_line_item").count({ where: { crm_product: id } }).catch(() => 0) + ]); + if (oppRefs + quoteRefs > 0) { + throw refuse( + `Cannot delete product: referenced by ${oppRefs} opportunity(ies) and ${quoteRefs} quote(s). Set is_active=false to retire instead.`, + "DELETE_RESTRICTED", + 409 + ); + } + } + } +}; +var product_hook_default = productHook; + +// src/revenue/objects/quote.hook.ts +var quoteValidation = { + name: "quote_workflow", + // ⚠️ Two objects, deliberately (#2060): the freeze below is ONE freeze — the + // quote's and its lines' — so it lives in one place, judged by one user/system + // boundary and carried by one envelope, rather than a second copy of both on + // the line. `test/package-ownership.test.ts` reads every name in the list. + object: ["crm_quote", "crm_quote_line_item"], + events: ["beforeInsert", "beforeUpdate"], + priority: 200, + description: "Default expiration date; freeze accepted/expired quotes and their lines.", + handler: async (ctx) => { + function refuse(message, code, status, userMessage = message) { + const err = new Error(message); + err.code = code; + err.status = status; + err.userMessage = userMessage; + return err; + } + const { event, input, previous } = ctx; + if (ctx.object === "crm_quote_line_item") { + const changed = Object.keys(input).some((k) => !["id", "updated_at", "updated_by", "line_number"].includes(k) && input[k] !== previous?.[k]); + for (const id of /* @__PURE__ */ new Set([input.crm_quote, previous?.crm_quote])) { + const q = changed && ctx.user?.id && typeof id === "string" && id ? await ctx.api?.object("crm_quote").findOne({ where: { id }, fields: ["quote_number", "name", "status"] }) : null; + if (q?.status === "accepted" || q?.status === "expired") { + throw refuse(`Quote ${String(q.quote_number)} - ${String(q.name)} is ${q.status}, so its line items can no longer be added or changed.`, "RECORD_LOCKED", 409); + } + } + return; + } + function subject() { + const label = [previous?.quote_number, previous?.name].map((v) => typeof v === "string" ? v.trim() : "").filter(Boolean).join(" - "); + return label ? `Quote ${label}` : "Quote"; + } + function addDays(iso, days) { + const d = new Date(iso); + d.setUTCDate(d.getUTCDate() + days); + return d.toISOString().slice(0, 10); + } + if (event === "beforeInsert" && !input.expiration_date) { + const base = typeof input.quote_date === "string" ? input.quote_date : (/* @__PURE__ */ new Date()).toISOString().slice(0, 10); + input.expiration_date = addDays(base, 30); + } + if (event === "beforeUpdate" && previous && ctx.user?.id) { + const frozen = previous.status === "accepted" || previous.status === "expired"; + if (frozen) { + const allowed = /* @__PURE__ */ new Set(["internal_notes"]); + const SYSTEM_FIELDS = /* @__PURE__ */ new Set([ + "id", + "owner_id", + "created_at", + "updated_at", + "created_by", + "updated_by", + "space_id", + "organization_id", + "org_id", + "version" + ]); + const violating = Object.keys(input).filter( + (k) => !allowed.has(k) && !SYSTEM_FIELDS.has(k) && input[k] !== previous[k] + ); + if (violating.length > 0) { + const REFERENCE_FIELDS = /* @__PURE__ */ new Set(["crm_account", "crm_contact", "crm_opportunity"]); + const isReferenceCleanup = violating.every( + (k) => REFERENCE_FIELDS.has(k) && input[k] === null && previous?.[k] != null + ); + if (isReferenceCleanup) return; + const what = `${subject()} is ${previous.status}`; + throw refuse(`${what}; only internal_notes may be edited. Attempted: ${violating.join(", ")}.`, "RECORD_LOCKED", 409); + } + } + if (input.status === "accepted" && previous.status !== "accepted") { + const dealId = [input.crm_opportunity, previous.crm_opportunity].find((v) => typeof v === "string" && v); + const deal = dealId ? await ctx.api?.object("crm_opportunity").findOne({ + where: { id: dealId }, + fields: ["stage", "approval_status", "status_change_approval_status", "qualification_approval_status"] + }).catch(() => null) : null; + const held = deal && !String(deal.stage).startsWith("closed_") ? [["approval_status", "Approval Status"], ["status_change_approval_status", "Status Change Approval"], ["qualification_approval_status", "Qualification Approval"]].filter(([f]) => deal[f] === "pending" || deal[f] === "rejected" && f !== "approval_status").map(([f, label]) => `${label} is ${deal[f] === "pending" ? "Pending" : "Rejected"}`) : []; + if (held.length > 0) { + const what = `${subject()} cannot be accepted while its opportunity is held by an approval`; + throw refuse(`${what} (${held.join("; ")}): accepting it would close that deal as won. Accept it once the approval is granted.`, "RECORD_LOCKED", 409); + } + } + } + } +}; +var quoteAcceptedContractDraft = { + name: "quote_accepted_contract_draft", + object: "crm_quote", + events: ["afterUpdate"], + priority: 800, + async: true, + onError: "log", + runAs: "system", + description: "Draft the accepted quote\u2019s contract.", + handler: async (ctx) => { + const { input, previous } = ctx; + if (input.status !== "accepted" || previous?.status === "accepted") return; + const api = ctx.api; + if (!api) return; + function addMonths(iso, months) { + const d = new Date(iso); + d.setUTCMonth(d.getUTCMonth() + months); + return d.toISOString().slice(0, 10); + } + const pickId = (...candidates) => candidates.find((c) => typeof c === "string" && c !== ""); + const accountId = pickId(input.crm_account, previous?.crm_account); + const contactId = pickId(input.crm_contact, previous?.crm_contact); + const opportunityId = pickId(input.crm_opportunity, previous?.crm_opportunity); + const ownerId = pickId(input.owner_id, previous?.owner_id, ctx.user?.id); + const totalPrice = [input.total_price, previous?.total_price].find((v) => typeof v === "number") ?? 0; + const paymentTerms = pickId(input.payment_terms, previous?.payment_terms); + const today = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10); + const DRAFT_CONTRACT_DEFAULTS = { + contract_term_months: 12, + contract_type: "subscription", + start_date: today + }; + const trimmed = (v) => typeof v === "string" ? v.trim() : ""; + const quoteLabel = [trimmed(previous?.quote_number), [input.name, previous?.name].map(trimmed).find(Boolean)].filter(Boolean).join(" - "); + const contract = { + ...DRAFT_CONTRACT_DEFAULTS, + status: "draft", + end_date: addMonths(DRAFT_CONTRACT_DEFAULTS.start_date, DRAFT_CONTRACT_DEFAULTS.contract_term_months), + contract_value: totalPrice, + description: quoteLabel ? `Auto-drafted from accepted quote ${quoteLabel}` : "Auto-drafted from an accepted quote" + }; + if (accountId) contract.crm_account = accountId; + if (contactId) contract.crm_contact = contactId; + if (opportunityId) contract.crm_opportunity = opportunityId; + if (ownerId) contract.owner_id = ownerId; + if (paymentTerms) contract.payment_terms = paymentTerms; + try { + await api.object("crm_contract").insert(contract); + } catch (err) { + throw new Error(`could not draft the contract for quote ${quoteLabel}: ${err.message}`); + } + } +}; +var quoteAccepted = { + name: "quote_on_accepted", + object: "crm_quote", + events: ["afterUpdate"], + priority: 800, + async: true, + onError: "log", + description: "Close-win the accepted quote\u2019s opportunity.", + handler: async (ctx) => { + const { input, previous } = ctx; + if (input.status !== "accepted" || previous?.status === "accepted") return; + const api = ctx.api; + const id = [input.crm_opportunity, previous?.crm_opportunity].find((v) => typeof v === "string" && v !== ""); + if (!api || !id) return; + try { + const opp = await api.object("crm_opportunity").findOne({ where: { id } }); + if (opp && !String(opp.stage).startsWith("closed_")) { + const won = { id, stage: "closed_won", close_date: (/* @__PURE__ */ new Date()).toISOString().slice(0, 10) }; + await api.object("crm_opportunity").update({ ...won, ...opp.win_reason ? {} : { win_reason: "quote_accepted" } }, { where: { id } }); + } + } catch (err) { + throw new Error(`could not close-won the opportunity of quote ${String(previous?.quote_number)}: ${err.message}`); + } + } +}; +var quote_hook_default = [quoteValidation, quoteAcceptedContractDraft, quoteAccepted]; + +// src/revenue/objects/quote_line_item.hook.ts +var quoteLineItemPriceFill = createLineItemPriceFill( + "crm_quote_line_item", + "quote_line_item_price_fill" +); +var quoteLineItemNumbering = createLineItemNumbering( + "crm_quote_line_item", + "quote_line_item_line_number" +); +var quoteTotalRollup = { + name: "quote_total_rollup", + object: "crm_quote_line_item", + events: ["afterInsert", "afterUpdate", "afterDelete"], + priority: 300, + async: true, + onError: "log", + description: "Recompute parent quote subtotal/discount/total from its line items.", + handler: async (ctx) => { + const api = ctx.api; + if (!api) return; + const { input, previous } = ctx; + const num = (v) => typeof v === "number" ? v : 0; + const quoteIds = /* @__PURE__ */ new Set(); + for (const v of [input?.crm_quote, previous?.crm_quote]) { + if (typeof v === "string" && v) quoteIds.add(v); + } + if (quoteIds.size === 0) return; + for (const quoteId of quoteIds) { + const quote = await api.object("crm_quote").findOne({ + where: { id: quoteId }, + fields: ["id", "status", "discount", "tax", "shipping_handling"] + }); + if (!quote) continue; + const status = typeof quote.status === "string" ? quote.status : void 0; + if (status === "accepted" || status === "expired") continue; + const lines = await api.object("crm_quote_line_item").find({ + where: { crm_quote: quoteId }, + fields: ["quantity", "unit_price", "discount"], + top: 5e3 + }); + if (!lines || lines.length === 0) continue; + let subtotal = 0; + for (const l of lines) subtotal += num(l.quantity) * num(l.unit_price) * (1 - num(l.discount) / 100); + subtotal = Math.round(subtotal * 100) / 100; + const discountAmount = Math.round(subtotal * (num(quote.discount) / 100) * 100) / 100; + const total = Math.round((subtotal - discountAmount + num(quote.tax) + num(quote.shipping_handling)) * 100) / 100; + await api.object("crm_quote").update( + { id: quoteId, subtotal, discount_amount: discountAmount, total_price: total }, + { where: { id: quoteId } } + ); + } + } +}; +var quote_line_item_hook_default = [quoteLineItemPriceFill, quoteLineItemNumbering, quoteTotalRollup]; + +// src/marketing/objects/campaign.hook.ts +var campaignValidation = { + name: "campaign_validation", + object: "crm_campaign", + events: ["beforeInsert", "beforeUpdate"], + priority: 200, + description: "Validate campaign date range and required fields per status.", + handler: async (ctx) => { + function refuse(message, code, status2, userMessage = message) { + const err = new Error(message); + err.code = code; + err.status = status2; + err.userMessage = userMessage; + return err; + } + const { input } = ctx; + const previous = ctx.previous; + const start = typeof input.start_date === "string" && input.start_date || typeof previous?.start_date === "string" && previous.start_date || void 0; + const end = typeof input.end_date === "string" && input.end_date || typeof previous?.end_date === "string" && previous.end_date || void 0; + if (start && end && start > end) { + throw refuse(`Campaign start_date (${start}) must not be after end_date (${end}).`, "VALIDATION_FAILED", 400); + } + const status = typeof input.status === "string" && input.status || typeof previous?.status === "string" && previous.status || void 0; + if (status === "in_progress" && (!start || !end)) { + throw refuse("Campaign cannot move to in_progress without both start_date and end_date.", "VALIDATION_FAILED", 400); + } + } +}; +var campaignMetricsRefresh = { + name: "campaign_metrics_refresh", + object: "crm_campaign", + events: ["afterUpdate"], + priority: 800, + async: true, + onError: "log", + description: "Recompute the campaign metric block whenever the campaign status moves.", + handler: async (ctx) => { + const { input } = ctx; + const previous = ctx.previous; + if (typeof input.status !== "string") return; + if (previous && input.status === previous.status) return; + const api = ctx.api; + if (!api) return; + const campaignId = typeof input.id === "string" && input.id || (typeof previous?.id === "string" ? previous.id : ""); + if (!campaignId) return; + for (const id of [campaignId]) { + const memberRows = await api.object("crm_campaign_member").find({ + where: { crm_campaign: id }, + fields: ["crm_lead", "status"], + top: 5e3 + }); + const leadIds = Array.from(new Set( + memberRows.map((r) => typeof r.crm_lead === "string" ? r.crm_lead : "").filter(Boolean) + )); + const convertedLeads = leadIds.length > 0 ? await api.object("crm_lead").count({ where: { id: { $in: leadIds }, is_converted: true } }) : 0; + const numOpportunities = await api.object("crm_opportunity").count({ where: { crm_campaign: id } }); + const numWon = await api.object("crm_opportunity").count({ where: { crm_campaign: id, stage: "closed_won" } }); + const wonRows = await api.object("crm_opportunity").find({ + where: { crm_campaign: id, stage: "closed_won" }, + fields: ["amount"], + top: 5e3 + }); + const actualRevenue = wonRows.reduce( + (sum, row) => sum + (typeof row.amount === "number" ? row.amount : Number(row.amount) || 0), + 0 + ); + await api.object("crm_campaign").update({ + id, + num_sent: memberRows.length, + num_responses: memberRows.filter((r) => r.status === "responded" || r.status === "converted").length, + num_leads: leadIds.length, + num_converted_leads: convertedLeads, + num_opportunities: numOpportunities, + num_won_opportunities: numWon, + actual_revenue: actualRevenue + }, { where: { id } }); + } + } +}; +var CAMPAIGN_METRIC_FIELDS = [ + "num_sent", + "num_responses", + "num_leads", + "num_converted_leads", + "num_opportunities", + "num_won_opportunities", + "actual_revenue" +]; +var CAMPAIGN_METRIC_WRITE_KEYS = ["id", ...CAMPAIGN_METRIC_FIELDS]; +var campaign_hook_default = [campaignValidation, campaignMetricsRefresh]; + +// src/marketing/objects/campaign_member.hook.ts +var campaignMemberLifecycle = { + name: "campaign_member_lifecycle", + object: "crm_campaign_member", + events: ["beforeInsert", "beforeUpdate"], + priority: 200, + description: "Keep has_responded / response_date in lockstep with the member status.", + handler: async (ctx) => { + if (ctx.event === "beforeUpdate" && ctx.dispatch?.mode === "per-row") return; + const { input } = ctx; + const previous = ctx.previous; + const status = typeof input.status === "string" && input.status || (typeof previous?.status === "string" ? previous.status : void 0); + if (!status) return; + const responded = status === "responded" || status === "converted"; + const priorStatus = typeof previous?.status === "string" ? previous.status : ""; + const wasResponded = priorStatus === "responded" || priorStatus === "converted"; + if (responded) { + input.has_responded = true; + const existing = input.response_date ?? previous?.response_date; + if (!wasResponded && (existing === void 0 || existing === null || existing === "")) { + input.response_date = (/* @__PURE__ */ new Date()).toISOString(); + } + return; + } + if (wasResponded && typeof input.status === "string") { + input.has_responded = false; + input.response_date = null; + return; + } + if (ctx.event === "beforeInsert" && input.has_responded === void 0) { + input.has_responded = false; + } + } +}; +var campaignMemberOptOutSync = { + name: "campaign_member_optout_sync", + object: "crm_campaign_member", + events: ["afterInsert", "afterUpdate"], + priority: 300, + async: true, + onError: "log", + runAs: "system", + description: "Sync an unsubscribed member back to the lead/contact email_opt_out flag.", + handler: async (ctx) => { + const api = ctx.api; + if (!api) return; + const { input } = ctx; + const previous = ctx.previous; + if (input?.status !== "unsubscribed") return; + if (previous?.status === "unsubscribed") return; + const leadId = typeof input?.crm_lead === "string" && input.crm_lead || (typeof previous?.crm_lead === "string" ? previous.crm_lead : void 0); + const contactId = typeof input?.crm_contact === "string" && input.crm_contact || (typeof previous?.crm_contact === "string" ? previous.crm_contact : void 0); + if (leadId) { + await api.object("crm_lead").update( + { id: leadId, email_opt_out: true }, + { where: { id: leadId } } + ); + } + if (contactId) { + await api.object("crm_contact").update( + { id: contactId, email_opt_out: true }, + { where: { id: contactId } } + ); + } + } +}; +var campaignMemberMetricsRefresh = { + name: "campaign_member_metrics_refresh", + object: "crm_campaign_member", + events: ["afterInsert", "afterUpdate", "afterDelete"], + priority: 800, + async: true, + onError: "log", + runAs: "system", + description: "Recompute the campaign metric block live whenever its membership changes.", + handler: async (ctx) => { + const api = ctx.api; + if (!api) return; + const { input } = ctx; + const previous = ctx.previous; + const campaignIds = Array.from(new Set([ + typeof input?.crm_campaign === "string" ? input.crm_campaign : "", + typeof previous?.crm_campaign === "string" ? previous.crm_campaign : "" + ].filter(Boolean))); + for (const id of campaignIds) { + const memberRows = await api.object("crm_campaign_member").find({ + where: { crm_campaign: id }, + fields: ["crm_lead", "status"], + top: 5e3 + }); + const leadIds = Array.from(new Set( + memberRows.map((r) => typeof r.crm_lead === "string" ? r.crm_lead : "").filter(Boolean) + )); + const convertedLeads = leadIds.length > 0 ? await api.object("crm_lead").count({ where: { id: { $in: leadIds }, is_converted: true } }) : 0; + const numOpportunities = await api.object("crm_opportunity").count({ where: { crm_campaign: id } }); + const numWon = await api.object("crm_opportunity").count({ where: { crm_campaign: id, stage: "closed_won" } }); + const wonRows = await api.object("crm_opportunity").find({ + where: { crm_campaign: id, stage: "closed_won" }, + fields: ["amount"], + top: 5e3 + }); + const actualRevenue = wonRows.reduce( + (sum, row) => sum + (typeof row.amount === "number" ? row.amount : Number(row.amount) || 0), + 0 + ); + await api.object("crm_campaign").update({ + id, + num_sent: memberRows.length, + num_responses: memberRows.filter((r) => r.status === "responded" || r.status === "converted").length, + num_leads: leadIds.length, + num_converted_leads: convertedLeads, + num_opportunities: numOpportunities, + num_won_opportunities: numWon, + actual_revenue: actualRevenue + }, { where: { id } }); + } + } +}; +var campaign_member_hook_default = [ + campaignMemberLifecycle, + campaignMemberOptOutSync, + campaignMemberMetricsRefresh +]; + +// src/sales/flows/lead-conversion.flow.ts +import { P as P26, cel as cel6 } from "@objectstack/spec"; +var LeadConversionFlow = { + name: "lead_conversion", + label: "Lead Conversion Process", + description: "Automated flow to convert qualified leads to accounts, contacts, and opportunities", + type: "screen", + status: "active", + variables: [ + // Named `recordId` to match the console's flow-action invocation contract: + // POST /automation/:name/trigger sends { recordId, objectName } and the + // dispatcher exposes them as params.recordId / params.crmLeadId. A custom + // name like `leadId` never gets seeded (16.x runtime). + { name: "recordId", type: "text", isInput: true, isOutput: false }, + // THE authority for the conversion default. `defaultValue` is what makes + // declared mean BOUND: the engine seeds every declared variable that + // carries one before the run starts, so `createOpportunity` is bound on + // every path — including the one where the screen runner posts back only + // the fields the user touched. The screen field below derives its prefill + // from this line rather than restating `false`. + // + // Measured on 17.0.0 GA, by running flows (not by reading the engine): + // · declared + nothing supplied → bound to `false`; ablating this key + // from the declaration re-fails the read with `No such key: + // createOpportunity`, so the default is what binds it; + // · seeded BEFORE the start condition is evaluated, so a start condition + // could read it too; + // · a caller-supplied `context.params.createOpportunity` WINS — the + // boundary is `!== undefined`, so an explicit `false`/`null` is a + // supplied answer, and only absence falls through to this default. + // ⛔ Never seed this with an assignment node instead: an assignment is + // unconditional and clobbers a caller-supplied value. All of the above is + // pinned in `test/flow-variable-conditions.test.ts`. + { name: "createOpportunity", type: "boolean", isInput: true, isOutput: false, defaultValue: false }, + { name: "opportunityName", type: "text", isInput: true, isOutput: false }, + { name: "opportunityAmount", type: "text", isInput: true, isOutput: false }, + // The conversion's close date, collected on the screen below + // instead of stamped inside `create_opportunity`. Declared with NO + // `defaultValue`, and that is measured rather than chosen: the engine + // binds a DECLARATION's default raw — `seedDeclaredVariables` does a plain + // `variables.set(name, defaultValue)` with no `interpolate` call — so + // `{TODAY() + 90}` written here would bind that string verbatim and + // `create_opportunity` would post the braces into a date column. Measured + // on 17.3.0 by running a probe flow, not by reading the engine. The screen + // field is therefore the only layer that can carry the expression, which + // is where the +90 lives and why this line is deliberately bare. + { name: "closeDate", type: "date", isInput: true, isOutput: false } + ], + nodes: [ + { id: "start", type: "start", label: "Start", config: { objectName: "crm_lead" } }, + { + id: "screen_1", + type: "screen", + label: "Conversion Details", + config: { + // The suspected-duplicate warning. `lead_duplicate_check` flags a + // re-captured email at intake and links the record the lead repeats; + // the rep about to CONVERT is the last moment that flag is worth + // anything, and without it the duplicate becomes a second account, + // contact and opportunity. + // + // ⛔ Not on `convert_lead`'s `confirmText`: that string is static and + // unconditional, so it would warn identically on every clean lead — the + // cry-wolf that makes a confirm dialog furniture. This screen is where + // the conversion decision is actually taken, and the one surface that + // can say something TRUE about THIS lead. + // + // Mechanism: the executor renders `config.description` — a text slot, + // written as a `{{ }}` hole since 18.0.0-next.0 — into the `ScreenSpec` + // it puts on the wire, and `FlowRunner.tsx` renders it — + // `{screen.description && …}`. A hole over `null` + // renders the empty string, which the executor's `renderTextSlot` + // turns into no description at all (read in the installed + // 18.0.0-next.0 `service-automation`; on the 17.1.0 bundles it was + // measured as `interp` mapping null to `undefined`), so the clean-lead + // branch below (which assigns `null`) renders NO description rather + // than an empty paragraph. That is why the conditionality lives in an + // assignment and not in the copy: a screen `description` has no + // `visibleWhen`. + description: "{{duplicateWarning}}", + // `visibleWhen` on a screen field is BARE CEL over the screen's own + // field names — not the CEL value envelopes the rest of this flow uses + // for filters and `update_record` fields, evaluated on the server. The + // client re-evaluates the predicate against the values collected so far, + // which is why it cannot be a server-evaluated envelope. + fields: [ + // ⛔ NEVER `required` on a boolean screen field. A checkbox has no + // unanswered state — clear IS an answer, and "convert this lead + // WITHOUT an opportunity" is the commonest path. `required: true` + // blocks on both sides of the wire: the client counts the untouched + // box as an unanswered field and disables Submit, and from + // 17.0.0-rc.2 the SERVER enforces the screen's declared contract too, + // refusing the resume with `INVALID_SCREEN_INPUT: Screen field + // "createOpportunity" is required` — so a runner that posts only what + // the user touched cannot convert a lead at all. The variable's + // declared `defaultValue` is what supplies the answer. + // + // DERIVED, not restated. The envelope reads the flow variable + // `createOpportunity`, so the literal `false` is written exactly once in this + // file — on the declaration — and the widget prefill cannot drift from + // the value the engine binds. + // + // A screen field's `defaultValue` is a CEL value envelope evaluated + // before the descriptor goes on the wire, so the client receives the + // value, never the envelope: boolean `false`, which is what the + // 17.0.0 GA template was measured to send. (`visibleWhen` below is the + // opposite case: forwarded raw, never evaluated on the server. Same + // node, two different dialects.) + { name: "createOpportunity", label: "Create Opportunity?", type: "boolean", defaultValue: cel6`createOpportunity` }, + // PREFILLED FROM THE LEAD (REQ-0005 acceptance 2). Both defaults are + // CEL envelopes over `leadRecord`, which `get_lead` bound before this + // screen was reached — the fetch sits AHEAD of the screen for the + // duplicate warning, and these two ride the same ordering. + // + // ⚠️ Each envelope is evaluated before the descriptor goes on the + // wire, so `estimated_amount` arrives as a NUMBER. `company` is + // required on a lead; `estimated_amount` is not, so its read is + // guarded: a lead with no estimate is served `null` where 17.x served + // nothing (the migration entry: a field's `defaultValue` seeds the + // field with null), and an ABSENT column on a sparse datasource no + // longer fails the run at this screen. + // + // ⛔ The amount is prefilled, never copied silently. `estimated_amount` + // is a pre-qualification guess and `crm_opportunity.amount` is a + // number a rep defends in a forecast; conversion is the moment a human + // turns one into the other, so the figure is shown in an editable box + // and the rep confirms it. Writing it straight into + // `create_opportunity` would put an unreviewed estimate into the + // forecast and leave the two fields looking like copies of each other. + // + // `required` on the amount mirrors the column, for the reason given + // at `closeDate` below: `crm_opportunity.amount` is `required` + + // `notNull`, and without this a ticked box with no amount reached + // `create_opportunity` after the account and contact were written, + // leaving the lead half-converted (#2060 item 2). Visible-only, so + // an unticked box still converts with no amount. + { name: "opportunityName", label: "Opportunity Name", type: "text", required: true, defaultValue: cel6`leadRecord.company`, visibleWhen: "createOpportunity == true" }, + { name: "opportunityAmount", label: "Opportunity Amount", type: "currency", required: true, defaultValue: cel6`has(leadRecord.estimated_amount) ? leadRecord.estimated_amount : null`, visibleWhen: "createOpportunity == true" }, + // The close date, DEFAULTED AND VISIBLE. `close_date` is what files + // an opportunity into a forecast PERIOD, so ⛔ never stamp it silently + // inside `create_opportunity`: a hidden +90 days files every converted + // deal a quarter out and moves the forecast where nobody can see it. + // + // The +90 is written HERE and nowhere else, and here the layer is + // FORCED rather than preferred. A screen field's `defaultValue` is + // evaluated before the descriptor goes on the wire and a flow + // variable's default is bound raw (see the declaration above), so this + // is the only place the expression can be written at all. + // `isoDate(daysFromNow(90))` writes the `YYYY-MM-DD` string 90 days out + // on the UTC calendar — what 17.3.0's `{TODAY() + 90}` was measured to + // send — and the value the rep sees is the value + // `create_opportunity` writes. + // + // `required` mirrors the column — `crm_opportunity.close_date` is + // `required` + `notNull` — and it is what keeps the refusal at the + // SCREEN boundary. Measured both ways against a real ObjectQL engine: + // WITHOUT it, a submission carrying no date reaches + // `create_opportunity` and fails there with `Close Date is required`, + // by which point the account and the contact have already been + // written and the lead is left half-converted; WITH it the resume is + // refused before any node runs, nothing is written, and the message + // names the field. That path is not hypothetical — a rep who CLEARS + // the prefilled date posts the key empty, and `isPresent('')` is + // false. A hidden `required` never fires: the server contract skips it + // when `visibleWhen` evaluates false, and so does the console, which + // is the untouched-checkbox path this screen has always had to keep + // working. + { name: "closeDate", label: "Close Date", type: "date", required: true, defaultValue: cel6`isoDate(daysFromNow(90))`, visibleWhen: "createOpportunity == true" } + ] + } + }, + { + // ⛔ This fetch must stay AHEAD of the screen: the duplicate warning + // reads `leadRecord`, and a screen that suspends before the fetch has + // nothing to read. The fetch itself never depended on the screen — + // `recordId` is an input variable, seeded before the run starts. + id: "get_lead", + type: "get_record", + label: "Get Lead Record", + config: { objectName: "crm_lead", filter: { id: cel6`recordId` }, outputVariable: "leadRecord" } + }, + { + // Branching is on edges `e21` / `e22` / `e25` — see `decision_account`. + // Three ways out, because `duplicate_status` carries two different KINDS + // of fact and they get different answers: the machine's `suspected` guess + // warns and lets the rep decide (`e21`), a person's `confirmed` verdict + // refuses outright (`e25`), and everything else converts silently (`e22`). + id: "decision_duplicate", + type: "decision", + label: "Duplicate Verdict?" + }, + { + // The warning names the record the way the UI names a person — by the + // email address the two records share — and NOT by + // `duplicate_of_lead` / `duplicate_of_contact`, which hold ids. That is + // the house rule `test/record-id-not-in-prose.test.ts` states for every + // sentence a user reads: "the id goes in the relationship field that + // exists to carry it, or nowhere". The link itself is on the lead's + // record page (`lead_detail.page.ts`), where it can be clicked. + // + // "flagged at intake" is the app's own published definition of this + // value, not a guess about provenance: `duplicate_status`'s help text + // reads "Suspected = flagged automatically at intake" in all four + // locales, and `lead_duplicate_check` is insert-only by design. + // + // This warning's TEXT is English-only: it is the value of a variable, + // and no locale pack reaches a variable — the screen's translated + // `description` can only carry the `{{duplicateWarning}}` hole that + // shows it. The screens' own headings and bodies are keyed in the packs + // (`flows.lead_conversion` in `src/sales/translations//app.ts`), + // and the banner on the record page carries the warning in all four. + id: "warn_duplicate", + type: "assignment", + label: "Compose Duplicate Warning", + config: { + assignments: { + duplicateWarning: cel6`'Suspected duplicate — intake flagged this lead as repeating an existing record with this email address (' + leadRecord.email + '). Converting creates a second account, contact and opportunity for the same buyer; compare the linked record on the lead page before you continue.'` + } + } + }, + { + // The other branch assigns `null`, which is what makes the warning + // CONDITIONAL: the description hole renders it as no description at + // all (see `screen_1`). Same shape as `no_opportunity` below — both branches + // write the variable so no downstream read ever meets an unset one. + id: "no_duplicate_warning", + type: "assignment", + label: "No Duplicate Warning", + config: { assignments: { duplicateWarning: null } } + }, + { + // The REFUSAL. A `confirmed` duplicate is a person's verdict, and the app + // stops converting on it — the rule AGENTS.md states as "interception + // stands on a person's judgement". `suspected` keeps the warn-and-allow + // above: a machine's guess stays advisory, because `lead_duplicate_check` + // matches on email EQUALITY and a shared inbox (`info@`, a switchboard + // address) false-positives by construction. ⛔ Do not block on the guess — + // it would need an override flag to stay usable, and an override flag is + // the one shape this exhibit must not demonstrate. + // + // ## Why the refusal is HERE and not on `convert_lead`'s predicate + // + // A refusal must NAME the verdict and the surviving record, and measured + // against `@objectstack/spec` 17.2.0 the action predicates cannot: + // `visible` and `disabled` are each a bare boolean/CEL envelope with + // nowhere to put a sentence, so `visible` hides a button that cannot then + // explain itself and `disabled` greys one out with no reason attached. + // `errorMessage` on the Action is a single static string — what the + // console toasts on a FAILED run — and cannot say anything about THIS + // lead. A screen node's `description` is a text slot rendered per run + // and shown by `FlowRunner` as the dialog body. + // + // The flow is also the only choke point covering every door: the + // record-header button, the list-row button and the `action_convert_lead` + // AI tool all dispatch `POST /automation/lead_conversion/trigger`, while + // `visible` / `disabled` are console-side and say nothing to the other + // two. + // + // ## What the rep sees, measured on the shipped console bundle + // + // A run that PAUSES returns `{ success: true, silent: true }` to the + // action framework (`RecordDetailView`'s flow handler), and `silent` + // suppresses the success toast — so `convert_lead`'s + // `successMessage: 'Lead converted successfully!'` does NOT fire behind + // this dialog. Submitting it resumes into `end`; nothing is created and + // the lead is untouched on either path, because every write in this flow + // is downstream of `screen_1`. + // + // ## What the copy may claim + // + // ⛔ NOT the shared email address, which is what `warn_duplicate` above + // uses. That claim is safe for `suspected` because only + // `lead_duplicate_check` writes it and it matches on email; `confirmed` + // is written by a PERSON, and the lead form lets a reviewer point + // `duplicate_of_type` + its lookup at any record they like. So the + // refusal names the survivor through the relationship fields that exist + // to carry it (`test/record-id-not-in-prose.test.ts`: "the id goes in the + // relationship field that exists to carry it, or nowhere"), naming the + // `duplicates` field group by its shipped label, "Duplicate Management". + // That sentence also stays true on the `erased` tombstone, where the + // verdict survives its pointer (`lead.hook.ts`, job 1c). + // + // ⛔ Never transcribe the vocabulary of `duplicate_of_type` into this + // sentence ("an existing Lead" / "an existing Contact"). Those labels are + // locale-pack facts with one source of truth, the rep can see them on the + // section this line points at, and a hand-copied machine list in prose is + // the drift AGENTS.md documentation rule 5 forbids. + // + // The title and the body are translated in the packs + // (`flows.lead_conversion.screens.refuse_confirmed_duplicate`). + id: "refuse_confirmed_duplicate", + type: "screen", + label: "Conversion Refused", + config: { + title: "Conversion refused", + description: "This lead's Duplicate Status is Confirmed: a reviewer compared it against an existing record and recorded that it repeats one. Converting would create a second account, contact and opportunity for the same buyer. The Duplicate Management section on this lead names the surviving record; disqualify this lead as a duplicate instead. Only a reviewer revising that verdict reopens conversion.", + // A message-only screen: no fields, so the pause has to be asked for. + // `waitForInput` is what turns a field-less screen from a server-side + // pass-through into the dialog the rep reads (the executor's + // `shouldPause`), and without it this node would fall through to `end` + // in silence — a refusal nobody is told about. + waitForInput: true + } + }, + { + // Branching is on edges `e28` / `e29` — see `decision_account`. + id: "decision_approval", + type: "decision", + label: "Approved for Conversion?" + }, + { + // The approval gate, on the surface a REST caller reaches (REQ-0005 + // acceptance 3). `convert_lead`'s `visible` predicate hides the button and + // `lead.hook.ts` refuses the write, but this flow has its own door — + // `POST /automation/lead_conversion/trigger` — and without this branch a + // caller through that door would run the whole conversion and only be + // refused at `mark_converted`, by which point the account, the contact and + // the opportunity have already been written and the lead is left + // half-converted. Refusing HERE, ahead of `screen_1`, is what makes the + // gate whole: every create and update in this flow sits behind that + // screen, and this path never reaches it. + id: "refuse_unapproved", + type: "screen", + label: "Conversion Refused", + config: { + title: "Conversion refused", + description: "This lead has not been approved for conversion. An approver has to sign it off before it can become an account, contact and opportunity; the Conversion Approval field on the lead shows whether the decision is still pending or was refused. Keep working the lead in the meantime \u2014 nothing about it is frozen.", + // Field-less screen: `waitForInput` is what turns it from a server-side + // pass-through into the dialog the rep reads. See + // `refuse_confirmed_duplicate` for the mechanism. + waitForInput: true + } + }, + { + // Branching is on edges `e31` / `e32` — see `decision_account`. The + // match-key guard sits between the duplicate verdict and `screen_1`, so + // it dominates `find_account` and a key-less lead is refused before the + // rep fills in the form and before any write. It is the LAST of the + // three refusals on purpose: an unapproved lead or a confirmed duplicate + // is told that verdict first, and a missing key is a repairable data + // gap rather than a verdict. + id: "decision_match_key", + type: "decision", + label: "Company Match Key?" + }, + { + // The KEY-LESS refusal (#2017). Why `find_account` must not run without + // a key is recorded on that node; this is what the rep reads instead. + // + // A refusal, not a new account, and that is the flow's own stated intent + // rather than a fresh choice: a conversion that stops is far cheaper to + // diagnose than one that quietly attaches to the wrong account or + // creates a duplicate one, and `screen_1` offers the rep no account + // choice that could confirm a match by hand. + // + // The copy claims only what holds on every path into it: the key is + // derived from `company` on every write that carries it + // (`lead_duplicate_check`), and nothing has been written, because every + // create and update in this flow sits behind `screen_1`. Its title and + // body are translated in the packs, like the other two refusals. + // + // Field-less screen: `waitForInput` is what turns it from a server-side + // pass-through into the dialog the rep reads. See + // `refuse_confirmed_duplicate` for the mechanism. + id: "refuse_no_match_key", + type: "screen", + label: "Conversion Refused", + config: { + title: "Conversion refused", + description: "This lead's company has no match key, so conversion cannot tell which account it belongs to, and it will not guess: a guess could file the contact and opportunity under another customer. Saving the lead's Company rebuilds the key, so save it again, then convert. Nothing has been created.", + waitForInput: true + } + }, + { + // Account dedupe: match on the NORMALIZED company name, never on the raw + // one — "Acme Corp" and "ACME Corp" are the same account. + // + // Both sides of this comparison are stored, hook-maintained columns, and + // on 17.x that was forced rather than chosen: a flow template could not + // normalize ANYTHING. `service-automation`'s `resolveToken` recognises exactly one + // function form — `NOW()` / `TODAY()` — and every bare identifier in the + // expression fallback is substituted before evaluation, so no string + // method is reachable either: `{LOWER(x)}`, `{TRIM(x)}` and + // `{x.toLowerCase()}` all resolve to `undefined`, and an unwrapped + // `LOWER({x})` interpolates literally to "LOWER(Acme Corp)". A formula + // field is no help either — it has no physical column to filter on. So + // the producer canonicalizes (`account_protection`, + // `lead_duplicate_check`) and this node does a plain, indexed equality + // match. `test/account-name-normalized-match.test.ts` re-measures all of + // that rather than trusting this paragraph. + // + // Normalize-then-EXACT only: lower + trim + collapse internal + // whitespace. Fuzzy matching stays out of scope. + // + // A lead with NO `company_normalized` never reaches this node: + // `decision_match_key`, ahead of `screen_1`, refuses it first. The node + // cannot be left to refuse on its own, because "no key" arrives in two + // shapes that behave differently (both measured on 17.7.0): + // + // · ABSENT — a sparse datasource (`driver-memory` / `driver-mongodb`) + // on a row never written with the column. The token resolves to + // nothing and `get_record` refuses to run, so the run FAILS + // (`FLOW_FAILED`, "refusing to run — 1 filter condition(s) resolved + // to nothing and were dropped from the query …"). + // · NULL — SQL, or any datasource once the column is written empty, + // which `lead_duplicate_check` does on purpose for a company that + // folds to nothing. The token resolves to `null`, and a bare `null` + // in a filter is the platform's documented HAS-NO-VALUE predicate + // (`$eq: null`, `@objectstack/spec` `data/filter.zod.ts`). This + // lookup then MATCHES every account whose own key is null, and the + // lead converts onto an unrelated customer's account (#2017). + // + // A key-less lead is not only a row written before the producer existed + // (the backfill in docs/MAINTENANCE.md §3.3): a non-string company + // written through the record API folds to `null` too. A conversion that + // stops is far cheaper to diagnose than one that quietly attaches to the + // wrong account or creates a duplicate one, so the answer is the + // refusal the rep reads in `refuse_no_match_key`. + // + // Since 18.0.0-next.0 the operand is a CEL envelope: an absent key fails + // the run before the query, and a null one refuses the node instead of + // matching (the platform's `flow-value-slot-template-dialect-refused` + // entry; not re-measured here). Neither shape converts onto another + // account any more, and `decision_match_key` still refuses first, with + // copy the rep can read. + // + // ⛔ Never paper this over with a second, case-sensitive lookup on the + // raw `name`: a missing key means the producer could not derive one, and + // a tolerant consumer path would hide that while restoring the exact bug + // this node exists to fix. + id: "find_account", + type: "get_record", + label: "Find Existing Account", + config: { objectName: "crm_account", filter: { name_normalized: cel6`leadRecord.company_normalized` }, outputVariable: "matchedAccount" } + }, + { + // Branching is on edges `e5` / `e6`. No `config.condition` here: a + // `decision` node's singular one is never evaluated. + id: "decision_account", + type: "decision", + label: "Account Already Exists?" + }, + { + // NEW-account branch. outputVariable is `createdAccount`; the assignment + // below normalizes both branches onto a single `accountId` id string so + // downstream nodes don't need to know which path ran. + // + // `name` carries the lead's company VERBATIM — the display value. The + // match key `name_normalized` is deliberately absent: it is readonly and + // hook-owned, and `account_protection` derives it from the `name` written + // here, so an account created by this node is immediately findable by the + // next conversion. + id: "create_account", + type: "create_record", + label: "Create Account", + config: { + objectName: "crm_account", + fields: { + // `company` is required on a lead; every other copied fact is + // optional, so its read is guarded to null (an insert treats null as + // it treated the key the template left out). + name: cel6`leadRecord.company`, + phone: cel6`has(leadRecord.phone) ? leadRecord.phone : null`, + website: cel6`has(leadRecord.website) ? leadRecord.website : null`, + industry: cel6`has(leadRecord.industry) ? leadRecord.industry : null`, + annual_revenue: cel6`has(leadRecord.annual_revenue) ? leadRecord.annual_revenue : null`, + number_of_employees: cel6`has(leadRecord.number_of_employees) ? leadRecord.number_of_employees : null`, + billing_address: cel6`has(leadRecord.address) ? leadRecord.address : null`, + owner_id: cel6`current_user.id`, + is_active: true + }, + outputVariable: "createdAccount" + } + }, + { + id: "use_new_account", + type: "assignment", + label: "Use New Account", + config: { assignments: { accountId: cel6`createdAccount.id` } } + }, + { + id: "use_existing_account", + type: "assignment", + label: "Reuse Existing Account", + config: { assignments: { accountId: cel6`matchedAccount.id` } } + }, + { + // Contact dedupe by email — GLOBAL, not per-account. ⛔ Never scope this + // lookup to the account: `crm_contact` carries a global unique index on + // `email`, so an account-scoped lookup misses a same-email contact under + // another account and `create_contact` then explodes on the DB index + // AFTER the account has been created, orphaning it. Leads require an + // email, so the match key is reliable. + id: "find_contact", + type: "get_record", + label: "Find Existing Contact", + config: { + objectName: "crm_contact", + filter: { email: cel6`leadRecord.email` }, + outputVariable: "matchedContact" + } + }, + { + // Branching is on edges `e11` / `e12` — see `decision_account`. + id: "decision_contact", + type: "decision", + label: "Contact Already Exists?" + }, + { + // `accountId` is a bare id string from whichever account branch ran. + id: "create_contact", + type: "create_record", + label: "Create Contact", + config: { + objectName: "crm_contact", + fields: { + // The person's own facts travel with them (#2068). `crm_contact` + // declares each of these on the lead's vocabulary (`_picklists.ts` + // for the two selects, pinned by `test/actions-flows-integrity`), so + // a straight copy is always legal. The two opt-outs are copied, + // never defaulted: a lead that opted out must not become a contact + // that has not — `email_opt_out` hides Send Email and silences + // `contact_welcome`, `do_not_call` refuses a scheduled call. A + // REUSED contact does not come through here: see + // `decision_contact_do_not_call`. + // + // Names and email are required on a lead and read bare; the rest + // are optional and guarded to null, which an insert reads as the + // omitted key the template wrote (each opt-out then takes its + // `false` default, as before). + salutation: cel6`has(leadRecord.salutation) ? leadRecord.salutation : null`, + mobile: cel6`has(leadRecord.mobile) ? leadRecord.mobile : null`, + lead_source: cel6`has(leadRecord.lead_source) ? leadRecord.lead_source : null`, + do_not_call: cel6`has(leadRecord.do_not_call) ? leadRecord.do_not_call : null`, + email_opt_out: cel6`has(leadRecord.email_opt_out) ? leadRecord.email_opt_out : null`, + first_name: cel6`leadRecord.first_name`, + last_name: cel6`leadRecord.last_name`, + email: cel6`leadRecord.email`, + phone: cel6`has(leadRecord.phone) ? leadRecord.phone : null`, + title: cel6`has(leadRecord.title) ? leadRecord.title : null`, + crm_account: cel6`accountId`, + is_primary: true, + owner_id: cel6`current_user.id` + }, + outputVariable: "createdContact" + } + }, + { + id: "use_new_contact", + type: "assignment", + label: "Use New Contact", + config: { assignments: { contactId: cel6`createdContact.id` } } + }, + { + id: "use_existing_contact", + type: "assignment", + label: "Reuse Existing Contact", + config: { assignments: { contactId: cel6`matchedContact.id` } } + }, + { + // ── A REUSED contact keeps the stricter consent (#2068) ────────────── + // + // `create_contact` copies the lead's opt-outs onto a NEW contact. A + // reused contact already holds its own answer, and an opt-out is a + // promise to a person that a conversion never takes back — so this path + // only ever RAISES a flag, one node per flag, and only when the lead + // carries it. The `raise_*` nodes write the literal `true`, ⛔ never a + // copy of `leadRecord.x`: a copy would write the lead's `false` over a contact + // who had opted out. `crm_account` carries neither flag, so the account + // half of "the stricter value wins" has nothing to write. + // + // The edges read the LEAD's flag only, not whether the contact already + // holds it. Reading `vars.matchedContact.x` needs a + // `has(vars.matchedContact)` guard, which + // `test/flow-variable-conditions.test.ts` forbids on this flow (a + // `get_record` binds it on every path) — and writing `true` over `true` + // changes nothing. + // + // Branching on `e35` / `e36`, then `e38` / `e39`: each pair is TOTAL and + // partitions by De Morgan, so exactly one edge holds on every shape + // `get_lead` can bind — pinned in `test/flow-conversion.test.ts`. + id: "decision_contact_do_not_call", + type: "decision", + label: "Lead Is Do-Not-Call?" + }, + { + id: "raise_contact_do_not_call", + type: "update_record", + label: "Carry Do-Not-Call to Contact", + config: { objectName: "crm_contact", filter: { id: cel6`contactId` }, fields: { do_not_call: true } } + }, + { + id: "decision_contact_email_opt_out", + type: "decision", + label: "Lead Opted Out of Email?" + }, + { + id: "raise_contact_email_opt_out", + type: "update_record", + label: "Carry Email Opt-Out to Contact", + config: { objectName: "crm_contact", filter: { id: cel6`contactId` }, fields: { email_opt_out: true } } + }, + { + // Branching is on edges `e16` / `e17` — see `decision_account`. + id: "decision_opportunity", + type: "decision", + label: "Create Opportunity?" + }, + { + // `close_date` comes from the screen field, which is the only layer that + // can carry the `isoDate(daysFromNow(90))` expression — see the + // `closeDate` declaration. An unbound `closeDate` fails the run at this + // node rather than inventing a quarter, which is the failure this node + // is allowed to have. + id: "create_opportunity", + type: "create_record", + label: "Create Opportunity", + config: { + objectName: "crm_opportunity", + fields: { + name: cel6`opportunityName`, + crm_account: cel6`accountId`, + primary_contact: cel6`contactId`, + amount: cel6`opportunityAmount`, + stage: "prospecting", + probability: 10, + lead_source: cel6`has(leadRecord.lead_source) ? leadRecord.lead_source : null`, + close_date: cel6`closeDate`, + owner_id: cel6`current_user.id` + }, + outputVariable: "createdOpportunity" + } + }, + { + // Normalize both opportunity branches onto a single `opportunityId`, the + // same pattern as accountId/contactId. ⛔ Never reference + // `createdOpportunity.id` downstream instead: on the "No" branch the + // create node never ran, and the unbound read fails the run (on 17.x the + // unresolved token interpolated into the `converted_opportunity` lookup + // as a placeholder). + id: "use_new_opportunity", + type: "assignment", + label: "Use New Opportunity", + config: { assignments: { opportunityId: cel6`createdOpportunity.id` } } + }, + { + id: "no_opportunity", + type: "assignment", + label: "No Opportunity", + config: { assignments: { opportunityId: null } } + }, + { + id: "mark_converted", + type: "update_record", + label: "Mark Lead as Converted", + config: { + objectName: "crm_lead", + filter: { id: cel6`recordId` }, + fields: { + // `status: 'converted'` rides along so list views agree with the + // conversion flags (the qualified → converted transition is legal + // per the lead_status_progression state machine). + is_converted: true, + status: "converted", + converted_date: cel6`isoDatetime(now())`, + converted_account: cel6`accountId`, + converted_contact: cel6`contactId`, + converted_opportunity: cel6`opportunityId` + } + } + }, + { + // ADR-0012: deliver via the `notify` node (inbox + email). The legacy + // `script` + `actionType:'email'` shape is a no-op stub in 7.4. + id: "send_notification", + type: "notify", + label: "Send Confirmation", + config: { + recipients: [cel6`current_user.id`], + channels: ["inbox", "email"], + topic: "lead_converted", + template: "crm.lead_converted", + templateData: { first_name: cel6`leadRecord.first_name`, last_name: cel6`leadRecord.last_name` }, + actionUrl: "/crm_account/{{accountId}}" + } + }, + { id: "end", type: "end", label: "End" } + ], + edges: [ + // ⛔ A retired edge's id stays VACANT and every surviving edge keeps the id + // it has always had — `e1`, `e3` and `e15` are gaps on purpose. + // Renumbering to close a gap rewrites ids that other notes, tests and run + // logs refer to. + { id: "e0", source: "start", target: "get_lead", type: "default" }, + // ⛔ When you add an edge, take the next id AFTER THE HIGHEST IN USE — do + // not reuse a vacant one, and do not assume an unused-looking id is free. + // A duplicate id is INERT (traversal filters out-edges by `source`, never + // by `id`), so nothing fails and the collision survives to trap the next + // editor picking out of the sequence. `e1`, `e3` and `e15` are vacant + // retired ids and stay that way; `e27` is above the highest live id, not + // a gap-fill. + { id: "e27", source: "get_lead", target: "decision_approval", type: "default" }, + // ── The approval gate (REQ-0005 step 7) ──────────────────────────── + // + // The same TOTAL, PARTITIONING pair the duplicate verdict below is written + // as, and for the same measured reason: a decision node declaring no + // `config.conditions` takes EVERY out-edge whose condition holds, in + // parallel, so two overlapping guards would refuse the conversion and + // continue it in one run. `e29` is `e28` negated by De Morgan. + // + // ⚠️ The polarity is fail-OPEN, unlike the duplicate branch, and that is the + // gate's off switch rather than a slip. Only the two verdicts a live + // approval writes refuse; `not_required` — the shipped default — and an + // absent column (a lead from before the field existed) both continue, so + // with the gate off this pair is invisible and conversion behaves exactly as + // it did before. `lead.hook.ts` and `convert_lead.visible` carry the same + // polarity, because the three have to agree about what "off" means. + { id: "e28", source: "decision_approval", target: "refuse_unapproved", type: "default", condition: P26`has(vars.leadRecord) && has(vars.leadRecord.conversion_approval_status) + && (vars.leadRecord.conversion_approval_status == "pending" || vars.leadRecord.conversion_approval_status == "rejected")`, label: "Not approved" }, + { id: "e29", source: "decision_approval", target: "decision_duplicate", type: "default", condition: P26`!has(vars.leadRecord) || !has(vars.leadRecord.conversion_approval_status) + || (vars.leadRecord.conversion_approval_status != "pending" && vars.leadRecord.conversion_approval_status != "rejected")`, label: "Clear" }, + // Rejoins nothing, exactly like `e26`: the refusal IS not reaching a writer. + { id: "e30", source: "refuse_unapproved", target: "end", type: "default" }, + // ⚠️ Both conditions are TOTAL, and on this surface that is not a style + // preference: a flow condition is interpreted strict CEL on every run, and + // an unguarded field read against a driver that omits absent columns + // (`driver-memory` / `driver-mongodb`) aborts — which FAILS THE RUN, so an + // unguarded read here would make ordinary leads unconvertible. Measured, in + // exactly that shape: `condition failed to evaluate as CEL: No such key: + // duplicate_status`. The full table is in + // `test/flow-condition-totality.test.ts`. + // + // TWO guards, in the spelling `test/flow-variable-conditions.test.ts` + // requires, and the outer one is not decoration: `vars.leadRecord` is a + // KEY, so a plain `vars.leadRecord != null` would itself abort with + // `Unknown variable` on the run where `get_lead` bound nothing — the guard + // would be the fault it was written to prevent. `has(vars.leadRecord)` + // answers instead of reading. + // + // The THREE edges PARTITION by De Morgan (`!(a && b && c)` written out as + // `!a || !b || !c`, with the two verdict tests conjoined under the last + // term), so exactly one is true for every record shape, including the + // shapes where the column, the row or both are missing. + // + // ⛔ `e22`'s third term must carry BOTH inequalities. A decision node that + // declares no `config.conditions` reports no branch, so traversal takes + // EVERY out-edge whose condition holds, IN PARALLEL — with `e22` left at + // `!= "suspected"` a confirmed lead satisfies `e22` AND `e25`, showing the + // refusal and converting the lead in the same run. Measured on + // `AutomationEngine.evaluateCondition` across all seven record shapes; the + // pin is in `test/lead-duplicate-visibility.test.ts`. + { id: "e21", source: "decision_duplicate", target: "warn_duplicate", type: "default", condition: P26`has(vars.leadRecord) && has(vars.leadRecord.duplicate_status) && vars.leadRecord.duplicate_status == "suspected"`, label: "Suspected" }, + { id: "e25", source: "decision_duplicate", target: "refuse_confirmed_duplicate", type: "default", condition: P26`has(vars.leadRecord) && has(vars.leadRecord.duplicate_status) && vars.leadRecord.duplicate_status == "confirmed"`, label: "Confirmed" }, + { id: "e22", source: "decision_duplicate", target: "no_duplicate_warning", type: "default", condition: P26`!has(vars.leadRecord) || !has(vars.leadRecord.duplicate_status) || (vars.leadRecord.duplicate_status != "suspected" && vars.leadRecord.duplicate_status != "confirmed")`, label: "Clean" }, + // Both clear duplicate branches pass the match-key guard before the form. + { id: "e23", source: "warn_duplicate", target: "decision_match_key", type: "default" }, + { id: "e24", source: "no_duplicate_warning", target: "decision_match_key", type: "default" }, + // ── The match-key guard (#2017) ──────────────────────────────────── + // + // TOTAL and PARTITIONING, for the reason recorded at `e28` / `e29`: `e32` + // is `e31` negated by De Morgan, so exactly one holds for every shape + // `get_lead` can bind — unbound, a null row, the column absent, null, + // empty, or keyed. `has()` alone is not the test: on a row that carries + // the column as null it answers true, so the value needs `isBlank` too. + // Fail-CLOSED, unlike the approval gate: without a key there is nothing to + // match on, and a guess is the defect. + { id: "e31", source: "decision_match_key", target: "screen_1", type: "default", condition: P26`has(vars.leadRecord) && has(vars.leadRecord.company_normalized) && !isBlank(vars.leadRecord.company_normalized)`, label: "Has match key" }, + { id: "e32", source: "decision_match_key", target: "refuse_no_match_key", type: "default", condition: P26`!has(vars.leadRecord) || !has(vars.leadRecord.company_normalized) || isBlank(vars.leadRecord.company_normalized)`, label: "No match key" }, + // Rejoins nothing, exactly like `e26` / `e30`. + { id: "e33", source: "refuse_no_match_key", target: "end", type: "default" }, + // The refusal branch rejoins nothing: it goes straight to `end`, so no + // node that writes is downstream of it. That is the refusal — the flow's + // every create/update sits behind `screen_1`, which this path never + // reaches. + { id: "e26", source: "refuse_confirmed_duplicate", target: "end", type: "default" }, + { id: "e2", source: "screen_1", target: "find_account", type: "default" }, + { id: "e4", source: "find_account", target: "decision_account", type: "default" }, + // Existing account → reuse; no account → create. Both converge on create_contact. + // `find_account` is reached only with a match key (`e31`), so a match + // here is an equality on a real key, never the has-no-value predicate. + // ⛔ No second copy of the key test on these two edges: it could never + // be false here, and an inert restatement of a live predicate is the + // shape #650 retired from this repo's decision nodes. + { id: "e5", source: "decision_account", target: "use_existing_account", type: "default", condition: P26`vars.matchedAccount != null`, label: "Existing" }, + { id: "e6", source: "decision_account", target: "create_account", type: "default", condition: P26`vars.matchedAccount == null`, label: "New" }, + { id: "e7", source: "create_account", target: "use_new_account", type: "default" }, + // Both account branches converge on the contact-dedupe lookup. + { id: "e8", source: "use_new_account", target: "find_contact", type: "default" }, + { id: "e9", source: "use_existing_account", target: "find_contact", type: "default" }, + { id: "e10", source: "find_contact", target: "decision_contact", type: "default" }, + // Existing contact → reuse; none → create. Both converge on + // decision_opportunity, the reuse path through the consent raise below. + { id: "e11", source: "decision_contact", target: "use_existing_contact", type: "default", condition: P26`vars.matchedContact != null`, label: "Existing" }, + { id: "e12", source: "decision_contact", target: "create_contact", type: "default", condition: P26`vars.matchedContact == null`, label: "New" }, + { id: "e13", source: "create_contact", target: "use_new_contact", type: "default" }, + { id: "e14", source: "use_new_contact", target: "decision_opportunity", type: "default" }, + // ── The reused contact's consent raise (#2068) ───────────────────── + // + // `e15` (use_existing_contact → decision_opportunity) is RETIRED and stays + // vacant; `e34` replaces it. Each pair below is TOTAL and PARTITIONING, and + // only a flag the lead carries as `true` takes the raise. + { id: "e34", source: "use_existing_contact", target: "decision_contact_do_not_call", type: "default" }, + { id: "e35", source: "decision_contact_do_not_call", target: "raise_contact_do_not_call", type: "default", condition: P26`has(vars.leadRecord) && has(vars.leadRecord.do_not_call) && vars.leadRecord.do_not_call == true`, label: "Do not call" }, + { id: "e36", source: "decision_contact_do_not_call", target: "decision_contact_email_opt_out", type: "default", condition: P26`!has(vars.leadRecord) || !has(vars.leadRecord.do_not_call) || vars.leadRecord.do_not_call != true`, label: "Callable" }, + { id: "e37", source: "raise_contact_do_not_call", target: "decision_contact_email_opt_out", type: "default" }, + { id: "e38", source: "decision_contact_email_opt_out", target: "raise_contact_email_opt_out", type: "default", condition: P26`has(vars.leadRecord) && has(vars.leadRecord.email_opt_out) && vars.leadRecord.email_opt_out == true`, label: "Opted out" }, + { id: "e39", source: "decision_contact_email_opt_out", target: "decision_opportunity", type: "default", condition: P26`!has(vars.leadRecord) || !has(vars.leadRecord.email_opt_out) || vars.leadRecord.email_opt_out != true`, label: "Emailable" }, + { id: "e40", source: "raise_contact_email_opt_out", target: "decision_opportunity", type: "default" }, + { id: "e16", source: "decision_opportunity", target: "create_opportunity", type: "default", condition: P26`vars.createOpportunity == true`, label: "Yes" }, + { id: "e17", source: "decision_opportunity", target: "no_opportunity", type: "default", condition: P26`vars.createOpportunity != true`, label: "No" }, + { id: "e18", source: "create_opportunity", target: "use_new_opportunity", type: "default" }, + { id: "e18a", source: "use_new_opportunity", target: "mark_converted", type: "default" }, + { id: "e18b", source: "no_opportunity", target: "mark_converted", type: "default" }, + { id: "e19", source: "mark_converted", target: "send_notification", type: "default" }, + { id: "e20", source: "send_notification", target: "end", type: "default" } + ] +}; + +// src/sales/flows/lead-conversion-approval.flow.ts +import { P as P27, cel as cel7 } from "@objectstack/spec"; +var LeadConversionApprovalFlow = { + name: "lead_conversion_approval", + label: "Lead Conversion Approval", + description: "Sign-off a lead needs before it may be converted. Inert unless the install arms the gate on crm_lead.conversion_approval_status.", + type: "record_change", + status: "active", + // Same reading `opportunity_approval` records, and for the same two reasons. + // A gate exists to CONSTRAIN the submitter, so the submitter's own scope is + // the wrong identity to evaluate it under — and an approval control that + // engages only for writers carrying a session is not a control, since a + // `runAs: 'system'` importer creating leads would simply bypass it. The + // verdict writes below also land on `conversion_approval_status`, which is + // `readonly: true` on the object, so only a platform write reaches it. + runAs: "system", + variables: [ + { name: "leadId", type: "text", isInput: true, isOutput: false } + ], + nodes: [ + { + id: "start", + type: "start", + label: "Start", + config: { + objectName: "crm_lead", + triggerType: "record-after-create", + // TOTALITY (AGENTS.md — validation predicates must be TOTAL): `has()` + // on every read. A flow condition is strict CEL on every run, and an + // unguarded read against a driver that omits absent columns aborts — + // which from 17.0.0-rc.2 FAILS THE RUN rather than skipping it. The + // absent case must read as "not gated": a lead with no approval column + // at all is a lead from before the field existed, and it converts the + // way it always did. + condition: P27`has(record.conversion_approval_status) && record.conversion_approval_status == "pending"` + } + }, + { + id: "get_lead", + type: "get_record", + label: "Get Lead", + config: { objectName: "crm_lead", filter: { id: cel7`record.id` }, outputVariable: "leadRecord" } + }, + { + id: "conversion_review", + type: "approval", + label: "Lead Conversion Review", + config: { + // The customer's chain is 销售负责人 → 销售总监; the generic shape core + // ships is the manager bench this app already declares approvers + // against. A second tier, or a different position, is overlay + // configuration — the same status as the need-type vocabulary. + approvers: [{ type: "position", value: "sales_manager" }], + // Explicit though it is the schema default, exactly as + // `opportunity_approval` authors it: approvers snapshot at request + // creation, so an empty bench would otherwise leave the request + // undecidable — and here that means a lead nobody can ever convert. + onEmptyApprovers: "admin_rescue", + behavior: "first_response", + // ⚠️ `false`, and NOT the schema default `true` — the one place this + // node deliberately differs from its opportunity sibling. A deal under + // review is a document being negotiated; a LEAD under review is a person + // a rep is still calling. Locking the record would freeze + // `last_contacted_date`, `next_followup_date`, the notes and every + // activity bubble for as long as the approver takes, so the gate would + // stop the work it exists to authorise. Nothing is at risk in leaving it + // open: the verdict column is `readonly: true`, so the only field this + // node's decision touches is one no user may write anyway. + lockRecord: false, + approvalStatusField: "conversion_approval_status" + } + }, + { + id: "mark_approved", + type: "update_record", + label: "Mark Approved", + config: { + objectName: "crm_lead", + filter: { id: cel7`record.id` }, + fields: { conversion_approval_status: "approved" } + } + }, + { + id: "notify_approved", + type: "notify", + label: "Notify Owner \u2014 Approved", + config: { + recipients: [cel7`has(leadRecord.owner_id) ? leadRecord.owner_id : null`], + channels: ["inbox"], + topic: "lead_conversion_approved", + template: "crm.lead_conversion_approved", + templateData: { first_name: cel7`leadRecord.first_name`, last_name: cel7`leadRecord.last_name` }, + actionUrl: "/crm_lead/{{record.id}}" + } + }, + { + id: "mark_rejected", + type: "update_record", + label: "Mark Rejected", + config: { + objectName: "crm_lead", + filter: { id: cel7`record.id` }, + fields: { conversion_approval_status: "rejected" } + } + }, + { + id: "notify_rejected", + type: "notify", + label: "Notify Owner \u2014 Rejected", + config: { + recipients: [cel7`has(leadRecord.owner_id) ? leadRecord.owner_id : null`], + channels: ["inbox"], + severity: "warning", + topic: "lead_conversion_rejected", + template: "crm.lead_conversion_rejected", + templateData: { first_name: cel7`leadRecord.first_name`, last_name: cel7`leadRecord.last_name` }, + actionUrl: "/crm_lead/{{record.id}}" + } + }, + { id: "end", type: "end", label: "End" } + ], + edges: [ + { id: "e1", source: "start", target: "get_lead", type: "default" }, + { id: "e2", source: "get_lead", target: "conversion_review", type: "default" }, + // Approval-node branch labels — the engine resumes down the out-edge whose + // `label` matches the recorded decision. + { id: "e3", source: "conversion_review", target: "mark_approved", type: "default", label: "approve" }, + { id: "e4", source: "conversion_review", target: "mark_rejected", type: "default", label: "reject" }, + { id: "e5", source: "mark_approved", target: "notify_approved", type: "default" }, + { id: "e6", source: "notify_approved", target: "end", type: "default" }, + { id: "e7", source: "mark_rejected", target: "notify_rejected", type: "default" }, + { id: "e8", source: "notify_rejected", target: "end", type: "default" } + ] +}; + +// src/sales/flows/account-approval.flow.ts +import { P as P28, cel as cel8 } from "@objectstack/spec"; +var AccountApprovalFlow = { + name: "account_approval", + label: "Account Approval", + description: "Sign-off a newly created account needs before it counts as established data. Switchable from crm_account.approval_status.", + type: "record_change", + status: "active", + // Same reading the two sibling approval flows record. A gate exists to + // CONSTRAIN the submitter, so the submitter's own scope is the wrong identity + // to evaluate it under; and the verdict writes below land on + // `approval_status`, which is `readonly: true` on the object, so only a + // platform write reaches it at all. + runAs: "system", + variables: [{ name: "accountId", type: "text", isInput: true, isOutput: false }], + nodes: [ + { + id: "start", + type: "start", + label: "Start", + config: { + objectName: "crm_account", + triggerType: "record-after-create", + // Fires on the BLANK a new account is born with (see the header): + // absent on a sparse driver, null on SQL. A user cannot pre-fill the + // column (it is `readonly`), so only a system writer or an install's + // `approved` default can make it non-blank at insert, and both mean + // "nothing to submit". + // TOTALITY (AGENTS.md — validation predicates must be TOTAL): the + // `(!has(x) || isBlank(x))` form is the "x holds no value" row of that + // table. A flow condition is strict CEL on every run, and an unguarded + // read against a driver that omits absent columns aborts — which from + // 17.0.0-rc.2 FAILS THE RUN rather than skipping it. + condition: P28`!has(record.approval_status) || isBlank(record.approval_status)` + } + }, + { + id: "get_account", + type: "get_record", + label: "Get Account", + config: { + objectName: "crm_account", + filter: { id: cel8`record.id` }, + outputVariable: "accountRecord" + } + }, + { + id: "account_review", + type: "approval", + label: "Account Review", + config: { + // The customer's chain is 销售负责人 → 销售总监; REQ-0003 rules that named + // chain **C** (overlay — one company's org chart), so core ships the + // one generic tier against the manager bench this app already declares. + approvers: [{ type: "position", value: "sales_manager" }], + // Explicit though it is the schema default, exactly as both sibling + // flows author it: approvers snapshot at request creation, so an empty + // bench would otherwise leave the request undecidable — and here that + // means an account nobody can ever approve. + onEmptyApprovers: "admin_rescue", + behavior: "first_response", + // ⚠️ `false`, matching the lead sibling rather than the opportunity one. + // An account under review is a record a rep is still working — contacts + // are being attached, the address is being corrected, activity is + // landing on it. Locking it would freeze exactly the data-entry the + // approval exists to review. Nothing is at risk: the verdict column is + // `readonly: true`, so the only field this decision touches is one no + // user may write anyway. + lockRecord: false, + approvalStatusField: "approval_status" + } + }, + { + id: "mark_approved", + type: "update_record", + label: "Mark Approved", + config: { + objectName: "crm_account", + filter: { id: cel8`record.id` }, + fields: { approval_status: "approved" } + } + }, + { + id: "notify_approved", + type: "notify", + label: "Notify Owner \u2014 Approved", + config: { + recipients: [cel8`has(accountRecord.owner_id) ? accountRecord.owner_id : null`], + channels: ["inbox"], + topic: "account_approved", + template: "crm.account_approved", + templateData: { name: cel8`accountRecord.name` }, + actionUrl: "/crm_account/{{record.id}}" + } + }, + { + id: "mark_rejected", + type: "update_record", + label: "Mark Rejected", + config: { + objectName: "crm_account", + filter: { id: cel8`record.id` }, + fields: { approval_status: "rejected" } + } + }, + { + id: "notify_rejected", + type: "notify", + label: "Notify Owner \u2014 Rejected", + config: { + recipients: [cel8`has(accountRecord.owner_id) ? accountRecord.owner_id : null`], + channels: ["inbox"], + severity: "warning", + topic: "account_rejected", + template: "crm.account_rejected", + templateData: { name: cel8`accountRecord.name` }, + actionUrl: "/crm_account/{{record.id}}" + } + }, + { id: "end", type: "end", label: "End" } + ], + edges: [ + { id: "e1", source: "start", target: "get_account", type: "default" }, + { id: "e2", source: "get_account", target: "account_review", type: "default" }, + // Approval-node branch labels — the engine resumes down the out-edge whose + // `label` matches the recorded decision. + { id: "e3", source: "account_review", target: "mark_approved", type: "default", label: "approve" }, + { id: "e4", source: "account_review", target: "mark_rejected", type: "default", label: "reject" }, + { id: "e5", source: "mark_approved", target: "notify_approved", type: "default" }, + { id: "e6", source: "notify_approved", target: "end", type: "default" }, + { id: "e7", source: "mark_rejected", target: "notify_rejected", type: "default" }, + { id: "e8", source: "notify_rejected", target: "end", type: "default" } + ] +}; + +// src/sales/flows/schedule-followup.flow.ts +import { cel as cel9 } from "@objectstack/spec"; +var ScheduleFollowUpFlow = { + name: "schedule_followup", + label: "Schedule Follow-up", + description: "Create the next follow-up task on a lead, already linked and owned.", + type: "screen", + status: "active", + variables: [ + // MUST be `recordId` — the console's flow-action contract seeds only that + // name (and its camelCase object alias); a custom name arrives undefined. + { name: "recordId", type: "text", isInput: true, isOutput: false }, + { name: "subject", type: "text", isInput: true, isOutput: false }, + { name: "dueDate", type: "date", isInput: true, isOutput: false }, + { name: "activityType", type: "text", isInput: true, isOutput: false }, + { name: "priority", type: "text", isInput: true, isOutput: false }, + { name: "notes", type: "text", isInput: true, isOutput: false } + ], + nodes: [ + { id: "start", type: "start", label: "Start", config: { objectName: "crm_lead" } }, + { + id: "screen_1", + type: "screen", + label: "Schedule Follow-up", + config: { + fields: [ + { name: "subject", label: "What is the next step?", type: "text", required: true }, + { name: "dueDate", label: "Due Date", type: "date", required: true }, + { + name: "activityType", + label: "Activity Type", + type: "select", + // Mirrors crm_task.type exactly. ⛔ Never hand-copy the subset — it + // silently drops an option (`other`) from the picker. + options: plainOptions(TASK_TYPE_OPTIONS) + }, + { + name: "priority", + label: "Priority", + type: "select", + options: [ + { label: "Low", value: "low" }, + { label: "Normal", value: "normal" }, + { label: "High", value: "high" }, + { label: "Urgent", value: "urgent" } + ] + }, + { name: "notes", label: "Notes", type: "textarea" } + ] + } + }, + { + id: "get_lead", + type: "get_record", + label: "Get Lead Record", + config: { objectName: "crm_lead", filter: { id: cel9`recordId` }, outputVariable: "leadRecord" } + }, + { + id: "create_task", + type: "create_record", + label: "Create Follow-up Task", + config: { + objectName: "crm_task", + fields: { + subject: cel9`subject`, + due_date: cel9`dueDate`, + // The three optional answers: a resume may leave one unbound, which + // the template wrote as nothing and the guard writes as null. On an + // insert the two are the same — the engine applies a field's default + // to an explicit null exactly as to an omitted key, so an unanswered + // priority still lands as `normal`. + type: cel9`has(vars.activityType) ? activityType : null`, + priority: cel9`has(vars.priority) ? priority : null`, + description: cel9`has(vars.notes) ? notes : null`, + status: "not_started", + owner_id: cel9`current_user.id`, + // Polymorphic parent: both halves are required for the lead's + // Related tab to pick the task up. + related_to_type: "crm_lead", + related_to_lead: cel9`recordId` + }, + outputVariable: "createdTask" + } + }, + { + // Keep the lead's own follow-up date in step with the task that was just + // filed, so the Hot Leads view (sorted by next_followup_date) reflects + // the commitment the rep actually made. + id: "stamp_lead", + type: "update_record", + label: "Stamp Next Follow-up Date", + config: { + objectName: "crm_lead", + filter: { id: cel9`recordId` }, + fields: { next_followup_date: cel9`dueDate` } + } + }, + { id: "end", type: "end", label: "End" } + ], + edges: [ + { id: "e1", source: "start", target: "screen_1", type: "default" }, + { id: "e2", source: "screen_1", target: "get_lead", type: "default" }, + { id: "e3", source: "get_lead", target: "create_task", type: "default" }, + { id: "e4", source: "create_task", target: "stamp_lead", type: "default" }, + { id: "e5", source: "stamp_lead", target: "end", type: "default" } + ] +}; + +// src/sales/flows/opportunity-approval.flow.ts +import { P as P29, cel as cel10 } from "@objectstack/spec"; +var OpportunityApprovalFlow = { + name: "opportunity_approval", + label: "Large Deal Approval", + description: "Tiered approval for opportunities: manager review at $100K or more, director sign-off > $500K.", + type: "record_change", + status: "active", + // Same user-less exposure as every record-change flow (ADR-0049) — and the + // one with teeth. Measured on 17.0.0-rc.2: a $150K renewal + // created by the `runAs: 'system'` contract_renewal sweep fired this flow + // with no trigger user, and the run died at `get_opportunity`. The deal sat + // at `approval_status: 'not_required'`, unlocked, with no approval request + // ever opened — the gate was bypassed by the writer simply not carrying a + // session. An approval control that only engages for logged-in writers is + // not a control. + // + // Elevating the USER-driven runs too is not merely acceptable here, it is + // required. This gate exists to CONSTRAIN the submitter, so the submitter's + // own scope is the wrong identity to evaluate it under; and + // `mark_approved` / `mark_rejected` stamp `approval_status` on a record the + // approval node holds locked (`lockRecord: true`), which only a platform + // write may land. The approval node itself already opens its request under + // the platform identity while re-attaching the deciding user for + // attribution, so this declaration aligns the flow with the node it drives. + runAs: "system", + variables: [ + { name: "opportunityId", type: "text", isInput: true, isOutput: false } + ], + nodes: [ + { + id: "start", + type: "start", + label: "Start", + // Trigger wiring (7.4): bind to afterUpdate; gate on crossing the entry + // threshold while not already in an approval state. The `not_required` + // guard stops the flow's own approval_status writes from re-triggering it. + config: { + objectName: "crm_opportunity", + triggerType: "record-after-update", + // Null-tolerant: rows inserted before approval_status had a field-level + // defaultValue (e.g. flow-created opportunities) carry null, which must + // still enter approval. + // Stage guard: a settled deal must never (re-)enter approval — the + // freeze hook rejects approval-status writes on closed records, so + // without this guard the flow opened a locked approval request it + // could never resolve (lockRecord held the closed record hostage). + // TOTALITY: `has(...)` on every read, plus `!= null` on the + // ordering comparison — `has()` passes an explicit null and + // `record.amount >= 100000` then aborts with + // `no such overload: dyn >= int`. Measured total as authored + // today (amount/stage are required, approval_status is defaulted), but + // that is `crm_opportunity`'s schema doing the work, not the + // predicate. An absent `approval_status` reads the same as the null + // this condition already tolerates; an absent `stage` is not a settled + // stage, so it must not block approval. + condition: P29`has(record.amount) && record.amount != null && record.amount >= ${LARGE_DEAL_AMOUNT} + && (!has(record.approval_status) || record.approval_status == "not_required" || record.approval_status == null) + && (!has(record.stage) || (record.stage != "closed_won" && record.stage != "closed_lost"))` + } + }, + { + id: "get_opportunity", + type: "get_record", + label: "Get Opportunity", + config: { objectName: "crm_opportunity", filter: { id: cel10`record.id` }, outputVariable: "oppRecord" } + }, + // ── Tier 1: Sales Manager review (all deals at $100K or more) ─── + { + id: "manager_review", + type: "approval", + label: "Sales Manager Review", + config: { + // ⛔ Never add an org-owner approver as an empty-bench workaround. + // `onEmptyApprovers: 'admin_rescue'` is the node policy for an empty + // position on @objectstack 17 (approvers snapshot at request creation, + // so a position with no holders would otherwise leave the request + // undecidable while `lockRecord` held the record hostage). An + // `{ type: 'org_membership_level', value: 'owner' }` entry overshoots: + // with `behavior: 'first_response'` it makes an org owner a routine + // approver for every deal, not a rescue when the bench is empty. + approvers: [{ type: "position", value: "sales_manager" }], + // Explicit even though `admin_rescue` is the schema default — this is + // the mechanism the node depends on, so it is authored, not inherited. + onEmptyApprovers: "admin_rescue", + behavior: "first_response", + lockRecord: true, + approvalStatusField: "approval_status" + } + }, + // ── Tier gate: does this deal also need director sign-off? ────── + { + // No `config.condition` here: the branch is on edges `e5` / `e6`, which + // is where the engine actually reads it. A copy on the node would be + // inert and indistinguishable from the live one (17.0.0-rc.2's + // `flow-inert-node-condition`). + id: "check_high_value", + type: "decision", + label: "High Value (> $500K)?" + }, + // ── Tier 2: Sales Director sign-off (deals > $500K only) ──────── + { + id: "director_signoff", + type: "approval", + label: "Sales Director Sign-off", + config: { + // Same node policy as manager_review — see the note there. + approvers: [{ type: "position", value: "sales_director" }], + onEmptyApprovers: "admin_rescue", + behavior: "first_response", + lockRecord: true, + approvalStatusField: "approval_status" + } + }, + // ── Final approve: stamp status + notify owner ────────────────── + { + id: "mark_approved", + type: "update_record", + label: "Mark Approved", + config: { + objectName: "crm_opportunity", + filter: { id: cel10`record.id` }, + fields: { approval_status: "approved", approved_date: cel10`isoDatetime(now())` } + } + }, + { + id: "notify_approved", + type: "notify", + label: "Notify Owner \u2014 Approved", + config: { + recipients: [cel10`has(oppRecord.owner_id) ? oppRecord.owner_id : null`], + channels: ["inbox", "email"], + topic: "opportunity_approved", + template: "crm.opportunity_approved", + templateData: { name: cel10`oppRecord.name` }, + actionUrl: "/crm_opportunity/{{record.id}}" + } + }, + // ── Rejection: stamp status + notify owner ────────────────────── + { + id: "mark_rejected", + type: "update_record", + label: "Mark Rejected", + config: { + objectName: "crm_opportunity", + filter: { id: cel10`record.id` }, + fields: { approval_status: "rejected" } + } + }, + { + id: "notify_rejected", + type: "notify", + label: "Notify Owner \u2014 Rejected", + config: { + recipients: [cel10`has(oppRecord.owner_id) ? oppRecord.owner_id : null`], + channels: ["inbox", "email"], + severity: "warning", + topic: "opportunity_rejected", + template: "crm.opportunity_rejected", + templateData: { name: cel10`oppRecord.name` }, + actionUrl: "/crm_opportunity/{{record.id}}" + } + }, + { id: "end", type: "end", label: "End" } + ], + edges: [ + { id: "e1", source: "start", target: "get_opportunity", type: "default" }, + { id: "e2", source: "get_opportunity", target: "manager_review", type: "default" }, + // Manager decision (approval-node branch labels) + { id: "e3", source: "manager_review", target: "check_high_value", type: "default", label: "approve" }, + { id: "e4", source: "manager_review", target: "mark_rejected", type: "default", label: "reject" }, + // Tier gate (decision-node conditional branches). These EDGES are the live + // sites — the engine never evaluates a `decision` node's singular + // `config.condition` — and they must PARTITION, so the guards are written + // in opposite polarity. A deal whose amount cannot be read lands on + // `mark_approved`: the manager has already approved it, and an unreadable + // amount must not strand an approved deal in a locked, undecidable + // director step. + // + // TOTALITY: `oppRecord` is a `get_record` OUTPUT, so the read needs + // `has(vars.oppRecord)` (the variable), `has(vars.oppRecord.amount)` (the + // column — `findOne` answers a miss with `null`, and a sparse driver row + // omits an unwritten column outright) and `!= null` (an explicit null + // passes `has()` and the ordering comparison then aborts with `no such + // overload: dyn > int`). Measured total as authored today — `amount` + // is `required` on `crm_opportunity` and the `get_record` is keyed on the + // row that just fired the trigger — but that is the neighbouring schema + // doing the work, exactly as in the start condition above. `vars.`-scoped + // rather than bare: `has(oppRecord.amount)` still aborts with `Unknown + // variable: oppRecord` on an unbound variable, `has(vars.oppRecord)` + // answers `false` (measured). From 17.0.0-rc.2 an unevaluable condition + // ABORTS the step rather than skipping it, so a guard that was + // belt-and-braces is now what keeps the run alive. + { id: "e5", source: "check_high_value", target: "director_signoff", type: "conditional", condition: P29`has(vars.oppRecord) && has(vars.oppRecord.amount) + && vars.oppRecord.amount != null && vars.oppRecord.amount > ${HIGH_VALUE_DEAL_AMOUNT}`, label: "High value (> $500K)" }, + { id: "e6", source: "check_high_value", target: "mark_approved", type: "conditional", condition: P29`!has(vars.oppRecord) || !has(vars.oppRecord.amount) + || vars.oppRecord.amount == null || vars.oppRecord.amount <= ${HIGH_VALUE_DEAL_AMOUNT}`, label: "Standard (\u2264 $500K)" }, + // Director decision (approval-node branch labels) + { id: "e7", source: "director_signoff", target: "mark_approved", type: "default", label: "approve" }, + { id: "e8", source: "director_signoff", target: "mark_rejected", type: "default", label: "reject" }, + // Terminal branches + { id: "e9", source: "mark_approved", target: "notify_approved", type: "default" }, + { id: "e10", source: "notify_approved", target: "end", type: "default" }, + { id: "e11", source: "mark_rejected", target: "notify_rejected", type: "default" }, + { id: "e12", source: "notify_rejected", target: "end", type: "default" } + ] +}; +var OpportunityApprovalOnCreateFlow = { + ...OpportunityApprovalFlow, + name: "opportunity_approval_on_create", + label: "Large Deal Approval (on create)", + description: "Approval intake for opportunities created above the threshold (insert-time twin of opportunity_approval).", + nodes: OpportunityApprovalFlow.nodes.map( + (n) => n.id === "start" ? { ...n, config: { ...n.config, triggerType: "record-after-create" } } : n + ) +}; + +// src/sales/flows/opportunity-status-change-approval.flow.ts +import { P as P30, cel as cel11 } from "@objectstack/spec"; +var OpportunityStatusChangeApprovalFlow = { + name: "opportunity_status_change_approval", + label: "Opportunity Status Change Approval", + description: "Sign-off a deal needs before it is declared won or lost. Inert unless the install arms the gate on crm_opportunity.status_change_approval_status.", + type: "record_change", + status: "active", + // REQ-0006 acceptance 4, and the same reading `opportunity_approval` records + // from its own measured failure: a gate that engages only for writers + // carrying a session is not a control — a `runAs: 'system'` sweep or import + // would simply bypass it. The verdict and the stage write below also land on + // columns the readonly strip protects, which only a platform write reaches. + runAs: "system", + variables: [ + { name: "opportunityId", type: "text", isInput: true, isOutput: false } + ], + nodes: [ + { + id: "start", + type: "start", + label: "Start", + config: { + objectName: "crm_opportunity", + triggerType: "record-after-update", + // TOTALITY (AGENTS.md — validation predicates must be TOTAL): `has()` + // on every read. A flow condition is strict CEL on every run and an + // unguarded read against a driver that omits absent columns aborts, + // which from 17.0.0-rc.2 FAILS THE RUN rather than skipping it. The + // absent case must read as "not gated": a deal with no gate column at + // all predates the field and closes the way it always did. + // + // Three halves: + // + // - the gate is ARMED: `pending` (born armed, no request decided yet) + // or `rejected` (the last request was refused). `rejected` re-opens + // on a new request because `opportunity.hook.ts` refuses a direct + // close in both states — if only `pending` entered here, a rejected + // deal could be neither requested nor closed, ever. + // - a request is present; + // - the request is NEW on this write. TRANSITION, not current value — + // the idiom `billing_handoff_closed_won` records for this object. + // Without it the flow re-fires on its own write-back while the + // request is still open (the approval node's `pending` stamp through + // `approvalStatusField` is an update of this record). Measured on + // 17.6.0 with this term deleted: one re-entry per request, each + // caught only by the engine's self-trigger guard ("the guard as + // authored does not exclude the flow's own write-back"); with it, + // none. `previous.*` is guarded FAIL-CLOSED: no visible prior + // value, no visible new request. + // + // `apply_status` leaves the gate `approved` (out of reach) and + // `clear_request` empties the request, so neither re-enters. + condition: P30`has(record.status_change_approval_status) + && (record.status_change_approval_status == "pending" || record.status_change_approval_status == "rejected") + && has(record.requested_status) && record.requested_status != null && record.requested_status != "" + && has(previous.requested_status) && previous.requested_status != record.requested_status` + } + }, + { + id: "get_opportunity", + type: "get_record", + label: "Get Opportunity", + config: { objectName: "crm_opportunity", filter: { id: cel11`record.id` }, outputVariable: "oppRecord" } + }, + { + id: "status_review", + type: "approval", + label: "Status Change Review", + config: { + // The customer's chain is 销售负责人 → 事业部负责人; the generic shape core + // ships is the manager bench this app already declares approvers + // against. A second tier, or a different position, is overlay + // configuration (REQ-0006 acceptance 5). + approvers: [{ type: "position", value: "sales_manager" }], + // Explicit though it is the schema default, exactly as both sibling + // approvals author it: approvers snapshot at request creation, so an + // empty bench would leave the request undecidable — and here that + // means a deal nobody can ever close. + onEmptyApprovers: "admin_rescue", + behavior: "first_response", + // `true`, matching `opportunity_approval` and NOT the lead gate: a deal + // awaiting a won/lost verdict must not keep moving underneath the + // approver. Its narrative fields are what the freeze hook leaves open + // anyway. + lockRecord: true, + approvalStatusField: "status_change_approval_status" + } + }, + { + // The approved decision is what moves the stage — "通过后正式生效". + // + // ⚠️ Both fields in ONE write, and that is load-bearing: the + // status-change guard in `opportunity.hook.ts` reads the gate column + // INPUT-FIRST, so this write presents itself as already-approved and the + // guard lets the stage through. Splitting it into two writes would have + // the guard refuse the flow's own write (ELEVATION IS NOT ANONYMITY — + // `runAs: 'system'` carries the triggering user, so `ctx.user?.id` is + // present in this run). + // + // `win_reason` / `loss_reason` are `requiredWhen` the stage is closed and + // are evaluated against the merged record, so the values the rep captured + // when requesting satisfy them here. + id: "apply_status", + type: "update_record", + label: "Apply Requested Status", + config: { + objectName: "crm_opportunity", + filter: { id: cel11`record.id` }, + fields: { + stage: cel11`oppRecord.requested_status`, + status_change_approval_status: "approved", + approved_date: cel11`isoDatetime(now())` + } + } + }, + { + // A rejected request is cleared, not left standing, and the verdict stays + // `rejected` so the hook keeps refusing a direct close: the way on is a + // new request, which the start condition opens as a fresh approval. + id: "clear_request", + type: "update_record", + label: "Clear Rejected Request", + config: { + objectName: "crm_opportunity", + filter: { id: cel11`record.id` }, + fields: { status_change_approval_status: "rejected", requested_status: null } + } + }, + { id: "end", type: "end", label: "End" } + ], + edges: [ + { id: "e1", source: "start", target: "get_opportunity", type: "default" }, + { id: "e2", source: "get_opportunity", target: "status_review", type: "default" }, + // Approval-node branch labels. + { id: "e3", source: "status_review", target: "apply_status", type: "default", label: "approve" }, + { id: "e4", source: "status_review", target: "clear_request", type: "default", label: "reject" }, + { id: "e5", source: "apply_status", target: "end", type: "default" }, + { id: "e6", source: "clear_request", target: "end", type: "default" } + ] +}; + +// src/sales/flows/opportunity-qualification-approval.flow.ts +import { P as P31, cel as cel12 } from "@objectstack/spec"; +var OpportunityQualificationApprovalFlow = { + name: "opportunity_qualification_approval", + label: "Opportunity Qualification Approval", + description: "The \u7ACB\u9879 sign-off a deal needs before its stage or won/lost call may change. Inert unless the install arms the gate on crm_opportunity.qualification_approval_status.", + type: "record_change", + status: "active", + // The reading both sibling gates record from `opportunity_approval`'s + // measured failure: a gate that engages only for writers carrying a session + // is not a control. The verdict writes below also land on a column the + // readonly strip protects, which only a platform write reaches. + runAs: "system", + variables: [ + { name: "opportunityId", type: "text", isInput: true, isOutput: false } + ], + nodes: [ + { + id: "start", + type: "start", + label: "Start", + config: { + objectName: "crm_opportunity", + triggerType: "record-after-update", + // TOTALITY (AGENTS.md — validation predicates must be TOTAL): `has()` + // on every read; the absent case reads as "not gated". + // + // Three halves, the status-change gate's own: + // + // - the gate is ARMED: `pending` or `rejected`. `rejected` re-opens on a + // new request because the hook refuses the gated acts in both states — + // if only `pending` entered here, a rejected deal could never qualify. + // - the request is ticked; + // - the request is NEW on this write. TRANSITION, not current value: + // the approval node's `pending` stamp through `approvalStatusField` is + // an update of this record while the request is still ticked, and a + // current-value test re-fires on it. Measured on a 17.6.0 boot with + // this term deleted: one re-entry per request, caught only by the + // engine's self-trigger guard ("the guard as authored does not + // exclude the flow's own write-back"); with it, none. `previous.*` is + // guarded FAIL-CLOSED: no visible prior value, no visible new request. + // + // `mark_qualified` leaves the gate `approved` (out of reach) and + // `clear_request` unticks the request, so neither re-enters. + condition: P31`has(record.qualification_approval_status) + && (record.qualification_approval_status == "pending" || record.qualification_approval_status == "rejected") + && has(record.qualification_requested) && record.qualification_requested == true + && has(previous.qualification_requested) && previous.qualification_requested != true` + } + }, + { + id: "get_opportunity", + type: "get_record", + label: "Get Opportunity", + config: { objectName: "crm_opportunity", filter: { id: cel12`record.id` }, outputVariable: "oppRecord" } + }, + { + id: "qualification_review", + type: "approval", + label: "Qualification Review", + config: { + // The customer's chain is 销售负责人 / 事业部审批岗 → 事业部负责人; the generic + // shape core ships is the manager bench both sibling gates route to. A + // second tier, or a different position, is overlay configuration + // (REQ-0006: the named approval chains are C). + approvers: [{ type: "position", value: "sales_manager" }], + // Explicit though it is the schema default, as every sibling authors + // it: an empty bench would leave the request undecidable — here, a + // deal that can never move its stage. + onEmptyApprovers: "admin_rescue", + behavior: "first_response", + // ⚠️ `false`, NOT the status-change gate's `true` — the one term this + // node deliberately takes from the LEAD gate instead. Step 11 says it + // in as many words: 「新增商机可跟进」. A deal awaiting 立项 is still being + // worked — the narrative, the customer calendar, the amount and Will + // Bid are what the approver reads — and locking it would stop that work + // for as long as the approver takes. The two acts the gate exists to hold + // are refused by `opportunity_lifecycle` whether or not a request is + // open, so the lock would add nothing but the freeze. + lockRecord: false, + approvalStatusField: "qualification_approval_status" + } + }, + { + id: "mark_qualified", + type: "update_record", + label: "Mark Qualified", + config: { + objectName: "crm_opportunity", + filter: { id: cel12`record.id` }, + fields: { qualification_approval_status: "approved" } + } + }, + { + // A rejected request is cleared, not left standing, and the verdict stays + // `rejected` so the hook keeps refusing the gated acts: the way on is a + // new request, which the start condition opens as a fresh approval. + id: "clear_request", + type: "update_record", + label: "Clear Rejected Request", + config: { + objectName: "crm_opportunity", + filter: { id: cel12`record.id` }, + fields: { qualification_approval_status: "rejected", qualification_requested: false } + } + }, + { id: "end", type: "end", label: "End" } + ], + edges: [ + { id: "e1", source: "start", target: "get_opportunity", type: "default" }, + { id: "e2", source: "get_opportunity", target: "qualification_review", type: "default" }, + // Approval-node branch labels. + { id: "e3", source: "qualification_review", target: "mark_qualified", type: "default", label: "approve" }, + { id: "e4", source: "qualification_review", target: "clear_request", type: "default", label: "reject" }, + { id: "e5", source: "mark_qualified", target: "end", type: "default" }, + { id: "e6", source: "clear_request", target: "end", type: "default" } + ] +}; + +// src/sales/flows/opportunity-stagnation.flow.ts +import { P as P32, cel as cel13 } from "@objectstack/spec"; +var STALE_THRESHOLD_DAYS = 14; +var OpportunityStagnationFlow = { + name: "opportunity_stagnation", + label: "Stalled Deal Alert", + description: "Daily sweep: nudge owners about open opportunities stuck in-stage beyond the threshold.", + type: "schedule", + status: "active", + // Scheduled runs have no trigger user, so under the default runAs:'user' the + // data nodes execute UNSCOPED anyway. Declare runAs:'system' to make that + // RLS-bypassing elevation explicit and intended (ADR-0049). + runAs: "system", + variables: [], + nodes: [ + { id: "start", type: "start", label: "Start (daily 07:30)", config: { schedule: "30 7 * * *" } }, + { + id: "query_stalled", + type: "get_record", + label: "Find Stalled Deals", + config: { + objectName: "crm_opportunity", + // ⛔ Predicate on the STORED `stage_entry_date`, never on + // `days_in_stage`: the latter is a formula, computed after the query, so + // as a filter key it addresses a column that does not exist. + // `entry < today − N` + // is the same test as `days_in_stage > N`, computed by a CEL value + // envelope (the `isoDate(daysAgo(n))` spelling; contract-renewal uses + // its `daysFromNow` twin). + // A row with a null `stage_entry_date` does not satisfy `$lt` and is + // skipped, preserving "nothing has stagnated yet" for unstamped rows. + filter: { + stage: { $nin: ["closed_won", "closed_lost"] }, + stage_entry_date: { $lt: cel13`isoDate(daysAgo(${STALE_THRESHOLD_DAYS}))` } + }, + limit: 500, + outputVariable: "oppList" + } + }, + { + id: "loop_opps", + type: "loop", + label: "For Each Stalled Deal", + config: { + collection: cel13`oppList`, + iteratorVariable: "currentOpp", + body: guarded("opp", { + nodes: [ + { + // Idempotency gate: a still-open stall task means this deal was + // already nudged. ⛔ Without it the daily sweep re-notifies and + // re-creates an identical task every morning for as long as the + // deal stays stalled — an unbounded duplicate pile-up. + id: "find_existing_task", + type: "get_record", + label: "Already Nudged?", + config: { + objectName: "crm_task", + filter: { + related_to_opportunity: cel13`currentOpp.id`, + subject: cel13`'Advance stalled deal: ' + currentOpp.name`, + status: { $nin: ["completed"] } + }, + outputVariable: "existingStallTask" + } + }, + { + // Gateway only — the predicate lives on the out-edge. + id: "check_not_nudged", + type: "decision", + label: "First Nudge?" + }, + { + // Owner only: `{currentOpp.owner_id.manager}` cannot traverse a + // lookup in flow templates — it interpolates to the literal + // "undefined" (cf. opportunity_won_alert). + id: "notify_owner", + type: "notify", + label: "Nudge Owner", + config: { + recipients: [cel13`has(currentOpp.owner_id) ? currentOpp.owner_id : null`], + channels: ["inbox", "email"], + topic: "deal_stalled", + template: "crm.deal_stalled", + templateData: { + name: cel13`currentOpp.name`, + stage: cel13`currentOpp.stage`, + days_in_stage: cel13`currentOpp.days_in_stage` + }, + actionUrl: "/crm_opportunity/{{currentOpp.id}}" + } + }, + { + id: "create_followup_task", + type: "create_record", + label: "Create Follow-up Task", + config: { + objectName: "crm_task", + fields: { + subject: cel13`'Advance stalled deal: ' + currentOpp.name`, + type: "follow_up", + priority: "high", + status: "not_started", + due_date: cel13`isoDate(daysFromNow(2))`, + owner_id: cel13`has(currentOpp.owner_id) ? currentOpp.owner_id : null`, + // ORG PARTITION. A schedule trigger carries no + // organization, so without this the nudge task is born + // `organization_id` NULL — outside every org partition. + // Upstream ruling objectstack#6155 Q2=A assigns the answer to + // the flow author; the task belongs to the org of the deal it + // nudges. `crm_opportunity` carries the column, so the read + // resolves. It is deliberately UNGUARDED: on 17.x a source + // lacking it interpolated to `undefined` and landed as NULL + // while looking declared; CEL fails the iteration instead, and + // a `has()` guard would write that NULL back. + organization_id: cel13`currentOpp.organization_id`, + related_to_type: "crm_opportunity", + related_to_opportunity: cel13`currentOpp.id` + } + } + } + ], + edges: [ + { id: "b1", source: "find_existing_task", target: "check_not_nudged", type: "default" }, + // "Already nudged" has no edge, so the loop moves to the next item. + // This edge is the ONLY site for the predicate: a `decision` + // node's singular `config.condition` is never read, so a node copy + // would be inert metadata free to drift away from what runs. + { id: "b2", source: "check_not_nudged", target: "notify_owner", type: "conditional", condition: P32`existingStallTask == null`, label: "First nudge" }, + { id: "b3", source: "notify_owner", target: "create_followup_task", type: "default" } + ] + }) + } + }, + { id: "end", type: "end", label: "End" } + ], + edges: [ + { id: "e1", source: "start", target: "query_stalled", type: "default" }, + { id: "e2", source: "query_stalled", target: "loop_opps", type: "default" }, + { id: "e3", source: "loop_opps", target: "end", type: "default" } + ] +}; + +// src/sales/flows/forecast-snapshot.flow.ts +import { P as P33, expression as expression2, cel as cel14 } from "@objectstack/spec"; +var SNAPSHOT_PERIOD = "quarter"; +var OPEN_STAGES = { $nin: ["closed_won", "closed_lost"] }; +var CURRENT_PERIOD_FILTER = { + owner_id: cel14`currentOwner.id`, + period: SNAPSHOT_PERIOD, + period_start: { $lte: cel14`isoDate(today())` }, + period_end: { $gte: cel14`isoDate(today())` } +}; +var OWNED_PERIOD_FILTER = { ...CURRENT_PERIOD_FILTER, source: "scheduled" }; +var inPeriod = (extra) => ({ + owner_id: cel14`currentOwner.id`, + organization_id: cel14`currentForecast.organization_id`, + close_date: { + $gte: cel14`currentForecast.period_start`, + $lte: cel14`currentForecast.period_end` + }, + ...extra +}); +var sumBucket = (key, label, filter, total, item = `current_${key}`) => ({ + find: { + id: `find_${key}`, + type: "get_record", + label: `Find ${label}`, + config: { + objectName: "crm_opportunity", + filter, + limit: 500, + outputVariable: `${key}Opps` + } + }, + sum: { + id: `sum_${key}`, + type: "loop", + label: `Sum ${label}`, + config: { + collection: expression2(`${key}Opps`, "cel"), + iteratorVariable: item, + body: { + nodes: [ + { + id: `add_${key}`, + type: "assignment", + label: `Add to ${label}`, + config: { + assignments: { + [total]: expression2(`${total} + (!has(${item}.amount) || isBlank(${item}.amount) ? 0.0 : double(${item}.amount))`, "cel") + } + } + } + ], + edges: [] + } + } + } +}); +var BUCKETS = [ + sumBucket("pipeline", "Open Pipeline", inPeriod({ stage: OPEN_STAGES }), "pipelineTotal"), + sumBucket( + "best_case", + "Best Case", + inPeriod({ stage: OPEN_STAGES, forecast_category: { $in: ["best_case", "commit"] } }), + "bestCaseTotal" + ), + sumBucket( + "commit", + "Commit", + inPeriod({ stage: OPEN_STAGES, forecast_category: "commit" }), + "commitTotal" + ), + sumBucket("won", "Closed Won", inPeriod({ stage: "closed_won" }), "closedTotal") +]; +var OWNER_CHAIN = [ + "reset_totals", + ...BUCKETS.flatMap((b) => [b.find.id, b.sum.id]), + "write_snapshot" +]; +var ForecastSnapshotFlow = { + name: "forecast_snapshot", + label: "Forecast Snapshot", + description: "Nightly sweep: upsert a current-quarter crm_forecast row per active opportunity owner with pipeline, best-case, commit and closed-won totals.", + type: "schedule", + status: "active", + // Scheduled runs have no trigger user, so under the default runAs:'user' the + // data nodes execute UNSCOPED anyway. Declare runAs:'system' to make that + // RLS-bypassing elevation explicit and intended (ADR-0049) — and it + // is load-bearing here: `crm_forecast` is `sharingModel: 'private'`, so a + // user-scoped sweep could only ever see its own rows. + runAs: "system", + variables: [], + nodes: [ + { id: "start", type: "start", label: "Start (daily 03:00)", config: { schedule: "0 3 * * *" } }, + { + // Every user is a candidate; the `has_deals` gate below decides who is + // actually an opportunity owner. Filtering `sys_user` here instead would + // hard-code an activity flag this app does not own. + // No `filter` key: an EMPTY filter node (`{}`) reduces to TRUE and + // matches every row, so it is indistinguishable from an absent key — + // ObjectStack 17.0.0-rc.6 promotes the pair to an author-time error + // (`filter-empty-node`) precisely because only the absent key SAYS + // "every user is a candidate" to the next reader. The `has_deals` gate + // below is what actually narrows the set. + id: "query_owners", + type: "get_record", + label: "Find Users", + config: { objectName: "sys_user", limit: 500, outputVariable: "ownerList" } + }, + { + id: "loop_owners", + type: "loop", + label: "For Each Owner", + config: { + collection: cel14`ownerList`, + iteratorVariable: "currentOwner", + body: guarded("owner", { + nodes: [ + { + // Cheap findOne gate: a user with no live opportunity is not a + // forecast owner, and must not get a row (a fresh install would + // otherwise gain one empty snapshot per employee). + id: "find_any_deal", + type: "get_record", + label: "Owns Any Live Deal?", + config: { + objectName: "crm_opportunity", + filter: { owner_id: cel14`currentOwner.id`, stage: { $nin: ["closed_lost"] } }, + outputVariable: "ownerAnyDeal" + } + }, + { + // Gateway only — the predicate lives on the out-edge. + id: "has_deals", + type: "decision", + label: "Active Owner?" + }, + { + // Idempotency gate AND period lookup in one read: the row whose + // window contains today IS this owner's current-period snapshot. + id: "find_forecast", + type: "get_record", + label: "Current-Period Snapshot?", + config: { + objectName: "crm_forecast", + filter: CURRENT_PERIOD_FILTER, + outputVariable: "existingForecast" + } + }, + { + // Gateway only — the predicate lives on the out-edges. + id: "check_missing", + type: "decision", + label: "First Snapshot This Period?" + }, + { + // Only `period` is supplied: `forecast.hook.ts` derives + // period_start/period_end/period_label so the boundaries are + // calendar-true without the flow doing date arithmetic it + // cannot do. `quota` is omitted on purpose — see the header. + // A leaf node: the two mutually-exclusive edges out of + // `check_missing` both converge on `reload_forecast`, so the + // chain below runs exactly once on either path. + id: "create_forecast", + type: "create_record", + label: "Open Snapshot Row", + config: { + objectName: "crm_forecast", + fields: { + owner_id: cel14`currentOwner.id`, + // ORG PARTITION. A schedule trigger carries no + // organization, so without this the snapshot row is born + // `organization_id` NULL — outside every org partition, where + // an `(organization_id, …)` unique index does not constrain + // and org-scoped reads never see it. Upstream ruling + // objectstack#6155 Q2=A assigns the answer to the flow author. + // + // The source is `ownerAnyDeal`, NOT `currentOwner`. The loop + // item here is a `sys_user` row, and `sys_user` declares NO + // `organization_id` — identity is global, org-partitioned it + // is not (it carries `primary_business_unit_id` instead). + // On 17.x `{currentOwner.organization_id}` interpolated to + // `undefined` and landed as NULL: the publish guard, which only + // checks that the key is declared, went green over a row still + // born outside every partition (measured, not assumed). Under + // CEL that read fails the iteration instead. + // + // `ownerAnyDeal` is the `crm_opportunity` from `find_any_deal` + // — it carries the column, and edge `b2` (`ownerAnyDeal != + // null`) is the only route to this node, so it is never null + // here. Semantically right too: an owner's forecast belongs to + // the org their pipeline is in. + organization_id: cel14`ownerAnyDeal.organization_id`, + period: SNAPSHOT_PERIOD, + snapshot_date: cel14`isoDate(today())`, + source: "scheduled", + pipeline_amount: 0, + best_case_amount: 0, + commit_amount: 0, + closed_amount: 0 + } + } + }, + { + // Re-read rather than reuse the create output, so both paths + // (row already existed / row just created) hand the rest of the + // body ONE variable carrying the hook-derived period window. + // + // ⛔ Scope this to OWNED_PERIOD_FILTER, never to the gate's + // window: this read chooses the row that gets WRITTEN, and the + // sweep only ever owns its own. A miss binds `currentForecast` to + // null — `get_record` always binds — which is exactly what + // `check_owned` below is there to read. + id: "reload_forecast", + type: "get_record", + label: "Load Snapshot Row", + config: { + objectName: "crm_forecast", + filter: OWNED_PERIOD_FILTER, + outputVariable: "currentForecast" + } + }, + { + // Gateway only — the predicate lives on the out-edge. + // + // The stand-down gate. The window is handled either way by the + // time we get here; this asks whether the row handling it is the + // sweep's. Same single-out-edge skip shape as `has_deals`: when + // the only conditional edge does not match, the iteration ends and + // the engine records the unreached nodes as `skipped` with this + // node as `skippedBy` — so a stand-down is visible in the run log + // rather than silent. + id: "check_owned", + type: "decision", + label: "Sweep Owns This Row?" + }, + { + // Accumulators live in the flow-wide variable map (a loop body + // shares the enclosing scope), so they MUST be zeroed per owner + // or every rep inherits the previous rep's totals. + id: "reset_totals", + type: "assignment", + label: "Reset Totals", + config: { + assignments: { + pipelineTotal: 0, + bestCaseTotal: 0, + commitTotal: 0, + closedTotal: 0 + } + } + }, + ...BUCKETS.flatMap((b) => [b.find, b.sum]), + { + // Filter by id: `update_record` calls `data.update` without + // `options.multi`, so a filter matching more than one row fails + // (same constraint as demo_bootstrap / case_sla_monitor). + id: "write_snapshot", + type: "update_record", + label: "Write Snapshot", + config: { + objectName: "crm_forecast", + filter: { id: cel14`currentForecast.id` }, + fields: { + pipeline_amount: cel14`pipelineTotal`, + best_case_amount: cel14`bestCaseTotal`, + commit_amount: cel14`commitTotal`, + closed_amount: cel14`closedTotal`, + snapshot_date: cel14`isoDate(today())`, + source: "scheduled" + } + } + } + ], + edges: [ + // Loop-nested conditions are explicit CEL envelopes (`P`): the + // conversion pass that wraps bare strings only walks a flow's + // TOP-LEVEL edges, so a bare string in here would fall through to + // the legacy template path and compare as text — a gate that never + // opens, silently. + // + // These edges are the ONLY site for their predicates: a + // `decision` node's singular `config.condition` is never read, so a + // node-level copy would be inert metadata free to drift. + { id: "b1", source: "find_any_deal", target: "has_deals", type: "default" }, + // No matching edge simply ends this iteration, so a user with no + // live deal is skipped without a snapshot row. + { id: "b2", source: "has_deals", target: "find_forecast", type: "conditional", condition: P33`ownerAnyDeal != null`, label: "Active owner" }, + { id: "b3", source: "find_forecast", target: "check_missing", type: "default" }, + // Mutually exclusive, and both reach `reload_forecast` — never a + // default edge alongside a conditional one, which would traverse + // BOTH and double-count the whole chain. + { id: "b4", source: "check_missing", target: "create_forecast", type: "conditional", condition: P33`existingForecast == null`, label: "Open new row" }, + { id: "b5", source: "check_missing", target: "reload_forecast", type: "conditional", condition: P33`existingForecast != null`, label: "Refresh existing row" }, + { id: "b6", source: "create_forecast", target: "reload_forecast", type: "default" }, + { id: "b7", source: "reload_forecast", target: "check_owned", type: "default" }, + // The stand-down. No complementary edge, on purpose: the + // false branch is "this window belongs to a manual/ai row", and the + // whole point is that the sweep then does NOTHING — no write, and + // no second row. A variable-root null test, so no `has()` guard is + // needed: `reload_forecast` is a `get_record` and binds + // `currentForecast` unconditionally, to `null` on a miss. + { id: "b8", source: "check_owned", target: "reset_totals", type: "conditional", condition: P33`currentForecast != null`, label: "Sweep owns the row" }, + ...OWNER_CHAIN.slice(0, -1).map((source, i) => ({ + id: `c${i}`, + source, + target: OWNER_CHAIN[i + 1], + type: "default" + })) + ] + }) + } + }, + { id: "end", type: "end", label: "End" } + ], + edges: [ + { id: "e1", source: "start", target: "query_owners", type: "default" }, + { id: "e2", source: "query_owners", target: "loop_owners", type: "default" }, + { id: "e3", source: "loop_owners", target: "end", type: "default" } + ] +}; + +// src/sales/flows/lead-assignment.flow.ts +import { P as P34, cel as cel15 } from "@objectstack/spec"; +var LeadAssignmentFlow = { + name: "lead_assignment", + label: "New Lead Routing & SLA", + description: "On new lead: set a rating-based follow-up SLA and alert the lead owner.", + type: "record_change", + status: "active", + // A record-change flow fired by a SYSTEM write carries no trigger user + // either (ADR-0049). This is the population the flow is FOR: + // leads arrive from web-to-lead, a CSV import, a partner integration or a + // seed load, none of which carry a user session. Measured on 17.0.0-rc.2, a + // user-less run refuses `sla_hot` / `sla_std` outright, so the lead lands + // with no follow-up SLA and no alert at all — silently, since the refusal + // surfaces only in the server log. + // + // Elevating the USER-driven runs too is correct: the SLA stamp is the + // platform's routing decision about the row that just fired the trigger + // (keyed to `{record.id}`), not the submitting rep's own edit, and a rep who + // may create a lead is not thereby guaranteed edit rights on it. + runAs: "system", + variables: [], + nodes: [ + { + id: "start", + type: "start", + label: "Start (lead created)", + config: { objectName: "crm_lead", triggerType: "record-after-create" } + }, + { + // Branching lives on edges `e2` / `e3` — see the totality note there. + // This node carries no `config.condition`: the engine never evaluates a + // `decision` node's singular one, so a copy here would restate the gate + // without being the gate (17.0.0-rc.2's `flow-inert-node-condition`). + id: "check_hot", + type: "decision", + label: "Hot Lead (rating \u2265 4)?" + }, + // ── Hot path: 1-day SLA, high-severity alert ─────────────────── + { + id: "sla_hot", + type: "update_record", + label: "Set 1-Day SLA", + config: { objectName: "crm_lead", filter: { id: cel15`record.id` }, fields: { next_followup_date: cel15`isoDate(daysFromNow(1))` } } + }, + { + id: "notify_hot", + type: "notify", + label: "Alert \u2014 Hot Lead", + config: { + // Route to the lead's OWNER (a real user id). A CRM position like + // 'sales_manager' is NOT a messaging audience — the messaging service + // resolves user:/role:(sys_member)/team:/owner_of:, and a bare + // 'sales_manager' was stored verbatim as sys_inbox_message.user_id, + // matching no real user, so these alerts reached nobody. owner is set + // on insert (defaultValue os.user.id) and is the accountable party. + recipients: [cel15`record.owner_id`], + channels: ["inbox", "email"], + severity: "warning", + topic: "lead_routing", + template: "crm.lead_routing_hot", + templateData: { + first_name: cel15`record.first_name`, + last_name: cel15`record.last_name`, + company: cel15`record.company`, + rating: cel15`record.rating` + }, + actionUrl: "/crm_lead/{{record.id}}" + } + }, + // ── Standard path: 3-day SLA, normal alert ───────────────────── + { + id: "sla_std", + type: "update_record", + label: "Set 3-Day SLA", + config: { objectName: "crm_lead", filter: { id: cel15`record.id` }, fields: { next_followup_date: cel15`isoDate(daysFromNow(3))` } } + }, + { + id: "notify_std", + type: "notify", + label: "Alert \u2014 New Lead", + config: { + // Route to the lead's owner — see notify_hot for why a bare + // 'sales_manager' position never reached anyone. + recipients: [cel15`record.owner_id`], + channels: ["inbox"], + topic: "lead_routing", + template: "crm.lead_routing_new", + templateData: { + first_name: cel15`record.first_name`, + last_name: cel15`record.last_name`, + company: cel15`record.company` + }, + actionUrl: "/crm_lead/{{record.id}}" + } + }, + { id: "end", type: "end", label: "End" } + ], + edges: [ + { id: "e1", source: "start", target: "check_hot", type: "default" }, + // TOTALITY: these two edges must PARTITION every lead — a rating + // the predicate cannot read has to fall down one branch, never neither. + // Guarding both with `has(...) &&` would have traded a loud abort for a + // silent no-op (unrated lead → no SLA, no alert, no error), which is the + // "declared ≠ enforced" shape this repo keeps deleting rules over. So the + // hot branch demands a readable rating and the standard branch absorbs + // everything else: an unrated lead is, correctly, not a hot lead. + // + // `rating` is neither required nor defaulted, so a lead written without one + // is stored with NO `rating` column on driver-memory / driver-mongodb. + // Measured end-to-end: the unguarded `record.rating >= 4` aborted with `No + // such key: rating` and an unrated lead got no SLA stamp and no alert at + // all. `has()` alone is not enough on an ORDERING comparison — an explicit + // `rating: null` passes `has()` and then aborts with `no such overload: + // dyn >= int` — so both guards are required, in this order. + { id: "e2", source: "check_hot", target: "sla_hot", type: "conditional", condition: P34`has(record.rating) && record.rating != null && record.rating >= 4`, label: "Hot" }, + { id: "e3", source: "check_hot", target: "sla_std", type: "conditional", condition: P34`!has(record.rating) || record.rating == null || record.rating < 4`, label: "Standard" }, + { id: "e4", source: "sla_hot", target: "notify_hot", type: "default" }, + { id: "e5", source: "notify_hot", target: "end", type: "default" }, + { id: "e6", source: "sla_std", target: "notify_std", type: "default" }, + { id: "e7", source: "notify_std", target: "end", type: "default" } + ] +}; + +// src/sales/flows/contact-welcome.flow.ts +import { P as P35, cel as cel16 } from "@objectstack/spec"; +var ContactWelcomeFlow = { + name: "contact_welcome", + label: "Contact Welcome", + description: "On new contact: prompt the owner to welcome them.", + type: "record_change", + status: "active", + // A record-change flow fired by a SYSTEM write carries no trigger user + // either (ADR-0049) — and this flow exists FOR that + // population: the start condition below already documents the seeded / + // integration-written contacts whose `owner_id` the security middleware + // never stamped because the write carried no session. + // + // Measured honestly on 17.0.0-rc.2: this flow has NO data node today (start + // → notify → end), the runAs refusal covers get/create/update/delete only, + // and `notify` dispatches through the messaging service without a run data + // context — so a user-less run completes and delivers today, and this + // declaration changes nothing observable right now. It is declared anyway + // because the decision being recorded is "record-change automation runs as + // the platform", not "this flow currently happens to have no data node". + // The day a data node is added — or a start-node `config.expand`, which is + // the remedy the notify node's own error message recommends and which reads + // through the same guarded path — the elevation has already been reasoned + // about here rather than discovered as a refusal in production. Elevation is + // harmless for the user-driven runs: there is no data operation to scope. + runAs: "system", + variables: [], + nodes: [ + { + id: "start", + type: "start", + label: "Start (contact created)", + config: { + objectName: "crm_contact", + triggerType: "record-after-create", + // TOTALITY: every `record.x` read carries a `has(record.x)` + // guard — see the house-rule block in + // `test/flow-condition-totality.test.ts`. The absent-key case is real + // here, not hypothetical: `owner_id` is auto-stamped by the security + // middleware only on writes that CARRY a user, and a system write — + // seed data, an integration, a `runAs: 'system'` flow — short-circuits + // that middleware entirely. Such a row reaches driver-memory + // with NO `owner_id` column at all, so `record.owner_id != null` alone + // aborts with `No such key` and no seeded contact ever gets a welcome + // prompt. `!= null` is not a substitute for `has()`: on an absent key + // it aborts exactly like `== "v"` does. An absent `email_opt_out` + // means the contact has not opted out. + condition: P35`has(record.owner_id) && record.owner_id != null + && (!has(record.email_opt_out) || record.email_opt_out != true)` + } + }, + { + id: "send_welcome", + type: "notify", + label: "Prompt Owner to Welcome", + config: { + recipients: [cel16`record.owner_id`], + channels: ["inbox", "email"], + topic: "contact_welcome", + template: "crm.contact_welcome", + templateData: { first_name: cel16`record.first_name`, last_name: cel16`record.last_name` }, + actionUrl: "/crm_contact/{{record.id}}" + } + }, + { id: "end", type: "end", label: "End" } + ], + edges: [ + { id: "e1", source: "start", target: "send_welcome", type: "default" }, + { id: "e2", source: "send_welcome", target: "end", type: "default" } + ] +}; + +// src/sales/flows/opportunity-won-alert.flow.ts +import { P as P36, cel as cel17 } from "@objectstack/spec"; +var OpportunityWonAlertFlow = { + name: "opportunity_won_alert", + label: "Large Deal Won Alert", + description: "On closed_won opportunities of $100K or more: notify the owner \u2014 the owner alone, not their manager.", + type: "record_change", + status: "active", + // A record-change flow fired by a SYSTEM write carries no trigger user + // either (ADR-0049). Deals reach `closed_won` through + // machinery as well as through a rep's own save — `lead_conversion` and the + // `contract_renewal` sweep both write opportunities, and the latter is + // itself `runAs: 'system'`. + // + // Measured honestly on 17.0.0-rc.2: this flow has NO data node (start → + // notify → end), so the refusal does not reach it today and declaring + // `system` changes nothing observable. Declared for the same reason as + // `contact_welcome` — see the fuller note there. Nothing to scope, so + // elevating the user-driven runs costs nothing. + runAs: "system", + variables: [], + nodes: [ + { + id: "start", + type: "start", + label: "Start (opp updated)", + config: { + objectName: "crm_opportunity", + triggerType: "record-after-update", + // `previous.stage` guard: fire on the TRANSITION into closed_won only. + // Without it every later edit of a won deal (seed-ownership + // claims, approval-status stamps, description tweaks) re-sent the + // congratulations blast. The trigger forwards `previous` into the + // condition scope (cf. the engine's record-change context). + // TOTALITY: `has(...)` on every read, plus `!= null` on the + // ordering comparison (`has()` passes an explicit null and + // `record.amount >= 100000` then aborts with + // `no such overload: dyn >= int`). + // + // `previous.stage` is guarded FAIL-CLOSED — `has(previous.stage) &&`, + // not `!has(previous.stage) ||` — which is the opposite of how + // `record.stage` is guarded, deliberately. This term exists solely to + // suppress a re-fire, and the failure it was written for (a + // congratulations blast to management re-sent on every later edit of a + // won deal) is worse than a missed one. When the engine cannot see + // what the prior stage was it cannot see a TRANSITION either, so it + // must not claim one. In practice `previous` is a full prior row on + // every record-after-update; the shape this covers is a bulk + // `updateMany`, where ObjectQL never reads a prior row and `previous` + // arrives null — and firing one blast per row of a bulk update is + // exactly what nobody wants. + condition: P36`has(record.stage) && record.stage == "closed_won" + && has(previous.stage) && previous.stage != "closed_won" + && has(record.amount) && record.amount != null && record.amount >= ${LARGE_DEAL_AMOUNT}` + } + }, + { + // The `label` names what this node actually does: it notifies the owner + // and nobody else. The `id` keeps its original `notify_management` + // spelling on purpose — `edges[]` reference nodes by id, so renaming one + // is a behaviour change, not a wording fix. + id: "notify_management", + type: "notify", + label: "Notify Owner", + config: { + // Owner only: `{record.owner_id.manager}` cannot traverse a lookup on the + // raw trigger snapshot — it interpolates to the literal "undefined" + // and the message is delivered to a phantom user. + recipients: [cel17`record.owner_id`], + channels: ["inbox", "email"], + severity: "info", + topic: "large_deal_won", + template: "crm.large_deal_won", + templateData: { name: cel17`record.name`, amount: cel17`record.amount` }, + actionUrl: "/crm_opportunity/{{record.id}}" + } + }, + { id: "end", type: "end", label: "End" } + ], + edges: [ + { id: "e1", source: "start", target: "notify_management", type: "default" }, + { id: "e2", source: "notify_management", target: "end", type: "default" } + ] +}; + +// src/sales/flows/task-urgent-alert.flow.ts +import { P as P37, cel as cel18 } from "@objectstack/spec"; +var TaskUrgentAlertFlow = { + name: "task_urgent_alert", + label: "Urgent Task Alert", + description: "On new urgent task: notify the owner.", + type: "record_change", + status: "active", + // A record-change flow fired by a SYSTEM write carries no trigger user + // either (ADR-0049), and most urgent tasks in this app are + // machine-written: `case_status_side_effects` opens the escalation follow-up + // task, and the scheduled sweeps create their own — none of those writes + // carries a session. + // + // Measured honestly on 17.0.0-rc.2: this flow has NO data node (start → + // notify → end), so the refusal does not reach it today and declaring + // `system` changes nothing observable. Declared for the same reason as + // `contact_welcome` — see the fuller note there: the recorded decision is + // that record-change automation runs as the platform, so a data node added + // later inherits an elevation that was reasoned about rather than one + // discovered as a production refusal. No data operation exists to scope, so + // elevating the user-driven runs costs nothing. + runAs: "system", + variables: [], + nodes: [ + { + id: "start", + type: "start", + label: "Start (task created)", + config: { + objectName: "crm_task", + triggerType: "record-after-create", + // Gate on the `status` enum, not the `is_completed` boolean: on + // SQLite/libsql booleans persist as integer 1, so `is_completed != true` + // is `1 != true` = always true and the guard never trips (cf. the same + // hazard documented in case_escalation). + // TOTALITY: `has(...)` on every read. Both fields are `required` + // AND defaulted today, so this predicate measured total as authored — + // but that is a property of `crm_task`'s schema, not of the predicate. + // Drop either default and the flow goes silently inert on + // driver-memory / driver-mongodb, with nothing to catch it. An absent + // `status` is not `completed`, so it must not suppress the alert. + condition: P37`has(record.priority) && record.priority == "urgent" + && (!has(record.status) || record.status != "completed")` + } + }, + { + id: "notify_owner", + type: "notify", + label: "Notify Owner", + config: { + recipients: [cel18`record.owner_id`], + channels: ["inbox", "email"], + severity: "warning", + topic: "urgent_task", + template: "crm.urgent_task", + templateData: { subject: cel18`record.subject` }, + actionUrl: "/crm_task/{{record.id}}" + } + }, + { id: "end", type: "end", label: "End" } + ], + edges: [ + { id: "e1", source: "start", target: "notify_owner", type: "default" }, + { id: "e2", source: "notify_owner", target: "end", type: "default" } + ] +}; + +// src/sales/flows/task-due-reminder.flow.ts +import { cel as cel19 } from "@objectstack/spec"; +var TaskDueReminderFlow = { + name: "task_due_reminder", + label: "Task Due Reminder", + description: "Hourly sweep: notify owners of tasks whose reminder time has arrived.", + type: "schedule", + status: "active", + // Scheduled runs have no trigger user, so under the default runAs:'user' the + // data nodes execute UNSCOPED anyway. Declare runAs:'system' to make that + // RLS-bypassing elevation explicit and intended (ADR-0049). + runAs: "system", + variables: [], + nodes: [ + { + id: "start", + type: "start", + label: "Start (hourly)", + config: { schedule: "0 * * * *" } + }, + { + id: "query_due", + type: "get_record", + label: "Find Tasks Due for Reminder", + config: { + objectName: "crm_task", + // De-dup via `reminder_date` itself: the sweep notifies tasks whose + // reminder time has arrived, then CLEARS reminder_date (see mark_sent), + // so the row no longer matches `$lte` next tick. We do NOT filter on the + // `reminder_sent` boolean here — empirically, a where-clause on that + // (newly added) boolean column returns zero rows at runtime in this + // engine build, while the long-standing `is_completed` boolean works. + // Reusing the verified `$lte` + `is_completed` predicates keeps the + // sweep reliable; `reminder_sent` is still stamped for the audit trail. + filter: { + is_completed: false, + reminder_date: { $lte: cel19`isoDatetime(now())` } + }, + limit: 500, + outputVariable: "reminderList" + } + }, + { + // The loop body MUST be nested in `config.body` — a flat-graph loop + // (body omitted, iterator wired via outer edges) does NOT iterate or bind + // the iterator variable in the runtime (legacy no-op path), so + // `{currentTask.*}` resolves empty. Verified empirically. + id: "loop_tasks", + type: "loop", + label: "For Each Due Task", + config: { + collection: cel19`reminderList`, + iteratorVariable: "currentTask", + body: guarded("task", { + nodes: [ + { + id: "notify_owner", + type: "notify", + label: "Notify Owner", + config: { + recipients: [cel19`has(currentTask.owner_id) ? currentTask.owner_id : null`], + channels: ["inbox", "email"], + severity: "warning", + topic: "task_reminder", + template: "crm.task_reminder", + templateData: { + subject: cel19`currentTask.subject`, + reminder_date: cel19`currentTask.reminder_date` + }, + actionUrl: "/crm_task/{{currentTask.id}}" + } + }, + { + id: "mark_sent", + type: "update_record", + label: "Mark Reminder Sent", + config: { + objectName: "crm_task", + filter: { id: cel19`currentTask.id` }, + // Clearing reminder_date is what de-dups (the row stops matching + // the sweep's `$lte` next tick); reminder_sent is the audit flag. + fields: { reminder_sent: true, reminder_date: null } + } + } + ], + edges: [ + { id: "b1", source: "notify_owner", target: "mark_sent", type: "default" } + ] + }) + } + }, + { id: "end", type: "end", label: "End" } + ], + edges: [ + { id: "e1", source: "start", target: "query_due", type: "default" }, + { id: "e2", source: "query_due", target: "loop_tasks", type: "default" }, + { id: "e3", source: "loop_tasks", target: "end", type: "default" } + ] +}; + +// src/sales/flows/billing-handoff-closed-won.flow.ts +import { P as P38, cel as cel21 } from "@objectstack/spec"; + +// src/sales/flows/_billing-endpoint.ts +import { cel as cel20, expression as expression3 } from "@objectstack/spec"; +var BILLING_HANDOFF_ENDPOINT = process.env.HOTCRM_BILLING_ENDPOINT?.trim() || "https://billing.example.com/hotcrm/events"; +var BILLING_HANDOFF_SIGNING_SECRET = process.env.HOTCRM_BILLING_SIGNING_SECRET?.trim() || void 0; +var BILLING_HANDOFF_TIMEOUT_MS = 3e4; +var BILLING_HANDOFF_EVENT = { + opportunityClosedWon: "crm.opportunity.closed_won", + contractActivated: "crm.contract.activated" +}; +var BILLING_HANDOFF_PAYLOAD_VERSION = 1; +var BILLING_HANDOFF_LINE_ITEM_LIMIT = 200; +var ACCOUNT_FIELDS = [ + "id", + "name", + "account_number", + "billing_address", + "billing_country", + "phone", + "website" +]; +var LINE_ITEM_FIELDS = [ + "id", + "line_number", + "crm_product", + "description", + "quantity", + "list_price", + "unit_price", + "discount", + "total_price" +]; +var accountField = (field) => `has(billingAccount.${field}) ? billingAccount.${field} : null`; +var ACCOUNT_BLOCK = `{'id': billingAccount.id, 'name': billingAccount.name, 'account_number': billingAccount.account_number, 'billing_address': ${accountField("billing_address")}, 'billing_country': ${accountField("billing_country")}, 'phone': ${accountField("phone")}, 'website': ${accountField("website")}}`; +var billingBody = (event, key, fields) => expression3( + `{'event': dyn('${event}'), 'version': dyn(${BILLING_HANDOFF_PAYLOAD_VERSION}), 'occurred_at': dyn(isoDatetime(now())), '${key}': dyn({${fields.map((f) => typeof f === "string" ? [f, f] : f).map(([k, f]) => `'${k}': record.${f}`).join(", ")}}), 'account': dyn(${ACCOUNT_BLOCK}), 'line_items': billingLineItems}` +); +var loadAccountNode = () => ({ + id: "load_account", + type: "get_record", + label: "Load Account", + config: { + objectName: "crm_account", + filter: { id: cel20`record.crm_account` }, + fields: ACCOUNT_FIELDS, + // No `limit`: `get_record` calls `findOne` below 2 and binds the single row + // itself, which is what the account block's `billingAccount.FIELD` reads need. + outputVariable: "billingAccount" + } +}); + +// src/sales/flows/billing-handoff-closed-won.flow.ts +var BillingHandoffClosedWonFlow = { + name: "billing_handoff_closed_won", + label: "Billing Hand-off: Closed Won", + description: "On the transition into closed_won: POST the deal, its account and its line items to the billing endpoint via the durable HTTP outbox.", + type: "record_change", + status: "active", + // A record-change flow fired by a SYSTEM write carries no trigger user + // (ADR-0049), and opportunities reach `closed_won` through + // machinery as well as a rep's own save — `lead_conversion` writes them, and + // the `contract_renewal` sweep is itself `runAs: 'system'`. This flow has two + // data nodes, so under the default `runAs: 'user'` those reads would be + // REFUSED on exactly those runs and the hand-off would vanish silently. The + // hand-off must also see the WHOLE deal, not the slice the closing rep may + // read: an RLS-scoped line-item query that returns three of five rows would + // under-bill the customer without failing anything. + runAs: "system", + variables: [ + // Bound with a default so the payload key always exists. Not strictly + // needed here (this flow always runs the read) — declared for symmetry with + // the contract flow, where the read is conditional, so the two payloads + // cannot drift into different shapes for an empty item list. + { name: "billingLineItems", type: "collection", isInput: false, isOutput: false, defaultValue: [] } + ], + nodes: [ + { + id: "start", + type: "start", + label: "Start (opportunity updated)", + config: { + objectName: "crm_opportunity", + triggerType: "record-after-update", + // TRANSITION, not current value — see the file header. `previous.stage` + // is guarded fail-closed: no visible prior stage means no visible + // transition, so no hand-off. + condition: P38`has(record.stage) && record.stage == "closed_won" + && has(previous.stage) && previous.stage != "closed_won"` + } + }, + loadAccountNode(), + { + id: "load_line_items", + type: "get_record", + label: "Load Line Items", + config: { + objectName: "crm_opportunity_line_item", + filter: { crm_opportunity: cel21`record.id` }, + fields: LINE_ITEM_FIELDS, + // > 1 is what makes `get_record` issue a `find` and bind an ARRAY; + // omit it and the node calls `findOne` and binds a single row. + limit: BILLING_HANDOFF_LINE_ITEM_LIMIT, + outputVariable: "billingLineItems" + } + }, + { + // The node id becomes the delivery's `X-Objectstack-Event` header + // (`flow:`), so it is named for the event and not for the verb. + id: "send_closed_won_handoff", + type: "http", + label: "Enqueue Billing Hand-off", + config: { + url: BILLING_HANDOFF_ENDPOINT, + method: "POST", + // The whole point of this route: enqueue on `sys_http_delivery` rather + // than call inline, so a receiver that is down gets the delivery when + // it comes back instead of losing it. + durable: true, + timeoutMs: BILLING_HANDOFF_TIMEOUT_MS, + signingSecret: BILLING_HANDOFF_SIGNING_SECRET, + // One envelope building the whole payload (see `billingBody`). Each + // read is the value itself, never its stringification, so the amount + // stays a number and the line items an array. + body: billingBody(BILLING_HANDOFF_EVENT.opportunityClosedWon, "opportunity", [ + "id", + "name", + "amount", + "close_date", + "stage", + "type", + ["account_id", "crm_account"], + "owner_id" + ]) + } + }, + { id: "end", type: "end", label: "End" } + ], + edges: [ + { id: "e1", source: "start", target: "load_account", type: "default" }, + { id: "e2", source: "load_account", target: "load_line_items", type: "default" }, + { id: "e3", source: "load_line_items", target: "send_closed_won_handoff", type: "default" }, + { id: "e4", source: "send_closed_won_handoff", target: "end", type: "default" } + ] +}; + +// src/revenue/flows/quote-generation.flow.ts +import { P as P39, expression as expression4, cel as cel22 } from "@objectstack/spec"; +var DISCOUNT = "(!has(vars.discount) || isBlank(vars.discount) ? 0.0 : double(vars.discount))"; +var ADVANCE = `has(vars.oppRecord) && has(vars.oppRecord.stage) + && (vars.oppRecord.stage == "prospecting" || vars.oppRecord.stage == "qualification" || vars.oppRecord.stage == "needs_analysis") + && (!has(vars.oppRecord.approval_status) || vars.oppRecord.approval_status != "pending")`; +var QuoteGenerationFlow = { + name: "quote_generation", + label: "Generate Quote from Opportunity", + description: "Create a quote based on opportunity details", + type: "screen", + status: "active", + variables: [ + // MUST be `recordId` — the console's flow-action trigger contract seeds + // only that name ({ recordId, objectName }); a custom name like + // `opportunityId` arrives undefined. + { name: "recordId", type: "text", isInput: true, isOutput: false }, + { name: "quoteName", type: "text", isInput: true, isOutput: false }, + { name: "expirationDays", type: "number", isInput: true, isOutput: false }, + { name: "discount", type: "number", isInput: true, isOutput: false } + ], + nodes: [ + { id: "start", type: "start", label: "Start", config: { objectName: "crm_opportunity" } }, + // ─── The 立项 (qualification) gate, REQ-0006 step 11 (#2032) ───────── + // + // 「新增商机可跟进，立项通过后方可更新阶段、投标、赢丢单操作。」 Ruled (hotcrm-R74b + // item 2, B): before 立项 is approved, Generate Quote REFUSES and creates + // nothing. Steps 15 and 18 put quoting after the deal's approval too. + // + // Why the refusal is HERE, ahead of the form and of every writer: this + // flow writes the quote BEFORE the stage, and a flow carries no + // transaction (ADR-0077). With the gate armed, `opportunity_lifecycle` + // refuses the `update_opportunity` stage write — so the run used to fail + // AFTER `create_quote` had landed: measured on 17.7.0 as a sales_rep, + // `FLOW_FAILED` 400 at `update_opportunity` ("This deal needs + // qualification approval first …"), one draft quote left behind, the + // stage unchanged. ⛔ Not #2015's keep-stage-and-quote: that lock does + // not hold quoting, this gate does. + // + // The flow is the one choke point every door reaches — the record-header + // and list-row buttons and `POST /automation/quote_generation/trigger` — + // so the refusal lives here and `generate_quote` stays visible: hiding + // it would leave the rep a missing button with no reason, because an + // action's `visible` / `disabled` are bare predicates with nowhere to + // put a sentence. + // + // The FILTER is the gate's reading, the one `opportunity_lifecycle` + // applies: `pending` or `rejected` holds the deal (an approver's "no" is + // not a release), every other value — the shipped `not_required`, + // `approved`, none at all — does not. So `held` binds the deal only while + // it is held, and `null` otherwise; `test/flow-quote.test.ts` pins that + // the two answer alike, verdict by verdict. + // + // A read of its own, at click time. ⛔ Do not fold it into + // `get_opportunity`: that read stays AFTER the screen so the pricing and + // the #2015 approval branch (`e4a` / `e4b`) see the deal as it is at + // submit. The verdict cannot drift toward held while the form is open: + // `not_required` and `approved` are never written back to `pending`. + { id: "get_held", type: "get_record", label: "Get Held Deal", config: { objectName: "crm_opportunity", filter: { id: cel22`recordId`, qualification_approval_status: { $in: ["pending", "rejected"] } }, outputVariable: "held" } }, + // A first-class refusal (`EndConfigSchema` `outcome: 'refused'`): the run + // ends `refused`, never `failed` and never parked, nothing is written, + // and the console shows the message with Close only — no Submit and no + // "completed" toast, which is what a message-only screen would give. It + // names the next step the `opportunity_lifecycle` refusal of this gate + // names. + // + // Translated: since 18.0.0-next.0 the `flows` translation group keys an + // `end` node's refusal as `refusals.refuse_held.message`, which the + // engine renders in the run's locale (at 17.7.0 it had no such key, the + // gap raised from #2032). The console titles the dialog with the action's + // translated label. ⛔ Do not re-route the refusal through a screen to + // borrow a translatable title. + { id: "refuse_held", type: "end", label: "Quote Refused", config: { outcome: "refused", message: "Qualification approval comes first: tick Request Qualification Approval. Nothing was created." } }, + { + id: "screen_1", + type: "screen", + label: "Quote Details", + config: { + fields: [ + { name: "quoteName", label: "Quote Name", type: "text", required: true }, + { name: "expirationDays", label: "Valid For (Days)", type: "number", required: true, defaultValue: 30 }, + // The ceiling is a HARD block with no override + // (`crm_quote.discount_within_ceiling`), so until it is written here + // a rep meets the number only by having the quote refused. Both + // strings below interpolate `QUOTE_DISCOUNT_CEILING` — imported, + // never retyped, the same rule the two object rules follow — so the + // hint cannot drift from the rule it describes. + // + // ⛔ There is deliberately NO `max`, and adding one does not work: + // `ScreenFieldConfigSchema` is STRICT at 17.3.0 and its entire key + // set is `name` / `label` / `type` / `required` / `options` / + // `defaultValue` / `placeholder` / `visibleWhen`. `max` is rejected + // BY NAME (`Unrecognized key(s) on this screen field: max`), so + // it fails `pnpm validate` rather than quietly doing nothing, and + // the executor forwards no such key into the `ScreenSpec` the client + // renders. `helpText` is rejected the same way — the console's + // dialog would render one, but no flow screen can carry it there. + // + // That leaves two carriers, and the label is the load-bearing one: + // `placeholder` renders only while the input is empty and + // `defaultValue: 0` seeds it, so it surfaces for the moment the rep + // clears the box to type — real, but not enough on its own. + { + name: "discount", + label: `Discount % (\u2264 ${QUOTE_DISCOUNT_CEILING})`, + type: "percent", + defaultValue: 0, + placeholder: `0-${QUOTE_DISCOUNT_CEILING}` + } + ] + } + }, + { + id: "get_opportunity", + type: "get_record", + label: "Get Opportunity", + config: { objectName: "crm_opportunity", filter: { id: cel22`recordId` }, outputVariable: "oppRecord" } + }, + { + id: "create_quote", + type: "create_record", + label: "Create Quote", + config: { + objectName: "crm_quote", + fields: { + name: cel22`quoteName`, + crm_opportunity: cel22`recordId`, + crm_account: cel22`oppRecord.crm_account`, + crm_contact: cel22`has(oppRecord.primary_contact) ? oppRecord.primary_contact : null`, + owner_id: cel22`current_user.id`, + status: "draft", + quote_date: cel22`isoDate(today())`, + expiration_date: cel22`isoDate(addDays(today(), expirationDays))`, + // `subtotal` is a bare path pass-through and needs no rounding: it + // copies `crm_opportunity.amount` as stored and does no arithmetic, + // so it adds no floating-point tail of its own. + // `discount` is an optional screen answer: a resume may leave it + // unbound, which the template wrote as nothing and the guard writes + // as null (the quote field has no default, so the two agree). + subtotal: cel22`oppRecord.amount`, + discount: cel22`has(vars.discount) ? discount : null`, + // ⛔ A currency × percentage MUST be rounded to whole cents inside the + // expression — the flow hands the engine a money amount, never an + // unrounded double. `discount / 100` is inexact for every percentage + // whose hundredth is not a dyadic rational, so a BARE product carries + // a tail: 180,000 at 30% is 125999.99999999999. While these fields + // declared `scale: 2` the insert was rejected for it (`Total Price + // must have at most 2 decimal places (got 11)`, #1206). Currency + // fields no longer declare `scale` — the platform refuses it, a + // currency's decimals are its ISO 4217 minor unit (#1965) — so the + // write is now ACCEPTED and the tail would be stored silently. The + // rounding keeps `discount_amount` / `total_price` whole-cent amounts. + // + // Both are CEL value envelopes. CEL's `round()` is INTEGER-ONLY and + // single-argument, and it returns an INT — so the divisor MUST be + // the decimal `100.0`. ⛔ Never `/ 100`: in CEL int / int is integer + // division, which silently drops the cents (1,234.56 at 10% would + // store 123, not 123.46; `test/flow-quote.test.ts` pins it). ⛔ Not + // `round(x, 2)` either: there is no precision form, and it fails + // loudly. `double()` types the amount, which some drivers return as + // a string. A cleared discount (null / absent / "") prices as 0%, as + // it did before; the `has()` guard is what keeps that TOTAL. + // + // ⭐ This shape applies ANYWHERE a flow multiplies a currency by a + // percentage. Write the rounding, not the bare product. + discount_amount: expression4(`round(double(oppRecord.amount) * (${DISCOUNT} / 100.0) * 100.0) / 100.0`, "cel"), + total_price: expression4(`round(double(oppRecord.amount) * (1.0 - ${DISCOUNT} / 100.0) * 100.0) / 100.0`, "cel"), + payment_terms: "net_30" + }, + outputVariable: "quoteId" + } + }, + { + // Advance to `proposal` only from a PRE-proposal stage (the state machine + // allows `→ proposal` from all three). ⛔ Never re-write `proposal` on a + // deal already at proposal/negotiation: that is an illegal self/backward + // transition. Those deals keep their stage; the quote is still created. + // + // ⛔ Nor on a deal AWAITING APPROVAL (`approval_status == "pending"`). A + // deal of `LARGE_DEAL_AMOUNT` or more is held by `opportunity_approval`'s + // approval node (`lockRecord: true`) until a manager decides, and the + // lock refuses this run's stage write — the run is the rep's + // (`runAs: 'user'`), and the lock is the approval working as intended. + // `create_quote` has already landed by then and a flow carries no + // transaction (ADR-0077), so the refusal used to fail the run AFTER the + // quote existed: measured on 17.7.0, `FLOW_FAILED` 400 `RECORD_LOCKED` + // at `update_opportunity`, the rep told the quote failed, and the draft + // quote left standing (#2015). A deal under review keeps its stage + // exactly like a deal already at proposal; the quote is still created — + // the button is offered at every open stage, and a draft quote commits + // nothing the approval is there to hold. `approval_status` is the lock's + // own mirror (`approvalStatusField`): the approvals plugin stamps + // `pending` when it opens the locking request and a terminal verdict + // when it releases it. + // + // The predicate itself lives on edges `e4a` / `e4b` — a `decision` node's + // singular `config.condition` is never evaluated, so a copy here would be + // inert (17.0.0-rc.2's `flow-inert-node-condition`). The totality + // rationale is on those edges, where the guards are. + id: "check_stage", + type: "decision", + label: "Can Advance to Proposal?" + }, + { + id: "update_opportunity", + type: "update_record", + label: "Update Opportunity", + config: { + // ⛔ No `last_activity_date` write: `crm_opportunity` has no such field + // (it lives on `crm_account`), and an unknown column fails this node. + objectName: "crm_opportunity", + filter: { id: cel22`recordId` }, + fields: { stage: "proposal" } + } + }, + { + // ADR-0012: deliver via the `notify` node (inbox + email). The legacy + // `script` + `actionType:'email'` shape is a no-op stub in 7.4. + id: "notify_owner", + type: "notify", + label: "Send Notification", + config: { + recipients: [cel22`current_user.id`], + channels: ["inbox", "email"], + topic: "quote_created", + template: "crm.quote_created", + templateData: { quote_name: cel22`quoteName` }, + actionUrl: "/crm_quote/{{quoteId.id}}" + } + }, + { id: "end", type: "end", label: "End" } + ], + edges: [ + // ⛔ A retired edge's id stays VACANT: `e1` (start → screen_1) is one. + // Every surviving edge keeps its id, and a new one takes the next id after + // the highest in use — a duplicate id is inert, so nothing would flag it. + { id: "e7", source: "start", target: "get_held", type: "default" }, + // ── The 立项 gate (#2032) ────────────────────────────────────────── + // + // COMPLEMENTARY CONDITIONALS off a plain data node, not a `decision` — the + // shape `billing-handoff-contract-activated.flow.ts` records: they are + // evaluated one by one, and `!= null` / `== null` partition exactly. + // `get_held` dominates both and binds `held` on every path — the row, or + // `null` on a miss — so neither read takes a `has()` guard: the + // get_record-dominated case `test/flow-variable-conditions.test.ts` + // records as needing none, written like `lead_conversion`'s `e5` / `e6`. + // Fail-OPEN like the hook: a deal the read cannot see goes on to the form + // and fails at `create_quote` exactly as it always did. + { id: "e9", source: "get_held", target: "refuse_held", type: "default", condition: P39`vars.held != null`, label: "Held" }, + { id: "e10", source: "get_held", target: "screen_1", type: "default", condition: P39`vars.held == null`, label: "Not held" }, + { id: "e2", source: "screen_1", target: "get_opportunity", type: "default" }, + { id: "e3", source: "get_opportunity", target: "create_quote", type: "default" }, + { id: "e4", source: "create_quote", target: "check_stage", type: "default" }, + // The two branches must PARTITION, so the keep side is the advance side + // negated whole (`ADVANCE` above): `has(…) && …` advances and everything + // else keeps. An unknown stage therefore lands on "keep stage" — the quote + // is still created and nothing illegal is written to the state machine. + // These EDGES are the live sites; `check_stage` carries no + // `config.condition` at all, because the engine never evaluates one. + // + // TOTALITY: `oppRecord` is a `get_record` OUTPUT — `findOne` answers + // a miss with `null`, and reading a field off it then aborts with `No such + // key: stage`. Measured unreachable TODAY only because two neighbouring + // schemas happen to close it: `crm_opportunity.stage` is `required` (never + // a sparse column) and `crm_quote.crm_account` is `required`, so a null + // `oppRecord` makes `create_quote` fail one node earlier. Both are one + // `required: false` away from re-opening it, so the predicate carries its + // own guard — and from 17.0.0-rc.2 an unevaluable condition aborts the step + // instead of skipping it, so the guard is load-bearing, not + // decorative. Note the scope is `vars.oppRecord`, not bare `oppRecord`: + // measured, `has(oppRecord.stage)` still aborts with `Unknown variable: + // oppRecord` when the variable is unbound, while `has(vars.oppRecord)` + // answers `false` — only the `vars.`-scoped form is total against both + // hazards. + // + // The approval term (see `check_stage`) is guarded the same way: an absent + // or null `approval_status` is "not under approval" and advances, as it + // did before the term existed. + { id: "e4a", source: "check_stage", target: "update_opportunity", type: "conditional", condition: expression4(ADVANCE, "cel"), label: "Advance" }, + { id: "e4b", source: "check_stage", target: "notify_owner", type: "conditional", condition: expression4(`!(${ADVANCE})`, "cel"), label: "Keep stage" }, + { id: "e5", source: "update_opportunity", target: "notify_owner", type: "default" }, + { id: "e6", source: "notify_owner", target: "end", type: "default" } + ] +}; + +// src/revenue/flows/contract-renewal.flow.ts +import { P as P40, cel as cel23 } from "@objectstack/spec"; +var ContractRenewalFlow = { + name: "contract_renewal", + label: "Contract Renewal Reminder", + description: "Daily sweep: open renewal tasks/opportunities for contracts nearing end_date.", + type: "schedule", + status: "active", + // Scheduled runs have no trigger user, so under the default runAs:'user' the + // data nodes execute UNSCOPED anyway. Declare runAs:'system' to make that + // RLS-bypassing elevation explicit and intended (ADR-0049). + runAs: "system", + variables: [], + nodes: [ + { id: "start", type: "start", label: "Start (daily 08:00)", config: { schedule: "0 8 * * *" } }, + { + // Broad pre-filter (next 120 days — ⛔ must cover the LARGEST + // renewal_notice_days in use; seeds go up to 90). The per-record notice + // window is applied in the decision node below so each contract honours + // its own renewal_notice_days. A pre-filter narrower than the largest + // notice period silently truncates it: a 90-day contract stays invisible + // until 60 days out. + id: "query_contracts", + type: "get_record", + label: "Find Expiring Contracts", + config: { + objectName: "crm_contract", + filter: { status: "activated", end_date: { $gte: cel23`isoDate(today())`, $lte: cel23`isoDate(daysFromNow(120))` } }, + limit: 500, + outputVariable: "contractList" + } + }, + { + id: "loop_contracts", + type: "loop", + label: "For Each Contract", + config: { + collection: cel23`contractList`, + iteratorVariable: "currentContract", + body: guarded("contract", { + nodes: [ + { + // Gateway only — the predicate lives on the out-edge. + id: "check_notice_window", + type: "decision", + label: "Within Notice Window?" + }, + { + // Idempotency gate: the sweep matches the same contract every day + // of its notice window, so ⛔ without it every day produces a + // duplicate task + notification (and, below, a duplicate + // pipeline-inflating renewal opportunity). An open renewal task + // for this contract means this window was already handled. + id: "find_existing_task", + type: "get_record", + label: "Already Reminded?", + config: { + objectName: "crm_task", + filter: { + related_to_account: cel23`currentContract.crm_account`, + subject: cel23`'Renewal due: contract ' + currentContract.contract_number`, + status: { $nin: ["completed"] } + }, + outputVariable: "existingRenewalTask" + } + }, + { + // Gateway only — the predicate lives on the out-edge. + id: "check_not_reminded", + type: "decision", + label: "First Reminder?" + }, + { + id: "create_renewal_task", + type: "create_record", + label: "Create Renewal Task", + config: { + objectName: "crm_task", + fields: { + subject: cel23`'Renewal due: contract ' + currentContract.contract_number`, + type: "follow_up", + priority: "high", + status: "not_started", + due_date: cel23`currentContract.end_date`, + owner_id: cel23`has(currentContract.owner_id) ? currentContract.owner_id : null`, + // ORG PARTITION. A schedule trigger carries no + // organization, so the engine has nothing to fill this from + // and the row would be born `organization_id` NULL — outside + // every org partition, where an `(organization_id, …)` unique + // index does not constrain and org-scoped reads never see it. + // Upstream ruling objectstack#6155 Q2=A puts the answer here, + // with the flow author: a renewal task belongs to the org of + // the contract that spawned it. Fill-only precedence means an + // author-set value wins over the engine (objectstack#6153). + // The source MUST be a row that actually carries the column. + // On 17.x an absent key interpolated to `undefined` and landed + // as NULL, which satisfied the publish guard while reproducing + // the bug; the CEL read below fails the iteration instead, and + // it is deliberately left UNGUARDED — a `has()` guard would + // write that NULL back. `crm_contract` carries it; `sys_user` + // does not. + organization_id: cel23`currentContract.organization_id`, + related_to_type: "crm_account", + related_to_account: cel23`currentContract.crm_account` + } + } + }, + { + id: "notify_owner", + type: "notify", + label: "Notify Owner", + config: { + recipients: [cel23`has(currentContract.owner_id) ? currentContract.owner_id : null`], + channels: ["inbox", "email"], + topic: "contract_renewal", + template: "crm.contract_renewal", + templateData: { + contract_number: cel23`currentContract.contract_number`, + end_date: cel23`currentContract.end_date` + }, + actionUrl: "/crm_contract/{{currentContract.id}}" + } + }, + { + // Gateway only — the predicate lives on the out-edge. + id: "check_auto_renewal", + type: "decision", + label: "Auto-Renewal On?" + }, + { + // Second gate: never open a second renewal opportunity while one + // is still in flight for this account (belt-and-braces for the + // case where the task was completed but the deal is still open). + id: "find_existing_renewal_opp", + type: "get_record", + label: "Open Renewal Deal Exists?", + config: { + objectName: "crm_opportunity", + filter: { + crm_account: cel23`currentContract.crm_account`, + type: "existing_renewal", + stage: { $nin: ["closed_won", "closed_lost"] } + }, + outputVariable: "existingRenewalOpp" + } + }, + { + // Gateway only — the predicate lives on the out-edge. + id: "check_no_open_renewal", + type: "decision", + label: "No Open Renewal Deal?" + }, + { + id: "create_renewal_opp", + type: "create_record", + label: "Open Renewal Opportunity", + config: { + objectName: "crm_opportunity", + fields: { + name: cel23`'Renewal — ' + currentContract.contract_number`, + crm_account: cel23`currentContract.crm_account`, + amount: cel23`currentContract.contract_value`, + stage: "proposal", + type: "existing_renewal", + close_date: cel23`currentContract.end_date`, + owner_id: cel23`has(currentContract.owner_id) ? currentContract.owner_id : null`, + // ORG PARTITION — see `create_renewal_task` above. + // The renewal deal belongs to the same org as the contract. + organization_id: cel23`currentContract.organization_id`, + next_step: "Confirm renewal terms with customer" + } + } + } + ], + edges: [ + // Only act when inside the per-contract notice window; gates with + // no matching edge simply end the iteration, so the loop moves on. + // + // The EDGE is the ONLY site: a `decision` node's singular + // `config.condition` is never read — the executor reads the plural + // `config.conditions[]` and nothing else — so a copy on the node + // would be inert metadata that drifts silently. `check_notice_window` + // is therefore a bare gateway and this predicate is authored once. + // + // `end_date` is a DATE field and arrives as `YYYY-MM-DD`, but CEL's + // `timestamp()` only accepts a full ISO 8601 datetime and throws + // otherwise ("timestamp() requires a string in ISO 8601 format"). + // Appending the time part is what makes this evaluate instead of + // blowing up mid-sweep. + // + // TOTALITY: `currentContract` is a LOOP ITEM over + // `contractList`, which `get_record` filled from `data.find` — + // every element is a raw driver row, sparse in exactly the way + // a raw driver row is. `end_date` is `required` on `crm_contract` so + // that column is always written, but `renewal_notice_days` + // (`defaultValue: 30`) and `auto_renewal` (`defaultValue: false`) + // are only DEFAULTED, and a row written before the default existed + // carries neither the column nor a value. Both operands + // additionally need `!= null`, because the abort here is not the + // usual overload error: `null + "T00:00:00Z"` and `int(null)` each + // blow up inside the function call, one contract into a 500-row + // sweep, taking the whole scheduled run with them. + { id: "b1", source: "check_notice_window", target: "find_existing_task", type: "conditional", condition: P40`has(vars.currentContract) && has(vars.currentContract.end_date) && has(vars.currentContract.renewal_notice_days) + && vars.currentContract.end_date != null && vars.currentContract.renewal_notice_days != null + && timestamp(vars.currentContract.end_date + "T00:00:00Z") <= daysFromNow(int(vars.currentContract.renewal_notice_days))`, label: "In window" }, + { id: "b2", source: "find_existing_task", target: "check_not_reminded", type: "default" }, + { id: "b3", source: "check_not_reminded", target: "create_renewal_task", type: "conditional", condition: P40`existingRenewalTask == null`, label: "First reminder" }, + { id: "b4", source: "create_renewal_task", target: "notify_owner", type: "default" }, + { id: "b5", source: "notify_owner", target: "check_auto_renewal", type: "default" }, + // TOTALITY: same loop item, same sparse driver row. Only an + // explicit `true` opens a renewal deal, so an absent column reads + // as "auto-renewal off" — the conservative branch. + { id: "b6", source: "check_auto_renewal", target: "find_existing_renewal_opp", type: "conditional", condition: P40`has(vars.currentContract) && has(vars.currentContract.auto_renewal) + && vars.currentContract.auto_renewal == true`, label: "Auto-renew" }, + { id: "b7", source: "find_existing_renewal_opp", target: "check_no_open_renewal", type: "default" }, + { id: "b8", source: "check_no_open_renewal", target: "create_renewal_opp", type: "conditional", condition: P40`existingRenewalOpp == null`, label: "Open renewal deal" } + ] + }) + } + }, + { id: "end", type: "end", label: "End" } + ], + edges: [ + { id: "e1", source: "start", target: "query_contracts", type: "default" }, + { id: "e2", source: "query_contracts", target: "loop_contracts", type: "default" }, + { id: "e3", source: "loop_contracts", target: "end", type: "default" } + ] +}; + +// src/revenue/flows/quote-expiration.flow.ts +import { cel as cel24 } from "@objectstack/spec"; +var QuoteExpirationFlow = { + name: "quote_expiration", + label: "Quote Auto-Expiration", + description: "Daily: expire quotes past their expiration_date that are still open.", + type: "schedule", + status: "active", + // Scheduled runs have no trigger user, so under the default runAs:'user' the + // data nodes execute UNSCOPED anyway. Declare runAs:'system' to make that + // RLS-bypassing elevation explicit and intended (ADR-0049). + runAs: "system", + variables: [], + nodes: [ + { id: "start", type: "start", label: "Start (daily 01:00)", config: { schedule: "0 1 * * *" } }, + { + id: "query_quotes", + type: "get_record", + label: "Find Expired Quotes", + config: { + objectName: "crm_quote", + filter: { status: { $nin: ["accepted", "rejected", "expired"] }, expiration_date: { $lt: cel24`isoDate(today())` } }, + limit: 500, + outputVariable: "quoteList" + } + }, + { + id: "loop_quotes", + type: "loop", + label: "For Each Quote", + config: { + collection: cel24`quoteList`, + iteratorVariable: "currentQuote", + body: guarded("quote", { + nodes: [ + { + id: "mark_expired", + type: "update_record", + label: "Mark Expired", + config: { objectName: "crm_quote", filter: { id: cel24`currentQuote.id` }, fields: { status: "expired" } } + } + ], + edges: [] + }) + } + }, + { id: "end", type: "end", label: "End" } + ], + edges: [ + { id: "e1", source: "start", target: "query_quotes", type: "default" }, + { id: "e2", source: "query_quotes", target: "loop_quotes", type: "default" }, + { id: "e3", source: "loop_quotes", target: "end", type: "default" } + ] +}; + +// src/revenue/flows/contract-expiration.flow.ts +import { cel as cel25 } from "@objectstack/spec"; +var ContractExpirationFlow = { + name: "contract_expiration", + label: "Contract Auto-Expiration", + description: "Daily: expire activated contracts past their end_date and notify the owner.", + type: "schedule", + status: "active", + // Scheduled runs have no trigger user, so under the default runAs:'user' the + // data nodes execute UNSCOPED anyway. Declare runAs:'system' to make that + // RLS-bypassing elevation explicit and intended (ADR-0049). + runAs: "system", + variables: [], + nodes: [ + { id: "start", type: "start", label: "Start (daily 00:00)", config: { schedule: "0 0 * * *" } }, + { + id: "query_contracts", + type: "get_record", + label: "Find Expired Contracts", + config: { + objectName: "crm_contract", + filter: { status: "activated", end_date: { $lt: cel25`isoDate(today())` } }, + limit: 500, + outputVariable: "contractList" + } + }, + { + id: "loop_contracts", + type: "loop", + label: "For Each Contract", + config: { + collection: cel25`contractList`, + iteratorVariable: "currentContract", + body: guarded("contract", { + nodes: [ + { + id: "mark_expired", + type: "update_record", + label: "Mark Expired", + config: { objectName: "crm_contract", filter: { id: cel25`currentContract.id` }, fields: { status: "expired" } } + }, + { + id: "notify_owner", + type: "notify", + label: "Notify Owner", + config: { + recipients: [cel25`has(currentContract.owner_id) ? currentContract.owner_id : null`], + channels: ["inbox", "email"], + topic: "contract_expired", + template: "crm.contract_expired", + templateData: { contract_number: cel25`currentContract.contract_number` }, + actionUrl: "/crm_contract/{{currentContract.id}}" + } + } + ], + edges: [ + { id: "b1", source: "mark_expired", target: "notify_owner", type: "default" } + ] + }) + } + }, + { id: "end", type: "end", label: "End" } + ], + edges: [ + { id: "e1", source: "start", target: "query_contracts", type: "default" }, + { id: "e2", source: "query_contracts", target: "loop_contracts", type: "default" }, + { id: "e3", source: "loop_contracts", target: "end", type: "default" } + ] +}; + +// src/revenue/flows/billing-handoff-contract-activated.flow.ts +import { P as P41, cel as cel26 } from "@objectstack/spec"; +var BillingHandoffContractActivatedFlow = { + name: "billing_handoff_contract_activated", + label: "Billing Hand-off: Contract Activated", + description: "On the transition into activated: POST the contract, its account and the originating deal\u2019s line items to the billing endpoint via the durable HTTP outbox.", + type: "record_change", + status: "active", + // Contracts are activated by machinery as well as by hand — `contract.hook.ts` + // stamps the account promotion and signed date on that same transition, and + // the renewal sweep runs `runAs: 'system'`. A system write carries no trigger + // user, so under the default `runAs: 'user'` this flow's two reads would be + // refused on exactly those runs and the hand-off would disappear without a + // failed step. Elevation also guarantees the payload is the whole contract, + // not an RLS-narrowed view of it. + runAs: "system", + variables: [ + // Bound with a default because the line-item read below is CONDITIONAL: a + // contract need not have an originating opportunity. Without the default, + // the skipped path leaves `billingLineItems` unbound and the payload key + // vanishes — so a receiver could not tell "no items" from "not sent". + { name: "billingLineItems", type: "collection", isInput: false, isOutput: false, defaultValue: [] } + ], + nodes: [ + { + id: "start", + type: "start", + label: "Start (contract updated)", + config: { + objectName: "crm_contract", + triggerType: "record-after-update", + condition: P41`has(record.status) && record.status == "activated" + && has(previous.status) && previous.status != "activated"` + } + }, + loadAccountNode(), + { + id: "load_line_items", + type: "get_record", + label: "Load Originating Deal\u2019s Line Items", + config: { + objectName: "crm_opportunity_line_item", + // Contracts carry no line items of their own; what was sold sits on the + // opportunity the contract came from. Reached only via the guarded edge + // below, because `crm_opportunity` is OPTIONAL on a contract and a + // filter operand that evaluates to null makes `get_record` refuse the + // step (an absent condition widens a query rather than narrowing it). + filter: { crm_opportunity: cel26`record.crm_opportunity` }, + fields: LINE_ITEM_FIELDS, + limit: BILLING_HANDOFF_LINE_ITEM_LIMIT, + outputVariable: "billingLineItems" + } + }, + { + id: "send_contract_activated_handoff", + type: "http", + label: "Enqueue Billing Hand-off", + config: { + url: BILLING_HANDOFF_ENDPOINT, + method: "POST", + durable: true, + timeoutMs: BILLING_HANDOFF_TIMEOUT_MS, + signingSecret: BILLING_HANDOFF_SIGNING_SECRET, + // One envelope building the whole payload (see `billingBody`). This + // flow is the consumer of `billing_frequency` and `payment_terms`: they + // are what the billing system needs to raise the schedule HotCRM + // deliberately does not model. + body: billingBody(BILLING_HANDOFF_EVENT.contractActivated, "contract", [ + "id", + "contract_number", + "status", + "contract_type", + "start_date", + "end_date", + "contract_term_months", + "contract_value", + "billing_frequency", + "payment_terms", + "auto_renewal", + "signed_date", + ["account_id", "crm_account"], + ["opportunity_id", "crm_opportunity"], + "owner_id" + ]) + } + }, + { id: "end", type: "end", label: "End" } + ], + edges: [ + { id: "e1", source: "start", target: "load_account", type: "default" }, + // The two edges below are COMPLEMENTARY CONDITIONALS on a plain data node, + // deliberately not a `decision` gateway. A decision with no declared + // `config.conditions` reports the engine's `default` branch label, and + // traversal then narrows the edge set to out-edges claiming that label — + // an `isDefault: true` sibling would swallow the whole branch and the + // conditional edge would never be evaluated. Complementary conditions off a + // non-branching node are evaluated one by one, which is the behaviour this + // needs. + { + id: "e2", + source: "load_account", + target: "load_line_items", + type: "conditional", + label: "Has originating deal", + condition: P41`has(record.crm_opportunity) && record.crm_opportunity != null` + }, + { + id: "e3", + source: "load_account", + target: "send_contract_activated_handoff", + type: "conditional", + label: "No originating deal", + condition: P41`!has(record.crm_opportunity) || record.crm_opportunity == null` + }, + { id: "e4", source: "load_line_items", target: "send_contract_activated_handoff", type: "default" }, + { id: "e5", source: "send_contract_activated_handoff", target: "end", type: "default" } + ] +}; + +// src/marketing/flows/campaign-enrollment.flow.ts +import { P as P42, cel as cel27 } from "@objectstack/spec"; +var CampaignEnrollmentFlow = { + name: "campaign_enrollment", + label: "Enroll Members in Campaign", + description: "Bulk enroll eligible leads or contacts into this campaign (skips already-enrolled and opted-out people).", + type: "screen", + status: "active", + variables: [ + // `recordId` matches the console's flow-action trigger contract + // ({ recordId, objectName }) — cf. lead_conversion / quote_generation. + { name: "recordId", type: "text", isInput: true, isOutput: false }, + /** + * `memberSource` is BOUND BY THIS DECLARATION — not by a seeding node. + * + * Both branch edges (`e4` / `e7`) read `vars.memberSource`, so it must be + * bound on every path reaching them. `FlowVariableSchema` carries + * `defaultValue` and the engine seeds it before the start node runs, so this + * key alone binds the name — while a caller-supplied + * `context.params.memberSource` still WINS over it. + * + * ⚠️ Measured on the 17.1.0 spec, with the schema key re-checked on 17.2.0. + * Neither that key nor the seeding behaviour was re-checked on 17.3.0 or + * 17.4.0 (PR #1814, #1807), nor on 17.5.0, 17.6.0, 17.7.0 or 18.0.0-next.0 (the pin since #2031). + * + * ⛔ Never seed this with an assignment node instead. An assignment is + * unconditional, so it CLOBBERS a supplied param — measured: launching with + * `params.memberSource = 'contacts'` ran the LEAD branch. It also restates a + * default the screen field carries, with nothing keeping the two in step. + * + * A second, independent reason no seeding node is needed here: the + * `memberSource` screen field below is `required: true`, and since + * 17.0.0-rc.2 the SERVER holds a screen resume to the declared field + * contract. A resume signal omitting `memberSource` is refused with + * `INVALID_SCREEN_INPUT` and the run stays paused, so the ordinary resume + * path cannot reach an unbound read at all — unlike `lead_conversion`'s + * checkbox, which is deliberately not `required` and therefore has an + * unanswered state. The one path that skips that check is a resume carrying + * NO signal object; measured on 17.x, it fails one node later at + * `query_leads` regardless of this binding, because `leadStatus` is unbound + * and the query never runs widened. Since 18.0.0-next.0 the filter operand + * is a CEL envelope, and an unbound variable fails the run before the query + * (the platform's `flow-value-slot-template-dialect-refused` contract; not + * re-measured here). + * + * The literal lives HERE and nowhere else: the screen field derives its + * prefill from this variable (its `defaultValue` envelope reads `memberSource`). + */ + { name: "memberSource", type: "text", isInput: true, isOutput: false, defaultValue: "leads" }, + /** + * `leadStatus` / `contactDepartment` deliberately carry NO `defaultValue`, + * and the asymmetry with `memberSource` is the point. No condition in this + * flow reads either one — each is a `get_record` `filter` operand — so the + * binding analysis in `test/flow-variable-conditions.test.ts` does not + * cover them. An unbound one fails the run before the query is made (the + * 18.0.0-next.0 filter-operand contract), because an absent condition + * widens a query instead of narrowing it. Seeding these two would turn that + * loud failure into a silent enrolment of a segment nobody chose; their + * `required: true` screen fields are what supply them. + */ + { name: "leadStatus", type: "text", isInput: true, isOutput: false }, + { name: "contactDepartment", type: "text", isInput: true, isOutput: false } + ], + nodes: [ + { id: "start", type: "start", label: "Start", config: { objectName: "crm_campaign" } }, + { + id: "screen_1", + type: "screen", + label: "Enrollment Criteria", + config: { + fields: [ + { + // Prefill DERIVED from the variable, so the default is written + // once (on the declaration) rather than restated here — the + // single-authority form. The envelope is evaluated before the + // screen goes on the wire, so the client receives the raw value, + // the string `leads`, which is what a literal + // `defaultValue: 'leads'` used to send. + name: "memberSource", + label: "Enroll", + type: "select", + required: true, + defaultValue: cel27`memberSource`, + options: [ + { label: "Leads", value: "leads" }, + { label: "Contacts", value: "contacts" } + ] + }, + { + name: "leadStatus", + label: "Enroll leads in status", + type: "select", + required: true, + defaultValue: "new", + options: [ + { label: "New", value: "new" }, + { label: "Contacted", value: "contacted" }, + { label: "Qualified", value: "qualified" } + ] + }, + { + // Required, like `leadStatus`, and for the same reason: a blank + // segment would reach the filter as an empty string and + // silently match the contacts with NO department rather than all of + // them. Both branches make the caller name a segment. + name: "contactDepartment", + label: "Enroll contacts in department", + type: "select", + required: true, + defaultValue: "executive", + options: [ + { label: "Executive", value: "executive" }, + { label: "Sales", value: "sales" }, + { label: "Marketing", value: "marketing" }, + { label: "Engineering", value: "engineering" }, + { label: "Support", value: "support" }, + { label: "Finance", value: "finance" }, + { label: "Human Resources", value: "hr" }, + { label: "Operations", value: "operations" } + ] + } + ] + } + }, + { + id: "get_campaign", + type: "get_record", + label: "Get Campaign", + config: { objectName: "crm_campaign", filter: { id: cel27`recordId` }, outputVariable: "campaignRecord" } + }, + { + // The gate itself is on edges `e4` / `e7` — see the notes there. This node + // carries NO `config.condition`: the key is the trigger gate on a `start` + // node and is read nowhere else, so a copy here would be a second, inert + // statement of the predicate that no reader can tell apart from the live + // one (flagged by `flow-inert-node-condition` from 17.0.0-rc.2). + id: "check_campaign_open", + type: "decision", + label: "Campaign Open?" + }, + { + id: "query_leads", + type: "get_record", + label: "Find Eligible Leads", + config: { + objectName: "crm_lead", + filter: { + status: cel27`leadStatus`, + is_converted: false, + email: { $ne: null }, + // This is email-campaign enrollment — honour the opt-out flag. + // `campaign_member_optout_sync` populates it: an unsubscribed member + // round-trips to the person's `email_opt_out`. + email_opt_out: false + }, + limit: 1e3, + outputVariable: "leadList" + } + }, + { + id: "loop_leads", + type: "loop", + label: "Process Each Lead", + config: { + collection: cel27`leadList`, + iteratorVariable: "currentLead", + body: guarded("lead", { + nodes: [ + { + // Dedupe: skip leads already enrolled in THIS campaign, so a + // re-run tops up instead of double-enrolling (double rows + // inflated num_sent / response_rate). + id: "find_existing_member", + type: "get_record", + label: "Already Enrolled?", + config: { + objectName: "crm_campaign_member", + filter: { crm_campaign: cel27`recordId`, crm_lead: cel27`currentLead.id` }, + outputVariable: "existingMember" + } + }, + { + // Gateway only — the predicate lives on the out-edge. + id: "check_not_enrolled", + type: "decision", + label: "New Member?" + }, + { + // ⭐ The INSERT is elevated, this flow is NOT. `added_date` is + // `readonly: true`, and from @objectstack/objectql 17.4.0 the + // readonly strip runs inside `engine.insert` for a non-system + // caller as well as on update — so a write from this screen + // flow's user context now loses the stamp. The remedy the + // platform names is a system context; the remedy AGENTS.md house + // rule 9 names is a dedicated `system` sub-flow rather than + // elevating the screen flow. Both are satisfied here. ⛔ Do not + // fold this back by giving THIS flow `runAs: 'system'`: it would + // also lift RLS off `query_leads` / `query_contacts`, and + // `crm_lead` is `sharingModel: 'private'`. + // See `src/marketing/flows/campaign-member-enroll.flow.ts`. + id: "create_campaign_member", + type: "subflow", + label: "Add to Campaign", + config: { + flowName: "campaign_lead_member_enroll", + input: { campaignId: cel27`recordId`, leadId: cel27`currentLead.id` } + } + } + ], + edges: [ + { id: "b1", source: "find_existing_member", target: "check_not_enrolled", type: "default" }, + // Already enrolled → no edge → next lead. This edge is the ONLY + // site for the predicate: a `decision` node's singular + // `config.condition` is never read, so a node copy would be inert. + { id: "b2", source: "check_not_enrolled", target: "create_campaign_member", type: "conditional", condition: P42`existingMember == null`, label: "Enroll" } + ] + }) + } + }, + { + id: "query_contacts", + type: "get_record", + label: "Find Eligible Contacts", + config: { + objectName: "crm_contact", + filter: { + department: cel27`contactDepartment`, + email: { $ne: null }, + // Same opt-out honour as the lead branch. There is no `is_converted` + // twin here: a contact IS the converted end state. + email_opt_out: false + }, + limit: 1e3, + outputVariable: "contactList" + } + }, + { + id: "loop_contacts", + type: "loop", + label: "Process Each Contact", + config: { + collection: cel27`contactList`, + iteratorVariable: "currentContact", + body: guarded("contact", { + nodes: [ + { + // Dedupe scoped on `crm_contact`, so a person enrolled as a LEAD + // and again as a CONTACT is not treated as a duplicate: those are + // two records of two different relationships, and the seed + // datasets key them separately for the same reason. + id: "find_existing_contact_member", + type: "get_record", + label: "Already Enrolled?", + config: { + objectName: "crm_campaign_member", + filter: { crm_campaign: cel27`recordId`, crm_contact: cel27`currentContact.id` }, + outputVariable: "existingContactMember" + } + }, + { + // Gateway only — the predicate lives on the out-edge. + id: "check_contact_not_enrolled", + type: "decision", + label: "New Member?" + }, + { + // The contact mirror of `create_campaign_member` above — same + // elevation, same reason. See that node's note. + id: "create_contact_member", + type: "subflow", + label: "Add Contact to Campaign", + config: { + flowName: "campaign_contact_member_enroll", + input: { campaignId: cel27`recordId`, contactId: cel27`currentContact.id` } + } + } + ], + edges: [ + { id: "c1", source: "find_existing_contact_member", target: "check_contact_not_enrolled", type: "default" }, + { id: "c2", source: "check_contact_not_enrolled", target: "create_contact_member", type: "conditional", condition: P42`existingContactMember == null`, label: "Enroll" } + ] + }) + } + }, + { id: "end", type: "end", label: "End" } + ], + edges: [ + { id: "e1", source: "start", target: "screen_1", type: "default" }, + { id: "e2", source: "screen_1", target: "get_campaign", type: "default" }, + { id: "e3", source: "get_campaign", target: "check_campaign_open", type: "default" }, + // Closed campaign → no edge → flow ends without enrolling. + // + // THE live gate, on the EDGES and only here. A `decision` node's singular + // `config.condition` is never read by the engine. + // + // Only enroll into campaigns that are actually running (or planned): + // topping up a completed/aborted campaign would corrupt its recorded + // metrics. (Status values: planning / in_progress / completed / aborted.) + // + // TOTALITY: `has(vars.campaignRecord)` first, then + // `has(vars.campaignRecord.status)`. `campaignRecord` is a `get_record` + // OUTPUT, and `findOne` answers a miss with `null` — so a campaign that was + // deleted (or hidden by sharing) between the action click and this node + // leaves the variable bound to null, and an unguarded read aborts with + // `No such key: status`, recording the run `failed` with not one lead + // enrolled. `status` is `required` on `crm_campaign` today so the column is + // never sparse — but that is the neighbouring schema doing the work, not + // this predicate, so it is guarded too. + // + // TWO conditional out-edges, one per member side. The open-campaign clause + // is repeated on both rather than hoisted to a second decision node: the + // gate IS the edge predicate here, so a separate "which side" node would + // need its own out-edges carrying the same clause anyway, and a node + // stating it once in `config.condition` is inert. + { id: "e4", source: "check_campaign_open", target: "query_leads", type: "conditional", condition: P42`has(vars.campaignRecord) && has(vars.campaignRecord.status) + && (vars.campaignRecord.status == "planning" || vars.campaignRecord.status == "in_progress") + && vars.memberSource != "contacts"`, label: "Open \xB7 Leads" }, + { id: "e5", source: "query_leads", target: "loop_leads", type: "default" }, + { id: "e6", source: "loop_leads", target: "end", type: "default" }, + // The contact branch. `memberSource` carries no `has()` guard on either + // edge, deliberately: its `flow.variables` declaration carries + // `defaultValue: 'leads'`, which the engine seeds before the start node, so + // it is bound on every path that reaches here — and on the ordinary resume + // path the server has already refused any signal that omitted the + // `required` screen field. A guard would have buried the policy ("no answer + // means leads") inside a predicate and left the graph defect in place — see + // test/flow-variable-conditions.test.ts. + { id: "e7", source: "check_campaign_open", target: "query_contacts", type: "conditional", condition: P42`has(vars.campaignRecord) && has(vars.campaignRecord.status) + && (vars.campaignRecord.status == "planning" || vars.campaignRecord.status == "in_progress") + && vars.memberSource == "contacts"`, label: "Open \xB7 Contacts" }, + { id: "e8", source: "query_contacts", target: "loop_contacts", type: "default" }, + { id: "e9", source: "loop_contacts", target: "end", type: "default" } + ] +}; + +// src/marketing/flows/campaign-member-enroll.flow.ts +import { cel as cel28 } from "@objectstack/spec"; +var MEMBERSHIP_FIELDS = { + status: "sent", + // The readonly stamp this elevation exists for. + added_date: cel28`isoDatetime(now())` +}; +var CampaignLeadMemberEnrollFlow = { + name: "campaign_lead_member_enroll", + label: "Enroll Lead in Campaign", + description: "Insert one lead campaign-membership row with its readonly added_date stamp, using the system context. Called by campaign_enrollment through a subflow node.", + type: "autolaunched", + status: "active", + // ⭐ THE ENTIRE POINT OF THIS FILE — see the header. One `create_record`. + runAs: "system", + variables: [ + // Supplied by the caller's `subflow` node. + { name: "campaignId", type: "text", isInput: true, isOutput: false }, + { name: "leadId", type: "text", isInput: true, isOutput: false } + ], + nodes: [ + // `config: {}` — an autolaunched callee is handed its params by the + // `subflow` executor and resolves no trigger record of its own, so there is + // no `objectName` for the start node to load. Same shape as + // `case_escalation_stamp`, measured in `test/readonly-write-semantics.test.ts`. + { id: "start", type: "start", label: "Start", config: {} }, + { + id: "create_campaign_member", + type: "create_record", + label: "Add to Campaign", + config: { + objectName: "crm_campaign_member", + // ⛔ Do not add fields here. Every column in this node is written with + // the elevated context; anything a marketer may legitimately type + // belongs in `campaign_enrollment` instead. + fields: { crm_campaign: cel28`campaignId`, crm_lead: cel28`leadId`, ...MEMBERSHIP_FIELDS } + } + }, + { id: "end", type: "end", label: "End" } + ], + edges: [ + { id: "e1", source: "start", target: "create_campaign_member", type: "default" }, + { id: "e2", source: "create_campaign_member", target: "end", type: "default" } + ] +}; +var CampaignContactMemberEnrollFlow = { + name: "campaign_contact_member_enroll", + label: "Enroll Contact in Campaign", + description: "Insert one contact campaign-membership row with its readonly added_date stamp, using the system context. Called by campaign_enrollment through a subflow node.", + type: "autolaunched", + status: "active", + runAs: "system", + variables: [ + { name: "campaignId", type: "text", isInput: true, isOutput: false }, + { name: "contactId", type: "text", isInput: true, isOutput: false } + ], + nodes: [ + { id: "start", type: "start", label: "Start", config: {} }, + { + id: "create_contact_member", + type: "create_record", + label: "Add Contact to Campaign", + config: { + objectName: "crm_campaign_member", + fields: { crm_campaign: cel28`campaignId`, crm_contact: cel28`contactId`, ...MEMBERSHIP_FIELDS } + } + }, + { id: "end", type: "end", label: "End" } + ], + edges: [ + { id: "e1", source: "start", target: "create_contact_member", type: "default" }, + { id: "e2", source: "create_contact_member", target: "end", type: "default" } + ] +}; + +// src/marketing/flows/campaign-completion.flow.ts +import { cel as cel29 } from "@objectstack/spec"; +var CampaignCompletionFlow = { + name: "campaign_completion", + label: "Campaign Auto-Completion", + description: "Daily: mark in_progress campaigns whose end_date has passed as completed.", + type: "schedule", + status: "active", + // Scheduled runs have no trigger user, so under the default runAs:'user' the + // data nodes execute UNSCOPED anyway. Declare runAs:'system' to make that + // RLS-bypassing elevation explicit and intended (ADR-0049). + runAs: "system", + variables: [], + nodes: [ + { id: "start", type: "start", label: "Start (daily 02:00)", config: { schedule: "0 2 * * *" } }, + { + id: "query_campaigns", + type: "get_record", + label: "Find Ended Campaigns", + config: { + objectName: "crm_campaign", + filter: { status: "in_progress", end_date: { $lt: cel29`isoDate(today())` } }, + limit: 500, + outputVariable: "campaignList" + } + }, + { + id: "loop_campaigns", + type: "loop", + label: "For Each Campaign", + config: { + collection: cel29`campaignList`, + iteratorVariable: "currentCampaign", + body: guarded("campaign", { + nodes: [ + { + id: "mark_completed", + type: "update_record", + label: "Mark Completed", + config: { objectName: "crm_campaign", filter: { id: cel29`currentCampaign.id` }, fields: { status: "completed" } } + } + ], + edges: [] + }) + } + }, + { id: "end", type: "end", label: "End" } + ], + edges: [ + { id: "e1", source: "start", target: "query_campaigns", type: "default" }, + { id: "e2", source: "query_campaigns", target: "loop_campaigns", type: "default" }, + { id: "e3", source: "loop_campaigns", target: "end", type: "default" } + ] +}; + +// src/sales/skills/lead-qualification.skill.ts +import { defineSkill as defineSkill2 } from "@objectstack/spec"; +var LeadQualificationSkill = defineSkill2({ + name: "lead_qualification", + label: "Lead Qualification", + description: "Qualifies inbound leads using BANT criteria and assigns a 0\u2013100 score.", + instructions: `When the user asks to qualify, score, or analyse a lead: + +1. Read the lead \u2014 \`describe_object\` for \`crm_lead\` first (fields + change), then \`get_record\`. Use \`query_records\` to pull the + related activity history when the lead has any. +2. Score it yourself, 0\u2013100, with BANT. There is no scoring tool: + Budget (is spend confirmed or inferable from company size?), + Authority (is the contact a decision maker?), Need (is there a + stated problem you solve?), Timeline (is there a date?). Weight + them evenly unless the user says otherwise. +3. Report the score, one line of justification per BANT dimension + naming the field or activity you read, and the single recommended + next step. Cite the lead ID. +4. Score >= 70 and the user agrees \u2192 call \`action_convert_lead\`. +5. Otherwise, or when the user wants to nurture, call + \`action_schedule_followup\` with the date you recommend. Say why + that date. +6. Never convert without explicit confirmation \u2014 conversion is not + reversible from this surface.`, + tools: [ + "describe_object", + "get_record", + "query_records", + "action_convert_lead", + "action_schedule_followup" + ], + triggerConditions: [ + { field: "objectName", operator: "eq", value: "crm_lead" } + ] +}); + +// src/sales/skills/email-drafting.skill.ts +import { defineSkill as defineSkill3 } from "@objectstack/spec"; +var EmailDraftingSkill = defineSkill3({ + name: "email_drafting", + label: "Email Drafting", + description: "Drafts personalised outbound emails grounded in live contact data, ready for a human to review and send.", + instructions: `When the user asks to draft, write, or optimise an email: + +1. Ground it in real data before writing a word: \`get_record\` the + contact (and the related account or opportunity when the request + references one) so names, titles and recent activity are accurate. + Use \`query_records\` when you need the recent history. +2. Write the copy yourself \u2014 subject and body. You do not have, and do + not need, a copy-generation tool. Aim for: a subject under 60 + characters naming the concrete value, a first line referencing + something specific to THIS recipient rather than a generic + pleasantry, one clear ask, and no more than 150 words. +3. Offer two subject-line variants, say which you recommend and why, + so the user can A/B them. +4. Show the draft and stop. You cannot send \u2014 say so plainly rather + than implying a send is queued. +5. Point the user at **Send Email** on the contact record, where the + subject and body you drafted can be pasted, reviewed and sent.`, + tools: ["get_record", "query_records"] +}); + +// src/sales/skills/revenue-forecasting.skill.ts +import { defineSkill as defineSkill4 } from "@objectstack/spec"; +var RevenueForecastingSkill = defineSkill4({ + name: "revenue_forecasting", + label: "Revenue Forecasting", + description: "Analyses pipeline health, surfaces at-risk deals, and forecasts revenue from live opportunity data.", + instructions: `When the user asks about pipeline health, forecast, +risk, or deal slippage: + +1. Establish the shape first: \`describe_object\` for + \`crm_opportunity\` so you use the CURRENT stage, amount, + probability and close-date fields rather than assumed ones. +2. Summarise the pipeline with \`aggregate_data\` \u2014 count and summed + amount grouped by stage, scoped to the period the user names + (default: the current quarter). Weighted value is amount \xD7 + probability; compute it yourself from what you read. +3. Surface at-risk deals with \`query_records\`: close date already + past, or no activity in 30+ days, or the stage unchanged for longer + than its typical duration. Name each deal and the specific signal. +4. Forecast by summing weighted value for open deals plus closed-won + in the period. State the assumption behind the number in one line, + and give a range rather than false precision \u2014 the spread between + commit-only (high-probability stages) and full weighted pipeline. +5. Offer \`visualize_data\` when a chart would carry the answer better + than prose, e.g. stage distribution or month-over-month trend. +6. Be quantitative: every claim cites a number or a deal name. If the + data cannot support a claim, say so instead of estimating.`, + tools: ["describe_object", "aggregate_data", "query_records", "visualize_data"], + triggerConditions: [ + { field: "objectName", operator: "in", value: ["crm_opportunity", "dashboard"] } + ] +}); + +// src/sales/skills/customer-360.skill.ts +import { defineSkill as defineSkill5 } from "@objectstack/spec"; +var Customer360Skill = defineSkill5({ + name: "customer_360", + label: "Customer 360", + description: "Aggregates account, recent cases, open opportunities, and knowledge hits into a single customer profile.", + instructions: `When the user asks for "the full picture" of a +customer / account / contact: + +1. Read the shape first \u2014 \`describe_object\` for \`crm_account\`, and for + each related object before you query it. Admins add fields; never + summarise from memory of a previous turn. +2. \`get_record\` the account, then pull the related work with + \`query_records\`, each filtered to this account: + - \`crm_contact\` \u2014 who the people are, primary contact first. + - \`crm_case\` \u2014 cases where \`is_closed\` is false, newest first. + - \`crm_opportunity\` \u2014 open deals with stage, amount and close date. + Quote totals from \`aggregate_data\` (open pipeline amount, case count + by status) rather than adding up rows yourself. +3. For the policy or playbook context, \`query_records\` on + \`crm_knowledge_article\` \u2014 \`status\` published, matched on the + \`category\` or \`tags\` of the cases you just read. You have no + knowledge-search tool in this skill and do not need one: the knowledge + base is an object like any other. +4. Summarise into three sections: **Account Snapshot** \xB7 **Active Work** \xB7 + **Risks & Notes**. Every risk names the record and the signal that + raised it \u2014 an escalated case, a close date already past, a deal with + no activity in 30+ days. Do not infer risk you cannot cite. +5. Cite record IDs inline (e.g. "case CASE-01234", "article KA-0007") so + the UI can deep link. If a section has no records, say so plainly + instead of filling it.`, + tools: ["describe_object", "get_record", "query_records", "aggregate_data"] +}); + +// src/sales/skills/live-data.skill.ts +import { defineSkill as defineSkill6 } from "@objectstack/spec"; +var LiveDataSkill = defineSkill6({ + name: "live_data", + label: "Live Data Access", + description: "Queries any CRM object using the current live schema. Always inspects the object structure first so newly added fields are picked up immediately.", + instructions: `When the user asks a question that touches a CRM +record (account, contact, lead, opportunity, case, quote, etc.): + +1. **Always** call \`describe_object\` for the relevant object FIRST, + even if you think you remember the fields. The schema can change + between turns \u2014 trust the tool, not your memory. +2. Use \`list_objects\` if you are not sure which object holds the + data the user is asking about. +3. Use \`query_records\` (filters, sort, limit) for lists, + \`get_record\` for a single ID, \`aggregate_data\` for sums / + counts / averages. +4. When you reference data, cite the record ID inline so the UI + can deep-link (e.g. "opportunity OPP-1234"). +5. If \`describe_object\` shows a field you've never seen before, + USE IT \u2014 that's the user's whole point in adding it. Surface it + in your answer when relevant.`, + tools: [ + "describe_object", + "list_objects", + "query_records", + "get_record", + "aggregate_data" + ] +}); + +// src/sales/sharing/account.sharing.ts +import { P as P43 } from "@objectstack/spec"; +var AccountTeamSharingRule = { + name: "account_team_sharing", + label: "Account Team Sharing", + object: "crm_account", + type: "criteria", + condition: P43`record.type == "customer" && record.is_active == true`, + accessLevel: "edit", + sharedWith: { type: "position", value: "sales_manager" } +}; +var TerritorySharingRules = [ + { + name: "north_america_territory", + label: "North America Territory", + object: "crm_account", + type: "criteria", + condition: P43`record.territory == ${TERRITORY.NA}`, + accessLevel: "edit", + sharedWith: { type: "position", value: "na_sales_team" } + }, + { + name: "europe_territory", + label: "Europe Territory", + object: "crm_account", + type: "criteria", + condition: P43`record.territory == ${TERRITORY.EMEA}`, + accessLevel: "edit", + sharedWith: { type: "position", value: "eu_sales_team" } + } +]; + +// src/sales/sharing/opportunity.sharing.ts +import { P as P44 } from "@objectstack/spec"; +var OpportunitySalesSharingRule = { + name: "opportunity_sales_sharing", + label: "Opportunity Sales Team Sharing", + object: "crm_opportunity", + type: "criteria", + condition: P44`!(record.stage in ["closed_won", "closed_lost"]) && record.amount >= ${LARGE_DEAL_AMOUNT}`, + accessLevel: "read", + sharedWith: { type: "position", value: "sales_director" } +}; +var OpportunityExecutiveSharingRule = { + name: "opportunity_executive_sharing", + label: "Large Open Deals \u2014 Executive", + object: "crm_opportunity", + type: "criteria", + condition: P44`!(record.stage in ["closed_won", "closed_lost"]) && record.amount >= ${LARGE_DEAL_AMOUNT}`, + accessLevel: "read", + sharedWith: { type: "position", value: "executive" } +}; + +// src/sales/sharing/positions.ts +var CrmPositions = [ + { name: "executive", label: "Executive" }, + { name: "sales_director", label: "Sales Director" }, + { name: "sales_manager", label: "Sales Manager" }, + { name: "sales_rep", label: "Sales Representative" }, + { name: "service_director", label: "Service Director" }, + { name: "service_manager", label: "Service Manager" }, + { name: "service_agent", label: "Service Agent" }, + { name: "marketing_director", label: "Marketing Director" }, + { name: "marketing_manager", label: "Marketing Manager" }, + { name: "marketing_user", label: "Marketing User" }, + // Territory groupings referenced by the account sharing rules. + { name: "na_sales_team", label: "NA Sales Team" }, + { name: "eu_sales_team", label: "EU Sales Team" } +]; + +// src/marketing/sharing/campaign.sharing.ts +import { P as P45 } from "@objectstack/spec"; +var CampaignLeadershipSharingRules = [ + { + name: "campaign_leadership_manager", + label: "Live Campaigns \u2014 Marketing Manager", + object: "crm_campaign", + type: "criteria", + condition: P45`record.status in ["planning", "in_progress"] && record.is_active == true`, + accessLevel: "edit", + sharedWith: { type: "position", value: "marketing_manager" } + }, + { + name: "campaign_leadership_director", + label: "Live Campaigns \u2014 Marketing Director", + object: "crm_campaign", + type: "criteria", + condition: P45`record.status in ["planning", "in_progress"] && record.is_active == true`, + accessLevel: "edit", + sharedWith: { type: "position", value: "marketing_director" } + } +]; + +// src/sales/data/sales.seed.ts +import { defineSeed } from "@objectstack/spec/data"; +import { cel as cel31 } from "@objectstack/spec"; + +// src/sales/data/_shared.ts +import { cel as cel30 } from "@objectstack/spec"; +var celDaysAgo = (n) => cel30`daysAgo(${n})`; +var lineTotal = (l) => Math.round(l.quantity * l.unit_price * (1 - (l.discount ?? 0) / 100) * 100) / 100; +var linesTotal = (lines) => Math.round(lines.reduce((sum, l) => sum + lineTotal(l), 0) * 100) / 100; + +// src/sales/data/sales.seed.ts +var accounts = defineSeed(Account, { + mode: "upsert", + externalId: "name", + records: [ + { + name: "Acme Corporation", + approval_status: "approved", + type: "customer", + industry: "technology", + annual_revenue: 5e6, + number_of_employees: 250, + phone: "+1-415-555-0100", + billing_address: { street: "500 Howard Street, Suite 400", city: "San Francisco", state: "CA", postalCode: "94105", country: "US" }, + website: "https://acme.example.com", + tier: "enterprise", + segment: "growth", + health_score: "healthy", + // Held: workshop, demo, calls and an onsite visit — see `service.seed.ts`. + last_activity_date: cel31`today()`, + // The ARR line below used to read "signed Q1 2025 renewal" while the + // deal it describes closes `daysAgo(15)` — a fixed calendar quarter on a + // relative-date record, wrong in both the quarter and the year (#1692). + // The label is not re-derived here either: that date belongs to + // `Acme Annual Renewal 2025` (`close_date`) and to its contract + // (`signed_date`, `revenue.seed.ts`), and computing a copy in this module + // means re-stating that record's own offset — a second source of truth + // for a value two records already own. Same ruling as the `next_step` + // block below (#1660): no date goes back into this prose, absolute OR + // relative. What stays true however the renewal is dated is that it IS + // signed: the deal is `closed_won` and its contract `activated`. + description: `**Strategic Customer \xB7 Enterprise Tier** + +Acme Corporation is a Series-C robotics & industrial automation +company that switched from a competitor 18 months ago. They run +HotCRM as their system of record for sales + service across +three regional teams (NA, EMEA, APAC). + +**Relationship** +- Primary economic buyer: Jordan Park (CTO) \u2014 values our open + architecture and AI roadmap. +- Day-to-day champion: John Smith (VP Engineering) \u2014 owns the + technical evaluation and integration questions. +- Procurement: handled by Lisa Kim \u2014 prefers annual contracts, + net-30 terms. + +**Current state** +- ARR: $220K (signed renewal). Up 22% YoY. +- 1 open enterprise opportunity ($150K platform upgrade) in proposal + stage, 1 service ticket open (login issues), 1 billing dispute + awaiting customer response. +- AI agent governance became a hard requirement for that upgrade + after their internal compliance review, so the workshop now on + the calendar is the gate on signature. + +**Red flags** +- Lost the $75K Marketing Cloud add-on on timing \u2014 their marketing + org is locked into a 2-year HubSpot contract, and the buying + window opens when that contract renews. +- Login issues ticket is already past its SLA clock \u2014 needs eyes + today.` + }, + { + name: "Globex Industries", + approval_status: "approved", + type: "prospect", + industry: "manufacturing", + annual_revenue: 12e6, + number_of_employees: 800, + phone: "+1-312-555-0200", + billing_address: { street: "233 South Wacker Drive", city: "Chicago", state: "IL", postalCode: "60606", country: "US" }, + website: "https://globex.example.com", + tier: "enterprise", + segment: "net_new", + // Only a booked demo and a cancelled review — neither bubbles, so this + // 8-day age survives the seed load and stays inside every churn window. + last_activity_date: cel31`daysAgo(8)` + }, + { + name: "Initech Solutions", + approval_status: "approved", + type: "customer", + industry: "finance", + annual_revenue: 35e5, + number_of_employees: 150, + phone: "+1-212-555-0300", + billing_address: { street: "1 Liberty Plaza, 23rd Floor", city: "New York", state: "NY", postalCode: "10006", country: "US" }, + website: "https://initech.example.com", + tier: "mid_market", + segment: "at_risk", + health_score: "at_risk", + // QUIET 60+ — the `at_risk` segment and health score, with a clock that + // finally agrees with them: ten weeks of silence. A no-show call 55 days + // ago was the last attempt; the re-engagement call on the calendar is + // `planned`, so it moves nothing. + last_activity_date: cel31`daysAgo(72)` + }, + { + name: "Stark Medical", + approval_status: "approved", + type: "partner", + industry: "healthcare", + annual_revenue: 8e6, + number_of_employees: 400, + // The one Canadian account: still inside north_america_territory, and the + // reason that rule's `$in` list is not a single-country list in disguise. + phone: "+1-416-555-0400", + billing_address: { street: "181 Bay Street, Suite 2200", city: "Toronto", state: "ON", postalCode: "M5J 2T3", country: "CA" }, + website: "https://starkmed.example.com", + tier: "mid_market", + segment: "stable", + // `at_risk` rather than `churning`, and the distinction is the reason + // this row can exist at all: a partner whose pilot was WON and whose + // expansion then died on a capital freeze can be at risk, but it was + // never a subscription that could churn. The records say it — `Stark + // Expansion (Lost)` closed `no_budget` 60 days ago and the partnership + // contract is still in legal review — and the panel's criterion admits + // both values, so the honest severity is also the one that flags. + // + // Diverging from `segment: 'stable'` is deliberate, the same split + // Wayne demonstrates below: `segment` is how the book classifies the + // account, `health_score` is what a person asserts about it. The clock + // stays at today(), so like Wayne this row is outside every windowed + // panel on that report: it reaches `csm_flagged_accounts` and no other + // block. + health_score: "at_risk", + // The completed 'Send welcome package' task bubbles here on every seed + // load, so this has ALWAYS resolved to today — the previous `daysAgo(5)` + // was authored and then overwritten before anyone could read it. + last_activity_date: cel31`today()` + }, + { + name: "Wayne Enterprises", + approval_status: "approved", + type: "customer", + industry: "technology", + annual_revenue: 25e6, + number_of_employees: 2e3, + phone: "+1-650-555-0500", + billing_address: { street: "3000 Hanover Street", city: "Palo Alto", state: "CA", postalCode: "94304", country: "US" }, + website: "https://wayne.example.com", + tier: "strategic", + segment: "growth", + // CHURNING, with the clock still running — the population + // `csm_flagged_accounts` exists for (#1414). Every DERIVED signal on + // this row reads healthy: an operations rollout closed four days ago, a + // licence sits at 80% two weeks from signature, three meetings were held + // this month. The CSM who has been in the room says the account is going + // anyway, and `health_score` is the only churn signal in the model a + // person ASSERTS — which is why the panel that reads it is first on the + // report and carries no time window. + // + // ⛔ Do not "correct" this to `at_risk` to agree with the pipeline, and + // ⛔ do not stop the clock to agree with the health score: either edit + // folds the row back into `at_risk_accounts` (60-day window) and the + // flagged panel goes back to restating its neighbour. + health_score: "churning", + // Held: negotiation meeting, security-addendum call, governance webinar. + last_activity_date: cel31`today()` + }, + { + name: "Northwind Energy", + approval_status: "approved", + type: "prospect", + industry: "energy", + annual_revenue: 18e6, + number_of_employees: 1100, + // europe_territory, half 1: DE. + phone: "+49-89-5550-0600", + billing_address: { street: "Leopoldstrasse 21", city: "Munich", state: "BY", postalCode: "80802", country: "DE" }, + website: "https://northwind.example.com", + tier: "enterprise", + segment: "net_new", + // QUIET 30+ — the field-service pilot was lost 80 days ago and the grid + // program has not been worked since. The discovery workshop is booked, + // not held. + last_activity_date: cel31`daysAgo(41)`, + description: "A regional energy provider evaluating a unified operations and customer-data platform." + }, + { + name: "Vertex Analytics", + approval_status: "approved", + type: "customer", + industry: "software", + annual_revenue: 95e5, + number_of_employees: 420, + phone: "+1-512-555-0700", + billing_address: { street: "600 Congress Avenue, Floor 14", city: "Austin", state: "TX", postalCode: "78701", country: "US" }, + website: "https://vertex.example.com", + tier: "enterprise", + segment: "growth", + health_score: "healthy", + // Held: rollout meeting, analytics demo, committee call, retrospective. + last_activity_date: cel31`today()`, + description: "An analytics SaaS customer expanding usage from the data team to its revenue organization." + }, + { + name: "Lattice Education", + approval_status: "approved", + type: "customer", + industry: "education", + annual_revenue: 68e5, + number_of_employees: 320, + // europe_territory, half 2 — and the alias fixture. `UK` is not ISO + // 3166-1 alpha-2 (`GB` is); it is an ACCEPTED SPELLING in + // `src/sales/objects/_territory.ts`, so this row proves on stock data that a + // legacy spelling still lands in `emea` (#639). No `state`: an address + // without a subdivision is a normal shape, and only `country` is read. + phone: "+44-20-7946-0800", + billing_address: { street: "20 Fenchurch Street", city: "London", postalCode: "EC3M 3BY", country: "UK" }, + website: "https://lattice.example.com", + tier: "mid_market", + segment: "stable", + health_score: "healthy", + // Signed the analytics expansion six days ago; the renewal review is + // booked, not held, so nothing bubbles and this age stands. + last_activity_date: cel31`daysAgo(6)`, + description: "A higher-education technology company consolidating admissions, student-success and alumni workflows." + }, + { + name: "Apex Logistics", + approval_status: "approved", + type: "prospect", + industry: "logistics", + annual_revenue: 22e6, + number_of_employees: 1400, + // `territory == "other"` on purpose: without a record that matches + // neither rule, "the rules partition the accounts" is unfalsifiable — + // a match-all regression would look identical to a working one. `SG` is + // a real country the staffed territories do not cover, which is exactly + // what `other` is for (#639) — it is a stated classification here, not a + // blank. + phone: "+65-6555-0900", + billing_address: { street: "10 Marina Boulevard, #30-01", city: "Singapore", postalCode: "018983", country: "SG" }, + website: "https://apexlogistics.example.com", + tier: "enterprise", + segment: "net_new", + // QUIET 90+ — a lost compliance deal 110 days ago and a data-hub + // evaluation that has been silent for a quarter. Only a booked + // re-engagement call. + last_activity_date: cel31`daysAgo(104)`, + description: "A fast-growing logistics provider assessing a modern data hub for its operations and commercial teams." + } + ] +}); +var contacts = defineSeed(Contact, { + mode: "upsert", + externalId: "email", + records: [ + { + salutation: "mr", + first_name: "John", + last_name: "Smith", + email: "john.smith@acme.example.com", + phone: "+1-415-555-0101", + title: "VP of Engineering", + department: "engineering", + crm_account: "Acme Corporation", + is_primary: true + }, + { + salutation: "ms", + first_name: "Sarah", + last_name: "Johnson", + email: "sarah.j@globex.example.com", + phone: "+1-312-555-0201", + title: "Chief Procurement Officer", + department: "executive", + crm_account: "Globex Industries", + is_primary: true + }, + { + salutation: "dr", + first_name: "Michael", + last_name: "Chen", + email: "mchen@initech.example.com", + phone: "+1-212-555-0301", + title: "Director of Operations", + department: "operations", + crm_account: "Initech Solutions", + is_primary: true + }, + { + salutation: "ms", + first_name: "Emily", + last_name: "Davis", + email: "emily.d@starkmed.example.com", + phone: "+1-617-555-0401", + title: "Head of Partnerships", + department: "sales", + crm_account: "Stark Medical", + is_primary: true + }, + { + salutation: "mr", + first_name: "Robert", + last_name: "Wilson", + email: "rwilson@wayne.example.com", + phone: "+1-650-555-0501", + title: "CTO", + department: "engineering", + crm_account: "Wayne Enterprises", + is_primary: true + }, + { + salutation: "ms", + first_name: "Olivia", + last_name: "Chen", + email: "olivia.chen@northwind.example.com", + phone: "+1-303-555-0601", + title: "VP of Digital Operations", + department: "operations", + crm_account: "Northwind Energy", + is_primary: true + }, + { + salutation: "mr", + first_name: "Ethan", + last_name: "Brooks", + email: "ethan.brooks@vertex.example.com", + phone: "+1-512-555-0701", + title: "Chief Revenue Officer", + department: "executive", + crm_account: "Vertex Analytics", + is_primary: true + }, + { + salutation: "ms", + first_name: "Priya", + last_name: "Shah", + email: "priya.shah@lattice.example.com", + phone: "+1-617-555-0801", + title: "VP of Student Success", + department: "operations", + crm_account: "Lattice Education", + is_primary: true + }, + { + salutation: "mr", + first_name: "Marcus", + last_name: "Reed", + email: "marcus.reed@apexlogistics.example.com", + phone: "+1-404-555-0901", + title: "Director of Commercial Systems", + department: "operations", + crm_account: "Apex Logistics", + is_primary: true + } + ] +}); +var DISQUALIFICATION_REASONS = [ + { reason: "no_budget", note: "No budget approved for this fiscal year \u2014 revisit next planning cycle." }, + { reason: "not_a_fit", note: "Requirements sit outside what the product covers today." }, + { reason: "wrong_persona", note: "Contact has no say in the buying decision and no path to an owner." }, + { reason: "unreachable", note: "Six touches across email and phone over four weeks, no response." } +]; +var leads = defineSeed(Lead, { + mode: "upsert", + externalId: "email", + records: [ + { + first_name: "Alice", + last_name: "Martinez", + company: "NextGen Retail", + email: "alice@nextgenretail.example.com", + phone: "+1-503-555-0600", + status: "new", + lead_source: "web", + industry: "retail", + rating: 3, + next_followup_date: cel31`daysFromNow(2)` + }, + { + first_name: "David", + last_name: "Kim", + company: "EduTech Labs", + email: "dkim@edutechlabs.example.com", + phone: "+1-408-555-0700", + status: "contacted", + lead_source: "referral", + industry: "education", + rating: 4, + next_followup_date: cel31`daysFromNow(1)`, + // A seeded `held` event names this lead, and `event_activity_bubble` + // stamps `last_contacted_date` with the SEED MOMENT rather than the + // event's own timestamp — so an authored age here would be overwritten + // the instant it was written (doctrine rule 2 in `./_shared.ts`). Day + // granularity is the honest match: the seed writes today's UTC midnight, + // the bubble writes today's instant, and both render as "today". + last_contacted_date: cel31`today()` + }, + { + first_name: "Lisa", + last_name: "Thompson", + company: "CloudFirst Inc", + email: "lisa.t@cloudfirst.example.com", + phone: "+1-206-555-0800", + status: "qualified", + lead_source: "event", + industry: "technology", + // WHOLE stars only. `lead.hook.ts` rounds its computed score to an + // integer because "half values rendered inconsistently in the star + // widget", and the hook leaves an explicitly seeded number alone — so a + // seeded 4.5 was the one rating in the system the contract could never + // produce, and it rendered as the broken half-star it was meant to + // prevent (#591). + rating: 5, + next_followup_date: cel31`daysFromNow(0)`, + // Same as David Kim above: a `held` qualification call names this lead. + last_contacted_date: cel31`today()` + }, + // ─── Generated demo leads — spread across 6 months for monthly-bucket reports + // (`LeadInflowByMonthSourceReport`). Each `last_contacted_date` lives in a + // distinct month / source pair so the matrix has multiple cells populated. + ...[ + { fn: "Noah", ln: "Patel", co: "Vertex Analytics", src: "web", ind: "technology", age: 7 }, + { fn: "Maya", ln: "Singh", co: "BluePeak Logistics", src: "referral", ind: "logistics", age: 14 }, + { fn: "Owen", ln: "Becker", co: "Northwind Energy", src: "event", ind: "energy", age: 21 }, + { fn: "Sara", ln: "Lopez", co: "Helios Solar", src: "partner", ind: "energy", age: 28 }, + { fn: "Leo", ln: "Vance", co: "CleanCart", src: "web", ind: "retail", age: 38 }, + { fn: "Iris", ln: "Okafor", co: "PulseHealth", src: "cold_call", ind: "healthcare", age: 45 }, + { fn: "Ravi", ln: "Mehta", co: "Foundry Robotics", src: "event", ind: "manufacturing", age: 52 }, + { fn: "Tess", ln: "Brown", co: "Lattice Education", src: "referral", ind: "education", age: 67 }, + { fn: "Marco", ln: "Ricci", co: "Aurora Travel", src: "advertisement", ind: "hospitality", age: 74 }, + { fn: "Pia", ln: "Anand", co: "Citrine Finance", src: "partner", ind: "finance", age: 81 }, + { fn: "Jonas", ln: "Holt", co: "Polar Cargo", src: "web", ind: "logistics", age: 95 }, + { fn: "Anya", ln: "Volkov", co: "RedOak Realty", src: "cold_call", ind: "real_estate", age: 102 }, + { fn: "Theo", ln: "Park", co: "Skyline Media", src: "advertisement", ind: "media", age: 116 }, + { fn: "Wren", ln: "Garcia", co: "Maple Bakery Group", src: "event", ind: "retail", age: 123 }, + { fn: "Hugo", ln: "Dubois", co: "Nimbus Aerospace", src: "referral", ind: "manufacturing", age: 138 }, + { fn: "Lena", ln: "Fischer", co: "Granite Insurance", src: "partner", ind: "finance", age: 145 }, + { fn: "Kai", ln: "Watanabe", co: "Coral Reef Hotels", src: "web", ind: "hospitality", age: 162 }, + { fn: "Mira", ln: "Costa", co: "Atlas Construction", src: "cold_call", ind: "other", age: 175 } + ].map((l, i) => { + const domain = `${l.co.toLowerCase().replace(/\s+/g, "")}.example.com`; + const status = ["new", "contacted", "qualified", "unqualified"][i % 4]; + return { + first_name: l.fn, + last_name: l.ln, + company: l.co, + email: `${l.fn.toLowerCase()}.${l.ln.toLowerCase()}@${domain}`, + phone: `+1-555-01${String(i).padStart(2, "0")}-${String(1e3 + i * 7)}`, + status, + lead_source: l.src, + industry: l.ind, + rating: 1 + i * 7 % 5, + last_contacted_date: celDaysAgo(l.age), + // The qualification fields were left blank on every generated lead, so + // the detail page's Contact / Lead Detail / Description sections had + // nothing to render (they also drop whatever the highlights strip + // already shows, so all four collapsed to nothing) and the demo read + // like a half-finished import. + title: ["VP Operations", "Head of IT", "Director of Sales", "COO", "Procurement Lead"][i % 5], + mobile: `+1-555-02${String(i).padStart(2, "0")}-${String(2e3 + i * 3)}`, + website: `https://${domain}`, + annual_revenue: 2e6 + i * 37e5 % 9e7, + number_of_employees: 25 + i * 137 % 4800, + description: `Inbound via ${l.src.replace(/_/g, " ")}. Evaluating a CRM to replace spreadsheets across their ${l.ind.replace(/_/g, " ")} operation.`, + ...status === "unqualified" ? { + disqualification_reason: DISQUALIFICATION_REASONS[(i >> 2) % DISQUALIFICATION_REASONS.length].reason, + notes: DISQUALIFICATION_REASONS[(i >> 2) % DISQUALIFICATION_REASONS.length].note + } : {} + }; + }) + ] +}); +var OPPORTUNITY_LINES = { + "Acme Platform Upgrade": [ + { product: "ObjectStack Platform", quantity: 2, unit_price: 5e4, discount: 10, description: "Enterprise edition \u2014 NA + EMEA production tenants (multi-year discount)." }, + { product: "Premium Support", quantity: 1, unit_price: 25e3, description: "24\xD77 premium support with a named TAM." }, + { product: "AI Agent Seat (Annual)", quantity: 35, unit_price: 1e3, description: "Agent seats for the Ops organization." } + ], + "Globex Manufacturing Suite": [ + { product: "ObjectStack Platform", quantity: 1, unit_price: 5e4, description: "Enterprise edition \u2014 one shared tenant serving all six manufacturing sites." }, + { product: "Admin Training Workshop", quantity: 4, unit_price: 6e3, description: "Four workshop days, one per regional plant cluster." }, + { product: "Standard Support", quantity: 1, unit_price: 9e3, description: "Business-hours support for the first year." }, + { product: "AI Agent Seat (Annual)", quantity: 12, unit_price: 1e3, description: "Agent seats for the plant operations leads." } + ], + "Wayne Enterprise License": [ + { product: "ObjectStack Platform", quantity: 20, unit_price: 5e4, discount: 15, description: "Enterprise-wide license, volume discount at 20 tenants." }, + { product: "Premium Support", quantity: 4, unit_price: 25e3, description: "Premium support across four business units." }, + { product: "AI Agent Seat (Annual)", quantity: 250, unit_price: 1e3, description: "Agent seats for the global revenue organization." } + ], + "Initech Cloud Migration": [ + { product: "Data Migration Services", quantity: 1, unit_price: 35e3, description: "Migration off the legacy on-premise CRM." }, + { product: "Cloud Hosting (Annual)", quantity: 2, unit_price: 12e3, description: "Managed hosting, primary + DR region." }, + { product: "Standard Support", quantity: 1, unit_price: 9e3, description: "Business-hours support for the first year." }, + { product: "AI Agent Seat (Annual)", quantity: 12, unit_price: 1e3, description: "Agent seats for the service desk." } + ], + "Acme Annual Renewal 2025": [ + { product: "ObjectStack Platform", quantity: 3, unit_price: 5e4, description: "Renewal of the three production tenants." }, + { product: "Premium Support", quantity: 1, unit_price: 25e3, description: "Premium support renewal." }, + { product: "AI Agent Seat (Annual)", quantity: 45, unit_price: 1e3, description: "Seat expansion driven by the new EMEA team." } + ], + "Stark Medical Pilot": [ + { product: "ObjectStack Platform", quantity: 2, unit_price: 5e4, description: "Pilot tenants for two clinical service lines." }, + { product: "Standard Support", quantity: 1, unit_price: 9e3, description: "Standard support during the pilot." }, + { product: "Admin Training Workshop", quantity: 6, unit_price: 6e3, description: "Six workshop days for the clinical operations admins." } + ], + "Wayne Q1 Expansion": [ + { product: "ObjectStack Platform", quantity: 6, unit_price: 5e4, description: "Expansion into six additional subsidiaries." }, + { product: "Premium Support", quantity: 2, unit_price: 25e3, description: "Premium support for the expanded footprint." }, + { product: "AI Agent Seat (Annual)", quantity: 30, unit_price: 1e3, description: "Agent seats for the expansion teams." } + ], + "Globex Training Package": [ + { product: "Admin Training Workshop", quantity: 10, unit_price: 6e3, description: "Ten workshop days across the plant admin community." }, + { product: "AI Agent Seat (Annual)", quantity: 5, unit_price: 1e3, description: "Agent seats for the training sandbox." } + ], + "Initech Phase 1": [ + { product: "Implementation Services", quantity: 1, unit_price: 75e3, description: "Phase 1 implementation: accounts, contacts, pipeline." }, + { product: "Standard Support", quantity: 1, unit_price: 9e3, description: "Standard support for phase 1." }, + { product: "AI Agent Seat (Annual)", quantity: 6, unit_price: 1e3, description: "Agent seats for the phase-1 pilot group." } + ], + "Acme Add-on (Lost)": [ + { product: "Analytics Add-on", quantity: 2, unit_price: 22e3, description: "Marketing analytics for two business units." }, + { product: "Integration Connector Pack", quantity: 1, unit_price: 16e3, description: "Marketing-automation connector pack." }, + { product: "Sandbox Environment (Annual)", quantity: 2, unit_price: 7500, description: "Two sandboxes for the marketing build-out." } + ], + "Stark Expansion (Lost)": [ + { product: "ObjectStack Platform", quantity: 2, unit_price: 5e4, description: "Two additional clinical tenants." }, + { product: "Field Service Mobile", quantity: 1, unit_price: 14e3, description: "Field service mobile for the device-servicing team." }, + { product: "AI Agent Seat (Annual)", quantity: 6, unit_price: 1e3, description: "Agent seats for the service coordinators." } + ], + "Globex Line Expansion (Lost)": [ + { product: "ObjectStack Platform", quantity: 2, unit_price: 5e4, description: "Two further production-line tenants." }, + { product: "Integration Connector Pack", quantity: 1, unit_price: 16e3, description: "Connector pack for the line-control systems." }, + { product: "AI Agent Seat (Annual)", quantity: 8, unit_price: 1e3, description: "Agent seats for the line supervisors." } + ], + "Northwind Field Service Pilot (Lost)": [ + { product: "Field Service Mobile", quantity: 1, unit_price: 14e3, description: "Field-service mobile for the metering crews." }, + { product: "Standard Support", quantity: 1, unit_price: 9e3, description: "Business-hours support during the pilot." }, + { product: "AI Agent Seat (Annual)", quantity: 10, unit_price: 1e3, description: "Agent seats for the dispatch desk." } + ], + "Apex Compliance Reporting (Lost)": [ + { product: "Analytics Add-on", quantity: 1, unit_price: 22e3, description: "Regulatory reporting pack for fleet compliance." }, + { product: "Sandbox Environment (Annual)", quantity: 1, unit_price: 7500, description: "Sandbox for the compliance rule build-out." }, + { product: "AI Agent Seat (Annual)", quantity: 6, unit_price: 1e3, description: "Agent seats for the compliance analysts." } + ], + "Northwind Grid Modernization": [ + { product: "ObjectStack Platform", quantity: 1, unit_price: 5e4, description: "Enterprise edition for grid, field and customer operations." }, + { product: "Field Service Mobile", quantity: 1, unit_price: 14e3, description: "Field-service mobile for the grid maintenance crews." }, + { product: "Sandbox Environment (Annual)", quantity: 1, unit_price: 7500, description: "Sandbox for the operational-data assessment." }, + { product: "AI Agent Seat (Annual)", quantity: 15, unit_price: 1e3, description: "Agent seats for the control-room pilot." } + ], + "Lattice Student Success Platform": [ + { product: "ObjectStack Platform (SMB Edition)", quantity: 2, unit_price: 18e3, description: "Student-success tenants for the two pilot colleges." }, + { product: "Admin Training Workshop", quantity: 2, unit_price: 6e3, description: "Two workshop days for the student-success advisers." }, + { product: "AI Agent Seat (Annual)", quantity: 5, unit_price: 1e3, description: "Agent seats for the advising team." } + ], + "Vertex Analytics Expansion": [ + { product: "Analytics Add-on", quantity: 2, unit_price: 22e3, description: "Analytics for the sales and marketing teams." }, + { product: "Premium Support", quantity: 1, unit_price: 25e3, description: "Premium support for the expanded footprint." }, + { product: "AI Agent Seat (Annual)", quantity: 10, unit_price: 1e3, description: "Agent seats for the revenue operations team." } + ], + "Apex Logistics Data Hub": [ + { product: "ObjectStack Platform", quantity: 1, unit_price: 5e4, description: "Data-hub tenant shared by commercial, operations and finance." }, + { product: "Data Migration Services", quantity: 1, unit_price: 35e3, description: "Consolidation of four fragmented commercial systems." }, + { product: "AI Agent Seat (Annual)", quantity: 8, unit_price: 1e3, description: "Agent seats for the commercial operations team." } + ], + "Lattice Education Renewal": [ + { product: "ObjectStack Platform", quantity: 1, unit_price: 5e4, description: "Renewal of the institution-wide tenant." }, + { product: "Analytics Add-on", quantity: 1, unit_price: 22e3, description: "Expanded analytics package for the renewal term." }, + { product: "AI Agent Seat (Annual)", quantity: 15, unit_price: 1e3, description: "Student-success automation seats." } + ], + "Vertex Enterprise Rollout": [ + { product: "ObjectStack Platform", quantity: 1, unit_price: 5e4, discount: 20, description: "Phase-one tenant for the first region, with data-residency controls (multi-phase commitment discount)." }, + { product: "Data Migration Services", quantity: 1, unit_price: 35e3, description: "Phase-one migration of the regional revenue data." }, + { product: "Standard Support", quantity: 1, unit_price: 9e3, description: "Business-hours support for phase one." }, + { product: "AI Agent Seat (Annual)", quantity: 10, unit_price: 1e3, description: "Agent seats for the first rollout wave." } + ], + // Campaign-attributed wins — see the campaign metrics note below. + "Lattice Analytics Expansion": [ + { product: "Analytics Add-on", quantity: 2, unit_price: 22e3, description: "Analytics for admissions and alumni engagement." }, + { product: "Admin Training Workshop", quantity: 1, unit_price: 6e3, description: "Analytics enablement day for the institutional-research team." }, + { product: "AI Agent Seat (Annual)", quantity: 20, unit_price: 1e3, description: "Agent seats for the admissions team." } + ], + "Wayne Operations Module Rollout": [ + { product: "ObjectStack Platform", quantity: 2, unit_price: 5e4, description: "Operations tenants for two manufacturing divisions." }, + { product: "Standard Support", quantity: 1, unit_price: 9e3, description: "Standard support for the operations rollout." }, + { product: "AI Agent Seat (Annual)", quantity: 11, unit_price: 1e3, description: "Agent seats for the operations planners." } + ], + "Vertex Developer Platform Adoption": [ + { product: "ObjectStack Platform", quantity: 3, unit_price: 5e4, description: "Developer platform tenants for three product teams." }, + { product: "Integration Connector Pack", quantity: 1, unit_price: 16e3, description: "Connector pack for the internal data warehouse." }, + { product: "Analytics Add-on", quantity: 1, unit_price: 22e3, description: "Product-usage analytics for the platform team." }, + { product: "AI Agent Seat (Annual)", quantity: 12, unit_price: 1e3, description: "Agent seats for the developer-experience team." } + ] +}; +var dealValue = (opportunityName, probability) => { + const lines = OPPORTUNITY_LINES[opportunityName]; + if (!lines) throw new Error(`Seed error: no line items authored for opportunity "${opportunityName}"`); + const amount = linesTotal(lines); + return { amount, expected_revenue: Math.round(amount * probability) / 100 }; +}; +var opportunities = defineSeed(Opportunity, { + mode: "upsert", + externalId: "name", + records: [ + { + name: "Acme Platform Upgrade", + crm_account: "Acme Corporation", + ...dealValue("Acme Platform Upgrade", 60), + stage: "proposal", + probability: 60, + close_date: cel31`daysFromNow(30)`, + type: "existing_upgrade", + forecast_category: "commit", + lead_source: "web", + stage_entry_date: celDaysAgo(12), + description: `Upgrade from Standard to Enterprise edition for the +NA + EMEA teams. Drivers: (1) AI agent governance becomes a hard +requirement after their internal compliance review, (2) advanced +analytics seats for the Ops org, (3) priority support SLA.`, + // This sentence used to DATE the workshop itself ("the week of + // close_date - 14d" => daysFromNow(16)) while the seeded event had it at + // daysFromNow(6) and a seeded task chased it at daysFromNow(7) — three + // records, three answers (#1660). The date now lives in exactly ONE + // place, the `crm_event` row in service.seed.ts, and this prose states + // only what stays true however that event is scheduled: it is booked, + // and its invitation has gone out (the attendee builder clamps + // `invited_date` at daysAgo(0), so a planned event's invite is never in + // the future). Re-dating the event therefore cannot strand this line. + // Do not put a date back here, absolute OR relative: a second copy is + // a second thing to drift. + next_step: `Send the revised proposal (Enterprise edition, 18-month term, 12% multi-year discount) to Jordan Park by EOW. The AI governance workshop with their compliance team is already booked and the invitation is out.` + }, + { + name: "Globex Manufacturing Suite", + crm_account: "Globex Industries", + ...dealValue("Globex Manufacturing Suite", 25), + stage: "qualification", + probability: 25, + close_date: cel31`daysFromNow(60)`, + type: "new_business", + forecast_category: "pipeline", + lead_source: "referral", + stage_entry_date: celDaysAgo(45) + }, + { + name: "Wayne Enterprise License", + crm_account: "Wayne Enterprises", + ...dealValue("Wayne Enterprise License", 80), + stage: "negotiation", + probability: 80, + close_date: cel31`daysFromNow(14)`, + type: "new_business", + forecast_category: "commit", + lead_source: "partner", + stage_entry_date: celDaysAgo(7) + }, + { + name: "Initech Cloud Migration", + crm_account: "Initech Solutions", + ...dealValue("Initech Cloud Migration", 40), + stage: "needs_analysis", + probability: 40, + close_date: cel31`daysFromNow(45)`, + type: "existing_upgrade", + forecast_category: "best_case", + lead_source: "event", + stage_entry_date: celDaysAgo(38) + }, + // ─── Closed Won deals (powers KPIs & revenue trends) ──────────────── + { + name: "Acme Annual Renewal 2025", + crm_account: "Acme Corporation", + ...dealValue("Acme Annual Renewal 2025", 100), + stage: "closed_won", + probability: 100, + close_date: cel31`daysAgo(15)`, + stage_entry_date: cel31`daysAgo(15)`, + type: "existing_renewal", + forecast_category: "closed", + lead_source: "partner", + win_reason: "relationship", + description: `Annual renewal of the Acme Standard subscription, signed two weeks ahead of the renewal date. 22% YoY uplift driven by seat expansion in the new EMEA team. Multi-year option declined this round \u2014 they want to see how the platform upgrade lands first.` + }, + { + name: "Stark Medical Pilot", + crm_account: "Stark Medical", + ...dealValue("Stark Medical Pilot", 100), + stage: "closed_won", + probability: 100, + close_date: cel31`daysAgo(50)`, + stage_entry_date: cel31`daysAgo(50)`, + type: "new_business", + forecast_category: "closed", + lead_source: "event", + win_reason: "best_fit" + }, + { + name: "Wayne Q1 Expansion", + crm_account: "Wayne Enterprises", + ...dealValue("Wayne Q1 Expansion", 100), + stage: "closed_won", + probability: 100, + close_date: cel31`daysAgo(95)`, + stage_entry_date: cel31`daysAgo(95)`, + type: "existing_upgrade", + forecast_category: "closed", + lead_source: "web", + win_reason: "better_product" + }, + { + name: "Globex Training Package", + crm_account: "Globex Industries", + ...dealValue("Globex Training Package", 100), + stage: "closed_won", + probability: 100, + close_date: cel31`daysAgo(140)`, + stage_entry_date: cel31`daysAgo(140)`, + type: "new_business", + forecast_category: "closed", + lead_source: "referral", + win_reason: "better_support" + }, + { + name: "Initech Phase 1", + crm_account: "Initech Solutions", + ...dealValue("Initech Phase 1", 100), + stage: "closed_won", + probability: 100, + close_date: cel31`daysAgo(200)`, + stage_entry_date: cel31`daysAgo(200)`, + type: "new_business", + forecast_category: "closed", + lead_source: "web", + win_reason: "better_price" + }, + // ─── Campaign-attributed wins ─────────────────────────────────────── + // `crm_campaign` is what `campaign_attribution_refresh` counts + // (`num_opportunities` / `num_won_opportunities` / the summed + // `actual_revenue`) — on every opportunity insert, update and delete, not + // once at completion. Before #591 not one opportunity carried it, so those + // three metrics were structurally zero and every campaign's seeded + // `actual_revenue` was a number the hook would have overwritten on the + // first attributed write. + // These three wins are what make the marketing ROI numbers below TRUE. + { + name: "Lattice Analytics Expansion", + crm_account: "Lattice Education", + primary_contact: "priya.shah@lattice.example.com", + crm_campaign: "Q3 Enterprise Email Nurture", + ...dealValue("Lattice Analytics Expansion", 100), + stage: "closed_won", + probability: 100, + close_date: cel31`daysAgo(6)`, + stage_entry_date: cel31`daysAgo(6)`, + type: "existing_expansion", + forecast_category: "closed", + lead_source: "email_campaign", + win_reason: "best_fit", + description: "Analytics package for admissions and alumni engagement, sourced from the enterprise nurture track." + }, + { + name: "Wayne Operations Module Rollout", + crm_account: "Wayne Enterprises", + primary_contact: "rwilson@wayne.example.com", + crm_campaign: "Operations Platform Launch", + ...dealValue("Wayne Operations Module Rollout", 100), + stage: "closed_won", + probability: 100, + close_date: cel31`daysAgo(4)`, + stage_entry_date: cel31`daysAgo(4)`, + type: "existing_upgrade", + forecast_category: "closed", + lead_source: "content", + description: "Operations module for two manufacturing divisions, closed off the operations-platform launch program.", + win_reason: "relationship" + }, + { + name: "Vertex Developer Platform Adoption", + crm_account: "Vertex Analytics", + primary_contact: "ethan.brooks@vertex.example.com", + crm_campaign: "Developer Content Marketing Push", + ...dealValue("Vertex Developer Platform Adoption", 100), + stage: "closed_won", + probability: 100, + close_date: cel31`daysAgo(6)`, + stage_entry_date: cel31`daysAgo(6)`, + type: "existing_expansion", + forecast_category: "closed", + lead_source: "content", + description: "Three product teams adopted the developer platform after the technical content series.", + win_reason: "better_product" + }, + // ─── Closed Lost deals (powers win-rate + loss-reason analytics) ──── + // + // Five losses across five distinct `loss_reason` values, and every one of + // them is now MANDATORY rather than decorative: `loss_reason` is + // `requiredWhen` stage is `closed_lost` (#593), so a seeded lost deal + // without one is rejected by the engine at seed time — the demo database + // cannot boot with the empty column that made the loss-reason widget + // unbuildable in the first place. + // + // Their `lead_source` values are chosen so that the sources carrying a loss + // ALSO carry a win (`web`, `referral`, `content`), plus two sources that + // only ever lost (`cold_call`, `advertisement`). That is what makes + // `win_rate_by_lead_source` a real measurement instead of a column of + // 100%s: three rows where both halves of the ratio move, and two rows that + // show what an all-loss source looks like. + { + name: "Acme Add-on (Lost)", + crm_account: "Acme Corporation", + ...dealValue("Acme Add-on (Lost)", 0), + stage: "closed_lost", + probability: 0, + close_date: cel31`daysAgo(25)`, + stage_entry_date: cel31`daysAgo(25)`, + type: "existing_upgrade", + forecast_category: "omitted", + lead_source: "cold_call", + loss_reason: "timing", + loss_details: "Marketing is locked into a 2-year HubSpot contract; the buying window opens when that renews.", + // This line used to end "Revisit in Q3" — a hand-typed calendar quarter + // on a record whose `close_date` is `daysAgo(25)`, so the quarter it told + // a rep to wait for is the one the deal was already lost in, and it + // contradicted this record's own `loss_details`: a 2-year lock does not + // reopen inside the quarter the deal closed in (#1712). Same ruling as + // the `next_step` block above (#1660): no date goes back into this prose, + // absolute OR relative. The renewal is the anchor that stays true however + // this record is dated — which is how `loss_details` and the account + // description already state it. + description: `Tried to bolt on the Marketing Cloud module via cold outbound. Lost because Acme's marketing org is already on a 2-year HubSpot contract. Revisit when that contract comes up for renewal \u2014 that is when the buying window opens.` + }, + { + name: "Stark Expansion (Lost)", + crm_account: "Stark Medical", + ...dealValue("Stark Expansion (Lost)", 0), + stage: "closed_lost", + probability: 0, + close_date: cel31`daysAgo(60)`, + stage_entry_date: cel31`daysAgo(60)`, + type: "new_business", + forecast_category: "omitted", + lead_source: "advertisement", + loss_reason: "no_budget", + loss_details: "Capital freeze on non-clinical systems for the rest of the fiscal year." + }, + { + name: "Globex Line Expansion (Lost)", + crm_account: "Globex Industries", + ...dealValue("Globex Line Expansion (Lost)", 0), + stage: "closed_lost", + probability: 0, + close_date: cel31`daysAgo(35)`, + stage_entry_date: cel31`daysAgo(35)`, + type: "existing_expansion", + forecast_category: "omitted", + lead_source: "referral", + loss_reason: "competitor", + loss_details: "Incumbent MES vendor bundled the two additional lines into an existing master agreement.", + description: "Expansion into two further production lines, lost to the incumbent MES vendor on bundling." + }, + { + name: "Northwind Field Service Pilot (Lost)", + crm_account: "Northwind Energy", + ...dealValue("Northwind Field Service Pilot (Lost)", 0), + stage: "closed_lost", + probability: 0, + close_date: cel31`daysAgo(80)`, + stage_entry_date: cel31`daysAgo(80)`, + type: "new_business", + forecast_category: "omitted", + lead_source: "web", + loss_reason: "price", + loss_details: "Per-technician pricing landed ~30% above the budget the operations director had approved.", + description: "Field-service pilot for the metering crews, lost on price against a cheaper point solution." + }, + { + name: "Apex Compliance Reporting (Lost)", + crm_account: "Apex Logistics", + ...dealValue("Apex Compliance Reporting (Lost)", 0), + stage: "closed_lost", + probability: 0, + close_date: cel31`daysAgo(110)`, + stage_entry_date: cel31`daysAgo(110)`, + type: "new_business", + forecast_category: "omitted", + lead_source: "content", + loss_reason: "features", + loss_details: "No native hours-of-service audit trail; the compliance team could not sign off without it.", + description: "Regulatory reporting pack for the fleet compliance team, lost on a missing audit-trail capability." + }, + // ─── Curated active pipeline ───────────────────────────────────── + // Two cards in each active stage make the kanban immediately legible in + // a customer demo. They also tell a coherent sales story instead of + // overwhelming the board with anonymous generated rows. + // + // PRICED TO STAY DRAGGABLE (#1902). A deal at or above + // `LARGE_DEAL_AMOUNT` is born into `opportunity_approval_on_create`, whose + // approval nodes hold the record with `lockRecord: true` — on the board + // that card refuses every drag with `RECORD_LOCKED`. When nine of the ten + // open deals sat over the line, the one board a demo opens first was + // frozen. So exactly TWO open deals exhibit the approval flow, one per + // tier, and both are in the block above: `Acme Platform Upgrade` + // (manager review only, $100K–$500K) and `Wayne Enterprise License` + // (manager, then director sign-off, over `HIGH_VALUE_DEAL_AMOUNT`). Every + // deal in this block is priced under the line, so each active stage keeps + // at least one card that moves. `test/seed-consistency.test.ts` pins the + // two by name — re-pricing a deal here over $100K goes red there. + { + name: "Northwind Grid Modernization", + crm_account: "Northwind Energy", + primary_contact: "olivia.chen@northwind.example.com", + ...dealValue("Northwind Grid Modernization", 10), + stage: "prospecting", + probability: 10, + close_date: cel31`daysFromNow(72)`, + type: "new_business", + forecast_category: "pipeline", + lead_source: "webinar", + stage_entry_date: celDaysAgo(4), + description: "Northwind is assessing a unified grid-modernization program after an executive webinar.", + next_step: "Confirm discovery participants and agree the operational-data assessment scope." + }, + { + name: "Lattice Student Success Platform", + crm_account: "Lattice Education", + primary_contact: "priya.shah@lattice.example.com", + crm_campaign: "Developer Content Marketing Push", + ...dealValue("Lattice Student Success Platform", 10), + stage: "prospecting", + probability: 10, + close_date: cel31`daysFromNow(96)`, + type: "new_business", + forecast_category: "pipeline", + lead_source: "content", + stage_entry_date: celDaysAgo(11), + description: "A new student-success initiative sourced from the higher-education content series.", + next_step: "Invite the operations sponsor to the discovery workshop." + }, + { + name: "Vertex Analytics Expansion", + crm_account: "Vertex Analytics", + primary_contact: "ethan.brooks@vertex.example.com", + ...dealValue("Vertex Analytics Expansion", 25), + stage: "qualification", + probability: 25, + close_date: cel31`daysFromNow(52)`, + type: "existing_expansion", + forecast_category: "pipeline", + lead_source: "partner", + stage_entry_date: celDaysAgo(8), + description: "Vertex wants to extend the platform from its data team to the full revenue organization.", + next_step: "Validate the buying committee, budget owner and expansion timeline." + }, + { + name: "Apex Logistics Data Hub", + crm_account: "Apex Logistics", + primary_contact: "marcus.reed@apexlogistics.example.com", + ...dealValue("Apex Logistics Data Hub", 40), + stage: "needs_analysis", + probability: 40, + close_date: cel31`daysFromNow(38)`, + type: "new_business", + forecast_category: "best_case", + lead_source: "partner", + stage_entry_date: celDaysAgo(18), + description: "Apex is mapping its fragmented commercial systems before committing to a data-hub program.", + next_step: "Complete the architecture workshop and quantify the integration backlog." + }, + { + name: "Lattice Education Renewal", + crm_account: "Lattice Education", + primary_contact: "priya.shah@lattice.example.com", + crm_campaign: "Q3 Enterprise Email Nurture", + ...dealValue("Lattice Education Renewal", 60), + stage: "proposal", + probability: 60, + close_date: cel31`daysFromNow(24)`, + type: "existing_renewal", + forecast_category: "commit", + lead_source: "email_campaign", + stage_entry_date: celDaysAgo(6), + description: "Renewal proposal adds student-success automation and an expanded analytics package.", + next_step: "Review the two-year option with procurement before the executive sponsor meeting." + }, + { + name: "Vertex Enterprise Rollout", + crm_account: "Vertex Analytics", + primary_contact: "ethan.brooks@vertex.example.com", + ...dealValue("Vertex Enterprise Rollout", 80), + stage: "negotiation", + probability: 80, + close_date: cel31`daysFromNow(11)`, + type: "existing_expansion", + forecast_category: "commit", + lead_source: "referral", + stage_entry_date: celDaysAgo(3), + description: "Phase one of an enterprise rollout, negotiated around phased deployment and data-residency requirements.", + next_step: "Resolve the final security addendum and confirm the procurement signature date." + } + ] +}); + +// src/sales/data/activity.seed.ts +import { defineSeed as defineSeed2 } from "@objectstack/spec/data"; +import { cel as cel32 } from "@objectstack/spec"; +var tasks = defineSeed2(Task, { + mode: "upsert", + externalId: "subject", + records: [ + { + subject: "Follow up with Acme on proposal", + description: "Send Jordan Park the revised Enterprise proposal and a 30-min calendar slot to walk through the AI governance section.", + status: "not_started", + priority: "high", + priority_rank: 3, + due_date: cel32`daysFromNow(2)`, + related_to_type: "crm_opportunity", + related_to_account: "Acme Corporation", + related_to_opportunity: "Acme Platform Upgrade" + }, + { + // The workshop this task asks someone to book is ALREADY on the + // calendar: the `Acme — AI agent governance workshop` event lower in + // this file is `planned` at daysFromNow(6), and the attendee builder + // dates its invitation `daysAgo(max(-6 + invitedDaysBefore(9), 0))` = + // daysAgo(3) — already sent, and already answered `tentative`. So the + // booking task is DONE, and it was done the day the invitation went + // out. An open "schedule it" task beside a booked-and-invited meeting + // is the contradiction itself, not a due date to nudge (#1660). + // + // The EVENT owns the workshop's date. Nothing here restates it — both + // dates below derive from the invitation instant — so there is no + // second copy to drift out of step. + subject: "Acme \u2014 schedule AI governance workshop", + description: "Block a 90-min joint workshop with Acme\u2019s compliance team to walk through how HotCRM agents handle data scoping, RBAC, audit trails, and human-in-the-loop. Pre-read: ADR-0007 + the governance demo deck.", + status: "completed", + priority: "high", + priority_rank: 3, + due_date: cel32`daysAgo(3)`, + completed_date: cel32`daysAgo(3)`, + // Hooks don't run over seeds — mirror what task_completion would stamp. + is_completed: true, + progress_percent: 100, + related_to_type: "crm_opportunity", + related_to_account: "Acme Corporation", + related_to_opportunity: "Acme Platform Upgrade" + }, + { + subject: "Acme \u2014 close out login-issues ticket before SLA", + description: "Confirm engineering has the EMEA SSO clock-skew patch ready, deploy to Acme\u2019s tenant, and send Lisa Kim a customer-facing post-mortem.", + status: "in_progress", + priority: "urgent", + priority_rank: 4, + due_date: cel32`daysFromNow(1)`, + related_to_type: "crm_case", + related_to_account: "Acme Corporation", + related_to_case: "Login issues after platform upgrade" + }, + { + subject: "Schedule demo for Globex team", + status: "in_progress", + priority: "normal", + priority_rank: 2, + due_date: cel32`daysFromNow(5)`, + related_to_type: "crm_account", + related_to_account: "Globex Industries" + }, + { + subject: "Prepare contract for Wayne Enterprises", + status: "not_started", + priority: "urgent", + priority_rank: 4, + due_date: cel32`daysFromNow(1)`, + related_to_type: "crm_account", + related_to_account: "Wayne Enterprises" + }, + { + subject: "Send welcome package to Stark Medical", + status: "completed", + priority: "low", + priority_rank: 1, + completed_date: cel32`daysAgo(2)`, + // Hooks don't run over seeds — mirror what task_completion would stamp. + is_completed: true, + progress_percent: 100, + related_to_type: "crm_account", + related_to_account: "Stark Medical" + }, + { + // Internal housekeeping task — deliberately unparented (the + // related_to_required rule is a warning, not an error). + subject: "Update CRM pipeline report", + status: "not_started", + priority: "normal", + priority_rank: 2, + due_date: cel32`daysFromNow(7)` + } + ] +}); +var EVENT_RELATED_FIELD = { + crm_account: "related_to_account", + crm_contact: "related_to_contact", + crm_opportunity: "related_to_opportunity", + crm_lead: "related_to_lead", + crm_case: "related_to_case" +}; +var celClock = (daysAgo, hour, minute) => { + const clock = `${hour}h${minute}m`; + return daysAgo >= 0 ? cel32`daysAgo(${daysAgo}) + duration(${clock})` : cel32`daysFromNow(${-daysAgo}) + duration(${clock})`; +}; +var EVENT_SPECS = [ + // ─── Acme Corporation — the hero account, worked across every parent ──── + { + subject: "Acme \u2014 Enterprise edition walkthrough", + type: "demo", + status: "held", + daysAgo: 2, + at: [10, 0], + minutes: 60, + relatedType: "crm_opportunity", + relatedKey: "Acme Platform Upgrade", + account: "Acme Corporation", + location: "Zoom", + outcome: "Walked the Ops team through agent governance and the analytics seats. Revised proposal to follow this week.", + attendees: [{ contact: "john.smith@acme.example.com", response: "accepted" }] + }, + { + subject: "Acme \u2014 proposal follow-up call", + type: "call", + status: "held", + daysAgo: 5, + at: [15, 30], + minutes: 25, + relatedType: "crm_contact", + relatedKey: "john.smith@acme.example.com", + account: "Acme Corporation", + outcome: "Procurement wants an 18-month term. Pricing to be re-cut before the governance workshop.", + attendees: [{ contact: "john.smith@acme.example.com", response: "accepted" }] + }, + { + subject: "Acme \u2014 AI governance scoping session", + type: "meeting", + status: "held", + daysAgo: 12, + at: [9, 0], + minutes: 90, + relatedType: "crm_account", + relatedKey: "Acme Corporation", + location: "Google Meet", + outcome: "Agreed the workshop agenda: data scoping, RBAC, audit trails, human-in-the-loop.", + attendees: [{ contact: "john.smith@acme.example.com", response: "accepted" }] + }, + { + subject: "Acme \u2014 login incident status call", + type: "call", + status: "held", + daysAgo: 16, + at: [8, 30], + minutes: 20, + relatedType: "crm_case", + relatedKey: "Login issues after platform upgrade", + account: "Acme Corporation", + outcome: "Confirmed the EMEA SSO clock-skew hypothesis; engineering reproducing in staging.", + attendees: [{ contact: "john.smith@acme.example.com", response: "accepted" }] + }, + { + subject: "Acme \u2014 renewal signature review", + type: "meeting", + status: "held", + daysAgo: 20, + at: [14, 0], + minutes: 45, + relatedType: "crm_opportunity", + relatedKey: "Acme Annual Renewal 2025", + account: "Acme Corporation", + outcome: "Signed two weeks ahead of the renewal date. Multi-year deferred to the upgrade decision.", + attendees: [{ contact: "john.smith@acme.example.com", response: "accepted" }] + }, + { + subject: "Acme \u2014 San Francisco HQ business review", + type: "onsite_visit", + status: "held", + daysAgo: 33, + at: [13, 0], + minutes: 120, + relatedType: "crm_account", + relatedKey: "Acme Corporation", + location: "500 Howard Street, Suite 400, San Francisco", + outcome: "Quarterly review with the CTO org. Expansion into the EMEA team confirmed as the next motion.", + attendees: [{ contact: "john.smith@acme.example.com", response: "accepted" }] + }, + // ─── Wayne Enterprises — a deal in negotiation ────────────────────────── + { + subject: "Wayne \u2014 enterprise license negotiation", + type: "meeting", + status: "held", + daysAgo: 3, + at: [16, 0], + minutes: 60, + relatedType: "crm_opportunity", + relatedKey: "Wayne Enterprise License", + account: "Wayne Enterprises", + location: "Zoom", + outcome: "Volume tier agreed at 20 tenants. Security addendum is the last open item.", + attendees: [{ contact: "rwilson@wayne.example.com", response: "accepted" }] + }, + { + subject: "Wayne \u2014 security addendum walkthrough", + type: "call", + status: "held", + daysAgo: 8, + at: [11, 0], + minutes: 30, + relatedType: "crm_contact", + relatedKey: "rwilson@wayne.example.com", + account: "Wayne Enterprises", + outcome: "Legal to return redlines within the week.", + attendees: [{ contact: "rwilson@wayne.example.com", response: "accepted" }] + }, + { + subject: "Wayne \u2014 platform governance webinar", + type: "webinar", + status: "held", + daysAgo: 26, + at: [15, 0], + minutes: 60, + relatedType: "crm_account", + relatedKey: "Wayne Enterprises", + location: "https://acme.example.com/webinars/governance", + outcome: "Four business units attended; two asked for their own rollout plan.", + attendees: [{ contact: "rwilson@wayne.example.com", response: "accepted" }] + }, + { + subject: "Wayne \u2014 bulk import rollout check-in", + type: "call", + status: "held", + daysAgo: 45, + at: [10, 30], + minutes: 25, + relatedType: "crm_case", + relatedKey: "Request: bulk import via CSV", + account: "Wayne Enterprises", + outcome: "CSV import shipped and documented; the customer closed the request out on the call.", + attendees: [{ contact: "rwilson@wayne.example.com", response: "accepted" }] + }, + // ─── Vertex Analytics — expansion, then an enterprise rollout ─────────── + { + subject: "Vertex \u2014 rollout phasing and data residency", + type: "meeting", + status: "held", + daysAgo: 1, + at: [9, 30], + minutes: 75, + relatedType: "crm_opportunity", + relatedKey: "Vertex Enterprise Rollout", + account: "Vertex Analytics", + location: "Zoom", + outcome: "Phase 1 scoped to four regions. Residency controls to be confirmed with their security team.", + attendees: [{ contact: "ethan.brooks@vertex.example.com", response: "accepted" }] + }, + { + subject: "Vertex \u2014 revenue analytics demo", + type: "demo", + status: "held", + daysAgo: 10, + at: [14, 30], + minutes: 45, + relatedType: "crm_opportunity", + relatedKey: "Vertex Analytics Expansion", + account: "Vertex Analytics", + location: "Zoom", + outcome: "Sales, marketing and service leads all asked for their own workspace \u2014 the expansion case makes itself.", + attendees: [{ contact: "ethan.brooks@vertex.example.com", response: "accepted" }] + }, + { + subject: "Vertex \u2014 expansion buying committee call", + type: "call", + status: "held", + daysAgo: 19, + at: [16, 30], + minutes: 30, + relatedType: "crm_contact", + relatedKey: "ethan.brooks@vertex.example.com", + account: "Vertex Analytics", + outcome: "CRO owns the budget; the data team stays the technical sponsor.", + attendees: [{ contact: "ethan.brooks@vertex.example.com", response: "accepted" }] + }, + { + subject: "Vertex \u2014 developer platform retrospective", + type: "meeting", + status: "held", + daysAgo: 38, + at: [11, 0], + minutes: 60, + relatedType: "crm_account", + relatedKey: "Vertex Analytics", + outcome: "Three product teams live on the developer platform; usage analytics is the next ask.", + attendees: [{ contact: "ethan.brooks@vertex.example.com", response: "accepted" }] + }, + // ─── Stark Medical — the partner motion ──────────────────────────────── + { + subject: "Stark Medical \u2014 Toronto clinical operations visit", + type: "onsite_visit", + status: "held", + daysAgo: 52, + at: [9, 0], + minutes: 180, + relatedType: "crm_account", + relatedKey: "Stark Medical", + location: "181 Bay Street, Suite 2200, Toronto", + outcome: "Two clinical service lines live on the pilot. Device-servicing expansion parked on budget.", + attendees: [{ contact: "emily.d@starkmed.example.com", response: "accepted" }] + }, + // ─── Leads: the only held rows that touch a prospect's own clock ──────── + { + subject: "CloudFirst \u2014 qualification call with Lisa Thompson", + type: "call", + status: "held", + daysAgo: 1, + at: [11, 0], + minutes: 30, + relatedType: "crm_lead", + relatedKey: "lisa.t@cloudfirst.example.com", + outcome: "Budget confirmed and a technical evaluation agreed \u2014 qualified.", + attendees: [{ lead: "lisa.t@cloudfirst.example.com", response: "accepted" }] + }, + { + subject: "EduTech Labs \u2014 discovery call with David Kim", + type: "call", + status: "held", + daysAgo: 4, + at: [13, 0], + minutes: 30, + relatedType: "crm_lead", + relatedKey: "dkim@edutechlabs.example.com", + outcome: "Replacing spreadsheets across admissions. Referral source confirmed.", + attendees: [{ lead: "dkim@edutechlabs.example.com", response: "accepted" }] + }, + // The earlier touch on each of the two leads above, so each lead's Activity + // tab reads as a short history rather than a single row. Both leads already + // carry `last_contacted_date: today()` for their later call, so a second held + // row moves no recency clock (`event_activity_bubble` stamps the seed moment). + { + subject: "CloudFirst \u2014 follow-up meeting after the Cloud Summit booth", + type: "meeting", + status: "held", + daysAgo: 8, + at: [15, 0], + minutes: 45, + relatedType: "crm_lead", + relatedKey: "lisa.t@cloudfirst.example.com", + outcome: "Walked through pipeline and forecasting. Asked for a qualification call with finance.", + attendees: [{ lead: "lisa.t@cloudfirst.example.com", response: "accepted" }] + }, + { + subject: "EduTech Labs \u2014 referral intro call with David Kim", + type: "call", + status: "held", + daysAgo: 9, + at: [10, 0], + minutes: 15, + relatedType: "crm_lead", + relatedKey: "dkim@edutechlabs.example.com", + outcome: "Warm intro from the referring partner. Booked a proper discovery call.", + attendees: [{ lead: "dkim@edutechlabs.example.com", response: "accepted" }] + }, + // ─── Booked, not held: the calendar ahead ─────────────────────────────── + // These are what `status` exists for. Not one of them moves a recency clock, + // and the three re-engagement rows below sit on the accounts the churn tiles + // count — which is the demonstration, not an oversight. + { + subject: "Acme \u2014 AI agent governance workshop", + type: "meeting", + status: "planned", + daysAgo: -6, + at: [9, 0], + minutes: 90, + relatedType: "crm_opportunity", + relatedKey: "Acme Platform Upgrade", + account: "Acme Corporation", + location: "Google Meet", + description: "Joint workshop with Acme compliance: data scoping, RBAC, audit trails, human-in-the-loop.", + attendees: [{ contact: "john.smith@acme.example.com", response: "tentative" }], + invitedDaysBefore: 9 + }, + { + subject: "Wayne \u2014 procurement signature call", + type: "meeting", + status: "planned", + daysAgo: -1, + at: [11, 0], + minutes: 30, + relatedType: "crm_opportunity", + relatedKey: "Wayne Enterprise License", + account: "Wayne Enterprises", + description: "Confirm the signature date once the security addendum is closed.", + attendees: [{ contact: "rwilson@wayne.example.com", response: "accepted" }], + invitedDaysBefore: 4 + }, + { + subject: "Globex \u2014 manufacturing suite demo", + type: "demo", + status: "planned", + daysAgo: -5, + at: [15, 0], + minutes: 60, + relatedType: "crm_opportunity", + relatedKey: "Globex Manufacturing Suite", + account: "Globex Industries", + location: "Zoom", + description: "Plant-operations demo for the six-site rollout, ahead of the qualification review.", + attendees: [{ contact: "sarah.j@globex.example.com", response: "accepted" }], + invitedDaysBefore: 8 + }, + { + subject: "Lattice \u2014 renewal proposal review", + type: "meeting", + status: "planned", + daysAgo: -3, + at: [10, 0], + minutes: 45, + relatedType: "crm_opportunity", + relatedKey: "Lattice Education Renewal", + account: "Lattice Education", + description: "Walk procurement through the two-year option before the executive sponsor meeting.", + attendees: [{ contact: "priya.shah@lattice.example.com", response: "accepted" }], + invitedDaysBefore: 6 + }, + { + subject: "Initech \u2014 re-engagement call before renewal", + type: "call", + status: "planned", + daysAgo: -2, + at: [14, 0], + minutes: 30, + relatedType: "crm_account", + relatedKey: "Initech Solutions", + description: "Nobody has spoken to Initech in ten weeks and the renewal is 75 days out. Re-open the relationship.", + attendees: [{ contact: "mchen@initech.example.com", response: "no_response" }], + invitedDaysBefore: 5 + }, + { + subject: "Northwind \u2014 grid modernization discovery workshop", + type: "meeting", + status: "planned", + daysAgo: -7, + at: [9, 30], + minutes: 120, + relatedType: "crm_opportunity", + relatedKey: "Northwind Grid Modernization", + account: "Northwind Energy", + location: "Leopoldstrasse 21, Munich", + description: "Confirm discovery participants and agree the operational-data assessment scope.", + attendees: [{ contact: "olivia.chen@northwind.example.com", response: "tentative" }], + invitedDaysBefore: 10 + }, + { + subject: "Apex Logistics \u2014 data hub re-engagement call", + type: "call", + status: "planned", + daysAgo: -4, + at: [16, 0], + minutes: 30, + relatedType: "crm_account", + relatedKey: "Apex Logistics", + description: "The data-hub evaluation has been silent for a quarter. Re-establish the commercial sponsor.", + attendees: [{ contact: "marcus.reed@apexlogistics.example.com", response: "no_response" }], + invitedDaysBefore: 6 + }, + { + subject: "NextGen Retail \u2014 first discovery call with Alice Martinez", + type: "call", + status: "planned", + daysAgo: -2, + at: [15, 0], + minutes: 30, + relatedType: "crm_lead", + relatedKey: "alice@nextgenretail.example.com", + description: "Inbound web lead, booked on her follow-up date.", + attendees: [{ lead: "alice@nextgenretail.example.com", response: "no_response" }], + invitedDaysBefore: 3 + }, + // ─── Neither held nor booked ──────────────────────────────────────────── + // `duration_minutes` is 0 on both, exactly as `event_schedule_derive` + // recomputes it: a meeting nobody attended occupies nobody's time, while the + // calendar slot it was booked into stays on the record as evidence of the + // attempt. + { + subject: "Globex \u2014 line expansion review", + type: "meeting", + status: "cancelled", + daysAgo: 30, + at: [14, 0], + minutes: 60, + relatedType: "crm_opportunity", + relatedKey: "Globex Line Expansion (Lost)", + account: "Globex Industries", + description: "Cancelled by the customer: the incumbent MES vendor had already bundled the two lines.", + attendees: [{ contact: "sarah.j@globex.example.com", response: "declined" }], + invitedDaysBefore: 7 + }, + { + subject: "Initech \u2014 SSO configuration check-in", + type: "call", + status: "no_show", + daysAgo: 55, + at: [10, 0], + minutes: 30, + relatedType: "crm_account", + relatedKey: "Initech Solutions", + description: "Customer did not join. The last attempt to reach Initech before the account went quiet.", + attendees: [{ contact: "mchen@initech.example.com", response: "no_response" }], + invitedDaysBefore: 4 + } +]; +var endClock = (spec) => { + const total = spec.at[0] * 60 + spec.at[1] + spec.minutes; + return [Math.floor(total / 60), total % 60]; +}; +var events = defineSeed2(Event, { + mode: "upsert", + externalId: "subject", + records: EVENT_SPECS.map((spec) => { + const [endHour, endMinute] = endClock(spec); + return { + subject: spec.subject, + type: spec.type, + status: spec.status, + start_datetime: celClock(spec.daysAgo, spec.at[0], spec.at[1]), + end_datetime: celClock(spec.daysAgo, endHour, endMinute), + // Authored rather than left to the hook, and authored to the value the + // hook computes: `event_schedule_derive` measures the gap between the two + // timestamps above, then zeroes it for a cancelled / no-show row. Both + // branches agree with this literal, so the figure is right whether or not + // hooks fire over the seed write (`./_shared.ts`, doctrine rule 2). + duration_minutes: spec.status === "cancelled" || spec.status === "no_show" ? 0 : spec.minutes, + all_day: false, + related_to_type: spec.relatedType, + [EVENT_RELATED_FIELD[spec.relatedType]]: spec.relatedKey, + // The account link is authored on every row that has one, including rows + // whose `related_to_type` is the contact / opportunity / case — the same + // shape the task seeds use, and what fills the ACCOUNT's activity list. + ...spec.account && spec.relatedType !== "crm_account" ? { related_to_account: spec.account } : {}, + ...spec.location ? { location: spec.location } : {}, + ...spec.description ? { description: spec.description } : {}, + ...spec.outcome ? { outcome_notes: spec.outcome } : {} + // No `owner_id`: a seed cannot name a user (see `objectstack.composition.ts`, + // "A seed can't name a user"), so these rows land ownerless and the + // platform's seed-ownership claim hands them to the first administrator + // when the seed settles (#671, #1892). + }; + }) +}); +var attendeeRecords = (kind) => EVENT_SPECS.flatMap( + (spec) => spec.attendees.filter((a) => kind === "lead" ? a.lead : a.contact).map((a) => ({ + crm_event: spec.subject, + attendee_type: kind, + ...kind === "lead" ? { crm_lead: a.lead } : { crm_contact: a.contact }, + response: a.response, + is_organizer: false, + // The invitation predates the slot. Clamped at 0 so a meeting booked + // for the day after tomorrow was invited today, never tomorrow. + invited_date: celDaysAgo(Math.max(spec.daysAgo + (spec.invitedDaysBefore ?? 3), 0)) + })) +); +var eventAttendeesFromContacts = defineSeed2(EventAttendee, { + mode: "upsert", + externalId: ["crm_event", "crm_contact"], + records: attendeeRecords("contact") +}); +var eventAttendeesFromLeads = defineSeed2(EventAttendee, { + mode: "upsert", + externalId: ["crm_event", "crm_lead"], + records: attendeeRecords("lead") +}); +var SYS_ACTIVITY_RETENTION_DAYS = 14; +var LOGGED_SUMMARY_PREFIX = { + call: "", + meeting: "Meeting: " +}; +var leadInteractionPointers = { + object: "sys_activity", + mode: "upsert", + // One timeline pointer per rich source record, exactly as the action writes + // it. Matched on the RESOLVED ids, so replay boots dedupe. + externalId: ["source_object", "source_id"], + records: EVENT_SPECS.filter( + (spec) => spec.relatedType === "crm_lead" && spec.status === "held" && LOGGED_SUMMARY_PREFIX[spec.type] !== void 0 && spec.daysAgo >= 0 && spec.daysAgo < SYS_ACTIVITY_RETENTION_DAYS + ).map((spec) => { + const [endHour, endMinute] = endClock(spec); + return { + // `held` is what both actions write as `completed` — the `task` feed + // kind, the one the lead Activity tab renders. + type: "completed", + // The action's own summary: prefix, subject, duration in brackets. + summary: `${LOGGED_SUMMARY_PREFIX[spec.type]}${spec.subject} (${spec.minutes} min)`, + // Logged when the slot ended. + timestamp: celClock(spec.daysAgo, endHour, endMinute), + object_name: "crm_lead", + record_id: spec.relatedKey, + source_object: "crm_event", + source_id: spec.subject, + metadata: JSON.stringify({ + kind: spec.type, + duration_minutes: spec.minutes, + notes: spec.outcome ?? "", + attendee_count: spec.attendees.length + }) + }; + }) +}; + +// src/sales/data/forecast.seed.ts +import { defineSeed as defineSeed3 } from "@objectstack/spec/data"; +import { cel as cel33 } from "@objectstack/spec"; +var FORECAST_MONTHS = ["Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"]; +var forecastIsoDate = (d) => `${d.getUTCFullYear()}-${String(d.getUTCMonth() + 1).padStart(2, "0")}-${String(d.getUTCDate()).padStart(2, "0")}`; +var forecastQuarterLabel = (d) => `Q${Math.floor(d.getUTCMonth() / 3) + 1} ${d.getUTCFullYear()}`; +var forecastMonthLabel = (d) => `${FORECAST_MONTHS[d.getUTCMonth()]} ${d.getUTCFullYear()}`; +var forecastNow = /* @__PURE__ */ new Date(); +var forecastYear = forecastNow.getUTCFullYear(); +var forecastMonth = forecastNow.getUTCMonth(); +var forecastQuarterMonth = Math.floor(forecastMonth / 3) * 3; +var thisMonthStart = new Date(Date.UTC(forecastYear, forecastMonth, 1)); +var thisMonthEnd = new Date(Date.UTC(forecastYear, forecastMonth + 1, 0)); +var lastQuarterStart = new Date(Date.UTC(forecastYear, forecastQuarterMonth - 3, 1)); +var lastQuarterEnd = new Date(Date.UTC(forecastYear, forecastQuarterMonth, 0)); +var quarterStartAgo = (n) => new Date(Date.UTC(forecastYear, forecastQuarterMonth - 3 * n, 1)); +var quarterEndAgo = (n) => new Date(Date.UTC(forecastYear, forecastQuarterMonth - 3 * (n - 1), 0)); +var monthStartAgo = (n) => new Date(Date.UTC(forecastYear, forecastMonth - n, 1)); +var monthEndAgo = (n) => new Date(Date.UTC(forecastYear, forecastMonth - n + 1, 0)); +var closedPeriod = (seed_key, period, start, end, quota, closed, open, notes) => ({ + seed_key, + period, + period_label: period === "quarter" ? forecastQuarterLabel(start) : forecastMonthLabel(start), + period_start: forecastIsoDate(start), + period_end: forecastIsoDate(end), + snapshot_date: forecastIsoDate(end), + quota, + pipeline_amount: open.pipeline, + best_case_amount: open.bestCase, + commit_amount: open.commit, + closed_amount: closed, + source: "scheduled", + notes +}); +var forecasts = defineSeed3(Forecast, { + mode: "upsert", + externalId: "seed_key", + records: [ + { + seed_key: "demo_month_current", + period: "month", + period_label: forecastMonthLabel(thisMonthStart), + period_start: forecastIsoDate(thisMonthStart), + period_end: forecastIsoDate(thisMonthEnd), + snapshot_date: cel33`today()`, + quota: 5e5, + pipeline_amount: 76e4, + best_case_amount: 54e4, + commit_amount: 36e4, + closed_amount: 295e3, + source: "scheduled", + notes: "Healthy coverage; two commit deals expected to close this week." + }, + { + seed_key: "demo_quarter_minus_1", + period: "quarter", + period_label: forecastQuarterLabel(lastQuarterStart), + period_start: forecastIsoDate(lastQuarterStart), + period_end: forecastIsoDate(lastQuarterEnd), + snapshot_date: forecastIsoDate(lastQuarterEnd), + quota: 14e5, + pipeline_amount: 24e4, + best_case_amount: 15e4, + commit_amount: 95e3, + closed_amount: 1485e3, + source: "scheduled", + notes: "Closed at 106% of quota." + }, + closedPeriod( + "demo_quarter_minus_2", + "quarter", + quarterStartAgo(2), + quarterEndAgo(2), + 13e5, + 1196e3, + { pipeline: 285e3, bestCase: 19e4, commit: 12e4 }, + "Closed at 92% of quota \u2014 two enterprise deals slipped into the next quarter." + ), + closedPeriod( + "demo_quarter_minus_3", + "quarter", + quarterStartAgo(3), + quarterEndAgo(3), + 12e5, + 1308e3, + { pipeline: 195e3, bestCase: 13e4, commit: 85e3 }, + "Closed at 109% of quota, carried by the enterprise renewal cohort." + ), + closedPeriod( + "demo_quarter_minus_4", + "quarter", + quarterStartAgo(4), + quarterEndAgo(4), + 11e5, + 1045e3, + { pipeline: 165e3, bestCase: 11e4, commit: 7e4 }, + "Closed at 95% of quota in the first quarter on the new territory model." + ), + closedPeriod( + "demo_month_minus_1", + "month", + monthStartAgo(1), + monthEndAgo(1), + 48e4, + 505e3, + { pipeline: 96e3, bestCase: 62e3, commit: 4e4 }, + "Closed at 105% of quota; the expansion motion covered a soft new-business month." + ), + closedPeriod( + "demo_month_minus_2", + "month", + monthStartAgo(2), + monthEndAgo(2), + 46e4, + 414e3, + { pipeline: 92e3, bestCase: 58e3, commit: 35e3 }, + "Closed at 90% of quota \u2014 summer slowdown across the mid-market segment." + ) + ] +}); + +// src/sales/data/index.ts +var COMPOSITION_ENV_VAR = "HOTCRM_COMPOSITION"; +var HOTCRM_COMPOSITIONS = ["default", "saas"]; +function resolveComposition(raw = process.env[COMPOSITION_ENV_VAR]) { + const value = (raw ?? "").trim(); + if (value === "") return "default"; + if (HOTCRM_COMPOSITIONS.includes(value)) { + return value; + } + throw new Error( + `${COMPOSITION_ENV_VAR}="${value}" is not a HotCRM composition. Expected one of: ${HOTCRM_COMPOSITIONS.join(", ")} (or leave it unset for 'default').` + ); +} + +// src/revenue/data/catalog.seed.ts +import { defineSeed as defineSeed4 } from "@objectstack/spec/data"; +var products = defineSeed4(Product, { + mode: "upsert", + externalId: "name", + records: [ + { + name: "ObjectStack Platform", + description: "The enterprise edition: unlimited objects, AI agents, governance and audit.", + category: "software", + family: "enterprise", + sku: "OS-PLAT-ENT", + list_price: 5e4, + cost: 12e3, + is_active: true + }, + { + name: "ObjectStack Platform (SMB Edition)", + description: "The mid-market edition: core CRM objects and automation, capped agent usage.", + category: "software", + family: "smb", + sku: "OS-PLAT-SMB", + list_price: 18e3, + cost: 4500, + is_active: true + }, + { + name: "Cloud Hosting (Annual)", + description: "Managed hosting with regional data residency and a 99.9% availability target.", + category: "subscription", + family: "cloud", + sku: "OS-CLOUD-HOST", + list_price: 12e3, + cost: 4200, + is_active: true + }, + { + name: "Sandbox Environment (Annual)", + description: "A full-copy non-production environment for testing metadata changes before release.", + category: "subscription", + family: "cloud", + sku: "OS-CLOUD-SBX", + list_price: 7500, + cost: 2600, + is_active: true + }, + { + name: "AI Agent Seat (Annual)", + description: "A named-user seat for the Co-Pilot and agent surfaces, billed annually.", + category: "subscription", + family: "cloud", + sku: "OS-AI-SEAT", + list_price: 1e3, + cost: 260, + is_active: true + }, + { + name: "Analytics Add-on", + description: "Dashboards, cubes and scheduled reporting for the revenue organization.", + category: "software", + family: "enterprise", + sku: "OS-ADDON-ANL", + list_price: 22e3, + cost: 6500, + is_active: true + }, + { + name: "Integration Connector Pack", + description: "Pre-built connectors for ERP, marketing automation and data warehouse targets.", + category: "software", + family: "enterprise", + sku: "OS-ADDON-INT", + list_price: 16e3, + cost: 5200, + is_active: true + }, + { + name: "Field Service Mobile", + description: "Offline-capable mobile app for field technicians and route-based service work.", + category: "software", + family: "smb", + sku: "OS-ADDON-FSM", + list_price: 14e3, + cost: 4200, + is_active: true + }, + { + name: "Premium Support", + description: "24\xD77 support with a one-hour P1 response target and a named technical account manager.", + category: "support", + family: "services", + sku: "OS-SUP-PREM", + list_price: 25e3, + cost: 9e3, + is_active: true + }, + { + name: "Standard Support", + description: "Business-hours support with a next-business-day response target.", + category: "support", + family: "services", + sku: "OS-SUP-STD", + list_price: 9e3, + cost: 3600, + is_active: true + }, + { + name: "Implementation Services", + description: "Guided implementation: discovery, metadata build, integration and go-live support.", + category: "service", + family: "services", + sku: "OS-SVC-IMPL", + list_price: 75e3, + cost: 41e3, + is_active: true + }, + { + name: "Data Migration Services", + description: "Extraction, mapping and reconciliation of legacy CRM and spreadsheet data.", + category: "service", + family: "services", + sku: "OS-SVC-MIGR", + list_price: 35e3, + cost: 19e3, + is_active: true + }, + { + name: "Admin Training Workshop", + description: "A one-day workshop for administrators on metadata, permissions and analytics.", + category: "service", + family: "services", + sku: "OS-SVC-TRN", + list_price: 6e3, + cost: 2400, + is_active: true + } + ] +}); +var catalogPrice = (productName) => { + const product = products.records.find((r) => r.name === productName); + if (!product || typeof product.list_price !== "number") { + throw new Error(`Seed error: no catalog product named "${productName}"`); + } + return product.list_price; +}; +var lineItemRecords = (parentField, table) => Object.entries(table).flatMap( + ([parent, lines]) => lines.map((l, i) => ({ + [parentField]: parent, + crm_product: l.product, + description: l.description, + quantity: l.quantity, + list_price: catalogPrice(l.product), + unit_price: l.unit_price, + discount: l.discount ?? 0, + line_number: i + 1 + })) +); + +// src/revenue/data/opportunity-line-item.seed.ts +import { defineSeed as defineSeed5 } from "@objectstack/spec/data"; +var opportunityLineItems = defineSeed5(OpportunityLineItem, { + mode: "upsert", + externalId: ["crm_opportunity", "crm_product"], + records: lineItemRecords("crm_opportunity", OPPORTUNITY_LINES) +}); + +// src/revenue/data/revenue.seed.ts +import { defineSeed as defineSeed6 } from "@objectstack/spec/data"; +import { cel as cel34 } from "@objectstack/spec"; +var contracts = defineSeed6(Contract, { + mode: "upsert", + externalId: "description", + records: [ + // The one ACTIVATED contract in the app — `contract_renewal`, + // `contract_expiration` and `billing_handoff` all filter on exactly that + // status — so it has to be a contract that was really signed, off a deal + // that was really won. + // + // It used to link `Acme Platform Upgrade` and carry that deal's line total + // (150000) while that deal is still `proposal`, closing `daysFromNow(30)` + // (#1661). Nothing in this app can produce that pairing: `quote_on_accepted` + // close-wins an opportunity the moment its quote is accepted, and + // `closed_won` is TERMINAL in `opportunity_stage_progression` — so a signed + // contract can never sit on an open deal, from either direction. + // + // Every field below is now derived from `Acme Annual Renewal 2025`, the + // `closed_won` deal this contract's own description was already describing: + // contract_value — that deal's line-item total, which is also the ARR the + // account description reports. 150000 was the upgrade's + // total, i.e. the value came from a different deal than + // the link did; + // signed_date — its `close_date`: you sign when you win, and + // `quote_on_accepted` stamps that same day; + // start_date — signature + 14d, because that deal's description says + // it was "signed two weeks ahead of the renewal date"; + // end_date — start + 365d, the span every other row here uses for a + // 12-month term. + { + crm_account: "Acme Corporation", + crm_contact: "john.smith@acme.example.com", + crm_opportunity: "Acme Annual Renewal 2025", + status: "activated", + contract_term_months: 12, + start_date: cel34`daysAgo(1)`, + end_date: cel34`daysFromNow(364)`, + contract_value: 22e4, + billing_frequency: "annually", + payment_terms: "net_30", + auto_renewal: true, + renewal_notice_days: 60, + contract_type: "subscription", + signed_date: cel34`daysAgo(15)`, + signed_by: "John Smith", + description: "Annual platform subscription with premium support tier." + }, + { + crm_account: "Wayne Enterprises", + crm_contact: "rwilson@wayne.example.com", + crm_opportunity: "Wayne Enterprise License", + status: "in_approval", + contract_term_months: 36, + start_date: cel34`daysFromNow(14)`, + end_date: cel34`daysFromNow(1109)`, + contract_value: 12e5, + billing_frequency: "annually", + payment_terms: "net_60", + auto_renewal: false, + renewal_notice_days: 90, + contract_type: "license", + description: "Multi-year enterprise license with custom SLA." + }, + { + crm_account: "Initech Solutions", + crm_contact: "mchen@initech.example.com", + status: "expired", + contract_term_months: 12, + start_date: cel34`daysAgo(400)`, + end_date: cel34`daysAgo(35)`, + contract_value: 6e4, + billing_frequency: "quarterly", + payment_terms: "net_30", + auto_renewal: false, + renewal_notice_days: 30, + contract_type: "service", + signed_date: cel34`daysAgo(405)`, + signed_by: "Michael Chen", + description: "Initial service agreement, pending renewal discussion." + }, + { + crm_account: "Stark Medical", + crm_contact: "emily.d@starkmed.example.com", + status: "draft", + contract_term_months: 24, + start_date: cel34`daysFromNow(30)`, + end_date: cel34`daysFromNow(760)`, + contract_value: 35e4, + billing_frequency: "monthly", + payment_terms: "net_30", + auto_renewal: true, + renewal_notice_days: 60, + contract_type: "partnership", + description: "Healthcare partnership agreement, currently under legal review." + } + ] +}); +var QUOTE_LINES = { + "Acme Platform Upgrade Quote": OPPORTUNITY_LINES["Acme Platform Upgrade"], + "Acme Annual Renewal 2025 Quote": OPPORTUNITY_LINES["Acme Annual Renewal 2025"], + "Globex Manufacturing Suite Proposal": OPPORTUNITY_LINES["Globex Manufacturing Suite"], + "Wayne Enterprise License Quote": OPPORTUNITY_LINES["Wayne Enterprise License"], + "Initech Cloud Migration Estimate": OPPORTUNITY_LINES["Initech Cloud Migration"], + // Quoted standalone, before any opportunity existed — and then rejected. + "Stark Medical Pilot Quote": [ + { product: "Admin Training Workshop", quantity: 5, unit_price: 6e3, description: "Five workshop days for the pilot clinical teams." }, + { product: "Standard Support", quantity: 1, unit_price: 9e3, description: "Standard support for the pilot term." }, + { product: "AI Agent Seat (Annual)", quantity: 6, unit_price: 1e3, description: "Agent seats for the pilot coordinators." } + ] +}; +var quoteTotals = (quoteName, opts) => { + const lines = QUOTE_LINES[quoteName]; + if (!lines) throw new Error(`Seed error: no line items authored for quote "${quoteName}"`); + const subtotal = linesTotal(lines); + const discount_amount = Math.round(subtotal * (opts.discount / 100) * 100) / 100; + const total_price = Math.round((subtotal - discount_amount + opts.tax + opts.shipping_handling) * 100) / 100; + return { + subtotal, + discount: opts.discount, + discount_amount, + tax: opts.tax, + shipping_handling: opts.shipping_handling, + total_price + }; +}; +var quotes = defineSeed6(Quote, { + mode: "upsert", + externalId: "name", + records: [ + { + name: "Acme Platform Upgrade Quote", + crm_account: "Acme Corporation", + crm_contact: "john.smith@acme.example.com", + crm_opportunity: "Acme Platform Upgrade", + // `expired`, not `accepted` (#1661). Accepting this quote would have + // close-won `Acme Platform Upgrade`, which is `proposal` and 30 days from + // close — the same impossible pairing the contract above carried, one + // object over. `expired` is what `quote_expiration` computes for a + // presented quote past its `expiration_date`, and it is what the deal's + // own next step assumes: the revised Enterprise proposal still has to go + // out. Its `crm_contact` stays put — the row is no longer gated by + // `requiredWhen`, but the recipient is still who it was sent to. + status: "expired", + quote_date: cel34`daysAgo(45)`, + expiration_date: cel34`daysAgo(15)`, + ...quoteTotals("Acme Platform Upgrade Quote", { discount: 10, tax: 11475, shipping_handling: 0 }), + payment_terms: "net_30", + description: "Platform upgrade with 10% loyalty discount applied." + }, + // The renewal's own quote, and the seed's one ACCEPTED quote. Acceptance is + // only coherent here: `quote_on_accepted` close-wins whatever opportunity a + // quote links, so an accepted quote can only ever point at a `closed_won` + // deal. It also completes the provenance chain the contract above needs — + // deal won, quote accepted, contract drafted, then completed and activated + // by an admin (the draft the hook writes is explicitly a starting point). + // `Acme Annual Renewal 2025` keeps its rep-recorded `relationship` win + // reason: the hook only supplies `quote_accepted` when nobody recorded one. + { + name: "Acme Annual Renewal 2025 Quote", + crm_account: "Acme Corporation", + crm_contact: "john.smith@acme.example.com", + crm_opportunity: "Acme Annual Renewal 2025", + status: "accepted", + quote_date: cel34`daysAgo(30)`, + expiration_date: cel34`daysAgo(1)`, + // No discount — the renewal went at list ("multi-year option declined + // this round"), which is what its 22% YoY uplift is made of. Tax is 8.5% + // of the post-discount subtotal, the rate the other Acme quote bills at; + // every non-Acme quote here bills 8%. + ...quoteTotals("Acme Annual Renewal 2025 Quote", { discount: 0, tax: 18700, shipping_handling: 0 }), + payment_terms: "net_30", + description: "Annual renewal \u2014 three production tenants, premium support and the EMEA seat expansion." + }, + { + name: "Globex Manufacturing Suite Proposal", + crm_account: "Globex Industries", + crm_contact: "sarah.j@globex.example.com", + crm_opportunity: "Globex Manufacturing Suite", + status: "presented", + quote_date: cel34`daysAgo(7)`, + expiration_date: cel34`daysFromNow(23)`, + ...quoteTotals("Globex Manufacturing Suite Proposal", { discount: 5, tax: 7220, shipping_handling: 2500 }), + payment_terms: "net_60", + description: "Manufacturing suite licensing with plant-admin training." + }, + { + name: "Wayne Enterprise License Quote", + crm_account: "Wayne Enterprises", + crm_contact: "rwilson@wayne.example.com", + crm_opportunity: "Wayne Enterprise License", + status: "in_review", + quote_date: cel34`daysAgo(3)`, + expiration_date: cel34`daysFromNow(27)`, + ...quoteTotals("Wayne Enterprise License Quote", { discount: 15, tax: 81600, shipping_handling: 0 }), + payment_terms: "net_60", + description: "Multi-year enterprise license with volume discount." + }, + { + name: "Initech Cloud Migration Estimate", + crm_account: "Initech Solutions", + crm_contact: "mchen@initech.example.com", + crm_opportunity: "Initech Cloud Migration", + status: "draft", + quote_date: cel34`daysAgo(1)`, + expiration_date: cel34`daysFromNow(29)`, + ...quoteTotals("Initech Cloud Migration Estimate", { discount: 0, tax: 6400, shipping_handling: 0 }), + payment_terms: "net_30", + description: "Cloud migration services, awaiting internal review." + }, + { + name: "Stark Medical Pilot Quote", + crm_account: "Stark Medical", + crm_contact: "emily.d@starkmed.example.com", + status: "rejected", + quote_date: cel34`daysAgo(60)`, + expiration_date: cel34`daysAgo(30)`, + ...quoteTotals("Stark Medical Pilot Quote", { discount: 0, tax: 3600, shipping_handling: 0 }), + payment_terms: "net_30", + description: "Pilot project quote, rejected due to budget constraints.", + internal_notes: "Customer requested re-quote with smaller scope." + } + ] +}); +var quoteLineItems = defineSeed6(QuoteLineItem, { + mode: "upsert", + externalId: ["crm_quote", "crm_product"], + records: lineItemRecords("crm_quote", QUOTE_LINES) +}); + +// src/service/data/service.seed.ts +import { defineSeed as defineSeed7 } from "@objectstack/spec/data"; +import { cel as cel35 } from "@objectstack/spec"; + +// src/service/objects/_case-sla.ts +var CASE_SLA_DEFAULT_TIER = "smb"; +var CASE_SLA_CALENDAR_HOURS = { + // strategic enterprise mid_market smb + critical: { strategic: 4, enterprise: 4, mid_market: 4, smb: 4 }, + high: { strategic: 6, enterprise: 8, mid_market: 8, smb: 8 }, + medium: { strategic: 24, enterprise: 36, mid_market: 48, smb: 48 }, + low: { strategic: 96, enterprise: 120, mid_market: 168, smb: 168 } +}; +function caseSlaCalendarHours(priority, tier) { + const row = CASE_SLA_CALENDAR_HOURS[priority]; + if (!row) return void 0; + return row[tier] ?? row[CASE_SLA_DEFAULT_TIER]; +} +var caseSlaBreached = (dueAt, clockStoppedAt) => dueAt < clockStoppedAt; + +// src/service/data/service.seed.ts +var TIER_BY_ACCOUNT = new Map( + accounts.records.map((a) => [ + String(a.name), + typeof a.tier === "string" ? a.tier : CASE_SLA_DEFAULT_TIER + ]) +); +var seededSlaHours = (priority, accountName) => { + const hours = caseSlaCalendarHours(priority, accountName ? TIER_BY_ACCOUNT.get(accountName) : void 0); + if (hours === void 0) throw new Error(`seed: no SLA matrix row for priority "${priority}"`); + return hours; +}; +var celCaseSlaDue = (createdDaysAgo, priority, accountName) => cel35`daysAgo(${createdDaysAgo}) + duration('${seededSlaHours(priority, accountName)}h')`; +var seededSettledBreach = (createdDaysAgo, settledDaysAgo, priority, accountName) => caseSlaBreached(seededSlaHours(priority, accountName), (createdDaysAgo - settledDaysAgo) * 24); +var cases = defineSeed7(Case, { + mode: "upsert", + externalId: "subject", + records: [ + { + subject: "Login issues after platform upgrade", + description: `Users in the EMEA office report intermittent 401 errors when logging in after the v4.2 upgrade rolled out Wednesday night. Pattern: only affects users authenticating via SAML through Okta, only between 09:00\u201310:30 UTC. NA and APAC users are unaffected. + +**Customer impact:** ~40 users blocked at peak, costing ~3 productive hours per affected user. + +**Initial triage:** Suspect a clock-skew issue on the EMEA SSO relay added during the upgrade window. Engineering is reproducing in staging.`, + crm_account: "Acme Corporation", + crm_contact: "john.smith@acme.example.com", + status: "in_progress", + priority: "high", + priority_rank: 3, + type: "problem", + origin: "email", + is_closed: false, + is_sla_violated: false, + is_escalated: false, + created_at: cel35`daysAgo(2)`, + sla_due_date: celCaseSlaDue(2, "high", "Acme Corporation") + }, + { + subject: "Data export timing out for large datasets", + description: "CSV export fails for datasets over 10k rows.", + crm_account: "Globex Industries", + crm_contact: "sarah.j@globex.example.com", + status: "escalated", + priority: "critical", + priority_rank: 4, + type: "bug", + origin: "phone", + is_closed: false, + is_sla_violated: true, + is_escalated: true, + escalation_reason: "Customer threatening churn", + created_at: cel35`daysAgo(5)`, + sla_due_date: celCaseSlaDue(5, "critical", "Globex Industries") + }, + { + subject: "How to configure SSO with Okta?", + description: "Customer needs guidance on SSO setup with Okta.", + crm_account: "Initech Solutions", + crm_contact: "mchen@initech.example.com", + status: "resolved", + priority: "medium", + priority_rank: 2, + type: "question", + origin: "web", + // Resolved-but-not-closed: case.hook keeps is_closed=false and stamps + // closed_date as the resolved-date proxy; resolution_time_hours is the + // closed−created delta the hook would compute (daysAgo() is day-granular, + // so deltas come in 24h steps). + is_closed: false, + is_sla_violated: seededSettledBreach(3, 2, "medium", "Initech Solutions"), + is_escalated: false, + resolution_time_hours: 24, + created_at: cel35`daysAgo(3)`, + closed_date: cel35`daysAgo(2)`, + sla_due_date: celCaseSlaDue(3, "medium", "Initech Solutions") + }, + { + subject: "API rate limit exceeded on production", + description: "Production environment hitting rate limits during peak hours.", + crm_account: "Wayne Enterprises", + crm_contact: "rwilson@wayne.example.com", + status: "closed", + priority: "high", + priority_rank: 3, + type: "problem", + origin: "chat", + is_closed: true, + is_sla_violated: seededSettledBreach(7, 6, "high", "Wayne Enterprises"), + is_escalated: false, + // `resolution` is REQUIRED when status is 'closed' (object validation + // `resolution_required_for_closed`) — without it the seed row is rejected. + resolution: "Raised the production rate-limit tier and added client-side backoff; usage now within limits.", + // The deflection link (#601): this case was answered out of the knowledge + // base, so it names the article that resolved it. Referenced by the + // article seed's `externalId` (`title`), the same way every other seeded + // lookup names its target. + resolved_by_article: "API Rate Limits", + // closed−created delta, as case.hook computes it. + resolution_time_hours: 24, + created_at: cel35`daysAgo(7)`, + closed_date: cel35`daysAgo(6)`, + sla_due_date: celCaseSlaDue(7, "high", "Wayne Enterprises") + }, + { + subject: "PDF reports not rendering charts correctly", + description: "Charts appear blank when exporting dashboard to PDF.", + crm_account: "Stark Medical", + crm_contact: "emily.d@starkmed.example.com", + status: "new", + priority: "medium", + priority_rank: 2, + type: "bug", + origin: "email", + is_closed: false, + is_sla_violated: false, + is_escalated: false, + created_at: cel35`daysAgo(1)`, + sla_due_date: celCaseSlaDue(1, "medium", "Stark Medical") + }, + { + subject: "Billing discrepancy on last invoice", + description: `Customer (Lisa Kim, Procurement) flagged that the May invoice shows 15 active seats but Acme is only using 12. Two of the seats were de-provisioned in early April when two engineers left the company. + +**Root cause:** the de-provisioning happened in our admin console but the seat-count metric in billing only refreshes monthly, so the May invoice picked up the pre-change count. + +**Resolution path:** issue a $1,200 credit memo and switch Acme to the new real-time seat-billing pipeline so this can't recur. Waiting on Lisa to confirm she's good with the credit-memo treatment vs a refund.`, + crm_account: "Acme Corporation", + crm_contact: "john.smith@acme.example.com", + status: "waiting_customer", + priority: "low", + priority_rank: 1, + type: "problem", + origin: "email", + is_closed: false, + is_sla_violated: false, + is_escalated: false, + created_at: cel35`daysAgo(4)`, + sla_due_date: celCaseSlaDue(4, "low", "Acme Corporation") + }, + { + subject: "Mobile app crashes on iOS 17", + description: "App crashes on launch for users running iOS 17.2+.", + crm_account: "Globex Industries", + crm_contact: "sarah.j@globex.example.com", + status: "in_progress", + priority: "critical", + priority_rank: 4, + type: "bug", + origin: "web", + is_closed: false, + is_sla_violated: true, + is_escalated: true, + escalation_reason: "Affects 30% of mobile users", + created_at: cel35`daysAgo(3)`, + sla_due_date: celCaseSlaDue(3, "critical", "Globex Industries") + }, + { + subject: "Request: bulk import via CSV", + description: "Customer requesting ability to import records via CSV upload.", + crm_account: "Wayne Enterprises", + crm_contact: "rwilson@wayne.example.com", + status: "closed", + priority: "low", + priority_rank: 1, + type: "feature_request", + origin: "web", + is_closed: true, + is_sla_violated: seededSettledBreach(10, 8, "low", "Wayne Enterprises"), + is_escalated: false, + // Required for closed cases (resolution_required_for_closed). + resolution: "Delivered CSV bulk-import in the 9.4 release; shared the docs link with the customer.", + // closed−created delta, as case.hook computes it. + resolution_time_hours: 48, + created_at: cel35`daysAgo(10)`, + closed_date: cel35`daysAgo(8)`, + sla_due_date: celCaseSlaDue(10, "low", "Wayne Enterprises") + }, + // ─── Generated demo cases — 30 cases over the last 30 days, mixed across + // priorities. Powers `CasesOpenedByDayPriorityReport` (daily bucketing + // matrix) and the service dashboard's daily-volume area chart. + // + // ### Why every axis carries a rotation, and not just `i % length` (#1659) + // + // These rows used to read ONE counter for every axis: `crm_account` and + // `status` both took `i % 5`, and `priority`, `type` and `origin` all took + // `i % 4`. Equal-length lists walked by one index advance in lockstep, so + // each group came out PERFECTLY correlated — every Acme case `new`, every + // Globex case `in_progress`, and every `low` case a `question` raised by + // `email`. Thirty rows of volume with no variety, which is the opposite of + // what a volume generator is for: the account × status cross-tab held 5 of + // its 25 cells, and priority × type × origin 4 of 16 apiece. + // + // Each list now advances one step per row PLUS a rotation — `c` extra steps + // every `m` rows. Two axes stay correlated exactly when their relative + // offset never moves, so the rotations are chosen to make every relative + // offset sweep its whole cycle. `crm_account` is the anchor and carries no + // rotation; the other four are stated relative to it. + // + // `account × status` is complete BY CONSTRUCTION rather than by luck, and + // the proof is one line: account `a` takes rows i = a, a+5 … a+25, whose + // block numbers run 0…5, so its statuses are `(a + b) % 5` over b = 0…5 — + // all five of them. The thirty rows therefore walk the whole 5 × 5 grid, + // twenty-five cells once and five of them a second time. + // + // ⚠️ The remaining three constants are TUNED, not derived. They were picked + // by computing all ten pairwise cross-tabs and keeping the assignment that + // left the fewest empty cells. Measured over the lists as shipped: 188 of + // the 193 pairwise cells are occupied, no cell holds more than 3 rows, and + // the marginals stay as flat as thirty rows allow — 6/6/6/6/6 by account + // and by status, 8/7/7/8 by priority, type and origin. ⛔ Changing the + // LENGTH of any list below voids that tuning: re-measure the cross-tabs + // rather than assuming the rotations still separate the axes. + // + // Two schemes that read as more principled than they measure were rejected + // here, and are recorded so they are not re-derived: rotating the 5-lists + // on the 4-block and the 4-lists on the 5-block ("the lengths are coprime, + // so they cannot resonate") empties one status completely; and rotating + // `crm_account` as well — to break the every-fifth-day beat it walks the + // calendar on — costs twelve further empty cells. That beat is the + // deliberate price of anchoring: with one row per day, some axis has to be + // the fixed one the other four are measured against. + ...(() => { + const priorities = ["low", "medium", "high", "critical"]; + const rankByPriority = { low: 1, medium: 2, high: 3, critical: 4 }; + const types = ["question", "bug", "problem", "feature_request"]; + const origins = ["email", "phone", "web", "chat"]; + const statuses = ["new", "in_progress", "resolved", "closed", "escalated"]; + const accountsList = ["Acme Corporation", "Globex Industries", "Wayne Enterprises", "Initech Solutions", "Stark Medical"]; + const out = []; + for (let i = 0; i < 30; i++) { + const account = accountsList[i % accountsList.length]; + const status = statuses[(i + Math.floor(i / accountsList.length)) % statuses.length]; + const priority = priorities[(i + Math.floor(i / priorities.length)) % priorities.length]; + const type = types[(i + 2 * Math.floor(i / types.length)) % types.length]; + const origin = origins[(i + Math.floor(i / 10)) % origins.length]; + const settled = status === "resolved" || status === "closed"; + const ageDays = 1 + i % 30; + const resolutionDays = Math.min(ageDays, 1 + i % 3); + const slaViolated = settled ? seededSettledBreach(ageDays, ageDays - resolutionDays, priority, account) : priority === "critical" && i % 3 === 0; + out.push({ + subject: `Demo case ${String(i + 1).padStart(2, "0")} \u2014 ${priority} ${type}`, + description: `Auto-generated demo case for ${priority} priority on day -${ageDays}.`, + crm_account: account, + status, + priority, + priority_rank: rankByPriority[priority], + type, + origin, + // is_closed strictly mirrors case.hook: true ONLY for status + // 'closed' — a resolved case is NOT closed yet. + is_closed: status === "closed", + is_sla_violated: slaViolated, + is_escalated: status === "escalated", + ...settled ? { resolution_time_hours: resolutionDays * 24 } : {}, + // Object validations require these when closed/escalated — without + // them the generated rows are rejected (resolution_required_for_closed + // / escalation_reason_required). + ...status === "closed" ? { resolution: "Resolved per standard runbook; root cause documented and customer confirmed." } : {}, + ...status === "escalated" ? { escalation_reason: "Escalated to tier-2 engineering for SLA-risk review." } : {}, + created_at: celDaysAgo(ageDays), + // Resolved cases also carry closed_date: case.hook stamps it as the + // resolved-date proxy while keeping is_closed=false. + ...settled ? { closed_date: celDaysAgo(ageDays - resolutionDays) } : {}, + sla_due_date: celCaseSlaDue(ageDays, priority, account) + }); + } + return out; + })() + ] +}); +var knowledgeArticles = defineSeed7(KnowledgeArticle, { + mode: "upsert", + externalId: "title", + records: [ + { + title: "Getting Started with HotCRM", + summary: "A five-minute tour of accounts, contacts, leads and the sales pipeline.", + category: "getting_started", + status: "published", + audience: "public", + language: "en", + body: `# Getting Started with HotCRM + +Welcome! This guide walks you through the core objects: + +1. **Accounts** \u2014 the companies you sell to and serve. +2. **Contacts** \u2014 the people at those accounts. +3. **Leads** \u2014 unqualified prospects in the top of the funnel. +4. **Opportunities** \u2014 qualified deals moving through your pipeline. + +Open the **Sales Pipeline** kanban to drag deals between stages, and use the +**Executive Overview** dashboard to track revenue at a glance.`, + published_at: cel35`daysAgo(40)`, + last_reviewed_at: cel35`daysAgo(20)` + }, + { + title: "Resetting Your Password", + summary: "How end users reset a forgotten password from the login screen.", + category: "how_to", + status: "published", + audience: "public", + language: "en", + body: `# Resetting Your Password + +1. On the login screen, click **Forgot password?** +2. Enter the email associated with your account. +3. Check your inbox for a reset link (valid for 30 minutes). +4. Choose a new password of at least 12 characters. + +If the email does not arrive, check spam or contact your administrator.`, + published_at: cel35`daysAgo(25)`, + last_reviewed_at: cel35`daysAgo(10)` + }, + { + title: "API Rate Limits", + summary: "Per-token request quotas and recommended back-off strategy.", + category: "api", + status: "draft", + audience: "internal", + language: "en", + body: `# API Rate Limits (DRAFT) + +Default quota is 600 requests/minute per token. On HTTP 429, back off +exponentially starting at 1s. Numbers pending final review with platform team.` + }, + { + title: "Legacy SSO Setup", + summary: "SAML configuration for the pre-2025 identity stack.", + category: "troubleshooting", + status: "published", + audience: "internal", + language: "en", + body: `# Legacy SSO Setup + +This covers the deprecated SAML 1.1 flow. New tenants should use the OIDC +connector instead. Retained for customers still on the legacy stack.`, + published_at: cel35`daysAgo(240)`, + last_reviewed_at: cel35`daysAgo(220)` + } + ] +}); + +// src/marketing/data/marketing.seed.ts +import { defineSeed as defineSeed8 } from "@objectstack/spec/data"; +import { cel as cel36 } from "@objectstack/spec"; +var CAMPAIGN_MEMBERS = { + "Q3 Enterprise Email Nurture": [ + { lead: "noah.patel@vertexanalytics.example.com", status: "responded", addedDaysAgo: 14, respondedDaysAgo: 9 }, + { lead: "maya.singh@bluepeaklogistics.example.com", status: "sent", addedDaysAgo: 14 }, + { lead: "owen.becker@northwindenergy.example.com", status: "responded", addedDaysAgo: 14, respondedDaysAgo: 11 }, + { lead: "sara.lopez@heliossolar.example.com", status: "sent", addedDaysAgo: 14 }, + { lead: "leo.vance@cleancart.example.com", status: "unsubscribed", addedDaysAgo: 14 }, + { lead: "iris.okafor@pulsehealth.example.com", status: "sent", addedDaysAgo: 13 }, + { lead: "ravi.mehta@foundryrobotics.example.com", status: "sent", addedDaysAgo: 13 }, + { lead: "tess.brown@latticeeducation.example.com", status: "responded", addedDaysAgo: 13, respondedDaysAgo: 8 }, + { contact: "john.smith@acme.example.com", status: "responded", addedDaysAgo: 14, respondedDaysAgo: 10 }, + { contact: "ethan.brooks@vertex.example.com", status: "sent", addedDaysAgo: 14 }, + { contact: "priya.shah@lattice.example.com", status: "responded", addedDaysAgo: 14, respondedDaysAgo: 7 }, + { contact: "rwilson@wayne.example.com", status: "sent", addedDaysAgo: 13 } + ], + "Operations Platform Launch": [ + { lead: "jonas.holt@polarcargo.example.com", status: "responded", addedDaysAgo: 11, respondedDaysAgo: 6 }, + { lead: "anya.volkov@redoakrealty.example.com", status: "sent", addedDaysAgo: 11 }, + { lead: "theo.park@skylinemedia.example.com", status: "sent", addedDaysAgo: 11 }, + { lead: "wren.garcia@maplebakerygroup.example.com", status: "responded", addedDaysAgo: 10, respondedDaysAgo: 5 }, + { lead: "hugo.dubois@nimbusaerospace.example.com", status: "sent", addedDaysAgo: 10 }, + { contact: "rwilson@wayne.example.com", status: "responded", addedDaysAgo: 11, respondedDaysAgo: 7 }, + { contact: "marcus.reed@apexlogistics.example.com", status: "sent", addedDaysAgo: 11 }, + { contact: "olivia.chen@northwind.example.com", status: "sent", addedDaysAgo: 10 }, + { contact: "sarah.j@globex.example.com", status: "sent", addedDaysAgo: 10 } + ], + "Developer Content Marketing Push": [ + { lead: "lena.fischer@graniteinsurance.example.com", status: "responded", addedDaysAgo: 33, respondedDaysAgo: 27 }, + { lead: "kai.watanabe@coralreefhotels.example.com", status: "sent", addedDaysAgo: 33 }, + { lead: "mira.costa@atlasconstruction.example.com", status: "unsubscribed", addedDaysAgo: 33 }, + { lead: "pia.anand@citrinefinance.example.com", status: "responded", addedDaysAgo: 32, respondedDaysAgo: 24 }, + { lead: "marco.ricci@auroratravel.example.com", status: "sent", addedDaysAgo: 32 }, + { lead: "lisa.t@cloudfirst.example.com", status: "responded", addedDaysAgo: 30, respondedDaysAgo: 21 }, + { contact: "ethan.brooks@vertex.example.com", status: "responded", addedDaysAgo: 33, respondedDaysAgo: 19 }, + { contact: "mchen@initech.example.com", status: "sent", addedDaysAgo: 33 }, + { contact: "john.smith@acme.example.com", status: "sent", addedDaysAgo: 32 }, + { contact: "emily.d@starkmed.example.com", status: "sent", addedDaysAgo: 32 }, + { contact: "sarah.j@globex.example.com", status: "sent", addedDaysAgo: 30 } + ], + // Campaigns still in `planning` carry their invitation / registration list: + // the enrollment flow runs for `planning` and `in_progress` campaigns alike + // and stamps `sent` on enrollment, so a pre-launch target list looks exactly + // like this. + "Cloud Migration Webinar": [ + { lead: "dkim@edutechlabs.example.com", status: "sent", addedDaysAgo: 4 }, + { lead: "alice@nextgenretail.example.com", status: "sent", addedDaysAgo: 4 }, + { lead: "jonas.holt@polarcargo.example.com", status: "sent", addedDaysAgo: 3 }, + { lead: "anya.volkov@redoakrealty.example.com", status: "sent", addedDaysAgo: 3 }, + { contact: "mchen@initech.example.com", status: "sent", addedDaysAgo: 4 }, + { contact: "marcus.reed@apexlogistics.example.com", status: "sent", addedDaysAgo: 3 } + ], + "Executive AI Governance Roundtable": [ + { contact: "john.smith@acme.example.com", status: "sent", addedDaysAgo: 6 }, + { contact: "rwilson@wayne.example.com", status: "sent", addedDaysAgo: 6 }, + { contact: "ethan.brooks@vertex.example.com", status: "sent", addedDaysAgo: 5 }, + { contact: "priya.shah@lattice.example.com", status: "sent", addedDaysAgo: 5 }, + { contact: "emily.d@starkmed.example.com", status: "sent", addedDaysAgo: 5 } + ], + "Partner Operations Roadshow": [ + { lead: "maya.singh@bluepeaklogistics.example.com", status: "sent", addedDaysAgo: 7 }, + { lead: "ravi.mehta@foundryrobotics.example.com", status: "sent", addedDaysAgo: 7 }, + { contact: "marcus.reed@apexlogistics.example.com", status: "sent", addedDaysAgo: 6 }, + { contact: "olivia.chen@northwind.example.com", status: "sent", addedDaysAgo: 6 } + ], + "SaaSCon 2026 Trade Show": [ + { lead: "theo.park@skylinemedia.example.com", status: "sent", addedDaysAgo: 8 }, + { lead: "wren.garcia@maplebakerygroup.example.com", status: "sent", addedDaysAgo: 8 }, + { lead: "hugo.dubois@nimbusaerospace.example.com", status: "sent", addedDaysAgo: 7 }, + { lead: "marco.ricci@auroratravel.example.com", status: "sent", addedDaysAgo: 7 } + ] +}; +var campaignMetrics = (campaignName) => { + const members = CAMPAIGN_MEMBERS[campaignName] ?? []; + const leadKeys = new Set(members.map((m) => m.lead).filter((e) => Boolean(e))); + const convertedLeads = leads.records.filter( + (l) => typeof l.email === "string" && leadKeys.has(l.email) && l.is_converted === true + ).length; + const attributed = opportunities.records.filter((o) => o.crm_campaign === campaignName); + const won = attributed.filter((o) => o.stage === "closed_won"); + return { + // "Total members enrolled" — campaign.hook.ts's single definition of num_sent. + num_sent: members.length, + // `responded` or `converted`, as in `computeCampaignMetrics`. The seed set + // holds no `converted` member (see the note on CAMPAIGN_MEMBERS), so the + // two predicates coincide on this data — spelled the narrow way because + // widening it here would suggest a seeded state that does not exist. + num_responses: members.filter((m) => m.status === "responded").length, + num_leads: leadKeys.size, + num_converted_leads: convertedLeads, + num_opportunities: attributed.length, + num_won_opportunities: won.length, + actual_revenue: won.reduce((sum, o) => sum + (typeof o.amount === "number" ? o.amount : 0), 0) + }; +}; +var campaigns = defineSeed8(Campaign, { + mode: "upsert", + externalId: "name", + records: [ + { + name: "Q3 Enterprise Email Nurture", + description: "Multi-touch nurture for enterprise IT decision makers evaluating AI governance and analytics.", + type: "email", + channel: "email", + status: "in_progress", + start_date: cel36`daysAgo(15)`, + end_date: cel36`daysFromNow(21)`, + budgeted_cost: 28e3, + actual_cost: 14e3, + expected_revenue: 56e4, + target_size: 5e3, + ...campaignMetrics("Q3 Enterprise Email Nurture"), + landing_page_url: "https://acme.example.com/lp/enterprise-q3", + is_active: true + }, + { + name: "Executive AI Governance Roundtable", + description: "A live executive roundtable on operating AI agents with governance, auditability and trust.", + type: "conference", + channel: "events", + status: "planning", + start_date: cel36`daysFromNow(2)`, + end_date: cel36`daysFromNow(3)`, + budgeted_cost: 22e3, + expected_revenue: 32e4, + target_size: 120, + ...campaignMetrics("Executive AI Governance Roundtable"), + is_active: true + }, + { + name: "Cloud Migration Webinar", + description: "A technical webinar on modernizing customer operations and data workflows in the cloud.", + type: "webinar", + channel: "digital", + status: "planning", + start_date: cel36`daysFromNow(6)`, + end_date: cel36`daysFromNow(8)`, + budgeted_cost: 18e3, + expected_revenue: 36e4, + target_size: 1500, + ...campaignMetrics("Cloud Migration Webinar"), + landing_page_url: "https://acme.example.com/webinars/cloud-migration", + is_active: true + }, + { + name: "Operations Platform Launch", + description: "Launch campaign for the operations platform, pairing product content with customer proof points.", + type: "content", + channel: "digital", + status: "in_progress", + // Was `daysFromNow(12)` — an `in_progress` campaign that had not started + // yet, which no attribution can be consistent with (#591). + start_date: cel36`daysAgo(12)`, + end_date: cel36`daysFromNow(14)`, + budgeted_cost: 36e3, + actual_cost: 12e3, + expected_revenue: 48e4, + target_size: 8e3, + ...campaignMetrics("Operations Platform Launch"), + landing_page_url: "https://acme.example.com/launch/operations-platform", + is_active: true + }, + { + name: "Partner Operations Roadshow", + description: "Joint regional sessions with strategic partners for operations and IT leaders.", + type: "partner", + channel: "partner", + status: "planning", + start_date: cel36`daysFromNow(19)`, + end_date: cel36`daysFromNow(22)`, + budgeted_cost: 48e3, + expected_revenue: 72e4, + target_size: 600, + ...campaignMetrics("Partner Operations Roadshow"), + is_active: true + }, + { + name: "SaaSCon 2026 Trade Show", + description: "A focused booth, executive dinner and customer-story program at the SaaSCon industry conference.", + type: "trade_show", + channel: "events", + status: "planning", + start_date: cel36`daysFromNow(27)`, + end_date: cel36`daysFromNow(30)`, + budgeted_cost: 75e3, + expected_revenue: 12e5, + target_size: 3e3, + ...campaignMetrics("SaaSCon 2026 Trade Show"), + is_active: true + }, + { + name: "Developer Content Marketing Push", + description: "Technical blog posts, video tutorials and developer community engagement completed last month.", + type: "content", + channel: "digital", + status: "completed", + start_date: cel36`daysAgo(35)`, + end_date: cel36`daysAgo(4)`, + budgeted_cost: 4e4, + actual_cost: 25e3, + expected_revenue: 25e4, + target_size: 1e4, + ...campaignMetrics("Developer Content Marketing Push"), + landing_page_url: "https://acme.example.com/developers", + is_active: true + } + ] +}); +var memberRecords = (kind) => Object.entries(CAMPAIGN_MEMBERS).flatMap( + ([campaign, members]) => members.filter((m) => kind === "lead" ? m.lead : m.contact).map((m) => ({ + crm_campaign: campaign, + ...kind === "lead" ? { crm_lead: m.lead } : { crm_contact: m.contact }, + status: m.status, + added_date: celDaysAgo(m.addedDaysAgo), + // `has_responded` / `response_date` track the `responded` status + // exactly — a responded member with no response date is a shape the + // response-tracking surfaces cannot render. + has_responded: m.status === "responded", + ...m.respondedDaysAgo !== void 0 ? { response_date: celDaysAgo(m.respondedDaysAgo) } : {} + })) +); +var campaignMembersFromLeads = defineSeed8(CampaignMember, { + mode: "upsert", + externalId: ["crm_campaign", "crm_lead"], + records: memberRecords("lead") +}); +var campaignMembersFromContacts = defineSeed8(CampaignMember, { + mode: "upsert", + externalId: ["crm_campaign", "crm_contact"], + records: memberRecords("contact") +}); + +// objectstack.composition.ts +var byExportName = (merged) => Object.entries(merged).sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0).map(([, value]) => value); +var appHooks = [ + account_hook_default, + campaign_hook_default, + opportunity_campaign_metrics_hook_default, + lead_campaign_metrics_hook_default, + campaign_member_hook_default, + contact_hook_default, + contract_hook_default, + event_hook_default, + forecast_hook_default, + lead_hook_default, + opportunity_hook_default, + opportunity_line_item_hook_default, + product_hook_default, + quote_hook_default, + quote_line_item_hook_default, + task_hook_default +].flatMap((entry) => Array.isArray(entry) ? entry : [entry]); +var appFlows = [ + CampaignEnrollmentFlow, + CampaignLeadMemberEnrollFlow, + CampaignContactMemberEnrollFlow, + AccountApprovalFlow, + LeadConversionFlow, + LeadConversionApprovalFlow, + ScheduleFollowUpFlow, + OpportunityApprovalFlow, + OpportunityApprovalOnCreateFlow, + OpportunityStatusChangeApprovalFlow, + OpportunityQualificationApprovalFlow, + QuoteGenerationFlow, + ContractRenewalFlow, + OpportunityStagnationFlow, + ForecastSnapshotFlow, + LeadAssignmentFlow, + CampaignCompletionFlow, + QuoteExpirationFlow, + ContractExpirationFlow, + ContactWelcomeFlow, + OpportunityWonAlertFlow, + TaskUrgentAlertFlow, + TaskDueReminderFlow, + BillingHandoffClosedWonFlow, + BillingHandoffContractActivatedFlow +]; +var appSkills = [ + LeadQualificationSkill, + EmailDraftingSkill, + RevenueForecastingSkill, + Customer360Skill, + LiveDataSkill +]; +var appObjects = byExportName({ + ...objects_exports2, + ...objects_exports3, + ...objects_exports4 +}); +var appActions = byExportName({ ...actions_exports, ...actions_exports2 }); +var appDashboards = byExportName({ ...dashboards_exports }); +var appDatasets = byExportName({ ...datasets_exports, ...datasets_exports2 }); +var appReports = byExportName({ ...reports_exports }); +var appViews = byExportName({ + ...views_exports, + ...views_exports2, + ...views_exports3 +}); +var appPages = byExportName({ ...pages_exports }); +var appMappings = byExportName({ ...mappings_exports }); +var appApps = byExportName({ ...apps_exports }); +var appTranslations = byExportName({ ...translations_exports }); +var appEmailTemplates = byExportName({ + ...email_templates_exports, + ...email_templates_exports2 +}).flat(); +var allProfiles = profiles_exports; +var appSharingRules = [ + AccountTeamSharingRule, + OpportunitySalesSharingRule, + OpportunityExecutiveSharingRule, + ...TerritorySharingRules, + ...CampaignLeadershipSharingRules +]; +var allHooks = [...appHooks, ...serviceHooks]; +var allFlows = [...appFlows, ...serviceFlows]; +var allSkills = [...appSkills, ...serviceSkills]; +var CrmSharingRules = [...appSharingRules, ...serviceSharingRules]; +var CrmSeedData = [ + accounts, + contacts, + leads, + opportunities, + products, + opportunityLineItems, + tasks, + cases, + // Events come after the five objects their `related_to_*` lookups resolve + // against (accounts, contacts, leads, opportunities, cases); the attendee + // junctions come after the events they hang off. + events, + eventAttendeesFromContacts, + eventAttendeesFromLeads, + leadInteractionPointers, + campaigns, + campaignMembersFromLeads, + campaignMembersFromContacts, + contracts, + quotes, + quoteLineItems, + forecasts, + knowledgeArticles +]; +var SaasTenantSeedData = [products]; +var ServiceSeedData = [cases, knowledgeArticles]; +var AppSeedData = CrmSeedData.filter((family) => !ServiceSeedData.includes(family)); +var seedDataFor = (composition2) => composition2 === "saas" ? { app: SaasTenantSeedData, service: [] } : { app: AppSeedData, service: ServiceSeedData }; +var composition = resolveComposition(); +var isSaas = composition === "saas"; +var seedData = seedDataFor(composition); +var compositionPermissions = isSaas ? [...Object.values(allProfiles).filter((set) => set !== SystemAdminProfile), TenantAdminProfile] : Object.values(allProfiles); +var serviceStack = createHotCrmServiceStack({ data: seedData.service }); +var appStack = createHotCrmAppStack( + { + objects: appObjects, + actions: appActions, + dashboards: appDashboards, + datasets: appDatasets, + reports: appReports, + // Reusable import projections (#603). Referenced by name from the import + // endpoint — `mappingName: 'crm_account_import'` — so a customer's own + // spreadsheet loads without per-column mapping by hand. Templates: + // `assets/import-templates/`. + mappings: appMappings, + flows: appFlows, + skills: appSkills, + permissions: compositionPermissions, + apps: appApps, + views: appViews, + pages: appPages, + // Approvals are modeled as `record_change` flows with `approval` nodes + // (ADR-0019); see src/sales/flows/opportunity-approval.flow.ts. The + // standalone `approvals` stack field was removed in ObjectStack 7.4. + // No `analyticsCubes`: datasets (ADR-0021) are the semantic layer — the + // analytics service compiles each dataset into its cube internally, and a + // second hand-written cube layer only duplicates and drifts. + hooks: appHooks, + data: seedData.app, + translations: appTranslations, + // The localizable content path for `notify` (#9205). A node names a template + // and supplies its `templateData`; the delivery path resolves + // `(name, locale)` against these rows PER RECIPIENT, after fan-out — the + // recipient's own `sys_user.locale` when set, else `i18n.defaultLocale` — + // so two people on one notification can read it in two languages. + emailTemplates: appEmailTemplates, + sharingRules: appSharingRules, + // ADR-0090 D3: positions are flat capability-distribution groups — the v1 + // role hierarchy's parent links are gone (hierarchy belongs to the + // business-unit tree, which this app does not model). + positions: CrmPositions + }, + { artifactObjects: (serviceStack.objects ?? []).map((object) => object.name) } +); + +// objectstack.config.ts +var objectstack_config_default = composeStacks([serviceStack, appStack], { manifest: "preserve" }); +export { + objectstack_config_default as default +}; +//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["objectstack.config.ts", "src/sales/index.ts", "src/service/index.ts", "src/service/actions/case.actions.ts", "src/service/objects/index.ts", "src/service/objects/article_feedback.object.ts", "src/service/objects/case.object.ts", "src/service/objects/knowledge_article.object.ts", "src/sales/objects/index.ts", "src/sales/objects/account.object.ts", "src/sales/objects/_picklists.ts", "src/sales/objects/_territory.ts", "src/sales/objects/contact.object.ts", "src/sales/objects/event.object.ts", "src/sales/objects/event_attendee.object.ts", "src/sales/objects/forecast.object.ts", "src/sales/objects/lead.object.ts", "src/sales/objects/opportunity.object.ts", "src/sales/objects/task.object.ts", "src/sales/actions/activity-actions.ts", "src/service/actions/case-activity.actions.ts", "src/service/actions/knowledge_article.actions.ts", "src/service/dashboards/service.dashboard.ts", "src/service/datasets/case.dataset.ts", "src/sales/email-templates/_bundle.ts", "src/service/email-templates/en.ts", "src/service/email-templates/zh-CN.ts", "src/service/email-templates/ja-JP.ts", "src/service/email-templates/es-ES.ts", "src/service/email-templates/crm.email-template.ts", "src/service/flows/case-escalation.flow.ts", "src/service/flows/case-actions.flow.ts", "src/service/objects/_case-assignment.ts", "src/service/flows/case-escalation-stamp.flow.ts", "src/service/flows/case-sla-monitor.flow.ts", "src/sales/flows/_guarded-iteration.ts", "src/service/objects/article_feedback.hook.ts", "src/service/objects/case.hook.ts", "src/service/objects/knowledge_article.hook.ts", "src/service/pages/case_detail.page.ts", "src/service/reports/case.report.ts", "src/service/sharing/case.sharing.ts", "src/service/skills/case-triage.skill.ts", "src/service/views/case.view.ts", "src/service/views/knowledge_article.view.ts", "src/revenue/objects/index.ts", "src/revenue/objects/contract.object.ts", "src/revenue/objects/opportunity_line_item.object.ts", "src/revenue/objects/product.object.ts", "src/revenue/objects/quote.object.ts", "src/sales/objects/_thresholds.ts", "src/revenue/objects/quote_line_item.object.ts", "src/marketing/objects/index.ts", "src/marketing/objects/campaign.object.ts", "src/marketing/objects/campaign_member.object.ts", "src/sales/actions/index.ts", "src/sales/actions/contact.actions.ts", "src/sales/actions/lead.actions.ts", "src/sales/actions/opportunity.actions.ts", "src/marketing/actions/index.ts", "src/marketing/actions/campaign.actions.ts", "src/sales/dashboards/index.ts", "src/sales/dashboards/activity.dashboard.ts", "src/sales/dashboards/shared-widgets.ts", "src/sales/dashboards/crm.dashboard.ts", "src/sales/dashboards/executive.dashboard.ts", "src/sales/dashboards/sales.dashboard.ts", "src/sales/datasets/index.ts", "src/sales/datasets/opportunity.dataset.ts", "src/sales/datasets/account.dataset.ts", "src/sales/datasets/contact.dataset.ts", "src/sales/datasets/lead.dataset.ts", "src/sales/datasets/task.dataset.ts", "src/sales/datasets/event.dataset.ts", "src/sales/datasets/forecast.dataset.ts", "src/revenue/datasets/index.ts", "src/revenue/datasets/product.dataset.ts", "src/sales/reports/index.ts", "src/sales/reports/account.report.ts", "src/sales/reports/lead.report.ts", "src/sales/reports/opportunity.report.ts", "src/sales/reports/churn.report.ts", "src/sales/mappings/index.ts", "src/sales/mappings/account_import.mapping.ts", "src/sales/mappings/_shared.ts", "src/sales/mappings/contact_import.mapping.ts", "src/sales/mappings/lead_import.mapping.ts", "src/sales/apps/index.ts", "src/sales/apps/crm.app.ts", "src/sales/profiles/index.ts", "src/sales/profiles/guest-portal.profile.ts", "src/sales/profiles/marketing-user.profile.ts", "src/sales/profiles/sales-manager.profile.ts", "src/sales/profiles/sales-rep.profile.ts", "src/sales/profiles/service-agent.profile.ts", "src/sales/profiles/system-admin.profile.ts", "src/sales/translations/index.ts", "src/sales/translations/en/app.ts", "src/sales/translations/en/_shared.ts", "src/sales/translations/en/objects.customer.ts", "src/sales/translations/en/objects.pipeline.ts", "src/sales/translations/en/objects.commerce.ts", "src/sales/translations/en/objects.service.ts", "src/sales/translations/en/objects.activity.ts", "src/sales/translations/en/objects.marketing.ts", "src/sales/translations/en.ts", "src/sales/translations/zh-CN/app.ts", "src/sales/translations/zh-CN/_shared.ts", "src/sales/translations/zh-CN/objects.customer.ts", "src/sales/translations/zh-CN/objects.pipeline.ts", "src/sales/translations/zh-CN/objects.commerce.ts", "src/sales/translations/zh-CN/objects.service.ts", "src/sales/translations/zh-CN/objects.activity.ts", "src/sales/translations/zh-CN/objects.marketing.ts", "src/sales/translations/zh-CN.ts", "src/sales/translations/ja-JP/app.ts", "src/sales/translations/ja-JP/_shared.ts", "src/sales/translations/ja-JP/objects.customer.ts", "src/sales/translations/ja-JP/objects.pipeline.ts", "src/sales/translations/ja-JP/objects.commerce.ts", "src/sales/translations/ja-JP/objects.service.ts", "src/sales/translations/ja-JP/objects.activity.ts", "src/sales/translations/ja-JP/objects.marketing.ts", "src/sales/translations/ja-JP.ts", "src/sales/translations/es-ES/app.ts", "src/sales/translations/es-ES/_shared.ts", "src/sales/translations/es-ES/objects.customer.ts", "src/sales/translations/es-ES/objects.pipeline.ts", "src/sales/translations/es-ES/objects.commerce.ts", "src/sales/translations/es-ES/objects.service.ts", "src/sales/translations/es-ES/objects.activity.ts", "src/sales/translations/es-ES/objects.marketing.ts", "src/sales/translations/es-ES.ts", "src/sales/translations/crm.translation.ts", "src/sales/views/index.ts", "src/sales/views/lead.view.ts", "src/sales/views/account.view.ts", "src/sales/views/contact.view.ts", "src/sales/views/opportunity.view.ts", "src/sales/views/task.view.ts", "src/sales/views/event.view.ts", "src/sales/views/event_attendee.view.ts", "src/sales/views/forecast.view.ts", "src/revenue/views/index.ts", "src/revenue/views/contract.view.ts", "src/revenue/views/product.view.ts", "src/revenue/views/quote.view.ts", "src/marketing/views/index.ts", "src/marketing/views/campaign.view.ts", "src/sales/pages/index.ts", "src/sales/pages/lead_detail.page.ts", "src/sales/pages/opportunity_detail.page.ts", "src/sales/pages/account_detail.page.ts", "src/sales/pages/account_workbench.page.ts", "src/sales/pages/home.page.ts", "src/sales/pages/app_launcher.page.ts", "src/sales/pages/utility_bar.page.ts", "src/sales/email-templates/index.ts", "src/sales/email-templates/en.ts", "src/sales/email-templates/zh-CN.ts", "src/sales/email-templates/ja-JP.ts", "src/sales/email-templates/es-ES.ts", "src/sales/email-templates/crm.email-template.ts", "src/revenue/email-templates/index.ts", "src/revenue/email-templates/en.ts", "src/revenue/email-templates/zh-CN.ts", "src/revenue/email-templates/ja-JP.ts", "src/revenue/email-templates/es-ES.ts", "src/revenue/email-templates/crm.email-template.ts", "src/sales/profiles/tenant-admin.profile.ts", "src/sales/objects/account.hook.ts", "src/sales/objects/contact.hook.ts", "src/sales/objects/event.hook.ts", "src/sales/objects/forecast.hook.ts", "src/sales/objects/lead.hook.ts", "src/sales/objects/lead.campaign-metrics.hook.ts", "src/sales/objects/opportunity.hook.ts", "src/sales/objects/opportunity.campaign-metrics.hook.ts", "src/sales/objects/task.hook.ts", "src/revenue/objects/contract.hook.ts", "src/revenue/objects/_line-item-price-fill.ts", "src/revenue/objects/opportunity_line_item.hook.ts", "src/revenue/objects/product.hook.ts", "src/revenue/objects/quote.hook.ts", "src/revenue/objects/quote_line_item.hook.ts", "src/marketing/objects/campaign.hook.ts", "src/marketing/objects/campaign_member.hook.ts", "src/sales/flows/lead-conversion.flow.ts", "src/sales/flows/lead-conversion-approval.flow.ts", "src/sales/flows/account-approval.flow.ts", "src/sales/flows/schedule-followup.flow.ts", "src/sales/flows/opportunity-approval.flow.ts", "src/sales/flows/opportunity-status-change-approval.flow.ts", "src/sales/flows/opportunity-qualification-approval.flow.ts", "src/sales/flows/opportunity-stagnation.flow.ts", "src/sales/flows/forecast-snapshot.flow.ts", "src/sales/flows/lead-assignment.flow.ts", "src/sales/flows/contact-welcome.flow.ts", "src/sales/flows/opportunity-won-alert.flow.ts", "src/sales/flows/task-urgent-alert.flow.ts", "src/sales/flows/task-due-reminder.flow.ts", "src/sales/flows/billing-handoff-closed-won.flow.ts", "src/sales/flows/_billing-endpoint.ts", "src/revenue/flows/quote-generation.flow.ts", "src/revenue/flows/contract-renewal.flow.ts", "src/revenue/flows/quote-expiration.flow.ts", "src/revenue/flows/contract-expiration.flow.ts", "src/revenue/flows/billing-handoff-contract-activated.flow.ts", "src/marketing/flows/campaign-enrollment.flow.ts", "src/marketing/flows/campaign-member-enroll.flow.ts", "src/marketing/flows/campaign-completion.flow.ts", "src/sales/skills/lead-qualification.skill.ts", "src/sales/skills/email-drafting.skill.ts", "src/sales/skills/revenue-forecasting.skill.ts", "src/sales/skills/customer-360.skill.ts", "src/sales/skills/live-data.skill.ts", "src/sales/sharing/account.sharing.ts", "src/sales/sharing/opportunity.sharing.ts", "src/sales/sharing/positions.ts", "src/marketing/sharing/campaign.sharing.ts", "src/sales/data/sales.seed.ts", "src/sales/data/_shared.ts", "src/sales/data/activity.seed.ts", "src/sales/data/forecast.seed.ts", "src/sales/data/index.ts", "src/revenue/data/catalog.seed.ts", "src/revenue/data/opportunity-line-item.seed.ts", "src/revenue/data/revenue.seed.ts", "src/service/data/service.seed.ts", "src/service/objects/_case-sla.ts", "src/marketing/data/marketing.seed.ts", "objectstack.composition.ts"],
  "sourcesContent": ["const __injected_filename__ = \"/home/user/hotcrm-issue-2097/objectstack.config.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/objectstack.config.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport { composeStacks } from '@objectstack/spec';\n\n// The two package stacks, built \u2014 see `objectstack.composition.ts`, which also\n// resolves the `HOTCRM_COMPOSITION` knob and records why that work cannot live\n// in this file (\u26D4 this module may carry no named export: the build parses it\n// against a `.strict` stack schema and fails on any key but the default).\nimport { serviceStack, appStack } from './objectstack.composition.js';\n\n/**\n * ONE release artifact, TWO packages (ADR-0130 D4).\n *\n *  - `app.objectstack.hotcrm` (`src/sales/index.ts`) \u2014 the `type: 'app'`\n *    package a customer installs: sales, plus the `src/revenue/` and\n *    `src/marketing/` directories it still registers, the app and its\n *    navigation groups, the permission sets, the locale packs.\n *  - `app.objectstack.hotcrm.service` (`src/service/index.ts`) \u2014 the support\n *    module: cases and knowledge, and the five navigation entries it\n *    contributes into the app's groups.\n *\n * `manifest: 'preserve'` is the only option that separates \"one artifact\n * carrying N packages\" from the pick-one composition every other strategy\n * performs. It emits `packages[]`, one entry per input stack carrying that\n * package ASSEMBLED \u2014 its manifest plus the collections it owns. That list is\n * what `ObjectQL.registerApp` registers package by package, and it is where\n * per-package OWNERSHIP comes from. Each definition is carried ONCE, in the\n * body of the package that owns it: a multi-package artifact has no flattened\n * copy of its collections beside `packages[]` (ADR-0130 D4, 2026-09-22\n * addendum), so a reader wanting \"every object of the app\" resolves the\n * package bodies, as every platform reader does.\n *\n * The App package is LAST deliberately, and that is not the load-bearing half:\n *\n *  - the singular `manifest` is still picked by the default `'last'` rule, so\n *    the artifact identifies as the App a consumer installs (ADR-0019 D1),\n *    `app.objectstack.hotcrm`, not as one of its modules;\n *  - REGISTRATION order is decided by `dependencies` \u2014 the service module\n *    declares `app.objectstack.hotcrm`, and `packages[]` is sorted through the\n *    platform's one topological sorter (ADR-0130 D5, ADR-0116) \u2014 so the app\n *    registers first whatever slot it occupies here. An artifact that only\n *    worked because someone listed the packages in the right order is the\n *    failure ADR-0116 exists about, and it fails SILENTLY.\n *\n * `objectstack build` compiles this file into one `dist/objectstack.json`;\n * `objectstack dev` boots the same shape straight from source.\n */\nexport default composeStacks([serviceStack, appStack], { manifest: 'preserve' });\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/sales/index.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/sales\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/sales/index.ts\";// Copyright (c) 2026 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport { defineStack, type ObjectStackDefinition, type ObjectStackDefinitionInput } from '@objectstack/spec';\n\n/**\n * Everything the app package REGISTERS, as opposed to what it IS.\n *\n * The identity keys are not in it and cannot be passed: `manifest`, `requires`\n * and `i18n` are this package's own statement about itself, and `packages`\n * belongs to the artifact envelope one level up.\n */\nexport type HotCrmAppCollections = Omit<\n  ObjectStackDefinitionInput,\n  'manifest' | 'packages' | 'requires' | 'i18n'\n>;\n\n/**\n * `app.objectstack.hotcrm` \u2014 the App package of this artifact, and the sales\n * module (ADR-0130 D4, `module-split-plan.md` decision 4).\n *\n * ADR-0019 requires exactly one `type: 'app'` package per artifact and the\n * artifact takes its identity from it; nothing requires that package to be an\n * empty shell, and the platform's own two-package fixture\n * (`examples/app-multi-package`) says the opposite \u2014 its App package owns the\n * customer object and the navigation. So sales IS the app: it keeps the id\n * `app.objectstack.hotcrm`, owns the customer core and the activity objects,\n * the app and its navigation GROUPS, the cross-domain dashboards and skills,\n * the permission sets, the positions, the four locale packs, the import\n * mappings, and every source file more than one package needs.\n *\n * ## Why this file takes its collections instead of importing them\n *\n * `src/revenue/` and `src/marketing/` are packages in the LAYOUT but not yet\n * packages in the ARTIFACT \u2014 the ruling asked for sales and support first \u2014 so\n * the app package registers their collections for now. A file under\n * `src/sales/` may not import from a module directory (AGENTS.md *Project\n * Architecture* rule 2: own directory or `src/sales/`, never sideways), so the\n * assembly of those two cannot happen here. It happens in\n * `objectstack.composition.ts`, the root module that is allowed to see every\n * package. When revenue and marketing become packages of their own, the\n * argument shrinks to the sales barrels and this file can import them itself.\n *\n * ## `artifactObjects` \u2014 the permission sets stay whole here\n *\n * ADR-0130's 2026-09-02 addendum keeps every permission set WHOLE in the\n * `type: 'app'` package: a set is authored per ROLE, so no module owns one. The\n * app package also owns objects of its own, so `defineStack` would otherwise\n * read a grant on `crm_case` as a grant on an object \"not defined in objects\".\n * `artifactObjects` is the platform's answer to exactly that (objectstack#18202):\n * the names the OTHER packages of this artifact own, against which this\n * package's `permissions[].objects` and `data[].object` \u2014 and those two\n * reference classes only \u2014 are resolved. Measured on 17.7.0: without it, the\n * seven sets' 18 grants on `crm_case`, `crm_knowledge_article` and\n * `crm_article_feedback` are refused (\"defineStack cross-reference validation\n * failed (18 issues)\"); with it, none. The claim is verified, not trusted: a\n * grant naming an object no package of the artifact defines is still refused,\n * by `composeStacks`' artifact pass, even when the name is listed here. A hook\n * or an app navigation entry on another package's object stays refused;\n * navigation crosses only through the module's `navigationContributions`.\n *\n * ## What is deliberately NOT here\n *\n * The `HOTCRM_COMPOSITION` knob (#1361). It selects permission sets and seed\n * families, and it is resolved once at the root and handed down already\n * applied \u2014 `objectstack.composition.ts` carries the full audit of what the\n * knob changes and why, because the answer is about the ARTIFACT, not about\n * this package.\n */\nexport const createHotCrmAppStack = (\n  collections: HotCrmAppCollections,\n  options: { artifactObjects: readonly string[] },\n): ObjectStackDefinition =>\n  defineStack({\n    manifest: {\n      id: 'app.objectstack.hotcrm',\n      namespace: 'crm',\n      version: '4.0.1',\n      type: 'app',\n      name: 'HotCRM',\n      description: 'AI-Native CRM for the ObjectStack marketplace \u2014 Accounts, Contacts, Leads, Opportunities, Cases, Knowledge, Forecasts, Campaigns, Contracts.',\n      // ADR-0087 protocol handshake (ADR-0025 \u00A73.2): the metadata/runtime\n      // protocol major this app's metadata is authored against. Only the major\n      // participates in the check \u2014 a runtime on a different major refuses the\n      // load with a structured OS_PROTOCOL_INCOMPATIBLE diagnostic (naming the\n      // `objectstack migrate meta` replay) instead of failing deep in a schema\n      // parse. Bump together with `specVersion` on every platform upgrade\n      // (docs/MAINTENANCE.md \u00A73) \u2014 `test/docs-declared-versions.test.ts` now\n      // enforces that pairing against `objectstack.manifest.json` instead of\n      // trusting this comment, because two platform upgrades in a row (rc.2, then\n      // rc.3) moved the manifest and left this line behind (#728). Every package\n      // of this artifact states the same protocol; `src/service/index.ts`\n      // repeats it for the same reason.\n      engines: { protocol: '^18.0.0-next.0' },\n    },\n\n    // \u2500\u2500\u2500 Platform capabilities this app needs \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n    // The runtime resolves each capability name to a built-in service plugin\n    // and auto-loads it (with extras like Automation's node packs). No need\n    // to hand-instantiate plugins or pass `--preset` flags. See\n    // packages/cli/src/commands/serve.ts CAPABILITY_PROVIDERS for the\n    // complete map; explicit `plugins: [...]` always shadows the resolver.\n    // `auth` enables the auth/login surface (login/register) via @objectstack/plugin-auth.\n    // `ui`   serves the unified Console shell and CRM apps under /_console/\n    //        (login at /_console/login). ObjectStack 7.x replaced the legacy\n    //        /_studio/ and /_account/ mounts with this single /_console/ surface.\n    // Both are required for a clickable login flow when running `objectstack start`\n    // off the compiled artifact.\n    // Note: the foundational slate (queue, job, cache, settings, email,\n    // storage) is auto-injected by the CLI for every non-`minimal`\n    // preset \u2014 see `ALWAYS_CAPS` in packages/cli/src/commands/serve.ts.\n    // Listed below only the *opt-in* capabilities this stack actually\n    // wants on top of that slate.\n    // `triggers` installs the record-change + schedule trigger providers that\n    // actually fire autolaunched flows (record_change & schedule types). Without\n    // it the `automation` engine registers flows but nothing ever launches them.\n    // Schedule triggers run via the job service (in the always-on slate).\n    //\n    // This is the APP package's slate. `defineStack` validates capabilities per\n    // stack, so `src/service/index.ts` declares the four its own metadata needs\n    // itself, and the artifact's slate is the union of the two lists.\n    //\n    // `ai` is deliberately NOT listed. ObjectStack 11.3.0 (ADR-0025 S2) removed\n    // `@objectstack/service-ai` from the open edition \u2014 the AI runtime now ships\n    // only in the closed cloud package, and the framework CLI does not depend on\n    // it. Under ObjectStack 16, `requires: ['ai']` is a *fail-fast* capability:\n    // the serve command hard-aborts boot when the package is absent, so keeping it\n    // here would break `objectstack start`/`dev` for this open-edition app (the AI\n    // block runs before every other capability resolves). The AI metadata is\n    // unaffected \u2014 the skills still validate, build into the artifact, and run\n    // wherever a runtime provides the `ai` tier (cloud's objectos-runtime). There\n    // are no app-authored agents: they were retired in #512 and the surface is\n    // skills-only (ADR-0063 \u00A72); skills attach to a platform agent by `surface`.\n    // A local open-edition boot simply omits the AI service and hides its console\n    // surface. To run AI locally, declare `@objectstack/service-ai` (cloud) in\n    // package.json \u2014 its mere presence best-effort auto-loads it.\n    // `hierarchy-security` is the ONE enterprise-edition capability this app\n    // declares. It was introduced for #880 \u2014 `sales_manager` authored\n    // `writeScope: 'own_and_reports'` on `crm_contract`, an ADR-0057 HIERARCHY\n    // scope resolved by the `hierarchy-scope-resolver` service that ships only\n    // in `@objectstack/security-enterprise`, and `defineStack` refuses such a\n    // grant unless the capability is declared. Since #549 `crm_contract` is\n    // `controlled_by_parent` under the account, that scope is inert and is no\n    // longer authored; the app currently authors NO hierarchy scope at all.\n    //\n    // The declaration STAYS. Maintainer ruling 2026-08-31 (#1378, pinned by\n    // `test/hierarchy-read-depth.test.ts`): nothing is removed from `requires[]`.\n    // Maintainer ruling, 2026-08-11, verbatim: \u300C\u672C\u9879\u76EE\u662F\u5143\u6570\u636Eapp\uFF0C\u5728\u4F01\u4E1A\u7248\u8FD0\u884C\u5C31\n    // \u5177\u5907\u4F01\u4E1A\u7248\u76F8\u5173\u7684\u80FD\u529B\uFF0C\u4E0D\u91CD\u590D\u5F00\u53D1\u3002\u300D The app states what it MEANS and the\n    // edition supplies the capability, rather than approximating it with a broader\n    // open-edition value.\n    //\n    // UNLIKE `ai` above, this is SAFE to declare on an open-edition boot and does\n    // NOT fail fast. Verified against `@objectstack/cli`'s serve command: the\n    // capability resolver looks the token up in `CAPABILITY_PROVIDERS`, finds no\n    // entry, and because `hierarchy-security` IS in the known\n    // `PLATFORM_CAPABILITY_TOKENS` vocabulary it takes the deliberate \"stay quiet\"\n    // branch \u2014 no warning, no abort \u2014 since the capability arrives via an explicit\n    // enterprise plugin in `plugins[]`. Only tier-gated tokens (ai / ai-studio /\n    // i18n / ui / auth) have the dedicated hard-abort blocks the note above\n    // describes. `objectstack validate` does print one informational line naming\n    // the package to install; that is expected output, not a defect to silence.\n    requires: ['automation', 'triggers', 'analytics', 'auth', 'ui', 'approvals', 'sharing', 'hierarchy-security'],\n\n    // The locale configuration is the ARTIFACT's, and `i18n` is a\n    // `'single'`-disposition key: two stacks declaring different values make\n    // `composeStacks` throw, and declaring identical ones twice is a second\n    // place to drift. It lives on the App package, alone.\n    i18n: {\n      defaultLocale: 'en',\n      supportedLocales: ['en', 'zh-CN', 'ja-JP', 'es-ES'],\n      fallbackLocale: 'en',\n    },\n\n    ...collections,\n  }, { artifactObjects: options.artifactObjects });\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/service/index.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/service\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/service/index.ts\";// Copyright (c) 2026 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport { defineStack, type ObjectStackDefinition, type ObjectStackDefinitionInput } from '@objectstack/spec';\n\nimport {\n  EscalateCaseAction, CloseCaseAction, ClaimCaseAction,\n  LogCallAction, LogMeetingAction, CaseScheduleMeetingAction,\n  MarkArticleHelpfulAction, MarkArticleNotHelpfulAction,\n} from './actions/index.js';\nimport { ServiceDashboard } from './dashboards/index.js';\nimport { CaseDataset } from './datasets/index.js';\nimport { ServiceEmailTemplates } from './email-templates/index.js';\nimport {\n  CaseEscalationFlow, CaseEscalationOnCreateFlow, EscalateCaseFlow, CloseCaseFlow,\n  ClaimCaseFlow, CaseEscalationStampFlow, CaseSlaMonitorFlow,\n} from './flows/index.js';\nimport { ArticleFeedback, Case, KnowledgeArticle } from './objects/index.js';\nimport { articleFeedbackHook, caseHook, knowledgeArticleHook } from './objects/hooks.js';\nimport { CaseDetailPage } from './pages/index.js';\nimport {\n  CasesByStatusPriorityReport, SlaPerformanceReport, CasesOpenedByDayPriorityReport,\n} from './reports/index.js';\nimport {\n  CaseDirectorSharingRule, CaseEscalationSharingRule, CaseUnassignedTriageSharingRule,\n} from './sharing/index.js';\nimport { CaseTriageSkill } from './skills/index.js';\nimport { CaseViews, KnowledgeArticleViews } from './views/index.js';\n\n/**\n * The four collections of this package that the app-wide sweeps also read,\n * named once, here.\n *\n * `objectstack.composition.ts` assembles `allHooks`, `allFlows`, `allSkills`\n * and `CrmSharingRules` \u2014 every hook, flow, skill and sharing rule of the\n * ARTIFACT \u2014 out of each package's own list, so the suites that sweep them keep\n * reading one list and this package's half of it is the very array its stack\n * registers. `.flat()` because a `*.hook.ts` may default-export an ARRAY of\n * hooks (one file, several triggers on its object).\n */\nexport const serviceHooks = [articleFeedbackHook, caseHook, knowledgeArticleHook].flat();\n\n/** This package's flows \u2014 see {@link serviceHooks}. */\nexport const serviceFlows = [\n  CaseEscalationFlow, CaseEscalationOnCreateFlow, EscalateCaseFlow, CloseCaseFlow,\n  ClaimCaseFlow, CaseEscalationStampFlow, CaseSlaMonitorFlow,\n];\n\n/** This package's skills \u2014 see {@link serviceHooks}. */\nexport const serviceSkills = [CaseTriageSkill];\n\n/** This package's sharing rules \u2014 see {@link serviceHooks}. */\nexport const serviceSharingRules = [\n  CaseEscalationSharingRule, CaseDirectorSharingRule, CaseUnassignedTriageSharingRule,\n];\n\n/**\n * What this package registers but does not assemble: its seed rows.\n *\n * Everything else comes from this package's own barrels. The seed families are\n * the one exception because WHICH families a build replays is the\n * `HOTCRM_COMPOSITION` knob's decision (#1361), made once, at the root \u2014 a\n * SaaS tenant gets the product catalogue and nothing else, so this package\n * registers no rows in that shape. See `seedDataFor` in\n * `objectstack.composition.ts`.\n */\nexport type HotCrmServiceCollections = Pick<ObjectStackDefinitionInput, 'data'>;\n\n/**\n * `app.objectstack.hotcrm.service` \u2014 the SUPPORT module of this artifact\n * (ADR-0130 D4: one release artifact, N packages, one namespace).\n *\n * It owns `crm_case`, `crm_knowledge_article` and `crm_article_feedback`, and\n * every item authored against them: their hooks, views, the case detail page,\n * the seven case flows, the case and article actions, `case_metrics` and the\n * three reports over it, the Service Overview dashboard, the case-triage skill,\n * the three case sharing rules, the two case notification templates and the\n * case and knowledge seed rows.\n *\n * Three properties are load-bearing:\n *\n *  - **The same `namespace` as the app package.** That is what ADR-0130 D1\n *    buys: co-ownership of one namespace inside one artifact, so `crm_case`\n *    keeps its name instead of becoming `service_case`. The object `name` IS\n *    the table name, the REST path and the saved-view key (ADR-0129 D1\u2013D2), so\n *    a rename would be a data migration; this split costs none.\n *  - **`dependencies` is the edge; the array order in `objectstack.config.ts`\n *    is not.** The load path sorts `packages[]` through the platform's one\n *    topological sorter (ADR-0130 D5, ADR-0116), so the app package registers\n *    first whatever slot it occupies in the `composeStacks([\u2026])` call.\n *  - **Navigation crosses only through contributions** \u2014 the block below.\n *\n * \u26D4 No `i18n` here: it is a `'single'`-disposition stack key, so two stacks\n * declaring DIFFERENT values make `composeStacks` throw and declaring identical\n * ones twice is a second place to drift. The app package declares it once, for\n * the artifact \u2014 and the locale packs that label this package's objects stay\n * whole in the app package with it.\n *\n * `requires` is the opposite: `defineStack` validates trigger capability PER\n * STACK, so a package whose own flows declare `record_change` / `schedule`\n * triggers must declare `triggers` itself \u2014 the app package's slate does not\n * reach this parse:\n *\n *     \u2717 flow 'case_escalation' declares a 'record_change' trigger but\n *       `requires` does not include 'automation' or 'triggers' \u2014 no\n *       'record_change' trigger would be registered \u2026\n *\n * (measured on 17.7.0 by deleting the line below: three such refusals, one\n * per triggered case flow).\n *\n * So this list is exactly what THIS package's metadata needs: `automation` and\n * `triggers` for the seven case flows, `analytics` for `case_metrics` and the\n * items over it, `sharing` for the three case sharing rules. The app package's\n * surface capabilities (`auth`, `ui`, `approvals`, `hierarchy-security`) are\n * not repeated.\n *\n * Registration stays file-by-file: every item is named here, through its\n * directory barrel. A file that reaches no barrel and no line below is\n * validated by nothing.\n */\nexport const createHotCrmServiceStack = (\n  collections: HotCrmServiceCollections,\n): ObjectStackDefinition => defineStack({\n  manifest: {\n    id: 'app.objectstack.hotcrm.service',\n    name: 'HotCRM Service',\n    // The app package's namespace, deliberately (ADR-0130 D1).\n    namespace: 'crm',\n    // The ARTIFACT's version: one `package.json`, one build, one release\n    // (ADR-0130 D6), so a module of this artifact is never at a version of its\n    // own. Bump it with the app package's and `package.json` \u2014\n    // `test/docs-declared-versions.test.ts` holds all three, and the range\n    // below, to one value.\n    version: '4.0.1',\n    type: 'module',\n    description: 'HotCRM support module \u2014 cases, knowledge articles, and the SLA surface.',\n    // The same protocol as the app package (ADR-0087 handshake); bump it with\n    // `specVersion` on every platform upgrade, exactly as the app's is.\n    engines: { protocol: '^18.0.0-next.0' },\n    // The App package this module extends.\n    dependencies: { 'app.objectstack.hotcrm': '^4.0.1' },\n\n    /**\n     * The five navigation entries this module puts into the app's menu\n     * (ADR-0029 D7).\n     *\n     * Not a design choice: an app's own `navigation` may not name another\n     * package's object (ADR-0130 \u00A71.5, rule R3 of `module-split-plan.md`), so\n     * all five became contributions the moment `crm_case`,\n     * `crm_knowledge_article`, `service_dashboard` and `sla_performance` left\n     * the app package. The app keeps the GROUPS (`group_service`, `group_work`,\n     * `group_insights`) \u2014 a container a module cannot declare inside an app it\n     * does not own \u2014 and this module fills them.\n     *\n     * `app` is the app's bare `name` (`crm_enterprise`), not the manifest id: a\n     * dotted id is refused as a non-snake_case identifier.\n     *\n     * \u26A0\uFE0F `priority` orders CONTRIBUTIONS against each other inside a group. It\n     * does NOT interleave them with the app's own children \u2014 a contributed item\n     * is appended after everything the app itself declares in that group. The\n     * one visible consequence is `nav_my_cases`, 4th of 6 in *My Work* before\n     * the split and last after it; the three `group_service` items and\n     * `nav_report_sla` keep their positions because the app declares nothing\n     * after them. \u26D4 Do not compensate with a per-item `order`: that key sorts\n     * in the renderer only, this app authors none anywhere, and adding one to\n     * work around a platform merge rule is what AGENTS.md forbids.\n     */\n    navigationContributions: [\n      {\n        app: 'crm_enterprise',\n        group: 'group_service',\n        // Stated rather than defaulted so that the day a second package\n        // contributes into one of these groups, the order is an authored fact\n        // instead of a registration-order accident.\n        priority: 10,\n        items: [\n          { id: 'nav_case',      type: 'object', objectName: 'crm_case',              label: 'Cases',     icon: 'life-buoy' },\n          { id: 'nav_knowledge', type: 'object', objectName: 'crm_knowledge_article', label: 'Knowledge', icon: 'book-open' },\n          { id: 'nav_service_dashboard', type: 'dashboard', dashboardName: 'service_dashboard', label: 'Service Overview', icon: 'gauge' },\n        ],\n      },\n      {\n        app: 'crm_enterprise',\n        group: 'group_work',\n        priority: 20,\n        items: [\n          { id: 'nav_my_cases', type: 'object', objectName: 'crm_case', viewName: 'my_open_cases', label: 'My Cases', icon: 'life-buoy' },\n        ],\n      },\n      {\n        app: 'crm_enterprise',\n        group: 'group_insights',\n        priority: 30,\n        items: [\n          { id: 'nav_report_sla', type: 'report', reportName: 'sla_performance', label: 'SLA Performance', icon: 'timer' },\n        ],\n      },\n    ],\n  },\n\n  // What THIS package's metadata needs \u2014 see the `requires` paragraph above.\n  requires: ['automation', 'triggers', 'analytics', 'sharing'],\n\n  objects: [ArticleFeedback, Case, KnowledgeArticle],\n  hooks: serviceHooks,\n  views: [CaseViews, KnowledgeArticleViews],\n  pages: [CaseDetailPage],\n  flows: serviceFlows,\n  actions: [\n    EscalateCaseAction, CloseCaseAction, ClaimCaseAction,\n    LogCallAction, LogMeetingAction, CaseScheduleMeetingAction,\n    MarkArticleHelpfulAction, MarkArticleNotHelpfulAction,\n  ],\n  datasets: [CaseDataset],\n  reports: [CasesByStatusPriorityReport, SlaPerformanceReport, CasesOpenedByDayPriorityReport],\n  dashboards: [ServiceDashboard],\n  skills: serviceSkills,\n  sharingRules: serviceSharingRules,\n  emailTemplates: ServiceEmailTemplates,\n\n  ...collections,\n});\n\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/service/actions/case.actions.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/service/actions\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/service/actions/case.actions.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport type { Action } from '@objectstack/spec/ui';\nimport { P } from '@objectstack/spec';\n\n/**\n * Case actions \u2014 all three delegate to screen flows in\n * `src/service/flows/case-actions.flow.ts` (see the note there for why: modal\n * actions never execute their body in 16.1.0, and script bodies cannot\n * UPDATE a record on a sharing-ruled object; screen flows are the mechanism\n * that demonstrably works, same as `convert_lead` / `schedule_followup`).\n */\nexport const EscalateCaseAction: Action = {\n  name: 'escalate_case',\n  label: 'Escalate Case',\n  objectName: 'crm_case',\n  icon: 'alert-triangle',\n  type: 'flow',\n  target: 'escalate_case',\n  locations: ['record_header', 'list_item'],\n  visible: P`has(record.is_escalated) && record.is_escalated == false && has(record.is_closed) && record.is_closed == false`,\n  confirmText: 'This will escalate the case to the escalation team. Continue?',\n  successMessage: 'Case escalated successfully!',\n  refreshAfter: true,\n};\n\nexport const CloseCaseAction: Action = {\n  name: 'close_case',\n  label: 'Close Case',\n  objectName: 'crm_case',\n  icon: 'check-circle',\n  type: 'flow',\n  target: 'close_case',\n  locations: ['record_header'],\n  visible: P`has(record.is_closed) && record.is_closed == false`,\n  confirmText: 'Are you sure you want to close this case?',\n  successMessage: 'Case closed successfully!',\n  refreshAfter: true,\n};\n\n/**\n * Claim Case \u2014 the affordance for the unassigned-triage gesture.\n *\n * \u26A0\uFE0F `visible` MUST mirror the sharing grant, never a convenience flag.\n * `case_unassigned_triage_sharing` (`src/service/sharing/case.sharing.ts`) is what\n * decides whether the agent looking at this button may write the row at all, so\n * the predicate here is copied from it verbatim. \u26D4 Never restate it as\n * `record.is_closed == false`: that flag is derived as `status === 'closed'` and\n * never flips on `resolved`, so it would offer a Claim button on resolved\n * ownerless cases the agent is not shared and cannot claim \u2014 a button that\n * answers FORBIDDEN. The button and the grant are one sentence stated twice, and\n * `test/claim-case-one-owner-writer.test.ts` holds them to that.\n *\n * No `confirmText`: the flow opens a screen that asks which working status the\n * agent is claiming into, and that screen IS the confirmation. A modal in front\n * of it would be two dialogs for one gesture.\n */\nexport const ClaimCaseAction: Action = {\n  name: 'claim_case',\n  label: 'Claim Case',\n  objectName: 'crm_case',\n  icon: 'user-plus',\n  type: 'flow',\n  target: 'claim_case',\n  locations: ['record_header', 'list_item'],\n  // \u26D4 Deliberately NOT `has()`-guarded \u2014 the one site the #1890 totality sweep\n  // left alone after making every other `visible` in `src/actions/` total. This\n  // predicate is the sharing grant's own text, verbatim, and\n  // `test/claim-case-one-owner-writer.test.ts` compares the two strings; the\n  // grant itself cannot carry `has()`, because `plugin-sharing` compiles a\n  // criteria condition with `compileCelToFilter`, which rejects the whole\n  // function-call class, and an untranslatable rule is DROPPED by the seeder\n  // (#621). `src/service/sharing/case.sharing.ts` writes that out in full, including why\n  // `record.owner_id == null` is total one layer down (`{ owner_id: { $null: true } }`).\n  // \u26A0\uFE0F What that reasoning does NOT cover is THIS surface: an action `visible` is\n  // interpreted by CEL in the browser against whatever the page holds, which is\n  // `{}` for the first renders, so this predicate does abort there. Making it\n  // total needs the grant and the parity pin moved together \u2014 a maintainer call,\n  // not this card's. (#1890)\n  visible: P`record.owner_id == null && record.status != \"resolved\" && record.status != \"closed\"`,\n  successMessage: 'Case claimed \u2014 it is yours now.',\n  refreshAfter: true,\n};\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/service/objects/index.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/service/objects\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/service/objects/index.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\n/**\n * Service object barrel.\n *\n * Re-exports this package's *.object.ts definitions; the `*.hook.ts` files\n * beside them register through `./hooks.ts`. The canonical note on the\n * collaboration capabilities (`enable.files`, `enable.feeds`) that every\n * object in this app points at is written once, in\n * `src/sales/objects/index.ts`.\n */\n\nexport { ArticleFeedback } from './article_feedback.object';\nexport { Case } from './case.object';\nexport { KnowledgeArticle } from './knowledge_article.object';\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/service/objects/article_feedback.object.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/service/objects\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/service/objects/article_feedback.object.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport { ObjectSchema, Field } from '@objectstack/spec/data';\n\n/**\n * Article Feedback Object (#601)\n *\n * One reader's verdict on one knowledge article \u2014 the WRITER behind\n * `crm_knowledge_article.helpful_count` / `not_helpful_count`, which were\n * `readonly` with nothing on either side of the platform able to move them.\n *\n * ### Why a row and not a counter bump\n *\n * The obvious shape \u2014 a \"Helpful\" button whose action body does\n * `helpful_count + 1` \u2014 cannot be built on this platform, and the reason is\n * measured rather than assumed:\n *\n *  - A `type: 'script'` action body runs in the QuickJS sandbox, whose\n *    execution context carries no caller identity. An UPDATE it issues against\n *    an object with sharing rules is refused by the sharing middleware even for\n *    the record's owner \u2014 the measurement `src/service/flows/case-actions.flow.ts`\n *    records, and the reason both case actions are screen flows. INSERTS are\n *    unaffected, which is the seam this object takes.\n *  - `crm_knowledge_article` is `public_read`: read-open, WRITE-OWNED. So the\n *    one agent who could bump the counter by hand is the article's author,\n *    which is precisely the person whose vote is worthless.\n *  - There is no atomic increment on the data API, so two concurrent votes\n *    read-modify-write the same value and one of them disappears.\n *\n * A vote row sidesteps all three: the reader INSERTS their own row (allowed),\n * and `article_feedback_metrics_refresh` (`article_feedback.hook.ts`) RECOUNTS\n * the article's two counters from this table under the hook's own privileges.\n * Recount, not increment \u2014 it is idempotent, it self-heals after a deleted or\n * edited vote, and it cannot drift the way a running total does. Exactly the\n * shape `campaign_member_metrics_refresh` uses to keep `crm_campaign`'s metric\n * block live (#597), which is the precedent this file follows on purpose\n * rather than inventing a second idiom for the same problem.\n *\n * ### What it buys beyond a writer\n *\n * A counter with no row behind it cannot answer \"did this person already\n * vote\", so it counts one enthusiast forty times. `unique_vote_per_reader`\n * below keys one row per (article, reader) and the `submit_article_feedback`\n * action UPDATES that row when a reader changes their mind \u2014 so the counters\n * mean \"how many people\", which is the only reading that makes\n * `helpful_count` vs `not_helpful_count` a comparison rather than two\n * unrelated tallies.\n *\n * \u26A0\uFE0F `verdict` is deliberately two-valued. A five-star scale, a free-text\n * reason taxonomy and \"was this article up to date\" are all plausible and all\n * unbuilt: this object exists to give two declared counters a real writer, and\n * a vocabulary nothing reads would recreate the very defect it is fixing.\n */\nexport const ArticleFeedback = ObjectSchema.create({\n  name: 'crm_article_feedback',\n  label: 'Article Feedback',\n  pluralLabel: 'Article Feedback',\n  icon: 'thumbs-up',\n  description: 'One reader\u2019s helpful / not-helpful verdict on a knowledge article',\n\n  // ADR-0090 D1/D7: OWD is an authored decision. Feedback is an attribute of\n  // the article, so record access DERIVES from it (ADR-0055) \u2014 the same call\n  // `crm_campaign_member` makes, and for the same reason: a vote row means\n  // nothing apart from the article it is about, and `crm_knowledge_article` is\n  // `public_read`, so anyone who can read the article can read its feedback.\n  //\n  // \u26D4 Not `private`: with the voter as owner, the counters' own evidence would\n  // be invisible to the author trying to understand them \u2014 the same way it was\n  // wrong on `crm_campaign_member`.\n  sharingModel: 'controlled_by_parent',\n\n  // ADR-0079: junction rows have no derivable text title; point the canonical\n  // nameField at the stored autonumber explicitly (autonumber is not in the\n  // auto-derivation whitelist). Same call as `crm_campaign_member` and\n  // `crm_event_attendee`.\n  nameField: 'feedback_number',\n\n  // A related list takes its columns from the child's `highlightFields` MINUS\n  // the lookup it is scoped by, and this object ships no view of its own \u2014 so\n  // this list IS the feedback panel on an article's detail page (#944): the\n  // verdict, and who gave it.\n  //\n  // TWO fields are deliberately absent, for two different reasons:\n  //\n  //  - `feedback_number`, the same call `crm_campaign_member` makes with\n  //    `member_number`: it is the record TITLE, which a detail page hoists out\n  //    of the body, so leading the strip with it would fill the panel with\n  //    autonumbers instead of verdicts.\n  //  - `comment`, a 500-character textarea. A highlight strip holds short\n  //    values, and keeping it out is also what stops the `basic` group being\n  //    ENTIRELY title-or-strip \u2014 a group whose every field is hoisted keeps its\n  //    heading on forms and silently vanishes from detail pages\n  //    (`field-group-shadowed`, the same trap `crm_campaign_member`'s `basic`\n  //    group and `crm_task`'s `assignment` group each had to be rescued from).\n  //    So the comment is the group's own content on the row's detail page,\n  //    and reaches the panel through `relatedListColumns` on the article\n  //    lookup below instead (#1199).\n  highlightFields: ['crm_knowledge_article', 'verdict', 'owner_id'],\n\n  fieldGroups: [\n    { key: 'basic', label: 'Feedback', icon: 'message-square' },\n  ],\n\n  fields: {\n    feedback_number: Field.autonumber({\n      label: 'Feedback #',\n      format: 'AF-{0000}',\n      group: 'basic',\n    }),\n\n    // Platform ownership anchor \u2014 canonical note in `account.object.ts` (#548).\n    // Here it is also the VOTER: the platform stamps it on insert, which is\n    // what `unique_vote_per_reader` keys on and what lets a reader change\n    // their own mind without an admin's help.\n    owner_id: Field.lookup('sys_user', {\n      label: 'Reader',\n      group: 'basic',\n      system: true,\n      readonly: false,\n    }),\n\n    /**\n     * The article this verdict is about.\n     *\n     * `deleteBehavior: 'cascade'` \u2014 a vote on a deleted article denotes\n     * nothing. This is the lesson #696 cost the campaign junction: both party\n     * lookups there took `Field.lookup`'s `set_null` default, the cleared row\n     * instantly violated the object's own required-reference rule, and every\n     * enrolled person became permanently undeletable. A required lookup that\n     * defaults to `set_null` is that bug waiting to happen, so the behaviour is\n     * spelled out here rather than inherited.\n     */\n    crm_knowledge_article: Field.lookup('crm_knowledge_article', {\n      label: 'Article',\n      required: true,\n      storage: { notNull: true },\n      group: 'basic',\n      deleteBehavior: 'cascade',\n      description: 'Knowledge article this feedback is about.',\n\n      // Curates the feedback panel on the article's detail page \u2014 the surface\n      // the article's AUTHOR reads (#1199). A related list reads\n      // `relatedListColumns` on the child's lookup before it falls back to\n      // `highlightFields` minus that lookup (#944), so this is a SUPERSET of\n      // the fallback (Verdict / Reader) plus `comment`: the note a reader\n      // types to explain a verdict was stored and shown on no list, and the\n      // author the field's own description names could not see it without\n      // opening each row. Last, because it is the one long value.\n      //\n      // \u26D4 Deliberately NOT solved by adding `comment` to `highlightFields` \u2014\n      // see the note above that list (`field-group-shadowed`).\n      relatedListColumns: ['verdict', 'owner_id', 'comment'],\n    }),\n\n    verdict: Field.select({\n      label: 'Verdict',\n      required: true,\n      storage: { notNull: true },\n      group: 'basic',\n      options: [\n        { label: 'Helpful', value: 'helpful', color: '#10B981', default: true },\n        { label: 'Not Helpful', value: 'not_helpful', color: '#EF4444' },\n      ],\n    }),\n\n    comment: Field.textarea({\n      label: 'Comment',\n      group: 'basic',\n      maxLength: 500,\n      description: 'Optional note explaining the verdict \u2014 read by the article\u2019s author.',\n    }),\n  },\n\n  indexes: [\n    { fields: ['crm_knowledge_article'] },\n    { fields: ['verdict'] },\n    // One vote per reader per article. Without it the counters answer \"how many\n    // clicks\", which is not a number anybody wants next to \"Not Helpful\".\n    //\n    // `unique: 'organization'` states the scope explicitly, per ADR-0120: the\n    // driver prepends the NULL-safe organization key part\n    // (`COALESCE(organization_id, '__global__')`) at registration, so the\n    // constraint is one vote per reader per article WITHIN an organization,\n    // and rows with no organization form one bucket rather than each escaping\n    // under SQL's NULL-distinct semantics. Bare `unique: true` is the\n    // deprecated positional spelling of `'global'` \u2014 it warns today\n    // (`unique/unscoped-declared-index`) and protocol 18 rejects it, and\n    // \"globally unique across every installation\" is not what one reader's\n    // opinion of one article means.\n    { fields: ['crm_knowledge_article', 'owner_id'], unique: 'organization' },\n  ],\n\n  enable: {\n    apiEnabled: true,\n    apiMethods: ['get', 'list', 'create', 'update', 'delete'],\n  },\n});\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/service/objects/case.object.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/service/objects\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/service/objects/case.object.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport { ObjectSchema, Field } from '@objectstack/spec/data';\nimport { F, P } from '@objectstack/spec';\n\nexport const Case = ObjectSchema.create({\n  name: 'crm_case',\n  label: 'Case',\n  pluralLabel: 'Cases',\n  icon: 'life-buoy',\n  description: 'Customer support cases and service requests',\n\n  // ADR-0090 D1/D7: OWD is an authored decision. Owner + escalation sharing rule.\n  sharingModel: 'private',\n\n  fieldGroups: [\n    { key: 'basic',       label: 'Case Information', icon: 'info' },\n    { key: 'origin',      label: 'Origin & Routing', icon: 'route' },\n    { key: 'sla',         label: 'SLA & Priority',   icon: 'clock' },\n    { key: 'resolution',  label: 'Resolution',       icon: 'check-circle' },\n    { key: 'escalation',  label: 'Escalation',       icon: 'alert-triangle', collapse: 'collapsed' },\n    { key: 'system',      label: 'System',           icon: 'database',       collapse: 'collapsed' },\n  ],\n\n  fields: {\n    // Platform ownership anchor \u2014 canonical note in `account.object.ts` (#548).\n    owner_id: Field.lookup('sys_user', {\n      label: 'Case Owner',\n      group: 'origin',\n      system: true,\n      readonly: false,\n      trackHistory: true,\n    }),\n\n    // Case Information\n    //\n    // `unique: true` is declared HERE, on the field, and deliberately NOT as a\n    // `{ fields: ['organization_id', 'case_number'], unique: true }` entry in\n    // `indexes[]` below (#1023) \u2014 same spelling `crm_account.name`,\n    // `crm_contact.email` and `crm_product.sku` already use, for the same\n    // reason. Since framework #3696 the field-level form is per-organization:\n    // it materializes as the composite `(organization key part, case_number)`,\n    // unique WITHIN an organization. Since platform 17.0.0-rc.4 (ADR-0120 D3,\n    // #5030) that key part is NULL-safe \u2014 `COALESCE(organization_id,\n    // '__global__')` \u2014 so rows with no organization form ONE bucket instead of\n    // each escaping the constraint under SQL's NULL-distinct semantics.\n    //\n    // The hand-written table composite this replaced could not get that: a\n    // declared index is taken verbatim, so it materialized as plain\n    // `UNIQUE (organization_id, case_number)` and enforced NOTHING on any row\n    // whose `organization_id` was NULL \u2014 i.e. every row of a single-organization\n    // or untenanted install. It also read as \"unique per organization\" while\n    // materializing as an unscoped composite, which is the bare-`unique: true`\n    // spelling ADR-0120 warns on in 17.x and protocol 18 rejects (#5082).\n    //\n    // Scope spelling: bare `true` at FIELD level already means \"per\n    // organization\" and carries no deprecation (`'organization'` is its\n    // explicit synonym with byte-identical materialization \u2014 measured). It is\n    // written as `true` to match the four sibling objects above; switching the\n    // repo to the explicit word is a uniform decision for all of them, not\n    // something `crm_case` forks on alone.\n    case_number: Field.autonumber({\n      label: 'Case Number',\n      group: 'basic',\n      format: 'CASE-{00000}',\n      unique: true,\n    }),\n    \n    subject: Field.text({\n      label: 'Subject',\n      group: 'basic',\n      required: true,\n      storage: { notNull: true },\n      searchable: true,\n      maxLength: 255,\n    }),\n\n    // ADR-0079 record title (was titleFormat '{case_number} - {subject}').\n    display_title: Field.formula({\n      label: 'Display Title',\n      group: 'basic',\n      expression: F`record.case_number + \" - \" + record.subject`,\n    }),\n\n    description: Field.markdown({\n      label: 'Description',\n      group: 'basic',\n      required: true,\n      storage: { notNull: true },\n    }),\n    \n    // Relationships\n    crm_account: Field.lookup('crm_account', {\n      label: 'Account',\n      group: 'basic',\n    }),\n    \n    crm_contact: Field.lookup('crm_contact', {\n      label: 'Contact',\n      group: 'basic',\n      // Optional so Web-to-Case (anonymous) submissions can land without\n      // an existing CRM contact. Back-office staff or a triage flow links\n      // the case to a contact after the fact. This matches the Salesforce\n      // Web-to-Case convention.\n      // @objectstack 12: string[] `referenceFilters` is dead (not read by the\n      // picker). `dependsOn` is the live cascading-lookup form \u2014 it scopes the\n      // contact candidates to those sharing the case's `crm_account` (ADR-0049).\n      dependsOn: ['crm_account'],\n    }),\n    \n    // Case Management\n    status: Field.select({\n      label: 'Status',\n      group: 'basic',\n      required: true,\n      storage: { notNull: true },\n      // ADR-0052 \u00A75b.1 \u2014 platform auto-renders status changes on the timeline\n      // (\"Status: New \u2192 Escalated\"). Delivers the case timeline declaratively\n      // (the hand-coded version was deferred in #396 due to a hook-crash bug).\n      trackHistory: true,\n      options: [\n        { label: 'New', value: 'new', color: '#808080', default: true },\n        { label: 'In Progress', value: 'in_progress', color: '#FFA500' },\n        { label: 'Waiting on Customer', value: 'waiting_customer', color: '#FFD700' },\n        { label: 'Waiting on Support', value: 'waiting_support', color: '#4169E1' },\n        { label: 'Escalated', value: 'escalated', color: '#FF0000' },\n        { label: 'Resolved', value: 'resolved', color: '#00AA00' },\n        { label: 'Closed', value: 'closed', color: '#006400' },\n      ]\n    }),\n    \n    priority: Field.select({\n      label: 'Priority',\n      group: 'sla',\n      required: true,\n      storage: { notNull: true },\n      trackHistory: true,\n      options: [\n        { label: 'Low', value: 'low', color: '#4169E1', default: true },\n        { label: 'Medium', value: 'medium', color: '#FFA500' },\n        { label: 'High', value: 'high', color: '#FF4500' },\n        { label: 'Critical', value: 'critical', color: '#FF0000' },\n      ]\n    }),\n\n    // Sortable ordinal for `priority`. Ordering a queue by the select field\n    // itself sorts the raw strings, so `priority desc` yields\n    // medium > low > high > critical \u2014 the exact inversion of urgency, which\n    // buried every critical case at the bottom of the agent's queue. Select\n    // options carry no ordinal in the spec, so the rank is materialised here\n    // and stamped by `case_sla_defaults`; queue views sort on it instead.\n    // `0` is the UNRANKED sentinel, shared with crm_task.priority_rank: it is\n    // what a record carries when no recognised priority has been stamped, and\n    // it sorts below every real rank (1\u20134) on the `priority_rank desc` queues.\n    // \u26D4 It must not be `1` here (or `2` on crm_task): a non-zero sentinel\n    // orders the same unknown priority differently on the two objects, and on\n    // this one it is indistinguishable from a genuine `low`.\n    priority_rank: Field.number({\n      label: 'Priority Rank',\n      readonly: true,\n      defaultValue: 0,\n    }),\n\n    type: Field.select({\n      label: 'Case Type',\n      group: 'basic',\n      options: [\n        { label: 'Question', value: 'question' },\n        { label: 'Problem', value: 'problem' },\n        { label: 'Feature Request', value: 'feature_request' },\n        { label: 'Bug', value: 'bug' },\n      ]\n    }),\n    \n    origin: Field.select({\n      label: 'Case Origin',\n      group: 'origin',\n      options: [\n        { label: 'Email', value: 'email' },\n        { label: 'Phone', value: 'phone' },\n        { label: 'Web', value: 'web' },\n        { label: 'Chat', value: 'chat' },\n        { label: 'Social Media', value: 'social_media' },\n      ]\n    }),\n    \n    // Assignment\n    \n    // SLA and Metrics\n    //\n    // NO `created_date` here (#1992, the #575 B2 precedent on\n    // `crm_opportunity`): the platform already injects `created_at` on every\n    // object and stamps it on every insert, while this duplicate had no writer\n    // at all \u2014 only the seed data set it, so every case created through the\n    // UI or REST stored null and fell out of \"Cases Opened by Priority \u00D7 Day\"\n    // and the service dashboard's date range. Surfaces that need the creation\n    // instant read `created_at` (the `case_metrics` dataset, the dashboard\n    // range, the `case_timeline` view, `case_sla_defaults`' resolution time);\n    // the seeds author it directly, and the seed loader keeps an authored\n    // `created_at` on first insert since @objectstack/objectql 17.7.0\n    // (objectstack#21646).\n    closed_date: Field.datetime({\n      label: 'Closed Date',\n      group: 'sla',\n      readonly: true,\n    }),\n    \n    // \u26D4 NOT `readonly`: stamped by `event_activity_bubble`\n    // (`src/sales/objects/event.hook.ts`) on the first HELD `crm_event` related to the\n    // case, whoever wrote that event. \u26A0\uFE0F That hook reaches this case through\n    // `ctx.api`, a `ScopedContext` over the ACTING USER's execution context \u2014\n    // so its write is a CALLER-supplied write from a non-`isSystem` context,\n    // which `stripReadonlyFields` deletes. `readonly` here silently disables\n    // the stamp. (A hook writing its OWN record's `ctx.input.data` is a\n    // different case and SURVIVES `readonly` \u2014 hook-written keys are not\n    // caller-supplied. Measured in `test/readonly-write-semantics.test.ts`.)\n    //\n    // Definition: the moment the customer first heard back from us, matching\n    // Salesforce `FirstResponseDateTime` / Zendesk first reply time \u2014 NOT an\n    // internal status change, which would report \"responded\" while the customer\n    // is still waiting.\n    first_response_date: Field.datetime({\n      label: 'First Response Date',\n      group: 'sla',\n    }),\n    \n    resolution_time_hours: Field.number({\n      label: 'Resolution Time (Hours)',\n      group: 'sla',\n      readonly: true,\n      scale: 2,\n    }),\n    \n    // Stamped once, on the first write that gives the case a priority, from the\n    // priority \u00D7 account-tier matrix in `./_case-sla.ts` (`case_sla_defaults`).\n    // Not `readonly`: a service manager may legitimately renegotiate a deadline,\n    // and the hook never overwrites a value that is already there.\n    sla_due_date: Field.datetime({\n      label: 'SLA Due Date',\n      description: 'Set from the case priority and the account\u2019s Customer Tier, in calendar hours: nights, weekends and holidays count.',\n      group: 'sla',\n    }),\n    \n    // Stamped by two writers, one per side of the clock stop (#2070): the\n    // `case_sla_monitor` schedule flow while the case is live work, and\n    // `case_sla_defaults` on the write that resolves or closes it late. The\n    // rule both apply is `caseSlaBreached` in `./_case-sla.ts`.\n    //\n    // NOT `readonly` \u2014 but NOT for the reason this comment used to give, and\n    // the difference is measured in `test/readonly-write-semantics.test.ts`\n    // (#1429). `case_sla_monitor` declares `runAs: 'system'`, so its writes\n    // would SURVIVE a `readonly: true` here. It stays writable pending a\n    // decision that has to weigh the other surfaces (seed data,\n    // `service-agent.profile.ts`, the create form), not because the platform\n    // would drop the sweep's write.\n    //\n    // \u26A0\uFE0F This is now the ONLY escalation-group flag still declared writable:\n    // `is_escalated` and `escalated_date` became `readonly: true` when #1434\n    // moved their user-context writer into a system sub-flow. So the open\n    // question here is narrower than it was \u2014 it is purely about this field's\n    // authoring surfaces, with no platform obstacle left to blame.\n    is_sla_violated: Field.boolean({\n      label: 'SLA Violated',\n      group: 'sla',\n      defaultValue: false,\n    }),\n    \n    // Escalation\n    //\n    // `readonly: true` \u2014 the honest declaration, because nobody types this.\n    // Its three writers are now unanimously elevated (#1434, maintainer-\n    // approved decision batch #21 \u2461):\n    //\n    //   case_escalation        runAs: 'system'  (record-change)\n    //   case_sla_monitor       runAs: 'system'  (schedule)\n    //   case_escalation_stamp  runAs: 'system'  (called by the escalate_case\n    //                                            screen flow via a subflow node)\n    //\n    // \u2B50 What changed, and why the readonly declaration is now safe: the\n    // `escalate_case` screen flow used to write this field itself, and it\n    // stays `runAs: 'user'` because a person clicks it. The platform's\n    // readonly strip is one branch of the UPDATE path\n    // (`if (!opCtx.context?.isSystem)`, over CALLER-supplied keys), so that\n    // user-context write WOULD have been silently dropped. Rather than\n    // elevating the whole screen flow, the stamp moved into the dedicated\n    // `case_escalation_stamp` sub-flow. The agent's own writes\n    // (`escalation_reason`, `priority`, `status`) still carry their identity;\n    // only these two stamps are elevated.\n    //\n    // The guest-submission branch of `case.hook.ts` also forces this false, and\n    // is unaffected: it is a `beforeInsert` hook, so its key is not\n    // caller-supplied AND the INSERT path is exempt from the strip entirely.\n    // Seed data (`service.seed.ts`) is exempt for the same reason.\n    //\n    // \u26D4 If you find yourself reverting this to writable so a user-context flow\n    // write lands, you are re-opening #1434 \u2014 add a `subflow` step instead.\n    // Semantics measured in `test/readonly-write-semantics.test.ts`.\n    is_escalated: Field.boolean({\n      label: 'Escalated',\n      group: 'escalation',\n      readonly: true,\n      defaultValue: false,\n    }),\n    \n    // `readonly: true`, same reasoning as `is_escalated` above and stamped by\n    // the same writers \u2014 `case_escalation` and the `case_escalation_stamp`\n    // sub-flow, both `runAs: 'system'`. Never typed by a person.\n    escalated_date: Field.datetime({\n      label: 'Escalated Date',\n      group: 'escalation',\n      readonly: true,\n    }),\n    \n    // \u26D4 DELIBERATELY NOT `readonly`, and this is load-bearing (#1434). This is\n    // the agent's own screen input \u2014 `escalate_case`'s screen collects it and\n    // writes it with the USER's context. Declaring it readonly would make the\n    // platform silently strip the reason the agent just typed, which is the\n    // harm #1434 was filed about, inverted onto user input. It is also\n    // required whenever `is_escalated` flips true (the\n    // `escalation_reason_required` validation below), so dropping it would\n    // reject the escalation outright.\n    escalation_reason: Field.textarea({\n      label: 'Escalation Reason',\n      group: 'escalation',\n    }),\n    \n    // No `parent_case`. A case hierarchy was declared here and never\n    // traversed: nothing rolled child cases up, nothing closed or notified them\n    // with the parent, and no service flow read the link. Related cases that\n    // matter in this app are linked through the knowledge article that resolved\n    // them (`resolved_by_article`), which the deflection measures do read.\n    \n    // Resolution\n    resolution: Field.markdown({\n      label: 'Resolution',\n      group: 'resolution',\n    }),\n\n    /**\n     * The knowledge article that RESOLVED this case (#601).\n     *\n     * The second half of a two-way link, and deliberately not a replacement for\n     * the first. `crm_knowledge_article.related_to_case` points the other way \u2014\n     * \"the case this article was WRITTEN FROM\" \u2014 and the two answer different\n     * questions: provenance (where did this article come from) versus\n     * deflection (what did this article save us). Merging them would make both\n     * unanswerable, so both stay.\n     *\n     * This is the column the deflection measures on `case_metrics` read\n     * (`kb_resolved_count` / `kb_deflection_rate`), which is why blank is\n     * normalised to NULL by `case_resolution_article_normalize` in\n     * `case.hook.ts`: the close-case screen sends `''` for a field the agent\n     * left empty, an empty string is NOT null, and `count(resolved_by_article)`\n     * counts it \u2014 a silently inflated numerator on a ratio widget, the exact\n     * shape of #614.\n     */\n    resolved_by_article: Field.lookup('crm_knowledge_article', {\n      label: 'Resolved by Article',\n      group: 'resolution',\n      description: 'Knowledge article that resolved this case \u2014 the deflection signal.',\n    }),\n\n\n    // Internal notes\n    internal_notes: Field.markdown({\n      label: 'Internal Notes',\n      group: 'system',\n      description: 'Internal notes; not visible to the customer.',\n    }),\n    \n    // Flags\n    is_closed: Field.boolean({\n      label: 'Is Closed',\n      group: 'system',\n      defaultValue: false,\n      readonly: true,\n    }),\n  },\n  \n  // Database indexes for performance\n  //\n  // `case_number` is an autonumber (`CASE-{00000}`), and the platform's\n  // autonumber sequence is PER TENANT \u2014 every organization counts from 1. A\n  // platform-wide unique index on it therefore rejects the second\n  // organization's `CASE-00001` on insert: the exact collision framework #3696\n  // exists to prevent. The constraint has to match the sequence that feeds it.\n  //\n  // No `{ fields: ['organization_id', 'case_number'], unique: true }` here\n  // (#1023). Case-number uniqueness is declared on the `case_number` field\n  // itself \u2014 see the note there for why the hand-written table composite could\n  // not express it. Do NOT add it back alongside the field-level declaration\n  // either: declaring both makes the verbatim index win and leaves the\n  // per-organization one unreachable (framework#3991\n  // `unique/double-declaration`), which would silently undo the fix.\n  indexes: [\n    { fields: ['crm_account'] },\n    { fields: ['owner_id'] },\n    { fields: ['status'] },\n    { fields: ['priority'] },\n  ],\n  \n  // API surface. History \u2192 Field.trackHistory (ADR-0052).\n  enable: {\n    apiEnabled: true,\n    // #602 \u2014 screenshots and logs are how a support case gets diagnosed.\n    // See the canonical capability note in `src/sales/objects/index.ts`.\n    files: true,\n  },\n\n  // ADR-0052 \u00A75b.2 \u2014 declarative milestone activity for the service narrative.\n  // The caseSideEffects hook still owns its real side-effects (escalation task,\n  // closed-date stamping); these are timeline entries only, emitted by the platform.\n  activityMilestones: [\n    { field: 'status', value: 'escalated', summary: 'Case escalated \u2014 {subject}', type: 'updated' },\n    { field: 'status', value: 'resolved', summary: 'Case resolved \u2014 {subject}', type: 'completed' },\n    { field: 'status', value: 'closed', summary: 'Case closed \u2014 {subject}', type: 'completed' },\n  ],\n\n  // ADR-0079: render-only `titleFormat` retired in favor of `nameField`,\n  // which names a real field. The former template composed two local fields, so\n  // the `display_title` formula field (see fields) reproduces it.\n  nameField: 'display_title',\n  // Explicit search targets (ADR-0061). REQUIRED because nameField is a\n  // FORMULA (display_title/full_name): without this, $search auto-defaults to\n  // the formula field, which isn't a real column, so the lookup picker + global\n  // search silently return zero. These are real, indexed columns.\n  searchableFields: ['subject', 'case_number'],\n  highlightFields: ['case_number', 'subject', 'crm_account', 'status', 'priority'],\n  \n  // Removed: list_views and form_views belong in UI configuration, not object definition\n  \n  // Predicates below are TOTAL: every `record.x` read is `has()`-guarded, so the\n  // rule returns a verdict even when the merged record has no such key. See\n  // AGENTS.md \"Validation predicates must be TOTAL\" and\n  // test/object-validation-predicates.test.ts, which fails the build otherwise.\n  validations: [\n    {\n      name: 'resolution_required_for_closed',\n      type: 'script',\n      severity: 'error',\n      message: 'Resolution is required when closing a case',\n      condition: P`has(record.status) && record.status == \"closed\" && (!has(record.resolution) || isBlank(record.resolution))`,\n    },\n    {\n      name: 'escalation_reason_required',\n      type: 'script',\n      severity: 'error',\n      message: 'Escalation reason is required when escalating a case',\n      condition: P`has(record.is_escalated) && record.is_escalated == true && (!has(record.escalation_reason) || isBlank(record.escalation_reason))`,\n    },\n    {\n      name: 'case_status_progression',\n      type: 'state_machine',\n      severity: 'warning',\n      message: 'Invalid status transition',\n      field: 'status',\n      // Escalate + Close actions are available from ANY open status (see\n      // escalate_case / close_case visibility). The transition map must permit\n      // \u2192escalated and \u2192closed from every open state, else those actions emit a\n      // spurious \"Invalid status transition\" warning (e.g. escalating a brand-new\n      // case, which is a legitimate support move).\n      transitions: {\n        'new': ['in_progress', 'waiting_customer', 'escalated', 'closed'],\n        'in_progress': ['waiting_customer', 'waiting_support', 'escalated', 'resolved', 'closed'],\n        'waiting_customer': ['in_progress', 'waiting_support', 'escalated', 'closed'],\n        'waiting_support': ['in_progress', 'waiting_customer', 'escalated', 'closed'],\n        'escalated': ['in_progress', 'resolved', 'closed'],\n        'resolved': ['closed', 'in_progress'],  // Can reopen\n        'closed': ['in_progress'],  // Can reopen\n      }\n    },\n  ],\n  \n  // \u26A0\uFE0F No `workflows[]` here, and none is possible: object `workflows[]` were\n  // removed from the platform. Field updates live in this object's `*.hook.ts`;\n  // scheduled status flips and notifications live in `src/*/flows/*.flow.ts`.\n});\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/service/objects/knowledge_article.object.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/service/objects\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/service/objects/knowledge_article.object.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport { ObjectSchema, Field } from '@objectstack/spec/data';\nimport { F, P } from '@objectstack/spec';\n\n/**\n * Knowledge Article Object\n *\n * Reusable, search-indexed answers that back the Support Knowledge Base\n * and ground the assistant's case-resolution skills.\n *\n * Lifecycle: draft \u2192 in_review \u2192 published \u2192 archived.\n * Audience:  public (customer portal visible) | internal (agent-only).\n */\nexport const KnowledgeArticle = ObjectSchema.create({\n  name: 'crm_knowledge_article',\n  label: 'Knowledge Article',\n  pluralLabel: 'Knowledge Articles',\n  icon: 'book-open',\n  description: 'Reusable knowledge base articles for self-service and AI grounding',\n\n  // ADR-0090 D1/D7: OWD is an authored decision. Knowledge base is org-readable; authors edit.\n  sharingModel: 'public_read',\n\n  // \u2500\u2500\u2500 Public access \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n  //\n  // Publishing a public article mints a share link through the platform's\n  // `publicSharing` surface (maintainer ruling, 2026-08-02: no customer portal,\n  // no anonymous-grant widening). \u26D4 The whole safety of that rests on\n  // `eligibility`, which is the ONLY thing standing between a share dialog and\n  // a stranger reading an internal or draft article \u2014 so this block may only be\n  // declared while every key below is enforced.\n  //\n  // MEASURED on `@objectstack/plugin-sharing@17.1.0` \u2014 the version\n  // installed AT THE TIME of the measurement, not the current pin (this table\n  // has NOT been re-taken on any later pin \u2014 not 17.3.0, #1676, not 17.4.0,\n  // PR #1814, and not 17.5.0) \u2014\n  // against the real `ShareLinkService` and a real engine,\n  // not read off a grep count:\n  //\n  //   | key                  | measured on 17.1.0                             |\n  //   | -------------------- | ---------------------------------------------- |\n  //   | `enabled`            | ENFORCED \u2014 false \u21D2 SHARING_NOT_ENABLED 422     |\n  //   | `allowedAudiences`   | ENFORCED \u2014 `signed_in` refused 422             |\n  //   | `allowedPermissions` | ENFORCED \u2014 non-`view` refused 422              |\n  //   | `redactFields`       | APPLIED to every token-served response         |\n  //   | `eligibility`        | **ENFORCED \u2014 false verdict \u21D2 422, no link**    |\n  //\n  // `test/knowledge-article-share-links.test.ts` drives all of it end to end\n  // and is the acceptance evidence; read it before changing anything here.\n  //\n  // \u26A0\uFE0F TWO SPELLING TRAPS, both measured, both of which produce a block that\n  // LOOKS declared and silently is not:\n  //\n  //  1. `eligibility` must be a PLAIN STRING. It is `z.ZodString` in the spec\n  //     and `getPolicy()` keeps it only when `typeof raw.eligibility ===\n  //     'string'`. The `P` tagged template used by `validations[].condition`\n  //     below returns an Expression OBJECT `{ dialect, source }` \u2014 passing one\n  //     here does not narrow anything, it makes the predicate vanish.\n  //\n  //  2. Every field read is `record.`-PREFIXED. The evaluator is\n  //     `ExpressionEngine` from `@objectstack/formula` (record-level CEL), and\n  //     `record` is the ONLY binding it is given. The bare-identifier spelling\n  //     `status == 'published' && audience == 'public'` COMPILES and then fails\n  //     at evaluate with `Unknown variable: audience`,\n  //     which `assertEligible` turns into ELIGIBILITY_UNEVALUABLE 422. That\n  //     fails CLOSED, so it is not a security hole; it is a feature that never\n  //     mints a single link while reading as if it works.\n  //\n  // The predicate is TOTAL for the same reason the `validations` below are:\n  // `has()` guards every read. `assertEligible` materializes declared fields to\n  // `null` first, so an absent key would not abort here today \u2014 the guards keep\n  // that true if the field set changes. (The `has(record.x)` caveat carried\n  // from objectstack#7861 is about `compileCelToFilter`, the SHARING-RULE path.\n  // That is a different evaluator, it is not on this code path, and it is not\n  // even exported from `@objectstack/plugin-sharing`. Verified, not assumed.)\n  //\n  // \u26A0\uFE0F Eligibility is evaluated at MINT time only; `resolveToken()` does not\n  // re-check it. Re-classifying a published/public article to internal or back\n  // to draft does NOT revoke links already minted from it \u2014 those must be\n  // revoked explicitly. That is platform behaviour, filed upstream, not\n  // something this app compensates for app-side.\n  publicSharing: {\n    enabled: true,\n    // `public` and `link_only` only. `signed_in` would be a different feature\n    // and `email` is refused at creation without an allowlist.\n    allowedAudiences: ['public', 'link_only'],\n    // Read-only. Same as the platform default, declared anyway: this is a\n    // security boundary, and a default is not a decision.\n    allowedPermissions: ['view'],\n    // The gate. Published AND public-audience, nothing else \u2014 a draft, an\n    // in_review, an archived, or any internal-audience article is refused at\n    // `createLink` with RECORD_NOT_ELIGIBLE 422 and no row is written.\n    eligibility:\n      'has(record.status) && record.status == \"published\" && ' +\n      'has(record.audience) && record.audience == \"public\"',\n    // Stripped from every token-served response. These are the fields that\n    // exist for staff: who owns the article, which customer case it was\n    // written from, and when an editor last reviewed it. None of them are part\n    // of the answer a reader followed the link for.\n    redactFields: ['owner_id', 'related_to_case', 'last_reviewed_at'],\n  },\n\n  // ADR-0079: render-only `titleFormat` retired in favor of `nameField`,\n  // which names a real field. The former template composed two local fields, so\n  // a `display_title` formula field reproduces it for the record title.\n  nameField: 'display_title',\n  // Explicit search targets (ADR-0061). REQUIRED because nameField is a\n  // FORMULA (display_title/full_name): without this, $search auto-defaults to\n  // the formula field, which isn't a real column, so the lookup picker + global\n  // search silently return zero. These are real, indexed columns.\n  searchableFields: ['title', 'article_number', 'summary'],\n  highlightFields: ['article_number', 'title', 'category', 'status', 'audience'],\n\n  fieldGroups: [\n    { key: 'basic',     label: 'Article Information', icon: 'info' },\n    { key: 'content',   label: 'Content',             icon: 'file-text' },\n    { key: 'taxonomy',  label: 'Categorization',      icon: 'tag' },\n    { key: 'metrics',   label: 'Engagement',          icon: 'activity', collapse: 'collapsed' },\n  ],\n\n  fields: {\n    // Platform ownership anchor \u2014 canonical note in `account.object.ts` (#548).\n    owner_id: Field.lookup('sys_user', {\n      label: 'Article Owner',\n      group: 'basic',\n      system: true,\n      readonly: false,\n      trackHistory: true,\n    }),\n\n    article_number: Field.autonumber({\n      label: 'Article Number',\n      format: 'KA-{0000}',\n      group: 'basic',\n    }),\n\n    title: Field.text({\n      label: 'Title',\n      required: true,\n      storage: { notNull: true },\n      searchable: true,\n      maxLength: 255,\n      group: 'basic',\n    }),\n\n    // ADR-0079 record title (was titleFormat '{article_number} - {title}').\n    display_title: Field.formula({\n      label: 'Display Title',\n      expression: F`record.article_number + \" - \" + record.title`,\n      group: 'basic',\n    }),\n\n    summary: Field.text({\n      label: 'Summary',\n      description: 'One-paragraph TL;DR shown in search results and AI citations.',\n      maxLength: 500,\n      searchable: true,\n      group: 'basic',\n    }),\n\n    body: Field.markdown({\n      label: 'Body',\n      description: 'Full article content (Markdown).',\n      searchable: true,\n      group: 'content',\n    }),\n\n    category: Field.select({\n      label: 'Category',\n      group: 'taxonomy',\n      options: [\n        { label: 'Getting Started',     value: 'getting_started', default: true },\n        { label: 'How-To',              value: 'how_to' },\n        { label: 'Troubleshooting',     value: 'troubleshooting' },\n        { label: 'Billing & Pricing',   value: 'billing' },\n        { label: 'API & Integrations',  value: 'api' },\n        { label: 'Release Notes',       value: 'release_notes' },\n        { label: 'Policy',              value: 'policy' },\n      ],\n    }),\n\n    tags: Field.select({\n      label: 'Tags',\n      multiple: true,\n      group: 'taxonomy',\n      options: [\n        { label: 'Auth',          value: 'auth' },\n        { label: 'SSO',           value: 'sso' },\n        { label: 'Mobile',        value: 'mobile' },\n        { label: 'Email',         value: 'email' },\n        { label: 'Reports',       value: 'reports' },\n        { label: 'Performance',   value: 'performance' },\n        { label: 'Data Import',   value: 'data_import' },\n        { label: 'Webhooks',      value: 'webhooks' },\n      ],\n    }),\n\n    status: Field.select({\n      label: 'Status',\n      required: true,\n      storage: { notNull: true },\n      group: 'basic',\n      trackHistory: true,\n      options: [\n        { label: 'Draft',      value: 'draft',     color: '#94A3B8', default: true },\n        { label: 'In Review',  value: 'in_review', color: '#F59E0B' },\n        { label: 'Published',  value: 'published', color: '#10B981' },\n        { label: 'Archived',   value: 'archived',  color: '#475569' },\n      ],\n    }),\n\n    audience: Field.select({\n      label: 'Audience',\n      required: true,\n      storage: { notNull: true },\n      group: 'basic',\n      description: 'Public articles are visible in the customer portal; internal articles are agent-only.',\n      options: [\n        { label: 'Public',   value: 'public', default: true, color: '#0EA5E9' },\n        { label: 'Internal', value: 'internal', color: '#7C3AED' },\n      ],\n    }),\n\n    language: Field.select({\n      label: 'Language',\n      group: 'basic',\n      options: [\n        { label: 'English',             value: 'en', default: true },\n        { label: 'Simplified Chinese',  value: 'zh_cn' },\n        { label: 'Spanish',             value: 'es_es' },\n        { label: 'Japanese',            value: 'ja_jp' },\n      ],\n    }),\n\n    related_to_case: Field.lookup('crm_case', {\n      label: 'Originating Case',\n      description: 'Case this article was authored from (optional).',\n      group: 'content',\n    }),\n\n\n    published_at: Field.datetime({\n      label: 'Published At',\n      readonly: true,\n      group: 'basic',\n    }),\n\n    last_reviewed_at: Field.datetime({\n      label: 'Last Reviewed At',\n      readonly: true,\n      group: 'basic',\n    }),\n\n    /**\n     * `view_count` is GONE (#601), and this note is the record of why.\n     *\n     * All three engagement counters were `readonly: true` with a writer\n     * nowhere \u2014 on the platform or in this app \u2014 so all three were pinned at\n     * whatever the seed said, forever, while the article grid summed a \"Views\"\n     * column. ADR-0049's enforce-or-remove leaves two honest endings per\n     * field: give it a writer, or delete it. The card left this one to the\n     * implementer, and the two below went the other way, so the split is\n     * argued rather than assumed.\n     *\n     * A page-view writer WOULD have been expressible \u2014 `afterFind` is a real\n     * hook event on this platform. It is not built, because of what the event\n     * actually means: `beforeFind`/`afterFind` fire on record MATERIALIZATION,\n     * for `find` and `findOne` alike, with no per-method read event\n     * (deliberately \u2014 see the spec's note on #3195). So a counter written\n     * there would increment on the article grid, on global search, on the\n     * lookup picker in the close-case screen, on the AI grounding queries that\n     * cite articles \u2014 every one of them a \"view\" of a row nobody read. The\n     * number would grow fastest for articles nobody opens, and it would carry\n     * a database write on every read path in the app to do it.\n     *\n     * \"Views\" that means \"appearances in any query\" is a worse lie than a\n     * field that is missing, because it looks like data. A real page-view\n     * counter needs a real view event from a real article surface \u2014 the day\n     * one exists, this field comes back with it, and not before.\n     *\n     * `helpful_count` / `not_helpful_count` DO get a writer, and it is the\n     * whole reason `crm_article_feedback` exists: reader verdicts are recorded\n     * as rows and these two are RECOUNTED from them by\n     * `article_feedback_metrics_refresh`. They stay `readonly: true` and that\n     * is now an accurate statement \u2014 derived from evidence, never typed in.\n     */\n    helpful_count: Field.number({\n      label: 'Helpful Votes',\n      group: 'metrics',\n      readonly: true,\n      defaultValue: 0,\n      description: 'Recounted from crm_article_feedback \u2014 never typed in.',\n    }),\n\n    not_helpful_count: Field.number({\n      label: 'Not Helpful Votes',\n      group: 'metrics',\n      readonly: true,\n      defaultValue: 0,\n      description: 'Recounted from crm_article_feedback \u2014 never typed in.',\n    }),\n  },\n\n  indexes: [\n    { fields: ['title'] },\n    { fields: ['category'] },\n    { fields: ['status'] },\n    { fields: ['audience'] },\n    { fields: ['language'] },\n  ],\n\n  // API surface. History \u2192 Field.trackHistory (ADR-0052).\n  enable: {\n    apiEnabled: true,\n    apiMethods: ['get', 'list', 'create', 'update', 'delete'],\n  },\n\n  // Predicates below are TOTAL: every `record.x` read is `has()`-guarded, so the\n  // rule returns a verdict even when the merged record has no such key. See\n  // AGENTS.md \"Validation predicates must be TOTAL\" and\n  // test/object-validation-predicates.test.ts, which fails the build otherwise.\n  validations: [\n    {\n      name: 'published_requires_body',\n      type: 'script',\n      severity: 'error',\n      message: 'Articles cannot be published without a body.',\n      condition: P`has(record.status) && record.status == \"published\" && (!has(record.body) || record.body == null || record.body == \"\")`,\n    },\n    {\n      name: 'published_requires_summary',\n      type: 'script',\n      severity: 'warning',\n      message: 'Published articles should have a summary for search results and AI citations.',\n      condition: P`has(record.status) && record.status == \"published\" && (!has(record.summary) || record.summary == null || record.summary == \"\")`,\n    },\n  ],\n});\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/sales/objects/index.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/sales/objects\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/sales/objects/index.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\n/**\n * Object Definitions Barrel\n * \n * Re-exports this package's *.object.ts definitions for registration by the\n * app package's stack (`objectstack.composition.ts` \u2192 `src/sales/index.ts`). The `*.hook.ts` files sit beside them and are\n * registered through `./hooks.ts` instead \u2014 a hook is attached to the object\n * it names, and since the ADR-0130 layout a directory is a package, so the two\n * travel together.\n */\n\n/*\n * Canonical note \u2014 the collaboration capabilities (`enable.files`,\n * `enable.feeds`). Referenced from each object that opts in (#602).\n *\n * **`enable.files` \u2014 attachments. Opt-in, spec default `false`.** It is a real,\n * doubly-enforced switch, not documentation:\n *\n * - Server: `plugin-audit`'s `enforceFilesCapability` runs `beforeInsert` on\n *   `sys_attachment` and throws `FILES_DISABLED` (403) when the row's\n *   `parent_object` does not declare `files: true`. No flag \u2192 no attachment can\n *   exist against the record, whatever the UI offers.\n * - Client: the console's `RecordDetailView` gates its Attachments panel on\n *   `enable?.files === true`, so an object without the flag has no upload\n *   surface at all.\n *\n * The flag opens the surface; it grants **no** access of its own, and nothing\n * else on the platform does either. `sys_attachment` is an object like any\n * other: the platform's member baseline names it nowhere (it was narrowed to\n * explicit-allow, objectstack-ai/objectstack#5491), so a person whose\n * permission sets do not grant it is refused the whole panel with 403\n * `PERMISSION_DENIED`, reads included. Measured on a fresh `pnpm dev` box\n * (#2029): `na.rep`, opening a quote they can read, got \"You don't have access\n * to these attachments\", and every other demo persona got the same answer.\n * The platform's attachments-access page names the remedy: an ordinary,\n * position-distributed permission set grants `sys_attachment`. So EVERY\n * permission set whose holders can read a files-enabled object grants it\n * `allowRead`, and `guest_portal` grants nothing.\n *\n * WHICH attachments that grant reaches stays with the parent record: a\n * `service-storage` middleware intersects every `sys_attachment` read with the\n * parents the caller can actually see (failing closed to a deny-all filter on\n * error). So a rep lists the attachments of the quotes they can read and of no\n * other (`test/record-attachments-access.test.ts` measures it).\n *\n * **Upload and delete are NOT granted, on purpose (#2029).** Their gate is\n * `canEdit(parent)` (attach) and uploader-or-`canEdit(parent)` (delete), asked\n * of the sharing service, and on 17.7.0 that service answers `true` for EVERY\n * `controlled_by_parent` object: it reads that model as `public` and never asks\n * the master. Three of the six files-enabled objects are such children\n * (`crm_contact`, `crm_quote`, `crm_contract`). Measured on the same box with\n * the write bits granted: `na.rep` attached a file to a quote they get 404 on\n * (201), and on a contract whose own PATCH answers them 403 they attached a\n * file (201) and deleted the admin's executed-contract file (200), while an\n * attach to a private account they cannot read answered 403\n * `ATTACHMENT_PARENT_ACCESS`. So the write bits would let every persona plant\n * files on, and delete others' files from, quotes, contracts and contacts\n * they cannot edit. That is a platform defect, reported upstream\n * from #2029; until its fix is in the pinned version, only an administrator\n * uploads, and the write bits join `allowRead` here when it lands (AGENTS.md\n * \u00A72: wait, do not route around it).\n *\n * Leads are deliberately excluded \u2014 attachments on unqualified leads invite\n * junk. Revisit on demand.\n *\n * **`enable.feeds` \u2014 record comments (`sys_comment`). Opt-OUT, spec default\n * `true`.** Both enforcement points gate on an explicit `false`\n * (`enforceFeedsCapability` throws `FEEDS_DISABLED` only for `feeds === false`;\n * the console renders the feed unless `enable?.feeds === false`), so every\n * HotCRM object already has comments enabled and authoring `feeds: true` would\n * restate a default rather than change behaviour. Do not add it: an inert\n * restatement is the kind of metadata that later reads as load-bearing.\n * If comments ever need to be switched off for an object, author `false`.\n * `test/collaboration-capabilities.test.ts` pins both halves of this rule.\n *\n * Verified in a live console (#602): the Discussion panel renders on the\n * opportunity and account records, a posted comment round-trips\n * (`POST /api/v1/data/sys_comment` \u2192 201) and survives a reload.\n *\n * Like `enable.files`, the flag opens the surface and grants no access. The\n * Discussion panel reads two platform objects, `sys_comment` (the comments)\n * and `sys_activity` (the record's activity timeline), and the member baseline\n * names neither, so through #2029 every persona but the platform admin got\n * \"You don't have permission to view comments on this record\" and the same for\n * its activity (403 `PERMISSION_DENIED`). So every set that grants\n * `sys_attachment` also grants `sys_comment` read, create and edit and\n * `sys_activity` read, and `guest_portal` grants neither.\n *\n * WHICH threads those grants reach is the platform's, and it follows the\n * parent record (the platform's objectstack-ai/objectstack#4630 gates): a\n * `plugin-audit` middleware narrows every `sys_comment` and `sys_activity` read\n * to rows whose parent the caller can read, a post to a thread whose record the\n * caller cannot read is refused with 403 `RECORD_NOT_ACCESSIBLE`, and only a\n * comment's author may edit it. Measured as `na.rep` on a fresh `pnpm dev` box\n * (#2029): the comments and activity of the accounts, quotes and contracts they\n * can read are listed, those of records they cannot read are not (404 by id),\n * and a post to one of those is refused. `test/record-comments-access.test.ts`\n * pins it.\n *\n * **Deleting a comment is NOT granted, on purpose (#2029).** Its gate is\n * author-or-`canEdit(parent)`, the same sharing-service call as the attachment\n * gate above, with the same 17.7.0 answer of `true` for every\n * `controlled_by_parent` parent. Measured with the delete bit granted: `na.rep`\n * deleted the admin's comment on a contract whose own PATCH answers them 403.\n * Reported upstream from #2029; the delete bit joins the grant when the fix is\n * in the pinned version (AGENTS.md \u00A72).\n */\n\nexport { Account } from './account.object';\nexport { Contact } from './contact.object';\nexport { Event } from './event.object';\nexport { EventAttendee } from './event_attendee.object';\nexport { Forecast } from './forecast.object';\nexport { Lead } from './lead.object';\nexport { Opportunity } from './opportunity.object';\nexport { Task } from './task.object';\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/sales/objects/account.object.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/sales/objects\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/sales/objects/account.object.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport { ObjectSchema, Field } from '@objectstack/spec/data';\nimport { F } from '@objectstack/spec';\nimport { INDUSTRY_OPTIONS } from './_picklists';\nimport { TERRITORY_OPTIONS } from './_territory';\n\nexport const Account = ObjectSchema.create({\n  name: 'crm_account',\n  label: 'Account',\n  pluralLabel: 'Accounts',\n  icon: 'building',\n  description: 'Companies and organizations doing business with us',\n\n  // ADR-0090 D1/D7: OWD is an authored decision. Owner + sharing rules (team/territory grants below).\n  sharingModel: 'private',\n  // ADR-0079: render-only `titleFormat` retired in favor of `nameField`,\n  // which names a real field. The former template composed two local fields, so\n  // a `display_title` formula field reproduces it for the record title.\n  nameField: 'display_title',\n  // Explicit search targets (ADR-0061). REQUIRED because nameField is a\n  // FORMULA (display_title/full_name): without this, $search auto-defaults to\n  // the formula field, which isn't a real column, so the lookup picker + global\n  // search silently return zero. These are real, indexed columns.\n  searchableFields: ['name', 'account_number', 'registration_number'],\n  highlightFields: ['account_number', 'name', 'type', 'owner_id'],\n  // The record's picture (#1199): the record chrome draws the logo beside the\n  // title in every account page header. No logo, no picture: the platform\n  // draws no placeholder or initials in its place.\n  imageField: 'logo',\n\n  // Field groups organize the form layout. Array order == display order.\n  // Each field below opts in via `group: '<key>'`.\n  fieldGroups: [\n    { key: 'basic',        label: 'Basic Information',  icon: 'building' },\n    { key: 'financials',   label: 'Financials',         icon: 'dollar-sign' },\n    // REQ-0003 acceptance 3: the business-profile fields render as their own\n    // group with NO `record:details` section authored anywhere \u2014 the derived\n    // layout ladder's rung 1 (AGENTS.md: escape hatches are for extreme cases).\n    { key: 'business_profile', label: 'Business Profile', icon: 'briefcase' },\n    { key: 'contact_info', label: 'Contact Information', icon: 'phone' },\n    { key: 'ownership',    label: 'Ownership & Status', icon: 'users' },\n    { key: 'branding',     label: 'Branding',           icon: 'palette', collapse: 'collapsed' },\n    { key: 'system',       label: 'System',             icon: 'settings', collapse: 'collapsed' },\n  ],\n\n  fields: {\n    // \u2500\u2500\u2500 Ownership \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n    //\n    // `owner_id` is the PLATFORM ownership anchor, not an app invention: the\n    // registry injects exactly this column into every user-owned object\n    // (`applySystemFields`), and it is the one OWD, sharing rules, owner-scope\n    // widening and the `is_private` row filter all read. \u26D4 Never author a\n    // SECOND `owner` lookup beside it \u2014 reassigning that moves the record in\n    // every list and report and moves no access at all.\n    //\n    // \u26A0\uFE0F Declared rather than left to injection, which the platform supports\n    // explicitly (\"author-declared fields with the same name always win over\n    // injection, no overwrite\"). Three things only a declaration buys:\n    //   \u2022 `os validate` resolves it. An injected column is invisible to every\n    //     author-time rule, so `highlightFields: ['owner_id']` is reported as\n    //     \"not a field on this object \u2014 silently skipped by every consumer\",\n    //     and a CEL predicate reading `record.owner_id` fails outright.\n    //   \u2022 the per-object label and `group` survive (an injected field carries\n    //     the generic label \"Owner\" and no group at all);\n    //   \u2022 `trackHistory` survives, so a transfer still renders on the record\n    //     timeline instead of only in the compliance audit log.\n    // `system: true` keeps the injected marker the platform's own tooling\n    // reads \u2014 notably the clone path, which strips system columns so a copy is\n    // stamped to the cloner rather than inheriting the source's owner.\n    //\n    // No `defaultValue`: the security middleware stamps `owner_id` to the\n    // acting user on any insert that leaves it empty, and denies one that names\n    // another user without `allowTransfer` (#3004). That is stronger than a\n    // field default, which evaluates to nothing on every user-less write.\n    owner_id: Field.lookup('sys_user', {\n      label: 'Account Owner',\n      group: 'ownership',\n      system: true,\n      readonly: false,\n      trackHistory: true,\n    }),\n\n    // AutoNumber field - Unique account identifier\n    account_number: Field.autonumber({\n      label: 'Account Number',\n      format: 'ACC-{000000}',\n      group: 'basic',\n    }),\n\n    // Basic Information\n    //\n    // \u26A0\uFE0F `unique: true` is declared HERE, on the field, and deliberately NOT as\n    // a `{ fields: ['name'], unique: true }` entry in `indexes[]` below. The\n    // field-level form is tenant-scoped \u2014 it materializes as\n    // `(organization_id, name)`, unique WITHIN an organization \u2014 while a\n    // declared index is taken verbatim, i.e. platform-wide. The table form\n    // means the SECOND organization to create an \"Acme Corp\" is rejected by the\n    // database, and account name is also the seed data's external-id / upsert\n    // key (`src/sales/data/sales.seed.ts`), so it bites the first multi-tenant\n    // install. The composite also indexes the column, so no separate\n    // `{ fields: ['name'] }` entry is needed for the `searchableFields` /\n    // seed-upsert read paths.\n    name: Field.text({\n      label: 'Account Name',\n      required: true,\n      storage: { notNull: true },\n      searchable: true,\n      unique: true,\n      maxLength: 255,\n      group: 'basic',\n    }),\n\n    /**\n     * Case- and whitespace-folded copy of `name` \u2014 the key lead conversion\n     * matches accounts on.\n     *\n     * ### Why a stored column, and not any of the cheaper shapes\n     *\n     * \u26A0\uFE0F Three cheaper fixes are all dead ends, and each is a live platform\n     * constraint. `test/account-name-normalized-match.test.ts` re-measures every\n     * one so this note cannot quietly go stale:\n     *\n     * - **A flow cannot normalize.** `service-automation`'s `resolveToken`\n     *   understands exactly one function form, `/^(NOW|TODAY)\\s*\\(\\s*\\)\u2026/`.\n     *   `{LOWER(x)}`, `{TRIM(x)}` and `{x.toLowerCase()}` all resolve to\n     *   `undefined` (every bare identifier is substituted before the expression\n     *   is evaluated, so no string method is reachable), and an unwrapped\n     *   `LOWER({x})` interpolates literally to `\"LOWER(Acme Corp)\"`.\n     * - **A formula field cannot be the match key.** `driver-sql`'s\n     *   `fieldHasColumn` returns false for `type: 'formula'`, so a computed\n     *   value has no physical column and nothing can filter on it.\n     * - **`$regex` is not an answer.** On `driver-sql` it does not run as a\n     *   regex at all: it compiles to `LIKE '%value%'`, a SUBSTRING match, so\n     *   `\"Acme Corp\"` also matches `\"Not Acme Corp Ltd\"`. It cannot collapse\n     *   internal whitespace, the leading wildcard defeats the index, and on the\n     *   in-memory driver it does compile user-controlled text into a `RegExp`.\n     *\n     * So the canonical form is established by the PRODUCER at write time \u2014 the\n     * same doctrine `crm_lead.email` / `crm_contact.email` follow \u2014 and the\n     * reader does a plain, indexed equality match. The other side of that\n     * comparison is `crm_lead.company_normalized`, which exists for the same\n     * reason: a flow can compare two stored columns, it cannot compute either.\n     *\n     * ### What it holds\n     *\n     * `name`, trimmed, lower-cased, with runs of internal whitespace collapsed\n     * to one space. Nothing else \u2014 normalize-then-EXACT. Fuzzy matching\n     * (punctuation folding, legal-suffix stripping, edit distance) is\n     * deliberately out of scope; it turns a lookup into a ranking problem and\n     * needs a human review affordance this app does not have.\n     *\n     * Derived, never authored: `account.hook.ts` recomputes it on every write\n     * that carries `name`, and leaves it alone otherwise. `readonly` keeps\n     * user/API writes off it (INSERT is exempt from the strip and UPDATE strips\n     * only CALLER-supplied keys, so the hook's own write always survives);\n     * `hidden` keeps a machine-owned column out of forms and pickers \u2014 the same\n     * pairing `crm_forecast.seed_key` uses.\n     */\n    name_normalized: Field.text({\n      label: 'Account Name (Normalized)',\n      description:\n        'Match key for lead conversion: Account Name lower-cased, trimmed, with internal whitespace collapsed. Maintained by the account_protection hook \u2014 never edit directly.',\n      readonly: true,\n      hidden: true,\n      maxLength: 255,\n      group: 'system',\n    }),\n\n    // ADR-0079 record title (was titleFormat '{account_number} - {name}').\n    display_title: Field.formula({\n      label: 'Display Title',\n      expression: F`record.account_number + \" - \" + record.name`,\n      group: 'basic',\n    }),\n\n    /**\n     * The counterparty's registered identity in a government registry.\n     *\n     * \u26D4 NOT named after one country's registry, and that is the whole design\n     * constraint (REQ-0003 *Disposition & rationale*). The requirement arrived\n     * as \u793E\u4F1A\u4FE1\u7528\u4EE3\u7801 because the customer registers in China; a Japanese install\n     * writes \u6CD5\u4EBA\u756A\u53F7 here, a German one a Handelsregisternummer, a US one an\n     * EIN. A `unified_social_credit_code` field would carry one country's\n     * registry in its NAME, where no install can rename it \u2014 so the core field\n     * is generic and the registry it came from is the install's own knowledge.\n     *\n     * \u26A0\uFE0F Distinct from `account_number` above, which is OUR sequence\n     * (`Field.autonumber`, `ACC-{000000}`) and already spent as half the record\n     * title. That is an identifier we issue; this is one we were given, and\n     * invoicing, credit checks and entity resolution key on the latter.\n     *\n     * `searchable` + the `searchableFields` entry above is REQ-0003 acceptance\n     * 1 \u2014 the value is findable from global search and the lookup picker. It is\n     * indexed below for that read path.\n     *\n     * \u26D4 NOT `unique: true`. Refusing a save because two rows carry the same\n     * registered identity is a data-quality POLICY, and this repo has already\n     * chosen the soft shape for that question once \u2014 the hard unique on\n     * `crm_lead.email` was removed because refusing a repeat is worse than\n     * recording it. The same reasoning `name_normalized` records: a match key,\n     * not a policy. Deduplication is a review affordance this app does not have.\n     */\n    registration_number: Field.text({\n      label: 'Registration Number',\n      description:\n        \"The counterparty's registered identity as issued by its own government registry \u2014 whichever registry that is. Not the Account Number, which we issue.\",\n      searchable: true,\n      maxLength: 64,\n      group: 'basic',\n    }),\n\n    /**\n     * What this account may be used for commercially \u2014 the category that GATES\n     * capability rather than merely classifying (REQ-0003, the record's most\n     * valuable primitive: *some counterparties are payable but not sellable*).\n     *\n     * ## Why a field BESIDE `type`, and not four more options on it\n     *\n     * REQ-0003 leaves this open (\"either new options on `type` or a field\n     * beside it, decided when built\"). It is a separate field because `type`\n     * is a RELATIONSHIP-STAGE axis \u2014 prospect \u2192 customer \u2192 former, plus\n     * partner \u2014 and it already has two readers that would be broken by a value\n     * meaning \"may not be sold to\": `account.hook.ts` promotes on it, and\n     * `opportunity.hook.ts` flips a won deal's account to `customer`. An\n     * `agency` option on `type` would therefore be overwritten into `customer`\n     * by the first won deal booked against it, silently un-restricting the\n     * account. The two axes are independent \u2014 an agency can be a prospect, a\n     * customer or a former customer \u2014 so they are two fields.\n     *\n     * ## Generic values only\n     *\n     * REQ-0003 rules the customer's own vocabulary (\u62DB\u6807\u4EE3\u7406\u516C\u53F8 \u2026) **C**:\n     * overlay configuration, \u26D4 never committed into core. Core ships the\n     * capability distinction itself; an install maps its market's categories\n     * onto these two values.\n     *\n     * ## What reads it: `opportunity.hook.ts` `beforeInsert`\n     *\n     * REQ-0003 is explicit that \"a category no rule reads is prose, and the\n     * rule is the point\", so this field ships WITH its reader. The reader is a\n     * hook, and which construct carries the gate is a maintainer ruling\n     * (2026-09-16), quoted verbatim and kept untranslated:\n     *\n     *   \u300C\u95F8\u95E8\u8D70 `opportunity.hook.ts` \u7684 `beforeInsert`\uFF0C\u7528 hook \u7684 `ctx.api` \u8BFB\u5BA2\u6237\u7C7B\u522B\u3002\n     *    REQ-0003 \u7B2C 128 \u884C\u7684 `validations[]` \u4E0E\u8BE5\u8BB0\u5F55\u81EA\u5DF1\u7684\u9A8C\u6536\u7B2C 2 \u6761\u51B2\u7A81\uFF0C\u4EE5\u9A8C\u6536\u4E3A\u51C6\u3002\u300D\n     *\n     * \u26D4 Do NOT restate the gate as the `validations[]` entry REQ-0003 line\n     * 128 names. TWO independent measurements say it cannot be that, and both\n     * are recorded here because each alone would be talked past:\n     *\n     *   1. **It would brick history.** A validation is evaluated against\n     *      `{...previous, ...data}` on EVERY write, so \"already linked to a\n     *      restricted account\" and \"linking now\" are the same state and every\n     *      later edit to every historical opportunity would be refused \u2014 the\n     *      exact thing REQ-0003 acceptance 2 forbids (\"opportunities that\n     *      already point at it keep working and keep being editable\").\n     *      `lead.hook.ts` carries the same finding for its own gate.\n     *   2. **It cannot read the account at all.** A predicate is evaluated by\n     *      `checkPredicate(rule, merged, previous)` over plain data objects \u2014\n     *      the opportunity's OWN stored columns. `record.crm_account.type`\n     *      does not traverse the lookup (measured: `runtime: No such key:\n     *      type`), and `os.lookup(...)` has no overload because `buildScope()`\n     *      in `@objectstack/formula` composes `os` from only `ctx.user` /\n     *      `ctx.org` / `ctx.env` and never binds `ctx.api` (measured:\n     *      `runtime: found no matching overload for 'dyn.lookup(string,\n     *      dyn)'`; filed upstream as objectstack#18318). An unevaluable\n     *      predicate REJECTS THE WRITE, so authoring it literally refuses\n     *      every opportunity write, insert and update alike.\n     *\n     * \u26A0\uFE0F The hook's `ctx.api` is a DIFFERENT surface from the formula\n     * `EvalContext.api` that measurement 2 is about, and the two are routinely\n     * confused. The hook one is live and used ~20 times across\n     * `src/sales/objects/*.hook.ts`; its shape is `./_hook-api.ts`, pinned\n     * against a real engine by `test/hook-query-predicate.test.ts` and\n     * `test/hook-write-shape.test.ts`. objectstack#18318 does not block this\n     * field.\n     *\n     * \u26D4 Do NOT \"fix\" anything here by denormalising this value onto\n     * `crm_opportunity`: a copy needs a writer and goes stale the moment an\n     * account is reclassified, and anything able to write the copy is able to\n     * simply refuse.\n     */\n    commercial_capability: Field.select({\n      label: 'Commercial Capability',\n      group: 'basic',\n      description:\n        'Whether new business may be opened against this account. Settlement Only accounts stay fully usable for billing and payment, but no new opportunity may be linked to them.',\n      defaultValue: 'full',\n      options: [\n        { label: 'Full', value: 'full', color: '#00AA00', default: true },\n        { label: 'Settlement Only', value: 'settlement_only', color: '#FFA500' },\n      ],\n    }),\n\n    // Select fields with custom options\n    type: Field.select({\n      label: 'Account Type',\n      group: 'basic',\n      options: [\n        { label: 'Prospect', value: 'prospect', color: '#FFA500', default: true },\n        { label: 'Customer', value: 'customer', color: '#00AA00' },\n        { label: 'Partner', value: 'partner', color: '#0000FF' },\n        { label: 'Former Customer', value: 'former', color: '#999999' },\n      ]\n    }),\n\n    industry: Field.select({\n      label: 'Industry',\n      group: 'basic',\n      // Canonical set shared with Lead (#490): lead_conversion copies\n      // `leadRecord.industry` onto the account it creates, so this must\n      // accept every Lead value.\n      options: [...INDUSTRY_OPTIONS],\n    }),\n\n    description: Field.markdown({\n      label: 'Description',\n      group: 'basic',\n    }),\n\n    // Number fields\n    annual_revenue: Field.currency({\n      label: 'Annual Revenue',\n      min: 0,\n      group: 'financials',\n      trackHistory: true,\n    }),\n\n    /**\n     * Rolled-up annual revenue of this account's direct children.\n     *\n     * \u26A0\uFE0F DIRECT children only, one level \u2014 the engine aggregates over the rows\n     * whose `parent_account` is this account, not over a transitive closure. A\n     * grandparent shows the sum of its own children, and the docs say so;\n     * anything else needs a different (and much more expensive) primitive than\n     * the one the platform ships.\n     *\n     * Self-referencing roll-ups are worth measuring rather than assuming,\n     * because parent and child are the same object and the engine's summary\n     * index is keyed by child object. `test/decorative-field-sweep.test.ts`\n     * drives all four legs of the lifecycle (insert, raise, re-parent, delete)\n     * so a platform regression cannot quietly turn this back into decoration.\n     */\n    child_account_revenue: Field.summary({\n      label: 'Child Account Revenue',\n      group: 'financials',\n      scale: 2,\n      summaryOperations: {\n        object: 'crm_account',\n        field: 'annual_revenue',\n        function: 'sum',\n        relationshipField: 'parent_account',\n      },\n    }),\n\n    number_of_employees: Field.number({\n      label: 'Employees',\n      min: 0,\n      group: 'financials',\n    }),\n\n    // \u2500\u2500\u2500 Business profile (REQ-0003 step 3) \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n    //\n    // Generic B2B sales intelligence, not IT-services vocabulary: who holds the\n    // account today, how much there is to win this year, and how they pay.\n    //\n    // \u26A0\uFE0F `annual_revenue` above answers none of these \u2014 it is the account's OWN\n    // turnover, what the counterparty earns, whereas the budget below is what\n    // it will SPEND with vendors. Reusing one for the other is the mistake this\n    // group exists to prevent.\n    //\n    // \u26A0\uFE0F `pnpm validate` reports all three as \"carrier-only \u2014 declared but\n    // nothing in this stack reads or displays it\", and that reading is EXPECTED\n    // here rather than a defect to tidy away. The liveness diagnostic counts\n    // view columns, form sections, page bindings, flow nodes, formulas, hooks\n    // and actions as sites; it does NOT count `fieldGroups` membership, which\n    // is precisely the DERIVED layout REQ-0003 acceptance 3 asks for (\"render\n    // as their own group \u2026 without any `record:details` section being\n    // authored\"). These are data-entry fields a person fills in and a person\n    // reads off the derived form. \u26D4 Do NOT answer the warning by authoring a\n    // `record:details` section \u2014 that is the escape hatch AGENTS.md reserves\n    // for a named customer demand, and it would trade acceptance 3 for a\n    // quieter log. No guard reads this warning.\n\n    incumbent_vendor: Field.text({\n      label: 'Incumbent Vendor',\n      description: 'The supplier currently holding this account for the spend we are chasing.',\n      maxLength: 255,\n      group: 'business_profile',\n    }),\n\n    annual_purchasing_budget: Field.currency({\n      label: 'Annual Purchasing Budget',\n      description: \"What this account expects to SPEND with vendors this year \u2014 not its own revenue.\",\n      min: 0,\n      group: 'business_profile',\n    }),\n\n    // Payment terms as a select, not free text: it is read by a person sizing\n    // cash-flow risk, and a picklist keeps that domain knowable. The values are\n    // the net-terms ladder every B2B install shares; a customer whose contracts\n    // use a different ladder overlays its own.\n    payment_cycle: Field.select({\n      label: 'Payment Cycle',\n      group: 'business_profile',\n      options: [\n        { label: 'Prepaid', value: 'prepaid' },\n        { label: 'Net 30', value: 'net_30' },\n        { label: 'Net 60', value: 'net_60' },\n        { label: 'Net 90', value: 'net_90' },\n      ],\n    }),\n\n    // Contact Information\n    phone: Field.text({\n      label: 'Phone',\n      format: 'phone',\n      group: 'contact_info',\n    }),\n\n    website: Field.url({\n      label: 'Website',\n      group: 'contact_info',\n    }),\n\n    // Structured Address field (new field type)\n    billing_address: Field.address({\n      label: 'Billing Address',\n      group: 'contact_info',\n    }),\n\n    /**\n     * Flat projection of `billing_address.country`.\n     *\n     * ### Why the flat column exists \u2014 the trap that catches every rule\n     * ### authored against an `address`\n     *\n     * \u26A0\uFE0F `billing_address` is an `address` field: the platform stores the whole\n     * {street, city, state, postalCode, country, countryCode, formatted} value\n     * in ONE column. A sharing rule's CEL condition is compiled to a\n     * pushdown-able `FilterCondition` by `compileCelToFilter`, and that compiler\n     * rejects every path reaching INSIDE such a value:\n     *\n     *     record.billing_address.country in [\"US\",\"CA\",\"MX\"]\n     *       \u2192 unsupported: cross-object/nested field path\n     *         \"record.billing_address.country\" is not pushdown-able\n     *\n     * `plugin-sharing` then refuses to seed the rule rather than degrade it to\n     * match-all, so the rule is dropped on every boot and its recipients get\n     * nothing at all. Measured: the blocker is the NESTED PATH, not the\n     * `in [...]` operator \u2014 `in [...]`, `==`, `!=`, `<`, `>`, `&&`, `||`, `!`,\n     * `startsWith()` and `== null` all compile fine against a FLAT field.\n     * Rewriting the condition as a disjunction of `==` therefore does NOT help;\n     * only a flat column does. `test/sharing-seeding.test.ts` measures that\n     * matrix instead of assuming it.\n     *\n     * ### What it holds\n     *\n     * `billing_address.country`, trimmed, internal whitespace collapsed, and\n     * upper-cased \u2014 nothing else. It is what was TYPED, so it is still free\n     * text and still capable of holding `Deutschland`. Nothing matches against\n     * it: `territory` below classifies it, and an unrecognised spelling lands in\n     * a stated `other`. `countryCode` is deliberately not consulted; see the\n     * note in `account.hook.ts` for why the ISO slot is not the input.\n     *\n     * Derived, never authored: `account.hook.ts` recomputes it on every write\n     * that carries `billing_address`, and leaves it untouched otherwise.\n     */\n    billing_country: Field.text({\n      label: 'Billing Country',\n      description:\n        'Derived from Billing Address \u2014 the country exactly as it was entered, trimmed and upper-cased. Territory is classified from it.',\n      readonly: true,\n      maxLength: 64,\n      group: 'contact_info',\n    }),\n\n    /**\n     * Territory \u2014 the declared value the territory sharing rules filter on.\n     *\n     * ### Why a select and not the country\n     *\n     * Matching free-text `billing_country` against a list of country codes\n     * inside a CEL string means an account whose address reads `United States`\n     * belongs to NO territory, silently \u2014 the metadata says territory sharing\n     * works and for that account it does nothing, with no error anywhere. A\n     * `select` makes the domain knowable: three values, declared, every one\n     * reachable, and an account outside the staffed territories says `other`\n     * rather than nothing.\n     *\n     * It also collapses four copies of the country list (two CEL strings and\n     * six localised documentation tables) into one authored table in\n     * `./_territory.ts`. Adding a country is a line there; the sharing rules,\n     * this picklist and the docs all follow, and\n     * `test/territory-single-source.test.ts` fails if any of them does not.\n     *\n     * ### Readonly, and always stated\n     *\n     * Derived by `account_protection` from `billing_address.country`, never\n     * authored \u2014 correcting an account's territory means correcting its\n     * address, which keeps ONE fact behind the classification. Every insert\n     * states it (an account with no address at all is `other`), and an update\n     * that does not carry the address leaves it alone.\n     */\n    territory: Field.select({\n      label: 'Territory',\n      description:\n        'Derived from Billing Address \u2014 the sales territory this account belongs to. Accounts outside the staffed territories are Other.',\n      readonly: true,\n      options: [...TERRITORY_OPTIONS],\n      group: 'contact_info',\n    }),\n\n    // Office Location (new field type)\n    office_location: Field.location({\n      label: 'Office Location',\n      group: 'contact_info',\n    }),\n\n    // Relationship fields\n\n    /**\n     * The account hierarchy. `child_account_revenue` below is its one reader \u2014\n     * the platform computes roll-up summaries itself, so the honest consumer is\n     * a single declaration rather than hand-written recompute hooks.\n     */\n    parent_account: Field.lookup('crm_account', {\n      label: 'Parent Account',\n      description: 'Parent company in hierarchy',\n      group: 'ownership',\n    }),\n\n    // Boolean field\n    is_active: Field.boolean({\n      label: 'Active',\n      defaultValue: true,\n      group: 'ownership',\n      trackHistory: true,\n    }),\n\n    /**\n     * Where this account stands in its sign-off (REQ-0003 step 5 / acceptance 4).\n     *\n     * `readonly`, so only the platform's own approval write reaches it: a\n     * user's insert or edit that names this column has it stripped (measured\n     * on 17.7.0 for `approved`, `pending` and `rejected` alike, #2067).\n     *\n     * \u26D4 NOT a second boolean beside `is_active`, which REQ-0003 rules out by\n     * name. `is_active` answers \"is this account live at all\"; this answers\n     * \"has the record been signed off\", and collapsing them would make\n     * deactivating an account indistinguishable from rejecting one.\n     *\n     * \u26A0\uFE0F Ships with NO default, and that is what keeps the gate armed (#2067).\n     * A new account is born blank, `account_approval` starts on the blank, and\n     * its approval node opens the request; the node's `approvalStatusField`\n     * mirror then writes `pending` (plugin-approvals `openNodeRequest`) before\n     * the create returns; only the create's own response body still shows the\n     * blank row it inserted. So with approvals in the composition REQ-0003\n     * acceptance 4 holds in as many words (\"A newly created account sits in a\n     * pending state, appears in the platform approval inbox \u2026\"), and `pending`\n     * always has a request behind it. Without approvals (a plan or edition\n     * that omits the capability) nothing opens a request, so nothing writes\n     * `pending`: the account stays blank and editable instead of reading\n     * \"locked for approval\" forever, which is what a shipped `pending` default\n     * did, since the console derives its lock from this column's value.\n     *\n     * \u26D4 Do not restore `defaultValue: 'pending'`, nor an option-level\n     * `default: true` on Pending (the form would preselect it). An install\n     * that wants no account sign-off ADDS `defaultValue: 'approved'`; the\n     * flow's start condition is then false for every record and the gate is\n     * off, switchable and inert. That is the same kind of off switch\n     * `crm_lead.conversion_approval_status` records, and \u26D4 NOT the flow's\n     * `status`, for the reasons measured in `lead-conversion-approval.flow.ts`.\n     *\n     * \u26D4 There is deliberately no `not_required` value. Blank already says\n     * \"no request has been opened\", and `approved` already spells \"nothing to\n     * decide\".\n     */\n    approval_status: Field.select({\n      label: 'Approval Status',\n      group: 'ownership',\n      readonly: true,\n      trackHistory: true,\n      options: [\n        { label: 'Pending', value: 'pending', color: '#FFA500' },\n        { label: 'Approved', value: 'approved', color: '#00AA00' },\n        { label: 'Rejected', value: 'rejected', color: '#FF0000' },\n      ],\n    }),\n\n    // Brand color (new field type)\n    brand_color: Field.color({\n      label: 'Brand Color',\n      group: 'branding',\n    }),\n\n    // Company logo (uploaded image). `accept` / `maxSize` are server-enforced\n    // from @objectstack 17 \u2014 see the note on `crm_product.image`.\n    logo: Field.image({\n      label: 'Company Logo',\n      group: 'branding',\n      accept: ['image/png', 'image/jpeg', 'image/svg+xml', 'image/webp'],\n      maxSize: 2 * 1024 * 1024,\n    }),\n\n    // Date field\n    //\n    // \u26D4 NOT `readonly`, and it must not become readonly. This is the signal\n    // `at_risk_accounts` and `customer_churn_signals` are built on, and it is\n    // written by ONE path: another object's hook calling\n    // `api.object('crm_account').update({ last_activity_date }, \u2026)`.\n    //\n    // \u26A0\uFE0F Platform constraint: `stripReadonlyFields` deletes a readonly key from\n    // any payload whose CALLER supplied it, for every context that is not\n    // `isSystem` \u2014 and a hook's `ctx.api` is a `ScopedContext` over the ACTING\n    // USER's execution context, not a system one. So a readonly field a hook\n    // writes is silently dropped: the engine logs `Field '\u2026' is read-only \u2014\n    // ignoring incoming change` and the column stays null forever.\n    //\n    // \u26D4 `crm_campaign_member.added_date` was cited here as a twin and is NOT\n    // one \u2014 it was ruled `readonly: true` in #1667 precisely because its\n    // writers are INSERTs, which the strip never reaches. THIS field is an\n    // UPDATE through a hook's `ctx.api`, which is the one shape that cannot be\n    // `readonly`. Note the rule\n    // is about the CONTEXT, not about hooks or flows as such \u2014 a hook stamping\n    // its own `ctx.input.data` survives, and a flow survives when its `runAs`\n    // is `'system'` (measured: `test/readonly-write-semantics.test.ts`, #1429;\n    // `crm_case.is_sla_violated` is cited elsewhere as a twin of this field\n    // and is NOT one \u2014 its writer is a system flow). This field stays out of\n    // every form section instead, which is the protection that actually\n    // holds. `test/activity-recency.test.ts` proves\n    // the write lands \u2014 and fails if the flag comes back.\n    last_activity_date: Field.date({\n      label: 'Last Activity Date',\n      group: 'system',\n    }),\n\n    // \u2500\u2500\u2500 Customer Success / Account Health \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n    tier: Field.select({\n      label: 'Customer Tier',\n      group: 'ownership',\n      options: [\n        { label: 'Strategic',  value: 'strategic',  color: '#7C3AED' },\n        { label: 'Enterprise', value: 'enterprise', color: '#4169E1' },\n        { label: 'Mid-Market', value: 'mid_market', color: '#00AA00' },\n        { label: 'SMB',        value: 'smb',        color: '#FFA500', default: true },\n      ],\n    }),\n\n    segment: Field.select({\n      label: 'Segment',\n      group: 'ownership',\n      options: [\n        { label: 'Net New',    value: 'net_new' },\n        { label: 'Growth',     value: 'growth' },\n        { label: 'At Risk',    value: 'at_risk' },\n        { label: 'Stable',     value: 'stable' },\n      ],\n    }),\n\n    health_score: Field.select({\n      label: 'Health Score',\n      group: 'ownership',\n      description: 'CSM-maintained health indicator',\n      options: [\n        { label: 'Healthy',    value: 'healthy',    color: '#00AA00' },\n        { label: 'Watching',   value: 'watching',   color: '#FFA500' },\n        { label: 'At Risk',    value: 'at_risk',    color: '#FF4500' },\n        { label: 'Churning',   value: 'churning',   color: '#FF0000' },\n      ],\n    }),\n\n    // \u26D4 No account-level renewal model here, on purpose. Renewal is a\n    // CONTRACT-level process with exactly one home \u2014 `crm_contract.end_date` +\n    // `renewal_notice_days`, swept daily by `src/revenue/flows/contract-renewal.flow.ts`,\n    // which books the task and notifies the CONTRACT owner; the user-facing\n    // queue is that object's `renewal_calendar` view. A `renewal_owner` /\n    // `next_renewal_date` pair here would be declared and inert, telling an\n    // admin a renewal reaches the CSM they named when nothing would. If an\n    // account-level renewal owner is ever wanted, it is a change to that flow\n    // plus a real writer for the date \u2014 not a second pair of fields.\n  },\n  \n  // Database indexes for performance\n  //\n  // \u26A0\uFE0F No `{ fields: ['name'], unique: true }` here. Account-name uniqueness is\n  // declared on the `name` field itself, which the framework builds as the\n  // tenant composite `(organization_id, name)`. Declaring the single-column\n  // index too makes the platform-wide constraint win and leaves the per-tenant\n  // one unreachable (framework#3991 `unique/double-declaration`) \u2014 the same\n  // trap `crm_contact`, `crm_lead` and `crm_product` document. Two\n  // organizations must be able to each have their own \"Acme Corp\".\n  indexes: [\n    { fields: ['owner_id'] },\n    { fields: ['type', 'is_active'] },\n    // The territory sharing rules filter on this column, so it is read on every\n    // account query a territory recipient makes. `billing_country` carries no\n    // index of its own: nothing filters on it \u2014 it is displayed, and classified\n    // into this column by the hook.\n    { fields: ['territory'] },\n    // Lead conversion filters on this column on every conversion \u2014 the column\n    // exists to replace an unindexed `$regex` scan. Plain index, NOT\n    // `unique: true`, deliberately:\n    //\n    // 1. Per-tenant uniqueness of account names is already declared on the\n    //    `name` field. A unique `name_normalized` would SUBSUME it (equal names\n    //    normalize equally) and force that constraint to be re-decided.\n    // 2. This column is a MATCH key, not a policy. Rejecting a near-duplicate\n    //    name outright is a separate data-quality decision, and this repo has\n    //    already chosen the soft shape for that question once (the hard unique\n    //    on `crm_lead.email` was removed because refusing a repeat enquiry is\n    //    worse than recording it).\n    // 3. \u26A0\uFE0F Measured hazard: `create_index` FAILS on any deployment already\n    //    holding `Acme Corp` and `ACME  Corp` separately, so a unique index\n    //    could not be an upgrade step without a merge pass first. That hazard\n    //    is bounded today ONLY because this repo's deployment shape is fresh\n    //    installs \u2014 see docs/MAINTENANCE.md \u00A73.3. The conclusion is conditional\n    //    on that premise, not universal.\n    //\n    // Consequence, recorded rather than hidden: two accounts CAN still hold the\n    // same normalized name if something outside the flow creates them, and\n    // `get_record` has no `sort` option, so the conversion would reuse an\n    // arbitrary one. Reusing one of N is still better than creating the N+1th.\n    { fields: ['name_normalized'] },\n    // `searchableFields` carries `registration_number`, and the note at the top\n    // of this file records why those must be real, indexed columns.\n    { fields: ['registration_number'] },\n  ],\n  \n  // API surface + capabilities. `files` and `feeds` are live and enforced (see\n  // the canonical note in `src/sales/objects/index.ts`). Field history lives on\n  // individual `Field.trackHistory` (ADR-0052); global search uses\n  // `searchableFields` / per-field `searchable`.\n  enable: {\n    apiEnabled: true,       // Expose via REST/GraphQL\n    apiMethods: ['get', 'list', 'create', 'update', 'delete'], // Whitelist allowed API operations\n    // Contracts, org charts and RFPs live on the account record. Opt-in (spec\n    // default false); attach/download/delete authority is the parent record's\n    // own, so this adds a surface, not a grant.\n    files: true,\n  },\n  \n  // \u26A0\uFE0F No `workflows[]` here, and none is possible: object `workflows[]` were\n  // removed from the platform. Field updates live in this object's `*.hook.ts`;\n  // scheduled status flips and notifications live in `src/*/flows/*.flow.ts`.\n});\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/sales/objects/_picklists.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/sales/objects\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/sales/objects/_picklists.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport type { SelectOption } from '@objectstack/spec/data';\n\n/**\n * Canonical picklist value sets shared across objects, flows, and actions.\n *\n * Several fields carry the same business vocabulary on more than one object\n * (`lead_source` on Lead/Contact/Opportunity, `industry` on Lead/Account,\n * `salutation` on Lead/Contact, `payment_terms` on Quote/Contract), and a few\n * flows/actions re-declare an object's own options inline (Task `type` in the\n * schedule_followup screen, Opportunity `stage` in mass_update_stage). Each\n * copy drifted independently (#490): the lead_conversion flow copies\n * `leadRecord.industry` / `leadRecord.lead_source` verbatim onto the created\n * Account/Opportunity, so any Lead-only value (`logistics`, `webinar`, \u2026)\n * became an illegal enum value on the target object.\n *\n * Declaring the set ONCE here and spreading it into every declaration keeps\n * the vocabularies identical by construction. Cross-object copies (flows,\n * conversion mappings) are then always legal.\n *\n * NOTE: spread (`[...X]`) at every use site so each ObjectSchema gets its own\n * array instance \u2014 schemas must not alias one another's metadata.\n */\n\n/** Salutation \u2014 Lead + Contact. Superset (incl. `prof`, formerly Contact-only). */\nexport const SALUTATION_OPTIONS: SelectOption[] = [\n  { label: 'Mr.', value: 'mr' },\n  { label: 'Ms.', value: 'ms' },\n  { label: 'Mrs.', value: 'mrs' },\n  { label: 'Dr.', value: 'dr' },\n  { label: 'Prof.', value: 'prof' },\n];\n\n/**\n * Industry \u2014 Lead + Account. Superset (formerly 15 on Lead, 6 on Account);\n * lead_conversion copies `leadRecord.industry` onto the created Account, so\n * Account MUST accept every Lead value.\n */\nexport const INDUSTRY_OPTIONS: SelectOption[] = [\n  { label: 'Technology',          value: 'technology' },\n  { label: 'Software / SaaS',     value: 'software' },\n  { label: 'Finance',             value: 'finance' },\n  { label: 'Healthcare',          value: 'healthcare' },\n  { label: 'Retail',              value: 'retail' },\n  { label: 'Manufacturing',       value: 'manufacturing' },\n  { label: 'Education',           value: 'education' },\n  { label: 'Real Estate',         value: 'real_estate' },\n  { label: 'Media & Entertainment', value: 'media' },\n  { label: 'Logistics',           value: 'logistics' },\n  { label: 'Hospitality',         value: 'hospitality' },\n  { label: 'Energy & Utilities',  value: 'energy' },\n  { label: 'Government',          value: 'government' },\n  { label: 'Non-profit',          value: 'nonprofit' },\n  { label: 'Other',               value: 'other' },\n];\n\n/**\n * Lead Source \u2014 Lead + Contact + Opportunity. Superset (formerly 12/5/6);\n * lead_conversion copies `leadRecord.lead_source` onto the created\n * Opportunity, so Opportunity MUST accept every Lead value.\n */\nexport const LEAD_SOURCE_OPTIONS: SelectOption[] = [\n  { label: 'Web',             value: 'web' },\n  { label: 'Referral',        value: 'referral' },\n  { label: 'Event / Trade Show', value: 'event' },\n  { label: 'Webinar',         value: 'webinar' },\n  { label: 'Partner',         value: 'partner' },\n  { label: 'Advertisement',   value: 'advertisement' },\n  { label: 'Paid Search',     value: 'paid_search' },\n  { label: 'Social Media',    value: 'social' },\n  { label: 'Content / Blog',  value: 'content' },\n  { label: 'Cold Call',       value: 'cold_call' },\n  { label: 'Email Campaign',  value: 'email_campaign' },\n  { label: 'Other',           value: 'other' },\n];\n\n/**\n * Payment Terms \u2014 Quote + Contract. Superset (incl. `due_on_receipt`,\n * formerly Quote-only): an accepted quote's terms carry over to the contract,\n * so the contract vocabulary must cover every quote value.\n *\n * The carry-over is `quote_accepted_contract_draft` in `src/revenue/objects/quote.hook.ts`, named\n * here because this rationale spent its first months unenforced (#873): the\n * hook drafted the contract without `payment_terms`, so every accepted quote\n * produced a contract on the `net_30` option default below regardless of what\n * was negotiated \u2014 a shared vocabulary justified by a copy that did not exist.\n * A comment that names its enforcer can be checked; this one could not be.\n */\nexport const PAYMENT_TERMS_OPTIONS: SelectOption[] = [\n  { label: 'Net 15', value: 'net_15' },\n  { label: 'Net 30', value: 'net_30', default: true },\n  { label: 'Net 60', value: 'net_60' },\n  { label: 'Net 90', value: 'net_90' },\n  { label: 'Due on Receipt', value: 'due_on_receipt' },\n];\n\n/**\n * Task Type \u2014 crm_task.type, also re-rendered as the `activityType` select in\n * the schedule_followup screen flow (which had drifted to a 5-value copy\n * missing `other`).\n */\nexport const TASK_TYPE_OPTIONS: SelectOption[] = [\n  { label: 'Call', value: 'call' },\n  { label: 'Email', value: 'email' },\n  { label: 'Meeting', value: 'meeting' },\n  { label: 'Follow-up', value: 'follow_up' },\n  { label: 'Demo', value: 'demo' },\n  { label: 'Other', value: 'other' },\n];\n\n/**\n * Opportunity Stage \u2014 crm_opportunity.stage, also re-rendered as the `stage`\n * param of the mass_update_stage action. Colors/default only matter on the\n * object schema; use {@link plainOptions} where a screen/param select wants\n * bare label/value pairs.\n */\nexport const OPPORTUNITY_STAGE_OPTIONS: SelectOption[] = [\n  { label: 'Prospecting', value: 'prospecting', color: '#808080', default: true },\n  { label: 'Qualification', value: 'qualification', color: '#FFA500' },\n  { label: 'Needs Analysis', value: 'needs_analysis', color: '#FFD700' },\n  { label: 'Proposal', value: 'proposal', color: '#4169E1' },\n  { label: 'Negotiation', value: 'negotiation', color: '#9370DB' },\n  { label: 'Closed Won', value: 'closed_won', color: '#00AA00' },\n  { label: 'Closed Lost', value: 'closed_lost', color: '#FF0000' },\n];\n\n/**\n * Event Type \u2014 crm_event.type, and the `kind` discriminator the per-object\n * activity actions stamp on the `crm_event` row they insert (#592).\n *\n * Distinct from {@link TASK_TYPE_OPTIONS} on purpose: a Task is something a rep\n * still owes someone, an Event is an interaction that occupies a slot on the\n * calendar. `email` is therefore absent here (an email is not a meeting slot;\n * it stays a `sys_email` + `sys_activity` pair) and `webinar` / `onsite_visit`\n * are present, because those are the meeting shapes a rep books.\n */\nexport const EVENT_TYPE_OPTIONS: SelectOption[] = [\n  { label: 'Meeting',      value: 'meeting',       color: '#4169E1', default: true },\n  { label: 'Call',         value: 'call',          color: '#00AA00' },\n  { label: 'Demo',         value: 'demo',          color: '#9370DB' },\n  { label: 'Webinar',      value: 'webinar',       color: '#FFA500' },\n  { label: 'Onsite Visit', value: 'onsite_visit',  color: '#0EA5E9' },\n  { label: 'Other',        value: 'other',         color: '#808080' },\n];\n\n/**\n * Event Status \u2014 crm_event.status.\n *\n * The `planned` \u2192 `held` transition is what separates \"a meeting is booked\"\n * from \"an interaction happened\", and only the second one bumps\n * `crm_account.last_activity_date` (see `event.hook.ts`). Without that split a\n * meeting booked for next quarter would reset the churn clock today.\n */\nexport const EVENT_STATUS_OPTIONS: SelectOption[] = [\n  { label: 'Planned',   value: 'planned',   color: '#4169E1', default: true },\n  { label: 'Held',      value: 'held',      color: '#00AA00' },\n  { label: 'Cancelled', value: 'cancelled', color: '#999999' },\n  { label: 'No Show',   value: 'no_show',   color: '#FF4500' },\n];\n\n/**\n * Attendee Response \u2014 crm_event_attendee.response.\n *\n * The reason attendees are RECORDS rather than a JSON string on the activity\n * (#592 acceptance): a per-attendee response only exists if the attendee does.\n */\nexport const ATTENDEE_RESPONSE_OPTIONS: SelectOption[] = [\n  { label: 'No Response', value: 'no_response', color: '#808080', default: true },\n  { label: 'Accepted',    value: 'accepted',    color: '#00AA00' },\n  { label: 'Declined',    value: 'declined',    color: '#FF0000' },\n  { label: 'Tentative',   value: 'tentative',   color: '#FFA500' },\n];\n\n/**\n * Polymorphic \"Related To\" type \u2014 crm_task.related_to_type and\n * crm_event.related_to_type.\n *\n * Both activity objects carry the same five `related_to_*` lookups, and both\n * hooks bubble recency through the same `related_to_type \u2192 lookup field` map.\n * Declared once so the vocabulary of the discriminator cannot drift from the\n * set of lookups that back it \u2014 a drift that reads as \"the bubble silently\n * stopped firing for one object type\".\n */\nexport const RELATED_TO_TYPE_OPTIONS: SelectOption[] = [\n  { label: 'Account',     value: 'crm_account' },\n  { label: 'Contact',     value: 'crm_contact' },\n  { label: 'Opportunity', value: 'crm_opportunity' },\n  { label: 'Lead',        value: 'crm_lead' },\n  { label: 'Case',        value: 'crm_case' },\n];\n\n/**\n * Duplicate Of \u2014 crm_lead.duplicate_of_type, the discriminator half of the\n * `duplicate_of_lead` / `duplicate_of_contact` pair (#598).\n *\n * Two vocabularies, deliberately, and the split is the enforcement:\n *\n *   - {@link DUPLICATE_OF_TYPE_AUTHORABLE_OPTIONS} is what a human may pick. Each\n *     value names an object, and `lead.object.ts` pairs it with that object's\n *     lookup through `requiredWhen`, so choosing one demands a record.\n *   - {@link DUPLICATE_OF_TYPE_OPTIONS} is what the COLUMN may hold. It is the\n *     authorable set plus {@link DUPLICATE_OF_TYPE_ERASED}, a tombstone no\n *     author writes.\n *\n * The form spreads the authorable set (`src/sales/views/lead.view.ts`) and the object\n * spreads the full one, so the tombstone is unpickable BY CONSTRUCTION rather\n * than by a hand-maintained exclusion list: a fourth authorable object type\n * added below reaches the form automatically, and the tombstone never does.\n */\nexport const DUPLICATE_OF_TYPE_AUTHORABLE_OPTIONS: SelectOption[] = [\n  { label: 'Lead',    value: 'crm_lead' },\n  { label: 'Contact', value: 'crm_contact' },\n];\n\n/**\n * The tombstone (#1164): \"this lead was confirmed a duplicate of a record that\n * has since been erased.\"\n *\n * It exists because on the record \u2014 which is all a validation can see, being\n * evaluated against `{...previous, ...data}` \u2014 \"the pointer was erased\" and\n * \"this claim never named anyone\" were the SAME state. Every way of teaching a\n * rule to tolerate the first also admitted the second, which is why the erasure\n * path could not be cleared by relaxing anything (measured in full on #1164).\n * Giving the two states different values makes them different facts, and then\n * no rule has to be loosened at all: the `requiredWhen` pairing fires only on\n * `crm_lead` / `crm_contact` so it never sees this value, and\n * `duplicate_disqualification_requires_survivor` asks for a NON-BLANK type,\n * which this is.\n *\n * Deliberately not an object name: it is the answer to \"which object holds the\n * survivor\" when the answer is \"none, any more\".\n *\n * \u26A0\uFE0F `lead_duplicate_check` (`lead.hook.ts`, job 1c) is the ONLY writer, and it\n * spells the value as an inline literal \u2014 L2 hook bodies run body-only in the\n * QuickJS sandbox, so a module constant resolves at authoring time and arrives\n * as `undefined` (same constraint as the SLA matrix in `case.hook.ts`). The two\n * spellings are pinned together, and the writer pinned to that one site, by\n * `test/lead-duplicate-management.test.ts`.\n */\nexport const DUPLICATE_OF_TYPE_ERASED = 'erased';\n\n/** The full column vocabulary: what an author may pick, plus the tombstone. */\nexport const DUPLICATE_OF_TYPE_OPTIONS: SelectOption[] = [\n  ...DUPLICATE_OF_TYPE_AUTHORABLE_OPTIONS,\n  { label: 'Erased Record', value: DUPLICATE_OF_TYPE_ERASED },\n];\n\n/** Project a canonical set down to bare `{ label, value }` pairs for flow\n * screens and action params, which don't understand color/default keys. */\nexport const plainOptions = (options: SelectOption[]): { label: string; value: string }[] =>\n  options.map(({ label, value }) => ({ label, value }));\n\n/**\n * Need Type \u2014 `crm_lead.need_type`, the answer to \"what is this prospect\n * asking for\" (REQ-0005 step 6, \u9700\u6C42\u7C7B\u578B).\n *\n * A GENERIC STARTER SET, and that is the disposition rather than an apology\n * for a short list: REQ-0005 rules the *slot* standard and the *values*\n * configuration \u2014 \"a customer's own demand taxonomy is overlay configuration\n * the same way `industry` values are\". So these seven are the vocabulary a\n * fresh install routes and reports on until an overlay replaces them, and\n * replacing them is a one-site edit because the set is declared here.\n *\n * \u26A0\uFE0F NOT the same axis as `crm_opportunity.type`, and \u26D4 never folded into it.\n * That field answers \"is this new business, an upgrade, a renewal or an\n * expansion\" \u2014 the customer RELATIONSHIP the deal changes. This one answers\n * what the buyer wants delivered, which is orthogonal: a renewal of a support\n * contract and a renewal of a consulting engagement differ here and not there.\n * They are deliberately not shared, so \u26D4 do not spread this set onto\n * `crm_opportunity` to make a conversion mapping possible.\n *\n * SINGLE-valued, for the reason `crm_contact.buying_function` records: a\n * grouped list view answers with one server-side aggregate per raw stored\n * value, so a `multiple: true` column groups by the COMBINATION and loses the\n * groupability REQ-0005 acceptance 1 asks for.\n */\nexport const LEAD_NEED_TYPE_OPTIONS: SelectOption[] = [\n  { label: 'New Implementation',   value: 'new_implementation' },\n  { label: 'Expansion',            value: 'expansion' },\n  { label: 'Replacement',          value: 'replacement' },\n  { label: 'Renewal',              value: 'renewal' },\n  { label: 'Consulting',           value: 'consulting' },\n  { label: 'Support & Maintenance', value: 'support' },\n  { label: 'Other',                value: 'other' },\n];\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/sales/objects/_territory.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/sales/objects\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/sales/objects/_territory.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport type { SelectOption } from '@objectstack/spec/data';\n\n/**\n * Territory \u2014 the ONE place the country-to-territory mapping is authored.\n *\n * \u26D4 Territory is a declared `select` on `crm_account`, derived from the billing\n * country by `account_protection`, and the sharing rules compare\n * `record.territory` against a declared value. A country string is never\n * compared again. Matching free text inside a CEL condition fails four ways,\n * all of them silent: an account whose country reads `United States` rather\n * than `US` lands in NO territory with nothing errored; adding a country means\n * editing a CEL string AND three localised tables with nothing to fail if you\n * edit fewer than all four; a wrong code (`UK` for `GB`) cannot be corrected\n * without evicting every account already typed that way; and free text has no\n * enumerable DOMAIN, so no authoring surface, import mapping or generated seed\n * can be checked against it.\n *\n * ### The three authored tables, and everything derived from them\n *\n * {@link TERRITORY_OPTIONS} (the picklist), {@link TERRITORY_COUNTRIES} (which\n * countries a territory covers) and {@link COUNTRY_ALIASES} (how else a country\n * may be spelled) are AUTHORED. {@link COUNTRY_TERRITORY} and\n * {@link territoryFor} are DERIVED from them, and so are the sharing rule\n * conditions, the account form's picklist and the documentation tables \u2014 see\n * `test/territory-single-source.test.ts`, which pins every derivation.\n *\n * ### \u26A0\uFE0F Why `account.hook.ts` still carries a copy of this map\n *\n * It has to. A hook handler is lowered to a metadata-only `body.source` and\n * evaluated inside QuickJS with NO module scope: a reference to anything\n * exported here is not a closure at runtime, it is a `ReferenceError`.\n * `extractHookBody` rejects such a handler outright\n * (`detectFreeIdentifiers`), and `test/action-sandbox.test.ts` fails the\n * build's own lowering pass for every registered hook. So the derivation cannot\n * import this module \u2014 the table has to be inline in the handler.\n *\n * `test/territory-single-source.test.ts` closes that gap from both directions:\n * it parses the inline table out of the LOWERED body source and asserts deep\n * equality with {@link COUNTRY_TERRITORY} (so a country added to either side\n * alone is red), and it runs the real body in the real sandbox over every\n * declared spelling and asserts the territory it produces. The map is therefore\n * authored once even though it is stored twice.\n *\n * ### Scope of the country list\n *\n * This is a SPELLING table for the countries the two staffed territories cover,\n * not a world country list. The value domain is `na` / `emea` / `other`;\n * everything else \u2014 `SG`, `JP`, an empty address \u2014 is `other`, explicitly.\n */\n\n/** The declared territory domain. `other` is a stated fact, never a blank. */\nexport type Territory = 'na' | 'emea' | 'other';\n\n/**\n * The stored values, named. Every other declaration in the repo that needs one\n * spells it through here \u2014 including the sharing rule conditions, where `P`\n * quotes the interpolated value (`record.territory == \"na\"`), so a rename of a\n * territory value cannot be applied to the picklist and missed in the rules.\n */\nexport const TERRITORY: Record<'NA' | 'EMEA' | 'OTHER', Territory> = {\n  NA: 'na',\n  EMEA: 'emea',\n  OTHER: 'other',\n};\n\n/**\n * The account picklist. `other` is deliberately a VALUE and not an empty\n * string: \"this account belongs to no territory\" and \"nobody filled this in\"\n * are different facts, and free text could not tell them apart (#639).\n */\nexport const TERRITORY_OPTIONS: SelectOption[] = [\n  { label: 'North America', value: TERRITORY.NA, color: '#0070D2' },\n  { label: 'EMEA', value: TERRITORY.EMEA, color: '#7C3AED' },\n  { label: 'Other', value: TERRITORY.OTHER, color: '#999999' },\n];\n\n/** The territory every unmapped country falls into. */\nexport const TERRITORY_FALLBACK: Territory = TERRITORY.OTHER;\n\n/**\n * Which countries each staffed territory covers, by ISO 3166-1 alpha-2 code.\n *\n * `other` is absent on purpose \u2014 it is the FALLBACK, reached by every country\n * not named here, so listing countries under it would be a second way to say\n * the same thing. The documentation tables render this record plus one row\n * stating the fallback.\n */\nexport const TERRITORY_COUNTRIES: Record<Exclude<Territory, 'other'>, readonly string[]> = {\n  na: ['US', 'CA', 'MX'],\n  emea: ['GB', 'DE', 'FR', 'IT', 'ES'],\n};\n\n/**\n * Accepted alternative spellings, mapped to the canonical code.\n *\n * Authored in DISPLAY form (`United States`, not `UNITED STATES`) because this\n * is what the documentation tables render \u2014 {@link COUNTRY_TERRITORY} applies\n * {@link normalizeCountry} when it flattens them, so the lookup is\n * case-insensitive without the authored table having to be shouted.\n *\n * `UK -> GB` is deliberate: `UK` is not the ISO 3166-1 alpha-2 code for the\n * United Kingdom, but the stock London account and every customer record typed\n * the same way must keep landing in `emea`. Because the rules no longer compare\n * a country at all, `GB` can be canonical AND `UK` can keep working.\n *\n * English names are here because they are what a CSV import, a generated seed\n * or a person typing into the address form actually produces. Native-language\n * spellings are NOT: they are unbounded, and the failure they would prevent is\n * now visible (`other`) rather than silent.\n */\nexport const COUNTRY_ALIASES: Record<string, string> = {\n  'United States': 'US',\n  'United States of America': 'US',\n  USA: 'US',\n  Canada: 'CA',\n  Mexico: 'MX',\n  UK: 'GB',\n  'United Kingdom': 'GB',\n  'Great Britain': 'GB',\n  Germany: 'DE',\n  France: 'FR',\n  Italy: 'IT',\n  Spain: 'ES',\n};\n\n/**\n * Every accepted spelling to its territory \u2014 the flattened form the hook body\n * carries inline and `test/territory-single-source.test.ts` pins it against.\n *\n * Derived, never authored: add a country to {@link TERRITORY_COUNTRIES} or a\n * spelling to {@link COUNTRY_ALIASES} and it appears here, in the docs tables\n * and (once the hook's inline copy is updated, which the pin test forces) in\n * the derivation.\n */\nexport const COUNTRY_TERRITORY: Record<string, Territory> = (() => {\n  const map: Record<string, Territory> = {};\n  for (const [territory, countries] of Object.entries(TERRITORY_COUNTRIES)) {\n    for (const code of countries) map[code] = territory as Territory;\n  }\n  for (const [alias, code] of Object.entries(COUNTRY_ALIASES)) {\n    const territory = map[code];\n    if (!territory) {\n      // A spelling pointing at a country no territory covers would resolve to\n      // `other` and read as deliberate. Failing at module load makes it a\n      // build-time error instead of a wrong answer at runtime.\n      throw new Error(`COUNTRY_ALIASES: \"${alias}\" points at \"${code}\", which no territory covers`);\n    }\n    const key = normalizeCountry(alias);\n    if (map[key] && map[key] !== territory) {\n      // Two spellings that normalise to the same key and disagree: last write\n      // would win, silently, and the loser's territory would just be wrong.\n      throw new Error(`COUNTRY_ALIASES: \"${alias}\" collides with an entry mapped to \"${map[key]}\"`);\n    }\n    map[key] = territory;\n  }\n  return map;\n})();\n\n/**\n * The one normalisation rule: trim, collapse internal whitespace, upper-case.\n *\n * `crm_account.billing_country` stores exactly this form, and every key above\n * is written in it, so the lookup is a plain property read. `de `, ` DE` and\n * `United  States` are all handled here rather than by a tolerant lookup \u2014\n * one rule, applied once, instead of a set of fallbacks at each reader.\n */\nexport function normalizeCountry(value: unknown): string {\n  return typeof value === 'string' ? value.trim().replace(/\\s+/g, ' ').toUpperCase() : '';\n}\n\n/**\n * The territory a country string belongs to. Total: every input has an answer,\n * and an unrecognised one is `other` rather than blank.\n */\nexport function territoryFor(value: unknown): Territory {\n  return COUNTRY_TERRITORY[normalizeCountry(value)] ?? TERRITORY_FALLBACK;\n}\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/sales/objects/contact.object.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/sales/objects\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/sales/objects/contact.object.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport { ObjectSchema, Field } from '@objectstack/spec/data';\nimport { F } from '@objectstack/spec';\nimport { SALUTATION_OPTIONS, LEAD_SOURCE_OPTIONS } from './_picklists';\n\nexport const Contact = ObjectSchema.create({\n  name: 'crm_contact',\n  label: 'Contact',\n  pluralLabel: 'Contacts',\n  icon: 'user',\n  description: 'People associated with accounts',\n\n  // ADR-0090 D1/D7: OWD is an authored decision. Master-detail child of crm_account \u2014 inherits the account's sharing.\n  sharingModel: 'controlled_by_parent',\n  \n  fieldGroups: [\n    { key: 'identity',        label: 'Identity',             icon: 'user' },\n    { key: 'account_info',    label: 'Account & Title',      icon: 'briefcase' },\n    { key: 'buying_centre',   label: 'Buying Centre',        icon: 'users' },\n    { key: 'contact_info',    label: 'Contact Information',  icon: 'phone' },\n    { key: 'mailing_address', label: 'Mailing Address',      icon: 'map-pin', collapse: 'collapsed' },\n    { key: 'additional',      label: 'Additional Info',      icon: 'info', collapse: 'collapsed' },\n    { key: 'preferences',     label: 'Communication Preferences', icon: 'bell-off', collapse: 'collapsed' },\n  ],\n\n  fields: {\n    // Platform ownership anchor \u2014 canonical note in `account.object.ts` (#548).\n    owner_id: Field.lookup('sys_user', {\n      label: 'Contact Owner',\n      group: 'account_info',\n      system: true,\n      readonly: false,\n      trackHistory: true,\n    }),\n\n    // Name fields\n    salutation: Field.select({\n      label: 'Salutation',\n      group: 'identity',\n      // Canonical set shared with Lead (#490) \u2014 see _picklists.ts.\n      options: [...SALUTATION_OPTIONS],\n    }),\n    first_name: Field.text({\n      label: 'First Name',\n      required: true,\n      storage: { notNull: true },\n      searchable: true,\n      group: 'identity',\n    }),\n    last_name: Field.text({\n      label: 'Last Name',\n      required: true,\n      storage: { notNull: true },\n      searchable: true,\n      group: 'identity',\n    }),\n\n    // Formula field - Full name\n    // `salutation` is a picklist, so the formula sees the raw VALUE (`ms`, `dr`),\n    // not the label \u2014 names rendered as \"ms Emily Davis\" in lists and details\n    // (#461). The formula language has no proper-case or option-label lookup, and\n    // hardcoding \"Ms.\" would defeat translation, so the name is built from the\n    // name fields alone; salutation stays its own (translated) field.\n    full_name: Field.formula({\n      label: 'Full Name',\n      expression: F`joinNonEmpty([record.first_name, record.last_name], ' ')`,\n      group: 'identity',\n    }),\n\n    // Avatar field. `accept` / `maxSize` are server-enforced from\n    // @objectstack 17 \u2014 see the note on `crm_product.image`.\n    avatar: Field.avatar({\n      label: 'Profile Picture',\n      group: 'identity',\n      accept: ['image/png', 'image/jpeg', 'image/webp'],\n      maxSize: 2 * 1024 * 1024,\n    }),\n\n    // Relationship: Link to Account (Master-Detail)\n    crm_account: Field.masterDetail('crm_account', {\n      label: 'Account',\n      required: true,\n      storage: { notNull: true },\n      deleteBehavior: 'cascade',  // Delete contacts when account is deleted\n      group: 'account_info',\n    }),\n\n    // Professional Information\n    title: Field.text({\n      label: 'Job Title',\n      group: 'account_info',\n    }),\n\n    department: Field.select({\n      label: 'Department',\n      group: 'account_info',\n      options: [\n        { label: 'Executive', value: 'executive' },\n        { label: 'Sales', value: 'sales' },\n        { label: 'Marketing', value: 'marketing' },\n        { label: 'Engineering', value: 'engineering' },\n        { label: 'Support', value: 'support' },\n        { label: 'Finance', value: 'finance' },\n        { label: 'Human Resources', value: 'hr' },\n        { label: 'Operations', value: 'operations' },\n      ]\n    }),\n\n    // \u2500\u2500 Buying centre (REQ-0004) \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n    //\n    // The three attributes that turn an account's contact list from a\n    // DIRECTORY into a MAP: what this person does in the purchase decision,\n    // where they stand on us, and how strong our relationship with them is.\n    // `title` above is the employer's job title and `is_primary` below is a\n    // one-bit answer to \"who do we call\" \u2014 neither of them is this fact.\n    //\n    // \u26D4 Read by people and by reporting, never by a gate. No hook, no flow\n    // and no validation is authored against any of the three, none is\n    // `required`, and none carries an option `default`: a contact with all\n    // three blank saves exactly as it did before this group existed\n    // (REQ-0004 acceptance 4). They are sales intelligence, and AGENTS.md\n    // metadata semantics rule 8 is what keeps a machine signal from refusing\n    // a write.\n    // \u26A0\uFE0F `buying_function`, not `buying_role` \u2014 and 'Buying Function', not\n    // 'Buying Role'. `security-role-word` (an author-time rule, ADR-0090 D3)\n    // refuses the word `role` on BOTH, measured on this branch as two\n    // successive `pnpm validate` exit-1 runs: first the field name, then the\n    // label, because \"admins must meet ONE vocabulary\" and `role` is the\n    // platform's security vocabulary (permission_set / position /\n    // business_unit). Its own remedy prescribes the replacement used here \u2014\n    // \"a domain word (e.g. 'function', 'duty')\".\n    //\n    // The rule's surface is the ENGLISH one it can read: it matches\n    // `/\\brole(s)?\\b/i` over object/field/action/permission-set/position/app\n    // declarations and does not reach the locale packs. So the three\n    // non-English packs keep the natural business term for this concept in\n    // their own language (zh-CN \u91C7\u8D2D\u89D2\u8272, es-ES Rol de Compra, ja-JP \u8CFC\u8CB7\u5F79\u5272)\n    // \u2014 same fact, each written the way its reader says it.\n    buying_function: Field.select({\n      label: 'Buying Function',\n      group: 'buying_centre',\n      // SINGLE-valued, and REQ-0004 left that call to the implementing PR.\n      // `multiple: true` would cost the field the property acceptance 2 asks\n      // for: `GroupingConfigSchema` (`@objectstack/spec/ui`, the installed\n      // pin) answers a grouped list with ONE server-side aggregate query, and\n      // its `GroupingFieldSchema.field` says the group header \"carries its\n      // raw stored value\" \u2014 so a multi-valued column groups by the\n      // COMBINATION. `decision_maker` + `user` would become a group of its\n      // own instead of feeding both, which is the opposite of reading an\n      // account as a map. A person who is genuinely two things is recorded as\n      // the role that governs THIS decision; the second one is already\n      // legible from `title` / `department`.\n      //\n      // The six are the generic buying-centre slots every industry reads the\n      // same way \u2014 \u26D4 deliberately not one company's role model.\n      options: [\n        { label: 'Decision Maker',      value: 'decision_maker' },\n        { label: 'Economic Buyer',      value: 'economic_buyer' },\n        { label: 'Technical Evaluator', value: 'technical_evaluator' },\n        { label: 'User',                value: 'user' },\n        { label: 'Influencer',          value: 'influencer' },\n        { label: 'Gatekeeper',          value: 'gatekeeper' },\n      ]\n    }),\n\n    attitude: Field.select({\n      label: 'Attitude to Us',\n      group: 'buying_centre',\n      // ORDERED, most to least favourable \u2014 declaration order IS the order a\n      // picklist and a grouped list present, so the ladder is authored rather\n      // than described. A blank means nobody has formed a view yet, which is\n      // a different fact from `neutral`.\n      options: [\n        { label: 'Champion',   value: 'champion' },\n        { label: 'Supportive', value: 'supportive' },\n        { label: 'Neutral',    value: 'neutral' },\n        { label: 'Skeptical',  value: 'skeptical' },\n        { label: 'Blocker',    value: 'blocker' },\n      ]\n    }),\n\n    relationship_strength: Field.select({\n      label: 'Relationship Strength',\n      group: 'buying_centre',\n      // ORDERED, weakest to strongest. \u26D4 Not a free-text score, and \u26D4 not\n      // derived from `last_contacted_date` below: recency is machine-written\n      // and measures something else \u2014 a weekly call with someone who will not\n      // take our side is not a strong relationship. A blank means unassessed;\n      // `distant` is an assessment that came back weak.\n      options: [\n        { label: 'Distant',              value: 'distant' },\n        { label: 'Acquaintance',         value: 'acquaintance' },\n        { label: 'Working Relationship', value: 'working' },\n        { label: 'Strong',               value: 'strong' },\n        { label: 'Trusted Advisor',      value: 'trusted_advisor' },\n      ]\n    }),\n\n    // No `reports_to`. The org chart was declared and never built: no page\n    // rendered the tree the contact docs promised, no skill read the chain when\n    // summarising an account, and no flow escalated along it. Sharing derives\n    // from the master `crm_account`, never from this lookup.\n\n    // Contact Information\n    email: Field.email({\n      label: 'Email',\n      required: true,\n      storage: { notNull: true },\n      unique: true,\n      group: 'contact_info',\n    }),\n\n    phone: Field.text({\n      label: 'Phone',\n      format: 'phone',\n      group: 'contact_info',\n    }),\n\n    mobile: Field.text({\n      label: 'Mobile',\n      format: 'phone',\n      group: 'contact_info',\n    }),\n\n    // Mailing Address \u2014 one structured `address` value, the same shape as\n    // `crm_account.billing_address` and `crm_lead.address`, because a postal\n    // address is one fact and AGENTS.md's field-type guidance names\n    // `Field.address()` for it (ruling on #1836; it replaced five flat\n    // `mailing_*` text fields, converted by `scripts/backfill-contact-mailing-address.ts`).\n    mailing_address: Field.address({\n      label: 'Mailing Address',\n      group: 'mailing_address',\n    }),\n\n    // Additional Information\n    //\n    // No `birthdate`. Nothing greeted, segmented or reported on it, and an\n    // importable date of birth with no consumer is personal data held for no\n    // stated purpose \u2014 the one field on this object where \"declared but inert\"\n    // also carries a data-protection cost.\n\n    lead_source: Field.select({\n      label: 'Lead Source',\n      group: 'additional',\n      // Canonical set shared with Lead + Opportunity (#490) \u2014 a converted\n      // lead's source must remain representable on the contact.\n      options: [...LEAD_SOURCE_OPTIONS],\n    }),\n\n    description: Field.markdown({\n      label: 'Description',\n      group: 'additional',\n    }),\n\n    // Flags\n    is_primary: Field.boolean({\n      label: 'Primary Contact',\n      defaultValue: false,\n      description: 'Is this the main contact for the account?',\n      group: 'preferences',\n    }),\n\n    do_not_call: Field.boolean({\n      label: 'Do Not Call',\n      defaultValue: false,\n      group: 'preferences',\n    }),\n\n    email_opt_out: Field.boolean({\n      label: 'Email Opt Out',\n      defaultValue: false,\n      group: 'preferences',\n    }),\n\n    // Interaction recency for the PERSON (#592). `crm_account` carries\n    // `last_activity_date` for the company and `crm_lead` carries\n    // `last_contacted_date` for a prospect; the contact \u2014 the record a rep\n    // actually calls and emails \u2014 had neither, so \"when did anyone last speak\n    // to our champion?\" was unanswerable.\n    //\n    // Written by the activity bubble in `event.hook.ts` / `task.hook.ts` and by\n    // `send_email`. Deliberately NOT `readonly`: a readonly field is stripped\n    // from every non-system write whose caller supplied the key (#2948), which\n    // is exactly how the account and lead columns above ended up permanently\n    // null. It is kept off the form sections instead.\n    last_contacted_date: Field.datetime({\n      label: 'Last Contacted',\n      group: 'additional',\n    }),\n  },\n  \n  // Enable features\n  // API surface. History \u2192 Field.trackHistory (ADR-0052).\n  enable: {\n    apiEnabled: true,\n    // #602 \u2014 signed NDAs, business cards, meeting notes attach to the person.\n    // See the canonical capability note in `src/sales/objects/index.ts`.\n    files: true,\n  },\n  \n  // Database indexes for performance\n  //\n  // NOTE: no `{ fields: ['email'], unique: true }` here. Email uniqueness is\n  // declared on the field itself (`unique: true`), which since framework #3696\n  // materializes as the tenant composite `(organization_id, email)` \u2014 unique\n  // WITHIN an organization, which is what a multi-tenant CRM wants (two orgs\n  // may each know john@acme.com). A declared single-column index is taken\n  // verbatim, i.e. platform-wide, so declaring both left the global index\n  // enforcing the old behaviour and the per-tenant constraint unreachable\n  // (framework#3991 `unique/double-declaration`).\n  indexes: [\n    { fields: ['crm_account'] },\n    { fields: ['owner_id'] },\n    { fields: ['last_name', 'first_name'] },\n  ],\n  \n  // Display configuration. ADR-0079 `nameField` names the real field holding\n  // the record title \u2014 here the `full_name` formula field defined above.\n  nameField: 'full_name',\n  // Explicit search targets (ADR-0061). REQUIRED because nameField is a\n  // FORMULA (display_title/full_name): without this, $search auto-defaults to\n  // the formula field, which isn't a real column, so the lookup picker + global\n  // search silently return zero. These are real, indexed columns.\n  searchableFields: ['first_name', 'last_name', 'email'],\n  highlightFields: ['full_name', 'email', 'crm_account', 'phone'],\n  \n  // \u26A0\uFE0F No standalone `type: 'unique'` validation exists on this platform\n  // (ADR-0032 validation union). Email uniqueness is enforced by the\n  // field-level `unique: true` above, scoped per organization.\n\n  // \u26A0\uFE0F No `workflows[]` here, and none is possible: object `workflows[]` were\n  // removed from the platform. Field updates live in this object's `*.hook.ts`;\n  // scheduled status flips and notifications live in `src/*/flows/*.flow.ts`.\n});", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/sales/objects/event.object.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/sales/objects\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/sales/objects/event.object.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport { P } from '@objectstack/spec';\nimport { ObjectSchema, Field } from '@objectstack/spec/data';\nimport {\n  EVENT_STATUS_OPTIONS,\n  EVENT_TYPE_OPTIONS,\n  RELATED_TO_TYPE_OPTIONS,\n} from './_picklists';\n\n/**\n * Event \u2014 a first-class interaction record (#592).\n *\n * # Why this object exists\n *\n * The CRM could not answer *\"what happened with this customer, and when?\"*.\n * `crm_task.type` offered a `meeting` value with no start time, no end time,\n * no location and no attendees, and `log_meeting` stuffed the attendee list\n * into a JSON string inside `sys_activity.metadata` \u2014 a payload no list view\n * can filter, no dataset can group by, and no report can count.\n *\n * `crm_event` is the queryable half of that story: one row per interaction\n * that occupies a slot on someone's calendar, whether it already happened (a\n * logged call) or is booked for next Tuesday (a scheduled meeting).\n *\n * # The Task / Event split\n *\n * `crm_task` stays what it was \u2014 something a rep still *owes* someone, due on\n * a date. `crm_event` is something that *occurs*, between two timestamps, with\n * people in the room. The two objects deliberately do NOT merge: a to-do list\n * sorted by due date and a calendar scaled by duration are different surfaces,\n * and every CRM that collapsed them ended up with a \"duration\" column that is\n * null on 90% of rows.\n *\n * Emails are the third shape and stay out: an email is not a calendar slot, so\n * `send_email` keeps writing `sys_email` + `sys_activity` (it does now also\n * stamp contact recency \u2014 see `contact.actions.ts`).\n *\n * # `status` is what makes the churn signal honest\n *\n * Only a `held` event bumps `crm_account.last_activity_date` /\n * `crm_lead.last_contacted_date` (see `event.hook.ts`). A meeting *booked* for\n * next quarter is not an interaction that happened, and letting it reset the\n * recency clock is precisely how an \"at risk\" report learns to lie.\n */\nexport const Event = ObjectSchema.create({\n  name: 'crm_event',\n  label: 'Event',\n  pluralLabel: 'Events',\n  icon: 'calendar-days',\n  description: 'Meetings, calls and other scheduled interactions with customers',\n\n  // ADR-0090 D1/D7: OWD is an authored decision. Mirrors `crm_task`: an event\n  // is a personal activity record, owned by the rep who ran it.\n  sharingModel: 'private',\n\n  fieldGroups: [\n    { key: 'basic',    label: 'Event Information', icon: 'info' },\n    { key: 'schedule', label: 'Schedule',          icon: 'calendar' },\n    { key: 'related',  label: 'Related Records',   icon: 'link' },\n    { key: 'outcome',  label: 'Outcome',           icon: 'clipboard-check', collapse: 'collapsed' },\n  ],\n\n  fields: {\n    // Platform ownership anchor \u2014 canonical note in `account.object.ts` (#548).\n    owner_id: Field.lookup('sys_user', {\n      label: 'Assigned To',\n      group: 'basic',\n      system: true,\n      readonly: false,\n      trackHistory: true,\n    }),\n\n    // \u2500\u2500\u2500 Event Information \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n    subject: Field.text({\n      group: 'basic',\n      label: 'Subject',\n      required: true,\n      storage: { notNull: true },\n      searchable: true,\n      maxLength: 255,\n    }),\n\n    type: Field.select({\n      group: 'basic',\n      label: 'Event Type',\n      required: true,\n      storage: { notNull: true },\n      // Field-level default, not just the option flag: the option `default`\n      // only preselects in some form surfaces, so a quick-create opened from a\n      // related list left this required field blank (same defect crm_task.status\n      // carries a note about).\n      defaultValue: 'meeting',\n      options: [...EVENT_TYPE_OPTIONS],\n    }),\n\n    status: Field.select({\n      group: 'basic',\n      label: 'Status',\n      required: true,\n      storage: { notNull: true },\n      trackHistory: true,\n      defaultValue: 'planned',\n      options: [...EVENT_STATUS_OPTIONS],\n    }),\n\n    description: Field.markdown({\n      group: 'basic',\n      label: 'Description',\n    }),\n\n    // \u2500\u2500\u2500 Schedule \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n    start_datetime: Field.datetime({\n      group: 'schedule',\n      label: 'Start',\n      required: true,\n      storage: { notNull: true },\n    }),\n\n    end_datetime: Field.datetime({\n      group: 'schedule',\n      label: 'End',\n    }),\n\n    all_day: Field.boolean({\n      group: 'schedule',\n      label: 'All Day Event',\n      defaultValue: false,\n    }),\n\n    // Derived in `event.hook.ts` from start/end. NOT `readonly`: the field is\n    // also what the activity actions supply directly when a rep logs a call\n    // that took 20 minutes, and a readonly field is stripped from any write\n    // whose CALLER supplied the key (#2948) \u2014 including an action body running\n    // under the rep's own context. Derivation inside this object's own\n    // before-hook is unaffected either way (the strip keys off the caller's\n    // payload, not the post-hook document), so leaving it writable costs\n    // nothing and keeps `log_call` honest.\n    duration_minutes: Field.number({\n      group: 'schedule',\n      label: 'Duration (minutes)',\n      min: 0,\n      scale: 0,\n    }),\n\n    location: Field.text({\n      group: 'schedule',\n      label: 'Location',\n      maxLength: 255,\n      description: 'Room, address, or meeting link',\n    }),\n\n    // \u2500\u2500\u2500 Related Records (polymorphic, same shape as crm_task) \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n    related_to_type: Field.select({\n      group: 'related',\n      label: 'Related To Type',\n      options: [...RELATED_TO_TYPE_OPTIONS],\n    }),\n\n    related_to_account: Field.lookup('crm_account', {\n      group: 'related',\n      label: 'Related Account',\n    }),\n\n    related_to_contact: Field.lookup('crm_contact', {\n      group: 'related',\n      label: 'Related Contact',\n    }),\n\n    related_to_opportunity: Field.lookup('crm_opportunity', {\n      group: 'related',\n      label: 'Related Opportunity',\n    }),\n\n    related_to_lead: Field.lookup('crm_lead', {\n      group: 'related',\n      label: 'Related Lead',\n    }),\n\n    related_to_case: Field.lookup('crm_case', {\n      group: 'related',\n      label: 'Related Case',\n    }),\n\n    // \u2500\u2500\u2500 Outcome \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n    outcome_notes: Field.markdown({\n      group: 'outcome',\n      label: 'Outcome Notes',\n      description: 'What was agreed, and what happens next',\n    }),\n\n    // No `is_past` / `is_upcoming` boolean. A write-time snapshot of \"has this\n    // happened yet\" is stale the moment the clock passes it, and the app has\n    // already been burnt by exactly that (`crm_task.is_overdue` \u2014 see the\n    // `overdue_tasks` view's label note). `status` is the authored, non-decaying\n    // signal, and the upcoming/past views filter on it and sort by\n    // `start_datetime` instead.\n  },\n\n  // API surface. History \u2192 Field.trackHistory (ADR-0052).\n  enable: {\n    apiEnabled: true,\n  },\n\n  indexes: [\n    { fields: ['start_datetime'] },\n    { fields: ['owner_id'] },\n    { fields: ['status'] },\n    { fields: ['related_to_account'] },\n    { fields: ['related_to_opportunity'] },\n  ],\n\n  // ADR-0079: `nameField` names the real field holding the record title.\n  nameField: 'subject',\n  highlightFields: ['subject', 'type', 'status', 'start_datetime', 'owner_id'],\n  searchableFields: ['subject', 'location'],\n\n  // Predicates below are TOTAL: every `record.x` read is `has()`-guarded, so the\n  // rule returns a verdict even when the merged record has no such key. See\n  // AGENTS.md \"Validation predicates must be TOTAL\" and\n  // test/object-validation-predicates.test.ts, which fails the build otherwise.\n  validations: [\n    {\n      name: 'end_after_start',\n      type: 'script',\n      severity: 'error',\n      message: 'The end time must be after the start time',\n      // BOTH guards, on both operands, because they answer different hazards\n      // (AGENTS.md \"Validation predicates must be TOTAL\"):\n      //   \u00B7 `has(...)`  \u2014 absent key. On a driver that stores only the columns\n      //     a row was written with, an absent `end_datetime` aborts the whole\n      //     predicate under strict CEL, and from 17.0.0-rc.2 that abort REJECTS\n      //     the save rather than skipping the rule (#4649).\n      //   \u00B7 `!= null`   \u2014 present-but-null. `dyn<null> < dyn` aborts too, and\n      //     `has()` says nothing about it.\n      // An ordering comparison needs both; neither substitutes for the other.\n      condition: P`has(record.start_datetime) && has(record.end_datetime) && record.start_datetime != null && record.end_datetime != null && !isBlank(record.end_datetime) && record.end_datetime < record.start_datetime`,\n    },\n    {\n      name: 'related_to_required',\n      type: 'script',\n      severity: 'warning',\n      message: 'At least one related record should be selected',\n      condition: P`(!has(record.related_to_account) || isBlank(record.related_to_account)) && (!has(record.related_to_contact) || isBlank(record.related_to_contact)) && (!has(record.related_to_opportunity) || isBlank(record.related_to_opportunity)) && (!has(record.related_to_lead) || isBlank(record.related_to_lead)) && (!has(record.related_to_case) || isBlank(record.related_to_case))`,\n    },\n  ],\n});\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/sales/objects/event_attendee.object.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/sales/objects\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/sales/objects/event_attendee.object.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport { expression } from '@objectstack/spec';\nimport { ObjectSchema, Field } from '@objectstack/spec/data';\nimport { ATTENDEE_RESPONSE_OPTIONS } from './_picklists';\n\n/**\n * The ways an attendee row can name a person \u2014 ONE declaration, not two lists\n * that happen to line up.\n *\n * `attendee_type` is the discriminator and each of the four columns below is a\n * resolution. \u26D4 Authoring the two separately lets them drift, and the failure\n * is silent: a type with no matching resolution means an external guest can\n * only be STORED MISLABELLED (a row claiming to be a Contact while pointing at\n * no contact is ACCEPTED, and an omitted type falls to the field default).\n *\n * Deriving BOTH the picklist and the two rules from this table is the point: a\n * fifth resolution cannot be added without its type, and a type cannot be added\n * without saying which column it names \u2014 the failure is not expressible in this\n * shape. Everything downstream (options, `attendee_resolves`,\n * `attendee_type_exclusive`) is generated below; nothing repeats the pairing.\n * `test/attendee-type-resolution.test.ts` pins it.\n *\n * Adding a row here is a user-visible picklist change: it needs a label in all\n * four locale packs (`test/i18n-references.test.ts` fails otherwise) and a\n * changeset.\n */\nexport const ATTENDEE_RESOLUTIONS = [\n  { value: 'contact',  column: 'crm_contact',   label: 'Contact',  color: '#4169E1' },\n  { value: 'lead',     column: 'crm_lead',      label: 'Lead',     color: '#FFA500' },\n  { value: 'user',     column: 'sys_user',      label: 'User',     color: '#00AA00' },\n  { value: 'external', column: 'external_name', label: 'External', color: '#8A8A8A' },\n] as const;\n\n/** A new attendee row is a Contact until the author says otherwise. */\nexport const DEFAULT_ATTENDEE_TYPE = 'contact';\n\n// The predicate fragments below are the TOTAL shapes from the house rule in\n// `test/object-validation-predicates.test.ts`: every `record.x` read carries its\n// own `has(record.x)` in the same expression, so the rule returns a verdict on a\n// merged record with absent keys instead of aborting (and, from 17.0.0-rc.2,\n// rejecting the write it could not judge).\nconst blank = (f: string) => `(!has(record.${f}) || isBlank(record.${f}))`;\nconst filled = (f: string) => `(has(record.${f}) && !isBlank(record.${f}))`;\nconst typeIs = (v: string) => `(has(record.attendee_type) && record.attendee_type == \"${v}\")`;\nconst typeIsNot = (v: string) => `(has(record.attendee_type) && record.attendee_type != \"${v}\")`;\n\n/**\n * Violation predicates \u2014 validations fire when the condition is TRUE.\n *\n * They are the two halves of \"declared = enforced\", split so each condition\n * carries its own wording: a row missing the party its type names is a\n * different mistake from a row naming a party its type does not.\n *\n * A record whose `attendee_type` is absent satisfies neither (every fragment is\n * `has()`-guarded on it), which is deliberate: \"no type at all\" is the REQUIRED\n * field's job \u2014 `Attendee Type is required` names the real obstacle, and a\n * second rule saying so would only shadow it.\n */\nconst RESOLVES_CONDITION = ATTENDEE_RESOLUTIONS\n  .map((r) => `(${typeIs(r.value)} && ${blank(r.column)})`)\n  .join(' || ');\n\nconst EXCLUSIVE_CONDITION = ATTENDEE_RESOLUTIONS\n  .map((r) => `(${filled(r.column)} && ${typeIsNot(r.value)})`)\n  .join(' || ');\n\n/**\n * `requiredWhen` for one party column \u2014 the SAME correspondence the two rules\n * enforce, asked one layer earlier so the form marks the column the chosen type\n * names instead of letting the save discover it is empty. Derived from\n * `ATTENDEE_RESOLUTIONS` like everything else here: a fifth resolution gets its\n * hint for free and cannot get it wrong.\n *\n * This is a HINT, not the contract. `attendee_resolves` and\n * `attendee_type_exclusive` at the bottom of this file are the contract every\n * writer meets \u2014 REST, ObjectQL, seeds, flows \u2014 and nothing here relaxes\n * either. \u26A0\uFE0F `requiredWhen` is a transition gate, not an invariant: it asks the\n * write in front of it for the column, it does not state a property of stored\n * rows. The duplication is deliberate and visible \u2014 a REST insert omitting the\n * named column answers twice, once per layer, and the accepted set is\n * unchanged.\n *\n * \u26A0\uFE0F The predicate is TOTAL (`has()`-guarded via `typeIs`), the same house rule\n * AGENTS.md states for every authored CEL predicate. `requiredWhen` fails\n * CLOSED in the Console \u2014 an unevaluable predicate demands nothing \u2014 so an\n * unguarded one would read as enforced here and require nothing at the form.\n *\n * # \u26D4 Why there is no `visibleWhen` beside it\n *\n * \u26A0\uFE0F Platform constraint, measured in the browser on 17.1.0: the Console hides\n * a populated field WITHOUT clearing it and submits the stale value anyway.\n * Fill Contact, then change the type to Lead \u2014 the Contact column leaves the\n * DOM, its value stays in form state, and the write carries it:\n *\n *     POST  {\"attendee_type\":\"lead\", \u2026, \"crm_contact\":\"AEwPffbkMvx-OlC4\",\n *                                       \"crm_lead\":\"0AM_zbdjuLcXMdnL\"}\n *     400   An attendee names exactly one party \u2014 clear every party column\n *           its Attendee Type does not name\n *\n * \u2014 so the row is refused, correctly, by a message naming a column no longer on\n * screen to clear. On the EDIT path it is a dead end rather than a puzzle:\n * retyping a stored `contact` row to `user` re-sends the stored `crm_contact`\n * on every attempt, and the Console offers no way to empty it. Today's form is\n * worse-looking and strictly more usable: the offending column is visible, so\n * the error can be acted on.\n *\n * Nothing in `@objectstack/spec` 17.1.0 or the shipped Console clears a value\n * when its field goes invisible \u2014 no `clearOnHide`-shaped key exists on either\n * surface \u2014 so `visibleWhen` here cannot be paired into safety from this repo.\n * The half that would need to change is upstream; it is the same\n * fail-open/stale-state family as the note in `src/sales/views/lead.view.ts`. \u26D4 Do\n * not add `visibleWhen` to these four columns until a hidden field stops being\n * submitted; the rules above will keep refusing the row, but the person in\n * front of the form will have no way to fix it.\n */\nconst partyFormHints = (column: string) => {\n  const resolution = ATTENDEE_RESOLUTIONS.find((r) => r.column === column);\n  if (!resolution) {\n    throw new Error(`No attendee resolution declares the column \"${column}\"`);\n  }\n  return {\n    requiredWhen: expression(typeIs(resolution.value), 'cel'),\n  };\n};\n\n/**\n * Event Attendee \u2014 who was in the room.\n *\n * # Why a junction object, and not multi-value lookups\n *\n * \"Attendees are queryable RECORDS, not JSON strings\", and three properties\n * decide the shape:\n *\n *  1. **Attendees are heterogeneous.** A customer meeting has internal people\n *     (`sys_user`), existing customers (`crm_contact`) and prospects\n *     (`crm_lead`) in it. A `Field.lookup(..., { multiple: true })` points at\n *     exactly ONE object, so a multi-lookup design needs three parallel\n *     multi-lookups and no way to order or de-duplicate across them.\n *  2. **An attendee carries its own attributes.** `response` and `is_organizer`\n *     belong to the *pairing* of a person and an event, not to either side. A\n *     multi-value lookup stores a bare id array with nowhere to hang them.\n *  3. **A junction is queryable.** \"Meetings this rep attended\", \"contacts who\n *     declined twice this quarter\" and \"accounts whose champion has not\n *     attended anything in 90 days\" are all `find()` calls on this object.\n *     Against an id array inside a multi-value column they are not expressible\n *     in ObjectQL at all.\n *\n * This mirrors `crm_campaign_member`, the app's existing junction, down to the\n * autonumber `nameField` and the `controlled_by_parent` OWD.\n *\n * # Access derives from the event\n *\n * `sharingModel: 'controlled_by_parent'` (ADR-0055). The relation resolver\n * accepts the REQUIRED `crm_event` lookup as the parent, so no master-detail\n * conversion is needed \u2014 same construction as `crm_campaign_member`.\n *\n * Reads are filtered to attendees whose `crm_event` the caller can read, and\n * adding or updating an attendee requires edit access to that event. \u26A0\uFE0F That\n * derivation resolves through the same paths a direct read of the event takes \u2014\n * ownership scope and `sys_record_share` grants folded in, not the master's\n * row-level security policies alone. The distinction is not academic: an\n * earlier platform version consulted master RLS policies ONLY, under a SYSTEM\n * context, and HotCRM authors none on `crm_event` \u2014 so every attendee row of\n * every meeting reached every holder of object-level read.\n * `test/parent-derived-reach.test.ts` pins the narrow behaviour and was written\n * to go red the day the platform changed it.\n */\nexport const EventAttendee = ObjectSchema.create({\n  name: 'crm_event_attendee',\n  label: 'Event Attendee',\n  pluralLabel: 'Event Attendees',\n  icon: 'users',\n  description: 'A person invited to or present at an event',\n\n  sharingModel: 'controlled_by_parent',\n\n  // ADR-0079: junction rows have no derivable text title; point the canonical\n  // nameField at the stored autonumber explicitly (autonumber is not in the\n  // auto-derivation whitelist).\n  nameField: 'attendee_number',\n\n  highlightFields: ['crm_event', 'attendee_type', 'response', 'is_organizer'],\n\n  fieldGroups: [\n    { key: 'basic',    label: 'Attendee',   icon: 'user' },\n    { key: 'response', label: 'Invitation', icon: 'mail-check' },\n  ],\n\n  fields: {\n    attendee_number: Field.autonumber({\n      group: 'basic',\n      label: 'Attendee Number',\n      format: 'EA-{00000}',\n    }),\n\n    // \u26A0\uFE0F Deliberately left on the spec default, and NOT cascaded with the party\n    // lookups below. Because it is REQUIRED, the engine escalates the stored\n    // `set_null` to a refusal at delete time, with a message naming the real\n    // obstacle instead of an unrelated rule: \"Cannot delete crm_event (...): 3\n    // dependent crm_event_attendee record(s) reference it via crm_event\n    // (crm_event is required, so it cannot be cleared).\" That is the correct\n    // answer on this side, for the same reason `crm_campaign_member.crm_campaign`\n    // keeps it: a meeting's attendee list is the meeting's historical record,\n    // not a per-person artefact. `test/event-attendee-cascade.test.ts` pins the\n    // resolved value so a copy-paste of the three cascades cannot reach here.\n    crm_event: Field.lookup('crm_event', {\n      group: 'basic',\n      label: 'Event',\n      required: true,\n      storage: { notNull: true },\n    }),\n\n    // The discriminator says which of the four columns below is the live one. It\n    // is authored rather than derived so a query can filter \"internal attendees\n    // only\" without four OR'd null checks. The options are GENERATED from the\n    // resolution table rather than retyped \u2014 see the note at the top of this\n    // file for why the pairing is declared once.\n    attendee_type: Field.select({\n      group: 'basic',\n      label: 'Attendee Type',\n      required: true,\n      storage: { notNull: true },\n      defaultValue: DEFAULT_ATTENDEE_TYPE,\n      options: ATTENDEE_RESOLUTIONS.map((r) => ({\n        label: r.label,\n        value: r.value,\n        color: r.color,\n        ...(r.value === DEFAULT_ATTENDEE_TYPE ? { default: true } : {}),\n      })),\n    }),\n\n    // \u26D4 `deleteBehavior: 'cascade'` on ALL THREE party lookups, not the default.\n    //\n    // \u26A0\uFE0F Platform constraint: a lookup defaults to `set_null`, and the engine\n    // implements `set_null` by UPDATING the row that holds it. On a column a\n    // validation rule reads, that makes the referenced party permanently\n    // UNDELETABLE: clearing this column leaves the row the engine just edited in\n    // violation of `attendee_resolves` below, and the whole delete rolls back\n    // with an error naming an object the caller never addressed. The same\n    // construction bites `crm_campaign_member`.\n    //\n    // `external_name` is the fourth resolution, but it is blank on every row the\n    // product actually writes (`src/sales/actions/activity-actions.ts` logs attendees\n    // with a party reference and never an external name), so it rescues nothing.\n    //\n    // Cascade rather than `restrict`: an attendee row is a JUNCTION whose whole\n    // meaning is \"this person was in this room\". Once the person is gone the row\n    // denotes nothing, and the query it exists to serve (\"meetings this person\n    // attended\") has lost its subject. `restrict` would produce an accurate\n    // message but keep the person undeletable until someone deleted their\n    // attendance by hand, and undeletable PEOPLE is the impact being fixed.\n    // Cascade also leaves no reachable state in which a stored attendee row\n    // breaks its own object's rule.\n    crm_contact: Field.lookup('crm_contact', {\n      group: 'basic',\n      label: 'Contact',\n      deleteBehavior: 'cascade',\n      description: 'Set when the attendee is an existing customer contact',\n      ...partyFormHints('crm_contact'),\n    }),\n\n    crm_lead: Field.lookup('crm_lead', {\n      group: 'basic',\n      label: 'Lead',\n      deleteBehavior: 'cascade',\n      description: 'Set when the attendee is still an unconverted lead',\n      ...partyFormHints('crm_lead'),\n    }),\n\n    // `sys_user` gets the SAME answer as the two CRM parties, and it was worth a\n    // second look rather than a copy-paste:\n    //\n    //  \u00B7 Deleting a user is a real, reachable operation. Generic CRUD delete on\n    //    the identity table is off (`sys_user` ships `apiMethods: ['get',\n    //    'list', 'update', 'bulk']`), but better-auth's own routes \u2014\n    //    `/api/v1/auth/delete-user`, which the platform's `sys_user` object\n    //    surfaces as the \"Delete My Account\" record action, and\n    //    `/api/v1/auth/admin/remove-user` \u2014 resolve `user` to `sys_user` and\n    //    land on `dataEngine.delete(...)`, i.e. the SAME ObjectQL delete that\n    //    runs the referential pass. So `set_null` here is not dormant: it breaks\n    //    account erasure for any colleague who ever attended a meeting.\n    //  \u00B7 The app's shipped stance is already \"a deleted user's references\n    //    degrade\". EVERY other `sys_user` lookup in HotCRM (every `owner_id`,\n    //    plus `product_manager`) is `set_null` and NO validation rule reads any\n    //    of them \u2014 the rule below is the only one in the app that reads a user\n    //    reference at all, which is precisely why this is the only lookup where\n    //    the default misbehaves. `restrict` here would make this junction the\n    //    ONE app row able to veto a platform identity erasure \u2014 an app object\n    //    holding a `protection: { lock: 'full' }`, better-auth-managed table\n    //    hostage, surfacing as an opaque failure from an auth route. That is a\n    //    layering inversion, not a fix.\n    //  \u00B7 The cost of cascade is bounded and is the right half to lose: the\n    //    meeting itself (`crm_event` \u2014 subject, times, outcome notes) survives\n    //    untouched; only the per-person row goes, and it goes because the\n    //    person's identity record was erased. Deactivation, not deletion, is the\n    //    ordinary offboarding path (the platform ships ban/unban), and it\n    //    touches nothing here.\n    sys_user: Field.lookup('sys_user', {\n      group: 'basic',\n      label: 'User',\n      deleteBehavior: 'cascade',\n      description: 'Set when the attendee is a colleague',\n      ...partyFormHints('sys_user'),\n    }),\n\n    // Free text is the LAST resort, not the default: it exists only for the\n    // genuinely unmodelled guest (a prospect's lawyer who is in no CRM object).\n    // It is the resolution of ONE attendee type \u2014 `external` \u2014 and the rules\n    // below enforce that both ways: an `external` row must fill it, and no\n    // other type may. It is not a place to paste a list, and not a note field\n    // to hang off a Contact row.\n    external_name: Field.text({\n      group: 'basic',\n      label: 'External Attendee',\n      maxLength: 255,\n      description: 'Name of an attendee who is in no CRM object \u2014 set when Attendee Type is External',\n      ...partyFormHints('external_name'),\n    }),\n\n    response: Field.select({\n      group: 'response',\n      label: 'Response',\n      required: true,\n      storage: { notNull: true },\n      trackHistory: true,\n      defaultValue: 'no_response',\n      options: [...ATTENDEE_RESPONSE_OPTIONS],\n    }),\n\n    is_organizer: Field.boolean({\n      group: 'response',\n      label: 'Organizer',\n      defaultValue: false,\n    }),\n\n    // \u26D4 NOT `readonly` \u2014 but the cross-reference this note used to carry is\n    // retired, not merely reworded: `crm_campaign_member.added_date` was ruled\n    // `readonly: true` in #1667, so it is no longer a precedent for keeping an\n    // insert-stamped column open, and the reason it cited (\"the engine strips a\n    // readonly key the CALLER supplied\") does not reach an INSERT at all \u2014 the\n    // strip is an UPDATE-path rule (`test/readonly-write-semantics.test.ts`).\n    // What holds it open is now MEASURED (#1747, the per-writer census #1435\n    // ran for the other three), not \"nobody has ruled on it\": this column has a\n    // user-context UPDATE writer, which none of the three columns #1666 / #1667\n    // moved had. The census, in full:\n    //   \u2022 the fifteen generated activity actions (5 `ACTIVITY_TARGETS` \u00D7 3\n    //     kinds, one shared body in `activity-actions.ts`) INSERT it, and an\n    //     action body runs `isSystem` \u2014 exempt twice over;\n    //   \u2022 the two `service.seed.ts` attendee seeds write it, and their\n    //     `mode: 'upsert'` replay UPDATE is exempt too, because seed writes are\n    //     `isSystem` (`flow-scheduled.test.ts` pins that via ownerless rows);\n    //   \u2022 the record form \u2014 `event_attendee.view.ts` lists it in the\n    //     `invitation` section, AUTHORED rather than synthesized, and the four\n    //     profiles that name the object all grant `allowEdit`. A rep correcting\n    //     Invited on a saved row is a non-`isSystem` UPDATE carrying a\n    //     caller-supplied key: precisely what the strip deletes. The three\n    //     flipped columns appear in NO form section anywhere in `src/*/views/`,\n    //     `crm_opportunity`'s authored form included.\n    // \u2B50 It is also not the same KIND of column. `added_date` / `approved_date`\n    // are stamped `{NOW()}` by the writer, so their value IS the write moment;\n    // `invited_date` records when the invitation went out, and the seed dates it\n    // 3-10 days before its own event, per row. A column whose value is not the\n    // write moment is one a person can be right about. \u26D4 Do not flip it on the\n    // strength of the sibling ruling.\n    invited_date: Field.datetime({\n      group: 'response',\n      label: 'Invited',\n    }),\n  },\n\n  indexes: [\n    { fields: ['crm_event'] },\n    { fields: ['crm_contact'] },\n    { fields: ['sys_user'] },\n  ],\n\n  // \u26A0\uFE0F Predicates below are TOTAL: every `record.x` read is `has()`-guarded, so\n  // the rule returns a verdict even when the merged record has no such key. See\n  // AGENTS.md \"Validation predicates must be TOTAL\" and\n  // test/object-validation-predicates.test.ts, which fails the build otherwise.\n  //\n  // Both rules are GENERATED from `ATTENDEE_RESOLUTIONS` at the top of this\n  // file. \u26A0\uFE0F `expression(..., 'cel')` is the same envelope the ``P`\u2026` `` tag\n  // produces, but the tag JSON-quotes an interpolated string and so cannot\n  // splice a source fragment \u2014 which is why these use the function form. The\n  // pairing is declared once and read twice; see the note up there.\n  validations: [\n    // The type's own column must be filled.\n    {\n      name: 'attendee_resolves',\n      type: 'script',\n      severity: 'error',\n      message:\n        'An attendee must fill the party its Attendee Type names \u2014 a Contact row needs a Contact, an External row needs an External Attendee name',\n      condition: expression(RESOLVES_CONDITION, 'cel'),\n    },\n    // \u2026and no other column may be filled. The separate rule is deliberate: one\n    // condition, one wording. Folding both into `attendee_resolves` would make\n    // its message a lie for half the rows it rejects, and \"you filled the wrong\n    // column\" is not the same instruction as \"you filled nothing\".\n    {\n      name: 'attendee_type_exclusive',\n      type: 'script',\n      severity: 'error',\n      message:\n        'An attendee names exactly one party \u2014 clear every party column its Attendee Type does not name',\n      condition: expression(EXCLUSIVE_CONDITION, 'cel'),\n    },\n  ],\n});\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/sales/objects/forecast.object.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/sales/objects\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/sales/objects/forecast.object.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport { ObjectSchema, Field } from '@objectstack/spec/data';\nimport { F, P } from '@objectstack/spec';\n\n/**\n * Forecast Object\n *\n * Monthly / quarterly snapshot of pipeline by owner. Each record holds\n * the aggregated amounts at the moment of snapshot, so trend reports\n * (\"how did our Q3 forecast change week over week?\") can be built\n * without re-aggregating opportunity history.\n *\n * Written by:\n *   \u2022 `src/sales/flows/forecast-snapshot.flow.ts` \u2014 the `forecast_snapshot`\n *     scheduled flow, nightly at 03:00, one current-quarter row per active\n *     opportunity owner (#590). It never touches `quota`.\n *   \u2022 `revenue_forecasting` AI skill on demand\n *   \u2022 `forecast.hook.ts` derives the period family + `snapshot_date` on every\n *     write; it creates nothing on its own.\n *\n * Forecast categories follow the standard Salesforce ladder, and the buckets\n * are CUMULATIVE \u2014 each is a subset of the one above it:\n *   pipeline  \u2192 all open opps closing in the period\n *   best_case \u2192 open opps whose forecast_category is best_case OR commit\n *   commit    \u2192 open opps whose forecast_category is commit\n *   closed    \u2192 already-won amount in the period\n *\n * The bucket boundary is the stored `forecast_category` column (derived from\n * `stage` by the opportunity lifecycle hook), NOT a probability threshold \u2014\n * one definition, shared with the \"Commit & Best Case\" opportunity view and\n * the `pipeline_by_forecast_category` dashboard widget.\n */\nexport const Forecast = ObjectSchema.create({\n  name: 'crm_forecast',\n  label: 'Forecast',\n  pluralLabel: 'Forecasts',\n  icon: 'trending-up',\n  description: 'Periodic pipeline snapshot by owner used for revenue forecasting.',\n\n  // OWD is an authored decision (ADR-0090 D1/D7). Forecasts are personal to the\n  // owner.\n  sharingModel: 'private',\n  // ADR-0079 record title. \u26A0\uFE0F A formula cannot dot-walk a lookup (ADR-0072), so\n  // `display_title` composes local fields only: period_label + (period_start).\n  nameField: 'display_title',\n  // \u26A0\uFE0F Explicit search targets (ADR-0061), REQUIRED because `nameField` is a\n  // FORMULA: without this, `$search` auto-defaults to the formula field, which\n  // is not a real column, so the lookup picker and global search silently\n  // return zero. These are real, indexed columns.\n  searchableFields: ['period_label'],\n  highlightFields: ['owner_id', 'period', 'period_start', 'commit_amount', 'closed_amount'],\n\n  fieldGroups: [\n    { key: 'basic',   label: 'Snapshot',    icon: 'info' },\n    { key: 'amounts', label: 'Amounts',     icon: 'dollar-sign' },\n    { key: 'meta',    label: 'Source',      icon: 'database', collapse: 'collapsed' },\n  ],\n\n  fields: {\n    // Platform ownership anchor \u2014 canonical note in `account.object.ts` (#548).\n    owner_id: Field.lookup('sys_user', {\n      label: 'Owner',\n      group: 'basic',\n      system: true,\n      readonly: false,\n      trackHistory: true,\n    }),\n\n\n    period: Field.select({\n      label: 'Period',\n      required: true,\n      storage: { notNull: true },\n      group: 'basic',\n      options: [\n        { label: 'Month',   value: 'month', default: true },\n        { label: 'Quarter', value: 'quarter' },\n      ],\n    }),\n\n    // Wording mirrors the two refusal messages this field is bound by\n    // (`period_start_first_of_period` / `quarter_starts_on_quarter_boundary`,\n    // both below) so the form and the rejection agree on the same rule\n    // instead of describing two different ones (#1085).\n    period_start: Field.date({\n      label: 'Period Start',\n      description:\n        'Must be the first day of the period \u2014 e.g. 2026-08-01 for Aug 2026. A quarterly forecast must additionally start on a quarter boundary: January 1, April 1, July 1 or October 1.',\n      required: true,\n      storage: { notNull: true },\n      group: 'basic',\n    }),\n\n    // Still not read-only: `forecast.hook.ts` fills it only when the write\n    // leaves it unset, and `src/sales/data/forecast.seed.ts` hand-fills it on every\n    // seeded row \u2014 so hand-entry is a capability this app uses. A hand-filled\n    // value is pinned to the same calendar period `period_start` is\n    // (`period_end_matches_calendar_period` below), and the description states\n    // that rule rather than the weaker `period_end_after_start` it subsumes:\n    // the form says what is actually enforced.\n    period_end: Field.date({\n      label: 'Period End',\n      description:\n        'Normally derived automatically from Period and Period Start. If set by hand, it must be the last day of that period \u2014 e.g. 2026-09-30 for a quarter starting 2026-07-01, or 2026-08-31 for Aug 2026.',\n      required: true,\n      storage: { notNull: true },\n      group: 'basic',\n    }),\n\n    period_label: Field.text({\n      label: 'Period Label',\n      description: 'Human-friendly label, e.g. \"Q3 2026\" or \"Aug 2026\".',\n      group: 'basic',\n    }),\n\n    // ADR-0079 record title. \u26A0\uFE0F A formula cannot dot-walk a lookup (ADR-0072),\n    // so this composes local fields only; `period_start` (a date) is\n    // string()-coerced for concat.\n    //\n    // \u26A0\uFE0F The coercion is `string()`, NOT `text()`. `text` is not a registered\n    // CEL function \u2014 it is absent from `CEL_STDLIB_FUNCTIONS` \u2014 so a formula\n    // using it faults at runtime and leaves the record's `nameField` null. The\n    // author-time `expression-invalid` rule now REPORTS it (\"found no matching\n    // overload for 'text(dyn)'\") instead of letting a broken formula through to\n    // null silently. `string` is the catalog's coercion, alongside\n    // `int`/`bool`/`double`/`timestamp`.\n    display_title: Field.formula({\n      label: 'Display Title',\n      expression: F`record.period_label + \" (\" + string(record.period_start) + \")\"`,\n      group: 'basic',\n    }),\n\n    snapshot_date: Field.date({\n      label: 'Snapshot Date',\n      description: 'The day this snapshot was captured.',\n      required: true,\n      storage: { notNull: true },\n      group: 'meta',\n    }),\n\n    quota: Field.currency({\n      label: 'Quota',\n      min: 0,\n      group: 'amounts',\n      trackHistory: true,\n    }),\n\n    pipeline_amount: Field.currency({\n      label: 'Pipeline',\n      description: 'Sum of all open opportunities closing in this period (any stage).',\n      min: 0,\n      group: 'amounts',\n    }),\n\n    best_case_amount: Field.currency({\n      label: 'Best Case',\n      description: 'Open opportunities in the Best Case or Commit forecast category.',\n      min: 0,\n      group: 'amounts',\n    }),\n\n    commit_amount: Field.currency({\n      label: 'Commit',\n      description: 'Open opportunities in the Commit forecast category (owner-committed).',\n      min: 0,\n      group: 'amounts',\n    }),\n\n    closed_amount: Field.currency({\n      label: 'Closed Won',\n      description: 'Already-closed-won amount in this period.',\n      min: 0,\n      group: 'amounts',\n    }),\n\n    expected_amount: Field.formula({\n      label: 'Expected',\n      description: 'Closed Won + Commit \u2014 what the owner reasonably expects to land.',\n      expression: F`coalesce(record.closed_amount, 0) + coalesce(record.commit_amount, 0)`,\n      scale: 2,\n      group: 'amounts',\n    }),\n\n    attainment_pct: Field.formula({\n      label: 'Attainment %',\n      description: 'Closed Won \u00F7 Quota \u00D7 100. Reads 0% until a positive quota is set.',\n      expression: F`coalesce(record.quota, 0) > 0 ? (coalesce(record.closed_amount, 0) * 100.0) / record.quota : 0.0`,\n      scale: 2,\n      group: 'amounts',\n    }),\n\n    coverage_ratio: Field.formula({\n      label: 'Coverage Ratio',\n      description: 'Pipeline \u00F7 (Quota \u2212 Closed Won) \u2014 whether enough pipeline remains to cover the gap. Reads 0 once the quota is already met.',\n      expression: F`(coalesce(record.quota, 0) - coalesce(record.closed_amount, 0)) > 0 ? coalesce(record.pipeline_amount, 0) / (record.quota - coalesce(record.closed_amount, 0)) : 0.0`,\n      scale: 2,\n      group: 'amounts',\n    }),\n\n    source: Field.select({\n      label: 'Source',\n      group: 'meta',\n      options: [\n        { label: 'Scheduled snapshot', value: 'scheduled', default: true },\n        { label: 'AI skill',           value: 'ai' },\n        { label: 'Manual entry',       value: 'manual' },\n      ],\n    }),\n\n    notes: Field.text({\n      label: 'Notes',\n      maxLength: 1000,\n      group: 'meta',\n    }),\n\n    // Fixture identity \u2014 the seed loader's `externalId`, and nothing else.\n    //\n    // `crm_forecast` is a PER-OWNER snapshot: its real identity is\n    // (owner_id, period, period_start), and every other column is a rendering of\n    // part of that. `period_label` in particular names a SET of rows once the\n    // `forecast_snapshot` sweep writes one row per active owner per quarter \u2014\n    // they all read 'Q3 2026' \u2014 so upserting on that label lets a re-seed match,\n    // and overwrite, a real rep's snapshot.\n    //\n    // \u26A0\uFE0F The true composite `externalId: ['owner_id', 'period', 'period_start']`\n    // is not available here: a seed cannot name a user (see the note in\n    // `objectstack.composition.ts`, \"A seed can't name a user\"), so `owner_id`\n    // is null on every seeded row, and\n    // the loader's `externalIdKey` returns \"\" as soon as any part is empty. An\n    // empty key never matches, so upsert degrades to insert-on-every-replay.\n    // Dropping `owner_id` does not rescue it: a runtime row for the current\n    // quarter carries exactly the same (period, period_start).\n    //\n    // \u26A0\uFE0F `mode: 'insert'` does NOT mean \"insert once\" \u2014 the loader inserts\n    // unconditionally on every replay boot (framework#3434). `'ignore'` is the\n    // real insert-once mode, but it decides \"already there?\" from the same\n    // `externalId`, so on a broken key it would SKIP the demo row because a real\n    // rep's row already claimed 'Q3 2026'. Fixing the identity is a prerequisite\n    // either way. Hence this synthetic, seeder-only key.\n    //\n    // \u26A0\uFE0F `readonly` is the load-bearing part, not decoration: seed writes run\n    // `{ isSystem: true }` and bypass readonly stripping, while readonly\n    // stripping does guard user/API writes \u2014 so a genuine forecast row can never\n    // acquire a `seed_key` and can never be matched by a re-seed. That is what\n    // makes the fix structural rather than a naming convention. `hidden` keeps a\n    // fixtures-only column out of forms and pickers.\n    seed_key: Field.text({\n      label: 'Seed Key',\n      description: 'Demo-fixture identity. Written only by the seed loader; empty on every real snapshot.',\n      maxLength: 64,\n      readonly: true,\n      hidden: true,\n      group: 'meta',\n    }),\n  },\n\n  indexes: [\n    { fields: ['owner_id', 'period_start', 'period'] },\n    { fields: ['snapshot_date'] },\n    { fields: ['period_start'] },\n  ],\n\n  // API surface. History \u2192 Field.trackHistory (ADR-0052).\n  enable: {\n    apiEnabled: true,\n    apiMethods: ['get', 'list', 'create', 'update', 'delete'],\n  },\n\n  // Predicates below are TOTAL: every `record.x` read is `has()`-guarded, so the\n  // rule returns a verdict even when the merged record has no such key. See\n  // AGENTS.md \"Validation predicates must be TOTAL\" and\n  // test/object-validation-predicates.test.ts, which fails the build otherwise.\n  validations: [\n    {\n      name: 'period_end_after_start',\n      type: 'script',\n      severity: 'error',\n      message: 'Period End must be after Period Start.',\n      // `<=`, not `<`: the rule name says \"after\" and a forecast period is a\n      // month or a quarter, never a single instant, so `period_end ==\n      // period_start` is a zero-length period rather than a valid one. Same\n      // operator and wording as the `end_after_start` twins on\n      // campaign/contract.\n      condition: P`has(record.period_end) && record.period_end != null && has(record.period_start) && record.period_start != null && record.period_end <= record.period_start`,\n    },\n    // A hand-filled `period_start` must be the first day of the calendar period\n    // it labels. Maintainer ruling 2026-08-11: \u300C\u63A5\u53D7\u4F60\u7684\u5168\u90E8\u5EFA\u8BAE\u300D \u2014 refuse\n    // rather than accept or snap.\n    //\n    // The hook derives `period_end` as \"start + one period\" \u2014 a ROLLING window.\n    // That is calendar-true for a start on a boundary and drifts for anything\n    // else: `period: 'quarter'` + `period_start: 2026-08-15` derives\n    // `period_end: 2026-10-31` under `period_label: 'Q3 2026'`, a window\n    // labelled Q3 that reaches a month into Q4. The row is internally\n    // inconsistent in a way no consumer can detect: every \"this quarter\"\n    // equals-filter reads `period_start`, and the nightly sweep selects the\n    // current row by `period_start <= today <= period_end`.\n    //\n    // These rules are the ONE enforcement point \u2014 deliberately not a throw in\n    // `forecast.hook.ts` as well. \u26A0\uFE0F A declared rule is the shape the platform\n    // can act on: it refuses the write with a `ValidationError` /\n    // `VALIDATION_FAILED` envelope (HTTP 400) on the record form, on the API and\n    // on a seed's system write alike, where a hook throw is a bare `Error`. The\n    // derivation is left alone: with the start pinned to a boundary, \"start +\n    // one period\" IS the calendar period.\n    //\n    // \u26A0\uFE0F WHY A REGEX AND NOT DATE ARITHMETIC: the CEL stdlib this app compiles\n    // against (`CEL_STDLIB_FUNCTIONS`) has no month/day accessor \u2014 the date\n    // functions are `today`/`daysBetween`/`addDays`/`addMonths`/`date` \u2014 so \"the\n    // 1st of its month\" is not expressible as arithmetic. Both drivers this app\n    // can run on hand `period_start` back as a `YYYY-MM-DD` string, and an ISO\n    // *datetime* string still matches these prefix-anchored patterns. A caller\n    // that writes a JS `Date` object is the one shape `string()` has no overload\n    // for; the engine then rejects that write naming the rule rather than\n    // admitting it, and no writer in this app does that.\n    {\n      name: 'period_start_first_of_period',\n      type: 'script',\n      severity: 'error',\n      message: 'Period Start must be the first day of the period \u2014 e.g. 2026-08-01 for Aug 2026.',\n      condition: P`has(record.period_start) && record.period_start != null && !matches(string(record.period_start), \"^[0-9]{4}-[0-9]{2}-01\")`,\n    },\n    {\n      name: 'quarter_starts_on_quarter_boundary',\n      type: 'script',\n      severity: 'error',\n      // The month rule above already rejects any non-1st day, so this one only\n      // ever adds the quarter-month half: 2026-08-01 is a valid month start and\n      // not a valid quarter start.\n      message: 'A quarterly forecast must start on a quarter boundary \u2014 January 1, April 1, July 1 or October 1.',\n      condition: P`has(record.period) && record.period == \"quarter\" && has(record.period_start) && record.period_start != null && !matches(string(record.period_start), \"^[0-9]{4}-(01|04|07|10)-01\")`,\n    },\n    // \u2026and the OTHER end of the same window. The two rules above pin the START;\n    // `period_end` stays reachable, because the hook derives it only when the\n    // write leaves it unset and the field sits editable on the record form.\n    // Without this rule, `period: 'quarter'` + `period_start: 2026-07-01` (a\n    // boundary the rules above admit) + a hand-typed `period_end: 2027-05-15` is\n    // ADMITTED under `period_label: 'Q3 2026'` \u2014 a ten-month window labelled as\n    // one quarter, reached through the other field.\n    //\n    // WHY A RULE AND NOT A READ-ONLY FIELD: deriving `period_end` always and\n    // locking the form breaks the demo seed \u2014\n    // `src/sales/data/forecast.seed.ts` hand-fills it on every seeded row.\n    // Hand-entry stays; it is now bounded.\n    //\n    // \u26A0\uFE0F WHY `type: 'script'` AND NOT A FIELD CONSTRAINT: a field bound judges\n    // only the value being written, so a row already stored wrong keeps\n    // accepting edits forever; a script validation is evaluated against the\n    // MERGED record on every write and is therefore a true invariant.\n    // `test/forecast-period-end-boundary.test.ts` pins both halves \u2014 a legacy\n    // row is refused on its next unrelated edit, and the repair is admitted.\n    //\n    // WHY DATE ARITHMETIC HERE WHEN THE TWO RULES ABOVE USE A REGEX: not taste.\n    // Those rules inspect ONE date's components (\"is this the 1st of its\n    // month?\"), and the CEL stdlib has no month/day accessor. This rule compares\n    // TWO dates, which `addMonths`/`addDays`/`daysBetween` express directly.\n    //\n    // The predicate says \"one period long\", and that is the same claim as \"ends\n    // on the calendar boundary\" ONLY because the two rules above pin the start\n    // to one. That coupling is deliberate: the three are one set enforcing one\n    // invariant (a row's window is exactly the calendar period it is labelled\n    // with), not three independent gates.\n    //\n    // \u26A0\uFE0F `daysBetween(a, b) != 0` rather than `a == b`: both drivers this app\n    // runs on hand dates back as `YYYY-MM-DD` strings while `addDays` returns a\n    // timestamp, and a string never `==` a timestamp \u2014 the rule would be\n    // permanently green. `daysBetween` puts both sides through the same\n    // `toDate`, so the string, an ISO datetime spelling and a JS `Date` all\n    // compare alike.\n    //\n    // \u26A0\uFE0F The `!= null` guards are load-bearing for a THIRD hazard beyond the two\n    // AGENTS.md names: `daysBetween(null, \u2026)` reaches `BigInt(NaN)` and THROWS,\n    // which the engine reports as `predicate failed to evaluate` \u2014 a rule that\n    // cannot answer, i.e. a rejected ordinary save. This predicate has no\n    // ordering operator, so `object-validation-predicates.test.ts`'s\n    // unguarded-comparison sweep does not cover it; the pin lives in\n    // `test/forecast-period-end-boundary.test.ts` instead.\n    {\n      name: 'period_end_matches_calendar_period',\n      type: 'script',\n      severity: 'error',\n      message:\n        'Period End must be the last day of the period \u2014 e.g. 2026-09-30 for a quarter starting 2026-07-01, or 2026-08-31 for Aug 2026.',\n      // Spelled out per period value instead of a ternary on the month count:\n      // an undeclared `period` is refused BY NAME by the picklist (\"Period must\n      // be one of: month, quarter\", measured), so this rule judges only the two\n      // values it understands and leaves the rest to the schema.\n      condition: P`has(record.period) && record.period != null && has(record.period_start) && record.period_start != null && has(record.period_end) && record.period_end != null && ((record.period == \"month\" && daysBetween(record.period_end, addDays(addMonths(record.period_start, 1), -1)) != 0) || (record.period == \"quarter\" && daysBetween(record.period_end, addDays(addMonths(record.period_start, 3), -1)) != 0))`,\n    },\n    {\n      name: 'snapshot_amounts_non_negative',\n      type: 'script',\n      severity: 'error',\n      message: 'Snapshot amounts cannot be negative.',\n      condition: P`(has(record.pipeline_amount) && record.pipeline_amount != null && record.pipeline_amount < 0) || (has(record.best_case_amount) && record.best_case_amount != null && record.best_case_amount < 0) || (has(record.commit_amount) && record.commit_amount != null && record.commit_amount < 0) || (has(record.closed_amount) && record.closed_amount != null && record.closed_amount < 0)`,\n    },\n  ],\n});\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/sales/objects/lead.object.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/sales/objects\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/sales/objects/lead.object.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport { ObjectSchema, Field } from '@objectstack/spec/data';\nimport { F, P } from '@objectstack/spec';\nimport {\n  SALUTATION_OPTIONS,\n  INDUSTRY_OPTIONS,\n  LEAD_SOURCE_OPTIONS,\n  LEAD_NEED_TYPE_OPTIONS,\n  DUPLICATE_OF_TYPE_OPTIONS,\n} from './_picklists';\n\nexport const Lead = ObjectSchema.create({\n  name: 'crm_lead',\n  label: 'Lead',\n  pluralLabel: 'Leads',\n  icon: 'user-plus',\n  description: 'Potential customers not yet qualified',\n\n  // ADR-0090 D1/D7: OWD is an authored decision. Owner-worked queue.\n  sharingModel: 'private',\n  \n  fieldGroups: [\n    { key: 'identity',     label: 'Identity',           icon: 'user-plus' },\n    { key: 'company_info', label: 'Company Information', icon: 'building' },\n    { key: 'contact_info', label: 'Contact Information', icon: 'phone' },\n    { key: 'qualification', label: 'Qualification',     icon: 'star' },\n    { key: 'assignment',   label: 'Assignment',         icon: 'user' },\n    { key: 'address',      label: 'Address',            icon: 'map-pin', collapse: 'collapsed' },\n    { key: 'additional',   label: 'Additional Info',    icon: 'info', collapse: 'collapsed' },\n    { key: 'preferences',  label: 'Communication Preferences', icon: 'bell-off', collapse: 'collapsed' },\n    { key: 'conversion',   label: 'Conversion',         icon: 'check-circle', collapse: 'collapsed' },\n    { key: 'duplicates',   label: 'Duplicate Management', icon: 'copy', collapse: 'collapsed' },\n  ],\n\n  fields: {\n    // Platform ownership anchor \u2014 canonical note in `account.object.ts` (#548).\n    owner_id: Field.lookup('sys_user', {\n      label: 'Lead Owner',\n      group: 'assignment',\n      system: true,\n      readonly: false,\n      trackHistory: true,\n    }),\n\n    // Personal Information\n    salutation: Field.select({\n      label: 'Salutation',\n      group: 'identity',\n      // Canonical set shared with Contact (#490) \u2014 see _picklists.ts.\n      options: [...SALUTATION_OPTIONS],\n    }),\n\n    first_name: Field.text({\n      label: 'First Name',\n      required: true,\n      storage: { notNull: true },\n      searchable: true,\n      group: 'identity',\n    }),\n\n    last_name: Field.text({\n      label: 'Last Name',\n      required: true,\n      storage: { notNull: true },\n      searchable: true,\n      group: 'identity',\n    }),\n\n    // \u26A0\uFE0F `salutation` is a picklist, so a formula sees the raw VALUE (`ms`,\n    // `dr`), not the label \u2014 including it renders names as \"ms Emily Davis\" in\n    // lists and details. Dropped here and from `display_title` below, matching\n    // Contact.\n    full_name: Field.formula({\n      label: 'Full Name',\n      expression: F`joinNonEmpty([record.first_name, record.last_name], ' ')`,\n      group: 'identity',\n    }),\n\n    // ADR-0079 record title (was titleFormat '{full_name} - {company}').\n    // Composed from the same source fields as `full_name` (not formula-on-formula)\n    // plus `company`, so the title resolves from real stored values.\n    display_title: Field.formula({\n      label: 'Display Title',\n      expression: F`joinNonEmpty([record.first_name, record.last_name], ' ') + \" - \" + record.company`,\n      group: 'identity',\n    }),\n\n    // Company Information\n    company: Field.text({\n      label: 'Company',\n      required: true,\n      storage: { notNull: true },\n      searchable: true,\n      group: 'company_info',\n    }),\n\n    /**\n     * Case- and whitespace-folded copy of `company` \u2014 the value lead conversion\n     * compares against `crm_account.name_normalized`.\n     *\n     * ### Why the LEAD needs one too\n     *\n     * \u26A0\uFE0F A normalized column on `crm_account` alone fixes nothing: the\n     * conversion flow would then compare a raw company string against a folded\n     * account name, and `\"ACME  Corp\"` still would not match `acme corp`. Both\n     * sides have to be canonical, and the flow can canonicalize neither \u2014\n     * `service-automation`'s `resolveToken` accepts exactly one function form\n     * (`NOW()` / `TODAY()`), so `{LOWER(x)}`, `{TRIM(x)}` and\n     * `{x.toLowerCase()}` all resolve to `undefined`. See the field comment on\n     * `crm_account.name_normalized` for the full measurement.\n     *\n     * `company` itself is NOT folded in place: it is the display value, it is\n     * copied verbatim onto the account the conversion creates, and lower-casing\n     * it would ship `acme corp` as a customer-visible account name. That is the\n     * one way this differs from `email`, which has no meaningful case and so is\n     * canonicalized in place.\n     *\n     * Derived, never authored: `lead_duplicate_check` recomputes it on every\n     * write that carries `company`. Not indexed \u2014 nothing filters on it; it is\n     * read off the lead record the flow already fetched.\n     */\n    company_normalized: Field.text({\n      label: 'Company (Normalized)',\n      description:\n        'Match key for lead conversion: Company lower-cased, trimmed, with internal whitespace collapsed. Maintained by the lead_duplicate_check hook \u2014 never edit directly.',\n      readonly: true,\n      hidden: true,\n      maxLength: 255,\n      group: 'company_info',\n    }),\n\n    title: Field.text({\n      label: 'Job Title',\n      group: 'company_info',\n    }),\n\n    industry: Field.select({\n      label: 'Industry',\n      group: 'company_info',\n      // Canonical set shared with Account (#490): lead_conversion copies this\n      // value onto the created Account, so both objects MUST agree.\n      options: [...INDUSTRY_OPTIONS],\n    }),\n\n    // \u26A0\uFE0F NOT `unique`. A hard uniqueness constraint on a lead's email says a\n    // person may enquire once, ever, and the database enforces it by REJECTING\n    // the second enquiry \u2014 turning an ordinary follow-up into a 500 on the\n    // public form. Real funnels re-capture the same address routinely.\n    // Duplicates are a fact to be RECORDED, not an error: `lead_duplicate_check`\n    // in lead.hook.ts links the new lead to the record it repeats (see the\n    // `duplicates` field group below). The plain index below is what keeps the\n    // column indexed in the constraint's absence \u2014 the intake dedupe lookup, the\n    // `crm_lead_import` upsert key and the conversion flow all read leads by\n    // email on every write.\n    email: Field.email({\n      label: 'Email',\n      required: true,\n      storage: { notNull: true },\n      group: 'contact_info',\n    }),\n\n    phone: Field.text({\n      label: 'Phone',\n      format: 'phone',\n      group: 'contact_info',\n    }),\n\n    mobile: Field.text({\n      label: 'Mobile',\n      format: 'phone',\n      group: 'contact_info',\n    }),\n\n    website: Field.url({\n      label: 'Website',\n      group: 'contact_info',\n    }),\n\n    // Lead Qualification\n    status: Field.select({\n      label: 'Lead Status',\n      required: true,\n      storage: { notNull: true },\n      group: 'qualification',\n      trackHistory: true,\n      // Field-level default: option-level `default: true` only preselects in\n      // UI forms after first paint; the quick-create dialog and API inserts\n      // need a real defaultValue (see approval_status for the same lesson).\n      defaultValue: 'new',\n      options: [\n        { label: 'New', value: 'new', color: '#808080', default: true },\n        { label: 'Contacted', value: 'contacted', color: '#FFA500' },\n        { label: 'Qualified', value: 'qualified', color: '#4169E1' },\n        { label: 'Unqualified', value: 'unqualified', color: '#FF0000' },\n        { label: 'Converted', value: 'converted', color: '#00AA00' },\n      ]\n    }),\n\n    rating: Field.rating(5, {\n      label: 'Lead Score',\n      description: 'Lead quality score (1-5 stars)',\n      group: 'qualification',\n    }),\n\n    lead_source: Field.select({\n      label: 'Lead Source',\n      group: 'qualification',\n      // Canonical set shared with Contact + Opportunity (#490): lead_conversion\n      // copies this value onto the created Opportunity, so all three MUST agree.\n      options: [...LEAD_SOURCE_OPTIONS],\n    }),\n\n    // \u2500\u2500 Demand: what this prospect wants, and what it is worth \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n    //\n    // REQ-0005 steps 6-7. Both fields are in `qualification` because they ARE\n    // qualification data \u2014 what the buyer is asking for and how big it is are\n    // the two facts a rep weighs before working a lead \u2014 and neither is\n    // required: a lead captured off the public form has neither, and saves\n    // exactly as it did before.\n\n    need_type: Field.select({\n      label: 'Need Type',\n      group: 'qualification',\n      description: 'What this prospect is asking for. Routing, prioritisation and demand reporting read this.',\n      // Generic starter vocabulary, declared once in `_picklists.ts` \u2014 see the\n      // note there for why it is NOT shared with `crm_opportunity.type`.\n      options: [...LEAD_NEED_TYPE_OPTIONS],\n    }),\n\n    // \u26D4 NEVER conflated with `annual_revenue`, which sits two groups below in\n    // `additional` and answers a different question: that is the prospect\n    // COMPANY's own turnover, a size signal, and it is the value\n    // `lead_conversion` copies onto the account it creates. This is the value\n    // of the DEMAND \u2014 the number that becomes `crm_opportunity.amount` when the\n    // lead converts, and the only figure the pipeline has before then.\n    //\n    // \u26D4 Nor is it a second copy of `crm_opportunity.amount`. The opportunity's\n    // amount is a committed deal figure a rep defends in a forecast; this is an\n    // estimate taken before qualification, and the conversion screen is where a\n    // human turns one into the other (it PREFILLS from here \u2014 see the\n    // `opportunityAmount` screen field in `lead-conversion.flow.ts` \u2014 rather\n    // than copying silently, so the rep confirms the number that enters the\n    // forecast).\n    estimated_amount: Field.currency({\n      label: 'Estimated Amount',\n      group: 'qualification',\n      description: 'Estimated value of this demand, before qualification. Prefills the deal amount at conversion.',\n    }),\n\n    // \u2500\u2500 The conversion approval gate (REQ-0005 step 7) \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n    //\n    // \u26A0\uFE0F `defaultValue: 'not_required'` IS THE GATE'S OFF SWITCH, and it is the\n    // one line an install changes to arm it. REQ-0005: \"The gate must be\n    // configurable \u2014 off by default. A single-seller install must not be forced\n    // through an approval to convert a lead.\"\n    //\n    //   OFF (shipped)  every lead is born `not_required`; nothing ever writes\n    //                  `pending`, so `lead_conversion_approval` never enters,\n    //                  the Convert button never hides and the write-path gate in\n    //                  `lead.hook.ts` never fires. Conversion behaves EXACTLY as\n    //                  it did before this field existed.\n    //   ON             change this one value to `'pending'`. Every lead is then\n    //                  born pending, `lead_conversion_approval` opens its\n    //                  request, and conversion is refused until an approver\n    //                  decides.\n    //\n    // Leads that predate the switch keep whatever they were born with, which is\n    // the point: arming the gate does not invalidate or re-open a single\n    // existing record (REQ-0005 acceptance 4). This is a TRANSITION GATE, not an\n    // invariant (AGENTS.md metadata semantics rule 7) \u2014 what is refused is the\n    // ACT of converting, evaluated against `previous` in `lead.hook.ts`, never\n    // the state of a record that is already converted.\n    //\n    // Shape copied from `crm_opportunity.approval_status`: `readonly: true`\n    // plus a REAL field-level `defaultValue`, \u26D4 not only an option-level\n    // `default: true` \u2014 the same lesson `status` above records, and the reason\n    // that field's own comment gives: an option default only preselects in UI\n    // forms after first paint, so a quick-create dialog or an API insert would\n    // land a null and a null matches no flow entry condition.\n    //\n    // \u26D4 Do NOT add an \"approved\" value to `status` instead. That select is the\n    // qualification lifecycle; a sixth value there would break the\n    // `convert_lead` predicate, the `lead_status_progression` transitions and\n    // the seeded rows, and would conflate \"this lead is worth working\" with\n    // \"someone signed off on converting it\".\n    conversion_approval_status: Field.select({\n      label: 'Conversion Approval',\n      group: 'qualification',\n      readonly: true,\n      trackHistory: true,\n      description:\n        'Whether this lead has been signed off for conversion. Not Required means no approval is asked for \u2014 the shipped default.',\n      defaultValue: 'not_required',\n      options: [\n        { label: 'Not Required', value: 'not_required', default: true },\n        { label: 'Pending', value: 'pending', color: '#FFA500' },\n        { label: 'Approved', value: 'approved', color: '#00AA00' },\n        { label: 'Rejected', value: 'rejected', color: '#FF0000' },\n      ],\n    }),\n\n    // Assignment\n\n    // Conversion tracking.\n    // \u26D4 NOT `readonly`: the `lead_conversion` flow's `mark_converted` node\n    // UPDATEs this column and the four `converted_*` ones below, and that flow\n    // declares no `runAs` \u2014 so it runs at the engine default `'user'`, which is\n    // also where house rule 9 keeps a screen flow. `stripReadonlyFields` runs\n    // under `if (!opCtx.context?.isSystem)` and deletes every readonly key the\n    // CALLER supplied, so `readonly` here would silently un-convert every\n    // conversion.\n    // \u26A0\uFE0F The other writer is unaffected, and is not the reason: the\n    // guest-submission sanitiser in `lead.hook.ts` ASSIGNS these on\n    // `beforeInsert`, and hook-written keys are not caller-supplied \u2014 nor does\n    // the strip run on INSERT at all. Measured in\n    // `test/readonly-write-semantics.test.ts`.\n    // \u21D2 Declaring these `readonly` would need the flow's write ELEVATED, which\n    // is a privilege decision on the maintainer's floor, not this file's (#1435).\n    // Edit-protection is the `beforeUpdate` guard in `lead.hook.ts`, which\n    // rejects any USER edit to a converted lead outside a small allow-list \u2014\n    // and it is the ONLY guard, deliberately: a script validation beside it\n    // never fires, because the hook's throw always wins the race.\n    is_converted: Field.boolean({\n      label: 'Converted',\n      defaultValue: false,\n      group: 'conversion',\n      trackHistory: true,\n    }),\n\n    converted_account: Field.lookup('crm_account', {\n      label: 'Converted Account',\n      group: 'conversion',\n    }),\n\n    converted_contact: Field.lookup('crm_contact', {\n      label: 'Converted Contact',\n      group: 'conversion',\n    }),\n\n    converted_opportunity: Field.lookup('crm_opportunity', {\n      label: 'Converted Opportunity',\n      group: 'conversion',\n    }),\n\n    converted_date: Field.datetime({\n      label: 'Converted Date',\n      group: 'conversion',\n    }),\n\n    // Address (using new address field type)\n    address: Field.address({\n      label: 'Address',\n      group: 'address',\n    }),\n\n    // Additional Info\n    annual_revenue: Field.currency({\n      label: 'Annual Revenue',\n      group: 'additional',\n    }),\n\n    number_of_employees: Field.number({\n      label: 'Number of Employees',\n      group: 'additional',\n    }),\n\n    description: Field.markdown({\n      label: 'Description',\n      group: 'additional',\n    }),\n\n    // Custom notes with rich text formatting\n    notes: Field.richtext({\n      label: 'Notes',\n      description: 'Working notes on this lead \u2014 supports formatting.',\n      group: 'additional',\n    }),\n\n    // Flags\n    do_not_call: Field.boolean({\n      label: 'Do Not Call',\n      defaultValue: false,\n      group: 'preferences',\n    }),\n\n    email_opt_out: Field.boolean({\n      label: 'Email Opt Out',\n      defaultValue: false,\n      group: 'preferences',\n    }),\n\n    // Follow-up & disqualification tracking\n    next_followup_date: Field.date({\n      label: 'Next Follow-up Date',\n      group: 'qualification',\n    }),\n\n    // NOT `readonly` (#592) \u2014 see the long note on\n    // `crm_account.last_activity_date`. The activity bubble writes this from\n    // another object's hook, and a readonly field is stripped from any\n    // non-system write whose caller supplied the key (#2948), so every bubble\n    // into this column was silently discarded.\n    last_contacted_date: Field.datetime({\n      label: 'Last Contacted',\n      group: 'qualification',\n    }),\n\n    disqualification_reason: Field.select({\n      label: 'Disqualification Reason',\n      group: 'qualification',\n      description: 'Required when status is Unqualified',\n      options: [\n        { label: 'Not a Fit',         value: 'not_a_fit' },\n        { label: 'No Budget',         value: 'no_budget' },\n        { label: 'Wrong Persona',     value: 'wrong_persona' },\n        { label: 'Unreachable',       value: 'unreachable' },\n        { label: 'Duplicate',         value: 'duplicate' },\n        { label: 'Competitor',        value: 'competitor' },\n        { label: 'Other',             value: 'other' },\n      ],\n    }),\n\n    // \u2500\u2500 Duplicate management \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n    //\n    // `disqualification_reason: 'duplicate'` is only meaningful if the record\n    // says WHAT it duplicates \u2014 otherwise the \"duplicate\" bar on the\n    // disqualification breakdown points at nothing you can open.\n    //\n    // \u26A0\uFE0F The surviving record can live on either object \u2014 a still-open lead, or\n    // a contact the prospect already became \u2014 and `Field.lookup` takes exactly\n    // one target (`Field.lookup(['crm_lead','crm_contact'])` is rejected at\n    // schema parse: \"reference: expected string, received array\"). So the link\n    // is the same TYPE-DISCRIMINATOR shape `crm_task.related_to_*` already uses:\n    // one select naming the object, one lookup per object, and the pairing\n    // enforced declaratively.\n    //\n    // The vocabulary is TWO sets, declared and split in `_picklists.ts`: the two\n    // object names an author may pick, plus `erased` \u2014 a tombstone the form does\n    // not offer and only `lead_duplicate_check` ever writes.\n    //\n    // The tombstone is what lets an erasure COMPLETE against a lead a human\n    // confirmed as a duplicate, without relaxing one rule, so read it as a\n    // constraint rather than as a spare value: `requiredWhen` below pairs only\n    // `crm_lead` / `crm_contact`, so a tombstoned type never fires either\n    // pairing and never demands a pointer to a record that is gone; and\n    // `duplicate_disqualification_requires_survivor` asks for a NON-BLANK type\n    // plus `duplicate_status == \"confirmed\"`, both of which a tombstoned lead\n    // still satisfies \u2014 so the verdict a reviewer recorded survives the erasure\n    // instead of being deleted as a side effect of someone else's GDPR request.\n    duplicate_of_type: Field.select({\n      label: 'Duplicate Of',\n      group: 'duplicates',\n      description: 'Which object holds the surviving record this lead repeats.',\n      options: [...DUPLICATE_OF_TYPE_OPTIONS],\n    }),\n\n    // \u26A0\uFE0F The type\u2194lookup pairing is `requiredWhen`, not a script validation:\n    // \"the lookup named by the type must be populated\" is exactly a conditional\n    // write contract, the engine evaluates it on insert and update, and it\n    // reports against the FIELD, so the form marks the empty lookup instead of\n    // showing a record-level error. (`crm_task` states the same intent as a\n    // warning-severity script rule because it predates `requiredWhen`,\n    // ADR-0113.)\n    //\n    // \u26A0\uFE0F `has(...)` is load-bearing, not decoration. A bare\n    // `record.duplicate_of_type == \"crm_lead\"` aborts with `No such key` on any\n    // record whose merged shape omits the column, and the engine's response to a\n    // predicate that fails to evaluate is to SKIP it (\"requiredWhen for\n    // 'duplicate_of_lead' failed to evaluate \u2014 skipped\"). The rule would then\n    // read as enforced and require nothing at all.\n    //\n    // \u26A0\uFE0F Both lookups take the spec default `deleteBehavior: 'set_null'`, and\n    // that is deliberate: a lead is a first-class record that happens to carry a\n    // flag, so `cascade` would destroy the lead because the record it was\n    // compared against was deleted. What keeps the pairing honest under a\n    // `set_null` clear is the retirement block in `lead_duplicate_check`\n    // (`lead.hook.ts`, job 1c): when a write leaves the named lookup blank it\n    // drops `duplicate_of_type` and `duplicate_status` in the same write, so the\n    // pair is never left half-stated and this rule never has to be loosened to\n    // tolerate one. Read that note before changing either predicate.\n    duplicate_of_lead: Field.lookup('crm_lead', {\n      label: 'Duplicate Of Lead',\n      group: 'duplicates',\n      requiredWhen: P`has(record.duplicate_of_type) && record.duplicate_of_type == \"crm_lead\"`,\n    }),\n\n    duplicate_of_contact: Field.lookup('crm_contact', {\n      label: 'Duplicate Of Contact',\n      group: 'duplicates',\n      requiredWhen: P`has(record.duplicate_of_type) && record.duplicate_of_type == \"crm_contact\"`,\n    }),\n\n    // Machine suspicion and human verdict are ONE field with two values, not two\n    // parallel sets of link fields: the intake hook writes `suspected` and only\n    // ever when this is blank (lead.hook.ts), so a human's `confirmed` survives\n    // every later write, and both states stay queryable off one column.\n    duplicate_status: Field.select({\n      label: 'Duplicate Status',\n      group: 'duplicates',\n      trackHistory: true,\n      description:\n        'Suspected = flagged automatically at intake. Confirmed = a human verified the match.',\n      options: [\n        { label: 'Suspected', value: 'suspected', color: '#FFA500' },\n        { label: 'Confirmed', value: 'confirmed', color: '#FF0000' },\n      ],\n    }),\n  },\n\n  // Lifecycle transitions are enforced via a `state_machine` validation rule\n  // (see validations[] below). \u26A0\uFE0F There is no top-level `stateMachines` key on\n  // the platform \u2014 status state machines are expressed in the validation union.\n\n  // Database indexes for performance\n  //\n  // \u26A0\uFE0F `email` is indexed but NOT unique, and the index must stay explicit: it\n  // used to exist only as a side effect of a field-level `unique: true`, so\n  // dropping that constraint would otherwise have dropped the index with it and\n  // left three read paths \u2014 the `lead_duplicate_check` intake lookup, the\n  // `crm_lead_import` upsert key and the conversion flow \u2014 scanning the table\n  // on every write.\n  //\n  // \u26D4 Do NOT add `unique: true` back here: a single-column unique index makes\n  // the platform-wide constraint win over the per-tenant composite\n  // (framework#3991), so two organizations could not work the same address\n  // independently. Uniqueness is not the rule this object wants at all.\n  indexes: [\n    { fields: ['owner_id'] },\n    { fields: ['status'] },\n    { fields: ['company'] },\n    { fields: ['email'] },\n  ],\n  \n  // API surface. History \u2192 Field.trackHistory (ADR-0052).\n  enable: {\n    apiEnabled: true,\n  },\n  \n  // ADR-0079 record title \u2014 the `display_title` formula field defined above.\n  nameField: 'display_title',\n  // Explicit search targets (ADR-0061). REQUIRED because nameField is a\n  // FORMULA (display_title/full_name): without this, $search auto-defaults to\n  // the formula field, which isn't a real column, so the lookup picker + global\n  // search silently return zero. These are real, indexed columns.\n  searchableFields: ['first_name', 'last_name', 'company', 'email'],\n  highlightFields: ['full_name', 'company', 'email', 'status', 'owner_id'],\n  \n  // Removed: list_views and form_views belong in UI configuration, not object definition\n  \n  // Predicates below are TOTAL: every `record.x` read is `has()`-guarded, so the\n  // rule returns a verdict even when the merged record has no such key. See\n  // AGENTS.md \"Validation predicates must be TOTAL\" and\n  // test/object-validation-predicates.test.ts, which fails the build otherwise.\n  validations: [\n    {\n      name: 'email_required',\n      type: 'script',\n      severity: 'error',\n      message: 'Email is required',\n      condition: P`!has(record.email) || isBlank(record.email)`,\n    },\n    {\n      // The field description promises \"Required when status is Unqualified\";\n      // this is what enforces it. A lead in `unqualified` with no recorded\n      // reason loses the one datum a disqualification review needs. Same shape\n      // as `crm_case.escalation_reason_required`.\n      name: 'disqualification_reason_required',\n      type: 'script',\n      severity: 'error',\n      message: 'Disqualification reason is required when a lead is Unqualified',\n      condition: P`has(record.status) && record.status == \"unqualified\" && (!has(record.disqualification_reason) || isBlank(record.disqualification_reason))`,\n    },\n    {\n      // \"Disqualified as a duplicate\" has to name the survivor.\n      //\n      // Same shape as `disqualification_reason_required` directly above \u2014 a\n      // declarative condition evaluated by the engine on insert and update, with\n      // no hook involved. The two clauses are the two things the field-level\n      // `requiredWhen` on the lookups cannot say:\n      //\n      //   1. `duplicate_of_type` must be chosen, which is what makes exactly one\n      //      of the two `requiredWhen` predicates fire and demand its lookup.\n      //   2. `duplicate_status` must be `confirmed` SPECIFICALLY. `requiredWhen`\n      //      asks whether a field is populated, not what it holds \u2014 and a lead\n      //      closed on the machine's `suspected` guess is precisely the outcome\n      //      this rule exists to prevent. A human has to look and agree.\n      //\n      // \u26A0\uFE0F Every field reference is wrapped in `has(...)`, and that is what makes\n      // this an enforced rule rather than a decorative one. The engine evaluates\n      // a validation against `{...previous, ...data}` and fills absent fields\n      // with null on INSERT \u2014 but not on UPDATE, where `previous` is whatever\n      // the driver returned, and a driver that stores only the columns a row was\n      // written with hands back a record with no `duplicate_status` key at all.\n      // Strict CEL then aborts the whole predicate with `No such key`, and a\n      // predicate that fails to evaluate is SKIPPED, not failed:\n      //\n      //     WARN Validation rule '\u2026' predicate failed to evaluate (\u2026) \u2014 skipped\n      //\n      // The unguarded first draft of this rule let a lead be closed as a\n      // duplicate with no survivor named, silently, on the in-memory driver \u2014\n      // the driver the whole test suite runs on.\n      name: 'duplicate_disqualification_requires_survivor',\n      type: 'script',\n      severity: 'error',\n      message:\n        'Disqualifying a lead as Duplicate requires naming the surviving record and setting Duplicate Status to Confirmed',\n      condition: P`has(record.disqualification_reason) && record.disqualification_reason == \"duplicate\" && !(has(record.duplicate_of_type) && !isBlank(record.duplicate_of_type) && has(record.duplicate_status) && record.duplicate_status == \"confirmed\")`,\n    },\n    {\n      name: 'lead_status_progression',\n      type: 'state_machine',\n      severity: 'warning',\n      message: 'Invalid lead status transition',\n      field: 'status',\n      // Conversion (\u2192 converted) is allowed from any worked-open status so the\n      // Convert action's widened visibility (new/contacted/qualified) never trips\n      // a spurious \"invalid transition\" warning when the flow stamps\n      // status:'converted'.\n      transitions: {\n        new: ['contacted', 'qualified', 'unqualified', 'converted'],\n        contacted: ['qualified', 'unqualified', 'converted'],\n        qualified: ['converted', 'unqualified'],\n        unqualified: ['new'],\n        converted: [],\n      },\n    },\n  ],\n  \n  // \u26A0\uFE0F No `workflows[]` here, and none is possible: object `workflows[]` were\n  // removed from the platform. Field updates live in this object's `*.hook.ts`;\n  // scheduled status flips and notifications live in `src/*/flows/*.flow.ts`.\n});\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/sales/objects/opportunity.object.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/sales/objects\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/sales/objects/opportunity.object.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport { ObjectSchema, Field } from '@objectstack/spec/data';\nimport { F, P } from '@objectstack/spec';\nimport { LEAD_SOURCE_OPTIONS, OPPORTUNITY_STAGE_OPTIONS } from './_picklists';\n\nexport const Opportunity = ObjectSchema.create({\n  name: 'crm_opportunity',\n  label: 'Opportunity',\n  pluralLabel: 'Opportunities',\n  icon: 'dollar-sign',\n  description: 'Sales opportunities and deals in the pipeline',\n\n  // ADR-0090 D1/D7: OWD is an authored decision. Owner + high-value management sharing rule.\n  sharingModel: 'private',\n  // \u26A0\uFE0F ADR-0079 `nameField` is a FIELD, not a render template, and a FORMULA\n  // sees the stored select VALUE rather than its translated label \u2014 so a\n  // `'{name} - {stage}'` title renders every deal \"Enterprise Deal -\n  // closed_won\" in lookups, related lists and search, in every locale. The\n  // formula language has no option-label lookup, so the title is the plain\n  // `name` column; `stage` still leads the highlight strip below, translated.\n  nameField: 'name',\n  // Explicit search targets (ADR-0061). `name` is a real indexed column, so\n  // $search resolves on its own here; the list is kept explicit to pin the\n  // intent (other objects whose nameField IS a formula rely on it).\n  searchableFields: ['name'],\n  highlightFields: ['name', 'crm_account', 'amount', 'stage', 'owner_id'],\n\n  fieldGroups: [\n    { key: 'basic',       label: 'Basic Information',   icon: 'dollar-sign' },\n    { key: 'financials',  label: 'Financials',          icon: 'trending-up' },\n    { key: 'sales_process', label: 'Sales Process',     icon: 'target' },\n    { key: 'qualification', label: 'Qualification',     icon: 'filter' },\n    { key: 'narrative',   label: 'Deal Narrative',      icon: 'book-open' },\n    { key: 'classification', label: 'Classification',   icon: 'tag' },\n    { key: 'campaign', label: 'Campaigns', icon: 'flag', collapse: 'collapsed' },\n    { key: 'notes',       label: 'Notes & Next Steps',  icon: 'file-text' },\n    { key: 'crm_forecast',    label: 'Forecast & Metrics',  icon: 'bar-chart', collapse: 'collapsed' },\n  ],\n\n  fields: {\n    // Platform ownership anchor \u2014 canonical note in `account.object.ts` (#548).\n    owner_id: Field.lookup('sys_user', {\n      label: 'Opportunity Owner',\n      group: 'basic',\n      system: true,\n      readonly: false,\n      trackHistory: true,\n    }),\n\n    // Basic Information\n    name: Field.text({\n      label: 'Opportunity Name',\n      required: true,\n      storage: { notNull: true },\n      searchable: true,\n      group: 'basic',\n    }),\n\n    // (No `display_title` formula \u2014 see `nameField` above: composing the title\n    // from `stage` leaked the raw select value into every rendered title.)\n\n    // Relationships\n    crm_account: Field.lookup('crm_account', {\n      label: 'Account',\n      required: true,\n      storage: { notNull: true },\n      group: 'basic',\n    }),\n\n    primary_contact: Field.lookup('crm_contact', {\n      label: 'Primary Contact',\n      // @objectstack 12: string[] `referenceFilters` is dead (not read by the\n      // picker); `dependsOn` is the live cascading form \u2014 scopes contacts to the\n      // opportunity's `crm_account` (ADR-0049).\n      dependsOn: ['crm_account'],\n      group: 'basic',\n    }),\n\n\n    // Financial Information\n    amount: Field.currency({\n      label: 'Amount',\n      required: true,\n      storage: { notNull: true },\n      min: 0,\n      group: 'financials',\n      trackHistory: true,\n    }),\n\n    expected_revenue: Field.currency({\n      label: 'Expected Revenue',\n      readonly: true,  // Calculated field\n      group: 'financials',\n    }),\n\n    // \u2500\u2500\u2500 Qualification (REQ-0006 step 8) \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n    //\n    // The standard triage vocabulary of a seller that cannot pursue every\n    // deal. `forecast_category` answers a different question \u2014 it is the\n    // forecast roll-up bucket, derived from `stage` \u2014 so none of this is\n    // folded into it. GENERIC values only: a customer's own grading scale is\n    // overlay configuration (REQ-0006 acceptance 5).\n    //\n    // \u26A0\uFE0F `pnpm validate` reports the fields in this block, in the narrative\n    // block below, and the customer-side dates as \"carrier-only \u2014 declared\n    // but nothing in this stack reads or displays it\", and that reading is\n    // EXPECTED here rather than a defect to tidy away. The liveness\n    // diagnostic counts view columns, form sections, page bindings, flow\n    // nodes, formulas, hooks and actions as sites; it does NOT count\n    // `fieldGroups` membership, which is precisely the DERIVED layout\n    // REQ-0006 acceptance 1 asks for. \u26D4 Do NOT answer the warning by\n    // authoring a `record:details` section \u2014 that is the escape hatch\n    // AGENTS.md reserves for a named customer demand, and it would trade\n    // acceptance 1 for a quieter log. `crm_account`'s business-profile block\n    // carries the same verdict on `main` for the same reason (#1948).\n    will_bid: Field.boolean({\n      label: 'Will Bid',\n      description: 'Whether we intend to bid. Unset means the decision is open.',\n      group: 'qualification',\n    }),\n\n    controllability: Field.select({\n      label: 'Controllability',\n      group: 'qualification',\n      options: [\n        { label: 'High', value: 'high' },\n        { label: 'Medium', value: 'medium' },\n        { label: 'Low', value: 'low' },\n      ],\n    }),\n\n    priority: Field.select({\n      label: 'Priority',\n      group: 'qualification',\n      options: [\n        { label: 'High', value: 'high' },\n        { label: 'Medium', value: 'medium' },\n        { label: 'Low', value: 'low' },\n      ],\n    }),\n\n    deal_level: Field.select({\n      label: 'Deal Level',\n      group: 'qualification',\n      options: [\n        { label: 'Strategic', value: 'strategic' },\n        { label: 'Key', value: 'key' },\n        { label: 'Standard', value: 'standard' },\n      ],\n    }),\n\n    // The FACT of subcontracting is generic and belongs in core; the\n    // customer's supplier list is not and is not proposed here.\n    is_subcontracted: Field.boolean({\n      label: 'Involves Subcontracting',\n      defaultValue: false,\n      group: 'qualification',\n    }),\n\n    subcontracting_note: Field.textarea({\n      label: 'Subcontracting Note',\n      group: 'qualification',\n    }),\n\n    // \u2500\u2500\u2500 The \u7ACB\u9879 (qualification) gate: the rep's request \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n    //\n    // REQ-0006 step 11: \u300C\u9500\u552E\u7ACB\u9879\u9700\u8D70\u5BA1\u6279\u6D41\u7A0B\uFF1B\u65B0\u589E\u5546\u673A\u53EF\u8DDF\u8FDB\uFF0C\u7ACB\u9879\u901A\u8FC7\u540E\u65B9\u53EF\u66F4\u65B0\u9636\u6BB5\u3001\n    // \u6295\u6807\u3001\u8D62\u4E22\u5355\u64CD\u4F5C\u3002\u300D The rep ASKS for \u7ACB\u9879 by ticking this box, and\n    // `opportunity_qualification_approval` opens one approval when it turns on\n    // (the TRANSITION, not the current value). A rejection clears it, so\n    // ticking it again is a fresh request \u2014 the role `requested_status` plays\n    // for the status-change gate, as a boolean because \u7ACB\u9879 asks for one thing.\n    //\n    // `defaultValue: false` is load-bearing for the start condition: every deal\n    // born after this column then STORES the key, so `has(previous.\u2026)` holds\n    // on every driver and the off\u2192on transition is visible. Not readonly: this\n    // is the one half of the gate a person writes. Inert while the gate is\n    // off \u2014 nothing reads it unless an install arms the verdict below.\n    qualification_requested: Field.boolean({\n      label: 'Request Qualification Approval',\n      description: 'Tick to send this deal for qualification approval. A rejection clears it; tick it again to ask again.',\n      defaultValue: false,\n      group: 'qualification',\n    }),\n\n    // \u2500\u2500\u2500 The \u7ACB\u9879 gate's switch AND its verdict column \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n    //\n    // \u26A0\uFE0F This `defaultValue` IS the switch, exactly as on\n    // `status_change_approval_status` below, and shipped it is `not_required`:\n    // the gate is OFF by default (REQ-0006 *Disposition*: \"Both gates must be\n    // configurable \u2014 off by default\"). No deal is born `pending`, the flow's\n    // start condition and the `opportunity_lifecycle` refusal are false for\n    // every record that has ever existed, and a stage move, Will Bid and a\n    // direct close work exactly as they do without it. An install ARMS the gate\n    // by changing this one value to `'pending'`; deals that already exist keep\n    // `not_required`, so arming it invalidates no record. \u26D4 Not the flow's\n    // `status` \u2014 `lead-conversion-approval.flow.ts` records why.\n    //\n    // \u26A0\uFE0F Its OWN column \u2014 \u26D4 never `approval_status` (the amount-tiered\n    // flow's; its entry keys on `not_required`, so sharing would re-arm it) and\n    // \u26D4 never `status_change_approval_status` (one gate's verdict would erase\n    // the other's, and the step-14 hook reads that column input-first).\n    //\n    // `readonly: true` on the #1666 grounds: the only writers are the gate's\n    // own `runAs: 'system'` flow and the insert default, and both survive the\n    // readonly strip. A user-supplied verdict is stripped BEFORE the\n    // `beforeUpdate` hooks run \u2014 measured on 17.6.0 with a real ObjectQL: a\n    // user update of `{ stage, qualification_approval_status: 'approved' }`\n    // reached the hooks as `{ id, stage }` and was refused 409 \u2014 so the\n    // input-first read in `opportunity_lifecycle` cannot be fed an `approved`\n    // by hand.\n    qualification_approval_status: Field.select({\n      label: 'Qualification Approval',\n      group: 'qualification',\n      readonly: true,\n      defaultValue: 'not_required',\n      options: [\n        { label: 'Not Required', value: 'not_required', default: true },\n        { label: 'Pending', value: 'pending', color: '#FFA500' },\n        { label: 'Approved', value: 'approved', color: '#00AA00' },\n        { label: 'Rejected', value: 'rejected', color: '#FF0000' },\n      ],\n    }),\n\n    // Sales Process\n    stage: Field.select({\n      label: 'Stage',\n      required: true,\n      storage: { notNull: true },\n      group: 'sales_process',\n      // ADR-0052 \u00A75b.1 \u2014 the platform auto-renders each stage change on the\n      // activity timeline as \"Stage: Proposal \u2192 Negotiation\" (no hook code).\n      trackHistory: true,\n      // Canonical set (#490) \u2014 the mass_update_stage action renders the same\n      // list; see _picklists.ts.\n      options: [...OPPORTUNITY_STAGE_OPTIONS],\n    }),\n\n    probability: Field.percent({\n      label: 'Probability (%)',\n      min: 0,\n      max: 100,\n      defaultValue: 10,\n      group: 'sales_process',\n    }),\n\n    // Important Dates\n    close_date: Field.date({\n      label: 'Close Date',\n      required: true,\n      storage: { notNull: true },\n      group: 'sales_process',\n      trackHistory: true,\n    }),\n\n    // NO `created_date` here: the platform already injects `created_at` on\n    // every object, and this duplicate had no writer at all \u2014 not the seed\n    // data, not a hook, not a flow \u2014 so it was permanently null while\n    // `created_at` carried the real value (#575 B2). Surfaces that need the\n    // creation instant read `created_at` (see the deal_timeline view).\n    //\n    // Stage-age clock (#489). This is the STORED half of the pair: a real,\n    // indexed date column, so it is what automation and views may filter and\n    // sort on. `days_in_stage` below is a formula derived from it.\n    // `opportunity_lifecycle` stamps it on insert and re-stamps it on every\n    // stage change; readonly because nothing but that hook should move it\n    // (before-hook writes survive readonly stripping \u2014 only caller-supplied\n    // keys are dropped).\n    stage_entry_date: Field.date({\n      label: 'Stage Entry Date',\n      description: 'Date this opportunity entered its current stage.',\n      readonly: true,\n      group: 'sales_process',\n    }),\n\n    // \u2500\u2500\u2500 The customer's own procurement calendar (REQ-0006 step 8) \u2500\u2500\u2500\u2500\u2500\n    //\n    // \u26D4 Never folded into `close_date`: that is a single date and it is OUR\n    // expected close. These are three distinct BUYER-side events, and\n    // REQ-0006 acceptance 2 requires them to be reportable independently of\n    // the forecast close date \u2014 see the `tender_this_quarter` list view,\n    // which predicates on `expected_tender_date` alone.\n    customer_initiation_date: Field.date({\n      label: 'Customer Initiation Date',\n      group: 'sales_process',\n    }),\n\n    expected_tender_date: Field.date({\n      label: 'Expected Tender Date',\n      group: 'sales_process',\n    }),\n\n    expected_signing_date: Field.date({\n      label: 'Expected Signing Date',\n      group: 'sales_process',\n    }),\n\n    expected_tender_amount: Field.currency({\n      label: 'Expected Tender Amount',\n      min: 0,\n      group: 'sales_process',\n    }),\n\n    expected_signing_amount: Field.currency({\n      label: 'Expected Signing Amount',\n      min: 0,\n      group: 'sales_process',\n    }),\n\n    // Additional Classification\n    type: Field.select({\n      label: 'Opportunity Type',\n      group: 'classification',\n      options: [\n        { label: 'New Business', value: 'new_business' },\n        { label: 'Existing Customer - Upgrade', value: 'existing_upgrade' },\n        { label: 'Existing Customer - Renewal', value: 'existing_renewal' },\n        { label: 'Existing Customer - Expansion', value: 'existing_expansion' },\n      ]\n    }),\n\n    // \u26D4 BESIDE `type`, never replacing or overloading it: `type`'s four\n    // values are a RELATIONSHIP taxonomy that `opportunity.hook.ts` and\n    // reporting read. Generic delivery-model values only \u2014 the customer's own\n    // line-of-business list is overlay (REQ-0006 acceptance 5).\n    business_line: Field.select({\n      label: 'Business Line',\n      group: 'classification',\n      options: [\n        { label: 'Product', value: 'product' },\n        { label: 'Professional Services', value: 'services' },\n        { label: 'Consulting', value: 'consulting' },\n        { label: 'Support & Maintenance', value: 'support' },\n        { label: 'Other', value: 'other' },\n      ],\n    }),\n\n    lead_source: Field.select({\n      label: 'Lead Source',\n      group: 'classification',\n      // Canonical set shared with Lead + Contact (#490): lead_conversion\n      // copies `leadRecord.lead_source` onto the opportunity it creates, so\n      // this must accept every Lead value.\n      options: [...LEAD_SOURCE_OPTIONS],\n    }),\n\n\n    // Campaign tracking\n    crm_campaign: Field.lookup('crm_campaign', {\n      label: 'Campaign',\n      description: 'Marketing campaign that generated this opportunity',\n      group: 'campaign',\n    }),\n\n    // Sales cycle metrics\n    //\n    // \u26A0\uFE0F FORMULA, not a stored counter. As a plain number column nothing ever\n    // raises it: the hook resets it to 0 on a stage change and no sweep\n    // increments it, so `days_in_stage > 14` matches only rows a seed hardcoded\n    // and the `opportunity_stagnation` flow never fires on real data. Deriving\n    // it from `stage_entry_date` is correct on every read and costs no nightly\n    // full-table pass.\n    //\n    // \u26A0\uFE0F The trade-off: formulas are evaluated AFTER the query (the engine's\n    // `applyFormulaPlan` walks the returned rows), so this is not a real column\n    // and CANNOT appear in a filter or a sort. Anything that needs to *select*\n    // stalled deals predicates on `stage_entry_date` instead \u2014 see\n    // `opportunity-stagnation.flow.ts` and the `stale_opportunities` view.\n    //\n    // \u26A0\uFE0F `has()` + null guard: `daysBetween(null, \u2026)` faults and the whole field\n    // silently evaluates to null, so an unstamped row is spelled out as null\n    // rather than arriving there by accident.\n    days_in_stage: Field.formula({\n      label: 'Days in Current Stage',\n      expression: F`has(record.stage_entry_date) && record.stage_entry_date != null ? daysBetween(record.stage_entry_date, today()) : null`,\n      returnType: 'number',\n      group: 'crm_forecast',\n    }),\n\n    // Additional information\n    description: Field.markdown({\n      label: 'Description',\n      group: 'notes',\n    }),\n\n    next_step: Field.textarea({\n      label: 'Next Steps',\n      group: 'notes',\n    }),\n\n    // \u2500\u2500\u2500 Deal narrative (REQ-0006 step 10) \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n    //\n    // The standard deal-review narrative, split out of `description` so each\n    // part is reviewable, templatable and (later) reportable on its own \u2014\n    // \u26D4 not more prose crammed into one markdown field.\n    //\n    // \u26A0\uFE0F `payment_terms` is PROSE here and a select on `crm_quote` /\n    // `crm_contract`: what a rep records mid-pursuit is the shape of a term\n    // still being negotiated, not the net-terms ladder a signed document\n    // carries. \u26D4 Do not \"unify\" it onto PAYMENT_TERMS_OPTIONS \u2014 that would\n    // force a half-agreed term into a closed vocabulary.\n    //\n    // All four are `Field.textarea` (REQ-0006 names markdown OR textarea per\n    // field). Measured on the 17.6.0 console, the Details tab's edit mode \u2014\n    // the surface these fields render on \u2014 has no markdown editor, so a\n    // markdown field here could be read but never written. The maintainer\n    // ruled textarea for the three that were markdown (2026-10-03, on #1950:\n    // \u300C\u6539\u6210 textarea(\u63A8\u8350)\u300D).\n    customer_background: Field.textarea({\n      label: 'Customer Background',\n      group: 'narrative',\n    }),\n\n    project_background: Field.textarea({\n      label: 'Project Background',\n      group: 'narrative',\n    }),\n\n    risk_analysis: Field.textarea({\n      label: 'Risk Analysis',\n      group: 'narrative',\n    }),\n\n    payment_terms: Field.textarea({\n      label: 'Payment Terms',\n      group: 'narrative',\n    }),\n\n    // Flags\n    is_private: Field.boolean({\n      label: 'Private',\n      defaultValue: false,\n      group: 'crm_forecast',\n    }),\n\n    forecast_category: Field.select({\n      label: 'Forecast Category',\n      group: 'crm_forecast',\n      options: [\n        { label: 'Pipeline', value: 'pipeline' },\n        { label: 'Best Case', value: 'best_case' },\n        { label: 'Commit', value: 'commit' },\n        { label: 'Omitted', value: 'omitted' },\n        { label: 'Closed', value: 'closed' },\n      ]\n    }),\n\n    // Approval workflow tracking.\n    // \u2B50 `readonly: true` \u2014 DECLARED, and the declaration is the honest one\n    // rather than a hopeful one. Audited per writer (#1666): every writer of\n    // this column and of `approved_date` is elevated or an insert.\n    // `opportunity_approval` declares `runAs: 'system'`, and\n    // `opportunity_approval_on_create` inherits it by spreading that flow, so\n    // `resolveRunDataContext` hands the engine `isSystem: true` and the\n    // `if (!opCtx.context?.isSystem)` strip branch is skipped outright; the\n    // `approval` node's own `approvalStatusField` write runs inside those same\n    // system runs; seeds write on INSERT, which the strip never touches. No\n    // view, page or action writes either column. \u21D2 No writer loses its write.\n    // Ruled #1666 (director seat, decision batch #74, 2026-09-07): \"Declared =\n    // enforced\" applies to the audit surface too. \u26D4 The hand-edit escape hatch\n    // \u2014 an admin clearing a stuck approval by typing over the stamp \u2014 is given\n    // up ON PURPOSE: a stuck approval is a platform or flow defect to be fixed\n    // as one, not a reason to keep an audit stamp hand-editable. \u26D4 Do not\n    // reintroduce a bypass, and do not soften either column back to editable\n    // without a new ruling. Both halves are pinned in\n    // `test/audit-stamp-readonly.test.ts`: the system path still lands both\n    // stamps, and a plain user-context UPDATE of either is stripped.\n    // \u26A0\uFE0F `defaultValue` at FIELD level: option-level `default: true`\n    // only preselects in UI forms \u2014 API and flow inserts land null without it,\n    // and a null `approval_status` never matches the flow's entry condition.\n    approval_status: Field.select({\n      label: 'Approval Status',\n      group: 'sales_process',\n      readonly: true,\n      defaultValue: 'not_required',\n      options: [\n        { label: 'Not Required', value: 'not_required', default: true },\n        { label: 'Pending', value: 'pending', color: '#FFA500' },\n        { label: 'Approved', value: 'approved', color: '#00AA00' },\n        { label: 'Rejected', value: 'rejected', color: '#FF0000' },\n      ],\n    }),\n\n    approved_date: Field.datetime({\n      label: 'Approved Date',\n      group: 'sales_process',\n      readonly: true,\n    }),\n\n    // \u2500\u2500\u2500 The status-change gate's switch AND its verdict column \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n    //\n    // \u26A0\uFE0F This `defaultValue` IS the switch, and shipped it is `not_required`,\n    // so the gate is OFF by default \u2014 REQ-0006 acceptance 3: \"with it off\n    // (the default), the existing amount-tiered behaviour of\n    // `opportunity-approval.flow.ts` is bit-for-bit what it is today\". No\n    // record is ever born `pending`, `opportunity_status_change_approval`'s\n    // start condition is false for every row that has ever existed, and\n    // nothing about the amount-tiered flow changes. An install ARMS the gate\n    // by changing this one value to `'pending'`.\n    //\n    // \u26D4 Not the flow's `status`, for the reason\n    // `lead-conversion-approval.flow.ts` records and measured: `draft` still\n    // fires its triggers, and `obsolete` composes with the installation's\n    // activation ledger into a gate no install can ever turn ON.\n    //\n    // \u26A0\uFE0F Deliberately NOT `approval_status`. That column is the amount-tiered\n    // flow's, and sharing it would make either gate's verdict erase the\n    // other's \u2014 and re-trigger the amount flow, whose entry condition keys on\n    // `approval_status == \"not_required\"`.\n    //\n    // `readonly: true` on the same audited grounds as `approval_status`\n    // (#1666): the only writers are the gate's own `runAs: 'system'` flow and\n    // the insert default, and both survive the readonly strip.\n    // What the rep is ASKING for, \u26D4 never the stage itself: REQ-0006\n    // acceptance 3 requires the stage not to move until the request is\n    // decided, and a `record_change` flow binds an AFTER hook \u2014 by the time it\n    // runs, a stage the rep wrote has already moved. So the rep writes the\n    // request here (with the win/loss reason), and the approved decision\n    // writes `stage` \u2014 the customer's own step 14, \u300C\u901A\u8FC7\u540E\u5546\u673A\u72B6\u6001\u6B63\u5F0F\u751F\u6548\u300D.\n    //\n    // Values ARE the two stage values, so the flow's approve branch can apply\n    // it with `stage: '{oppRecord.requested_status}'` and no mapping table can\n    // drift. Not readonly: this is the one half of the gate a person writes.\n    // Inert while the gate is off \u2014 nothing reads it unless the install arms\n    // `status_change_approval_status`.\n    requested_status: Field.select({\n      label: 'Requested Status',\n      group: 'sales_process',\n      options: [\n        { label: 'Won', value: 'closed_won' },\n        { label: 'Lost', value: 'closed_lost' },\n      ],\n    }),\n\n    status_change_approval_status: Field.select({\n      label: 'Status Change Approval',\n      group: 'sales_process',\n      readonly: true,\n      defaultValue: 'not_required',\n      options: [\n        { label: 'Not Required', value: 'not_required', default: true },\n        { label: 'Pending', value: 'pending', color: '#FFA500' },\n        { label: 'Approved', value: 'approved', color: '#00AA00' },\n        { label: 'Rejected', value: 'rejected', color: '#FF0000' },\n      ],\n    }),\n\n    // \u2500\u2500\u2500 Win / Loss analysis \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n    //\n    // \u26D4 The reason is captured AT CLOSE, and that is enforced, not requested.\n    // Leaving both fields optional means every seeded and user-closed deal\n    // lands with them empty and the win/loss widgets below have nothing to draw.\n    //\n    // `requiredWhen`, not a script validation, for the same reason\n    // `crm_lead.duplicate_of_lead` uses it (ADR-0113): \"this field must hold a\n    // value when the record looks like X\" is exactly a conditional write\n    // contract, the engine evaluates it on insert AND update inside\n    // `evaluateValidationRules`, and it reports against the FIELD \u2014 so the form\n    // marks the empty picklist instead of showing a record-level banner. It is\n    // ALSO the only shape the freeze below leaves usable: once a deal is closed,\n    // `opportunity.hook.ts` refuses every user edit outside the narrative\n    // fields, so a reason not captured in the closing write can never be added\n    // afterwards. Close time is the only chance.\n    // `test/win-loss-capture.test.ts` drives both predicates through a real\n    // ObjectQL over a real driver, on insert and on update.\n    //\n    // \u26A0\uFE0F `has(...)` is load-bearing. A bare `record.stage == \"closed_lost\"`\n    // aborts with `No such key` on any merged record that omits the column, and\n    // the engine's answer to a predicate that cannot evaluate is to SKIP it\n    // (\"requiredWhen for 'loss_reason' failed to evaluate \u2014 skipped\"), which\n    // would make this read as enforced while requiring nothing at all.\n    win_reason: Field.select({\n      label: 'Win Reason',\n      description: 'Why this deal was won. Required to close an opportunity as Won.',\n      group: 'classification',\n      requiredWhen: P`has(record.stage) && record.stage == \"closed_won\"`,\n      options: [\n        { label: 'Better Product', value: 'better_product' },\n        { label: 'Better Price', value: 'better_price' },\n        { label: 'Existing Relationship', value: 'relationship' },\n        { label: 'Better Support', value: 'better_support' },\n        { label: 'Best Fit / Features', value: 'best_fit' },\n        // Written by the machine, not chosen by a rep: `quote_on_accepted`\n        // (quote.hook.ts) wins the deal the moment a customer accepts the\n        // quote, and no human is in that write to attribute it. Naming the\n        // automated path is this repo's existing idiom for exactly that split\n        // (`crm_lead.duplicate_status` = machine `suspected` vs human\n        // `confirmed`) and it keeps the rule exception-free: every closed_won\n        // row carries a reason, and an analyst can still tell a CPQ close from\n        // a rep's attribution instead of reading a fabricated \"Better Product\".\n        { label: 'Quote Accepted', value: 'quote_accepted' },\n        { label: 'Other', value: 'other' },\n      ],\n    }),\n\n    loss_reason: Field.select({\n      label: 'Loss Reason',\n      description: 'Why this deal was lost. Required to close an opportunity as Lost.',\n      group: 'classification',\n      requiredWhen: P`has(record.stage) && record.stage == \"closed_lost\"`,\n      options: [\n        { label: 'Price Too High', value: 'price' },\n        { label: 'Lost to Competitor', value: 'competitor' },\n        { label: 'No Budget', value: 'no_budget' },\n        { label: 'No Decision', value: 'no_decision' },\n        { label: 'Bad Timing', value: 'timing' },\n        { label: 'Missing Features', value: 'features' },\n        { label: 'Other', value: 'other' },\n      ],\n    }),\n\n    loss_details: Field.textarea({\n      label: 'Loss/Win Details',\n      description: 'Free-text context behind the win or loss reason.',\n      group: 'classification',\n    }),\n  },\n  \n  // Database indexes for performance\n  indexes: [\n    { fields: ['name'] },\n    { fields: ['crm_account'] },\n    { fields: ['owner_id'] },\n    { fields: ['stage'] },\n    { fields: ['close_date'] },\n    // The stagnation sweep filters on this every morning.\n    { fields: ['stage_entry_date'] },\n  ],\n  \n  // Enable advanced features\n  //\n  // Stage/amount history is tracked per-field via `Field.trackHistory`\n  // (ADR-0052). \u26A0\uFE0F Ownership is NOT: it lives on the platform's injected\n  // `owner_id`, which carries no `trackHistory` flag \u2014 a transfer is recorded\n  // in the compliance audit log (`sys_audit_log`, unconditional) rather than on\n  // the activity feed.\n  enable: {\n    apiEnabled: true,\n    apiMethods: ['get', 'list', 'create', 'update', 'delete'], // Whitelist allowed API operations\n    // #602 \u2014 proposals, redlines and signed orders belong on the deal.\n    // See the canonical capability note in `src/sales/objects/index.ts`.\n    files: true,\n  },\n\n  // ADR-0052 \u00A75b.2 \u2014 declarative milestone activity. When `stage` enters these\n  // values the platform emits a semantic timeline entry (no hook code).\n  // Combined with the field-level `trackHistory` above (stage-change rows) this\n  // replaces any hand-coded activity hook.\n  activityMilestones: [\n    { field: 'stage', value: 'closed_won', summary: 'Deal won \u2014 {name}', type: 'completed' },\n    { field: 'stage', value: 'closed_lost', summary: 'Deal lost \u2014 {name}', type: 'completed' },\n  ],\n\n  // Removed: list_views and form_views belong in UI configuration, not object definition\n  \n  // Lifecycle transitions are enforced via a `state_machine` validation rule\n  // (see validations[] below). \u26A0\uFE0F There is no top-level `stateMachines` key on\n  // the platform \u2014 status state machines live in the validation union.\n\n  // Validation Rules\n  //\n  // Predicates below are TOTAL: every `record.x` read is `has()`-guarded, so the\n  // rule returns a verdict even when the merged record has no such key. See\n  // AGENTS.md \"Validation predicates must be TOTAL\" and\n  // test/object-validation-predicates.test.ts, which fails the build otherwise.\n  validations: [\n    {\n      name: 'close_date_future',\n      type: 'script',\n      severity: 'warning',\n      message: 'Close date should not be in the past unless opportunity is closed',\n      // An absent `stage` key means \"no stage recorded\", which is not a closed\n      // stage \u2014 hence `!has(record.stage) || (\u2026)` rather than a leading\n      // `has(record.stage) &&`, which would suppress the warning instead.\n      condition: P`has(record.close_date) && record.close_date != null && record.close_date < today() && (!has(record.stage) || (record.stage != \"closed_won\" && record.stage != \"closed_lost\"))`,\n    },\n    {\n      name: 'amount_positive',\n      type: 'script',\n      severity: 'error',\n      message: 'Amount must be greater than zero',\n      condition: P`has(record.amount) && record.amount != null && record.amount <= 0`,\n    },\n    {\n      name: 'opportunity_stage_progression',\n      type: 'state_machine',\n      severity: 'warning',\n      message: 'Invalid opportunity stage transition',\n      field: 'stage',\n      transitions: {\n        // `\u2192 proposal` is legal from every pre-proposal stage: the\n        // quote_generation flow fast-forwards the deal to `proposal` when a\n        // quote is generated, which can happen at any open stage.\n        prospecting: ['qualification', 'proposal', 'closed_lost'],\n        qualification: ['needs_analysis', 'proposal', 'closed_lost'],\n        needs_analysis: ['proposal', 'closed_lost'],\n        // `proposal \u2192 closed_won` is legal: the quote_on_accepted hook closes\n        // the linked deal directly from the CPQ path (quote_generation parks\n        // the opportunity at `proposal`; an accepted quote wins it without a\n        // separate negotiation step).\n        proposal: ['negotiation', 'closed_won', 'closed_lost'],\n        negotiation: ['closed_won', 'closed_lost'],\n        closed_won: [],\n        closed_lost: [],\n      },\n    },\n  ],\n  \n  // \u26A0\uFE0F `probability` and `expected_revenue` are NOT computed declaratively.\n  // They are derived in `opportunity.hook.ts` (single source of truth =\n  // stage \u2192 STAGE_PROBABILITY); keeping the math in one place avoids drift\n  // between a declarative CASE() table and the hook's lookup table.\n  //\n  // \u26A0\uFE0F No `workflows[]` here, and none is possible: object `workflows[]` were\n  // removed from the platform. Field updates live in this object's `*.hook.ts`;\n  // scheduled status flips and notifications live in `src/*/flows/*.flow.ts`.\n});\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/sales/objects/task.object.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/sales/objects\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/sales/objects/task.object.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport { ObjectSchema, Field } from '@objectstack/spec/data';\nimport { P } from '@objectstack/spec';\nimport { TASK_TYPE_OPTIONS } from './_picklists';\n\nexport const Task = ObjectSchema.create({\n  name: 'crm_task',\n  label: 'Task',\n  pluralLabel: 'Tasks',\n  icon: 'check-square',\n  description: 'Activities and to-do items',\n\n  // ADR-0090 D1/D7: OWD is an authored decision. Personal activity records.\n  sharingModel: 'private',\n\n  // Every other business object with a detail page groups its fields; task was\n  // one of the two that did not, so its detail page fell back to one flat grid\n  // where the five polymorphic `related_to_*` lookups and the recurrence\n  // machinery sat inline with the subject. The keys mirror the sections the\n  // task form already uses (Task / Related Records / Recurrence & Effort) so\n  // the two surfaces agree.\n  fieldGroups: [\n    { key: 'basic',      label: 'Task Information', icon: 'info' },\n    { key: 'scheduling', label: 'Scheduling',       icon: 'calendar' },\n    // No 'assignment' group: the assignee (`owner_id`) was its only member, and\n    // the synthesized detail page hoists it into the highlight strip \u2014 so the\n    // group rendered on forms and never on detail pages\n    // (`field-group-shadowed`). It lives in `basic` alongside\n    // subject/status/priority instead.\n    { key: 'related',    label: 'Related Records',  icon: 'link' },\n    { key: 'recurrence', label: 'Recurrence',       icon: 'refresh-ccw', collapse: 'collapsed' },\n    { key: 'effort',     label: 'Progress & Effort', icon: 'activity',   collapse: 'collapsed' },\n    { key: 'system',     label: 'System',           icon: 'database',    collapse: 'collapsed' },\n  ],\n\n  fields: {\n    // Platform ownership anchor \u2014 canonical note in `account.object.ts` (#548).\n    owner_id: Field.lookup('sys_user', {\n      label: 'Assigned To',\n      group: 'basic',\n      system: true,\n      readonly: false,\n      trackHistory: true,\n    }),\n\n    // Task Information\n    subject: Field.text({\n      group: 'basic',\n      label: 'Subject',\n      required: true,\n      storage: { notNull: true },\n      searchable: true,\n      maxLength: 255,\n    }),\n    \n    description: Field.markdown({\n      group: 'basic',\n      label: 'Description',\n    }),\n    \n    // Task Management\n    status: Field.select({\n      group: 'basic',\n      label: 'Status',\n      required: true,\n      storage: { notNull: true },\n      trackHistory: true,\n      // Field-level default, not just the option flag: the option `default`\n      // only preselects in some form surfaces, so a quick-create modal opened\n      // from a related list left this required field blank and the rep had to\n      // pick \"Not Started\" by hand every time.\n      defaultValue: 'not_started',\n      options: [\n        { label: 'Not Started', value: 'not_started', color: '#808080', default: true },\n        { label: 'In Progress', value: 'in_progress', color: '#FFA500' },\n        { label: 'Waiting', value: 'waiting', color: '#FFD700' },\n        { label: 'Completed', value: 'completed', color: '#00AA00' },\n        { label: 'Deferred', value: 'deferred', color: '#999999' },\n      ]\n    }),\n\n    priority: Field.select({\n      group: 'basic',\n      label: 'Priority',\n      required: true,\n      storage: { notNull: true },\n      trackHistory: true,\n      // `normal` is the default rather than `low`: a rep filing a to-do has\n      // made no priority judgement, and defaulting everything to Low made the\n      // field meaningless (nothing ever sorted above the noise).\n      defaultValue: 'normal',\n      options: [\n        { label: 'Low', value: 'low', color: '#4169E1' },\n        { label: 'Normal', value: 'normal', color: '#00AA00', default: true },\n        { label: 'High', value: 'high', color: '#FFA500' },\n        { label: 'Urgent', value: 'urgent', color: '#FF0000' },\n      ]\n    }),\n\n    // Sortable ordinal for `priority` \u2014 see crm_case.priority_rank. Sorting on\n    // the select itself compares raw strings (normal > low > high > urgent),\n    // which pushes urgent work to the bottom of the to-do queue.\n    //\n    // `0` is the UNRANKED sentinel, identical to crm_case.priority_rank. \u26D4 It\n    // must stay identical on both: a differing sentinel orders the same unknown\n    // priority differently on the two objects, and `2` here would make an\n    // unranked task indistinguishable from a genuine `normal`.\n    priority_rank: Field.number({\n      label: 'Priority Rank',\n      readonly: true,\n      defaultValue: 0,\n    }),\n\n    type: Field.select({\n      group: 'basic',\n      label: 'Task Type',\n      // Canonical set (#490) \u2014 the schedule_followup screen renders the same\n      // list; see _picklists.ts.\n      options: [...TASK_TYPE_OPTIONS],\n    }),\n    \n    // Dates\n    due_date: Field.date({\n      group: 'scheduling',\n      label: 'Due Date',\n    }),\n    \n    reminder_date: Field.datetime({\n      group: 'scheduling',\n      label: 'Reminder Date/Time',\n    }),\n    \n    completed_date: Field.datetime({\n      group: 'scheduling',\n      label: 'Completed Date',\n      readonly: true,\n    }),\n    \n    // Related To (Polymorphic relationship - can link to multiple object types)\n    related_to_type: Field.select({\n      group: 'related',\n      label: 'Related To Type',\n      options: [\n        { label: 'Account', value: 'crm_account' },\n        { label: 'Contact', value: 'crm_contact' },\n        { label: 'Opportunity', value: 'crm_opportunity' },\n        { label: 'Lead', value: 'crm_lead' },\n        { label: 'Case', value: 'crm_case' },\n      ]\n    }),\n    \n    related_to_account: Field.lookup('crm_account', {\n      group: 'related',\n      label: 'Related Account',\n    }),\n    \n    related_to_contact: Field.lookup('crm_contact', {\n      group: 'related',\n      label: 'Related Contact',\n    }),\n    \n    related_to_opportunity: Field.lookup('crm_opportunity', {\n      group: 'related',\n      label: 'Related Opportunity',\n    }),\n    \n    related_to_lead: Field.lookup('crm_lead', {\n      group: 'related',\n      label: 'Related Lead',\n    }),\n    \n    related_to_case: Field.lookup('crm_case', {\n      group: 'related',\n      label: 'Related Case',\n    }),\n    \n    // Recurrence (for recurring tasks)\n    is_recurring: Field.boolean({\n      group: 'recurrence',\n      label: 'Recurring Task',\n      defaultValue: false,\n    }),\n    \n    recurrence_type: Field.select({\n      group: 'recurrence',\n      label: 'Recurrence Type',\n      options: [\n        { label: 'Daily', value: 'daily' },\n        { label: 'Weekly', value: 'weekly' },\n        { label: 'Monthly', value: 'monthly' },\n        { label: 'Yearly', value: 'yearly' },\n      ]\n    }),\n    \n    recurrence_interval: Field.number({\n      group: 'recurrence',\n      label: 'Recurrence Interval',\n      defaultValue: 1,\n      min: 1,\n    }),\n    \n    recurrence_end_date: Field.date({\n      group: 'recurrence',\n      label: 'Recurrence End Date',\n    }),\n    \n    // Flags\n    is_completed: Field.boolean({\n      group: 'system',\n      label: 'Is Completed',\n      defaultValue: false,\n      readonly: true,\n    }),\n    \n    is_overdue: Field.boolean({\n      group: 'system',\n      label: 'Is Overdue',\n      defaultValue: false,\n      readonly: true,\n    }),\n\n    // Set by the `task_due_reminder` schedule flow once a reminder has fired\n    // (the sweep de-dups on `reminder_date`, which it clears; this flag is the\n    // audit trail), and defaulted to `false` by `task.hook.ts` on insert.\n    //\n    // NOT readonly \u2014 but the old reason here (\"16.x drops flow writes to\n    // readonly fields\") does not survive measurement. Taken on 17.1.0,\n    // RE-TAKEN on 17.2.0 (#1460) and RE-CONFIRMED on 17.3.0 (#1676) \u2014 the pin\n    // at each of those takings; not re-taken on 17.4.0 (PR #1814, #1807) or\n    // 17.5.0 \u2014 same verdict all three times: `task_due_reminder`\n    // declares `runAs: 'system'`, so its write WOULD survive a\n    // `readonly: true`.\n    //\n    // \u26A0\uFE0F The other half of that reason EXPIRED at 17.4.0 and is \u26D4 NOT\n    // renumbered here: \"the insert path is exempt from the strip\" held through\n    // 17.3.0 and was reversed as a declared BREAKING change \u2014 the retirement\n    // is recorded in the INSERT-path section of\n    // `test/readonly-write-semantics.test.ts` (#1429) and in\n    // `campaign_member.object.ts`. Neither half moves this field, which is not\n    // `readonly` at all. Left writable as-is; flipping it is a separate\n    // decision, not a comment fix.\n    reminder_sent: Field.boolean({\n      group: 'system',\n      label: 'Reminder Sent',\n      defaultValue: false,\n    }),\n\n    // Progress\n    progress_percent: Field.percent({\n      group: 'effort',\n      label: 'Progress (%)',\n      min: 0,\n      max: 100,\n      defaultValue: 0,\n    }),\n    \n    // No time tracking. `estimated_hours` / `actual_hours` were declared and\n    // inert: no rollup summed them onto a case or an opportunity, no variance\n    // report compared them, and nothing warned when actual overran estimate.\n    // Effort on a task is `progress_percent`, which the task views do read.\n  },\n  \n  // API surface. History \u2192 Field.trackHistory (ADR-0052).\n  enable: {\n    apiEnabled: true,\n  },\n  \n  // Database indexes for performance\n  indexes: [\n    { fields: ['status'] },\n    { fields: ['priority'] },\n    { fields: ['owner_id'] },\n    { fields: ['due_date'] },\n  ],\n  \n  // ADR-0079: render-only `titleFormat` retired in favor of `nameField`,\n  // which names the real field holding the record title (here: `subject`).\n  nameField: 'subject',\n  highlightFields: ['subject', 'status', 'priority', 'due_date', 'owner_id'],\n  \n  // Removed: list_views and form_views belong in UI configuration, not object definition\n  \n  // Predicates below are TOTAL: every `record.x` read is `has()`-guarded, so the\n  // rule returns a verdict even when the merged record has no such key. See\n  // AGENTS.md \"Validation predicates must be TOTAL\" and\n  // test/object-validation-predicates.test.ts, which fails the build otherwise.\n  validations: [\n    {\n      name: 'completed_date_required',\n      type: 'script',\n      severity: 'error',\n      message: 'Completed date is required when status is Completed',\n      condition: P`has(record.status) && record.status == \"completed\" && (!has(record.completed_date) || isBlank(record.completed_date))`,\n    },\n    {\n      name: 'recurrence_fields_required',\n      type: 'script',\n      severity: 'error',\n      message: 'Recurrence type is required for recurring tasks',\n      condition: P`has(record.is_recurring) && record.is_recurring == true && (!has(record.recurrence_type) || isBlank(record.recurrence_type))`,\n    },\n    {\n      name: 'related_to_required',\n      type: 'script',\n      severity: 'warning',\n      message: 'At least one related record should be selected',\n      condition: P`(!has(record.related_to_account) || isBlank(record.related_to_account)) && (!has(record.related_to_contact) || isBlank(record.related_to_contact)) && (!has(record.related_to_opportunity) || isBlank(record.related_to_opportunity)) && (!has(record.related_to_lead) || isBlank(record.related_to_lead)) && (!has(record.related_to_case) || isBlank(record.related_to_case))`,\n    },\n  ],\n  \n  // \u26A0\uFE0F No `workflows[]` here, and none is possible: object `workflows[]` were\n  // removed from the platform. Field updates live in this object's `*.hook.ts`;\n  // scheduled status flips and notifications live in `src/*/flows/*.flow.ts`.\n});\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/sales/actions/activity-actions.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/sales/actions\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/sales/actions/activity-actions.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport type { Action } from '@objectstack/spec/ui';\nimport * as salesObjects from '../objects';\n\n/**\n * Activity-logging actions \u2014 `log_call`, `log_meeting`, `schedule_meeting`.\n *\n * (It was `src/actions/global.actions.ts` until the ADR-0130 layout: nothing\n * here is a *global* action, and nothing can be \u2014 see the dispatcher note on\n * `objectName` below. The name now says what it builds.)\n *\n * # Why the factory lives in the SALES package\n *\n * Four of the five host objects \u2014 `crm_lead`, `crm_contact`, `crm_account`,\n * `crm_opportunity` \u2014 are sales', as is the `crm_event` every action writes.\n * The fifth, `crm_case`, is service's, and under plan item 7 a source more than\n * one package needs takes the lowest package all its consumers depend on. So\n * the factory is here and `src/service/actions/case-activity.actions.ts`\n * instantiates the case triple from it along the service -> sales edge. One\n * copy, never two.\n *\n * # The two rules this family exists to hold\n *\n *  1. **Scope.** The actions are GENERATED per object: one registered action\n *     per (kind \u00D7 object). \u26D4 Never pin an activity action to a single object,\n *     and never author one without an `objectName` \u2014 the runtime keys the\n *     registry on `<objectName>:<action.name>` and the dispatcher probes\n *     `<objectName>` first, so a single-object action is unreachable from every\n *     other object a rep sells to, and an object-less one is unreachable\n *     everywhere.\n *  2. **Shape.** Each of these actions inserts a real `crm_event`, real\n *     `crm_event_attendee` rows, and keeps the `sys_activity` row purely as the\n *     unified-timeline pointer (ADR-0052 `source_object` / `source_id`), the\n *     same way `send_email` points at its `sys_email`. \u26D4 Never move that\n *     structure back into a `metadata` JSON blob: a blob is not data \u2014 no view\n *     filters it, no dataset groups by it, no report counts it.\n *\n * # Live platform workaround\n *\n * `schedule_meeting` collects its start as a `date` + `time` PAIR rather than\n * as one `datetime` param, because a `datetime` action param cannot be\n * submitted from the Console at all (objectstack-ai/objectstack#5061). Both the\n * body and the param list carry the full reasoning and the revert instruction.\n *\n * The recency bubble (`crm_account.last_activity_date`,\n * `crm_lead.last_contacted_date`, `crm_contact.last_contacted_date`) is\n * deliberately NOT written here. It hangs off `crm_event`'s own hook, so an\n * event created from the calendar, from an import, or from a future flow bumps\n * recency exactly like one created from this button. One writer, not one per\n * entry point.\n */\n\n/**\n * `objectName` \u2192 the object's DECLARED `nameField`, derived from the object\n * definitions rather than hand-listed.\n *\n * \u26D4 Never stamp `record_label` from `ctx.record?.name`: `name` is not the\n * display field on almost anything here \u2014 most objects declare a different\n * `nameField` (`display_title`, `full_name`, `subject`, `contract_number`, \u2026)\n * and have no `name` column at all, so the label lands `null`.\n *\n * Deriving the map keeps it correct when an object retargets its `nameField`.\n * The lookup happens at AUTHORING time (each action knows its own object), so\n * the body carries the resolved field name rather than a table it could miss\n * on.\n *\n * The object definitions are passed IN rather than imported here, because the\n * five host objects no longer live in one directory: `crm_case` is service's.\n * A package hands {@link activityActionsFor} its own object barrel, so the map\n * is still derived from the real definition of the object being bound and no\n * package reaches into another's.\n */\ntype NameFieldSource = { name?: unknown; nameField?: unknown };\n\nconst nameFieldMap = (objectDefs: Record<string, NameFieldSource>): Record<string, string> =>\n  Object.fromEntries(\n    Object.values(objectDefs)\n      .filter(\n        (o): o is { name: string; nameField: string } =>\n          typeof o?.name === 'string' && typeof o?.nameField === 'string',\n      )\n      .map((o) => [o.name, o.nameField]),\n  );\n\n/**\n * The objects a rep can log an interaction against, and the `crm_event`\n * lookup that records the link.\n *\n * The keys are exactly `crm_event.related_to_type`'s options\n * (`RELATED_TO_TYPE_OPTIONS`), and the values exactly the `related_to_*`\n * lookups that back them. `test/activity-actions.test.ts` pins that agreement\n * against the object definition, so adding a sixth `related_to_*` field\n * without extending this map fails in CI instead of producing an action that\n * writes an event linked to nothing.\n */\nexport const ACTIVITY_TARGETS: Record<string, string> = {\n  crm_lead: 'related_to_lead',\n  crm_contact: 'related_to_contact',\n  crm_account: 'related_to_account',\n  crm_opportunity: 'related_to_opportunity',\n  crm_case: 'related_to_case',\n};\n\n/** JS string literal, safely quoted for splicing into a body source. */\nconst lit = (value: string): string => JSON.stringify(value);\n\n/**\n * The acting user's display name, as action-body SOURCE TEXT.\n *\n * Shared verbatim by every body that writes `sys_activity.actor_name`: the\n * activity family below and `send_email` in `contact.actions.ts`.\n *\n * # Why a string and not a function\n *\n * An action body is shipped BODY-ONLY and evaluated in a QuickJS sandbox with\n * no module scope, so a shared helper called from a body is not a closure at\n * runtime \u2014 it is a `ReferenceError` (`test/helpers/action-sandbox.ts` states\n * the same constraint for the shared line-item price fill). A string spliced at\n * AUTHORING time, while Node builds the metadata, has no such problem: what\n * reaches the sandbox is one self-contained body with this text inlined,\n * exactly as if it had been typed there. `test/action-sandbox.test.ts` executes\n * both bodies under the real runner AND pins that both still contain this\n * constant, so the two call sites cannot drift into disagreeing.\n *\n * # Contract for a splice site\n *\n * Splice into a body that has already declared `userId` (`ctx.user?.id ?? null`)\n * and whose action declares `api.read`. Afterwards `actorName` holds a\n * non-blank display name \u2014 the id only as a last resort, never `null`.\n */\nexport const ACTOR_NAME_RESOLUTION_SOURCE = `// The acting user's DISPLAY name, for the sys_activity row (#673 / #678).\n      //\n      // PLATFORM WORKAROUND. \\`ctx.user.name\\` is not a display name on the\n      // dispatch path the Console uses: the REST action dispatcher builds the\n      // body's user as \\`{ id: ec.userId, name: ec.userId, \u2026 }\\` \u2014 the key is\n      // present and carries the raw id, so \\`ctx.user?.name\\` reads as a\n      // plausible string and silently wrote ids like\n      // \"grDEyLoIgnunJ2M7Y2muLgcuQbDUT0s2\" into \\`sys_activity.actor_name\\`\n      // (@objectstack/runtime 17.0.0-rc.2, dist/index.js:5397-5399). The MCP\n      // dispatcher does try a display name first\n      // (\\`ec.userName ?? ec.userDisplayName ?? ec.userId\\`, dist/index.js:1776)\n      // but nothing in the installed platform ever populates either field, so\n      // it falls back to the id too.\n      //\n      // So the name is resolved HERE, from \\`sys_user.name\\` (the column the\n      // platform itself treats as the profile display name), with the id kept\n      // as the last resort \u2014 an opaque id is bad, a blank actor is worse.\n      // A name that differs from the id is taken as already-resolved, which is\n      // what makes this one query and not a query per activity write.\n      //\n      // DELETE THIS once the platform delivers a display name on ctx.user.name\n      // for REST-dispatched action bodies: every splice site collapses back to\n      // \\`actor_name: ctx.user?.name\\` (objectstack-ai/objectstack#5372).\n      const ctxName = ctx.user?.name ? String(ctx.user.name).trim() : '';\n      let actorName = ctxName && ctxName !== userId ? ctxName : '';\n      if (!actorName && userId) {\n        try {\n          const found = await ctx.api.object('sys_user').find({\n            where: { id: userId },\n            fields: ['name'],\n            top: 1,\n          });\n          const users = Array.isArray(found) ? found : (found?.records ?? []);\n          const resolved = users.length && users[0].name ? String(users[0].name).trim() : '';\n          if (resolved) actorName = resolved;\n        } catch (e) {\n          // A denied or unavailable sys_user read must not fail the log \u2014 the\n          // interaction the rep just recorded matters more than its label.\n        }\n      }\n      if (!actorName) actorName = userId;`;\n\n/**\n * The authored difference between one activity action and the next.\n *\n * Everything the variants share lives in {@link activityAction}; this type is\n * the complete list of what a variant is still allowed to differ on. \u26D4 Never\n * hand-copy one variant into another: `log_call` and `log_meeting` were\n * near-verbatim copies once \u2014 identical bodies apart from a summary prefix and\n * a metadata key \u2014 and drifted into disagreeing about whether `duration` is\n * required.\n */\ntype ActivitySpec = {\n  name: string;\n  label: string;\n  icon: string;\n  /** `crm_event.type` for the row this action writes. */\n  eventType: string;\n  /** `crm_event.status`: `held` for something that happened, `planned` for a booking. */\n  eventStatus: 'held' | 'planned';\n  /** Stamped in front of the activity summary; `''` for calls. */\n  summaryPrefix: string;\n  /** Subject used when the user submits the form with the field blank. */\n  defaultSubject: string;\n  subjectLabel: string;\n  notesLabel: string;\n  /** Booked-in-the-future variants collect a start date + wall clock and a location. */\n  collectsSchedule?: boolean;\n  successMessage: string;\n};\n\n/**\n * Build one activity action, bound to one object.\n *\n * `duration` is OPTIONAL everywhere. It was `required: true` for calls and\n * `required: false` for meetings with nothing documenting the split; optional\n * is the direction that keeps every form submittable, and it is the one the\n * body is written for.\n */\nfunction activityAction(spec: ActivitySpec, objectName: string, nameField: string): Action {\n  const relatedField = ACTIVITY_TARGETS[objectName];\n  if (!relatedField) {\n    throw new Error(\n      `activityAction: '${objectName}' is not an activity target \u2014 extend ACTIVITY_TARGETS ` +\n        'together with crm_event.related_to_type and its related_to_* lookup.',\n    );\n  }\n  return {\n    name: spec.name,\n    label: spec.label,\n    // Object-scoped, one registration per object. The runtime registers a body\n    // action under `<objectName>:<name>` and the dispatcher probes\n    // `<objectName>` then `*`; a body action with no objectName lands under a\n    // 'global' key nothing ever probes (\"Action 'log_call' on object '*' not\n    // found\", verified 2026-07-28). \u26D4 Never author an object-less body action.\n    objectName,\n    icon: spec.icon,\n    // script, not modal: modal submits die on GET /api/v1/meta/object/<target>\n    // \u2192 400 in 16.1.0; script actions POST /api/v1/actions/... and execute.\n    type: 'script',\n    body: {\n      language: 'js',\n      source: `\n      const OBJECT_NAME = ${lit(objectName)};\n      const RELATED_FIELD = ${lit(relatedField)};\n      const NAME_FIELD = ${lit(nameField)};\n      const EVENT_TYPE = ${lit(spec.eventType)};\n      const EVENT_STATUS = ${lit(spec.eventStatus)};\n\n      const record = ctx.record ?? {};\n      const recordId = ctx.recordId ?? record.id ?? null;\n      const userId = ctx.user?.id ?? null;\n      const nowIso = new Date().toISOString();\n\n      ${ACTOR_NAME_RESOLUTION_SOURCE}\n\n      const subject = input.subject ? String(input.subject) : ${lit(spec.defaultSubject)};\n      const duration = input.duration ? Number(input.duration) : 0;\n      const notes = input.notes ? String(input.notes) : '';\n      const location = input.location ? String(input.location) : '';\n\n      // A booking states its own start; a log is \"just now\".\n      //\n      // WORKAROUND for objectstack-ai/objectstack#5061 \u2014 the start is collected\n      // as a CALENDAR DAY + a WALL CLOCK (\\`start_date\\` / \\`start_time\\`) and\n      // joined here, instead of as one \\`type: 'datetime'\\` param. A datetime\n      // param is unusable from the Console: it renders as a zone-less\n      // \\`<input type=\"datetime-local\">\\` and POSTs the raw value\n      // (\"2026-08-10T15:00\"), which the runtime's action-param validator rejects\n      // with 400 \"expected an ISO-8601 instant with explicit zone\" \u2014 no user\n      // input can pass. \\`date\\` and \\`time\\` are the two param types whose\n      // renderer output (\"YYYY-MM-DD\" / \"HH:MM\") the validator accepts verbatim,\n      // so the pair is submittable where the single datetime never was.\n      //\n      // TIMEZONE: the wall clock is interpreted as **UTC**, and both param\n      // labels say so. UTC is the only zone this body can apply deterministically\n      // \u2014 the sandbox context carries no user or org timezone (\\`ctx.user\\` is\n      // id/name/email), and reading the server's local zone would make the same\n      // input mean different instants on different hosts and in tests. Everything\n      // else this app writes is likewise a UTC instant (\\`new Date().toISOString()\\`).\n      //\n      // When #5061 lands (the Console serializing datetime-local in the\n      // browser's zone), this reverts to ONE \\`type: 'datetime'\\` param and the\n      // zone becomes the user's own \u2014 see \\`collectsSchedule\\` in this file.\n      let startIso = nowIso;\n      const startDate = input.start_date ? String(input.start_date).trim() : '';\n      if (startDate) {\n        const startTime = input.start_time ? String(input.start_time).trim() : '00:00';\n        // 'HH:MM' and 'HH:MM:SS' are both shapes the validator lets through.\n        const clock = startTime.length === 5 ? startTime + ':00' : startTime;\n        const parsed = new Date(startDate + 'T' + clock + '.000Z');\n        // An unparseable value falls back to now rather than writing NaN into a\n        // required column.\n        if (!isNaN(parsed.getTime())) startIso = parsed.toISOString();\n      }\n\n      // 1. the interaction itself, as a queryable record.\n      const eventDoc = {\n        subject: subject,\n        type: EVENT_TYPE,\n        status: EVENT_STATUS,\n        start_datetime: startIso,\n        // Load-bearing, not decoration: an action body executes with\n        // isSystem: true (runtime buildActionExecutionContext), which\n        // short-circuits the security middleware \u2014 so the insert-time\n        // auto-stamp of owner_id never fires here. Omitting it would land the\n        // interaction ownerless, i.e. invisible in \"My \u2026\" and uneditable under\n        // a private OWD (#548, the #622 failure mode).\n        owner_id: userId,\n        related_to_type: OBJECT_NAME,\n      };\n      if (duration > 0) eventDoc.duration_minutes = duration;\n      if (location) eventDoc.location = location;\n      if (notes) eventDoc.description = notes;\n      if (recordId) eventDoc[RELATED_FIELD] = recordId;\n      const event = await ctx.api.object('crm_event').insert(eventDoc);\n      const eventId = event?.id ?? null;\n\n      // 2. attendees, as rows \u2014 the point of #592.\n      // A multi-lookup param may arrive as an array or, on a surface that\n      // renders it single-valued, as one scalar. Normalising both is not a\n      // lenient parse of authored metadata: it is the console's own input\n      // shape, which this body does not control.\n      const toList = (v) => {\n        if (v === null || v === undefined || v === '') return [];\n        return Array.isArray(v) ? v : [v];\n      };\n      const attendees = [];\n      if (userId) {\n        attendees.push({ attendee_type: 'user', sys_user: userId, is_organizer: true, response: 'accepted' });\n      }\n      // The record the action was fired from IS an attendee when it is a\n      // person. On an account / opportunity / case it is not, so nothing is\n      // invented for it \u2014 the event's related_to_* link already records it.\n      if (OBJECT_NAME === 'crm_contact' && recordId) {\n        attendees.push({ attendee_type: 'contact', crm_contact: recordId, response: 'no_response' });\n      }\n      if (OBJECT_NAME === 'crm_lead' && recordId) {\n        attendees.push({ attendee_type: 'lead', crm_lead: recordId, response: 'no_response' });\n      }\n      for (const c of toList(input.attendee_contacts)) {\n        attendees.push({ attendee_type: 'contact', crm_contact: String(c), response: 'no_response' });\n      }\n      for (const u of toList(input.attendee_users)) {\n        attendees.push({ attendee_type: 'user', sys_user: String(u), response: 'no_response' });\n      }\n\n      const seen = {};\n      const attendeeIds = [];\n      for (const a of attendees) {\n        const who = a.sys_user ?? a.crm_contact ?? a.crm_lead ?? '';\n        const key = a.attendee_type + ':' + who;\n        if (seen[key]) continue;\n        seen[key] = true;\n        const doc = Object.assign({}, a, { crm_event: eventId, invited_date: nowIso });\n        const row = await ctx.api.object('crm_event_attendee').insert(doc);\n        if (row?.id) attendeeIds.push(row.id);\n      }\n\n      // 3. the unified-timeline pointer.\n      // \\`metadata\\` no longer carries the attendee list: it is a display hint\n      // beside a real record now, not the record itself. ADR-0052\n      // source_object/source_id is the queryable drill to the crm_event row.\n      const summary = duration ? subject + ' (' + duration + ' min)' : subject;\n      const activity = await ctx.api.object('sys_activity').insert({\n        type: EVENT_STATUS === 'held' ? 'completed' : 'scheduled',\n        summary: ${lit(spec.summaryPrefix)} + summary,\n        actor_id: userId,\n        actor_name: actorName,\n        object_name: OBJECT_NAME,\n        record_id: recordId,\n        // #514 item 2: the object's DECLARED nameField, not a hardcoded name.\n        record_label: record[NAME_FIELD] ?? null,\n        source_object: 'crm_event',\n        source_id: eventId,\n        metadata: JSON.stringify({\n          kind: EVENT_TYPE,\n          duration_minutes: duration,\n          notes: notes,\n          attendee_count: attendeeIds.length,\n        }),\n      });\n\n      // 4. SLA first-response stamp \u2014 NOT here. #575 B2 originally stamped\n      // \\`crm_case.first_response_date\\` from this body, which meant the metric\n      // was only ever written when the interaction was recorded through the two\n      // buttons this factory builds; an event created any other way left it\n      // null, under a comment asking every future author to remember. #595\n      // moved the stamp to \\`event_activity_bubble\\` in\n      // \\`src/sales/objects/event.hook.ts\\`, which already fires on exactly the\n      // condition that matters (\"a held event, on its transition into held\")\n      // and already resolves \\`related_to_case\\`. Step 1 above writes that\n      // event, so this action still stamps the case \u2014 through one writer\n      // instead of a convention. Do not reintroduce a copy here: two writers\n      // racing on a \"first\" timestamp is how it becomes a \"last\" one.\n\n      return { eventId: eventId, activityId: activity?.id ?? null, attendeeIds: attendeeIds };\n    `,\n      capabilities: ['api.read', 'api.write'],\n      timeoutMs: 5000,\n    },\n    locations: ['record_header', 'list_item', 'record_related'],\n    params: [\n      {\n        name: 'subject',\n        label: spec.subjectLabel,\n        type: 'text',\n        required: true,\n      },\n      // WORKAROUND objectstack-ai/objectstack#5061 \u2014 one `type: 'datetime'`\n      // param (\"Starts At\") is what this WANTS to be, and it is unusable: the\n      // Console renders it as a zone-less `<input type=\"datetime-local\">` and\n      // POSTs the raw value, which the action-param validator rejects with a\n      // 400 (`expected an ISO-8601 instant with explicit zone`). The renderer's\n      // output shape and the validator's accepted shape do not intersect, so\n      // NO user input can submit the action \u2014 reproduced from both the list-row\n      // menu and the record header.\n      //\n      // `date` and `time` are the two param types where they DO intersect: the\n      // Console renders native `<input type=\"date\">` / `<input type=\"time\">`\n      // pickers (`ui-components` DateField / TimeField, both emitting\n      // `e.target.value` verbatim) and the validator's `CalendarDateValueSchema`\n      // /`ClockTimeValueSchema` accept exactly `YYYY-MM-DD` and `HH:MM`. Two\n      // native pickers are also better UX than one free-text box, which is the\n      // other shape that would have submitted.\n      //\n      // The zone is stated in the LABELS, not in `helpText`: the Console's\n      // action-param form forwards only name/label/type/required/placeholder/\n      // options/multiple/accept/maxSize to the field widget, so a `helpText`\n      // here would never reach the user.\n      //\n      // REVERT WHEN #5061 LANDS: back to\n      //   { name: 'start', label: 'Starts At', type: 'datetime', required: true }\n      // and drop the join in the body above.\n      ...(spec.collectsSchedule\n        ? ([\n            { name: 'start_date', label: 'Start Date (UTC)', type: 'date', required: true },\n            { name: 'start_time', label: 'Start Time (UTC)', type: 'time', required: true },\n            { name: 'location', label: 'Location', type: 'text', required: false },\n          ] as NonNullable<Action['params']>)\n        : []),\n      {\n        name: 'duration',\n        label: 'Duration (minutes)',\n        type: 'number',\n        required: false,\n      },\n      // Two typed lookups, not one free-text box: the platform has no\n      // polymorphic picker, and typed lookups produce queryable rows where a\n      // text box produces a comma-separated sentence nothing can filter on.\n      {\n        name: 'attendee_contacts',\n        label: 'Contact Attendees',\n        type: 'lookup',\n        reference: 'crm_contact',\n        multiple: true,\n        required: false,\n      },\n      {\n        name: 'attendee_users',\n        label: 'Internal Attendees',\n        type: 'lookup',\n        reference: 'sys_user',\n        multiple: true,\n        required: false,\n      },\n      {\n        name: 'notes',\n        label: spec.notesLabel,\n        type: 'textarea',\n        required: false,\n      },\n    ],\n    successMessage: spec.successMessage,\n    refreshAfter: true,\n  };\n}\n\nconst LOG_CALL_SPEC: ActivitySpec = {\n  name: 'log_call',\n  label: 'Log a Call',\n  icon: 'phone',\n  eventType: 'call',\n  eventStatus: 'held',\n  summaryPrefix: '',\n  defaultSubject: 'Untitled Call',\n  subjectLabel: 'Call Subject',\n  notesLabel: 'Call Notes',\n  successMessage: 'Call logged successfully!',\n};\n\nconst LOG_MEETING_SPEC: ActivitySpec = {\n  name: 'log_meeting',\n  label: 'Log a Meeting',\n  icon: 'calendar-check',\n  eventType: 'meeting',\n  eventStatus: 'held',\n  summaryPrefix: 'Meeting: ',\n  defaultSubject: 'Untitled Meeting',\n  subjectLabel: 'Meeting Subject',\n  notesLabel: 'Meeting Notes',\n  successMessage: 'Meeting logged successfully!',\n};\n\nconst SCHEDULE_MEETING_SPEC: ActivitySpec = {\n  name: 'schedule_meeting',\n  label: 'Schedule a Meeting',\n  icon: 'calendar-plus',\n  eventType: 'meeting',\n  // `planned`, and that is the whole difference that matters: a booking must\n  // NOT reset the customer's recency clock (see event.hook.ts).\n  eventStatus: 'planned',\n  summaryPrefix: 'Meeting scheduled: ',\n  defaultSubject: 'Untitled Meeting',\n  subjectLabel: 'Meeting Subject',\n  notesLabel: 'Agenda',\n  collectsSchedule: true,\n  successMessage: 'Meeting scheduled!',\n};\n\n/** The three activity kinds, in the order they appear on a record header. */\nexport const ACTIVITY_SPEC_NAMES = ['log_call', 'log_meeting', 'schedule_meeting'] as const;\n\nconst ACTIVITY_SPECS: ActivitySpec[] = [LOG_CALL_SPEC, LOG_MEETING_SPEC, SCHEDULE_MEETING_SPEC];\n\n/**\n * The three activity actions for ONE host object \u2014 the factory every package\n * with an activity target calls.\n *\n * Returned keyed by kind rather than as a list, so the named exports below read\n * as themselves and a caller cannot pick the wrong index. Each package calls\n * this ONCE per host object and exports the three it gets back, so a page that\n * imports `LogCallAction` and the barrel that registers it hold the SAME\n * object: two structurally-identical actions under one `<objectName>:<name>`\n * registry key is a duplicate registration the runtime warns about, and one of\n * them silently loses.\n *\n * `objectDefs` is the calling package's object barrel \u2014 see the note on\n * {@link nameFieldMap} for why the definitions arrive as an argument.\n */\nexport const activityActionsFor = (\n  objectName: string,\n  objectDefs: Record<string, NameFieldSource>,\n): Record<(typeof ACTIVITY_SPEC_NAMES)[number], Action> => {\n  // `?? 'name'` only fires for an object that declares no nameField at all,\n  // which no business object in this app does.\n  const nameField = nameFieldMap(objectDefs)[objectName] ?? 'name';\n  const built = ACTIVITY_SPECS.map((spec) => activityAction(spec, objectName, nameField));\n  return Object.fromEntries(built.map((a) => [a.name, a])) as Record<\n    (typeof ACTIVITY_SPEC_NAMES)[number],\n    Action\n  >;\n};\n\n/*\n * The family, named. `src/sales/actions/index.ts` re-exports exactly these \u2014\n * the stack is built from `Object.values(actions)`, so every export it forwards\n * must be one Action, never a list of them.\n *\n * Spelled out rather than looped for grep-ability: \"which surface can log a\n * call on a lead?\" has to be answerable with one search, and AGENTS.md trades\n * verbosity for exactly that everywhere else too.\n */\nconst leadActivityActions = activityActionsFor('crm_lead', salesObjects);\nconst contactActivityActions = activityActionsFor('crm_contact', salesObjects);\nconst accountActivityActions = activityActionsFor('crm_account', salesObjects);\nconst opportunityActivityActions = activityActionsFor('crm_opportunity', salesObjects);\n\nexport const LeadLogCallAction: Action = leadActivityActions.log_call;\nexport const LeadLogMeetingAction: Action = leadActivityActions.log_meeting;\nexport const LeadScheduleMeetingAction: Action = leadActivityActions.schedule_meeting;\n\nexport const ContactLogCallAction: Action = contactActivityActions.log_call;\nexport const ContactLogMeetingAction: Action = contactActivityActions.log_meeting;\nexport const ContactScheduleMeetingAction: Action = contactActivityActions.schedule_meeting;\n\nexport const AccountLogCallAction: Action = accountActivityActions.log_call;\nexport const AccountLogMeetingAction: Action = accountActivityActions.log_meeting;\nexport const AccountScheduleMeetingAction: Action = accountActivityActions.schedule_meeting;\n\nexport const OpportunityLogCallAction: Action = opportunityActivityActions.log_call;\nexport const OpportunityLogMeetingAction: Action = opportunityActivityActions.log_meeting;\nexport const OpportunityScheduleMeetingAction: Action = opportunityActivityActions.schedule_meeting;\n\n/*\n * The `crm_case`-scoped triple is NOT built here. `crm_case` is the service\n * package's object, so service instantiates it from this factory \u2014 see\n * `src/service/actions/case-activity.actions.ts`, which keeps the original\n * `LogCallAction` / `LogMeetingAction` / `CaseScheduleMeetingAction` export\n * names because `src/service/pages/case_detail.page.ts` imports them by those\n * names.\n */\n\n// \u26D4 Never add a global (object-less) body action here: it registers under the\n// 'global' key the dispatcher never probes \u2014 see the note on `objectName`\n// above. CSV export in particular needs no action at all; the list grids'\n// built-in `exportOptions: ['csv', 'xlsx']` already cover it.\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/service/actions/case-activity.actions.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/service/actions\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/service/actions/case-activity.actions.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport * as serviceObjects from '../objects';\nimport { activityActionsFor } from '../../sales/actions/activity-actions';\n\n/**\n * The `crm_case`-scoped activity triple \u2014 `log_call`, `log_meeting`,\n * `schedule_meeting` on a case.\n *\n * These three used to be built alongside the other twelve in what is now\n * `src/sales/actions/activity-actions.ts`. `crm_case` is this package's object,\n * so the ACTIONS authored against it are this package's too (plan item 5: an\n * item lives with the object it is authored against) \u2014 but the factory that\n * builds them is not duplicated. It stays in sales, where the other four host\n * objects and the `crm_event` every one of these writes live, and service\n * imports it along the one edge ADR-0130 allows a module to import on:\n * service -> sales, never sideways, never a second copy.\n *\n * The export names are the originals \u2014 `LogCallAction`, `LogMeetingAction`,\n * `CaseScheduleMeetingAction`, with no `Case` prefix on the first two \u2014 because\n * `src/service/index.ts` registers them by those names, and the PR that moved\n * this file renamed nothing it exports. (The case page names them by action id\n * since #1653, not by these exports.)\n *\n * No `: Action` annotation on the three: `activityActionsFor` already returns\n * `Record<kind, Action>`, so each export is typed `Action` without one (#2072\n * dropped the three, and the type-only import they needed, to pay for the case\n * header's three new action ids under the `src/service` token ceiling).\n */\nconst caseActivityActions = activityActionsFor('crm_case', serviceObjects);\n\nexport const LogCallAction = caseActivityActions.log_call;\nexport const LogMeetingAction = caseActivityActions.log_meeting;\nexport const CaseScheduleMeetingAction = caseActivityActions.schedule_meeting;\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/service/actions/knowledge_article.actions.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/service/actions\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/service/actions/knowledge_article.actions.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport type { Action } from '@objectstack/spec/ui';\nimport { P } from '@objectstack/spec';\n\n/**\n * Knowledge article feedback actions.\n *\n * The two buttons that make `helpful_count` / `not_helpful_count` move. Neither\n * writes a counter: each records the reader's own `crm_article_feedback` row,\n * and `article_feedback_metrics_refresh` recounts the article from that table.\n * The full reasoning for the indirection \u2014 a sandboxed action body cannot\n * UPDATE a sharing-ruled object, the article is write-owned, and there is no\n * atomic increment \u2014 is on `src/service/objects/article_feedback.object.ts`.\n *\n * ### One body, generated twice\n *\n * `feedbackBody(verdict)` composes the source string both actions ship. This is\n * FACTORY composition, which is allowed and is what `_case-assignment.ts` does\n * for hooks: the string it returns is complete and self-contained, so the body\n * that reaches the QuickJS sandbox reaches for no module scope. \u26D4 Never write\n * the other shape \u2014 a body that CALLS a shared function at runtime lowers to a\n * `ReferenceError`, because the body ships without its module\n * (`test/action-sandbox.test.ts` fails the build on it, and\n * `test/knowledge-feedback.test.ts` pins that these two bodies stay\n * character-identical apart from the verdict).\n *\n * ### Re-voting UPDATES rather than inserting\n *\n * `crm_article_feedback` carries a unique index on\n * (`crm_knowledge_article`, `owner_id`), so a reader who clicks Helpful and\n * then Not Helpful must move their existing row, not add a second one. The\n * body therefore reads first. Without the dedupe the counters would answer\n * \"how many clicks\", and one enthusiastic reader could out-vote a department.\n *\n * `owner_id` is set EXPLICITLY: an action body runs `isSystem`, so nothing\n * stamps the ownership anchor for it (the same note `clone_opportunity`\n * carries). It is the voter's identity that keys the dedupe, so getting it from\n * `ctx.user` is load-bearing rather than tidy \u2014 a null owner would collapse\n * every anonymous-looking vote onto one row.\n */\nconst feedbackBody = (verdict: 'helpful' | 'not_helpful'): string => `\n      const id = ctx.recordId;\n      if (!id) throw new Error('submit_article_feedback requires a recordId');\n      const userId = ctx.user?.id ?? null;\n      if (!userId) throw new Error('Sign in to rate an article.');\n\n      // One row per (article, reader) \u2014 the unique index says so, and this\n      // read is what keeps a mind-change an UPDATE instead of a duplicate.\n      const existing = await ctx.api.object('crm_article_feedback').findOne({\n        where: { crm_knowledge_article: id, owner_id: userId },\n      });\n\n      if (existing && existing.id) {\n        if (existing.verdict === '${verdict}') {\n          return { ok: true, id: existing.id, verdict: '${verdict}', changed: false };\n        }\n        await ctx.api.object('crm_article_feedback').update(\n          { id: existing.id, verdict: '${verdict}' },\n          { where: { id: existing.id } },\n        );\n        return { ok: true, id: existing.id, verdict: '${verdict}', changed: true };\n      }\n\n      const inserted = await ctx.api.object('crm_article_feedback').insert({\n        crm_knowledge_article: id,\n        verdict: '${verdict}',\n        owner_id: userId,\n      });\n      return { ok: true, id: inserted?.id ?? null, verdict: '${verdict}', changed: true };\n    `;\n\n/**\n * Only PUBLISHED articles collect votes. A draft's counters would describe a\n * version no reader outside the authoring team ever saw, and the review queue\n * reads these numbers as a signal about live content.\n */\nconst publishedOnly = P`has(record.status) && record.status == \"published\"`;\n\nexport const MarkArticleHelpfulAction: Action = {\n  name: 'mark_article_helpful',\n  label: 'Helpful',\n  objectName: 'crm_knowledge_article',\n  icon: 'thumbs-up',\n  type: 'script',\n  body: {\n    language: 'js',\n    source: feedbackBody('helpful'),\n    capabilities: ['api.read', 'api.write'],\n    timeoutMs: 5000,\n  },\n  locations: ['record_header'],\n  visible: publishedOnly,\n  successMessage: 'Thanks \u2014 recorded as helpful.',\n  refreshAfter: true,\n};\n\nexport const MarkArticleNotHelpfulAction: Action = {\n  name: 'mark_article_not_helpful',\n  label: 'Not Helpful',\n  objectName: 'crm_knowledge_article',\n  icon: 'thumbs-down',\n  type: 'script',\n  body: {\n    language: 'js',\n    source: feedbackBody('not_helpful'),\n    capabilities: ['api.read', 'api.write'],\n    timeoutMs: 5000,\n  },\n  locations: ['record_header'],\n  visible: publishedOnly,\n  successMessage: 'Thanks \u2014 recorded as not helpful.',\n  refreshAfter: true,\n};\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/service/dashboards/service.dashboard.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/service/dashboards\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/service/dashboards/service.dashboard.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport type { Dashboard } from '@objectstack/spec/ui';\n\n/**\n * The one dataset every widget below binds (`case_metrics`), written once and\n * passed by shorthand (`dataset,`) rather than spelled out on each widget.\n */\nconst dataset = 'case_metrics';\n\n/**\n * Customer Service Dashboard\n *\n * Case load, SLA health, and resolution performance for the support team.\n * Uses semantic colorVariant tokens (warning/danger/success) and chartConfig\n * palettes instead of raw hex values, mirroring the polished CRM dashboard\n * reference at https://github.com/objectstack-ai/objectui/tree/main/examples/crm.\n *\n * No KPI tile declares a `trend`. A period-over-period delta is a measurement,\n * so it has to come from a real comparison query (widget `compareTo`) once the\n * renderer supports it for dataset metrics \u2014 the percentages this file used to\n * carry were typed by hand and recomputed by nothing, so they kept asserting\n * the same \"-6.2% vs last week\" on any data, including an empty database.\n * Same rule as the executive dashboard (#500, #587).\n */\nexport const ServiceDashboard: Dashboard = {\n  name: 'service_dashboard',\n  label: 'Customer Service',\n  description: 'Case load, SLA health, and resolution performance',\n\n  columns: 12,\n  gap: 4,\n  refreshIntervalSeconds: 60, // 1 minute \u2014 service desks need fresh numbers\n\n  header: {\n    showTitle: true,\n    showDescription: true,\n    // Header action buttons removed: `create_case` is not a defined action and\n    // `/objects/case?owner=current_user` / `/reports/sla` are not in-app view\n    // routes \u2014 all three were dead. Re-add real, wired-up actions here when available.\n  },\n\n  // Historical note (#460 \u2192 #1157): this dashboard shipped without a date\n  // picker from PR #546 until the 17.0.0 GA upgrade, because windowing a\n  // `Field.datetime()` could not be compared \u2014 `driver-sql` 16.1.0 coerced\n  // datetime bounds to epoch-ms INTEGER while every datetime in the database is\n  // ISO TEXT, so `$gte` matched everything and `$lte` matched nothing and the\n  // whole dashboard read zeros. Both named preconditions are fixed and\n  // released: objectstack#3912 (the coercion) and objectstack#3777 (a bare-date\n  // `$lte` dropping same-day rows). The window below is not restored on the\n  // strength of those closures alone \u2014 `test/dashboard-date-range-window.test.ts`\n  // executes it against a real SQLite database and compares every widget to a\n  // ground truth computed in the same run, so a re-regression fails CI here\n  // rather than being discovered as an all-zero dashboard again.\n  //\n  // The range windows `created_at`, the platform's creation stamp (#1992). It\n  // used to window `created_date`, which nothing wrote on a real case, so\n  // every case created through the UI or REST fell outside every range.\n  dateRange: { field: 'created_at', defaultRange: 'last_90_days', allowCustomRange: true },\n\n  globalFilters: [\n    {\n      field: 'owner_id',\n      label: { en: 'Agent', 'zh-CN': '\u8D1F\u8D23\u4EBA', 'es-ES': 'Propietario del Caso', 'ja-JP': '\u30B1\u30FC\u30B9\u62C5\u5F53\u8005' },\n      type: 'lookup',\n      scope: 'dashboard',\n      optionsFrom: { object: 'sys_user', valueField: 'id', labelField: 'name' },\n    },\n    {\n      field: 'priority',\n      label: { en: 'Priority', 'zh-CN': '\u4F18\u5148\u7EA7', 'es-ES': 'Prioridad', 'ja-JP': '\u512A\u5148\u5EA6' },\n      type: 'select',\n      scope: 'dashboard',\n      options: [\n        // zh-CN `critical` is \u4E25\u91CD, never \u7D27\u6025 \u2014 \u7D27\u6025 belongs to crm_task.priority.urgent\n        // and the two vocabularies are distinct sets (ruling #1342). Same wording as\n        // `objects.crm_case.fields.priority.options` in every locale pack.\n        { value: 'critical', label: { en: 'Critical', 'zh-CN': '\u4E25\u91CD', 'es-ES': 'Cr\u00EDtica', 'ja-JP': '\u91CD\u5927' } },\n        { value: 'high',     label: { en: 'High', 'zh-CN': '\u9AD8', 'es-ES': 'Alta', 'ja-JP': '\u9AD8' } },\n        { value: 'medium',   label: { en: 'Medium', 'zh-CN': '\u4E2D', 'es-ES': 'Media', 'ja-JP': '\u4E2D' } },\n        { value: 'low',      label: { en: 'Low', 'zh-CN': '\u4F4E', 'es-ES': 'Baja', 'ja-JP': '\u4F4E' } },\n      ],\n    },\n  ],\n\n  widgets: [\n    // \u2500\u2500\u2500 Row 1: Case-Load KPIs \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n    {\n      id: 'open_cases',\n      title: 'Open Cases',\n      description: 'Cases that are not yet closed',\n      type: 'metric',\n      filter: { is_closed: false },\n      colorVariant: 'orange',\n      dataset, values: ['case_count'],\n      layout: { x: 0, y: 0, w: 3, h: 2 },\n    },\n    {\n      id: 'critical_cases',\n      title: 'Critical Cases',\n      description: 'Open cases marked as critical priority',\n      type: 'metric',\n      filter: { priority: 'critical', is_closed: false },\n      colorVariant: 'danger',\n      dataset, values: ['case_count'],\n      layout: { x: 3, y: 0, w: 3, h: 2 },\n    },\n    {\n      id: 'avg_resolution_time',\n      title: 'Avg Resolution Time',\n      description: 'Mean time to close, in hours',\n      type: 'metric',\n      filter: { is_closed: true },\n      colorVariant: 'blue',\n      dataset, values: ['avg_resolution'],\n      layout: { x: 6, y: 0, w: 3, h: 2 },\n    },\n    {\n      id: 'sla_violations',\n      title: 'SLA Violations',\n      description: 'Cases that breached their SLA',\n      type: 'metric',\n      // Counted at READ time (#2070): a case already flagged, OR a case still\n      // open whose deadline has passed. The second branch is the selection\n      // `case_sla_monitor` sweeps \u2014 same status set, same strict `$lt` at the\n      // current instant (`{now}` is that instant in a query filter; `{NOW()}`\n      // in a flow template) \u2014 so the tile reads true on a deployment that runs\n      // no scheduled work, where nothing flags an open breach. It counts; it\n      // does not act: escalation and the owner's alert still need the sweep.\n      // `test/case-sla-breach-on-close.test.ts` pins the two to one selection.\n      filter: {\n        $or: [\n          { is_sla_violated: true },\n          { status: { $nin: ['resolved', 'closed'] }, sla_due_date: { $lt: '{now}' } },\n        ],\n      },\n      colorVariant: 'warning',\n      dataset, values: ['case_count'],\n      layout: { x: 9, y: 0, w: 3, h: 2 },\n    },\n\n    // \u2500\u2500\u2500 Row 2: Distribution \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n    {\n      id: 'cases_by_status',\n      title: 'Cases by Status',\n      description: 'Workload distribution across the pipeline',\n      type: 'donut',\n      filter: { is_closed: false },\n      colorVariant: 'blue',\n      dataset, dimensions: ['status'], values: ['case_count'],\n      layout: { x: 0, y: 2, w: 4, h: 4 },\n      chartConfig: {\n        showLegend: true,\n        showDataLabels: true,\n        colors: ['#0EA5E9', '#06B6D4', '#14B8A6', '#10B981', '#F59E0B'],\n      },\n    },\n    {\n      id: 'cases_by_priority',\n      title: 'Cases by Priority',\n      description: 'Open case mix by urgency',\n      type: 'pie',\n      filter: { is_closed: false },\n      colorVariant: 'warning',\n      dataset, dimensions: ['priority'], values: ['case_count'],\n      layout: { x: 4, y: 2, w: 4, h: 4 },\n      chartConfig: {\n        showLegend: true,\n        showDataLabels: true,\n        // critical \u2192 high \u2192 medium \u2192 low\n        colors: ['#DC2626', '#F97316', '#F59E0B', '#10B981'],\n      },\n    },\n    {\n      id: 'cases_by_origin',\n      title: 'Cases by Origin',\n      description: 'Where our cases are coming from',\n      type: 'bar',\n      colorVariant: 'purple',\n      dataset, dimensions: ['origin'], values: ['case_count'],\n      layout: { x: 8, y: 2, w: 4, h: 4 },\n      chartConfig: {\n        showLegend: false,\n        showDataLabels: true,\n        colors: ['#8B5CF6'],\n      },\n    },\n\n    // \u2500\u2500\u2500 Row 3: Volume & SLA Trends \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n    {\n      id: 'daily_case_volume',\n      title: 'Daily Case Volume',\n      description: 'New cases created over the last 30 days',\n      type: 'area',\n      filter: { created_at: { $gte: '{30_days_ago}' } },\n      // Opted out ON PURPOSE, re-decided in #1157 rather than inherited.\n      //\n      // The floor above is no longer inert: on 17.0.0 `{30_days_ago}` resolves\n      // to a start-of-day bound the driver compares correctly (measured, with a\n      // ground truth, in `test/dashboard-date-range-window.test.ts`), so this\n      // chart really does plot the last 30 days and its title is true again.\n      // That is exactly why it must not follow the picker: the dashboard range\n      // is ANDed into every bound widget, so a reader who selects \"last 7 days\"\n      // would get a 7-day chart still labelled \"last 30 days\". Self-described\n      // windows opt out \u2014 the same rule the Executive dashboard's YTD tile\n      // follows, pinned by `test/action-references.test.ts`. Binding it instead\n      // would mean dropping this filter and retitling the widget in all four\n      // locale bundles; the fixed 30-day volume trend beside a 90-day case load\n      // is the intended reading.\n      filterBindings: { dateRange: false },\n      colorVariant: 'blue',\n      dataset, dimensions: ['created_at'], values: ['case_count'],\n      layout: { x: 0, y: 6, w: 8, h: 4 },\n      chartConfig: {\n        showLegend: false,\n        showDataLabels: false,\n        colors: ['#0EA5E9'],\n        interaction: { tooltips: true, brush: true },\n      },\n      options: { dateGranularity: 'day' },\n    },\n    {\n      id: 'sla_compliance_gauge',\n      title: 'SLA Compliance',\n      description: 'Percent of cases resolved within SLA this period',\n      type: 'gauge',\n      filter: { is_closed: true },\n      colorVariant: 'success',\n      // Plots COMPLIANCE, the quantity the title, the description, the\n      // success colouring and the 0.95 target line all name (#1213). It used\n      // to plot `avg_sla_violated` \u2014 the complement \u2014 with `options.invert`\n      // asking the renderer to flip it. `invert` is not a declared key on\n      // `DashboardWidgetOptionsSchema`; it rode the `.passthrough()`, nothing\n      // could report it inert, and the gauge read 0.0% on an org with 100%\n      // compliance. The key is gone rather than left pretending: a measure\n      // that means what the widget says is the fix, and the measure's own\n      // label prints under the number, so the two cannot drift apart again.\n      dataset, values: ['sla_compliance_rate'],\n      layout: { x: 8, y: 6, w: 4, h: 4 },\n      chartConfig: {\n        showLegend: false,\n        showDataLabels: true,\n        colors: ['#10B981', '#F59E0B', '#EF4444'],\n        annotations: [\n          { type: 'line', axis: 'y', value: 0.95, label: 'Target', style: 'dashed', color: '#10B981' },\n        ],\n      },\n      // The target line was written for COMPLIANCE and is unchanged: it was\n      // always right \u2014 it was the plotted value that disagreed with it. (The\n      // green/amber/red `options.thresholds` ladder beside it was deleted in\n      // 17.6.0's strict cleanup: no dashboard renderer reads widget\n      // `thresholds`, so it never coloured anything.)\n    },\n\n    // \u2500\u2500\u2500 Row 4: Knowledge deflection (#601) \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n    //\n    // The deflection metric the card asks the service dashboard to show, and\n    // the reason it is THREE tiles rather than one: a ratio widget on its own\n    // is unreadable \u2014 100% could be \"40 of 40\" or \"1 of 1\", and a blank rate\n    // could be \"no closed cases\" or \"no KB resolutions\" (measured: a filtered\n    // measure contributes NO row for a group it selects nothing in, so the\n    // rate comes back absent, not 0). Numerator and denominator therefore ship\n    // beside the percentage, the same rule the sales dashboard's win rate\n    // follows after #614.\n    {\n      id: 'kb_deflection_rate',\n      title: 'KB Deflection Rate',\n      description: 'Share of closed cases resolved with a knowledge article',\n      type: 'metric',\n      colorVariant: 'success',\n      dataset, values: ['kb_deflection_rate'],\n      layout: { x: 0, y: 10, w: 4, h: 2 },\n    },\n    {\n      id: 'kb_resolved_cases',\n      title: 'Resolved by KB',\n      description: 'Closed cases pointing at the article that resolved them',\n      type: 'metric',\n      colorVariant: 'blue',\n      dataset, values: ['kb_resolved_count'],\n      layout: { x: 4, y: 10, w: 4, h: 2 },\n    },\n    {\n      id: 'closed_cases_total',\n      title: 'Closed Cases',\n      description: 'The denominator behind the deflection rate',\n      type: 'metric',\n      colorVariant: 'default',\n      dataset, values: ['closed_count'],\n      layout: { x: 8, y: 10, w: 4, h: 2 },\n    },\n    {\n      id: 'top_resolving_articles',\n      title: 'Top Resolving Articles',\n      description: 'Knowledge articles ranked by the closed cases they resolved',\n      type: 'table',\n      filter: { is_closed: true },\n      colorVariant: 'default',\n      dataset, dimensions: ['resolved_article'], values: ['kb_resolved_count'],\n      layout: { x: 0, y: 12, w: 12, h: 4 },\n      options: {\n        sortBy: 'kb_resolved_count',\n        sortOrder: 'desc',\n        limit: 10,\n      },\n    },\n\n    // \u2500\u2500\u2500 Row 5: My Open Cases by Priority \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n    // A dashboard `table` binds to an analytics cube and aggregates; it cannot\n    // list individual cases (ADR-0021) \u2014 for the case-by-case queue, use the\n    // my_open_cases ListView (\"My Cases\" in the My Work nav group).\n    // `{current_user_id}` scopes what this widget SHOWS; it is presentation\n    // scope, not an access boundary \u2014 row-level security owns that (#510).\n    {\n      id: 'my_open_cases_by_priority',\n      title: 'My Open Cases by Priority',\n      description: 'Your open cases and their SLA-violation rate, broken down by priority',\n      type: 'table',\n      filter: { is_closed: false, owner_id: '{current_user_id}' },\n      // Opts out of the Agent global filter (keyed by its field, `owner_id`):\n      // ANDing an agent pick into \"mine\" empties the widget for anyone else.\n      filterBindings: { owner_id: false },\n      colorVariant: 'default',\n      dataset, dimensions: ['priority'], values: ['case_count', 'avg_sla_violated'],\n      layout: { x: 0, y: 16, w: 12, h: 4 },\n      options: {\n        sortBy: 'case_count',\n        sortOrder: 'desc',\n        limit: 10,\n      },\n    },\n  ],\n};\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/service/datasets/case.dataset.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/service/datasets\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/service/datasets/case.dataset.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport { defineDataset } from '@objectstack/spec/ui';\n\n/**\n * Case analytics dataset (ADR-0021) \u2014 the semantic source of truth for the\n * Service dashboard's case counts, resolution time and SLA compliance.\n */\nexport const CaseDataset = defineDataset({\n  name: 'case_metrics',\n  label: 'Case Metrics',\n  description: 'Semantic layer for support-case counts, resolution time and SLA',\n  object: 'crm_case',\n\n  dimensions: [\n    { name: 'status', label: 'Status', field: 'status', type: 'string' },\n    { name: 'priority', label: 'Priority', field: 'priority', type: 'string' },\n    { name: 'origin', label: 'Origin', field: 'origin', type: 'string' },\n    { name: 'type', label: 'Type', field: 'type', type: 'string' },\n    // The platform's creation stamp (#1992) \u2014 the same dimension\n    // `account_metrics` and `lead_metrics` declare, bucketed by day here.\n    { name: 'created_at', label: 'Created', field: 'created_at', type: 'date', dateGranularity: 'day' },\n    // Article ranking by resolutions (#601) \u2014 group closed cases by the\n    // article that resolved them. `type: 'lookup'`, the same spelling the\n    // `owner` dimension on `opportunity_metrics` uses for `owner_id`.\n    { name: 'resolved_article', label: 'Resolving Article', field: 'resolved_by_article', type: 'lookup' },\n  ],\n\n  measures: [\n    { name: 'case_count', label: 'Cases', aggregate: 'count' },\n    { name: 'avg_resolution', label: 'Avg Resolution (h)', aggregate: 'avg', field: 'resolution_time_hours', format: '0.0' },\n    { name: 'avg_sla_violated', label: 'SLA Violation Rate', aggregate: 'avg', field: 'is_sla_violated', format: '0.0%' },\n\n    // \u2500\u2500\u2500 Knowledge deflection (#601) \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n    //\n    // \"% of closed cases resolved with an article\". Built to the shape\n    // `opportunity_metrics.win_rate` arrived at the hard way (#593/#614): the\n    // two halves of the ratio are declared HERE as named measures, once, so no\n    // widget improvises a denominator \u2014 a wrong denominator does not error, it\n    // returns a plausible number.\n    //\n    // Each half carries its OWN `filter`, which the executor runs as a\n    // sub-query and merges back on the selected dimensions. A widget-level\n    // filter cannot express this: it would narrow BOTH halves to the same row\n    // set, which is how you end up dividing a number by itself.\n    //\n    // `kb_resolved_count` counts the COLUMN, not the rows: `count(<field>)`\n    // counts non-NULL values, so it needs no `$ne: null` predicate and no\n    // parallel boolean flag to drift out of step with the lookup. MEASURED on\n    // 17.0.0-rc.6 against both drivers \u2014 the numbers are pinned in\n    // `test/knowledge-deflection.test.ts`. The one thing it CANNOT discount is\n    // an empty string, which is non-NULL; that is why the blank is normalised\n    // to NULL at write time by `case_resolution_article_normalize`, and why\n    // that hook is part of this metric rather than a tidy-up beside it.\n    //\n    // Every widget that shows `kb_deflection_rate` also shows\n    // `kb_resolved_count` and `closed_count` beside it, so a reader can check\n    // the arithmetic that produced the percentage.\n    { name: 'closed_count', label: 'Closed Cases', aggregate: 'count', filter: { is_closed: true } },\n    {\n      name: 'kb_resolved_count',\n      label: 'Resolved by KB',\n      aggregate: 'count',\n      field: 'resolved_by_article',\n      filter: { is_closed: true },\n    },\n    {\n      name: 'kb_deflection_rate',\n      label: 'KB Deflection Rate',\n      derived: { op: 'ratio', of: ['kb_resolved_count', 'closed_count'] },\n      format: '0%',\n    },\n\n    // \u2500\u2500\u2500 SLA compliance (#1213) \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n    //\n    // The service dashboard's gauge asks \"are we meeting SLA?\", so the number\n    // it plots has to BE compliance. It used to plot `avg_sla_violated` \u2014 the\n    // complement \u2014 and ask the renderer to flip it with `options.invert`. That\n    // key is not declared by `DashboardWidgetOptionsSchema`; it rides the\n    // schema's `.passthrough()`, so no validator, lint rule or gate could ever\n    // tell the author it does nothing \u2014 and none did. The gauge read 0.0% on\n    // an org with 100% compliance.\n    //\n    // Spelled as a ratio of two counts rather than `1 - avg_sla_violated`\n    // because `DerivedMeasureOp` operands are MEASURE NAMES only (`of:\n    // string[]` \u2014 \"no raw fields, no raw SQL\"), so there is no literal `1` to\n    // subtract from. `difference` cannot express it either. This is the card's\n    // own second option and the spec's sanctioned shape \u2014 the one\n    // `kb_deflection_rate` above already uses.\n    //\n    // `is_sla_violated: false`, not `$ne: true`: the field declares\n    // `defaultValue: false`, and MEASURED on both drivers this app runs, a\n    // closed case inserted without the column stores `false` rather than NULL.\n    // So `sla_met_count + violated = closed_count` holds with no NULL hole.\n    // Both spellings measured identical (2 of 3, both drivers); the plain one\n    // is the one that reads as what it means.\n    //\n    // The denominator is `closed_count`, already declared above \u2014 the same\n    // measure the `closed_cases_total` tile shows, so a reader can check the\n    // percentage against a number on the same page. An empty numerator group\n    // does NOT blank the rate: the executor fills a `count` column's empty\n    // group with 0 BEFORE evaluating derived measures, so a fully-breached org\n    // reads 0%, not blank. A zero DENOMINATOR (no closed cases at all) does\n    // return null \u2014 \"no data\", which is the honest reading.\n    { name: 'sla_met_count', label: 'Cases Within SLA', aggregate: 'count', filter: { is_closed: true, is_sla_violated: false } },\n    {\n      name: 'sla_compliance_rate',\n      label: 'SLA Compliance Rate',\n      derived: { op: 'ratio', of: ['sla_met_count', 'closed_count'] },\n      format: '0%',\n    },\n  ],\n});\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/sales/email-templates/_bundle.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/sales/email-templates\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/sales/email-templates/_bundle.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport type { EmailTemplateDefinition } from '@objectstack/spec/system';\n\n/**\n * The one spelling of \"a locale pack becomes `sys_email_template` rows\",\n * shared by every package that owns notification templates.\n *\n * `EmailTemplateDefinition` carries ONE `locale` per row, so an n-language\n * bundle is n rows of the same `name` \u2014 that is the spec's own key, not a\n * convention this repo picked. Writing those rows out by hand would mean\n * repeating `name` and the row scaffolding four times per\n * template; here each locale pack states only what actually differs between\n * languages (the label and the two bodies) and this helper produces the rows.\n *\n * It lives in `src/sales/` because `src/service/` and `src/revenue/` both need\n * it: a source more than one package needs has one deterministic home, the\n * lowest package all its consumers depend on (AGENTS.md import rule 2), and\n * modules import it along their edge into sales \u2014 the same placement as\n * `flows/_guarded-iteration.ts` and `objects/_hook-api.ts`.\n */\n\n/**\n * What one template looks like in ONE language \u2014 every field of\n * `EmailTemplateDefinition` whose value is genuinely per-locale.\n *\n * `label` is in here because it is the Studio display name an administrator\n * reads, so it localizes with the content; `name` and `locale` are not, and\n * {@link bundle} supplies them once per row.\n */\nexport interface LocalizedEmailTemplate {\n  /** Studio display label for this template, in this language. */\n  label: string;\n  /** Subject line; `{{var}}` holes are filled from the notify node's `templateData`. */\n  subject: string;\n  /** HTML body; same `{{var}}` holes. `bodyText` is derived by the service when omitted. */\n  bodyHtml: string;\n}\n\n/** One language's face of every template a package owns, keyed by template name. */\nexport type EmailTemplatePack = Record<string, LocalizedEmailTemplate>;\n\n/**\n * Cross a package's locale packs into the flat `(name, locale)` rows\n * `defineStack({ emailTemplates })` takes.\n *\n * \u26A0\uFE0F The ENGLISH pack is registered under `en-US`, not `en`, and that is the\n * resolution ladder's doing rather than a style choice.\n * `EmailService.resolveAndRenderTemplate` matches `(name, locale)` EXACTLY,\n * then retries exactly once against its own `DEFAULT_TEMPLATE_LOCALE` \u2014 the\n * literal `'en-US'`. A recipient whose `sys_user.locale` is this app's default\n * `'en'` therefore misses on the first probe and lands on the second; a\n * recipient carrying `'en-US'` (or any locale this app ships no pack for)\n * lands on it directly. Tagging the rows `'en'` instead would invert that:\n * `'en-US'` is a truthy preferred locale, so the third probe is skipped and\n * the send fails with `TEMPLATE_NOT_FOUND`. `'en-US'` is the tag that cannot\n * strand a recipient.\n */\nexport const bundle = (packs: Record<string, EmailTemplatePack>): EmailTemplateDefinition[] =>\n  Object.entries(packs).flatMap(([locale, pack]) =>\n    Object.entries(pack).map(([name, row]) => ({ name, locale, ...row })));\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/service/email-templates/en.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/service/email-templates\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/service/email-templates/en.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport type { EmailTemplatePack } from '../../sales/email-templates/_bundle';\n\n/**\n * English (en-US) \u2014 the service package's notification templates.\n *\n * Every string is the text its `notify` node already sent, with the flow's\n * `{var.path}` interpolations re-expressed as the `{{key}}` holes the renderer\n * fills from that node's `templateData`. \u26A0\uFE0F Tagged `en-US`, not `en` \u2014 see the\n * resolution-ladder note on `bundle()`.\n */\nexport const en: EmailTemplatePack = {\n  'crm.case_escalated': {\n    label: 'Case Escalated',\n    subject: 'Case escalated: {{case_number}}',\n    bodyHtml: '<p>Case {{case_number}} ({{priority}}) has been auto-escalated on critical priority. Ownership passes to the service manager with the lightest load; while nobody holds that position the case stays with you. Open the case to see who owns it now.</p>',\n  },\n  'crm.case_sla_breach': {\n    label: 'Case SLA Breached',\n    subject: 'SLA breached: case {{case_number}}',\n    bodyHtml: '<p>Case {{case_number}} ({{priority}}) passed its SLA due date and has been auto-escalated.</p>',\n  },\n};\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/service/email-templates/zh-CN.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/service/email-templates\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/service/email-templates/zh-CN.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport type { EmailTemplatePack } from '../../sales/email-templates/_bundle';\n\n/** \u7B80\u4F53\u4E2D\u6587 (zh-CN) \u2014 the service package's notification templates. See `en.ts`. */\nexport const zhCN: EmailTemplatePack = {\n  'crm.case_escalated': {\n    label: '\u5DE5\u5355\u5DF2\u5347\u7EA7',\n    subject: '\u5DE5\u5355\u5DF2\u5347\u7EA7\uFF1A{{case_number}}',\n    bodyHtml: '<p>\u5DE5\u5355 {{case_number}}\uFF08{{priority}}\uFF09\u56E0\u4E25\u91CD\u7EA7\u522B\u5DF2\u81EA\u52A8\u5347\u7EA7\u3002\u6240\u6709\u6743\u5C06\u8F6C\u4EA4\u7ED9\u5F53\u524D\u8D1F\u8377\u6700\u8F7B\u7684\u670D\u52A1\u7ECF\u7406\uFF1B\u82E5\u8BE5\u804C\u4F4D\u6682\u65E0\u4EBA\u62C5\u4EFB\uFF0C\u5DE5\u5355\u4ECD\u5F52\u60A8\u6240\u6709\u3002\u8BF7\u6253\u5F00\u5DE5\u5355\u67E5\u770B\u5F53\u524D\u8D1F\u8D23\u4EBA\u3002</p>',\n  },\n  'crm.case_sla_breach': {\n    label: '\u5DE5\u5355 SLA \u8D85\u65F6',\n    subject: 'SLA \u8D85\u65F6\uFF1A\u5DE5\u5355 {{case_number}}',\n    bodyHtml: '<p>\u5DE5\u5355 {{case_number}}\uFF08{{priority}}\uFF09\u5DF2\u8D85\u8FC7 SLA \u5230\u671F\u65F6\u95F4\uFF0C\u5E76\u5DF2\u81EA\u52A8\u5347\u7EA7\u3002</p>',\n  },\n};\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/service/email-templates/ja-JP.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/service/email-templates\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/service/email-templates/ja-JP.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport type { EmailTemplatePack } from '../../sales/email-templates/_bundle';\n\n/** \u65E5\u672C\u8A9E (ja-JP) \u2014 the service package's notification templates. See `en.ts`. */\nexport const jaJP: EmailTemplatePack = {\n  'crm.case_escalated': {\n    label: '\u30B1\u30FC\u30B9\u306E\u30A8\u30B9\u30AB\u30EC\u30FC\u30B7\u30E7\u30F3',\n    subject: '\u30B1\u30FC\u30B9\u304C\u30A8\u30B9\u30AB\u30EC\u30FC\u30B7\u30E7\u30F3\u3055\u308C\u307E\u3057\u305F: {{case_number}}',\n    bodyHtml: '<p>\u30B1\u30FC\u30B9 {{case_number}}\uFF08{{priority}}\uFF09\u306F\u91CD\u5927\u5EA6\u304C\u9AD8\u3044\u305F\u3081\u81EA\u52D5\u7684\u306B\u30A8\u30B9\u30AB\u30EC\u30FC\u30B7\u30E7\u30F3\u3055\u308C\u307E\u3057\u305F\u3002\u6240\u6709\u6A29\u306F\u8CA0\u8377\u306E\u6700\u3082\u8EFD\u3044\u30B5\u30FC\u30D3\u30B9\u30DE\u30CD\u30FC\u30B8\u30E3\u30FC\u306B\u79FB\u308A\u307E\u3059\u3002\u305D\u306E\u5F79\u8077\u306B\u8AB0\u3082\u3044\u306A\u3044\u9593\u306F\u3001\u30B1\u30FC\u30B9\u306F\u3042\u306A\u305F\u306E\u307E\u307E\u3067\u3059\u3002\u30B1\u30FC\u30B9\u3092\u958B\u3044\u3066\u73FE\u5728\u306E\u6240\u6709\u8005\u3092\u3054\u78BA\u8A8D\u304F\u3060\u3055\u3044\u3002</p>',\n  },\n  'crm.case_sla_breach': {\n    label: '\u30B1\u30FC\u30B9\u306E SLA \u8D85\u904E',\n    subject: 'SLA \u8D85\u904E: \u30B1\u30FC\u30B9 {{case_number}}',\n    bodyHtml: '<p>\u30B1\u30FC\u30B9 {{case_number}}\uFF08{{priority}}\uFF09\u306F SLA \u671F\u9650\u3092\u904E\u304E\u305F\u305F\u3081\u3001\u81EA\u52D5\u7684\u306B\u30A8\u30B9\u30AB\u30EC\u30FC\u30B7\u30E7\u30F3\u3055\u308C\u307E\u3057\u305F\u3002</p>',\n  },\n};\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/service/email-templates/es-ES.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/service/email-templates\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/service/email-templates/es-ES.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport type { EmailTemplatePack } from '../../sales/email-templates/_bundle';\n\n/** Espa\u00F1ol (es-ES) \u2014 the service package's notification templates. See `en.ts`. */\nexport const esES: EmailTemplatePack = {\n  'crm.case_escalated': {\n    label: 'Caso escalado',\n    subject: 'Caso escalado: {{case_number}}',\n    bodyHtml: '<p>El caso {{case_number}} ({{priority}}) se ha escalado autom\u00E1ticamente por prioridad cr\u00EDtica. La propiedad pasa al responsable de servicio con menos carga; mientras nadie ocupe ese puesto, el caso sigue siendo tuyo. Abre el caso para ver qui\u00E9n lo tiene ahora.</p>',\n  },\n  'crm.case_sla_breach': {\n    label: 'SLA del caso incumplido',\n    subject: 'SLA incumplido: caso {{case_number}}',\n    bodyHtml: '<p>El caso {{case_number}} ({{priority}}) super\u00F3 su fecha l\u00EDmite de SLA y se ha escalado autom\u00E1ticamente.</p>',\n  },\n};\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/service/email-templates/crm.email-template.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/service/email-templates\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/service/email-templates/crm.email-template.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport type { EmailTemplateDefinition } from '@objectstack/spec/system';\nimport { bundle } from '../../sales/email-templates/_bundle';\nimport { en } from './en';\nimport { zhCN } from './zh-CN';\nimport { jaJP } from './ja-JP';\nimport { esES } from './es-ES';\n\n/**\n * Service \u2014 every `sys_email_template` row this package's `notify` nodes name.\n *\n * Four locale packs crossed with two template names. `bundle()` is imported\n * along this module's edge into sales, the one deterministic home for a source\n * more than one package needs.\n */\nexport const ServiceEmailTemplates: EmailTemplateDefinition[] = bundle({\n  'en-US': en,\n  'zh-CN': zhCN,\n  'ja-JP': jaJP,\n  'es-ES': esES,\n});\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/service/flows/case-escalation.flow.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/service/flows\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/service/flows/case-escalation.flow.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport { P, cel } from '@objectstack/spec';\nimport type * as Automation from '@objectstack/spec/automation';\ntype Flow = Automation.Flow;\n\n/** Case Escalation \u2014 auto-escalate high-priority cases */\nexport const CaseEscalationFlow: Flow = {\n  name: 'case_escalation',\n  label: 'Case Escalation Process',\n  description: 'Automatically escalate high-priority cases',\n  type: 'record_change',\n  status: 'active',\n  // A record-change flow fired by a SYSTEM write carries no trigger user\n  // either \u2014 the user-less exposure is NOT schedule-only (ADR-0049), and the\n  // platform's own build-time lint cannot see this shape\n  // because it is only knowable at run time. Measured on 17.0.0-rc.2: a\n  // user-less run refuses the very first data node \u2014 \"[runAs] refusing a data\n  // operation (object 'crm_case', event 'record-after-update')\" \u2014 so a case\n  // raised by the seed loader, an integration, or another runAs:'system'\n  // flow's write silently keeps its critical priority forever.\n  //\n  // Elevating the USER-driven runs too is correct here: escalation is a\n  // service-level policy, not the writer's own edit. Both data nodes are keyed\n  // to `{record.id}` \u2014 the row that just fired the trigger \u2014 so user scope\n  // buys no restriction that matters, while it does add a failure mode: an\n  // agent may legitimately raise a case without holding edit rights on the\n  // escalation lifecycle fields (`is_escalated` / `escalated_date` / `status`).\n  // This also puts the flow on the same footing as `case_sla_monitor`, which\n  // performs the same escalation on a schedule under `runAs: 'system'`.\n  runAs: 'system',\n\n  variables: [\n    { name: 'caseId', type: 'text', isInput: true, isOutput: false },\n  ],\n\n  nodes: [\n    {\n      // Trigger wiring (7.4): bind to afterUpdate and gate on the critical\n      // transition. The re-fire guard MUST NOT rely on the boolean\n      // `is_escalated`: this flow's own escalation write re-triggers\n      // record-after-update, and on SQLite/libsql a boolean persists as integer\n      // `1`, so `record.is_escalated != true` is `1 != true` = true \u2014 the guard\n      // never trips and the flow loops forever (it wedged a first-boot seed on\n      // 2026-07-06). Instead:\n      // - `escalated_date == null` marks \"never escalated\" (the escalation write\n      //   stamps it, suppressing the second fire AND any re-escalation when an\n      //   agent later moves the case back to in_progress to work it);\n      // - the status terms keep the flow off cases already escalated or already\n      //   finished \u2014 without them a critical case could never be resolved or\n      //   closed (the flow would yank `status` straight back to `escalated`).\n      id: 'start', type: 'start', label: 'Start',\n      config: {\n        objectName: 'crm_case',\n        triggerType: 'record-after-update',\n        // Also suppress on closed/resolved: closing a critical case is itself\n        // an afterUpdate, and with only the `!= \"escalated\"` guard this flow\n        // re-escalated the case the moment it was closed (observed live:\n        // close_case wrote status \"closed\", this flow immediately rewrote it\n        // to \"escalated\"). Status strings are the reliable guard \u2014 comparing\n        // the boolean is_closed suffers the SQLite `1 != true` trap above.\n        // `escalated_date == null` additionally keeps a case that was already\n        // escalated once (then reopened) from being escalated again.\n        //\n        // TOTALITY: every `record.x` read carries a `has(record.x)`\n        // guard \u2014 see the house-rule block in\n        // `test/flow-condition-totality.test.ts`. Measured end-to-end on\n        // driver-memory: a case BORN critical is stored without an\n        // `escalated_date` column at all, `record.escalated_date == null`\n        // aborted with `No such key: escalated_date`, and this flow never ran\n        // on the very population it exists for. The guards below preserve the\n        // predicate's answer on every shape where it previously had one.\n        // `escalated_date` absent means the same as null (\"never escalated\");\n        // an absent `status` cannot be a terminal status, so it must not\n        // suppress the escalation.\n        condition: P`has(record.priority) && record.priority == \"critical\"\n          && (!has(record.escalated_date) || record.escalated_date == null)\n          && (!has(record.status)\n            || (record.status != \"escalated\" && record.status != \"resolved\" && record.status != \"closed\"))`,\n      },\n    },\n    {\n      id: 'get_case', type: 'get_record', label: 'Get Case Record',\n      config: { objectName: 'crm_case', filter: { id: cel`record.id` }, outputVariable: 'caseRecord' },\n    },\n    {\n      // The `label` names what this node actually does: it flags the case as\n      // escalated (see `fields` below) and reassigns nothing. The `id` keeps\n      // its original `assign_senior_agent` spelling on purpose \u2014 `edges[]`\n      // reference nodes by id, and `CaseEscalationOnCreateFlow` rewrites the\n      // node list by id, so renaming one is a behaviour change, not a wording\n      // fix.\n      id: 'assign_senior_agent', type: 'update_record', label: 'Flag as Escalated',\n      config: {\n        objectName: 'crm_case', filter: { id: cel`record.id` },\n        // `escalation_reason` must be set whenever `is_escalated` flips true \u2014 the\n        // object's `escalation_reason_required` validation rejects the write\n        // otherwise (which silently aborted this flow until it was supplied).\n        //\n        // \u26D4 This node writes NO owner, and cannot: reassigning from a flow\n        // would mean `{caseRecord.owner_id.manager}`, and a flow template\n        // cannot traverse a lookup \u2014 it interpolates to the literal \"undefined\"\n        // and would orphan the case under a phantom owner. The hand-off does not\n        // need to happen here: this very update fires the\n        // `case_escalation_reassign` beforeUpdate hook\n        // (`src/service/objects/_case-assignment.ts`), which puts the case with the\n        // least-loaded holder of the flat `service_manager` position \u2014 a pool,\n        // which the app can resolve, rather than a manager chain, which it\n        // cannot. With that pool unstaffed the case keeps its owner and this\n        // write is unchanged.\n        fields: { is_escalated: true, escalation_reason: 'Auto-escalated: critical priority', escalated_date: cel`isoDatetime(now())`, status: 'escalated' },\n      },\n    },\n    // No `create_task` node here: the escalation write above flips `status` to\n    // `escalated`, which fires the `case_status_side_effects` hook \u2014 the single\n    // owner of escalation follow-up tasks (it also covers the `escalate_case`\n    // action and the SLA monitor). A second task node here produced duplicate,\n    // disagreeing tasks (case owner/high vs account owner/urgent) per escalation.\n    {\n      // Gateway only \u2014 the live predicate is on the out-edge `e4`. The engine\n      // never reads a `decision` node's singular `config.condition`, so a copy\n      // here would restate the gate without BEING the gate\n      // (`flow-inert-node-condition`); `pnpm lint` \u2014 `os lint --strict` \u2014\n      // fails on that.\n      //\n      // Why the gate exists: `crm_case.owner_id` is NULLABLE and an unowned case\n      // is an ordinary state \u2014 this repo ships `scripts/backfill-owner-id.ts`\n      // and `pnpm backfill:owner` precisely because ownerless rows happen, and\n      // ordinary REST creation / import reach the same state. `notify_team`\n      // below addresses exactly ONE recipient, so an ownerless case leaves it\n      // with an empty slate, which the builtin node treats as a HARD failure:\n      // `execute` returns `success: false`, `executeNode` turns that into a\n      // throw, and the run ends `status: 'failed'`.\n      //\n      // BLAST RADIUS, stated precisely because it differs from the sibling\n      // defect in `case_sla_monitor` and the difference is structural: these two\n      // are `record_change` flows with NO loop, so one ownerless case kills only\n      // its OWN run \u2014 there is no queue of other records behind it. A `schedule`\n      // flow whose work sits inside a `loop` awaits `runRegion` with no\n      // try/catch, and there one ownerless row takes down every record ordered\n      // behind it.\n      //\n      // \u26D4 The gate sits AFTER `assign_senior_agent`, which stays\n      // UNCONDITIONAL: the escalation itself must still land (measured\n      // `is_escalated: true`, `status: 'escalated'` on every failing run), so an\n      // ownerless critical case stays visible in views and reports. Only the\n      // notify is gated \u2014 and here that loses nothing a reader would want,\n      // because `caseRecord` is read by `get_case` UPSTREAM of the escalation\n      // write, so `{caseRecord.owner_id}` is deliberately the owner the case had\n      // BEFORE the hand-off. With no such person there is no \"previous owner\"\n      // for the message to be addressed to.\n      //\n      // \u26A0\uFE0F This guard is exactly the duplication objectstack#13682 exists to\n      // retire \u2014 `notify` should treat an empty audience as a RECORDED SKIP\n      // rather than a hard failure. When that lands, delete this node and edge\n      // `e4`'s predicate here, and the same pair in `case-sla-monitor.flow.ts`.\n      id: 'check_owner', type: 'decision', label: 'Case Has an Owner?',\n    },\n    {\n      // ADR-0012: the dedicated `notify` node dispatches through the messaging\n      // service (inbox + email + push). The legacy `script` + `actionType:'email'`\n      // shape is a no-op stub in 7.4 and never delivered anything.\n      // Owner only: `{caseRecord.owner_id.manager}` cannot traverse a lookup in\n      // flow templates \u2014 it interpolates to the literal \"undefined\".\n      // The `label` names the single recipient this node has (`recipients`\n      // below); the `id` keeps its `notify_team` spelling because `edges[]`\n      // reference it. Cf. the same node in `case-sla-monitor.flow.ts`, whose\n      // label already says `Alert Owner`.\n      id: 'notify_team', type: 'notify', label: 'Notify Case Owner',\n      config: {\n        // Owner only, and the owner it reaches is the one the case had BEFORE\n        // the escalation: `caseRecord` was read by `get_case` upstream of the\n        // write, so `{caseRecord.owner_id}` is the agent being handed off from\n        // \u2014 exactly the person this message is for. Flow templates cannot\n        // traverse a lookup (see the note on `assign_senior_agent` above):\n        // `{caseRecord.owner_id.manager}` and `{caseRecord.crm_account.name}`\n        // both interpolate to the literal string \"undefined\" \u2014 a phantom\n        // recipient and a garbled body.\n        recipients: [cel`caseRecord.owner_id`],\n        channels: ['inbox', 'email'],\n        severity: 'critical',\n        topic: 'case_escalated',\n        // \u26A0\uFE0F The body \u2014 now `crm.case_escalated` in `../email-templates/`, one\n        // row per locale \u2014 must stay true on BOTH outcomes. \"It remains\n        // assigned to you\" is false whenever the hand-off finds a manager; the\n        // opposite claim (\"it has been reassigned\") is false whenever the\n        // `service_manager` pool is unstaffed, which is the first-install norm.\n        // So it states the rule and points at the record for the answer, in\n        // every language.\n        template: 'crm.case_escalated',\n        templateData: { case_number: cel`caseRecord.case_number`, priority: cel`caseRecord.priority` },\n        actionUrl: '/crm_case/{{record.id}}',\n      },\n    },\n    { id: 'end', type: 'end', label: 'End' },\n  ],\n\n  edges: [\n    { id: 'e1', source: 'start', target: 'get_case', type: 'default' },\n    { id: 'e2', source: 'get_case', target: 'assign_senior_agent', type: 'default' },\n    { id: 'e3', source: 'assign_senior_agent', target: 'check_owner', type: 'default' },\n    // The gate. A `decision` with no matching out-edge simply ends the run\n    // here, after the escalation has already been written.\n    //\n    // TOTALITY: `caseRecord` is a `get_record` OUTPUT \u2014 a raw driver row, sparse\n    // in the way `driver-memory` / `driver-mongodb` store only the columns a row\n    // was written with \u2014 so only `has()` is total, and it must be `vars.`-scoped\n    // (measured: bare `has(caseRecord.owner_id)` still aborts with `Unknown\n    // variable` on an unbound root, while `has(vars.caseRecord)` answers\n    // `false`).\n    //\n    // \u26D4 EVERY TERM IS LOAD-BEARING \u2014 do not simplify this predicate. The last\n    // one MIRRORS THE NOTIFY NODE'S OWN emptiness rule rather than guessing at\n    // it: builtin `notify` builds its audience with `String(v).trim()` +\n    // `.filter(Boolean)`, so null, undefined, `''` and any all-whitespace value\n    // all collapse to the same empty slate. Each term was measured through\n    // `evaluateCondition` on the shape it alone covers, by dropping it and\n    // recording what the rest do:\n    //   - `has(vars.caseRecord)` \u2014 an UNBOUND root. Without it the predicate\n    //     aborts with `No such key: caseRecord`. `get_case` binds the variable\n    //     on every path here (it sets it even when it matched nothing), so this\n    //     term is what keeps a future graph edit from turning a gate into an\n    //     abort \u2014 and the `vars.`-scoped `has()` pair is the house rule\n    //     `test/flow-variable-conditions.test.ts` enforces.\n    //   - `has(vars.caseRecord.owner_id)` \u2014 the ABSENT key. Without it,\n    //     `vars.caseRecord.owner_id != null` aborts with `No such key: owner_id`.\n    //   - `vars.caseRecord.owner_id != null` \u2014 the explicit NULL. Without it the\n    //     wrap is handed one and aborts with `no matching overload for\n    //     'string(null)'`, so this term must short-circuit in front of it.\n    //   - `string(...).trim() != \"\"` \u2014 the BLANK/whitespace id. `'   ' != \"\"` is\n    //     TRUE in CEL, so a gate written that way opens for a whitespace\n    //     `owner_id` and reproduces this very defect one input narrower. The\n    //     `string()` wrap is not decoration either: measured, a bare `.trim()`\n    //     on a numeric id aborts with `no matching overload for\n    //     'double.trim()'` and `.matches()` with `'double.matches(string)'` \u2014 a\n    //     thrown condition, the fault mode this gate exists to remove.\n    //\n    // \u26D4 Do NOT add a `vars.caseRecord != null` term for the row that is GONE by\n    // the time `get_case` reads it. Measured INERT: `get_record` with no match\n    // sets the variable to `null`, key present, and `has()` on a null base\n    // answers `false` rather than aborting, so the four terms above already\n    // close that shape (`test/flow-escalation-ownerless-case.test.ts` covers\n    // it). A term that cannot change an answer is an inert copy, not defence in\n    // depth.\n    { id: 'e4', source: 'check_owner', target: 'notify_team', type: 'conditional', condition: P`has(vars.caseRecord) && has(vars.caseRecord.owner_id)\n      && vars.caseRecord.owner_id != null && string(vars.caseRecord.owner_id).trim() != \"\"`, label: 'Has owner' },\n    { id: 'e5', source: 'notify_team', target: 'end', type: 'default' },\n  ],\n};\n\n/**\n * Insert-time twin of `case_escalation`: a record-change flow binds exactly one\n * hook event, so the afterUpdate flow above never sees cases that are BORN\n * critical (phone-in P1s \u2014 the common path). Same nodes/edges, only the start\n * node is rebound to afterInsert. The `escalated_date == null` + status guard\n * carries over untouched (a case born critical has neither).\n */\nexport const CaseEscalationOnCreateFlow: Flow = {\n  ...CaseEscalationFlow,\n  name: 'case_escalation_on_create',\n  label: 'Case Escalation Process (on create)',\n  description: 'Escalate cases created critical (insert-time twin of case_escalation)',\n  nodes: CaseEscalationFlow.nodes.map((n) =>\n    n.id === 'start'\n      ? { ...n, config: { ...n.config, triggerType: 'record-after-create' } }\n      : n,\n  ),\n};\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/service/flows/case-actions.flow.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/service/flows\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/service/flows/case-actions.flow.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport { cel } from '@objectstack/spec';\nimport type * as Automation from '@objectstack/spec/automation';\nimport { CLAIMABLE_TARGET_STATUSES } from '../objects/_case-assignment';\ntype Flow = Automation.Flow;\n\n/**\n * Screen flows behind the Claim Case / Escalate Case / Close Case header\n * actions.\n *\n * \u26D4 Never re-express these as `body`-typed actions (verified against the\n * running 16.1.0 console, 2026-07-28):\n *\n *  - `type: 'modal'` never executes the body at all \u2014 on submit the console\n *    resolves the action `target` as an OBJECT name and dies on\n *    `GET /api/v1/meta/object/<target>` \u2192 400 (\"Error loading form\").\n *  - `type: 'script'` DOES reach `POST /api/v1/actions/...`, but a body that\n *    UPDATES a record on an object with sharing rules is rejected by the\n *    sharing middleware (\"FORBIDDEN: insufficient privileges to update\n *    crm_case \u2026\") \u2014 the sandbox execution context does not carry the caller\n *    identity, so `canEdit` fails even for the record owner. Inserts are\n *    unaffected (clone_opportunity works), updates are not.\n *  - Screen flows execute through the automation service, whose\n *    `update_record` nodes demonstrably write `crm_case` (the\n *    case_escalation record-change flow does exactly that in production).\n *\n * Same mechanism as `schedule_followup` / `lead_conversion`.\n */\nexport const EscalateCaseFlow: Flow = {\n  name: 'escalate_case',\n  label: 'Escalate Case',\n  description: 'Collect an escalation reason, then flag and re-prioritise the case.',\n  type: 'screen',\n  status: 'active',\n\n  variables: [\n    // MUST be `recordId` \u2014 the console's flow-action contract seeds only that\n    // name (and its camelCase object alias); a custom name arrives undefined.\n    { name: 'recordId', type: 'text', isInput: true, isOutput: false },\n    { name: 'reason', type: 'text', isInput: true, isOutput: false },\n  ],\n\n  nodes: [\n    { id: 'start', type: 'start', label: 'Start', config: { objectName: 'crm_case' } },\n    {\n      id: 'screen_1', type: 'screen', label: 'Escalate Case',\n      config: {\n        fields: [\n          { name: 'reason', label: 'Escalation Reason', type: 'textarea', required: true },\n        ],\n      },\n    },\n    {\n      // The USER-CONTEXT half of the escalation. Everything here is a\n      // column the acting agent may legitimately write, so it is written with\n      // their identity \u2014 this flow stays `runAs: 'user'`.\n      //\n      //   escalation_reason  the agent's own screen input\n      //   priority           an ordinary editable field\n      //   status             ordinary, and the hook trigger (below)\n      //\n      // The two stamps a person never types \u2014 `is_escalated` and\n      // `escalated_date` \u2014 are `readonly: true` on `crm_case` and are written\n      // by the `case_escalation_stamp` subflow that follows, with the system\n      // context. See `src/service/flows/case-escalation-stamp.flow.ts`.\n      //\n      // \u26A0\uFE0F `status: 'escalated'` MUST stay in this node, and not only because\n      // it is user-writable: it is the trigger both escalation hooks key off \u2014\n      // `case_escalation_reassign` (`_case-assignment.ts`) gates on\n      // `input.status !== 'escalated' || previous.status === 'escalated'`, and\n      // `case_status_side_effects` (`case.hook.ts`) reads the same transition.\n      // Keeping it here keeps the ownership hand-off and the side-effect tasks\n      // firing from the ACTING USER's write, exactly as they did before the\n      // split. Moving it into the elevated subflow would silently re-attribute\n      // both to the system.\n      //\n      // It is also what suppresses a double-fire of the automatic\n      // `case_escalation` record-change flow.\n      id: 'escalate', type: 'update_record', label: 'Escalate Case',\n      config: {\n        objectName: 'crm_case',\n        filter: { id: cel`recordId` },\n        fields: {\n          escalation_reason: cel`reason`,\n          status: 'escalated',\n          priority: 'critical',\n        },\n      },\n    },\n    {\n      // The ELEVATED half, and the only elevation in this flow: one\n      // `runAs: 'system'` flow, one `update_record`, two readonly columns.\n      // The maintainer-approved direction \u2014 elevate the write, not the flow.\n      //\n      // \u26A0\uFE0F THIS NODE MUST RUN AFTER `escalate`, NOT BEFORE. `crm_case`'s\n      // `escalation_reason_required` validation rejects any write whose merged\n      // record has `is_escalated == true` and a blank `escalation_reason`. The\n      // reason is written by the node above, so by the time the flag flips it\n      // is already stored. Reversing these two nodes fires that validation\n      // against a record with no reason yet and the stamp is rejected.\n      //\n      // \u26D4 Do not \"simplify\" this by giving THIS flow `runAs: 'system'` and\n      // folding the stamp back into the node above. That is option A, costed\n      // and explicitly not adopted: it elevates every write this screen flow\n      // makes and stops it carrying the acting user's context downstream.\n      // `AGENTS.md` house rule 9 states it as standing policy.\n      id: 'stamp_escalation', type: 'subflow', label: 'Stamp Escalation Flags',\n      config: {\n        flowName: 'case_escalation_stamp',\n        input: { recordId: cel`recordId` },\n      },\n    },\n    { id: 'end', type: 'end', label: 'End' },\n  ],\n\n  edges: [\n    { id: 'e1', source: 'start', target: 'screen_1', type: 'default' },\n    { id: 'e2', source: 'screen_1', target: 'escalate', type: 'default' },\n    { id: 'e3', source: 'escalate', target: 'stamp_escalation', type: 'default' },\n    { id: 'e4', source: 'stamp_escalation', target: 'end', type: 'default' },\n  ],\n};\n\nexport const CloseCaseFlow: Flow = {\n  name: 'close_case',\n  label: 'Close Case',\n  description: 'Collect the resolution, then close the case and stop the SLA clock.',\n  type: 'screen',\n  status: 'active',\n  // `is_closed` is a readonly lifecycle field. This trusted screen flow owns\n  // the transition and must therefore run with the system writer.\n  //\n  // \u26D4 A HISTORICAL PRECEDENT, NOT A POLICY \u2014 do not cite this line to justify\n  // elevating another screen flow (#1434, the maintainer ruling that settled\n  // it). The standing rule is the opposite one: a screen flow stays\n  // `runAs: 'user'` and a write that genuinely needs elevation is split into a\n  // dedicated `system` sub-flow reached by a `subflow` node \u2014 see\n  // `escalate_case` above and `src/service/flows/case-escalation-stamp.flow.ts`.\n  // \"Readonly stripped my write, so I made the flow system\" is the pattern\n  // that ruling exists to stop being copied; `AGENTS.md` house rule 9 carries\n  // it as house policy. This flow predates that rule and has not been\n  // re-shaped to match it.\n  runAs: 'system',\n\n  variables: [\n    { name: 'recordId', type: 'text', isInput: true, isOutput: false },\n    { name: 'resolution', type: 'text', isInput: true, isOutput: false },\n    { name: 'resolved_by_article', type: 'text', isInput: true, isOutput: false },\n  ],\n\n  nodes: [\n    { id: 'start', type: 'start', label: 'Start', config: { objectName: 'crm_case' } },\n    {\n      // The \"attach the article that resolved it\" affordance. Optional\n      // on purpose: most cases are not resolved out of the knowledge base, and\n      // a required field here would be answered with a junk value rather than\n      // left honest \u2014 which is worse than an absent link for a measure whose\n      // whole job is to say how OFTEN the KB resolves a case.\n      //\n      // `reference` names the object the picker offers. Up to\n      // `@objectstack/spec@17.4.0` a screen field had no such key, so this\n      // `type: 'lookup'` field had nothing to resolve a record picker from;\n      // 17.5.0 added `reference` to `ScreenFieldConfigSchema` and made it\n      // REQUIRED on a lookup screen field (#17913) \u2014 the stack does not load\n      // without it. It is the same target the case's own `resolved_by_article`\n      // lookup declares (`crm_knowledge_article`).\n      //\n      // The `Resolved by Article` lookup in the case's Resolution group, on the\n      // record form, writes the same column; the action is\n      // `refreshAfter: true`, so the record form is what the agent lands on\n      // immediately after closing.\n      id: 'screen_1', type: 'screen', label: 'Close Case',\n      config: {\n        fields: [\n          { name: 'resolution', label: 'Resolution', type: 'textarea', required: true },\n          {\n            name: 'resolved_by_article',\n            label: 'Resolved by Article (optional)',\n            type: 'lookup',\n            reference: 'crm_knowledge_article',\n            required: false,\n          },\n        ],\n      },\n    },\n    {\n      // `resolved_by_article` is written unconditionally, and a blank one is\n      // normalised to NULL by `case_resolution_article_normalize`\n      // (`src/service/objects/case.hook.ts`) rather than branched around here: MEASURED\n      // on the real engine, a screen field left empty resumes as `''` and lands\n      // as an empty string, which `count(resolved_by_article)` counts. A\n      // `decision` node could not have branched it either \u2014 this repo has\n      // measured `decision.config.condition` to be inert metadata\n      // (`test/win-loss-capture.test.ts`'s table of five such surfaces).\n      //\n      // The read is guarded because the field is optional: a resume that omits\n      // it leaves the variable unbound, which the 17.x template wrote as nothing\n      // (the stored link left alone) and CEL refuses. The guard writes NULL\n      // there \u2014 the value a blank field already lands as after the normalize\n      // hook \u2014 so an omitted answer and an empty one now close the case alike.\n      id: 'close', type: 'update_record', label: 'Close Case',\n      config: {\n        objectName: 'crm_case',\n        filter: { id: cel`recordId` },\n        fields: {\n          is_closed: true,\n          resolution: cel`resolution`,\n          status: 'closed',\n          resolved_by_article: cel`has(vars.resolved_by_article) ? resolved_by_article : null`,\n        },\n      },\n    },\n    { id: 'end', type: 'end', label: 'End' },\n  ],\n\n  edges: [\n    { id: 'e1', source: 'start', target: 'screen_1', type: 'default' },\n    { id: 'e2', source: 'screen_1', target: 'close', type: 'default' },\n    { id: 'e3', source: 'close', target: 'end', type: 'default' },\n  ],\n};\n\n/**\n * Claim Case \u2014 the triage claim gesture, given a button.\n *\n * ## What this flow is, and what it deliberately is NOT\n *\n * The claim already exists as behaviour: an agent moves an unowned case out of\n * **Unassigned \u2014 triage** by setting its status to one that means a person is\n * on it, and `case_self_claim` (`src/service/objects/_case-assignment.ts`, priority\n * 260) stamps `owner_id` with the caller. This flow is the screen that says so.\n *\n * It is **pure UI over the existing seam**. Its one write is the\n * STATUS MOVE. It does not write `owner_id`, and that is not a style choice:\n *\n *  - the ownership-transfer gate refuses any payload carrying `owner_id` in the\n *    sharing MIDDLEWARE, upstream of the hook phase, and a screen flow's\n *    `update_record` runs as the caller \u2014 so a flow that wrote the column would\n *    be refused exactly like a hand-written update, loudly and always;\n *  - and `case_self_claim` guard 2 stands down the moment `owner_id` is already\n *    in the payload, so even a caller holding `allowTransfer` would take the\n *    claim seam out of the picture rather than drive it.\n *\n * Ownership therefore keeps exactly ONE writer. `test/claim-case-one-owner-writer.test.ts`\n * is that sentence turned into a guard, so it is enforced rather than intended.\n *\n * ## Why `runAs: 'user'`, spelled out rather than defaulted\n *\n * House rule 9 (`AGENTS.md`) already says a screen flow stays `runAs: 'user'`,\n * but here the default is LOAD-BEARING and worth reading twice: `case_self_claim`\n * returns early for a write with no user, and again for `ctx.session.isSystem`.\n * An elevated run of this flow would move the status and claim NOTHING \u2014 the\n * case would leave the triage tab still ownerless. The declaration is explicit\n * so the next author sees the coupling before reaching for elevation.\n *\n * ## Why a screen, and why the picker is derived\n *\n * The three statuses that claim are one concept with three faces, and which one\n * an agent picks is real information (`waiting_customer` straight off a triage\n * row is a different day's work from `in_progress`). The options are built from\n * {@link CLAIMABLE_TARGET_STATUSES} \u2014 the seam's own declared set \u2014 rather than\n * hand-copied. \u26D4 Never hand-copy the subset: it silently drops an option from\n * the picker and nothing notices. A fourth claimable status makes the label map\n * below a COMPILE error rather than a quietly short picker.\n */\nconst CLAIM_STATUS_LABEL: Record<(typeof CLAIMABLE_TARGET_STATUSES)[number], string> = {\n  in_progress: 'In Progress',\n  waiting_customer: 'Waiting on Customer',\n  waiting_support: 'Waiting on Support',\n};\n\n/** The picker, derived from the seam's set. Labels are pinned to `crm_case.status`'s own. */\nconst CLAIM_STATUS_OPTIONS = CLAIMABLE_TARGET_STATUSES.map((value) => ({\n  value,\n  label: CLAIM_STATUS_LABEL[value],\n}));\n\nexport const ClaimCaseFlow: Flow = {\n  name: 'claim_case',\n  label: 'Claim Case',\n  description: 'Take an unowned case out of triage by moving it to a status that means you are on it.',\n  type: 'screen',\n  status: 'active',\n  // Load-bearing, not boilerplate \u2014 see the header. A system run claims nobody.\n  runAs: 'user',\n\n  variables: [\n    // MUST be `recordId` \u2014 the console's flow-action contract seeds only that\n    // name (and its camelCase object alias); a custom name arrives undefined.\n    { name: 'recordId', type: 'text', isInput: true, isOutput: false },\n    { name: 'claimStatus', type: 'text', isInput: true, isOutput: false },\n  ],\n\n  nodes: [\n    { id: 'start', type: 'start', label: 'Start', config: { objectName: 'crm_case' } },\n    {\n      id: 'screen_1', type: 'screen', label: 'Claim Case',\n      config: {\n        fields: [\n          {\n            name: 'claimStatus', label: 'Working status', type: 'select', required: true,\n            defaultValue: 'in_progress',\n            options: CLAIM_STATUS_OPTIONS,\n          },\n        ],\n      },\n    },\n    {\n      // \u26D4 `status` is the ONLY field this node may ever carry. Adding\n      // `owner_id` here does not \"make the claim explicit\" \u2014 it makes the write\n      // refused by the transfer gate before any hook runs, and it takes\n      // `case_self_claim` out of the path on the one caller it would reach.\n      // The guard beside this file fails on any such addition.\n      id: 'claim', type: 'update_record', label: 'Claim Case',\n      config: {\n        objectName: 'crm_case',\n        filter: { id: cel`recordId` },\n        fields: {\n          status: cel`claimStatus`,\n        },\n      },\n    },\n    { id: 'end', type: 'end', label: 'End' },\n  ],\n\n  edges: [\n    { id: 'e1', source: 'start', target: 'screen_1', type: 'default' },\n    { id: 'e2', source: 'screen_1', target: 'claim', type: 'default' },\n    { id: 'e3', source: 'claim', target: 'end', type: 'default' },\n  ],\n};\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/service/objects/_case-assignment.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/service/objects\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/service/objects/_case-assignment.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport type { Hook, HookContext } from '@objectstack/spec/data';\nimport type { HookApi } from '../../sales/objects/_hook-api';\n\n/**\n * \u2550\u2550\u2550 Case ownership assignment \u2014 the app-level stand-in for a missing queue \u2550\u2550\n *\n * # \u26D4 This module is a STOPGAP. It is the code to delete.\n *\n * Salesforce-shaped case intake routes an ownerless case into a QUEUE and lets\n * agents pull from it. ObjectStack has no queue engine: `sys_queue` does not\n * exist, and the `queue` sharing-recipient and approver enum members are\n * deprecated upstream. So a web-to-case submission \u2014 whose `owner_id` is\n * deliberately stripped by the guest-sanitisation branch of `case_sla_defaults`\n * \u2014 has nowhere to sit and lands with nobody accountable for it.\n *\n * This module substitutes a load-balanced round-robin for the missing queue, at\n * the app layer, the same way `lead_auto_assign` (`lead.hook.ts`) does for\n * inbound leads. **When a platform `sys_queue` or assignment-rule engine lands,\n * this whole module is reclaimed \u2014 not adapted.** Its replacement is\n * declarative queue metadata; a hook that picks an owner by counting rows is not\n * something to keep alongside one. Delete the module, delete its hooks from\n * `case.hook.ts`, and re-point the triage view at the queue.\n *\n * It is a MODULE rather than a branch in `case.hook.ts` so that \"who should own\n * this case\" has ONE home: all three factories below read a POSITION POOL and\n * pick its least-loaded holder, differing only in pool, seam and trigger.\n *\n * # \u26A0\uFE0F The L2 sandbox constraint \u2014 the shape every handler here must take\n *\n * L2 hook bodies run BODY-ONLY inside QuickJS: the handler is lowered to a\n * source string with no module scope, so a body referencing an import, a\n * top-level const or a factory PARAMETER is a `ReferenceError` at runtime, not\n * a closure. `test/action-sandbox.test.ts` lowers every hook in `allHooks` with\n * the CLI build's own extraction pass and fails the ones that leak.\n *\n * So sharing here is authoring-time sharing: the FACTORY composes the hook and\n * owns the doc, the constants and the contract; the handler body closes over\n * nothing but its own `ctx` and spells its literals INLINE. The duplication is\n * not accidental \u2014 it is the only shape the runtime accepts \u2014 and what keeps it\n * honest is a behavioural pin: `test/case-assignment.test.ts` drives the real\n * handler and asserts the pool it queries is exactly\n * {@link SERVICE_AGENT_POSITION}, so constant and literal cannot drift quietly.\n *\n * # \u26A0\uFE0F The ownership-transfer gate (#3004), and the three doors through it\n *\n * Stamping another user's `owner_id` is an ownership TRANSFER, denied unless\n * the caller holds `allowTransfer` on the object (`@objectstack/spec`\n * `security/permission.zod.ts`). `crm_case.allowTransfer` is NOT granted to\n * `service_agent`, and granting it would widen what an agent may do to a case\n * generally \u2014 a permission-model change, not a hook change.\n *\n * The gate is an operation middleware wrapping the whole call, so what it sees\n * depends entirely on the seam a write uses. Measured against the full shipped\n * stack (ObjectQL + `plugin-security` + `plugin-sharing` over this app's own\n * `objectstack.config.ts`), with negative controls proving the observations are\n * not vacuous, and pinned in `test/case-assignment.test.ts` and\n * `test/ownership-model.test.ts`:\n *\n *   \u2460 A `beforeInsert` / `beforeUpdate` hook STAMPING `owner_id` onto a payload\n *      that did not carry the key is INVISIBLE to the gate \u2014 the middleware\n *      observes the payload as authored, and the stored row carries the stamp.\n *      This is the door all three factories here use, and it is why none of\n *      them needs a permission grant.\n *   \u2461 A hook's `ctx.api` WRITE is a fresh operation carrying the caller's\n *      identity, so the gate DOES see it. That is why `case_status_side_effects`\n *      opening an escalation task under the account owner needs\n *      `service_agent.crm_task.allowTransfer`.\n *   \u2462 A caller-supplied `owner_id` is refused INSIDE the middleware, upstream\n *      of the hook phase \u2014 the hook never fires at all. No hook can approve,\n *      launder or adjudicate a payload that carries the key.\n *\n * \u21D2 \"An agent may set `owner_id` to themselves\" is not implementable as an\n * adjudicated write. It IS implementable one level up, as a GESTURE the hook\n * interprets: {@link createCaseSelfClaim}.\n *\n * \u26A0\uFE0F If a platform release moves the gate downstream of the hook phase, door \u2460\n * flips and those tests go red. The signal is then to grant `allowTransfer`\n * deliberately or to stop assigning in a hook \u2014 NOT to widen the permission\n * model to make a red test green.\n */\n\n/** The position whose holders form the case intake pool (`sys_user_position`). */\nexport const SERVICE_AGENT_POSITION = 'service_agent';\n\n/** The position ESCALATED cases are routed to. */\nexport const SERVICE_MANAGER_POSITION = 'service_manager';\n\n/**\n * Statuses that mean \"this case is no longer live work\".\n *\n * Load balancing counts OPEN cases, and `is_closed` is the wrong predicate:\n * it only flips on `closed`, so a pile of `resolved` cases would keep counting\n * against an agent who has already finished them. `case_sla_monitor` settles it\n * the same way \u2014 see the `$nin` note in `src/service/flows/case-sla-monitor.flow.ts`,\n * which also records that comparing the boolean `is_closed` walks into the\n * SQLite `1 != true` trap.\n */\nexport const CLOSED_CASE_STATUSES = ['resolved', 'closed'] as const;\n\n/** Cap on the pool read \u2014 the same bound `lead_auto_assign` uses. */\nexport const POOL_QUERY_LIMIT = 1000;\n\n/**\n * The statuses that mean \"a human has picked this case up and it is not\n * finished\" \u2014 the gesture {@link createCaseSelfClaim} reads as a claim.\n *\n * One concept, not three arbitrary picks: each says a person is engaged and the\n * work is still live. The four statuses NOT here are excluded for a reason\n * apiece:\n *\n *   - `new` \u2014 the state a triage row is already IN. Not a move, so not a claim.\n *   - `escalated` \u2014 {@link createCaseEscalationReassign} owns that transition\n *     and routes to the `service_manager` pool. Two hooks answering \"who owns\n *     this case\" for one status change is the \"one operation, two\n *     implementations\" shape this module exists to prevent.\n *   - `resolved` / `closed` \u2014 finishing a case is not picking it up. An agent\n *     may still resolve an unowned case straight out of triage (the share\n *     grants edit); that records them in `updated_by` and leaves the ownership\n *     column honest about the fact that nobody ever took the work.\n *\n * \u26A0\uFE0F Declared here for the doc and the tests \u2014 the handler body spells the same\n * three strings INLINE, because the L2 sandbox gives it no module scope (see\n * this file's header). `test/unassigned-case-triage-reach.test.ts` drives every\n * one of them through the real engine, so the copies cannot drift.\n */\nexport const CLAIMABLE_TARGET_STATUSES = [\n  'in_progress',\n  'waiting_customer',\n  'waiting_support',\n] as const;\n\n/**\n * Round-robin assignment for ownerless new cases.\n *\n * A case created without an owner \u2014 a web-to-case submission, an email-to-case\n * import, an API capture \u2014 is assigned to the service agent with the FEWEST\n * OPEN cases. Least-loaded is a self-balancing round-robin: no rotation\n * counter, no stored cursor, no coordination between concurrent inserts. It\n * writes `owner_id`, the platform ownership anchor that OWD, sharing rules and\n * the \"My Open Cases\" view all read, so the agent really owns the case rather\n * than merely being named on it.\n *\n * ## Priority 250: it MUST run after `case_sla_defaults` (200)\n *\n * Hooks run in ASCENDING priority order, and `case_sla_defaults` is where the\n * guest-sanitisation branch assigns `input.owner_id = null` to drop a\n * client-spoofed owner from an anonymous submission. Assigning first and being\n * stripped afterwards would land every web-to-case ownerless \u2014 the exact case\n * this hook exists for. `test/case-assignment.test.ts` pins the ordering.\n *\n * ## The empty pool is the FIRST-INSTALL NORM, not an edge case\n *\n * `sys_user_position` membership is runtime data. Before anyone holds the\n * `service_agent` position the pool is empty and this hook is a NO-OP: the case\n * is created and stays ownerless. Never blocking intake is correct, but silent\n * ownerlessness hides the problem, so the no-op path has a UI counterpart \u2014 the\n * `unassigned_triage` pinned tab on `crm_case` (`src/service/views/case.view.ts`) shows\n * exactly the cases this hook could not place.\n *\n * ## Best-effort, always\n *\n * Auto-assignment is an ENHANCEMENT and must never reject the insert. An\n * anonymous Web-to-Case submission runs under the public-form grant, which\n * permits create/read-back on `crm_case` and DENIES `find` on\n * `sys_user_position`; letting that denial propagate would 403 the whole\n * submission and break the public support form. So every read is wrapped and\n * ANY failure leaves the case ownerless for the triage view to surface.\n *\n * @param hookName registry name for the hook (metadata only \u2014 never read by\n *   the body, which the sandbox would not let it be).\n */\nexport function createCaseRoundRobinAssign(hookName = 'case_auto_assign'): Hook {\n  return {\n    name: hookName,\n    object: 'crm_case',\n    events: ['beforeInsert'],\n    priority: 250,\n    description: 'Assign ownerless new cases to the least-loaded service agent.',\n    handler: async (ctx: HookContext) => {\n      const { input } = ctx;\n      // Respect an explicit / creator-assigned owner. On any write that carries\n      // a user the security middleware has ALREADY stamped `owner_id` to that\n      // user by the time this runs, so this is also what keeps the round-robin\n      // scoped to genuinely ownerless intake rather than firing on every\n      // agent-created case.\n      if (typeof input.owner_id === 'string' && input.owner_id) return;\n      const api = ctx.api as HookApi | undefined;\n      if (!api) return;\n\n      try {\n        // The pool = holders of the `service_agent` position. This literal is\n        // the exported SERVICE_AGENT_POSITION; the sandbox forbids reading the\n        // constant here, and `test/case-assignment.test.ts` pins the parity.\n        const holders = await api.object('sys_user_position').find({\n          where: { position: 'service_agent' }, fields: ['user_id'], top: 1000,\n        });\n        const agentIds = Array.from(\n          new Set(\n            (holders ?? [])\n              .map((r) => (typeof r.user_id === 'string' ? r.user_id : ''))\n              .filter(Boolean),\n          ),\n        );\n        // No pool \u2192 leave the case ownerless (no-op). The `unassigned_triage`\n        // view is what makes this visible instead of silent.\n        if (agentIds.length === 0) return;\n\n        // Fewest OPEN cases wins. `$nin` over statuses rather than\n        // `is_closed: false`: a resolved case is finished work and must stop\n        // counting against its agent (same predicate as `case_sla_monitor`).\n        let best: string | undefined;\n        let bestCount = Infinity;\n        for (const agentId of agentIds) {\n          const openCount = await api.object('crm_case').count({\n            where: { owner_id: agentId, status: { $nin: ['resolved', 'closed'] } },\n          });\n          if (openCount < bestCount) {\n            bestCount = openCount;\n            best = agentId;\n          }\n        }\n        if (best) input.owner_id = best;\n      } catch {\n        // Swallow: assignment must never block case creation. The common case\n        // is the anonymous public-form context, which cannot read\n        // `sys_user_position` \u2014 the case is still captured, ownerless, and the\n        // triage view surfaces it. (No `console` here \u2014 the L2 hook sandbox\n        // does not define one.)\n      }\n    },\n  };\n}\n\n/**\n * Hand an escalating case to the least-loaded service manager.\n *\n * On the escalation TRANSITION the case moves to the holder of\n * {@link SERVICE_MANAGER_POSITION} with the fewest open cases \u2014 the same\n * least-loaded balance the intake round-robin computes, against a different\n * pool. Without it, escalation is only a flag, a status and an inbox message:\n * the agent who could not get to the case in time stays the only person who can\n * work it.\n *\n * \u26A0\uFE0F Positions are FLAT (`src/sales/sharing/positions.ts`), so \"the owner's manager\"\n * is not resolvable in this app \u2014 and a flow template referencing a lookup\n * traversal such as `{caseRecord.owner_id.manager}` interpolates to the literal\n * string `undefined` rather than failing. That is why the hand-off is a hook\n * and not a flow, and why the pool substitutes for the chain.\n *\n * ## `beforeUpdate`, not `afterUpdate`\n *\n * The `afterUpdate` shape (a `ctx.api` write) is a fresh operation and is\n * therefore VISIBLE to the transfer gate \u2014 it would need `crm_case.allowTransfer`\n * on `service_agent`, widening what an agent may do to a case generally. The\n * `beforeUpdate` door is invisible to the gate (this module's header, door \u2460),\n * so the hand-off costs no permission change.\n *\n * It also disposes of re-entrancy rather than guarding it: the hook performs NO\n * operation, mutating the payload of the update already in flight, so there is\n * no second write and no second `record-after-update` event for\n * `case_escalation` or `case_status_side_effects` to fire on. The predicate is\n * a TRANSITION rather than a state, so it is false on a replay, and the write\n * is idempotent \u2014 a case already owned by a pool member is left alone.\n * `test/case-assignment.test.ts` drives all three properties.\n *\n * ## The SLA sweep reaches this hook, and depends on it (#1405)\n *\n * `case_sla_monitor`'s `flag_breach` node writes `status: 'escalated'` on every\n * breached case, which IS the transition below \u2014 so the scheduled sweep puts an\n * ownerless breached case through this assignment without any flow-callable\n * seam, and the flow then re-reads the case (`reload_case`) to alert the owner\n * this hook produced. \u26A0\uFE0F That makes the TRANSITION predicate load-bearing for a\n * second caller: narrowing it to record-triggered escalations, or moving the\n * assignment to an `afterUpdate` write, silently returns the sweep to alerting\n * nobody for an unowned breach. `test/flow-sla-ownerless-assignment.test.ts`\n * drives the real flow through the real hook chain and goes red if it does.\n *\n * ## The empty pool: a no-op that is still VISIBLE\n *\n * `sys_user_position` membership is runtime data, and `service_manager` is\n * unstaffed on a fresh install. \u26A0\uFE0F The demo org is NO LONGER one of those: #1102\n * staffs Tomas Okafor into the position (`src/sales/sharing/demo-staffing.ts`), so the\n * exemplar now demonstrates the hand-off rather than the stand-down \u2014 which is\n * also what makes the sweep's assignment visible on this repo's own seed.\n *\n * With no pool the case keeps\n * its owner and the escalation completes as before. Unlike the intake path that\n * needs no new surface to stay visible: an escalated case is not ownerless, it\n * sits in the `escalated_cases` view, and `case_escalation_sharing` already\n * grants every `service_manager` edit access to open critical cases.\n *\n * ## Best-effort, always\n *\n * Reassignment is an ENHANCEMENT to the escalation, never a precondition. A\n * read denial, an empty pool or any other failure leaves the case with its\n * current owner and lets the escalation write through untouched.\n *\n * ## `runAs: 'system'` (#2014), and the organization pin\n *\n * The pool is `sys_user_position`, which a service agent may not read \u2014 so an\n * agent escalating their own case (the record form, or the `escalate_case`\n * action, whose `escalate` node deliberately keeps the status write in the\n * acting user's context) was refused the read, stood down, and the case stayed\n * with the agent who could not get to it; only the SLA sweep's system write\n * reached the pool. Choosing the escalation desk is the business's routing, not\n * the agent's privilege, so the hook elevates. What elevation reaches is the\n * two READS: the hook still issues no write of its own (door \u2460 above), so it\n * needs no transfer grant and moves nothing the escalation write is not\n * already moving.\n *\n * AGENTS.md rule 10: the pool and the load counts are organization-NEUTRAL\n * predicates (a position name, an owner id), so both are pinned to the\n * escalating case's own `organization_id` when it carries one. A person's\n * escalation is already confined by the driver \u2014 the elevated `ctx.api` keeps\n * the trigger's tenant \u2014 but the SLA sweep writes as the system with no\n * tenant at all, and without the pin its escalation would pick the\n * least-loaded manager of ANY organization. A case with no organization (a\n * single-organization install) has no wall to stay inside, and is not pinned.\n * Pinned, a manager whose position assignment is global (no organization)\n * does not receive a tenant's case.\n *\n * @param hookName registry name for the hook (metadata only \u2014 never read by\n *   the body, which the sandbox would not let it be).\n */\nexport function createCaseEscalationReassign(hookName = 'case_escalation_reassign'): Hook {\n  return {\n    name: hookName,\n    object: 'crm_case',\n    events: ['beforeUpdate'],\n    priority: 250,\n    runAs: 'system',\n    description: 'Hand a case being escalated to the least-loaded service manager.',\n    handler: async (ctx: HookContext) => {\n      // D3 stand-down: the escalation TRANSITION is read off this row's\n      // `previous`, so on a predicate update the new owner would be written to\n      // every matched case. `events` is `beforeUpdate` only, so the event half\n      // of the idiom in `forecast.hook.ts` would be a constant here.\n      if (ctx.dispatch?.mode === 'per-row') return;\n\n      const { input } = ctx;\n      const previous = ctx.previous;\n      if (!previous) return;\n\n      // The escalation TRANSITION, not the escalated STATE: a state predicate\n      // re-fires on any write that leaves the status alone, including a replay\n      // of this very update. Comparing status strings also stays clear of the\n      // SQLite boolean trap that `is_escalated != true` walks into.\n      if (input.status !== 'escalated' || previous.status === 'escalated') return;\n\n      // An explicit owner in the SAME payload wins: a manual \"escalate and hand\n      // it to Dana\" must not be overwritten by the pool's arithmetic.\n      if (typeof input.owner_id === 'string' && input.owner_id) return;\n\n      const api = ctx.api as HookApi | undefined;\n      if (!api) return;\n\n      // The escalating case's own organization \u2014 the rule-10 pin on both\n      // reads below. Read off the stored row: an update payload does not carry\n      // it, and the platform stamped it there.\n      const organizationId =\n        typeof previous.organization_id === 'string' && previous.organization_id !== ''\n          ? previous.organization_id\n          : undefined;\n      const inOrganization: Record<string, string> = organizationId ? { organization_id: organizationId } : {};\n\n      try {\n        // The pool = holders of the `service_manager` position. This literal is\n        // the exported SERVICE_MANAGER_POSITION; the sandbox forbids reading the\n        // constant here, and `test/case-assignment.test.ts` pins the parity.\n        const holders = await api.object('sys_user_position').find({\n          where: { position: 'service_manager', ...inOrganization }, fields: ['user_id'], top: 1000,\n        });\n        const managerIds = Array.from(\n          new Set(\n            (holders ?? [])\n              .map((r) => (typeof r.user_id === 'string' ? r.user_id : ''))\n              .filter(Boolean),\n          ),\n        );\n        // No pool \u2192 the case keeps its owner and the escalation still lands.\n        if (managerIds.length === 0) return;\n\n        // Already with the pool \u2192 leave it alone. This is what makes the write\n        // idempotent: a manager escalating their own case, or a second\n        // escalation of a case handed over once already, moves nothing.\n        const currentOwner =\n          (typeof previous.owner_id === 'string' && previous.owner_id) || '';\n        if (currentOwner && managerIds.indexOf(currentOwner) !== -1) return;\n\n        // Fewest OPEN cases wins \u2014 same predicate as the intake round-robin:\n        // `$nin` over statuses rather than `is_closed: false`, because a\n        // resolved case is finished work and must stop counting.\n        let best: string | undefined;\n        let bestCount = Infinity;\n        for (const managerId of managerIds) {\n          const openCount = await api.object('crm_case').count({\n            where: { owner_id: managerId, status: { $nin: ['resolved', 'closed'] }, ...inOrganization },\n          });\n          if (openCount < bestCount) {\n            bestCount = openCount;\n            best = managerId;\n          }\n        }\n        if (best) input.owner_id = best;\n      } catch {\n        // Swallow: the hand-off must never reject the escalation. A failed\n        // pool read leaves the case where it is, escalated.\n        // (No `console` here \u2014 the L2 hook sandbox does not define one.)\n      }\n    },\n  };\n}\n\n/**\n * Let a user CLAIM an unowned case out of triage.\n *\n * Contract: a caller may take ownership only for THEMSELVES, only while the\n * case is unowned, and only while it is not closed.\n *\n * ## Why the claim is a GESTURE, not a value the caller supplies\n *\n * \u26A0\uFE0F The ownership-transfer gate (#3004) rejects a payload carrying `owner_id`\n * INSIDE the operation middleware, upstream of the hook phase \u2014 the hook never\n * fires, so it cannot approve, launder or adjudicate such a write (door \u2462 in\n * this module's header). \"Let the agent write `{ owner_id: <self> }` and have a\n * hook vet it\" is therefore not implementable at all.\n *\n * So the claim is spelled as a MOVE: the caller puts an unowned open case into\n * a status meaning they picked it up ({@link CLAIMABLE_TARGET_STATUSES}) and\n * this hook stamps `ctx.user.id`, the only user id it has. That inverts the\n * safety burden in the app's favour \u2014 \"claim it for somebody else\" and \"claim\n * an owned case\" have no spelling, because the hook reads no target from the\n * payload and is inert unless the STORED row is ownerless. The alternative,\n * granting `crm_case.allowTransfer`, cannot express \"to yourself only\": it\n * would let an agent reassign any case they can edit, to anyone.\n * `src/sales/profiles/service-agent.profile.ts` needs no new grant for this hook.\n *\n * ## The four boundaries\n *\n * | write, as a `service_agent`                         | outcome |\n * | --- | --- |\n * | `{ status: 'in_progress' }` on an unowned OPEN case | claimed \u2014 owner becomes the caller |\n * | the same on a case owned by SOMEBODY ELSE           | refused: no reach, and guard 3 below |\n * | `{ owner_id: <anyone> }`, unowned or not            | refused by the transfer gate, upstream |\n * | the same on an unowned CLOSED case                  | refused: not shared, and guard 4 below |\n *\n * Each guard is doubled on purpose: `case_unassigned_triage_sharing` already\n * hides a closed or otherwise-owned case from an agent, but this hook also runs\n * for callers that rule does not constrain (an admin, a manager holding the\n * escalation share). `test/unassigned-case-triage-reach.test.ts` drives both\n * layers separately so neither can pass on the other's behalf.\n *\n * ## Re-entrancy\n *\n * The hook performs NO operation \u2014 it mutates the payload of the update already\n * in flight, so there is no second write and no second `record-after-update`\n * event for `case_escalation`, `case_sla_monitor` or `case_status_side_effects`\n * to re-fire on. Its predicate is a TRANSITION, not a state, so it is false on\n * a replay; and after a successful claim the stored row HAS an owner, so guard\n * 3 stops every later run. It cannot collide with the escalation hand-off:\n * `escalated` is deliberately not claimable, and at priority 260 this runs\n * after `case_escalation_reassign` (250) and stands down the moment `owner_id`\n * is already in the payload.\n *\n * ## Who this runs for\n *\n * A claim is something a PERSON does, so a write with no user (a seed, a\n * system-context migration, the anonymous web-to-case path) never claims \u2014\n * ownerless intake stays ownerless and stays in the triage tab. A write\n * carrying a real user id claims for that user, whoever they are.\n *\n * @param hookName registry name for the hook (metadata only \u2014 never read by\n *   the body, which the sandbox would not let it be).\n */\nexport function createCaseSelfClaim(hookName = 'case_self_claim'): Hook {\n  return {\n    name: hookName,\n    object: 'crm_case',\n    events: ['beforeUpdate'],\n    priority: 260,\n    description: 'Let a user claim an unowned open case by picking it up; the owner written is always the caller.',\n    handler: async (ctx: HookContext) => {\n      // D3 stand-down: every guard below is decided against this row's\n      // `previous`, so a predicate update would claim rows the caller never\n      // picked up. `beforeUpdate`-only, as above.\n      if (ctx.dispatch?.mode === 'per-row') return;\n\n      const { input } = ctx;\n      const previous = ctx.previous;\n      if (!previous) return;\n\n      // 1. A claim is something a PERSON does. A system or seed write leaves\n      //    the case ownerless for the triage tab to keep showing.\n      const claimant = ctx.user?.id;\n      if (typeof claimant !== 'string' || !claimant) return;\n      if (ctx.session?.isSystem) return;\n\n      // 2. An explicit `owner_id` in the payload WINS and is never touched. For\n      //    an agent that branch is unreachable (the transfer gate refuses such\n      //    a payload upstream), so in practice it means a caller who\n      //    legitimately holds `allowTransfer` gets the owner they named.\n      if ('owner_id' in input) return;\n\n      // 3. Only an UNOWNED case can be claimed. Covers both storage shapes of\n      //    \"no owner\": the key ABSENT (memory/mongo) and the column NULL (SQL).\n      if (typeof previous.owner_id === 'string' && previous.owner_id) return;\n\n      // 4. \u2026and only one that is not CLOSED. \u26A0\uFE0F This guard and the triage\n      //    sharing grant draw DIFFERENT lines on purpose, and \u26D4 neither is to\n      //    be \"aligned\" onto the other. `case_unassigned_triage_sharing`\n      //    (`src/service/sharing/case.sharing.ts`) excludes `resolved` as well as\n      //    `closed`, because a resolved unowned case is history, not backlog,\n      //    and the tab's row count has to keep meaning \"work waiting for a\n      //    human\". This guard stops at `closed` alone, because REOPENING a\n      //    resolved case IS picking the work up, so whoever does it should\n      //    become its owner. The gap between the two lines is live for exactly\n      //    the callers that rule does not reach \u2014 the admin, the manager\n      //    holding the escalation share \u2014 which is why\n      //    `test/unassigned-case-triage-reach.test.ts` drives the closed guard\n      //    once per layer, the second time with an actor that CAN reach the\n      //    row.\n      //\n      //    \u26A0\uFE0F The `is_closed == false` conditions elsewhere in that sharing\n      //    file are NOT this grant and NOT drift: they belong to the manager\n      //    and director rules on critical-priority cases, which keep standing\n      //    reach through the `resolved \u2192 closed` review window by their own\n      //    ruling. Their \u26A0\uFE0F headers carry it; \u26D4 do not read them as this one.\n      //\n      //    `status` is read first because it is a string on every driver;\n      //    `is_closed` is accepted as `true` or `1` because SQLite hands\n      //    booleans back as integers.\n      if (previous.status === 'closed') return;\n      if (previous.is_closed === true || previous.is_closed === 1) return;\n\n      // 5. The gesture: the status MOVES to one meaning a human picked the case\n      //    up. Inline copies of CLAIMABLE_TARGET_STATUSES \u2014 the sandbox forbids\n      //    reading the constant here; `test/unassigned-case-triage-reach.test.ts`\n      //    pins the two in step. `escalated` is absent on purpose: that\n      //    transition belongs to `case_escalation_reassign`.\n      const next = input.status;\n      if (typeof next !== 'string' || next === previous.status) return;\n      if (next !== 'in_progress' && next !== 'waiting_customer' && next !== 'waiting_support') return;\n\n      // The only user id this hook has, and the only one it can write.\n      input.owner_id = claimant;\n    },\n  };\n}\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/service/flows/case-escalation-stamp.flow.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/service/flows\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/service/flows/case-escalation-stamp.flow.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport { cel } from '@objectstack/spec';\nimport type * as Automation from '@objectstack/spec/automation';\ntype Flow = Automation.Flow;\n\n/**\n * The escalation STAMP \u2014 the one elevated step behind the Escalate Case\n * action (maintainer-approved).\n *\n * ## Why this flow exists at all\n *\n * `crm_case.is_escalated` and `escalated_date` are `readonly: true`: nobody\n * types them, so that is the honest declaration. But the platform's readonly\n * strip is one branch of the UPDATE path \u2014\n * `if (!opCtx.context?.isSystem)`, over CALLER-supplied keys \u2014 so a flow write\n * to a readonly column survives exactly when that flow's effective `runAs` is\n * `'system'` (the engine defaults it to `'user'`). The `escalate_case` screen\n * flow is invoked by a person from the UI and MUST keep running as that\n * person, so it cannot make this write itself.\n *\n * The resolution is to elevate the WRITE, not the FLOW: `escalate_case` stays\n * `runAs: 'user'` and calls this dedicated `runAs: 'system'` flow through a\n * `subflow` node. Everything the agent does keeps their identity; only these\n * two stamped columns are written with the elevated context.\n *\n * \u26D4 Do NOT fold this back into `escalate_case` by giving that flow\n * `runAs: 'system'`. That option was costed and explicitly NOT adopted: it\n * elevates every write the screen flow makes, not just these two, and it stops\n * the flow carrying the acting user's context for anything downstream that\n * reads it. See `AGENTS.md` house rule 9 (\"Elevate as little as possible\").\n *\n * ## Measured, not assumed\n *\n * The direction rests on one falsifiable premise \u2014 that a callee flow's own\n * `runAs` governs its writes rather than inheriting the caller's context \u2014 and\n * it is measured against a real engine in\n * `test/readonly-write-semantics.test.ts` (\"a system subflow called from a\n * user parent\"). That measurement reports three things:\n *\n *  - a `runAs: 'system'` callee invoked from a `runAs: 'user'` parent has its\n *    write to a `readonly` column SURVIVE;\n *  - the same callee declared `runAs: 'user'` is STRIPPED \u2014 so it is the\n *    callee's declaration that decides, not the subflow hop;\n *  - the parent's own later write to a readonly column is STILL stripped \u2014 the\n *    elevation is scoped to this run and does not leak back up.\n *\n * The mechanism is `resolveRunContext`\n * (`@objectstack/service-automation`), which re-asserts\n * `runAs: flow.runAs ?? 'user'` AFTER spreading the caller's context, so the\n * callee's own declaration wins: \"a COPY, never mutating the caller's context,\n * so the elevation is scoped to this run and the caller's identity is restored\n * when the run returns\" (ADR-0049).\n *\n * ## \u26D4 What this flow deliberately does NOT write\n *\n * Only the two columns a person never types:\n *\n *   is_escalated    stamped here\n *   escalated_date  stamped here\n *\n * `escalation_reason` is the agent's screen input and `priority` / `status`\n * are ordinary editable columns \u2014 all three stay in `escalate_case`, written\n * with the USER's context. Moving `escalation_reason` here (or declaring it\n * `readonly`) would make the platform silently strip the reason the agent just\n * typed \u2014 the exact harm this split exists to prevent, inverted onto user input.\n *\n * \u26A0\uFE0F ORDERING IS LOAD-BEARING, and it is why this flow runs LAST rather than\n * first. `crm_case`'s `escalation_reason_required` validation rejects any write\n * whose merged record has `is_escalated == true` with a blank\n * `escalation_reason`. `escalate_case` therefore writes the reason FIRST and\n * calls this flow AFTER, so the reason is already stored when the flag flips.\n * Stamping first would fire that validation against a record that does not yet\n * carry a reason. BOTH orders are measured in\n * `test/readonly-write-semantics.test.ts` (\"ordering: the reason must be stored\n * BEFORE the flag flips\"), including the counterfactual: stamping first is\n * refused by that validation, and because a `subflow` node reports its child's\n * failure the run aborts before the reason is written either \u2014 the agent loses\n * the whole escalation.\n */\nexport const CaseEscalationStampFlow: Flow = {\n  name: 'case_escalation_stamp',\n  label: 'Stamp Case Escalation',\n  description:\n    'Write the two readonly escalation stamps (is_escalated, escalated_date) with the system context. Called by escalate_case through a subflow node.',\n  type: 'autolaunched',\n  status: 'active',\n\n  // \u2B50 THE ENTIRE POINT OF THIS FILE. This is the only elevation in the\n  // escalate path, and it covers exactly one `update_record` node.\n  runAs: 'system',\n\n  variables: [\n    // Supplied by the caller's `subflow` node, whose `input` envelope reads its own `recordId`.\n    { name: 'recordId', type: 'text', isInput: true, isOutput: false },\n  ],\n\n  nodes: [\n    // `config: {}` matches the shape measured in\n    // `test/readonly-write-semantics.test.ts`: an autolaunched callee is handed\n    // its params by the `subflow` executor and resolves no trigger record of\n    // its own, so there is no `objectName` for the start node to load.\n    { id: 'start', type: 'start', label: 'Start', config: {} },\n    {\n      id: 'stamp', type: 'update_record', label: 'Stamp Escalation Flags',\n      config: {\n        objectName: 'crm_case',\n        filter: { id: cel`recordId` },\n        // \u26D4 Do not add fields here. Every column in this node is written with\n        // the elevated context; anything a user can legitimately type belongs\n        // in `escalate_case` instead.\n        fields: {\n          is_escalated: true,\n          escalated_date: cel`isoDatetime(now())`,\n        },\n      },\n    },\n    { id: 'end', type: 'end', label: 'End' },\n  ],\n\n  edges: [\n    { id: 'e1', source: 'start', target: 'stamp', type: 'default' },\n    { id: 'e2', source: 'stamp', target: 'end', type: 'default' },\n  ],\n};\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/service/flows/case-sla-monitor.flow.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/service/flows\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/service/flows/case-sla-monitor.flow.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport { P, cel } from '@objectstack/spec';\nimport type * as Automation from '@objectstack/spec/automation';\nimport { guarded } from '../../sales/flows/_guarded-iteration';\ntype Flow = Automation.Flow;\n\n/**\n * Case SLA Monitor \u2014 scheduled breach detection.\n *\n * Complements `case_escalation` (which reacts to *priority* the moment a case\n * is saved) by adding the missing *time* dimension. The schema carries\n * `sla_due_date` and `is_sla_violated`, but nothing watched the clock \u2014 a case\n * could silently blow its SLA. This flow sweeps open (not resolved/closed)\n * cases whose `sla_due_date` has passed, stamps the breach, escalates, and\n * alerts the owner.\n *\n * A breached case with NO owner is the hard case, and it is answered in two\n * halves. The escalation the sweep writes is itself what gives the case an\n * owner \u2014 `case_escalation_reassign` rides on that update and hands the case to\n * the least-loaded `service_manager` \u2014 so this flow re-reads the case\n * afterwards and alerts whoever it now belongs to. When the pool is empty the\n * assignment is a no-op, the case stays unowned, the alert is skipped at a\n * named gate, and the RUN SURVIVES: the breach is still recorded and every\n * other breached case is still swept. \u26D4 No fallback recipient, no\n * manager-chain dot-walk, no hard failure (maintainer ruling 2026-09-03).\n *\n * Capabilities exercised: scheduled trigger + `loop` + `update_record` +\n * `get_record` + `notify`.\n */\n\n/**\n * \"The case in hand carries an owner the `notify` node can address.\"\n *\n * Authored ONCE and used on two edges (`b2` and `b5`) because the two ask the\n * same question at two points in the iteration \u2014 before the sweep's write and\n * after it \u2014 and a hand-copied second spelling is exactly the drift measured on\n * decision nodes. {@link CASE_HAS_NO_OWNER} is its complement.\n *\n * TOTALITY: `currentCase` is a LOOP ITEM over `caseList`, which\n * `get_record` filled from `data.find` \u2014 every element is a raw driver row,\n * sparse in the way a raw driver row is. A case that was never written with\n * an `owner_id` column carries no key at all, so `has()` is the only total\n * accessor; an unguarded `vars.currentCase.owner_id != null` aborts with\n * `No such key` and takes the run down the same way an empty recipient slate\n * once did.\n *\n * Every term is load-bearing, and the last one MIRRORS THE NOTIFY NODE'S OWN\n * emptiness rule rather than guessing at it: builtin `notify` builds its\n * audience with `String(v).trim()` + `.filter(Boolean)`, so null, undefined,\n * `''` AND any all-whitespace value all collapse to the same empty slate.\n * Measured: `'   ' != \"\"` is TRUE in CEL, so a gate written that way opened for\n * a whitespace `owner_id` and reproduced this very defect one input narrower.\n * `string(...).trim() != \"\"` is the same predicate the node applies, in CEL.\n *\n * The `string()` wrap is not decoration: bare `.matches()` / `.trim()` on a\n * non-string id fails with `no matching overload`, which is a thrown condition\n * \u2014 the fault mode this flow exists to keep out. `string()` is total for every\n * non-null scalar, and the `!= null` term in front short-circuits before it can\n * be handed a null (`string(null)` has no overload either).\n */\nconst CASE_HAS_OWNER = () => P`has(vars.currentCase) && has(vars.currentCase.owner_id)\n  && vars.currentCase.owner_id != null && string(vars.currentCase.owner_id).trim() != \"\"`;\n\n/**\n * The exact complement of {@link CASE_HAS_OWNER}, in the opposite polarity the\n * house rule prescribes for a partition (`!has(x) || \u2026 `).\n *\n * \u26A0\uFE0F `has(vars.currentCase)` leads BOTH predicates rather than being negated\n * here, so the two edges partition only the cases where the iterator is bound.\n * That asymmetry is deliberate: with no `currentCase` at all NEITHER edge\n * matches and the iteration simply ends \u2014 the pre-existing behaviour \u2014 instead\n * of routing an unbindable row into `reload_case`, whose `{currentCase.id}`\n * filter token would then resolve to nothing and make `get_record` REFUSE the\n * step, killing the run for the exact reason this flow was repaired.\n */\nconst CASE_HAS_NO_OWNER = () => P`has(vars.currentCase) && (!has(vars.currentCase.owner_id)\n  || vars.currentCase.owner_id == null || string(vars.currentCase.owner_id).trim() == \"\")`;\n\nexport const CaseSlaMonitorFlow: Flow = {\n  name: 'case_sla_monitor',\n  label: 'Case SLA Monitor',\n  description: 'Hourly sweep: flag and escalate open cases that have breached their SLA due date.',\n  type: 'schedule',\n  status: 'active',\n  // Scheduled runs have no trigger user, so under the default runAs:'user' the\n  // data nodes execute UNSCOPED anyway. Declare runAs:'system' to make that\n  // RLS-bypassing elevation explicit and intended (ADR-0049).\n  runAs: 'system',\n\n  variables: [],\n\n  nodes: [\n    { id: 'start', type: 'start', label: 'Start (hourly)', config: { schedule: '0 * * * *' } },\n    {\n      id: 'query_breached', type: 'get_record', label: 'Find Breached Cases',\n      config: {\n        objectName: 'crm_case',\n        // \u26D4 `$nin` on `status`, never `is_closed: false`: a case in `resolved`\n        // has met its SLA \u2014 work is finished \u2014 but `is_closed` only flips on\n        // `closed`, so the boolean filter stamps false breaches on resolved\n        // cases and drags them back to `escalated`.\n        //\n        // `$lt` is `caseSlaBreached` (`src/service/objects/_case-sla.ts`) read\n        // with \"now\" as the instant: STRICTLY past due. Its other half is\n        // `case_sla_defaults`, which applies the same rule on the write that\n        // settles a case \u2014 so a case settled late is flagged even when this\n        // sweep never reached it, or never runs (#2070).\n        //\n        // \"Now\" is the query engine's own `{now}` placeholder, which an\n        // 18.0.0-next.0 filter operand leaves to the engine as written. It\n        // renders the instant's ISO text, as the retired `{NOW()}` flow token\n        // did, and it is the spelling the SLA Violations tile reads, so the\n        // sweep and the tile say \"past due\" in one wording.\n        filter: {\n          status: { $nin: ['resolved', 'closed'] },\n          is_sla_violated: false,\n          sla_due_date: { $lt: '{now}' },\n        },\n        limit: 500,\n        outputVariable: 'caseList',\n      },\n    },\n    {\n      id: 'loop_cases', type: 'loop', label: 'For Each Breached Case',\n      config: {\n        collection: cel`caseList`,\n        iteratorVariable: 'currentCase',\n        body: guarded('case', {\n          nodes: [\n            {\n              id: 'flag_breach', type: 'update_record', label: 'Flag SLA Breach',\n              config: {\n                objectName: 'crm_case',\n                filter: { id: cel`currentCase.id` },\n                // `escalation_reason` must accompany `is_escalated: true` \u2014 the\n                // object's `escalation_reason_required` validation (severity:\n                // error) rejects the whole write otherwise, turning this sweep\n                // into a silent no-op (cf. the same fix in case_escalation).\n                fields: {\n                  is_sla_violated: true,\n                  is_escalated: true,\n                  status: 'escalated',\n                  escalated_date: cel`isoDatetime(now())`,\n                  escalation_reason: 'Auto-escalated: SLA due date breached',\n                },\n              },\n            },\n            {\n              // Gateway only \u2014 the predicate lives on the out-edge.\n              //\n              // `crm_case.owner_id` is NULLABLE and an unowned case is an\n              // ordinary state (this repo ships `scripts/backfill-owner-id.ts` /\n              // `pnpm backfill:owner` precisely because ownerless rows happen;\n              // ordinary REST creation and import reach it too). The `notify`\n              // node below addresses exactly one recipient, so an ownerless case\n              // left it with an empty slate \u2014 which the builtin node treats as a\n              // HARD failure, and that failure is not scoped to the one case:\n              // `executeNode` throws, `runRegion` rethrows, and the `loop` node\n              // awaits it with no try/catch, so the whole sweep died on the\n              // ownerless row and every breached case ORDERED BEHIND IT was\n              // never even flagged. Measured, not assumed \u2014 see\n              // `test/flow-sla-ownerless-case.test.ts`.\n              //\n              // The gate sits AFTER `flag_breach` on purpose. `flag_breach` is\n              // unconditional, so an ownerless breach is still RECORDED on the\n              // record \u2014 visible in views and reports, where a service manager\n              // finds it. Gating both would trade a dead run for a silently\n              // dropped alert on exactly the cases most likely to be neglected.\n              //\n              // The ownerless branch is not a dead end: it goes to\n              // `reload_case`, because by the time the gate is reached the\n              // sweep's own write may ALREADY HAVE GIVEN THE CASE AN OWNER \u2014\n              // see that node (maintainer ruling 2026-09-03, option C).\n              id: 'check_owner', type: 'decision', label: 'Case Has an Owner?',\n            },\n            {\n              // Re-read the case the sweep just wrote.\n              //\n              // \u26A0\uFE0F THE ASSIGNMENT IS NOT AUTHORED HERE, AND MUST NOT BE.\n              // `flag_breach` writes `status: 'escalated'`, and that IS the\n              // escalation transition `case_escalation_reassign`\n              // (`src/service/objects/_case-assignment.ts`, `beforeUpdate`, priority\n              // 250) fires on: it stamps the least-loaded holder of the\n              // `service_manager` position onto the payload of the update\n              // already in flight. So the sweep does not need a seam to \"call\"\n              // the assignment \u2014 performing the transition IS putting the case\n              // through it, and the app keeps ONE answer to \"who should own\n              // this case\" instead of a flow-shaped second implementation of\n              // least-loaded balancing.\n              //\n              // MEASURED, not assumed (`test/flow-sla-ownerless-case.test.ts`\n              // drives the real flow, the real engine and the real hooks): with\n              // a staffed pool an ownerless breached case comes back owned; with\n              // an empty pool the hook stands down and the case comes back\n              // ownerless. No second write, no re-entry, no loop \u2014 the hook\n              // mutates the in-flight payload and issues no operation of its\n              // own.\n              //\n              // \u26D4 The READ is what this node is for, not a second write:\n              // `currentCase` is the loop item bound by `query_breached` BEFORE\n              // `flag_breach` ran, so the owner the sweep just assigned is\n              // invisible to it and `{currentCase.owner_id}` addresses the\n              // pre-write state. Re-binding the SAME variable is what makes the\n              // rest of the iteration \u2014 the gate below and the notify node's\n              // whole template \u2014 read the case as it now stands, with no second\n              // notify node to keep in step.\n              //\n              // No `limit`: `get_record` calls `findOne` at or below 1 and binds\n              // the single row itself, which is what `{currentCase.<field>}`\n              // needs. A miss binds `null` \u2014 `get_record` always binds \u2014 which\n              // `check_assigned` below is there to read.\n              id: 'reload_case', type: 'get_record', label: 'Re-read Case After Escalation',\n              config: {\n                objectName: 'crm_case',\n                filter: { id: cel`currentCase.id` },\n                outputVariable: 'currentCase',\n              },\n            },\n            {\n              // Gateway only \u2014 the predicate lives on the out-edge.\n              //\n              // The ruled empty-pool clause, as a gate rather than a failure:\n              // when the `service_manager` pool resolves empty the hook assigns\n              // nobody, the re-read case is still ownerless, no edge matches and\n              // the iteration ends. The breach stays on the record and in the\n              // run summary, the notification is skipped at a NAMED gate, and\n              // the run survives. \u26D4 No hard failure, no fallback recipient, no\n              // manager-chain dot-walk.\n              id: 'check_assigned', type: 'decision', label: 'Escalation Found an Owner?',\n            },\n            {\n              // Owner only: `{currentCase.owner_id.manager}` cannot traverse a\n              // lookup in flow templates \u2014 it interpolates to the literal\n              // \"undefined\" (cf. case_escalation / opportunity_won_alert).\n              //\n              // Reached from BOTH gates, and the whole template reads\n              // `currentCase` either way: on the owned branch that is the row\n              // `query_breached` bound, on the ownerless branch the row\n              // `reload_case` re-bound. One node, one wording, one recipient\n              // rule \u2014 a second notify node would be the same alert authored\n              // twice, free to drift on the half nobody is looking at.\n              //\n              // \u26A0\uFE0F THE RECIPIENT IS RULED, NOT INCIDENTAL \u2014 #1535, maintainer\n              // ruling 2026-09-07, option A. On a breached\n              // case that ALREADY HAS AN OWNER, `flag_breach` writes\n              // `status: 'escalated'` and `case_escalation_reassign` hands the\n              // case to the least-loaded `service_manager` inside that same\n              // write \u2014 yet this node addresses `currentCase` as\n              // `query_breached` bound it, BEFORE the hand-off. So the breach\n              // alert deliberately reaches the agent the case is being taken\n              // FROM, not the manager who now owns it.\n              //\n              // It is the SAME etiquette `case_escalation` already states in\n              // `content/docs/service/sla-and-escalation.mdx` \u2014 \"the\n              // notification goes to the previous owner alone\" \u2014 and that page\n              // now states it for this sweep too. One escalation etiquette\n              // across both mechanisms.\n              //\n              // \u26D4 Do not \"fix\" this into an alert for the new owner. That is\n              // option C, and it would have to re-rule `case_escalation` in the\n              // same stroke \u2014 \u26D4 never one mechanism only.\n              //\n              // `test/flow-sla-ownerless-assignment.test.ts` pins the pairing\n              // (the owned breach IS handed over AND its alert still goes to\n              // the pre-hand-off owner), and records the ruling's declared gap\n              // as measured: the hand-off hook issues no notice of its own, so\n              // the receiving manager is told nothing by this run.\n              id: 'notify_team', type: 'notify', label: 'Alert Owner',\n              config: {\n                // Owner only \u2014 `{currentCase.owner_id.manager}` dot-walks a\n                // lookup, which flow templates interpolate as \"undefined\".\n                recipients: [cel`currentCase.owner_id`],\n                channels: ['inbox', 'email'],\n                severity: 'critical',\n                topic: 'case_sla_breach',\n                template: 'crm.case_sla_breach',\n                templateData: {\n                  case_number: cel`currentCase.case_number`, priority: cel`currentCase.priority`,\n                },\n                actionUrl: '/crm_case/{{currentCase.id}}',\n              },\n            },\n          ],\n          edges: [\n            { id: 'b1', source: 'flag_breach', target: 'check_owner', type: 'default' },\n            // The two out-edges of `check_owner` are an exact PARTITION of the\n            // cases where `currentCase` is bound (see {@link CASE_HAS_OWNER} /\n            // {@link CASE_HAS_NO_OWNER}) \u2014 never a `default` edge alongside a\n            // conditional one, which would traverse BOTH and notify twice.\n            //\n            // \u26A0\uFE0F The owned branch reads `currentCase` as `query_breached` bound\n            // it, deliberately: a case that already had an\n            // owner keeps alerting THAT owner, which is what the sweep has\n            // always done. \u26A0\uFE0F That is RULED intent now, no longer an open\n            // question \u2014 the `notify_team` node carries the ruling.\n            { id: 'b2', source: 'check_owner', target: 'notify_team', type: 'conditional', condition: CASE_HAS_OWNER(), label: 'Has owner' },\n            { id: 'b3', source: 'check_owner', target: 'reload_case', type: 'conditional', condition: CASE_HAS_NO_OWNER(), label: 'No owner \u2014 re-read after escalation' },\n            { id: 'b4', source: 'reload_case', target: 'check_assigned', type: 'default' },\n            // Both branches converge on the ONE notify node, which is why the\n            // re-read re-binds `currentCase` rather than a second variable: the\n            // recipient, the title, the message and the action URL are authored\n            // once and cannot drift into two versions of the same alert.\n            //\n            // A gate with no matching edge simply ends the iteration, so an\n            // ownerless case the pool could not place is skipped and the loop\n            // moves on to the next breached case \u2014 the run survives, which is\n            // the property this flow was repaired for.\n            { id: 'b5', source: 'check_assigned', target: 'notify_team', type: 'conditional', condition: CASE_HAS_OWNER(), label: 'Escalation assigned an owner' },\n          ],\n        }),\n      },\n    },\n    { id: 'end', type: 'end', label: 'End' },\n  ],\n\n  edges: [\n    { id: 'e1', source: 'start', target: 'query_breached', type: 'default' },\n    { id: 'e2', source: 'query_breached', target: 'loop_cases', type: 'default' },\n    { id: 'e3', source: 'loop_cases', target: 'end', type: 'default' },\n  ],\n};\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/sales/flows/_guarded-iteration.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/sales/flows\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/sales/flows/_guarded-iteration.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\n/**\n * Per-iteration containment for `loop` bodies \u2014 the one spelling, in one place.\n *\n * ## The defect this closes\n *\n * `loop-node.ts` iterates its body with a bare `await` and has no `try`/`catch`\n * at all, so a body node that returns `success: false` or throws propagates\n * straight out of the container. The first failing item therefore ends the\n * WHOLE run: every later item is never processed, and the work already done is\n * not even reported. Measured by the platform on the real engine \u2014 a 5-item\n * sweep failing at item 3 touched 3 items and reported `acted: 0`.\n *\n * That is what `objectstack lint`'s `flow-loop-body-uncontained` names, and the\n * containment it prescribes is a `try_catch` INSIDE the body with the real work\n * moved into its `try` region.\n *\n * ## Why a helper rather than the literal 22x spelling\n *\n * Writing the `try_catch` out at each of the 22 warned loops re-indents every\n * body by two levels, and the re-indentation ALONE measured ~1,327 tokens over\n * the `business semantics` ceiling of `pnpm hygiene:tokens` \u2014 a ceiling that\n * moves only on a maintainer ruling. The ratchet strips comments, so slimming\n * prose cannot buy that back either.\n *\n * This helper wraps the body from OUTSIDE instead. At each site `body: {`\n * becomes `body: guarded('<key>', {` and the closing `},` becomes `}),`, so the\n * body keeps its own indentation byte-for-byte and the whole change costs a few\n * tokens per loop instead of sixty.\n *\n * ## Verified against the pinned `@objectstack/*` this repo installs\n *\n * First taken on 17.3.0; RE-TAKEN on 17.4.0 (#1883, after the PR #1814 bump;\n * not re-taken on 17.5.0), same verdict: a 5-item sweep whose body fails on every item\n * ran to completion \u2014 all 5 items touched, run `success: true` \u2014 where the\n * same sweep with the body UNWRAPPED stopped at the first failure with 1 item\n * touched and the run `failed`. That contrast IS the measurement; a guarded\n * run alone cannot tell containment from a body that never failed.\n *\n * (Not against the platform source tree \u2014 the containment has to work on the\n * artifact that actually ships here.)\n *\n *   - `try_catch` is registered by the pinned engine (`registerTryCatchNode`),\n *     runs its `try` region, and on a caught failure runs `catch` and returns\n *     `success: true`. That `success: true` is what lets the loop continue.\n *   - A bare `assignment` node with no `config` returns `success: true`: its\n *     executor folds an absent config to zero assignments, and `config` is\n *     optional on `FlowNodeSchema`. That is why the minimal handler is legal,\n *     and it is the exact handler the lint rule's own hint prescribes.\n *   - The failed attempt's steps are kept in the run log AHEAD of the handler's\n *     (`childSteps: [...failedAttemptSteps, ...catchSteps]`), so a skipped item\n *     stays visible with its own `status: 'failure'` step and the handler does\n *     not need to re-record it.\n *   - `catch` needs no `edges` (`FlowRegionSchema.edges` carries `.default([])`)\n *     and no `errorVariable` (it defaults to `$error`). A one-node region is\n *     single-entry/single-exit, which is what `analyzeRegion` requires.\n *\n * ## What it deliberately does NOT do\n *\n * The handler swallows the item and moves on. It does not retry (no `retry`\n * policy is declared, so one attempt is made), does not notify, and does not\n * accumulate a failure list \u2014 a sweep that reports its skips is a product\n * feature this card does not have a ruling for. The run log is the record.\n *\n * \u26D4 Not every loop wants this. A sweep MEANT to stop at its first failure is a\n * legitimate reading and keeps its warning, so decide per loop rather than\n * wrapping every warned site by reflex.\n */\n\n/**\n * A control-flow region, structurally. Deliberately looser than the spec's\n * `FlowRegion`: the loop bodies this wraps live under `config`, which the flow\n * schema types as `Record<string, unknown>`, so tightening the parameter here\n * would type-check the bodies for the first time and turn a mechanical wrap\n * into a typing change. Same shape in, same shape out.\n */\ntype Region = { nodes: unknown[]; edges?: unknown[] };\n\n/**\n * Wrap a loop body region so one failing item is contained to that iteration.\n *\n * `key` must be unique within its flow \u2014 it names the two nodes this adds\n * (`guard_<key>` and `handled_<key>`), and node ids collide flow-wide.\n */\nexport const guarded = (key: string, region: Region): Region => ({\n  nodes: [{\n    id: `guard_${key}`,\n    type: 'try_catch',\n    label: 'Guarded Iteration',\n    config: {\n      try: region,\n      catch: { nodes: [{ id: `handled_${key}`, type: 'assignment', label: 'Skip This Item' }] },\n    },\n  }],\n});\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/service/objects/article_feedback.hook.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/service/objects\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/service/objects/article_feedback.hook.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport type { Hook, HookContext } from '@objectstack/spec/data';\nimport type { HookApi } from '../../sales/objects/_hook-api';\n\n/**\n * The writer behind the knowledge article's engagement counters (#601).\n *\n * `crm_knowledge_article.helpful_count` and `not_helpful_count` were declared\n * `readonly: true` with a `defaultValue: 0` and NO writer anywhere \u2014 on the\n * platform or in this app \u2014 so they were structurally pinned at zero while the\n * article grid showed a \"Helpful Votes\" column and summed it. That is the same\n * defect `crm_campaign_member`'s engagement lifecycle was retired for (#597),\n * and ADR-0049's enforce-or-remove leaves exactly two honest endings: give the\n * field a writer, or delete it. Feedback on a knowledge article has a real\n * consumer \u2014 the review queue an author works from \u2014 so these two get a\n * writer. `view_count`, which has none available, was deleted; the reasoning\n * is on `crm_knowledge_article` itself.\n *\n * ### Recount, never increment\n *\n * Every event recomputes both counters from `crm_article_feedback` rather than\n * adding one to what is there. That makes the write idempotent (a replayed\n * hook cannot double-count), self-healing (an admin deleting a bogus vote row\n * is reflected on the next event, and a full recount fixes any historical\n * drift in one pass), and safe under concurrency (two simultaneous votes both\n * converge on the true count, where two read-modify-writes lose one). The\n * counters therefore cannot drift from their own evidence \u2014 which is what makes\n * `readonly: true` an honest declaration again rather than a description of\n * paralysis.\n *\n * `afterDelete` is in the event set for the same reason: the campaign junction\n * learned the hard way (#696) that a junction row's disappearance is a metric\n * change, and a counter that only ever goes up is a different kind of lie.\n *\n * `async: true` + `onError: 'log'` mirrors `campaign_member_metrics_refresh`:\n * the reader's vote is the user's action and must not fail because the article\n * row is momentarily locked. A missed refresh is corrected by the next vote;\n * a rejected write loses the vote itself.\n *\n * `runAs: 'system'` (#2014, AGENTS.md rule 9). The counters are `readonly`,\n * and the engine drops a readonly key a non-system caller writes \u2014 so a recount\n * fired by a PERSON's own write of a vote (an admin withdrawing one) committed\n * without the counters and the article kept counting the withdrawn vote. The\n * recount is the article's writer, not the voter's, so the hook elevates; the\n * vote itself stays the caller's write. Elevation is not anonymity: the\n * article's `updated_by` still names the person. Organization (rule 10): every\n * read and write is keyed to the triggering vote's own article, and the\n * elevated `ctx.api` keeps the trigger's tenant, so the driver's organization\n * predicate still applies.\n *\n * No loop: this writes `crm_knowledge_article`, whose own hook\n * (`knowledge_article_publish_timestamps`) fires on `before*` and returns\n * immediately unless the record is published \u2014 and either way it issues no\n * write against `crm_article_feedback`, so nothing re-enters here.\n *\n * \u26A0\uFE0F The recount block is written out INLINE and is not shared with\n * `campaign_member.hook.ts`'s structurally similar block. A hook handler lowers\n * to a metadata-only, body-only script: a reference to module scope \u2014 an\n * import, a top-level const, a shared factory's parameter \u2014 is a\n * `ReferenceError` at runtime, not a closure, and a handler that reaches for\n * one silently stops lowering (`test/action-sandbox.test.ts` fails the build on\n * it). Hooks may be composed by a FACTORY (`_case-assignment.ts` does exactly\n * that); the logic inside a body may not be imported.\n */\nconst articleFeedbackMetricsRefresh: Hook = {\n  name: 'article_feedback_metrics_refresh',\n  object: 'crm_article_feedback',\n  events: ['afterInsert', 'afterUpdate', 'afterDelete'],\n  priority: 800,\n  async: true,\n  onError: 'log',\n  runAs: 'system',\n  description: 'Recount an article\u2019s helpful / not-helpful votes from crm_article_feedback.',\n  handler: async (ctx: HookContext) => {\n    const api = ctx.api as HookApi | undefined;\n    if (!api) return;\n    const { input } = ctx;\n    const previous = ctx.previous;\n    // Both sides on update: moving a vote between articles has to recount the\n    // article it LEFT as well as the one it arrived at.\n    const articleIds = Array.from(new Set([\n      typeof input?.crm_knowledge_article === 'string' ? input.crm_knowledge_article : '',\n      typeof previous?.crm_knowledge_article === 'string'\n        ? (previous.crm_knowledge_article as string)\n        : '',\n    ].filter(Boolean)));\n\n    for (const id of articleIds) {\n      const helpful = await api.object('crm_article_feedback').count({\n        where: { crm_knowledge_article: id, verdict: 'helpful' },\n      });\n      const notHelpful = await api.object('crm_article_feedback').count({\n        where: { crm_knowledge_article: id, verdict: 'not_helpful' },\n      });\n      await api.object('crm_knowledge_article').update({\n        id,\n        helpful_count: helpful,\n        not_helpful_count: notHelpful,\n      }, { where: { id } });\n    }\n  },\n};\n\nexport default [articleFeedbackMetricsRefresh];\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/service/objects/case.hook.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/service/objects\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/service/objects/case.hook.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport type { Hook, HookContext } from '@objectstack/spec/data';\nimport type { HookApi } from '../../sales/objects/_hook-api';\nimport {\n  createCaseRoundRobinAssign,\n  createCaseEscalationReassign,\n  createCaseSelfClaim,\n} from './_case-assignment';\n\n/**\n * Case SLA & escalation hook.\n *\n * - Stamps `sla_due_date` on a case that has none, from the priority \u00D7 account\n *   tier matrix in `_case-sla.ts`.\n * - Records `is_sla_violated` on the write that resolves or closes a case after\n *   its `sla_due_date` \u2014 the half of the breach rule no schedule can miss.\n * - On escalation: creates a follow-up task OWNED BY the account owner (the\n *   single owner of escalation tasks \u2014 flows must not create their own).\n *   Owning it, not merely labelling it: `owner_id` is the one ownership column,\n *   so the person the task names is the person who can work it.\n * - On `resolved`: bumps account `last_activity_date` \u2014 its own hook,\n *   `case_resolution_account_activity`, because it is the one write here that\n *   needs elevation (#2014).\n *\n * \u26A0\uFE0F Ownership assignment is NOT here: all three answers to \"who should own\n * this case\" live in `_case-assignment.ts` \u2014 the ownerless-intake round-robin,\n * the escalation hand-off to the `service_manager` pool, and the triage\n * self-claim. One module, so the app never grows two independently-authored\n * ownership paths on `crm_case`; its hooks are composed into this module's\n * default export below, so the registry still sees one `crm_case` hook set. In\n * particular the escalation hand-off is deliberately NOT a branch of\n * `case_status_side_effects` below: that hook writes through `ctx.api`, a seam\n * the #3004 transfer guard CAN see (which would demand\n * `crm_case.allowTransfer`) and a second write that re-enters the record-change\n * trigger surface. Both measurements are in `_case-assignment.ts`'s header.\n */\n\nconst caseValidation: Hook = {\n  name: 'case_sla_defaults',\n  object: 'crm_case',\n  events: ['beforeInsert', 'beforeUpdate'],\n  priority: 200,\n  description: 'Apply the priority \u00D7 account-tier SLA matrix and the case lifecycle defaults.',\n  handler: async (ctx: HookContext) => {\n    // D3 stand-down: a predicate update has ONE payload for every matched row,\n    // so the `ctx.previous`-conditioned writes below would land on rows that\n    // did not earn them \u2014 refused as a diverging key set, or stored silently\n    // from the last row. Full account and the measurement: `forecast.hook.ts`.\n    if (ctx.event === 'beforeUpdate' && ctx.dispatch?.mode === 'per-row') return;\n\n    const { input } = ctx;\n    const api = ctx.api as HookApi | undefined;\n\n    // Guest (web-to-case) sanitisation. OVERWRITE with a safe value \u2014 never\n    // `delete`.\n    //\n    // \u2705 HISTORY, RESOLVED \u2014 and the conclusion is unchanged. Through 17.2.0,\n    // `delete ctx.input.<field>` in a hook was a SILENT NO-OP: ObjectQL hands a\n    // hook `ctx.input` as `{ data, options }` behind a flat-record Proxy\n    // (`installFlatInput`, `@objectstack/objectql` `src/hook-wrappers.ts`) that\n    // trapped `get` / `set` / `has` / `ownKeys` / `getOwnPropertyDescriptor` and\n    // routed each into `data` \u2014 but declared no `deleteProperty` trap, so the\n    // delete fell through to the WRAPPER, one level above the record:\n    //\n    //   delete input.owner_id   -> returned TRUE  (JS reported success)\n    //   'owner_id' in input     -> still true\n    //   input.owner_id          -> still the caller's value\n    //\n    // Fifteen such statements across two intake hooks did nothing in production\n    // while their tests passed (#1133). This block was rewritten to ASSIGN.\n    //\n    // The block above predicted its own trigger \u2014 \"a platform release that\n    // POSTDATES 2026-08-26\" \u2014 and that release is **17.3.0**, so every later\n    // pin carries the fix. objectstack#12277 shipped: the in-process Proxy\n    // traps `deleteProperty`, and the sandbox path diffs deletions against the\n    // entry snapshot rather than writing mutations home with `Object.assign`,\n    // which cannot represent a removal. Re-measured through the engine's own\n    // `wrapDeclarativeHook` in `test/hook-input-shape.test.ts`, which now pins\n    // the new contract in both directions.\n    //\n    // \u26D4 The trap arriving is NOT a licence to spell this block with `delete`.\n    // What these lines WRITE is load-bearing independently of how it is spelled:\n    // `case_auto_assign` stands down only on a non-empty STRING `owner_id`, so\n    // the column must arrive `null` rather than ABSENT (see the `null` note\n    // below). Removing a key and writing `null` are different downstream, so\n    // switching to `delete` would be a behaviour change on the public-form\n    // boundary, not a re-spelling. Assign \u2014 for the reason, not the constraint.\n    //\n    // \u26A0\uFE0F `null` rather than `''` or `undefined`, all three measured on the\n    // write path: `null` stores as null, `''` stores as an empty string (wrong\n    // in a lookup \u2014 see `case_resolution_article_normalize` below), and\n    // `undefined` stores the KEY with an undefined value rather than omitting\n    // it, which is not the same as absent and is what a `has()`-guarded CEL\n    // predicate then trips over. `null` is also what the downstream owner\n    // writer reads as \"ownerless\": `case_auto_assign` stands down only on a\n    // non-empty STRING `owner_id`, so a nulled column still reaches the\n    // round-robin.\n    //\n    // \u26A0\uFE0F `!ctx.session?.isSystem` is load-bearing. A predicate of\n    // `!ctx.previous && !ctx.user?.id` conflates the two callers that both\n    // arrive without a user id: an anonymous web-to-case submitter (untrusted,\n    // the caller this branch exists for) and a SYSTEM write \u2014 seed load,\n    // backfill, demo bootstrap, migration \u2014 the most trusted caller there is.\n    // Elsewhere in this app that same absence is read the opposite way:\n    // `lead_automation`'s converted-lead lock treats `!ctx.user?.id` as \"system\n    // write, allow it\". Without the narrowing, a system insert that names an\n    // owner has that owner blanked and every seeded or backfilled case lands\n    // ownerless (eight cases in `test/unassigned-case-triage-reach.test.ts`\n    // insert owned cases exactly that way). `ctx.session.isSystem` is the\n    // discriminator: a system context arrives as `session: { isSystem: true }`\n    // and an anonymous one carries no session at all. Narrowing only ever\n    // REMOVES callers from the branch, so nothing sanitised today stops being.\n    //\n    // `escalation_reason` is stripped ALONGSIDE `is_escalated`, and the pair is\n    // why: cleaning only the FLAG leaves the prose that explains the flag\n    // writable, so a case could carry a stated escalation reason while\n    // `is_escalated` is false \u2014 a contradiction on the record page's own\n    // `escalation` field group, where a service agent reads both. It IS a\n    // widening of a security control, so it is argued rather than assumed:\n    // `escalation_reason` is pipeline, not a fact a submitter states about\n    // themselves \u2014 the rule this branch declares \u2014 and every real writer is\n    // staff-side (`case_escalation`, `case_sla_monitor`, the `escalate_case`\n    // screen flow). The public `web_to_case` form (`src/service/views/case.view.ts`)\n    // collects exactly `subject`, `description`, `type` and `priority`, so\n    // nulling this drops nothing any guest surface asks for. `guest_portal`\n    // grants `crm_case.allowCreate` at the OBJECT level with no field\n    // allow-list, which is precisely why this branch is the field-level control\n    // and why an omission from it is a hole rather than a second layer.\n    //\n    // \u26A0\uFE0F The middleware path is MEASURED, and the answer bounds what this\n    // branch may claim. A real anonymous write does NOT reach these columns on\n    // the shipped app today \u2014 and this branch is not what stops it. Driven\n    // against a real server (`objectstack start`, the production plugin set:\n    // Auth, Security, Sharing, RestAPI), unauthenticated over HTTP:\n    //\n    //   POST  /api/v1/data/crm_case         401 UNAUTHENTICATED\n    //   PATCH /api/v1/data/crm_case/:id     401 UNAUTHENTICATED\n    //   POST  /api/v1/actions/...           401 UNAUTHENTICATED\n    //   POST  /api/v1/mcp                   401 UNAUTHENTICATED\n    //   POST  /api/v1/forms/support/submit  201 \u2014 the ONE anonymous write path\n    //\n    // and that surviving route filters the body against an allow-list built\n    // from the matched form view's OWN declared sections (`@objectstack/rest`,\n    // `registerFormEndpoints`), so a planted internal field is dropped before\n    // ObjectQL and before this hook.\n    // \u26D4 So do NOT write down that a guest reaches these columns in production.\n    //\n    // \u26D4 And do not read that as \"this branch is cosmetic\". That allow-list is\n    // the form's FIELD LIST \u2014 a product decision, not a security declaration \u2014\n    // and #1505 measured it by widening it: ONE line added to `web_to_case`'s\n    // sections and the same anonymous POST stored the planted value, while a\n    // field left off the widened form stayed null in the same request. That is\n    // what identifies the form list as the only thing holding, and this branch\n    // as the layer that has to hold when it moves. \u26A0\uFE0F That measurement was\n    // taken on `customer_rating` / `customer_feedback`, which #1428 has since\n    // retired under ADR-0049 \u2014 the two columns are gone, so the branch no\n    // longer strips them; the mechanism the measurement established is\n    // unchanged and governs every field it still assigns.\n    //\n    // \u26A0\uFE0F Field-level permissions are not a second layer behind this branch, and\n    // that was re-measured against the installed tree rather than taken on\n    // report: `PermissionEvaluator.getFieldPermissions` builds its mask ONLY\n    // from `<object>.<field>` keys a permission set names in its `fields` map,\n    // and `FieldMasker.detectForbiddenWrites` returns early on an empty mask\n    // and otherwise flags only names present in it. `guest_portal` declares no\n    // `fields` key at all, so its mask is empty and the write guard is skipped\n    // outright \u2014 a field NO profile names is unrestricted, not restricted.\n    //\n    // Nulling `escalation_reason` cannot trip the object's\n    // `escalation_reason_required` validation: that rule fires only on\n    // `is_escalated == true`, this same branch forces `is_escalated = false`,\n    // and on the engine's insert path `validateRecord` /\n    // `evaluateValidationRules` run AFTER the `beforeInsert` hooks, against the\n    // row the hook has already rewritten.\n    const isGuestSubmission = !ctx.previous && !ctx.user?.id && !ctx.session?.isSystem;\n    if (isGuestSubmission) {\n      if (!input.origin)   input.origin   = 'web';\n      if (!input.status)   input.status   = 'new';\n      // \u26A0\uFE0F No `priority` default here, and the absence is deliberate. A\n      // `if (!input.priority) input.priority = 'medium'` line here can never\n      // execute: `crm_case.priority` declares its `low` option `default: true`,\n      // and on the engine's own insert path `applyFieldDefaults` produces the\n      // row that BECOMES `ctx.input.data` before `triggerHooks('beforeInsert')`\n      // is called \u2014 so the slot is already full every time this branch runs.\n      // Such a line reads as a declared intent (\"guest submissions start at\n      // medium\") that the app does not honour. Whether a web-submitted case\n      // SHOULD outrank a staff-created one is a product question, and it is not\n      // settled by leaving dead code here that says it already is.\n      input.owner_id          = null;\n      input.is_escalated      = false;\n      input.escalation_reason = null;\n      input.internal_notes    = null;\n      input.resolution        = null;\n    }\n\n    const priority =\n      (typeof input.priority === 'string' && input.priority) ||\n      (typeof ctx.previous?.priority === 'string' && (ctx.previous.priority as string)) ||\n      undefined;\n\n    // Materialise the urgency ordinal so queue views can sort by it. Sorting on\n    // `priority` itself compares raw strings and inverts urgency\n    // (medium > low > high > critical).\n    //\n    // \u26A0\uFE0F The map is declared INLINE and duplicated in task.hook.ts on purpose:\n    // L2 hook bodies run body-only in the QuickJS sandbox, so a shared module\n    // constant resolves at authoring time and arrives as `undefined`. The two\n    // maps key off different vocabularies (medium vs normal), but the UNKNOWN\n    // fallback must stay identical on both objects \u2014 `0`, the unranked sentinel\n    // that sorts below every real rank. `test/priority-rank-parity.test.ts`\n    // pins that agreement.\n    if (priority) {\n      const rank: Record<string, number> = { low: 1, medium: 2, high: 3, critical: 4 };\n      input.priority_rank = rank[priority] ?? 0;\n    }\n\n    // \u2500\u2500 SLA policy matrix: priority \u00D7 account tier \u2500\u2500\n    //\n    // The canonical write-up \u2014 the unit, and why the `critical` row is flat at\n    // 4 \u2014 lives in `_case-sla.ts`.\n    //\n    // \u26A0\uFE0F The table is declared INLINE and duplicated in `_case-sla.ts` on\n    // purpose, for the same reason as the `rank` map above: L2 hook bodies run\n    // body-only in the QuickJS sandbox, so a shared module constant resolves at\n    // authoring time and arrives as `undefined`. The seed module imports the\n    // real constant; this body cannot. `test/case-sla-matrix.test.ts` pins all\n    // sixteen cells by driving THIS handler, so the copies cannot drift.\n    if (priority && !input.sla_due_date && !ctx.previous?.sla_due_date) {\n      const slaCalendarHours: Record<string, Record<string, number>> = {\n        critical: { strategic: 4, enterprise: 4, mid_market: 4, smb: 4 },\n        high: { strategic: 6, enterprise: 8, mid_market: 8, smb: 8 },\n        medium: { strategic: 24, enterprise: 36, mid_market: 48, smb: 48 },\n        low: { strategic: 96, enterprise: 120, mid_market: 168, smb: 168 },\n      };\n      // `smb` is both the loosest column and the `tier` field's own default, so\n      // an unclassified account and an UNREADABLE one land on the same cell.\n      // Erring loose is the safe direction: a tighter deadline invented out of\n      // a permission error would manufacture breaches.\n      const DEFAULT_TIER = 'smb';\n      const row = slaCalendarHours[priority];\n      // An unrecognised priority gets no clock at all rather than a guessed\n      // one \u2014 the same refusal-to-invent as the `0` unranked sentinel above.\n      if (row) {\n        let tier = DEFAULT_TIER;\n        // Only pay for the account read when the row actually varies by tier.\n        // The `critical` row does not, which is what makes a critical case\n        // behave EXACTLY as it did before this hook learned about accounts \u2014\n        // same 4 hours, same absence of any dependency on `ctx.api`.\n        const variesByTier =\n          row.strategic !== row.enterprise ||\n          row.enterprise !== row.mid_market ||\n          row.mid_market !== row.smb;\n        const accountId =\n          (typeof input.crm_account === 'string' && input.crm_account) ||\n          (typeof ctx.previous?.crm_account === 'string' && (ctx.previous.crm_account as string)) ||\n          undefined;\n        if (variesByTier && accountId && api) {\n          try {\n            const found = await api.object('crm_account').find({\n              where: { id: accountId }, fields: ['tier'], top: 1,\n            });\n            const rows = Array.isArray(found) ? found : [];\n            const stored = rows.length ? rows[0].tier : undefined;\n            if (typeof stored === 'string' && stored) tier = stored;\n          } catch {\n            // Best-effort tier resolution: the anonymous web-to-case grant can\n            // create a case and read nothing else, and a denial there must not\n            // reject the submission. Falling through leaves `tier` on the\n            // default column. (No `console` in the L2 hook sandbox \u2014 cf. #471.)\n          }\n        }\n        const hours = row[tier] ?? row[DEFAULT_TIER];\n        // Milliseconds, not `setHours(getHours() + n)`: the latter does LOCAL\n        // calendar arithmetic, so on a host in a DST-observing zone \"+4 hours\"\n        // silently becomes 3 or 5 real hours across a transition \u2014 and a 168h\n        // Low-priority clock crosses one twice a year by construction. These\n        // are elapsed hours, so add elapsed milliseconds.\n        input.sla_due_date = new Date(Date.now() + hours * 3_600_000).toISOString();\n      }\n    }\n\n    // Closed flag/date + resolution time.\n    const effStatus =\n      (typeof input.status === 'string' && input.status) ||\n      (typeof ctx.previous?.status === 'string' && (ctx.previous.status as string)) ||\n      undefined;\n\n    // `is_closed` is DERIVED from `status`, on every write including a guest's.\n    // \u26D4 Never make the recompute conditional on the caller: a guest's\n    // `status: 'closed'` stored alongside `is_closed: false` contradicts\n    // itself, and every consumer keyed on the flag \u2014 the pinned\n    // `unassigned_triage` view, the `case_unassigned_triage_sharing` rule \u2014\n    // reads such a case as open backlog forever. A derived column is derived on\n    // every write or it is not derived at all; the guest's own `is_closed` is\n    // still ignored, because this recompute overwrites whatever they sent.\n    if (typeof effStatus === 'string') input.is_closed = effStatus === 'closed';\n\n    if (!isGuestSubmission) {\n      const becameClosed = input.status === 'closed' && ctx.previous?.status !== 'closed';\n      if (becameClosed && !input.closed_date && !ctx.previous?.closed_date) {\n        input.closed_date = new Date().toISOString();\n      }\n\n      const closedDate =\n        (typeof input.closed_date === 'string' && input.closed_date) ||\n        (typeof ctx.previous?.closed_date === 'string' && (ctx.previous.closed_date as string)) ||\n        undefined;\n      // The creation instant is the platform's `created_at` (#1992): stamped\n      // by `sys_stamp_audit_insert` before this hook runs on an insert (a\n      // seed row keeps its authored value), and read back off the stored row\n      // on an update.\n      const createdDate =\n        (typeof input.created_at === 'string' && input.created_at) ||\n        (typeof ctx.previous?.created_at === 'string' && (ctx.previous.created_at as string)) ||\n        undefined;\n      if (closedDate && createdDate) {\n        const hrs = (new Date(closedDate).getTime() - new Date(createdDate).getTime()) / 3_600_000;\n        if (Number.isFinite(hrs) && hrs >= 0) input.resolution_time_hours = Math.round(hrs * 10) / 10;\n      }\n\n      // \u2500\u2500 The breach is recorded when the clock stops (#2070) \u2500\u2500\n      //\n      // `case_sla_monitor` flags a breach only while a case is live work, and\n      // only where scheduled work runs. A case resolved or closed after its\n      // `sla_due_date` therefore kept `is_sla_violated: false` for good, and\n      // the closed-case surfaces (`sla_performance`, the compliance gauge)\n      // counted it as met. The write that takes the case out of live work is\n      // the moment its clock stops, so that write records a late finish.\n      //\n      // The rule is `caseSlaBreached` in `_case-sla.ts`; the status set is\n      // `CLOSED_CASE_STATUSES` in `_case-assignment.ts`. Both are spelled\n      // inline because this body has no module scope:\n      // `test/case-sla-breach-on-close.test.ts` drives the lowered body\n      // against the helper, and `test/live-work-predicate-parity.test.ts` pins\n      // the set by name. Only the ENTRY into the set is judged (a\n      // resolved \u2192 closed write stopped no clock), a case with no due date is\n      // left alone, and the flag is never cleared \u2014 a breach stays recorded.\n      //\n      // The stop instant is the `closed_date` this write carries \u2014 the stamp\n      // above, or a system writer's own \u2014 else now. The flag is written onto\n      // this record's own payload, which is not a caller-supplied key, so the\n      // agent's `editable: false` mask on it does not refuse the agent's close.\n      const settledStatuses = ['resolved', 'closed'];\n      if (settledStatuses.includes(String(effStatus)) && !settledStatuses.includes(String(ctx.previous?.status))) {\n        const due = input.sla_due_date !== undefined ? input.sla_due_date : ctx.previous?.sla_due_date;\n        const stoppedAt = (typeof input.closed_date === 'string' && input.closed_date) || new Date().toISOString();\n        if (typeof due === 'string' && Date.parse(due) < Date.parse(stoppedAt)) input.is_sla_violated = true;\n      }\n    }\n  },\n};\n\nconst caseSideEffects: Hook = {\n  name: 'case_status_side_effects',\n  object: 'crm_case',\n  events: ['afterUpdate'],\n  priority: 800,\n  async: true,\n  onError: 'log',\n  description: 'Open the escalation follow-up task for the account owner.',\n  handler: async (ctx: HookContext) => {\n    const { input } = ctx;\n    const previous = ctx.previous;\n    if (!previous) return;\n    const api = ctx.api as HookApi | undefined;\n    if (!api) return;\n\n    const caseId =\n      (typeof input.id === 'string' && input.id) ||\n      (typeof previous.id === 'string' ? (previous.id as string) : undefined);\n    const accountId =\n      (typeof input.crm_account === 'string' && input.crm_account) ||\n      (typeof previous.crm_account === 'string' && previous.crm_account) ||\n      undefined;\n\n    // Escalation: open task for the account owner.\n    //\n    // \u26A0\uFE0F `owner_id` is the platform ownership anchor, and planting a record\n    // under ANOTHER user is a transfer: the #3004 guard denies it unless the\n    // caller holds `allowTransfer`. This insert runs on `ctx.api`, which\n    // carries the CALLER's context (not a system one), so the guard applies \u2014\n    // hence the `crm_task.allowTransfer` grant on `service_agent` (see\n    // `src/sales/profiles/service-agent.profile.ts`, and the canonical note in\n    // `src/sales/profiles/index.ts`). One ownership column means one answer, and the\n    // answer is the person who must act.\n    //\n    // The CASE itself has already changed hands by the time this runs, on the\n    // `beforeUpdate` seam of this very update (`case_escalation_reassign`) \u2014 so\n    // this hook still writes no `crm_case.owner_id` and needs no\n    // `crm_case.allowTransfer`. The task and the case are two different\n    // hand-offs: the task goes to the ACCOUNT owner (commercial follow-up), the\n    // case to a service manager (the work itself).\n    if (input.status === 'escalated' && previous.status !== 'escalated' && accountId) {\n      const account = await api.object('crm_account').findOne({ where: { id: accountId } });\n      const ownerId = (account as { owner_id?: string } | null)?.owner_id ?? ctx.user?.id;\n      // UTC calendar for the step, matching the `toISOString()` render below\n      // (same shape as `lead.hook.ts` / `opportunity.hook.ts`): a local\n      // `setDate` step preserves wall-clock time, so a one-day follow-up filed\n      // across a spring-forward lands on the day of the escalation itself.\n      const due = new Date();\n      due.setUTCDate(due.getUTCDate() + 1);\n      // Title the task with what the reader already knows the case by (#1208).\n      // Title the task with what the reader already knows the case by. The\n      // PRIMARY KEY is not that: every case surface in this app (record pages,\n      // list views, breadcrumbs, the `display_title` formula on `crm_case`)\n      // names a case `CASE-00039`, so a queue of urgent rows differing only in\n      // a 16-character opaque id is a queue nobody can triage. The id is not\n      // lost \u2014 it travels in `related_to_case` below, where a relationship\n      // belongs.\n      //\n      // Both parts are read off `previous`, not fetched: an `afterUpdate`\n      // pre-image is the WHOLE stored row (`driver.findOne` with no\n      // projection), so `case_number` \u2014 an engine-issued autonumber, never\n      // present on an update payload \u2014 and `subject` are both already in hand.\n      // `subject` still prefers `input`, since an update may be changing it in\n      // this very write.\n      //\n      // \u26A0\uFE0F The 255 cap is not cosmetic. `crm_task.subject` declares\n      // `maxLength: 255` and the engine ENFORCES it, while `crm_case.subject`\n      // allows the same 255 \u2014 so `Escalated: ` + number + separator + a\n      // max-length case subject is 279 characters and the insert is REJECTED.\n      // This hook is `async: true` + `onError: 'log'`, so that rejection\n      // surfaces nowhere: the escalation task would simply never exist.\n      // Truncating the TAIL keeps the identifier \u2014 the discriminating half \u2014\n      // intact in a column that visibly truncates anyway.\n      //\n      // \u26A0\uFE0F Composed INLINE rather than in a shared helper: hook bodies ship\n      // body-only through QuickJS, and a module-scope reference makes\n      // `extractHookBody` throw \u2014 which the CLI build CATCHES, silently\n      // bundling the closure instead, with no gate going red. The pin runs this\n      // out of the LOWERED body for exactly that reason\n      // (`test/escalation-task-subject.test.ts`).\n      const caseNumber = typeof previous.case_number === 'string' ? previous.case_number.trim() : '';\n      const caseSubject =\n        (typeof input.subject === 'string' && input.subject.trim()) ||\n        (typeof previous.subject === 'string' && previous.subject.trim()) ||\n        '';\n      const label = [caseNumber, caseSubject].filter(Boolean).join(' \u00B7 ');\n      const titled = label ? `Escalated: ${label}` : 'Escalated case needs attention';\n      await api.object('crm_task').insert({\n        subject: titled.length > 255 ? `${titled.slice(0, 254)}\u2026` : titled,\n        status: 'not_started',\n        priority: 'urgent',\n        type: 'follow_up',\n        due_date: due.toISOString().slice(0, 10),\n        owner_id: ownerId,\n        related_to_type: 'crm_case',\n        related_to_case: caseId,\n        related_to_account: accountId,\n      });\n    }\n  },\n};\n\n/**\n * Resolution rollup: a case reaching `resolved` bumps its account's\n * `last_activity_date`.\n *\n * \u26D4 No date is stamped on the CASE \u2014 `closed_date` belongs exclusively to the\n * `closed` transition (stamped by `case_sla_defaults`). Writing it as a proxy\n * for a resolved-date both corrupts resolution metrics (a resolved-then-closed\n * case keeps its resolve time as its close time) and re-enters the\n * record-change trigger surface.\n *\n * ## `runAs: 'system'`, and why this is its own hook (#2014)\n *\n * Cases are resolved by service agents, and an agent holds no edit right on\n * accounts \u2014 so as the caller the bump was refused, `onError: 'log'` swallowed\n * it, and an agent's resolve never reached the account's activity clock. The\n * clock is the account's derived fact, not the agent's edit, so the write is\n * elevated. It is split out of `case_status_side_effects` because `runAs` is\n * per hook and that hook's other write \u2014 the escalation task \u2014 needs no\n * elevation: the agent's narrow `crm_task.allowTransfer` grant exists for it\n * (`service-agent.profile.ts`). Elevating as little as possible (AGENTS.md rule\n * 9) means this one write. Elevation is not anonymity: the account's\n * `updated_by` still names the agent. Organization (rule 10): it writes only\n * the account the triggering case names, and the elevated `ctx.api` keeps the\n * trigger's tenant.\n */\nconst caseResolutionAccountActivity: Hook = {\n  name: 'case_resolution_account_activity',\n  object: 'crm_case',\n  events: ['afterUpdate'],\n  priority: 800,\n  async: true,\n  onError: 'log',\n  runAs: 'system',\n  description: 'Bump the account\u2019s last activity date when a case is resolved.',\n  handler: async (ctx: HookContext) => {\n    const { input } = ctx;\n    const previous = ctx.previous;\n    if (!previous) return;\n    if (input.status !== 'resolved' || previous.status === 'resolved') return;\n    const api = ctx.api as HookApi | undefined;\n    if (!api) return;\n    const accountId =\n      (typeof input.crm_account === 'string' && input.crm_account) ||\n      (typeof previous.crm_account === 'string' && previous.crm_account) ||\n      undefined;\n    if (!accountId) return;\n    await api.object('crm_account').update(\n      { id: accountId, last_activity_date: new Date().toISOString().slice(0, 10) },\n      { where: { id: accountId } },\n    );\n  },\n};\n\n/**\n * Ownerless-intake round-robin, composed from `_case-assignment.ts`.\n *\n * \u26A0\uFE0F Listed AFTER `case_sla_defaults` here for readability only \u2014 runtime\n * ordering is decided by `priority` (250 vs 200), not by array position, and it\n * is load-bearing: `case_sla_defaults` strips a guest-supplied `owner_id` and\n * this hook must run after the strip, never before it.\n */\nconst caseAutoAssign: Hook = createCaseRoundRobinAssign();\n\n/**\n * Escalation hand-off to the `service_manager` pool, composed from\n * `_case-assignment.ts`.\n *\n * Runs on `beforeUpdate` and mutates the escalation write itself \u2014 it issues no\n * operation of its own, which is what keeps it off the record-change trigger\n * surface.\n */\nconst caseEscalationReassign: Hook = createCaseEscalationReassign();\n\n/**\n * Triage self-claim, composed from `_case-assignment.ts`.\n *\n * An agent who moves an unowned open case into a worked status becomes its\n * owner. \u26A0\uFE0F Priority 260 puts it AFTER the escalation hand-off (250), and it\n * stands down whenever `owner_id` is already in the payload \u2014 so the two\n * ownership writers on this seam cannot both speak. Like the hand-off it issues\n * no operation of its own; unlike either sibling it reads no pool, because the\n * only user id it can write is the caller's own.\n */\nconst caseSelfClaim: Hook = createCaseSelfClaim();\n\n/**\n * Normalise a BLANK `resolved_by_article` to NULL.\n *\n * Additive and deliberately independent of everything above: it touches no\n * ownership column and issues no operation of its own.\n *\n * ### Why it has to exist\n *\n * `resolved_by_article` is the column the deflection ratio on `case_metrics`\n * counts (`kb_resolved_count` = `count(resolved_by_article)` over closed cases).\n *\n * \u26A0\uFE0F Platform behaviour, measured against the real automation engine: an\n * optional SCREEN field the agent leaves empty does not arrive as \"absent\" \u2014\n * the resume carries `''`, and `update_record` writes that empty string into\n * the column:\n *\n *   supplied `'ka1'` \u2192 `resolved_by_article: \"ka1\"`\n *   left blank       \u2192 `resolved_by_article: \"\"`      \u2190 counted by count(col)\n *   key omitted      \u2192 column not written at all      \u2190 correct\n *\n * SQL `count(column)` counts every NON-NULL value, and `''` is not NULL. So\n * without this hook every case closed WITHOUT an article lands in the numerator\n * and the deflection rate reads 100% on a dashboard that raises no error while\n * doing it \u2014 a wrong ratio indistinguishable from a right one.\n *\n * Fixing it here rather than in the measure is deliberate: an empty string in a\n * lookup column is wrong for the record form, the list views, the reports and\n * any future reader too, so it is the STORED value that is corrected. Teaching\n * one measure to discount `''` is a lenient consumer papering over bad data,\n * and the next reader would not know to copy it.\n * `test/knowledge-deflection.test.ts` pins both halves.\n *\n * \u26A0\uFE0F The blank test is spelled inline rather than lifted into a shared helper:\n * hook handlers lower to a metadata-only body and a free identifier would push\n * this one into the legacy runtime bundle instead\n * (`test/action-sandbox.test.ts` fails the build on it).\n */\nconst caseResolutionArticleNormalize: Hook = {\n  name: 'case_resolution_article_normalize',\n  object: 'crm_case',\n  events: ['beforeInsert', 'beforeUpdate'],\n  priority: 150,\n  description: 'Normalise a blank resolved_by_article to null so the deflection measure counts only real links.',\n  handler: async (ctx: HookContext) => {\n    const { input } = ctx;\n    // Only a write that CARRIES the key is normalised. An update that never\n    // mentions the column must not clear a link somebody else set.\n    if (!('resolved_by_article' in input)) return;\n    const value = input.resolved_by_article;\n    if (value === '' || value === undefined) {\n      input.resolved_by_article = null;\n      return;\n    }\n    if (typeof value === 'string' && value.trim() === '') {\n      input.resolved_by_article = null;\n    }\n  },\n};\n\nexport default [\n  caseValidation,\n  caseAutoAssign,\n  caseEscalationReassign,\n  caseSelfClaim,\n  caseResolutionArticleNormalize,\n  caseSideEffects,\n  caseResolutionAccountActivity,\n];\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/service/objects/knowledge_article.hook.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/service/objects\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/service/objects/knowledge_article.hook.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport type { Hook, HookContext } from '@objectstack/spec/data';\n\n/**\n * Knowledge article lifecycle hook.\n *\n * On the FIRST publish, stamps `published_at` and `last_reviewed_at`. On every\n * later write that leaves the article published \u2014 an ordinary edit, or a\n * re-publish after archiving \u2014 refreshes `last_reviewed_at` only, so admin\n * \"stale article\" reports keep working while the original publish date stays\n * put.\n *\n * \"First publish\" is decided by whether the record ALREADY CARRIES a\n * `published_at`, not by which status the write arrives from (#780). The old\n * test was `previous.status === 'published'`, which recognises only the\n * published \u2192 published edit as a re-publish. But the documented lifecycle is\n * `draft \u2192 in_review \u2192 published \u2192 archived`, so the ordinary re-shelving move\n * `archived \u2192 published` arrives with `previous.status === 'archived'`, fell\n * into the first-publish branch, and moved a 2024 publish date to today. The\n * `all_articles` view sorts `published_at desc`, so the re-shelved article\n * jumped to the top of the list as if it had just been written.\n *\n * The date is read as `input.published_at ?? previous?.published_at` \u2014 the\n * value this record would end up with if the handler stamped nothing, which is\n * exactly the question \"does it already have one\". This is precedence between\n * the two halves of one write, not a tolerated alias for one key, and both\n * halves are load-bearing:\n *\n *   - `previous` is the FULL stored row: `update()` reads it and binds it BEFORE\n *     dispatching `beforeUpdate` (ADR-0058 Addendum II), so a re-publish sees\n *     the original date there. The `sys_fetch_previous_update` builtin that used\n *     to issue that `findOne` is retired.\n *   - `input` carries the date whenever the write supplies one, and on an INSERT\n *     that value is what gets stored: measured on 17.0.0-rc.2, the engine's\n *     read-only strip runs on the update path only, and hooks run before it in\n *     any case. So an import or migration publishing records with their\n *     historical dates reaches this handler with `published_at` set and no\n *     `previous`, and stamping over it rewrites imported history.\n *\n * Two adjacent engine behaviours this handler deliberately does NOT try to\n * paper over, both measured and filed as #788: `readonly: true` is not enforced\n * on the insert path at all, and on the update path the strip deletes the\n * caller-supplied key together with whatever a hook wrote there \u2014 so an update\n * that echoes `published_at` back can land a published article with none. That\n * outcome is identical before and after this change; a lenient consumer here\n * would only hide it.\n *\n * On the bulk path (`multi: true`) this handler now runs ONCE PER ROW, with\n * `input.id` bound to the row and `previous` its pre-image (ADR-0058 Addendum\n * II, D1/D2); past 10000 matched rows the whole write is refused with\n * `ERR_BULK_PER_ROW_HOOK_LIMIT`. The rc.2-era account \u2014 no `input.id`, no\n * `previous`, nothing stamped (#779, closed) \u2014 is HISTORY. Do not reason from\n * it; it is recorded here only because this file's own argument once did.\n *\n * \u26A0\uFE0F A PREDICATE UPDATE DERIVES NOTHING HERE \u2014 ADR-0058 Addendum II D3, and\n * the stand-down at the top of the handler is the idiom every row-conditioned\n * hook in this app carries. The full account and its measurements live in\n * `forecast.hook.ts`; the short version is that `update(obj, payload,\n * { multi: true, where })` sends ONE `SET` clause for all N matched rows and\n * hands every row's `beforeUpdate` THAT payload rather than a per-row copy, so\n * a write whose if-guard reads `ctx.previous` does not scope itself to the row\n * it was decided on.\n *\n * Both writes below are gated on the row, so both diverge \u2014 and this hook is\n * key-presence divergence (the loud kind) in BOTH limbs. There is no silent\n * limb, because neither write takes its VALUE from the row: both store\n * `nowIso`, a clock read. The row only ever decides WHETHER a key is written.\n *\n *   - `last_reviewed_at` sits behind the `nextStatus !== 'published'` early\n *     return, and that return reads the ROW. Measured on 17.4.0 on a\n *     fresh `pnpm dev`: the platform's own seed-ownership claim (one payload of\n *     `{ owner_id }`, `where: { owner_id: null }`) matched all 4 seeded\n *     articles; the 3 published ones stamped `last_reviewed_at`, the 1 draft\n *     returned early and stamped nothing, and the engine refused the batch \u2014\n *     `Refusing a multi-record update on 'crm_knowledge_article': its\n *     'beforeUpdate' handlers wrote 'last_reviewed_at' for some of the 4\n *     matched records and not for others`. Nothing was written, all 4 articles\n *     stayed ownerless, and `my_drafts` (filtered `owner_id =\n *     {current_user_id}`) was EMPTY until the `demo_bootstrap` sweep repaired\n *     them by id ten minutes later.\n *   - `published_at`'s existence criterion is the same shape one key over:\n *     #1888 measured it refused over 3 rows with\n *     `MULTI_UPDATE_HOOK_KEY_DIVERGENCE`. That limb is what #1265 was filed\n *     for, back when the engine widened in silence instead of refusing.\n *\n * \u26A0\uFE0F The `ctx.event` half of the guard is load-bearing, not ceremony: a batch\n * INSERT also reports `dispatch.mode === 'per-row'`, and there each row carries\n * its OWN payload. This hook is `beforeInsert` too, so dropping that half would\n * stop the seed load stamping `published_at` / `last_reviewed_at` at all.\n *\n * \u26A0\uFE0F HISTORY \u2014 do not reason from it. Until 17.3.0 the sandbox context carried\n * no per-row signal, so a `ctx.dispatch` guard lowered cleanly, passed every\n * in-process test and was INERT in production; PR #1274 recorded that as the\n * reason this could not be fixed here. That is FALSE from 17.3.0 on:\n * `buildSandboxContext` marshals `dispatch` and an `inputOptions` projection\n * (objectstack#11552), and `test/hooks-runtime-service.test.ts` pins that they\n * cross. `ctx.input.id` is still absent \u2014 read `ctx.previous.id`.\n */\nconst knowledgeArticlePublish: Hook = {\n  name: 'knowledge_article_publish_timestamps',\n  object: 'crm_knowledge_article',\n  events: ['beforeInsert', 'beforeUpdate'],\n  priority: 300,\n  description: 'Stamp published_at on the first publish; refresh last_reviewed_at while published.',\n  handler: async (ctx: HookContext) => {\n    // D3 stand-down (see the header). Every write below is decided against this\n    // row's `previous`, and this handler makes no refusal, so the whole body\n    // stands down on the predicate path; deriving still happens per record.\n    if (ctx.event === 'beforeUpdate' && ctx.dispatch?.mode === 'per-row') return;\n\n    const { input } = ctx;\n    const previous = ctx.previous;\n    const nextStatus = (typeof input.status === 'string' && input.status) || previous?.status;\n    if (nextStatus !== 'published') return;\n\n    const nowIso = new Date().toISOString();\n    // Publishing, re-publishing and editing while published are all reviews.\n    input.last_reviewed_at = nowIso;\n    // The emptiness test is spelled out here rather than factored into a\n    // module-scope helper: hook handlers lower to a metadata-only body, and a\n    // free identifier would push this one into the legacy runtime bundle\n    // instead \u2014 `test/action-sandbox.test.ts` fails the build on it.\n    const existing = input.published_at ?? previous?.published_at;\n    if (existing === undefined || existing === null || existing === '') {\n      input.published_at = nowIso;\n    }\n  },\n};\n\nexport default knowledgeArticlePublish;\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/service/pages/case_detail.page.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/service/pages\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/service/pages/case_detail.page.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport type { Page } from '@objectstack/spec/ui';\n\n/**\n * Case Detail Record Page\n *\n * Service-agent record page for the `crm_case` object. Mirrors the\n * opportunity_detail layout: highlights strip, status path, then a tab\n * strip with **Details / Related / Activity**.\n *\n * The Activity tab uses `record:activity`, which pulls the unified\n * timeline from `sys_comment`, `sys_activity`, `feed_item` and the field\n * history (enabled via `trackHistory: true` on `case.object.ts`). That is\n * how case comments and call logs surface here without a custom feed \u2014\n * call logs only because the block sets `showCompleted` (#2071).\n */\nexport const CaseDetailPage: Page = {\n  name: 'case_detail_page',\n  label: 'Case Detail',\n  description:\n    'Service-agent case record: highlights, SLA path, details and activity timeline.',\n\n  type: 'record',\n  object: 'crm_case',\n\n  template: 'full-width',\n  kind: 'full',\n  variables: [\n    { name: 'activeTab', type: 'string', defaultValue: 'details' },\n  ],\n\n  regions: [\n    {\n      name: 'header',\n      width: 'full',\n      components: [\n        {\n          type: 'page:header',\n          id: 'case_header',\n          label: 'Case Information',\n          properties: {\n            title: '{case_number} \u00B7 {subject}',\n            // The lookup field is `crm_account` \u2014 `{account}` matched nothing\n            // and the subtitle rendered blank.\n            subtitle: '{crm_account}',\n            // `icon` removed from `page:header` in @objectstack/spec 17.0.0\n            // (#6946, ADR-0087 D2) \u2014 deleted, not renamed. See the full note on\n            // `account_detail.page.ts`; nothing ever drew it.\n            // `breadcrumb` retired from `page:header` in @objectstack/spec 17.6.0\n            // (#20785, `page-header-breadcrumb-removed`) \u2014 deleted: no renderer\n            // ever drew a trail for it; the app shell's own trail is unchanged.\n            // Action IDs, not `ActionDef` objects: `PageHeaderProps.actions` is\n            // `z.array(z.string())` (\"Action IDs to show in header\") in\n            // @objectstack/spec 17.3.0, and this repo authors against the\n            // protocol (#1653). Each id is the `name` of a crm_case-scoped\n            // action \u2014 `claim_case` / `escalate_case` / `close_case` in\n            // `src/service/actions/case.actions.ts`, the activity trio in\n            // `src/service/actions/case-activity.actions.ts`.\n            //\n            // This list is the whole header (#2072, the #592 sentence on\n            // `lead_detail.page.ts`): an action it does not name is reachable\n            // only from the list row's \u22EE menu, which is how an agent on an\n            // unowned case had to go back to the list to claim it, and could\n            // not log or book a meeting here at all. Each action's own\n            // `visible` still decides when it shows \u2014 `claim_case` only on an\n            // ownerless open case. `claim_case` goes FIRST because the header\n            // draws three buttons inline and folds the rest into \u22EF: on an\n            // ownerless case claiming is the gesture, and on an owned one it\n            // is hidden, so the inline three stay escalate / close / call.\n            // `test/action-references.test.ts` holds this list to every\n            // crm_case action placed at `record_header`.\n            actions: ['claim_case', 'escalate_case', 'close_case', 'log_call', 'log_meeting', 'schedule_meeting'],\n          },\n        },\n        {\n          type: 'record:highlights',\n          id: 'case_highlights',\n          label: 'Key Information',\n          properties: {\n            // crm_case carries a single `sla_due_date` plus the derived\n            // `is_sla_violated` flag \u2014 the split response/resolution deadlines\n            // named here do not exist, so the agent's most time-critical fact\n            // was missing from the strip entirely.\n            fields: [\n              'status',\n              'priority',\n              'sla_due_date',\n              'is_sla_violated',\n              'owner_id',\n              'crm_account',\n            ],\n          },\n        },\n        {\n          type: 'record:path',\n          id: 'case_status_path',\n          label: 'Case Status Path',\n          properties: {\n            statusField: 'status',\n            stages: [\n              { value: 'new', label: 'New' },\n              { value: 'in_progress', label: 'In Progress' },\n              // The status option is `waiting_customer`; the longer spelling\n              // matched no option, so this stage never lit up and rendered\n              // untranslated next to its neighbours.\n              { value: 'waiting_customer', label: 'Waiting on Customer' },\n              { value: 'escalated', label: 'Escalated' },\n              { value: 'resolved', label: 'Resolved' },\n              { value: 'closed', label: 'Closed' },\n            ],\n          },\n        },\n      ],\n    },\n    {\n      name: 'main',\n      width: 'large',\n      components: [\n        {\n          type: 'page:tabs',\n          id: 'case_main_tabs',\n          properties: {\n            // `type` \u2192 `tabStyle` (@objectstack/spec 17.0.0, #6776, ADR-0087\n            // D2). Same concept, same three values (`line` | `card` | `pill`);\n            // the rename exists because a props key called `type` collides with\n            // the component node's own dispatch key and is unauthorable in the\n            // flat and JSX carriers. See the full note on `home.page.ts`.\n            tabStyle: 'line',\n            position: 'top',\n            items: [\n              {\n                // Tab item `key` \u2192 `value` (#1269). `value` is the stable\n                // `?tab=` URL token the renderer reads (`it.value`, falling back\n                // to an index-derived `tab-<i>`); `key` is read by nothing, so\n                // these tabs were addressable only as `tab-0`/`tab-1`/`tab-2`,\n                // which point at different tabs the moment the item list\n                // changes. `PageTabsProps`' own alias table answers `key` with\n                // `value` for exactly this reason.\n                value: 'details',\n                label: 'Details',\n                children: [\n                  {\n                    type: 'record:details',\n                    id: 'case_details',\n                    label: 'Case Details',\n                    properties: {\n                      // `columns` is a STRING enum ('1'|'2'|'3'|'4') in\n                      // @objectstack/spec 17, and `layout` was removed there\n                      // (#6946 / ADR-0087 D2).\n                      columns: '2',\n                      // Every section references one of crm_case's `fieldGroups`\n                      // (#970, the #806 class ruling C): the renderer derives\n                      // members, label, icon and collapse state from the object,\n                      // so this page curates only the order. The full note \u2014\n                      // what a group section does on 17.6.0 and what may not sit\n                      // beside `group` \u2014 is on `lead_detail.page.ts`.\n                      //\n                      // The highlights strip still wins (#1211): the renderer\n                      // drops what `record:highlights` registered (`status`,\n                      // `priority`, `sla_due_date`, `is_sla_violated`,\n                      // `owner_id`, `crm_account`) and the title candidate\n                      // `subject` from the derived members.\n                      //\n                      // `escalated_date` \u2014 written by three flows and shown\n                      // nowhere until now (#970) \u2014 arrives with the `escalation`\n                      // group, beside `is_escalated` and `escalation_reason`.\n                      //\n                      // `internal_notes` (#1428) is in the `system` group with\n                      // `is_closed`. A group whose members are ALL empty renders\n                      // nothing, but a boolean always holds a value, so `system`\n                      // renders on every case and an unwritten `internal_notes`\n                      // stays reachable the way every empty field here is: the\n                      // section's \"Show N empty fields\" toggle, then inline edit.\n                      // \u26D4 Not the create form \u2014 `/new` and edit both resolve\n                      // `view.form`, and `case.hook.ts` nulls the column for\n                      // anonymous web-to-case submissions.\n                      //\n                      // `resolution` / `resolved_by_article` render once the case\n                      // carries one; `close_case` is the flow that collects the\n                      // resolution.\n                      //\n                      // `hideEmpty: false` (#2003, the #1211 reasoning) only on\n                      // `origin`: with `owner_id` in the strip, its one member is\n                      // the channel an agent picks, and without the key the\n                      // section vanishes on a new case. Not on `sla`: outside\n                      // the strip its members are stamps no one types\n                      // (`closed_date` and `resolution_time_hours` at close,\n                      // `first_response_date` by `event.hook.ts`), so the key\n                      // would draw empty rows to look at, not to fill.\n                      sections: [\n                        { group: 'basic' },\n                        { group: 'origin', hideEmpty: false },\n                        { group: 'sla' },\n                        { group: 'escalation' },\n                        { group: 'resolution' },\n                        { group: 'system' },\n                      ],\n                    },\n                  },\n                ],\n              },\n              {\n                value: 'related',\n                label: 'Related',\n                children: [\n                  {\n                    type: 'page:accordion',\n                    id: 'case_related_accordion',\n                    properties: {\n                      items: [\n                        {\n                          // An accordion item `key` is DELETED, not renamed to\n                          // `value` \u2014 the opposite verdict to the tab items\n                          // above, and the difference is a read point (#1269).\n                          // `PageAccordionProps`' item shape is\n                          // `{ label, icon?, collapsed?, children }` and it\n                          // prescribes AGAINST `value` by name: the renderer\n                          // maps every item to `{ ...it, value: `panel-<idx>` }`\n                          // before rendering, so an authored value is\n                          // overwritten. `page:tabs` really does read `it.value`;\n                          // `page:accordion` does not. Nothing addresses these\n                          // panels, so the identifier has nowhere to land.\n                          label: 'Open Tasks',\n                          children: [\n                            {\n                              type: 'record:related_list',\n                              id: 'case_tasks',\n                              properties: {\n                                objectName: 'crm_task',\n                                relationshipField: 'related_to_case',\n                                columns: [\n                                  'subject',\n                                  'status',\n                                  'priority',\n                                  'due_date',\n                                  'owner_id',\n                                ],\n                                filter: [\n                                  { field: 'status', operator: 'not_equals', value: 'completed' },\n                                ],\n                                limit: 10,\n                              },\n                            },\n                          ],\n                        },\n                      ],\n                    },\n                  },\n                ],\n              },\n              {\n                value: 'activity',\n                label: 'Activity',\n                children: [\n                  {\n                    type: 'record:activity',\n                    id: 'case_activity',\n                    properties: {\n                      filterMode: 'all',\n                      showFilterToggle: true,\n                      limit: 25,\n                      unifiedTimeline: true,\n                      showCommentInput: true,\n                      enableMentions: true,\n                      enableReactions: true,\n                      enableThreading: true,\n                      // Load-bearing (#2071): a call or meeting logged on the\n                      // case is a `sys_activity` row of type `completed` (the\n                      // `task` feed kind), and the renderer drops every such\n                      // row unless this is true \u2014 so an agent's logged call\n                      // never reached this tab. The case's other `completed`\n                      // writers are its own `resolved` / `closed` milestones\n                      // (`case.object.ts`), which belong on this timeline too.\n                      // Completed crm_task rows do NOT arrive here: a task's\n                      // audit rows are keyed to the task, and this feed reads\n                      // only rows keyed to the case. No `types` filter, unlike\n                      // the lead page: this timeline mixes comments and field\n                      // changes on purpose (`unifiedTimeline` above).\n                      showCompleted: true,\n                    },\n                  },\n                ],\n              },\n            ],\n          },\n        },\n      ],\n    },\n  ],\n\n  isDefault: true,\n\n  aria: {\n    ariaLabel: 'Case Detail Page',\n    ariaDescribedBy: 'Service-agent case detail view with SLA path, details, related items and activity timeline.',\n  },\n};\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/service/reports/case.report.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/service/reports\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/service/reports/case.report.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport type { Report } from '@objectstack/spec/ui';\n\nexport const CasesByStatusPriorityReport: Report = {\n  name: 'cases_by_status_priority',\n  label: 'Cases by Status and Priority',\n  description: 'Summary of cases by status and priority',\n  // The chart counts cases, so `case_count` must be selected alongside the\n  // resolution time \u2014 and the yAxis must name that MEASURE ('case_number'\n  // was a raw-field name that exists in no dataset, so the axis was empty).\n  dataset: 'case_metrics', rows: ['status', 'priority'], values: ['case_count', 'avg_resolution'],\n  type: 'summary',\n  chart: { type: 'bar', title: 'Cases by Status', showLegend: true, xAxis: 'status', yAxis: 'case_count' }\n};\n\nexport const SlaPerformanceReport: Report = {\n  name: 'sla_performance',\n  label: 'SLA Performance Report',\n  description: 'Analysis of SLA compliance',\n  // 'avg_sla_violated' (not a duplicated 'case_count') \u2014 the table showed two\n  // identical Cases columns and no violation measure; the chart's yAxis must\n  // name a dataset MEASURE, not a raw field ('is_sla_violated' leaked the\n  // column name onto the axis).\n  dataset: 'case_metrics', rows: ['priority'], values: ['case_count', 'avg_sla_violated', 'avg_resolution'],\n  type: 'summary',\n  runtimeFilter: { is_closed: true },\n  chart: { type: 'column', title: 'SLA Violations by Priority', showLegend: false, xAxis: 'priority', yAxis: 'avg_sla_violated' }\n};\n\n/**\n * Daily case inflow by priority \u2014 matrix over `created_at`. Support managers\n * use this to spot priority spikes (e.g. a P1 burst on Tuesday) and staff\n * accordingly.\n *\n * `case_metrics.created_at` declares the day bucket, so records created at\n * different times on the same day aggregate into one column.\n *\n * No `runtimeFilter` (#1992). The column used to be `created_date`, which\n * nothing wrote on a real case, so this report carried\n * `{ created_date: { $ne: null } }` against a headerless '\u2014' column and every\n * case created through the UI or REST fell out of it. `created_at` is the\n * platform's own creation stamp, written on every insert, so there is no\n * empty bucket to exclude and every case opened is counted.\n */\nexport const CasesOpenedByDayPriorityReport: Report = {\n  name: 'cases_opened_by_day_priority',\n  label: 'Cases Opened by Priority \u00D7 Day',\n  description: 'Daily case inflow split by priority',\n  dataset: 'case_metrics', rows: ['priority'], columns: ['created_at'], values: ['case_count'],\n  type: 'matrix',\n};\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/service/sharing/case.sharing.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/service/sharing\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/service/sharing/case.sharing.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport { P } from '@objectstack/spec';\n\n/**\n * Share escalated/critical cases with service managers.\n * ADR-0090 D3: `role_and_subordinates` is gone (positions are flat); the\n * grant now targets the manager position itself.\n *\n * ### \u26A0\uFE0F `is_closed == false` is DELIBERATE here \u2014 ruled 2026-08-31, do NOT align it\n *\n * `is_closed` is derived by `case_sla_defaults` as `effStatus === 'closed'` and\n * never flips on `resolved`, so this grant stands for the WHOLE\n * `resolved \u2192 closed` window: a manager keeps `edit` on a critical case that an\n * agent has already resolved, until somebody closes it.\n *\n * That standing access is the point, not an oversight. `resolved` means \"the\n * agent believes this is fixed\", not \"this case is over\", and the work that\n * belongs in the gap is the manager's: quality-sampling the resolution, calling\n * the customer back, reopening it when the fix did not hold. Taking the grant\n * away at `resolved` would revoke access exactly when that review starts. It is\n * also how mainstream service clouds shape the same window \u2014 a Zendesk\n * satisfaction rating arrives after Solved, ServiceNow surveys on resolution\n * and auto-closes on a timer.\n *\n * Two properties keep this from being the accumulating-permission hazard that\n * #1145 was about: it is NARROW (`critical` only \u2014 not every case a manager\n * could ask for) and it is BOUNDED (closing the case ends it, and closing is an\n * ordinary agent gesture, not an admin one).\n *\n * \u26D4 Do not rewrite this as `status not_in ['resolved', 'closed']` for symmetry\n * with `case_unassigned_triage_sharing` below. Same spelling, different\n * question: that rule asks \"is this work waiting for a human\", this one asks\n * \"may a manager still reach this case\". `test/live-work-predicate-parity.test.ts`\n * holds the difference on its boundary roster, so the alignment turns it red\n * rather than landing silently.\n *\n * ### What would make this the WRONG shape\n *\n * The keep rests on a workflow nobody has yet measured a real user performing,\n * so it is a judgement with named conditions rather than a fact. Any of these\n * turning true makes it a card to re-decide, not a tidy-up to perform:\n *\n *   - cases pile up in `resolved` because nothing closes them, so \"bounded\"\n *     stops being true in practice and the grant is effectively permanent;\n *   - the post-resolution review moves to a surface that needs no record access\n *     (a survey object, a report), leaving this grant with no consumer;\n *   - the criteria widens past `critical`, at which point \"narrow\" is gone too;\n *   - somebody measures that no manager ever opens a resolved case \u2014 the one\n *     piece of evidence #1328 could not obtain and explicitly declined to\n *     assume either way.\n */\nexport const CaseEscalationSharingRule = {\n  name: 'case_escalation_sharing',\n  label: 'Escalated Cases Sharing',\n  object: 'crm_case',\n  type: 'criteria' as const,\n  condition: P`record.priority == \"critical\" && record.is_closed == false`,\n  accessLevel: 'edit' as const,\n  sharedWith: { type: 'position' as const, value: 'service_manager' },\n};\n\n/**\n * The same escalation visibility one rung up.\n *\n * Positions are FLAT (ADR-0090 D3), so the director rung needs its own grant \u2014\n * without it a service director cannot open the critical case their manager is\n * being paged about. Read-only: the manager on the rule above handles it.\n *\n * ### \u26A0\uFE0F `is_closed == false` is DELIBERATE here too \u2014 ruled 2026-08-31\n *\n * Read the note on `CaseEscalationSharingRule` above in full; it is the same\n * decision and the same conditions for revisiting it. The short form: the flag\n * never flips on `resolved`, so a director keeps `read` on a resolved critical\n * case until it is closed, and that `resolved \u2192 closed` window is precisely\n * when a director looks \u2014 an escalation is reviewed after it is handled, not\n * while it is still burning. `read`, not `edit`, is the whole difference from\n * the rule above: the director watches the window, the manager works it.\n *\n * \u26D4 Do not move this onto `status not_in ['resolved', 'closed']`. Pinned on the\n * boundary roster of `test/live-work-predicate-parity.test.ts`, with the reason.\n */\nexport const CaseDirectorSharingRule = {\n  name: 'case_director_sharing',\n  label: 'Escalated Cases \u2014 Service Director',\n  object: 'crm_case',\n  type: 'criteria' as const,\n  condition: P`record.priority == \"critical\" && record.is_closed == false`,\n  accessLevel: 'read' as const,\n  sharedWith: { type: 'position' as const, value: 'service_director' },\n};\n\n/**\n * The intake queue's read side: an OPEN case that nobody owns is visible to\n * every service agent, so they can pull it out of triage (#1096).\n *\n * ### What was broken\n *\n * #596 shipped round-robin intake plus a pinned `Unassigned \u2014 triage` tab, and\n * `case_auto_assign` is a deliberate NO-OP whenever the `service_agent` pool is\n * empty or unreadable (the anonymous web-to-case path cannot read\n * `sys_user_position` at all). Those cases land ownerless \u2014 and `service_agent`\n * holds `crm_case` with `readScope: 'own'`, so an unowned row matched nobody's\n * own-scope. The tab was pinned in every Cases list including the agent's, and\n * it returned zero rows for the one persona it exists for.\n *\n * ### Why THIS shape (the ruling on #1096, option A)\n *\n * The grant is **self-limiting**: it holds only while `owner_id` is empty, so\n * the instant an agent claims the case the criteria stops matching, the share\n * is revoked on the next reconcile, and ordinary own-scope resumes. There is no\n * accumulating permission surface \u2014 the rule's own condition destroys it. That\n * is what makes it narrower than the two rejected alternatives: `viewAllRecords`\n * on the profile (option C) hands every agent every customer's entire case\n * history to solve a null-owner problem, and unpinning the tab (option B) is not\n * expressible \u2014 `ViewTabSchema` has no per-profile scoping \u2014 so it means\n * removing the tab for everyone.\n *\n * `edit`, not `read`: triage is a pull queue. An agent who can see the row but\n * not write it cannot claim it, and claiming is the whole point.\n *\n * ### \u26A0\uFE0F Why there is no `has()` guard here, and why adding one would break it\n *\n * A sharing condition is NOT an interpreted CEL predicate. `plugin-sharing`\n * compiles it to a pushdown filter with `compileCelToFilter`, which rejects the\n * whole function-call class \u2014 so a `has(record.owner_id)` guard makes this rule\n * *untranslatable*, and the seeder then refuses it outright (never degrading it\n * to match-all). The rule would be declared, documented and silently unseeded:\n * exactly the #621 defect. The house totality rule (AGENTS.md #630) governs the\n * two INTERPRETED surfaces \u2014 object `validations[]` / field predicates, and\n * record-change flow conditions \u2014 and does not reach this one.\n *\n * Totality is still answered, one layer down: `record.owner_id == null` lowers\n * to `{ owner_id: { $null: true } }`, and `$null` is the operator form that\n * treats an ABSENT key and a NULL column alike. That matters because the two\n * shapes are both real \u2014 `driver-memory` stores only the columns a row was\n * written with, SQL stores every column \u2014 and a marketplace app does not choose\n * its host's datasource. Both are MEASURED, end to end, in\n * `test/unassigned-case-triage-reach.test.ts`; the compiler's own verdict on\n * `has()` is pinned in `test/sharing-seeding.test.ts`.\n *\n * ### \u26A0\uFE0F Why the second clause is a STATUS chain, not `is_closed == false`\n *\n * This grant is deliberately NARROWER than it was. `is_closed` is derived by\n * `case_sla_defaults` as `effStatus === 'closed'`, so it never flips on\n * `resolved` \u2014 and the old predicate therefore handed every service agent\n * `edit` on every RESOLVED ownerless case, forever. A resolved case is not\n * backlog and not work waiting for a human, so the grant is now the same\n * \"no longer live work\" predicate the load-balancing hooks\n * (`CLOSED_CASE_STATUSES` in `_case-assignment.ts`) and `case_sla_monitor`\n * already use: the case is shared only while its status is neither `resolved`\n * nor `closed`. `test/live-work-predicate-parity.test.ts` holds the four\n * consumers to that one set, BY NAME.\n *\n * \u26A0\uFE0F The tightening does NOT break the claim seam. Record access is resolved\n * against the STORED row, so an agent resolving an unowned open case straight\n * out of triage is still reachable (the case is open at the moment of the\n * write) \u2014 #1143's \"finishing a case is not picking it up\" is unchanged. What\n * the agent loses is reopening an *already* resolved ownerless case, which puts\n * `resolved` in exactly the bucket `closed` has been in since #1134: reopening\n * a terminal unowned case is an admin move, not a triage move.\n *\n * The spelling is the `!=` chain rather than `!(record.status in [...])`, and\n * that is measured, not stylistic. Both compile, but the membership form lowers\n * to a TOP-LEVEL `$not` wrapping an `$in`, a combination absent from the\n * measured operator matrix in `test/sharing-seeding.test.ts` and on the one\n * operator that file records a driver regression for. The chain lowers to\n * `{ $and: [{ status: { $ne: \u2026 } }, \u2026] }` \u2014 plain conjunction of the operator\n * that matrix lists as supported. An untranslatable or unexecutable sharing\n * condition is not a loud failure: the seeder DROPS the rule and the tab goes\n * empty again (#621), so this rule takes the portable form.\n *\n * `status` needs no totality guard the way `owner_id` does: it is `required`\n * with `storage: { notNull: true }` on `crm_case`, so unlike the ownerless\n * column it is never the absent-key shape.\n *\n * A resolved or closed unowned case stays hidden on purpose: it is history, not\n * backlog, and the tab's row count has to keep meaning \"work waiting for a\n * human\".\n */\nexport const CaseUnassignedTriageSharingRule = {\n  name: 'case_unassigned_triage_sharing',\n  label: 'Unassigned Cases \u2014 Triage',\n  object: 'crm_case',\n  type: 'criteria' as const,\n  condition: P`record.owner_id == null && record.status != \"resolved\" && record.status != \"closed\"`,\n  accessLevel: 'edit' as const,\n  sharedWith: { type: 'position' as const, value: 'service_agent' },\n};\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/service/skills/case-triage.skill.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/service/skills\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/service/skills/case-triage.skill.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport { defineSkill } from '@objectstack/spec';\n\n/**\n * Case Triage \u2014 prioritise a support case and route it to the right action.\n *\n * ADR-0109: this skill declares NO tool records. Triage itself is\n * reasoning, not a tool \u2014 the agent reads the case with the platform's\n * data tools and applies the rubric below.\n *\n * It deliberately calls NOTHING that mutates. Escalate and Close carry no\n * `ai` block, and ADR-0011 exposure is opt-in / default off, so the\n * runtime materialises no `action_escalate_case` / `action_close_case`\n * tool for the skill to call. That is the right shape here \u2014 both Actions\n * exist to collect a reason / resolution from a person, so the agent\n * supplies the judgement and the human supplies the words and the\n * decision \u2014 and the skill recommends the button instead of pretending to\n * press it. (Both became `type: 'flow'` in #515, so opting them in later\n * is a governance call, not a mechanical one; the review step is the\n * point.)\n */\nexport const CaseTriageSkill = defineSkill({\n  name: 'case_triage',\n  label: 'Case Triage',\n  description: 'Triages a support case, assigns a priority with its justification, and points at the escalate/close action.',\n\n  instructions: `When the user asks to triage, prioritise, or classify a case:\n\n1. Read the case first \u2014 call \\`describe_object\\` for \\`crm_case\\` (the\n   schema is alive; admins add fields), then \\`get_record\\` for the case\n   at hand. Never triage from memory of a previous turn.\n2. Assign a priority yourself from what you read. There is no triage\n   tool and you do not need one \u2014 weigh, in order: customer tier and\n   contract value, whether the customer is blocked with no workaround,\n   how long the case has been open against its SLA, and the sentiment\n   of the latest customer message.\n3. State the priority and the ONE reason that drove it. Cite the case\n   ID and the field values you used.\n4. If the priority is critical, say so and point the user at\n   **Escalate Case** on the record header \u2014 offer a ready-to-paste\n   \\`reason\\` built from step 3. You cannot escalate yourself, and should\n   not imply otherwise.\n5. If the case is resolved in substance, point at **Close Case** and\n   offer a \\`resolution\\` summary the user can paste.\n6. For the customer-facing reply, hand off to the \\`email_drafting\\`\n   skill rather than drafting it here.`,\n\n  tools: ['describe_object', 'get_record'],\n\n  triggerConditions: [\n    { field: 'objectName', operator: 'eq', value: 'crm_case' },\n  ],\n});\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/service/views/case.view.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/service/views\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/service/views/case.view.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport { defineView } from '@objectstack/spec/ui';\n\n/**\n * The one data provider every view below reads \u2014 the default list, the seven\n * named list views and the web-to-case form all list or write `crm_case` \u2014\n * written once and passed by shorthand (`data,`) rather than spelled out nine\n * times.\n */\nconst data = { provider: 'object', object: 'crm_case' } as const;\n\n/**\n * Case (Service) Views\n *\n *   \u2022 grid     \u2014 support queue with SLA columns\n *   \u2022 kanban   \u2014 case workflow grouped by status\n *   \u2022 timeline \u2014 chronological case stream\n *   \u2022 calendar \u2014 SLA due-date calendar\n */\nexport const CaseViews = defineView({\n  list: {\n    type: 'grid',\n    name: 'all_cases',\n    label: 'All Cases',\n    userActions: { editInline: true },\n    data,\n    columns: [\n      { field: 'case_number', width: 130, sortable: true, link: true, pinned: 'left' },\n      { field: 'subject', width: 280, sortable: true },\n      { field: 'crm_account', width: 180 },\n      { field: 'crm_contact', width: 160 },\n      { field: 'priority', width: 110, sortable: true },\n      { field: 'status', width: 130, sortable: true },\n      { field: 'origin', width: 120 },\n      { field: 'sla_due_date', width: 160, sortable: true },\n      { field: 'is_sla_violated', width: 110, align: 'center' },\n      { field: 'is_escalated', width: 110, align: 'center' },\n      { field: 'owner_id', width: 150 },\n    ],\n    // Sort on the materialised ordinal, not the select itself: `priority desc`\n    // compares raw strings and lands medium > low > high > critical, burying\n    // every critical case at the bottom of the queue.\n    sort: [\n      { field: 'priority_rank', order: 'desc' },\n      { field: 'sla_due_date', order: 'asc' },\n    ],\n    rowColor: {\n      field: 'priority',\n      colors: { critical: 'red', high: 'orange', medium: 'yellow', low: 'slate' },\n    },\n    selection: { type: 'multiple' },\n    pagination: { pageSize: 50 },\n    // The UI door for the `allowExport` grant four profiles already hold on\n    // `crm_case`. Export runs on ONE server-side route\n    // (`GET /api/v1/data/crm_case/export`, gated by `security.canExport`), so\n    // this declares which formats the toolbar offers \u2014 not a second gate: a\n    // profile without the grant gets 403 whether it clicks the button or\n    // curls the route. Measured in #798/#816; before this the grant was live\n    // but reachable only by `curl`.\n    exportOptions: { formats: ['csv', 'xlsx'] },\n    appearance: {\n      showDescription: true,\n      allowedVisualizations: ['grid', 'kanban', 'calendar', 'timeline'],\n    },\n    // Binds the 'calendar' entry above: the switcher opens the same deadlines\n    // the dedicated `sla_calendar` view shows, on the field this list already\n    // sorts by. `sla_due_date` is optional \u2014 a case the SLA monitor has not\n    // stamped carries no date at all, which is the truthful answer; the\n    // alternative the platform refuses is a guessed field putting every such\n    // case on today.\n    calendar: {\n      startDateField: 'sla_due_date',\n      titleField: 'subject',\n      colorField: 'priority',\n    },\n    // Escalate straight from the queue: escalate_case's own\n    // `locations: ['list_item']` auto-injects the row-menu item.\n  },\n\n  listViews: {\n    /** Service workflow board */\n    case_workflow: {\n      name: 'case_workflow',\n      type: 'kanban',\n      label: 'Service Workflow',\n      data,\n      columns: ['case_number', 'subject', 'priority', 'sla_due_date'],\n      kanban: {\n        groupByField: 'status',\n        columns: ['case_number', 'subject', 'crm_account', 'priority', 'owner_id'],\n      },\n      filter: [{ field: 'is_closed', operator: 'equals', value: false }],\n      navigation: { mode: 'drawer', width: '640px' },\n    },\n\n    /** SLA calendar */\n    sla_calendar: {\n      name: 'sla_calendar',\n      type: 'calendar',\n      label: 'SLA Calendar',\n      data,\n      columns: ['case_number', 'subject', 'priority'],\n      calendar: {\n        startDateField: 'sla_due_date',\n        titleField: 'subject',\n        colorField: 'priority',\n      },\n    },\n\n    /** Chronological case stream */\n    case_timeline: {\n      name: 'case_timeline',\n      type: 'timeline',\n      label: 'Case Timeline',\n      data,\n      columns: ['case_number', 'subject'],\n      timeline: {\n        // `created_at`, the platform's own creation stamp \u2014 the object's\n        // duplicate `created_date` was removed in #1992 because nothing wrote\n        // it on a real case, so every user-created case started its bar at\n        // null. Same spelling as `deal_timeline` on crm_opportunity (#575 B2).\n        startDateField: 'created_at',\n        endDateField: 'closed_date',\n        titleField: 'subject',\n        groupByField: 'owner_id',\n        colorField: 'status',\n        scale: 'day',\n      },\n    },\n\n    /**\n     * The agent's personal queue: the cases themselves, one row each. Its\n     * aggregate counterpart is service_dashboard's \"My Open Cases by\n     * Priority\" (#510) \u2014 a dashboard widget counts, it cannot list.\n     */\n    my_open_cases: {\n      name: 'my_open_cases',\n      type: 'grid',\n      label: 'My Open Cases',\n      userActions: { editInline: true },\n      data,\n      columns: ['case_number', 'subject', 'crm_account', 'priority', 'status', 'sla_due_date'],\n      // \u26A0\uFE0F `status not_in CLOSED_CASE_STATUSES`, NOT `is_closed == false`: the\n      // flag is derived as `effStatus === 'closed'` and never flips on\n      // `resolved`, so the flag spelling listed every RESOLVED case under a tab\n      // labelled \"My Open Cases\" \u2014 measured on the seeded demo population, the\n      // flag returned 30 of 38 cases and 7 of those 30 were resolved. A resolved\n      // case is finished work awaiting closure, not an open queue, and the\n      // mainstream service-cloud reading of \"open\" excludes it (Zendesk's open\n      // set omits Solved; ServiceNow's OOTB Open filter is\n      // `state not in (Resolved, Closed, Cancelled)`). Ruled 2026-08-31; pinned by\n      // `test/live-work-predicate-parity.test.ts` (#1145), whose consumer roster\n      // this view joined in the same change.\n      filter: [\n        { field: 'owner_id', operator: 'equals', value: '{current_user_id}' },\n        { field: 'status', operator: 'not_in', value: ['resolved', 'closed'] },\n      ],\n      sort: [\n        { field: 'priority_rank', order: 'desc' },\n        { field: 'sla_due_date', order: 'asc' },\n      ],\n    },\n\n    /**\n     * Unassigned \u2014 triage (#596). The second half of the queue substitute.\n     *\n     * `case_auto_assign` (`src/service/objects/_case-assignment.ts`) is a NO-OP whenever\n     * the `service_agent` pool is empty, and an empty pool is the FIRST-INSTALL\n     * NORM rather than an edge case: `sys_user_position` membership is runtime\n     * data, so on a fresh org \u2014 and any time every agent has been unassigned\n     * from the position \u2014 an inbound web-to-case lands ownerless. Best-effort\n     * assignment also stands down on a permission denial (the anonymous\n     * public-form context cannot read `sys_user_position` at all).\n     *\n     * Those cases used to be invisible: no view filtered on the absence of an\n     * owner, so an unowned case appeared in `All Cases` with a blank Owner\n     * column and nothing distinguished it from the rest. This view is the\n     * standing answer \u2014 silence replaced by a pinned tab whose row count IS the\n     * intake backlog.\n     *\n     * `is_null` on `owner_id`, not `equals: null`: the ownerless shape is an\n     * ABSENT column on driver-memory (see the totality note in\n     * `case-escalation.flow.ts`, where `record.escalated_date == null` aborted\n     * with `No such key`) as well as a NULL one on SQL, and only the operator\n     * form answers the same way for both.\n     *\n     * The predicate for \"no longer live work\" is `status not_in ['resolved',\n     * 'closed']`, NOT `is_closed == false`. `is_closed` is derived by\n     * `case_sla_defaults` as `effStatus === 'closed'`, so it never flips on\n     * `resolved` \u2014 and a resolved ownerless case satisfied both of this view's\n     * old filters and sat here forever, which is neither \"arrives with no\n     * owner\" nor \"work waiting for a human\". `not_in` lowers to the `$nin` the\n     * load-balancing hooks and `case_sla_monitor` already use for the same\n     * concept, so the four consumers now state one predicate; the roster that\n     * holds them together by NAME is `test/live-work-predicate-parity.test.ts`.\n     * `closed` stays excluded for the reason it always was: history, not\n     * backlog.\n     *\n     * \u26A0\uFE0F WHO ACTUALLY SEES ROWS HERE is decided by record-level access, not by\n     * this view, and the answer today is narrower than the tab suggests. A\n     * view tab carries no role scoping \u2014 `ViewTabSchema` has `pinned`,\n     * `isDefault` and a boolean `visible`, and nothing per-profile \u2014 so this is\n     * pinned for everyone who can open Cases, while the ROWS resolve per\n     * profile:\n     *\n     *   - `system_admin` \u2014 `viewAllRecords`, so the full backlog. This is the\n     *     persona the empty-pool state is FOR: an empty `service_agent` pool is\n     *     fixed by staffing `sys_user_position`, which only an admin can do.\n     *   - `sales_manager` \u2014 `viewAllRecords`, read-only.\n     *   - a service manager / director \u2014 the critical, open slice only, via the\n     *     existing `case_escalation_sharing` / `case_director_sharing` criteria\n     *     rules (`src/service/sharing/case.sharing.ts`).\n     *   - `service_agent` \u2014 `readScope: 'own'` on `crm_case`, and an unowned\n     *     row is owned by nobody, so **an agent's triage tab is empty**.\n     *\n     * The last line is a real gap for the \"agent pulls from the queue\" story\n     * and is deliberately NOT closed here: granting service roles sight of\n     * unowned cases is a sharing-model change (a new criteria rule, or a\n     * `readScope` widening), which is outside this card's file surface and is\n     * exactly the kind of quiet permission widening the #596 ruling rules out.\n     * Filed as #1096 for a decision, with the reach table above and the three\n     * options priced.\n     */\n    unassigned_triage: {\n      name: 'unassigned_triage',\n      type: 'grid',\n      label: 'Unassigned \u2014 triage',\n      userActions: { editInline: true },\n      data,\n      columns: ['case_number', 'subject', 'crm_account', 'crm_contact', 'priority', 'status', 'origin', 'sla_due_date'],\n      filter: [\n        { field: 'owner_id', operator: 'is_null' },\n        { field: 'status', operator: 'not_in', value: ['resolved', 'closed'] },\n      ],\n      // Same ordering as the main queue: urgency first (on the materialised\n      // ordinal, never the raw select), then soonest deadline.\n      sort: [\n        { field: 'priority_rank', order: 'desc' },\n        { field: 'sla_due_date', order: 'asc' },\n      ],\n      rowColor: {\n        field: 'priority',\n        colors: { critical: 'red', high: 'orange', medium: 'yellow', low: 'slate' },\n      },\n      // The empty state carries the operational instruction, because \"no rows\"\n      // here is ambiguous on its own: it means either \"the round-robin placed\n      // everything\" (good) or \"no case has arrived yet\" (also fine) \u2014 and the\n      // reader most likely to be looking is someone who just found the tab\n      // full and needs to know why.\n      emptyState: {\n        title: 'Nothing waiting for triage',\n        message: 'Every case has an owner. Cases appear here when they arrive with no owner \u2014 typically a web-to-case submission that arrived while nobody held the Service Agent position.',\n        icon: 'inbox',\n      },\n    },\n\n    escalated_cases: {\n      name: 'escalated_cases',\n      type: 'grid',\n      label: 'Escalated Cases',\n      userActions: { editInline: true },\n      data,\n      columns: ['case_number', 'subject', 'crm_account', 'priority', 'sla_due_date', 'owner_id'],\n      filter: [{ field: 'is_escalated', operator: 'equals', value: true }],\n      sort: [{ field: 'priority_rank', order: 'desc' }],\n    },\n\n    /**\n     * SLA-at-risk: open cases at High or Critical priority needing attention.\n     *\n     * \u26A0\uFE0F Names what the filter below actually selects. This read\n     * \"high/urgent\" until #1333 \u2014 but `crm_case.priority` is\n     * low/medium/high/critical (`case.object.ts:138-142`) and has NO `urgent`;\n     * that value belongs to `crm_task`. The mirror-image crossing already\n     * shipped a real defect once (`task.view.ts:35` \u2014 Case colour keys on the\n     * task view left every urgent and normal row uncoloured), and the\n     * direction that cost something was the one where the comment was\n     * believed. Two overlapping-but-unequal vocabularies: keep them apart.\n     */\n    sla_at_risk: {\n      name: 'sla_at_risk',\n      type: 'grid',\n      label: '\u23F0 SLA at Risk',\n      userActions: { editInline: true },\n      data,\n      columns: ['case_number', 'subject', 'crm_account', 'priority', 'sla_due_date', 'owner_id'],\n      // Operator-only filter \u2014 sort by SLA due date ascending so the soonest\n      // surface first. (The view runtime does not interpolate `{NOW() + 4h}`.)\n      //\n      // \u26A0\uFE0F `status not_in CLOSED_CASE_STATUSES`, NOT `is_closed == false`: the\n      // flag is derived as `effStatus === 'closed'` and never flips on\n      // `resolved`, so the flag spelling listed resolved cases as at risk while\n      // `case_sla_monitor` \u2014 the automation that OWNS SLA \u2014 had already\n      // excluded them (`status: { $nin: ['resolved', 'closed'] }`). The tab a\n      // human reads and the sweep that acts must answer this one question the\n      // same way. Pinned by `test/live-work-predicate-parity.test.ts` (#1145).\n      filter: [\n        { field: 'status', operator: 'not_in', value: ['resolved', 'closed'] },\n        { field: 'priority', operator: 'in', value: ['high', 'critical'] },\n      ],\n      sort: [{ field: 'sla_due_date', order: 'asc' }],\n    },\n  },\n\n  /**\n   * The record form \u2014 and, because the platform has ONE, the CREATE form too.\n   *\n   * ## \u26A0\uFE0F This object's `form` IS the create dialog (#1214 item 3)\n   *\n   * Measured against the console this app shipped at that taking\n   * (`@objectstack/console` 17.1.0, `dist/assets/`; this bundle read was \u26D4 NOT\n   * re-taken on any later pin), BOTH\n   * entry points that open a case form resolve\n   * it the same way and neither takes a create/edit argument:\n   *\n   *   RecordFormPage (`/{object}/new`, `/{object}/record/{id}/edit`)\n   *       view.form ?? view.formViews?.default\n   *   useActionModal (the `+ New` modal off a list view)\n   *       view.form ?? view.formViews?.default\n   *\n   * \u21D2 There is no create-only form to author. `ListViewSchema.addRecord`\n   * carries a `formView` key in `@objectstack/spec`, but NO console code path\n   * reads it (the string appears only in the view designer's own i18n table),\n   * so pointing it at a second form view would ship an ADR-0049\n   * declared-but-unenforced shape and change nothing on screen.\n   *\n   * \u21D2 Therefore the create-safe field set has to BE this form's field set.\n   * That is why the SLA and Resolution sections are gone rather than gated.\n   *\n   * ## \u26D4 Why the tab strip was not the object's `fieldGroups`\n   *\n   * `crm_case.fieldGroups` declares SIX groups (Case Information / Origin &\n   * Routing / SLA & Priority / Resolution / Escalation / System) and the\n   * dialog showed THREE tabs \u2014 these sections. The renderer only reaches for\n   * `fieldGroups` on its AUTO-DERIVED path, taken when a form authors no\n   * `sections` at all; an authored `sections` array wins outright. So\n   * `src/service/objects/case.object.ts` is not part of this surface.\n   *\n   * ## \u26A0\uFE0F Authoring `sections` OPTS OUT of the create-mode field strip\n   *\n   * That auto-derived path also runs two filters the authored path never sees\n   * (`plugin-form`: `Qe` \u2192 `qe` drops `readonly`/`hidden` fields, and on\n   * `mode === 'create'` `Je` additionally drops formula / summary / autonumber\n   * fields). An authored section renders its list VERBATIM. That is the whole\n   * mechanism behind this defect: the platform would have hidden\n   * `created_date` (retired in #1992), `closed_date`, `resolution_time_hours`\n   * and `is_closed` from a creator by itself, and naming them in a section put\n   * them back.\n   *\n   * ## \u26D4 Why not gate the old sections on a predicate instead\n   *\n   * A section-level `visibleWhen` is parsed by `FormSectionSchema` and read by\n   * NOTHING in the form renderer (only FIELD-level `visibleWhen` is\n   * evaluated), so it would hide nothing. And field-level predicate evaluation\n   * FAILS OPEN \u2014 an unevaluable predicate renders the field visible, with no\n   * diagnostic (the house rule at the top of `lead.view.ts`, upstream\n   * objectstack-ai/objectstack#5149). A gate that fails open is not a gate for\n   * a data-integrity control, which is what this one is.\n   *\n   * ## What a creator may author here, and why the rest left\n   *\n   * Everything below is a fact the person raising the case HAS at intake.\n   * `case_number` stays because it is `readonly: true` on the object, so the\n   * renderer disables it \u2014 it is shown, never authored.\n   *\n   * The removed fields are all written by the lifecycle, and every one of them\n   * still has the surface it belongs on (pinned in\n   * `test/case-create-form-narrowing.test.ts`, both directions):\n   *\n   *   closed_date                      readonly; `case_timeline` end\n   *                                    (its start is the platform's\n   *                                    `created_at`; `created_date` was\n   *                                    retired in #1992)\n   *   sla_due_date                     `case.hook.ts` stamps it from the\n   *                                    priority \u00D7 tier matrix; list column,\n   *                                    sort key, `sla_calendar.startDateField`,\n   *                                    detail-page highlights\n   *   first_response_date              `event.hook.ts` is its SINGLE writer\n   *   resolution_time_hours            readonly; derived at close; detail page\n   *   is_sla_violated                  list column + detail-page highlights\n   *   is_escalated, escalation_reason  written by `case_escalation` /\n   *                                    `case_sla_monitor` / `escalate_case`;\n   *                                    detail page's Status & SLA section\n   *   resolution                       detail page's Description section\n   *                                    (the `resolution_required_on_close`\n   *                                    validation still has its surface)\n   *   is_closed                        readonly; derived from `status`\n   *\n   * \u26A0\uFE0F `internal_notes`, `customer_rating` and `customer_feedback` left with\n   * the Resolution section and had NO other authoring surface at all. #1428\n   * settled both halves of that, and neither answer was \"put them back here\":\n   *\n   *   internal_notes                   `case_detail.page.ts`'s Description\n   *                                    section, authored by inline edit \u2014\n   *                                    staff prose an agent writes while\n   *                                    WORKING a case, which is why it did not\n   *                                    come back to this form. The guest\n   *                                    branch of `case.hook.ts` nulls the\n   *                                    column on anonymous intake, so an\n   *                                    intake surface for it would be a\n   *                                    surface for a value the app discards.\n   *\n   *   customer_rating,                 RETIRED under ADR-0049 enforce-or-remove\n   *   customer_feedback                (maintainer ruling, decision batch #21,\n   *                                    2026-09-03). Neither column exists on\n   *                                    `crm_case` any more, so there is nothing\n   *                                    here to omit and nothing anywhere to\n   *                                    author.\n   *\n   * \u26D4 Do not re-introduce either field, here or elsewhere. The ruling was not\n   * \"no room on this form\": a satisfaction score typed by the person being\n   * scored is not the same fact as one the customer gave, and neither field was\n   * named in ANY profile's `fields` map \u2014 which on this platform means\n   * unrestricted, not restricted. `case_csat_followup`, whose only purpose was\n   * to notify the case owner to log a rating, was retired in the same change.\n   * A customer-answered survey is a feature and would arrive as its own card,\n   * not as two inputs added back here.\n   *\n   * `type: 'simple'`, not `'tabbed'`: one section is not a tab strip.\n   */\n  form: {\n    type: 'simple',\n    sections: [\n      {\n        name: 'case',\n        label: 'Case',\n        columns: 2,\n        fields: [\n          'case_number',\n          { field: 'subject', required: true, span: 'full' },\n          { field: 'crm_account', required: true },\n          'crm_contact',\n          { field: 'status', required: true },\n          'priority',\n          'origin',\n          'owner_id',\n          // Required on the object with no default \u2014 a form without it could\n          // never save a new case.\n          { field: 'description', required: true, span: 'full' },\n        ],\n      },\n    ],\n  },\n\n  /**\n   * Additional named form views.\n   *\n   * `web_to_case` is a PUBLIC / ANONYMOUS support form (Salesforce\n   * Web-to-Case equivalent). Hosted at `/forms/support` and embeddable in\n   * a help center. Guests can ONLY submit \u2014 the `guest_portal` profile\n   * denies read/edit/delete on `crm_case`. Internal fields (status, origin,\n   * owner_id, SLA) are stamped by `case.hook.ts` after a guest submission.\n   * `priority` is NOT one of them: this form asks the guest for it, and an\n   * unset one is filled by the `low` option `crm_case.priority` declares\n   * `default: true`. Field defaults are applied before `beforeInsert`, so the\n   * hook only ever reads `priority` (to derive `priority_rank`).\n   */\n  formViews: {\n    web_to_case: {\n      type: 'simple',\n      data,\n      sections: [\n        {\n          name: 'how_can_we_help',\n          label: 'How can we help?',\n          columns: 1,\n          fields: [\n            {\n              field: 'subject',\n              required: true,\n              placeholder: 'Short summary of the issue',\n            },\n            {\n              field: 'description',\n              required: true,\n              placeholder: 'Steps to reproduce, error messages, screenshots...',\n            },\n            {\n              field: 'type',\n              helpText: 'Pick the option that best matches your issue.',\n            },\n            {\n              field: 'priority',\n              helpText: 'Critical issues should also be reported via phone.',\n            },\n          ],\n        },\n      ],\n      sharing: {\n        enabled: true,\n        allowAnonymous: true,\n        publicLink: '/forms/support',\n      },\n    },\n  },\n});\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/service/views/knowledge_article.view.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/service/views\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/service/views/knowledge_article.view.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport { defineView } from '@objectstack/spec/ui';\n\n/**\n * Knowledge Article Views\n *\n *   \u2022 grid      \u2014 agent-facing article queue (status / category / audience)\n *   \u2022 published \u2014 public articles only\n *   \u2022 my drafts \u2014 the author's own drafts and in-review articles\n *\n * A fourth tab, `stale_articles` ('Review Queue \u00B7 Oldest First'), shipped here\n * until #781 and is deliberately absent: the maintainer ruled the knowledge\n * review queue out of the product rather than settling whether it should have\n * become a real 180-day cut. \u26D4 Do not reinstate it as a ranking either \u2014 the\n * ruling removed the FEATURE, not just the window question.\n *\n * `last_reviewed_at` is untouched by that removal and stays a data-layer\n * field: the publish hook still stamps it, and the Engagement form section\n * below still shows it. Whether the field itself should retire is a separate\n * question and is not answered here.\n */\nexport const KnowledgeArticleViews = defineView({\n  list: {\n    type: 'grid',\n    name: 'all_articles',\n    label: 'All Articles',\n    userActions: { editInline: true },\n    data: { provider: 'object', object: 'crm_knowledge_article' },\n    columns: [\n      { field: 'article_number', width: 120, link: true, pinned: 'left', sortable: true },\n      { field: 'title',          width: 320, sortable: true },\n      { field: 'category',       width: 160 },\n      { field: 'status',         width: 130, sortable: true },\n      { field: 'audience',       width: 110 },\n      { field: 'language',       width: 110 },\n      { field: 'owner_id',          width: 150 },\n      { field: 'published_at',   width: 160, sortable: true },\n      { field: 'helpful_count',  width: 110, align: 'right', summary: 'sum' },\n    ],\n    sort: [{ field: 'published_at', order: 'desc' }],\n    grouping: { fields: [{ field: 'category', order: 'asc' }] },\n    selection: { type: 'multiple' },\n    pagination: { pageSize: 50 },\n    rowColor: {\n      field: 'status',\n      colors: { draft: 'slate', in_review: 'amber', published: 'emerald', archived: 'gray' },\n    },\n    appearance: {\n      showDescription: true,\n      allowedVisualizations: ['grid', 'kanban'],\n    },\n  },\n\n  listViews: {\n    published_articles: {\n      name: 'published_articles',\n      type: 'grid',\n      label: 'Published',\n      userActions: { editInline: true },\n      data: { provider: 'object', object: 'crm_knowledge_article' },\n      columns: ['article_number', 'title', 'category', 'audience', 'helpful_count', 'not_helpful_count', 'published_at'],\n      filter: [{ field: 'status', operator: 'equals', value: 'published' }],\n      sort: [{ field: 'helpful_count', order: 'desc' }],\n    },\n    my_drafts: {\n      name: 'my_drafts',\n      type: 'grid',\n      label: 'My Drafts',\n      userActions: { editInline: true },\n      data: { provider: 'object', object: 'crm_knowledge_article' },\n      columns: ['article_number', 'title', 'category', 'status', 'updated_at'],\n      filter: [\n        { field: 'status', operator: 'in',     value: ['draft', 'in_review'] },\n        // `{current_user_id}` is the only user token the view runtime resolves.\n        { field: 'owner_id',  operator: 'equals', value: '{current_user_id}' },\n      ],\n      sort: [{ field: 'updated_at', order: 'desc' }],\n    },\n  },\n\n  form: {\n    type: 'simple',\n    sections: [\n      {\n        name: 'article',\n        label: 'Article',\n        columns: 2,\n        fields: [\n          'article_number',\n          { field: 'title', required: true, span: 'full' },\n          { field: 'summary', span: 'full' },\n          'category',\n          'tags',\n          'status',\n          'audience',\n          'language',\n          'owner_id',\n        ],\n      },\n      {\n        name: 'content',\n        label: 'Content',\n        columns: 1,\n        fields: ['body'],\n      },\n      {\n        // `name` alongside `label` (#1100): a form section declaring only a\n        // label renders its ENGLISH label under every locale, and neither the\n        // existing i18n tests nor the `i18n/missing-*` gate can see it \u2014 the\n        // heading has no key for a translator to miss. This section is named\n        // because this change edits it (`view_count` was removed from it, #601);\n        // the app-wide sweep of the other headings is #1100's job, held behind\n        // this card precisely so the two do not collide in the locale packs.\n        name: 'engagement',\n        label: 'Engagement',\n        columns: 3,\n        fields: ['helpful_count', 'not_helpful_count', 'published_at', 'last_reviewed_at', 'related_to_case'],\n      },\n    ],\n  },\n});\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/revenue/objects/index.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/revenue/objects\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/revenue/objects/index.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\n/**\n * Revenue object barrel.\n *\n * Re-exports this package's *.object.ts definitions; the `*.hook.ts` files\n * beside them register through `./hooks.ts`. The canonical note on the\n * collaboration capabilities (`enable.files`, `enable.feeds`) that every\n * object in this app points at is written once, in\n * `src/sales/objects/index.ts`.\n */\n\nexport { Contract } from './contract.object';\nexport { OpportunityLineItem } from './opportunity_line_item.object';\nexport { Product } from './product.object';\nexport { Quote } from './quote.object';\nexport { QuoteLineItem } from './quote_line_item.object';\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/revenue/objects/contract.object.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/revenue/objects\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/revenue/objects/contract.object.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport { ObjectSchema, Field } from '@objectstack/spec/data';\nimport { P } from '@objectstack/spec';\nimport { PAYMENT_TERMS_OPTIONS } from '../../sales/objects/_picklists';\n\n/**\n * Contract Object\n * Represents legal contracts with customers\n */\nexport const Contract = ObjectSchema.create({\n  name: 'crm_contract',\n  label: 'Contract',\n  pluralLabel: 'Contracts',\n  icon: 'file-pen-line',\n  description: 'Legal contracts and agreements',\n\n  // ADR-0090 D1/D7: OWD is an authored decision. Master-detail child of\n  // crm_account \u2014 a contract IS account data: reachable by whoever can reach\n  // the account, editable by whoever can edit it (#549, ruling 2026-08-31).\n  sharingModel: 'controlled_by_parent',\n  // ADR-0079: render-only `titleFormat` retired in favor of `nameField`.\n  // Original template was '{contract_number} - {crm_account.name}'. The\n  // `crm_account.name` segment is a lookup DOT-WALK, which a formula field\n  // cannot reference (ADR-0072), so it is DROPPED. Only the local\n  // `contract_number` (autonumber) remains, so no formula is needed \u2014 point\n  // `nameField` straight at it.\n  nameField: 'contract_number',\n  highlightFields: ['contract_number', 'crm_account', 'status', 'start_date', 'end_date'],\n\n  fieldGroups: [\n    { key: 'basic',     label: 'Contract Information', icon: 'info' },\n    { key: 'parties',   label: 'Parties',              icon: 'users' },\n    { key: 'terms',     label: 'Terms & Dates',        icon: 'calendar' },\n    { key: 'value',     label: 'Contract Value',       icon: 'dollar-sign' },\n    { key: 'status',    label: 'Status & Approval',    icon: 'check-circle' },\n    { key: 'renewal',   label: 'Renewal',              icon: 'refresh-ccw', collapse: 'collapsed' },\n  ],\n\n  fields: {\n    // Platform ownership anchor \u2014 canonical note in `account.object.ts` (#548).\n    owner_id: Field.lookup('sys_user', {\n      label: 'Contract Owner',\n      group: 'parties',\n      system: true,\n      readonly: false,\n      trackHistory: true,\n    }),\n\n    // AutoNumber field\n    contract_number: Field.autonumber({\n      label: 'Contract Number',\n      group: 'basic',\n      format: 'CTR-{0000}',\n    }),\n    \n    // Relationships \u2014 the master the OWD derives from. Authored as\n    // master-detail so the master is not decided by declaration order against\n    // the required `crm_contact` lookup below (objectstack#14747).\n    crm_account: Field.masterDetail('crm_account', {\n      label: 'Account',\n      group: 'parties',\n      required: true,\n      storage: { notNull: true },\n      deleteBehavior: 'cascade',\n    }),\n    \n    crm_contact: Field.lookup('crm_contact', {\n      label: 'Primary Contact',\n      group: 'parties',\n      required: true,\n      storage: { notNull: true },\n      // @objectstack 12: string[] `referenceFilters` is dead (not read by the\n      // picker); `dependsOn` is the live cascading-lookup form \u2014 scopes contacts\n      // to the contract's `crm_account` (ADR-0049).\n      dependsOn: ['crm_account'],\n    }),\n\n    crm_opportunity: Field.lookup('crm_opportunity', {\n      label: 'Related Opportunity',\n      group: 'parties',\n      // Scope opportunities to the contract's account (was dead referenceFilters).\n      dependsOn: ['crm_account'],\n    }),\n    \n\n    // Status\n    status: Field.select({\n      label: 'Status',\n      group: 'status',\n      options: [\n        { label: 'Draft', value: 'draft', color: '#999999', default: true },\n        { label: 'In Approval', value: 'in_approval', color: '#FFA500' },\n        { label: 'Activated', value: 'activated', color: '#00AA00' },\n        { label: 'Expired', value: 'expired', color: '#FF0000' },\n        { label: 'Terminated', value: 'terminated', color: '#666666' },\n      ],\n      required: true,\n      storage: { notNull: true },\n      trackHistory: true,\n    }),\n    \n    // Contract Terms\n    contract_term_months: Field.number({\n      label: 'Contract Term (Months)',\n      group: 'terms',\n      required: true,\n      storage: { notNull: true },\n      min: 1,\n    }),\n    \n    start_date: Field.date({\n      label: 'Start Date',\n      group: 'terms',\n      required: true,\n      storage: { notNull: true },\n    }),\n    \n    end_date: Field.date({\n      label: 'End Date',\n      group: 'terms',\n      required: true,\n      storage: { notNull: true },\n    }),\n    \n    // Financial\n    contract_value: Field.currency({ \n      label: 'Contract Value',\n      group: 'value',\n      min: 0,\n      required: true,\n      storage: { notNull: true },\n    }),\n    \n    billing_frequency: Field.select({\n      label: 'Billing Frequency',\n      group: 'value',\n      options: [\n        { label: 'Monthly', value: 'monthly', default: true },\n        { label: 'Quarterly', value: 'quarterly' },\n        { label: 'Annually', value: 'annually' },\n        { label: 'One-time', value: 'one_time' },\n      ]\n    }),\n    \n    payment_terms: Field.select({\n      label: 'Payment Terms',\n      group: 'value',\n      // Canonical set shared with Quote: an accepted quote's terms (incl.\n      // due_on_receipt) must survive the copy onto the contract. That copy is\n      // `quote_accepted_contract_draft` (src/revenue/objects/quote.hook.ts). This field's `net_30`\n      // option default applies only when the quote itself carried no term,\n      // which is the intended fall-through, not a gap.\n      options: [...PAYMENT_TERMS_OPTIONS],\n    }),\n    \n    // Renewal\n    auto_renewal: Field.boolean({\n      label: 'Auto Renewal',\n      group: 'renewal',\n      defaultValue: false,\n    }),\n    \n    renewal_notice_days: Field.number({\n      label: 'Renewal Notice (Days)',\n      group: 'renewal',\n      min: 0,\n      defaultValue: 30,\n    }),\n    \n    // Legal\n    contract_type: Field.select({\n      label: 'Contract Type',\n      group: 'basic',\n      options: [\n        { label: 'Subscription', value: 'subscription' },\n        { label: 'Service Agreement', value: 'service' },\n        { label: 'License', value: 'license' },\n        { label: 'Partnership', value: 'partnership' },\n        { label: 'NDA', value: 'nda' },\n        { label: 'MSA', value: 'msa' },\n      ]\n    }),\n    \n    signed_date: Field.date({\n      label: 'Signed Date',\n      group: 'status',\n    }),\n    \n    signed_by: Field.text({\n      label: 'Signed By',\n      group: 'status',\n      maxLength: 255,\n    }),\n    \n    document_url: Field.url({\n      label: 'Contract Document',\n      group: 'basic',\n    }),\n    \n    // Terms & Conditions\n    special_terms: Field.markdown({\n      label: 'Special Terms',\n      group: 'terms',\n    }),\n    \n    description: Field.markdown({\n      label: 'Description',\n      group: 'basic',\n    }),\n    \n    // Billing Address\n    billing_address: Field.address({\n      label: 'Billing Address',\n      group: 'value',\n    }),\n  },\n  \n  // Database indexes\n  indexes: [\n    { fields: ['crm_account'] },\n    { fields: ['status'] },\n    { fields: ['start_date'] },\n    { fields: ['end_date'] },\n    { fields: ['owner_id'] },\n  ],\n  \n  // Enable advanced features\n  // API surface. History \u2192 Field.trackHistory (ADR-0052).\n  enable: {\n    apiEnabled: true,\n    apiMethods: ['get', 'list', 'create', 'update', 'delete'],\n    // #602 \u2014 the executed contract itself. `document_url` remains the pointer\n    // to an external DMS copy; this is where the file actually lives.\n    // See the canonical capability note in `src/sales/objects/index.ts`.\n    files: true,\n  },\n  \n  // Validation Rules\n  //\n  // Predicates below are TOTAL: every `record.x` read is `has()`-guarded, so the\n  // rule returns a verdict even when the merged record has no such key. See\n  // AGENTS.md \"Validation predicates must be TOTAL\" and\n  // test/object-validation-predicates.test.ts, which fails the build otherwise.\n  validations: [\n    {\n      name: 'end_after_start',\n      type: 'script',\n      severity: 'error',\n      message: 'End Date must be after Start Date',\n      condition: P`has(record.end_date) && record.end_date != null && has(record.start_date) && record.start_date != null && record.end_date <= record.start_date`,\n    },\n    // NOTE: the `valid_contract_term` warning (months-between term check) was\n    // dropped in the 9.8.0 upgrade \u2014 its CEL predicate used `monthsBetween()`,\n    // which 9.8.0's aligned CEL stdlib (ADR-0032) no longer provides. It was a\n    // non-blocking warning; the hard end-date>start-date rule above remains.\n    {\n      // #575 B4. Like `crm_quote`, this object shipped a lifecycle vocabulary\n      // with no transition constraint and no status guard in `contract.hook.ts`\n      // \u2014 so `draft \u2192 activated` was a legal move, activating an agreement that\n      // never passed approval. Activation is the consequential edge here:\n      // `contract_on_activation` stamps `signed_date`, promotes the account to\n      // `customer`, and the renewal flow starts counting from it.\n      name: 'contract_status_progression',\n      type: 'state_machine',\n      severity: 'warning',\n      message: 'Invalid contract status transition',\n      field: 'status',\n      transitions: {\n        draft: ['in_approval', 'terminated'],\n        // Approval either lands (`activated`) or sends the paperwork back.\n        in_approval: ['draft', 'activated', 'terminated'],\n        // `\u2192 expired` is the contract_expiration flow, whose own sweep filter\n        // is `status: 'activated'` \u2014 nothing else ages out.\n        activated: ['expired', 'terminated'],\n        // Both ends are terminal: a renewal is a NEW contract (the\n        // contract_renewal flow files a task, it does not revive the old row).\n        expired: [],\n        terminated: [],\n      },\n    },\n  ],\n  \n  // Workflow Rules\n  // \u26A0\uFE0F No `workflows[]` here, and none is possible: object `workflows[]` were\n  // removed from the platform. Field updates live in this object's `*.hook.ts`;\n  // scheduled status flips and notifications live in `src/*/flows/*.flow.ts`.\n});\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/revenue/objects/opportunity_line_item.object.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/revenue/objects\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/revenue/objects/opportunity_line_item.object.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport { ObjectSchema, Field } from '@objectstack/spec/data';\nimport { F, P } from '@objectstack/spec';\n\n/**\n * Opportunity Line Item\n *\n * Individual product/service entry on an Opportunity. Together, all line items\n * roll up to the Opportunity amount. Required for any realistic sales process\n * where the deal value comes from a configured set of products rather than\n * a single typed-in total.\n */\nexport const OpportunityLineItem = ObjectSchema.create({\n  name: 'crm_opportunity_line_item',\n  label: 'Opportunity Line Item',\n  pluralLabel: 'Opportunity Line Items',\n  icon: 'package',\n  description: 'A single product line on an Opportunity',\n\n  // ADR-0090 D1/D7: OWD is an authored decision. A line item has no meaning\n  // apart from its deal, so its record access DERIVES from the opportunity\n  // (ADR-0055), and as of 17.0.0-rc.4 that derivation means what it says.\n  //\n  // \u26A0\uFE0F Reads ARE filtered to line items whose `crm_opportunity` the caller can\n  // read, and master accessibility resolves through the same paths a direct\n  // read of the opportunity takes \u2014 ownership and `sys_record_share` grants\n  // included, NOT the master's row-level security policies alone. So a rep\n  // reads the lines of the deals in their own book plus anything shared to\n  // them, and the private-deal RLS filter carried by the `sales_manager` and\n  // `marketing_user` sets narrows on top of that rather than being the only\n  // thing that narrows. The parent-write gate derives the same way: a line\n  // whose opportunity the caller cannot edit is refused.\n  //\n  // `test/parent-derived-reach.test.ts` pins the narrow semantics and was\n  // written to go red the day the platform widens them: with the master set\n  // resolved from RLS policies alone, any caller without the private-deal\n  // policy \u2014 `sales_rep` included \u2014 reaches EVERY opportunity's lines.\n  // ADR-0055's relation resolver accepts a REQUIRED LOOKUP as the parent, so\n  // this works without converting the relationship to master-detail.\n  //\n  // \u26D4 Not `private`: this object has no owner of its own, so `private` falls\n  // back to the platform's auto-stamped `owner_id` (whoever inserted the row) \u2014\n  // and the rep who owns the deal then cannot see a line the quote-generation\n  // flow or their manager added to it.\n  sharingModel: 'controlled_by_parent',\n\n  // Per-field history is opt-in via `Field.trackHistory` (ADR-0052), set on\n  // quantity/unit_price/discount below. Master-detail children still inherit\n  // the master's sharing automatically.\n\n  highlightFields: ['crm_product', 'quantity', 'unit_price', 'total_price'],\n\n  // Two groups, derived from the nine fields this object actually declares\n  // rather than copied off a neighbour (#1453). The split is the one the\n  // arithmetic already makes: everything `total_price` multiplies together is\n  // `pricing`, everything that says WHICH line this is is `basic`.\n  //\n  // `quantity` is a pricing field here, not an identity one \u2014 it is a factor in\n  // `total_price`, and separating it from the price it multiplies would put the\n  // two halves of one product on two sections. `crm_quote_line_item` takes the\n  // same split over its ten fields, and the parents agree: `crm_quote` and\n  // `crm_product` both keep every money field in `pricing` \u2014 `crm_quote`'s\n  // `tax` included \u2014 and both keep `description` in `basic`.\n  //\n  // \u26A0\uFE0F Neither group may be a subset of the highlight strip: a synthesized\n  // detail page hoists the title plus the first four `highlightFields` out of\n  // the body, so an all-hoisted group renders on forms and nowhere else\n  // (`field-group-shadowed`; `pnpm lint` \u2014 `os lint --strict` \u2014 fails on it).\n  // `basic` keeps crm_opportunity/description/line_number and `pricing` keeps\n  // list_price/discount outside that strip, so both survive the hoist.\n  fieldGroups: [\n    { key: 'basic',   label: 'Line Item', icon: 'package' },\n    { key: 'pricing', label: 'Pricing',   icon: 'dollar-sign' },\n  ],\n\n  fields: {\n    // The parent link, and the ONE field on this object that decides whether the\n    // deal it belongs to can be deleted at all (#727).\n    //\n    // Declaring nothing here does not mean \"no opinion\": `Field.lookup` resolves\n    // `deleteBehavior` to the spec default `set_null`, and the engine's\n    // `cascadeDeleteRelations` escalates a `set_null` default on a REQUIRED\n    // lookup to `restrict` \u2014 a NOT NULL column cannot be cleared. So the silent\n    // default made every itemised opportunity undeletable, with a message that\n    // told the API caller to `set deleteBehavior:'cascade'` on this very field:\n    //\n    //     DELETE /api/v1/data/crm_opportunity/<id>\n    //     \u2192 409 DELETE_RESTRICTED \"\u20261 dependent crm_opportunity_line_item\n    //       record(s) reference it via crm_opportunity\u2026\"\n    //\n    // `cascade` is the semantics this object already claims twice over: the\n    // header comment says a line has no meaning apart from its deal, and\n    // `opportunity_line_item.hook.ts` derives `crm_opportunity.amount` FROM the\n    // line set. A record whose parent is gone denotes nothing and would keep a\n    // dead deal's revenue in the line-level reports.\n    //\n    // This is deliberately NOT the campaign/event answer (#696, #711 kept\n    // `crm_campaign_member.crm_campaign` and `crm_event_attendee.crm_event` on\n    // the restricting default): a member list is a campaign's historical record\n    // and survives on its own terms. A price line does not.\n    crm_opportunity: Field.masterDetail('crm_opportunity', {\n      label: 'Opportunity',\n      group: 'basic',\n      required: true,\n      storage: { notNull: true },\n      deleteBehavior: 'cascade',\n    }),\n\n    // Deliberately left on the default, which the same escalation turns into\n    // `restrict`: deleting a catalog product must NOT shred the priced history\n    // of deals that sold it. `product.hook.ts`'s own `beforeDelete` says the\n    // same thing in words (\"Set is_active=false to retire instead\").\n    crm_product: Field.lookup('crm_product', {\n      label: 'Product',\n      group: 'basic',\n      required: true,\n      storage: { notNull: true },\n    }),\n\n    description: Field.text({\n      label: 'Description',\n      group: 'basic',\n      maxLength: 500,\n    }),\n\n    quantity: Field.number({\n      label: 'Quantity',\n      group: 'pricing',\n      required: true,\n      storage: { notNull: true },\n      scale: 2,\n      min: 0,\n      defaultValue: 1,\n      trackHistory: true,\n    }),\n\n    list_price: Field.currency({\n      label: 'List Price',\n      group: 'pricing',\n      readonly: true,\n      description: \"Auto-populated from the product's List Price.\",\n    }),\n\n    unit_price: Field.currency({\n      label: 'Sales Price',\n      group: 'pricing',\n      required: true,\n      storage: { notNull: true },\n      description: 'Negotiated unit price (may differ from list price)',\n      trackHistory: true,\n    }),\n\n    discount: Field.percent({\n      label: 'Discount %',\n      group: 'pricing',\n      scale: 2,\n      min: 0,\n      max: 100,\n      defaultValue: 0,\n      trackHistory: true,\n    }),\n\n    total_price: Field.formula({\n      label: 'Total',\n      group: 'pricing',\n      expression: F`record.quantity * record.unit_price * (1 - record.discount / 100)`,\n    }),\n\n    line_number: Field.number({\n      label: 'Line #',\n      group: 'basic',\n      scale: 0,\n      readonly: true,\n    }),\n  },\n\n  // Predicates below are TOTAL: every `record.x` read is `has()`-guarded, so the\n  // rule returns a verdict even when the merged record has no such key. See\n  // AGENTS.md \"Validation predicates must be TOTAL\" and\n  // test/object-validation-predicates.test.ts, which fails the build otherwise.\n  validations: [\n    {\n      name: 'unit_price_positive',\n      type: 'script',\n      severity: 'error',\n      message: 'Sales price cannot be negative',\n      // Both guards are load-bearing, not defensive noise. `has(...)` answers\n      // \"is the key present at all\": on update the predicate sees\n      // `{...previous, ...data}`, and a driver that stores only written columns\n      // returns no key, which aborts the whole predicate and silently skips the\n      // rule (#630). `!= null` answers \"does it hold a value\": strict CEL\n      // ABORTS on `null < 0` instead of evaluating it false, so the unguarded\n      // form left this rule inert on a blank price \u2014 it never fired at all,\n      // which is the opposite of what a validation is for. The `null` hazard is\n      // written up at `account.object.ts:244-245`; the same-named rule in\n      // `quote_line_item.object.ts` has carried that guard all along.\n      condition: P`has(record.unit_price) && record.unit_price != null && record.unit_price < 0`,\n    },\n  ],\n});\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/revenue/objects/product.object.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/revenue/objects\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/revenue/objects/product.object.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport { ObjectSchema, Field } from '@objectstack/spec/data';\nimport { F, P } from '@objectstack/spec';\n\n/**\n * Product Object\n * Represents products/services offered by the company\n */\nexport const Product = ObjectSchema.create({\n  name: 'crm_product',\n  label: 'Product',\n  pluralLabel: 'Products',\n  icon: 'box',\n  description: 'Products and services offered by the company',\n\n  // ADR-0090 D1/D7: OWD is an authored decision. Product catalog is org-visible; only owners edit.\n  sharingModel: 'public_read',\n  // ADR-0079: render-only `titleFormat` retired in favor of `nameField`,\n  // which names a real field. The former template composed two local fields, so\n  // a `display_title` formula field reproduces it for the record title.\n  nameField: 'display_title',\n  // Explicit search targets (ADR-0061). REQUIRED because nameField is a\n  // FORMULA (display_title/full_name): without this, $search auto-defaults to\n  // the formula field, which isn't a real column, so the lookup picker + global\n  // search silently return zero. These are real, indexed columns.\n  searchableFields: ['name', 'product_code', 'sku'],\n  highlightFields: ['product_code', 'name', 'category', 'is_active'],\n\n  fieldGroups: [\n    { key: 'basic',    label: 'Product Information', icon: 'info' },\n    { key: 'pricing',  label: 'Pricing',             icon: 'dollar-sign' },\n    { key: 'metadata', label: 'Resources',           icon: 'link', collapse: 'collapsed' },\n  ],\n\n  fields: {\n    // AutoNumber field - Unique product identifier\n    product_code: Field.autonumber({\n      label: 'Product Code',\n      group: 'basic',\n      format: 'PRD-{0000}',\n    }),\n    \n    // Basic Information\n    name: Field.text({\n      label: 'Product Name',\n      group: 'basic',\n      required: true,\n      storage: { notNull: true },\n      searchable: true,\n      maxLength: 255,\n    }),\n\n    // ADR-0079 record title (was titleFormat '{product_code} - {name}').\n    display_title: Field.formula({\n      label: 'Display Title',\n      group: 'basic',\n      expression: F`record.product_code + \" - \" + record.name`,\n    }),\n\n    description: Field.markdown({\n      label: 'Description',\n      group: 'basic',\n    }),\n\n    // Categorization\n    category: Field.select({\n      label: 'Category',\n      group: 'basic',\n      options: [\n        { label: 'Software', value: 'software', default: true },\n        { label: 'Hardware', value: 'hardware' },\n        { label: 'Service', value: 'service' },\n        { label: 'Subscription', value: 'subscription' },\n        { label: 'Support', value: 'support' },\n      ]\n    }),\n    \n    family: Field.select({\n      label: 'Product Family',\n      group: 'basic',\n      options: [\n        { label: 'Enterprise Solutions', value: 'enterprise' },\n        { label: 'SMB Solutions', value: 'smb' },\n        { label: 'Professional Services', value: 'services' },\n        { label: 'Cloud Services', value: 'cloud' },\n      ]\n    }),\n    \n    // Pricing\n    list_price: Field.currency({ \n      label: 'List Price',\n      group: 'pricing',\n      min: 0,\n      required: true,\n      storage: { notNull: true },\n    }),\n    \n    cost: Field.currency({ \n      label: 'Cost',\n      group: 'pricing',\n      min: 0,\n    }),\n    \n    // SKU\n    //\n    // `quantity_on_hand` / `reorder_point` were removed with the rest of the\n    // inventory surface: nothing in this app decremented stock, and the \"Low\n    // Stock\" view they fed compared against a hardcoded 10 rather than the\n    // reorder point beside it. HotCRM sells from a catalog; warehouse state\n    // belongs to the system of record that owns it.\n    sku: Field.text({\n      label: 'SKU',\n      group: 'basic',\n      maxLength: 50,\n      unique: true,\n    }),\n    \n    // Status\n    is_active: Field.boolean({\n      label: 'Active',\n      group: 'basic',\n      defaultValue: true,\n      trackHistory: true,\n    }),\n    \n    // Relationships\n    product_manager: Field.lookup('sys_user', {\n      label: 'Product Manager',\n      group: 'basic',\n    }),\n    \n    // Images and Assets\n    // `accept` / `maxSize` are declarable AND server-enforced from\n    // @objectstack 17 (ADR-0104 D3 wave 2). Before that the upload widget read\n    // them but `FieldSchema` dropped them at parse, so the constraint existed\n    // only in the browser and any direct API caller walked past it.\n    image: Field.image({\n      label: 'Product Image',\n      group: 'metadata',\n      accept: ['image/png', 'image/jpeg', 'image/webp'],\n      maxSize: 5 * 1024 * 1024,\n    }),\n\n    datasheet: Field.file({\n      label: 'Datasheet',\n      group: 'metadata',\n      accept: ['application/pdf'],\n      maxSize: 20 * 1024 * 1024,\n    }),\n\n    // `billing_type` and `unit_of_measure` were removed with the tax flag: both\n    // were seeded on all 13 catalog products and read by nothing \u2014 no quote\n    // total, no revenue-recognition report and no line-item behaviour ever\n    // consulted either. A picklist that only ever renders itself is a\n    // maintenance obligation (four locales, an import column, every future\n    // migration) charged against a capability that does not exist.\n  },\n  \n  // Database indexes\n  //\n  // No `{ fields: ['sku'], unique: true }` here: the field-level `unique: true`\n  // already builds the tenant composite `(organization_id, sku)` since\n  // framework #3696. Declaring the single-column index too made the\n  // platform-wide constraint win and left the per-tenant one unreachable\n  // (framework#3991) \u2014 an SKU is unique inside a catalogue, and two\n  // organizations may legitimately both stock \"ABC-123\".\n  indexes: [\n    { fields: ['name'] },\n    { fields: ['category'] },\n    { fields: ['is_active'] },\n  ],\n  \n  // Enable advanced features\n  // API surface. History \u2192 Field.trackHistory (ADR-0052).\n  enable: {\n    apiEnabled: true,\n    apiMethods: ['get', 'list', 'create', 'update', 'delete'],\n  },\n  \n  // Validation Rules\n  //\n  // Predicates below are TOTAL: every `record.x` read is `has()`-guarded, so the\n  // rule returns a verdict even when the merged record has no such key. See\n  // AGENTS.md \"Validation predicates must be TOTAL\" and\n  // test/object-validation-predicates.test.ts, which fails the build otherwise.\n  validations: [\n    {\n      name: 'price_positive',\n      type: 'script',\n      severity: 'error',\n      message: 'List Price must be positive',\n      // Two distinct guards, both required. `has(...)` answers \"is the key\n      // there at all\" \u2014 on update the merged record is `{...previous, ...data}`\n      // and a driver that stores only written columns hands back no key, which\n      // aborts the whole predicate (#630). `!= null` then answers \"does it hold\n      // a value\" \u2014 strict CEL cannot compare dyn<null> < int, the hazard\n      // written up on `account.object.ts`. `list_price` is `required`, but the\n      // rule also runs on partial updates that omit it.\n      condition: P`has(record.list_price) && record.list_price != null && record.list_price < 0`,\n    },\n    {\n      name: 'cost_less_than_price',\n      type: 'script',\n      severity: 'warning',\n      message: 'Cost should be less than List Price',\n      // Both operands need both guards: `cost` is optional and absent on every\n      // seeded product, so this warning has never once evaluated.\n      condition: P`has(record.cost) && record.cost != null && has(record.list_price) && record.list_price != null && record.cost >= record.list_price`,\n    },\n  ],\n});\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/revenue/objects/quote.object.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/revenue/objects\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/revenue/objects/quote.object.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport { ObjectSchema, Field } from '@objectstack/spec/data';\nimport { F, P, cel } from '@objectstack/spec';\nimport { PAYMENT_TERMS_OPTIONS } from '../../sales/objects/_picklists';\nimport { QUOTE_DISCOUNT_CEILING } from '../../sales/objects/_thresholds';\n\n/**\n * Quote Object\n * Represents price quotes sent to customers\n */\nexport const Quote = ObjectSchema.create({\n  name: 'crm_quote',\n  label: 'Quote',\n  pluralLabel: 'Quotes',\n  icon: 'file-text',\n  description: 'Price quotes for customers',\n\n  // ADR-0090 D1/D7: OWD is an authored decision. Master-detail child of\n  // crm_account \u2014 a quote is reachable by whoever can reach its account, and\n  // its line items derive one level further (#549, ruling 2026-08-31).\n  sharingModel: 'controlled_by_parent',\n  // ADR-0079: render-only `titleFormat` retired in favor of `nameField`,\n  // which names a real field. The former template composed two local fields, so\n  // a `display_title` formula field reproduces it for the record title.\n  nameField: 'display_title',\n  // Explicit search targets (ADR-0061). REQUIRED because nameField is a\n  // FORMULA (display_title/full_name): without this, $search auto-defaults to\n  // the formula field, which isn't a real column, so the lookup picker + global\n  // search silently return zero. These are real, indexed columns.\n  searchableFields: ['name', 'quote_number'],\n  highlightFields: ['quote_number', 'name', 'crm_account', 'status', 'total_price'],\n\n  fieldGroups: [\n    { key: 'basic',     label: 'Quote Information', icon: 'info' },\n    { key: 'pricing',   label: 'Pricing',           icon: 'dollar-sign' },\n    { key: 'terms',     label: 'Terms & Validity',  icon: 'calendar' },\n    { key: 'address',   label: 'Addresses',         icon: 'map-pin', collapse: 'collapsed' },\n    { key: 'system',    label: 'System',            icon: 'database', collapse: 'collapsed' },\n  ],\n\n  fields: {\n    // Platform ownership anchor \u2014 canonical note in `account.object.ts` (#548).\n    owner_id: Field.lookup('sys_user', {\n      label: 'Quote Owner',\n      group: 'basic',\n      system: true,\n      readonly: false,\n      trackHistory: true,\n    }),\n\n    // AutoNumber field\n    quote_number: Field.autonumber({\n      label: 'Quote Number',\n      group: 'basic',\n      format: 'QTE-{0000}',\n    }),\n    \n    // Basic Information\n    name: Field.text({\n      label: 'Quote Name',\n      group: 'basic',\n      required: true,\n      storage: { notNull: true },\n      searchable: true,\n      maxLength: 255,\n    }),\n\n    // ADR-0079 record title (was titleFormat '{quote_number} - {name}').\n    display_title: Field.formula({\n      label: 'Display Title',\n      group: 'basic',\n      expression: F`record.quote_number + \" - \" + record.name`,\n    }),\n\n    // Relationships \u2014 the master the OWD derives from (authored, not positional).\n    crm_account: Field.masterDetail('crm_account', {\n      label: 'Account',\n      group: 'basic',\n      required: true,\n      storage: { notNull: true },\n      deleteBehavior: 'cascade',\n    }),\n    \n    crm_contact: Field.lookup('crm_contact', {\n      label: 'Contact',\n      group: 'basic',\n      // Optional AT DRAFT TIME, required from `presented` on (#1017).\n      //\n      // quote_generation maps the opportunity's `primary_contact`, which is\n      // itself optional \u2014 a flat `required: true` here meant contact-less\n      // opportunities could never draft a quote at all. So the recipient is\n      // nailed down by the time a quote is PRESENTED, not when it is drafted.\n      // That sentence sat in this comment for the field's whole life with\n      // nothing enforcing it: no rule stopped a contact-less quote reaching\n      // `presented` or `accepted`, and the bill came due one object over.\n      // `crm_contract.crm_contact` is `required` + `notNull`, so accepting such\n      // a quote made `quote_on_accepted` fail to draft the contract \u2014 since\n      // #714/#1013 that failure is honest and no longer swallows the close-won\n      // leg, but the hook is `async` + `onError: 'log'`, so the accepting write\n      // still answers 200 and the only evidence is a server log nobody reads.\n      // `requiredWhen` moves the same refusal to the synchronous, someone-is-\n      // watching moment: the rep is told on the write that turns the quote\n      // outward, against the field, with the quote still editable.\n      //\n      // WHY EXACTLY `presented` + `accepted`, and not the other two terminal\n      // states. Both of those are reachable WITHOUT the quote ever being sent\n      // (see the `quote_status_progression` transitions below):\n      //   \u2022 `expired` \u2014 the `quote_expiration` flow sweeps on `expiration_date`\n      //     alone and expires never-sent drafts as readily as presented ones.\n      //     Requiring a recipient there would make a nightly system write fail\n      //     on exactly the quotes that have no recipient BECAUSE nobody sent\n      //     them, and the sweep's `runAs: 'system'` would not exempt it \u2014 the\n      //     gate applies on write, not on actor.\n      //   \u2022 `rejected` \u2014 legal straight from `in_review`, i.e. a quote killed\n      //     internally before anyone saw it. Demanding a contact to file that\n      //     verdict asks for a recipient the quote never had.\n      // Neither state passes anything on to a contract, so neither needs one.\n      //\n      // \u26A0\uFE0F `has(record.status)` is load-bearing, not decoration \u2014 the same trap\n      // documented at `lead.object.ts`'s duplicate lookups: a bare\n      // `record.status == \"presented\"` aborts with `No such key` on any merged\n      // record that simply omits the column, and the engine's answer to a\n      // predicate that fails to evaluate is to SKIP it (\"requiredWhen for\n      // 'crm_contact' failed to evaluate \u2014 skipped\"). The rule would then read\n      // as enforced and require nothing at all.\n      //\n      // @objectstack 12: string[] `referenceFilters` is dead (not read by the\n      // picker); `dependsOn` is the live cascading form \u2014 scopes contacts to the\n      // quote's `crm_account` (ADR-0049).\n      dependsOn: ['crm_account'],\n      requiredWhen: P`has(record.status) && (record.status == \"presented\" || record.status == \"accepted\")`,\n      description:\n        'Required once the quote is Presented or Accepted \u2014 the drafted contract takes its Primary Contact from here.',\n    }),\n\n    crm_opportunity: Field.lookup('crm_opportunity', {\n      label: 'Opportunity',\n      group: 'basic',\n      // Scope opportunities to the quote's account (was dead referenceFilters).\n      dependsOn: ['crm_account'],\n    }),\n\n\n    // Status\n    status: Field.select({\n      label: 'Status',\n      group: 'basic',\n      options: [\n        { label: 'Draft', value: 'draft', color: '#999999', default: true },\n        { label: 'In Review', value: 'in_review', color: '#FFA500' },\n        { label: 'Presented', value: 'presented', color: '#4169E1' },\n        { label: 'Accepted', value: 'accepted', color: '#00AA00' },\n        { label: 'Rejected', value: 'rejected', color: '#FF0000' },\n        { label: 'Expired', value: 'expired', color: '#666666' },\n      ],\n      required: true,\n      storage: { notNull: true },\n      trackHistory: true,\n    }),\n    \n    // Dates\n    quote_date: Field.date({\n      label: 'Quote Date',\n      group: 'terms',\n      required: true,\n      storage: { notNull: true },\n      defaultValue: cel`today()`,\n    }),\n    \n    expiration_date: Field.date({\n      label: 'Expiration Date',\n      group: 'terms',\n      required: true,\n      storage: { notNull: true },\n    }),\n    \n    // Pricing\n    // subtotal/discount_amount/total_price are NOT `readonly`, and the writer\n    // that decides it is the LINE-ITEM ROLLUP \u2014 not the flow this note used to\n    // name. `quote_total_rollup` (`quote_line_item.hook.ts`) recomputes all\n    // three on every line insert/update/delete through\n    // `api.object('crm_quote').update(...)`: a cross-record write via `ctx.api`,\n    // which is a `ScopedContext` over the ACTING USER's context. The keys are\n    // therefore CALLER-supplied to a non-`isSystem` UPDATE, exactly what\n    // `stripReadonlyFields` deletes \u2014 with `readonly` on, a quote's totals would\n    // freeze at whatever the flow first seeded and never track its lines again.\n    // \u26A0\uFE0F `quote_generation` writes them too, but at CREATE time, and the strip\n    // is an UPDATE-path rule \u2014 that write would survive `readonly` untouched.\n    // The retired 16.x claim rested on that create-time write, which is how this\n    // note reached a right conclusion from the wrong writer.\n    // Measured in `test/readonly-write-semantics.test.ts` (insert is exempt) and\n    // `test/activity-recency.test.ts` (the `ctx.api` strip, on the real engine).\n    subtotal: Field.currency({ \n      label: 'Subtotal',\n      group: 'pricing',\n    }),\n    \n    discount: Field.percent({\n      label: 'Discount %',\n      group: 'pricing',\n      scale: 2,\n      min: 0,\n      max: 100,\n    }),\n    \n    discount_amount: Field.currency({ \n      label: 'Discount Amount',\n      group: 'pricing',\n    }),\n    \n    tax: Field.currency({ \n      label: 'Tax',\n      group: 'pricing',\n    }),\n    \n    shipping_handling: Field.currency({ \n      label: 'Shipping & Handling',\n      group: 'pricing',\n    }),\n    \n    total_price: Field.currency({ \n      label: 'Total Price',\n      group: 'pricing',\n    }),\n    \n    // Terms\n    payment_terms: Field.select({\n      label: 'Payment Terms',\n      group: 'terms',\n      // Canonical set shared with Contract (#490) \u2014 see _picklists.ts.\n      options: [...PAYMENT_TERMS_OPTIONS],\n    }),\n    \n    shipping_terms: Field.text({\n      label: 'Shipping Terms',\n      group: 'terms',\n      maxLength: 255,\n    }),\n    \n    // Billing & Shipping Address\n    billing_address: Field.address({\n      label: 'Billing Address',\n      group: 'address',\n    }),\n\n    shipping_address: Field.address({\n      label: 'Shipping Address',\n      group: 'address',\n    }),\n    \n    // Notes\n    description: Field.markdown({\n      label: 'Description',\n      group: 'basic',\n    }),\n    \n    internal_notes: Field.textarea({\n      label: 'Internal Notes',\n      group: 'system',\n    }),\n  },\n  \n  // Database indexes\n  indexes: [\n    { fields: ['crm_account'] },\n    { fields: ['crm_opportunity'] },\n    { fields: ['owner_id'] },\n    { fields: ['status'] },\n    { fields: ['quote_date'] },\n  ],\n  \n  // Enable advanced features\n  // API surface. History \u2192 Field.trackHistory (ADR-0052).\n  enable: {\n    apiEnabled: true,\n    apiMethods: ['get', 'list', 'create', 'update', 'delete'],\n    // #602 \u2014 the generated quote PDF and the customer's countersigned copy.\n    // See the canonical capability note in `src/sales/objects/index.ts`.\n    files: true,\n  },\n  \n  // Validation Rules\n  //\n  // Predicates below are TOTAL: every `record.x` read is `has()`-guarded, so the\n  // rule returns a verdict even when the merged record has no such key. See\n  // AGENTS.md \"Validation predicates must be TOTAL\" and\n  // test/object-validation-predicates.test.ts, which fails the build otherwise.\n  validations: [\n    {\n      name: 'expiration_after_quote',\n      type: 'script',\n      severity: 'error',\n      message: 'Expiration Date must be after Quote Date',\n      condition: P`has(record.expiration_date) && record.expiration_date != null && has(record.quote_date) && record.quote_date != null && record.expiration_date <= record.quote_date`,\n    },\n    {\n      // #599. The only discount constraint this object ever had was the field's\n      // own `max: 100` \u2014 the arithmetic domain of a percentage \u2014 so a rep could\n      // put 90% off a $99K deal on a quote and nothing anywhere objected: the\n      // approval flow keys on the opportunity's AMOUNT, and $99K is under the\n      // large-deal line. This is the policy ceiling that constraint never was.\n      //\n      // \u26A0\uFE0F A predicate of `record.discount > 100` here would be DEAD: field-level\n      // bounds are evaluated BEFORE object validations, so `discount: 150` is\n      // already refused by `max: 100` with `code: 'max_value'` and the message\n      // \"Discount % must be \u2264 100\", and the rule's own message is unreachable on\n      // every input that could reach it.\n      //\n      // ### Why a script validation and not a lower `max` on the field\n      //\n      // This is an INVARIANT \u2014 \"a quote's discount may never exceed the\n      // ceiling\" \u2014 not a transition condition, and #1069 is open on exactly\n      // that distinction for `requiredWhen`. Both instruments were measured\n      // against a row stored above the ceiling before the rule existed\n      // (`test/quote-discount-ceiling.test.ts` runs the measurement):\n      //\n      //   Field.percent({ max: 60 })   legacy row, unrelated edit \u2192 ADMITTED\n      //   this rule                    legacy row, unrelated edit \u2192 REFUSED\n      //\n      // A field bound checks the value being WRITTEN; a script validation is\n      // evaluated against the MERGED record on every write. So `max` carries\n      // the same silent legacy hole #1069 describes, in a second instrument,\n      // and the rule does not. The cost of the invariant, stated rather than\n      // hidden: an over-ceiling row is frozen to everything except the repair \u2014\n      // bringing the discount back under the ceiling is admitted, and is an\n      // ordinary edit. HotCRM ships no such row (deepest seeded discount: 20%).\n      //\n      // `max: 100` stays on the field as the domain of a percentage. The policy\n      // number lives in `_thresholds.ts`, interpolated into both the predicate\n      // and the message so the two cannot disagree.\n      name: 'discount_within_ceiling',\n      type: 'script',\n      severity: 'error',\n      message: `Discount cannot exceed ${QUOTE_DISCOUNT_CEILING}%`,\n      condition: P`has(record.discount) && record.discount != null && record.discount > ${QUOTE_DISCOUNT_CEILING}`,\n    },\n    {\n      // #575 B4. `crm_quote` had a full lifecycle vocabulary and no transition\n      // constraint whatsoever \u2014 nor a status guard in `quote.hook.ts` \u2014 so a\n      // quote could go straight from `draft` to `accepted`, which in CPQ terms\n      // is a signed number nobody reviewed or sent. `warning` severity matches\n      // the lead / opportunity / case machines: it flags the jump on the record\n      // without blocking a support-driven correction.\n      name: 'quote_status_progression',\n      type: 'state_machine',\n      severity: 'warning',\n      message: 'Invalid quote status transition',\n      field: 'status',\n      transitions: {\n        // `\u2192 expired` is legal from every UNSETTLED state: the quote_expiration\n        // flow sweeps on `expiration_date` alone and expires drafts that were\n        // never sent as readily as presented ones.\n        draft: ['in_review', 'expired'],\n        in_review: ['draft', 'presented', 'rejected', 'expired'],\n        presented: ['accepted', 'rejected', 'expired'],\n        // `accepted` and `expired` are terminal, and not only by convention \u2014\n        // `quote_pricing_guard` in quote.hook.ts freezes both, allowing edits\n        // to `internal_notes` and nothing else.\n        accepted: [],\n        expired: [],\n        // A rejected quote is not frozen: the rep revises the numbers and\n        // re-issues, which starts again at `draft`.\n        rejected: ['draft'],\n      },\n    },\n  ],\n  \n  // Workflow Rules\n  // \u26A0\uFE0F No `workflows[]` here, and none is possible: object `workflows[]` were\n  // removed from the platform. Field updates live in this object's `*.hook.ts`;\n  // scheduled status flips and notifications live in `src/*/flows/*.flow.ts`.\n});\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/sales/objects/_thresholds.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/sales/objects\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/sales/objects/_thresholds.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\n/**\n * Commercial governance thresholds \u2014 the money lines this app draws, authored\n * ONCE.\n *\n * \"What counts as a large deal\" is one business question with four consumers:\n * the approval entry gate and the won-deal alert (`src/sales/flows/`), and the\n * sales-director and executive rules (`src/sales/sharing/opportunity.sharing.ts`).\n * Each interpolates the constant below, and each cuts at `>=`.\n *\n * \u26D4 Both halves are load-bearing, and neither may drift. Four independent\n * literals mean a deployment that raises the bar in one place ships a product\n * where a deal is large enough for the director to *see* and not large enough\n * to *approve* \u2014 governance narrower than visibility, which is the\n * counter-intuitive direction the next author will assume the reverse of.\n * Maintainer ruling: **a deal at the line is a large deal**, so every site cuts\n * at `>=` rather than `>`. `test/deal-threshold-parity.test.ts` reads the\n * compiled CEL of every flow condition and sharing rule back out of the shipped\n * metadata and fails if any site stops agreeing on the number OR the operator.\n *\n * If a reason ever appears for leadership to see a deal that needs no approval,\n * that reason belongs **here**, next to the constant, and the split becomes a\n * design instead of drift. Nothing in this repo makes that argument today.\n *\n * `HIGH_VALUE_DEAL_AMOUNT` below is deliberately NOT part of that guarantee:\n * its `>` and `<=` halves are one branch stated in complementary polarity,\n * which must PARTITION rather than agree. Two operators there are the design.\n */\n\n/**\n * A \"large deal\" \u2014 the amount at which an opportunity stops being routine.\n *\n * Consumed by the approval entry gate, the won-deal alert and both large-deal\n * sharing rules. `src/docs/crm_sales.md` and `src/docs/crm_admin.md` publish\n * this number to users, and `test/docs-drift.test.ts` fails if they drift from\n * what the flows actually ship.\n */\nexport const LARGE_DEAL_AMOUNT = 100_000;\n\n/**\n * The second approval tier \u2014 above this a Sales Director signs off as well as\n * the manager. Consumed by the `check_high_value` branch of\n * `opportunity-approval.flow.ts`, in both polarities.\n */\nexport const HIGH_VALUE_DEAL_AMOUNT = 500_000;\n\n/**\n * The hard ceiling on a discount percentage, in percent \u2014 on a quote, and on\n * each of its line items.\n *\n * ### One number, two rules, because a quote's total has two multipliers\n *\n * `crm_quote.discount_within_ceiling` and\n * `crm_quote_line_item.discount_within_ceiling` both interpolate this constant.\n * The second is not a copy for symmetry's sake: the quote-level percentage and\n * the per-line percentage are INDEPENDENT inputs to the same total\n * (`quote_total_rollup` discounts each line, sums, then applies the quote's\n * percentage to the sum), so a quote at `discount: 0` with every line at 90%\n * clears the quote-level rule outright and still prices 90% below list.\n * Ceiling one multiplier and the other is the way around it.\n *\n * \u26A0\uFE0F What this constant does NOT settle is what the ceiling means once the two\n * multipliers COMPOUND \u2014 60% per line and 60% on the quote is ~84% effective.\n * That is an open business-policy question, and neither rule pretends to answer\n * it.\n *\n * ### Why 60, and why only one number\n *\n * The ceiling is ABSOLUTE \u2014 there is no approval path to unblock a quote above\n * it. A blocking rule with no override has to sit where refusing is\n * unambiguously right, not where reviewing would be useful. 30% would refuse\n * aggressive-but-real commercial deals outright and leave the rep nothing to do\n * about it; 60% refuses \"a rep can give 90% off a $99K deal and nothing reviews\n * it\" while leaving genuine strategic pricing alone. The stock catalogue\n * agrees: the deepest discount HotCRM seeds anywhere is 20%\n * (`src/<pkg>/data/*.seed.ts`).\n *\n * \u26D4 There is deliberately no SOFT ceiling constant beside it. A soft tier has\n * exactly one possible consumer \u2014 discount-triggered approval routing \u2014 which\n * does not exist yet, and \u26A0\uFE0F a `severity: 'warning'` script validation is\n * admitted by this platform with *no observable surface at all*: no warning on\n * the result, nothing in the envelope. Declaring the number now would add a\n * sixth entry to the \"declared and then not applied\" table in\n * `test/win-loss-capture.test.ts`. The soft tier returns with the routing that\n * gives it a job.\n *\n * ### Why this is a validation rule and not `Field.percent({ max })`\n *\n * \u26A0\uFE0F Platform constraint, measured both ways on a legacy row already above the\n * ceiling (`test/quote-discount-ceiling.test.ts`): a field-level `max`\n * validates the WRITTEN VALUE only, so a row stored above the ceiling before\n * the rule existed keeps accepting edits forever \u2014 the same silent legacy hole\n * `requiredWhen` has. A `type: 'script'` validation is evaluated against the\n * MERGED record on every write, so it is a true invariant. Both fields keep\n * `max: 100` as the arithmetic domain of a percentage; the policy line lives in\n * the rules.\n */\nexport const QUOTE_DISCOUNT_CEILING = 60;\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/revenue/objects/quote_line_item.object.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/revenue/objects\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/revenue/objects/quote_line_item.object.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport { ObjectSchema, Field } from '@objectstack/spec/data';\nimport { F, P } from '@objectstack/spec';\nimport { QUOTE_DISCOUNT_CEILING } from '../../sales/objects/_thresholds';\n\n/**\n * Quote Line Item\n *\n * Individual line on a Quote. Quotes generated from an Opportunity typically\n * clone its OpportunityLineItems into QuoteLineItems so pricing can diverge\n * after the quote is sent without affecting the underlying opportunity.\n */\nexport const QuoteLineItem = ObjectSchema.create({\n  name: 'crm_quote_line_item',\n  label: 'Quote Line Item',\n  pluralLabel: 'Quote Line Items',\n  icon: 'package',\n  description: 'A single product line on a Quote',\n\n  // OWD is an authored decision (ADR-0090 D1/D7). Record access DERIVES from\n  // the quote (ADR-0055).\n  //\n  // \u26A0\uFE0F Reads ARE filtered to lines whose `crm_quote` the caller can read, and\n  // \"can read\" resolves through the same paths a direct read of the quote takes\n  // \u2014 owner scope and `sys_record_share` grants included, NOT the master's\n  // row-level security policies alone. A rep who owns one quote reads that\n  // quote's lines and no others. The parent-write gate derives the same way: a\n  // line whose quote the caller cannot edit is refused with a\n  // `PermissionDeniedError` naming the master.\n  //\n  // `test/parent-derived-reach.test.ts` pins those semantics with positive\n  // controls, so a regression is caught in either direction \u2014 it was written to\n  // go red the day the platform widens them: with the derivation consulting\n  // master RLS policies only, under a SYSTEM context, and no policy authored on\n  // `crm_quote`, the master set is EVERY quote and a line item is readable \u2014\n  // and writable \u2014 by every holder of object-level read on this object. The\n  // relation resolver accepts a REQUIRED LOOKUP as the parent, so no\n  // master-detail conversion is needed.\n  //\n  // \u26D4 Not `private`: with no owner field on this object that resolves to the\n  // platform's auto-stamped `owner_id` \u2014 the row's inserter \u2014 so lines cloned\n  // onto a quote by the `quote_generation` flow are invisible to the rep who\n  // owns the quote.\n  sharingModel: 'controlled_by_parent',\n\n  // Per-field history is opt-in via `Field.trackHistory` (ADR-0052), set on\n  // quantity/unit_price/discount below. Master-detail children still inherit\n  // the master's sharing automatically.\n\n  highlightFields: ['crm_product', 'quantity', 'unit_price', 'total_price'],\n\n  // The same two-group split as `crm_opportunity_line_item` (#1453), derived\n  // from the ten fields declared here: every factor `total_price` multiplies\n  // is `pricing`, everything that says WHICH line this is is `basic`.\n  //\n  // \u26A0\uFE0F Neither group may be a subset of the highlight strip \u2014 see the twin\n  // object for the hoisting rule this satisfies.\n  fieldGroups: [\n    { key: 'basic',   label: 'Line Item', icon: 'package' },\n    { key: 'pricing', label: 'Pricing',   icon: 'dollar-sign' },\n  ],\n\n  fields: {\n    // The parent link \u2014 same decision, same reasoning, as\n    // `opportunity_line_item.crm_opportunity` (#727); read the long note there.\n    // In short: declaring nothing resolves to the spec default `set_null`, which\n    // the engine escalates to `restrict` on a REQUIRED lookup, so every quote\n    // that had been itemised refused to delete with a 409 quoting this field.\n    // A quote line is subordinate to its quote (`quote_line_item.hook.ts` rolls\n    // the quote's subtotal/total UP from these rows), so it goes with it.\n    crm_quote: Field.masterDetail('crm_quote', {\n      label: 'Quote',\n      group: 'basic',\n      required: true,\n      storage: { notNull: true },\n      deleteBehavior: 'cascade',\n\n      // Curates the line-items panel on a quote's detail page (#1199) \u2014 the\n      // mechanism that panel reads first (#944; the long note is on\n      // `crm_campaign_member.crm_campaign`). A SUPERSET of the fallback it\n      // replaces (`highlightFields` minus this lookup: Product / Quantity /\n      // Sales Price / Total) plus `subtotal`, the line's price after its own\n      // discount \u2014 the formula was evaluated on every read and shown in no list.\n      //\n      // \u26D4 Not added to `highlightFields`: the detail page hoists the first\n      // four of that strip, so a fifth entry never reaches the strip, and\n      // reordering it would evict `total_price` from the record's header.\n      relatedListColumns: ['crm_product', 'quantity', 'unit_price', 'subtotal', 'total_price'],\n    }),\n\n    // Left on the restricting default on purpose \u2014 see the twin object: a\n    // product's catalog entry must not take priced quote history with it.\n    crm_product: Field.lookup('crm_product', {\n      label: 'Product',\n      group: 'basic',\n      required: true,\n      storage: { notNull: true },\n    }),\n\n    description: Field.text({\n      label: 'Description',\n      group: 'basic',\n      maxLength: 500,\n    }),\n\n    quantity: Field.number({\n      label: 'Quantity',\n      group: 'pricing',\n      required: true,\n      storage: { notNull: true },\n      scale: 2,\n      min: 0,\n      defaultValue: 1,\n      trackHistory: true,\n    }),\n\n    list_price: Field.currency({\n      label: 'List Price',\n      group: 'pricing',\n      readonly: true,\n    }),\n\n    unit_price: Field.currency({\n      label: 'Sales Price',\n      group: 'pricing',\n      required: true,\n      storage: { notNull: true },\n      trackHistory: true,\n    }),\n\n    discount: Field.percent({\n      label: 'Discount %',\n      group: 'pricing',\n      scale: 2,\n      min: 0,\n      max: 100,\n      defaultValue: 0,\n      trackHistory: true,\n    }),\n\n    subtotal: Field.formula({\n      label: 'Subtotal',\n      group: 'pricing',\n      expression: F`record.quantity * record.unit_price * (1 - record.discount / 100)`,\n    }),\n\n    // A line carries no tax: tax is the quote's own amount (#2069), so Total is\n    // `subtotal`'s expression, not a read of `subtotal` \u2014 a formula reading a\n    // formula depends on hydration order (`lead.object.ts:61-64`).\n    total_price: Field.formula({\n      label: 'Total',\n      group: 'pricing',\n      expression: F`record.quantity * record.unit_price * (1 - record.discount / 100)`,\n    }),\n\n    line_number: Field.number({\n      label: 'Line #',\n      group: 'basic',\n      scale: 0,\n      readonly: true,\n    }),\n  },\n\n  // Predicates below are TOTAL: every `record.x` read is `has()`-guarded, so the\n  // rule returns a verdict even when the merged record has no such key. See\n  // AGENTS.md \"Validation predicates must be TOTAL\" and\n  // test/object-validation-predicates.test.ts, which fails the build otherwise.\n  validations: [\n    {\n      name: 'unit_price_positive',\n      type: 'script',\n      severity: 'error',\n      message: 'Sales price cannot be negative',\n      condition: P`has(record.unit_price) && record.unit_price != null && record.unit_price < 0`,\n    },\n    {\n      // #1086. The other half of #599's ceiling, and the reason that card's own\n      // acceptance criterion \u2014 \"a quote with a 90% line discount cannot reach\n      // `presented`\" \u2014 was not met by the quote-level rule alone.\n      //\n      // ### The walk-around this closes\n      //\n      // A quote's total has TWO independent discount multipliers, and\n      // `quote_total_rollup` composes them:\n      //\n      //   subtotal        = \u03A3 line (quantity \u00D7 unit_price \u00D7 (1 \u2212 LINE discount/100))\n      //   discount_amount = subtotal \u00D7 QUOTE discount%\n      //\n      // #599 put a ceiling on the second one only. So a quote at\n      // `discount: 0` \u2014 which clears `discount_within_ceiling` on `crm_quote`\n      // outright \u2014 with every line at `discount: 90` prices 90% below list, and\n      // nothing objected: this object's only discount constraint was the\n      // field's own `max: 100`, the arithmetic domain of a percentage. An\n      // invariant with a documented walk-around is worse than no invariant,\n      // because a reader (human or AI) cites the rule as the guarantee.\n      //\n      // ### Same constant, same instrument, deliberately\n      //\n      // The number is `QUOTE_DISCOUNT_CEILING` \u2014 imported, never retyped, so the\n      // two ceilings are one policy and cannot drift into two. The instrument is\n      // a `type: 'script'` validation for the reason #599 measured on the quote\n      // (and this card re-measured on this object, in\n      // `test/quote-discount-ceiling.test.ts`): a field-level `max` validates\n      // only the value being WRITTEN, so a line stored above the ceiling before\n      // the rule existed keeps accepting edits forever, while a script\n      // validation is evaluated against the MERGED record on every write and is\n      // therefore a true invariant. `max: 100` stays on the field as the domain\n      // of a percentage; the policy line lives here.\n      //\n      // ### What this rule does NOT decide\n      //\n      // 60% per line AND 60% on the quote still compounds to ~84% EFFECTIVE.\n      // Whether the ceiling should be read against the effective discount is a\n      // business-policy question with no answer in this codebase, and it is\n      // open as #1109 \u2014 deliberately not guessed here. A per-line ceiling is\n      // correct under either answer: it is the whole policy if the answer is\n      // per-line, and a component of it if the answer is effective.\n      name: 'discount_within_ceiling',\n      type: 'script',\n      severity: 'error',\n      // Names the LINE, because the quote carries a same-named rule with its\n      // own message: on a refused save the rep must be able to tell which of\n      // the two numbers the platform is objecting to.\n      message: `Line discount cannot exceed ${QUOTE_DISCOUNT_CEILING}%`,\n      condition: P`has(record.discount) && record.discount != null && record.discount > ${QUOTE_DISCOUNT_CEILING}`,\n    },\n  ],\n});\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/marketing/objects/index.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/marketing/objects\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/marketing/objects/index.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\n/**\n * Marketing object barrel.\n *\n * Re-exports this package's *.object.ts definitions; the `*.hook.ts` files\n * beside them register through `./hooks.ts`. The canonical note on the\n * collaboration capabilities (`enable.files`, `enable.feeds`) that every\n * object in this app points at is written once, in\n * `src/sales/objects/index.ts`.\n */\n\nexport { Campaign } from './campaign.object';\nexport { CampaignMember } from './campaign_member.object';\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/marketing/objects/campaign.object.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/marketing/objects\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/marketing/objects/campaign.object.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport { ObjectSchema, Field } from '@objectstack/spec/data';\nimport { F, P } from '@objectstack/spec';\n\n/**\n * Campaign Object\n * Represents marketing campaigns\n */\nexport const Campaign = ObjectSchema.create({\n  name: 'crm_campaign',\n  label: 'Campaign',\n  pluralLabel: 'Campaigns',\n  icon: 'megaphone',\n  description: 'Marketing campaigns and initiatives',\n\n  // ADR-0090 D1/D7: OWD is an authored decision. Campaign catalog is org-visible; only owners edit.\n  sharingModel: 'public_read',\n  // ADR-0079: render-only `titleFormat` retired in favor of `nameField`,\n  // which names a real field. The former template composed two local fields, so\n  // a `display_title` formula field reproduces it for the record title.\n  nameField: 'display_title',\n  // Explicit search targets (ADR-0061). REQUIRED because nameField is a\n  // FORMULA (display_title/full_name): without this, $search auto-defaults to\n  // the formula field, which isn't a real column, so the lookup picker + global\n  // search silently return zero. These are real, indexed columns.\n  searchableFields: ['name', 'campaign_code'],\n  highlightFields: ['campaign_code', 'name', 'type', 'status', 'start_date'],\n\n  // Every other business object with a detail page groups its fields; campaign\n  // was one of the two that did not, so its detail page fell back to one flat\n  // 30-field grid with the ROI formulas sitting next to the campaign name. The\n  // labels mirror the sections the campaign form uses (Campaign Information /\n  // Schedule / Budget & ROI / Performance) so the two surfaces agree \u2014 the\n  // form's old three-section shape buried the two manual-entry cost fields in a\n  // combined \"Schedule & Budget\" row and was split to match this one (#597).\n  fieldGroups: [\n    { key: 'basic',      label: 'Campaign Information', icon: 'megaphone' },\n    { key: 'schedule',   label: 'Schedule',             icon: 'calendar' },\n    { key: 'budget',     label: 'Budget & ROI',         icon: 'dollar-sign' },\n    { key: 'metrics',    label: 'Performance',          icon: 'bar-chart' },\n    { key: 'assignment', label: 'Ownership',            icon: 'user' },\n    { key: 'assets',     label: 'Campaign Assets',      icon: 'link', collapse: 'collapsed' },\n  ],\n\n  fields: {\n    // Platform ownership anchor \u2014 canonical note in `account.object.ts` (#548).\n    owner_id: Field.lookup('sys_user', {\n      label: 'Campaign Owner',\n      group: 'assignment',\n      system: true,\n      readonly: false,\n      trackHistory: true,\n    }),\n\n    // AutoNumber field\n    campaign_code: Field.autonumber({\n      group: 'basic',\n      label: 'Campaign Code',\n      format: 'CPG-{0000}',\n    }),\n    \n    // Basic Information\n    name: Field.text({\n      group: 'basic',\n      label: 'Campaign Name',\n      required: true,\n      storage: { notNull: true },\n      searchable: true,\n      maxLength: 255,\n    }),\n\n    // ADR-0079 record title (was titleFormat '{campaign_code} - {name}').\n    display_title: Field.formula({\n      group: 'basic',\n      label: 'Display Title',\n      expression: F`record.campaign_code + \" - \" + record.name`,\n    }),\n\n    description: Field.markdown({\n      group: 'basic',\n      label: 'Description',\n    }),\n    \n    // Type & Channel\n    type: Field.select({\n      group: 'basic',\n      label: 'Campaign Type',\n      options: [\n        { label: 'Email', value: 'email', default: true },\n        { label: 'Webinar', value: 'webinar' },\n        { label: 'Trade Show', value: 'trade_show' },\n        { label: 'Conference', value: 'conference' },\n        { label: 'Direct Mail', value: 'direct_mail' },\n        { label: 'Social Media', value: 'social_media' },\n        { label: 'Content Marketing', value: 'content' },\n        { label: 'Partner Marketing', value: 'partner' },\n      ]\n    }),\n    \n    channel: Field.select({\n      group: 'basic',\n      label: 'Primary Channel',\n      options: [\n        { label: 'Digital', value: 'digital' },\n        { label: 'Social', value: 'social' },\n        { label: 'Email', value: 'email' },\n        { label: 'Events', value: 'events' },\n        { label: 'Partner', value: 'partner' },\n      ]\n    }),\n    \n    // Status\n    status: Field.select({\n      group: 'basic',\n      label: 'Status',\n      options: [\n        { label: 'Planning', value: 'planning', color: '#999999', default: true },\n        { label: 'In Progress', value: 'in_progress', color: '#FFA500' },\n        { label: 'Completed', value: 'completed', color: '#00AA00' },\n        { label: 'Aborted', value: 'aborted', color: '#FF0000' },\n      ],\n      required: true,\n      storage: { notNull: true },\n      trackHistory: true,\n    }),\n    \n    // Dates\n    start_date: Field.date({\n      group: 'schedule',\n      label: 'Start Date',\n      required: true,\n      storage: { notNull: true },\n    }),\n    \n    end_date: Field.date({\n      group: 'schedule',\n      label: 'End Date',\n      required: true,\n      storage: { notNull: true },\n    }),\n    \n    // Budget & ROI\n    budgeted_cost: Field.currency({ \n      group: 'budget',\n      label: 'Budgeted Cost',\n      min: 0,\n    }),\n    \n    actual_cost: Field.currency({ \n      group: 'budget',\n      label: 'Actual Cost',\n      min: 0,\n    }),\n    \n    expected_revenue: Field.currency({ \n      group: 'budget',\n      label: 'Expected Revenue',\n      min: 0,\n    }),\n    \n    // \u26D4 NOT `readonly` (here and on the num_* snapshot fields below), and the\n    // reason holds on the pinned engine rather than on the retired 16.x claim\n    // this note used to carry. The metric block \u2014 `CAMPAIGN_METRIC_FIELDS` in\n    // `campaign.hook.ts` \u2014 is written by FOUR refresh hooks, not by the\n    // long-retired `campaign_snapshot_metrics`: `campaign_metrics_refresh`,\n    // `campaign_attribution_refresh`, `campaign_lead_conversion_refresh` and\n    // `campaign_member_metrics_refresh`. Every one of them writes\n    // `api.object('crm_campaign').update(...)`, and none declares `Hook.runAs`,\n    // which defaults to `'inherit'` \u2014 so `ctx.api` is a `ScopedContext` over the\n    // ACTING USER's context, and the keys are CALLER-supplied to a\n    // non-`isSystem` UPDATE, exactly what `stripReadonlyFields` deletes. Their\n    // least-privileged trigger is an ordinary user edit \u2014 a rep moving a\n    // campaign's status, saving an opportunity, enrolling a member \u2014 so\n    // `readonly` here would freeze the whole block at its seeded values.\n    // Measured in `test/activity-recency.test.ts`, which runs this same\n    // `ctx.api` shape through the real engine under a plain user context.\n    actual_revenue: Field.currency({ \n      group: 'budget',\n      label: 'Actual Revenue',\n      min: 0,\n    }),\n    \n    // Metrics\n    target_size: Field.number({\n      group: 'metrics',\n      label: 'Target Size',\n      description: 'Target number of leads/contacts',\n      min: 0,\n    }),\n    \n    // NOT `readonly`: written by the same four refresh hooks, and for the same\n    // reason \u2014 see the note on `actual_revenue` above.\n    // Definition: total members enrolled.\n    num_sent: Field.number({\n      group: 'metrics',\n      label: 'Number Sent',\n      min: 0,\n    }),\n    \n    num_responses: Field.number({\n      group: 'metrics',\n      label: 'Number of Responses',\n      min: 0,\n    }),\n    \n    num_leads: Field.number({\n      group: 'metrics',\n      label: 'Number of Leads',\n      min: 0,\n    }),\n    \n    num_converted_leads: Field.number({\n      group: 'metrics',\n      label: 'Converted Leads',\n      min: 0,\n    }),\n    \n    num_opportunities: Field.number({\n      group: 'metrics',\n      label: 'Opportunities Created',\n      min: 0,\n    }),\n    \n    num_won_opportunities: Field.number({\n      group: 'metrics',\n      label: 'Won Opportunities',\n      min: 0,\n    }),\n    \n    // Calculated Metrics (Formula Fields)\n    response_rate: Field.formula({\n      group: 'metrics',\n      label: 'Response Rate %',\n      expression: F`coalesce(record.num_sent, 0) > 0 ? (coalesce(record.num_responses, 0) * 100.0) / record.num_sent : 0.0`,\n      scale: 2,\n    }),\n    \n    roi: Field.formula({\n      group: 'budget',\n      label: 'ROI %',\n      expression: F`coalesce(record.actual_cost, 0) > 0 ? ((coalesce(record.actual_revenue, 0) - record.actual_cost) * 100.0) / record.actual_cost : 0.0`,\n      scale: 2,\n    }),\n    \n    // No `parent_campaign`. Campaign hierarchy was declared and never used: no\n    // page, doc or report mentioned it, and the honest consumer for it \u2014 a\n    // rolled-up ROI \u2014 cannot be one declaration. `roi` here is a formula over\n    // this campaign's OWN `actual_cost` / `actual_revenue`, so a hierarchy ROI\n    // would put a second, differently-scoped ROI on the same record and leave\n    // every reader to guess which one they were looking at.\n    \n    // Campaign Assets\n    landing_page_url: Field.url({\n      group: 'assets',\n      label: 'Landing Page',\n    }),\n    \n    is_active: Field.boolean({\n      group: 'assets',\n      label: 'Active',\n      defaultValue: true,\n    }),\n  },\n  \n  // Database indexes\n  indexes: [\n    { fields: ['name'] },\n    { fields: ['type'] },\n    { fields: ['status'] },\n    { fields: ['start_date'] },\n    { fields: ['owner_id'] },\n  ],\n  \n  // Enable advanced features\n  // API surface. History \u2192 Field.trackHistory (ADR-0052).\n  enable: {\n    apiEnabled: true,\n    apiMethods: ['get', 'list', 'create', 'update', 'delete'],\n  },\n  \n  // Validation Rules\n  //\n  // Predicates below are TOTAL: every `record.x` read is `has()`-guarded, so the\n  // rule returns a verdict even when the merged record has no such key. See\n  // AGENTS.md \"Validation predicates must be TOTAL\" and\n  // test/object-validation-predicates.test.ts, which fails the build otherwise.\n  validations: [\n    {\n      name: 'end_after_start',\n      type: 'script',\n      severity: 'error',\n      message: 'End Date must be after Start Date',\n      // `<=`, not `<`: the message promises \"after\", so a campaign that ends\n      // the day it starts is a violation. Matches `crm_contract`'s twin rule\n      // and `crm_forecast.period_end_after_start` (#514 item 12).\n      condition: P`has(record.end_date) && record.end_date != null && has(record.start_date) && record.start_date != null && record.end_date <= record.start_date`,\n    },\n    {\n      name: 'actual_cost_within_budget',\n      type: 'script',\n      severity: 'warning',\n      message: 'Actual Cost exceeds Budgeted Cost',\n      condition: P`has(record.actual_cost) && record.actual_cost != null && has(record.budgeted_cost) && record.budgeted_cost != null && record.actual_cost > record.budgeted_cost`,\n    },\n  ],\n  \n  // Workflow Rules\n  // \u26A0\uFE0F No `workflows[]` here, and none is possible: object `workflows[]` were\n  // removed from the platform. Field updates live in this object's `*.hook.ts`;\n  // scheduled status flips and notifications live in `src/*/flows/*.flow.ts`.\n});\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/marketing/objects/campaign_member.object.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/marketing/objects\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/marketing/objects/campaign_member.object.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport { ObjectSchema, Field } from '@objectstack/spec/data';\nimport { P } from '@objectstack/spec';\n\n/**\n * Campaign Member Object\n *\n * Links a Lead OR Contact to a Campaign and tracks the response\n * lifecycle `sent \u2192 responded / converted / unsubscribed`.\n * Used by the campaign-enrollment flow and by ROI dashboards.\n *\n * \u26A0\uFE0F The lifecycle stops where the platform's writers stop (#597). It used to\n * read `Sent \u2192 Opened \u2192 Clicked \u2192 Responded \u2192 Converted` with `bounced` beside\n * it, plus `first_opened_date` / `first_clicked_date` stamps \u2014 six values and\n * two columns that NOTHING in this app or on the platform could ever write.\n * `@objectstack/plugin-email` is \"transport-pluggable OUTBOUND delivery with\n * sys_email persistence\": its `sys_email.status` vocabulary is\n * `queued | sent | failed`, there is no open/click webhook, no bounce\n * ingestion, and no tracking pixel anywhere in the installed platform\n * (measured on 17.0.0-rc.6). So an author reading this object was promised\n * engagement tracking the product cannot deliver, and every one of those\n * values would have stayed at its default forever.\n *\n * Removed rather than wired, per ADR-0049's enforce-or-remove spirit: they\n * come back the day a real tracking integration exists to write them, and not\n * before. What survives is the part with a real writer \u2014 see the writer table\n * beside each field below.\n */\nexport const CampaignMember = ObjectSchema.create({\n  name: 'crm_campaign_member',\n  label: 'Campaign Member',\n  pluralLabel: 'Campaign Members',\n  icon: 'user-plus',\n  description: 'Membership and response tracking for marketing campaigns',\n\n  // ADR-0090 D1/D7: OWD is an authored decision. Membership is an attribute of\n  // the campaign, so record access DERIVES from it (ADR-0055). The relation\n  // resolver accepts the REQUIRED `crm_campaign` LOOKUP as the parent, so no\n  // master-detail conversion is needed.\n  //\n  // The derivation delivers exactly \"members whose `crm_campaign` the caller\n  // can read\". \u26A0\uFE0F Master accessibility resolves through the same paths a direct\n  // read of the campaign takes \u2014 ownership and `sys_record_share` grants folded\n  // in ALONGSIDE the master's row-level security policies, not the policies\n  // alone. `test/parent-derived-reach.test.ts` pins that, and was written to go\n  // red the day the platform changes it: an earlier version consulted master\n  // RLS ONLY, under a SYSTEM context, so with no policy narrowing a SELECT on\n  // `crm_campaign` a member row was readable by every holder of object-level\n  // read on this object.\n  //\n  // \u26A0\uFE0F The write side reaches further than reads: the platform's\n  // `member_default` set carries an owner-only-writes RLS policy on updates,\n  // and because the derivation folds master RLS in, that policy reaches through\n  // to member writes \u2014 see the `marketing_campaign_updates` note in\n  // `src/sales/profiles/marketing-user.profile.ts`.\n  //\n  // \u26D4 Not `private`: with no owner field on the junction row that resolves to\n  // \"whoever inserted it\", which is nobody's idea of campaign membership and\n  // hides rows written by the enrollment flow.\n  sharingModel: 'controlled_by_parent',\n\n  // Per-field history is opt-in via `Field.trackHistory` (ADR-0052), set on\n  // `status` below \u2014 there is no object-level history flag.\n\n  // ADR-0079: junction rows have no derivable text title; point the canonical\n  // nameField at the stored autonumber explicitly (autonumber is not in the\n  // auto-derivation whitelist).\n  nameField: 'member_number',\n\n  // Load-bearing on TWO surfaces, and the second one is why this list is not\n  // the side that gave way to fix `field-group-shadowed` below (#715). Besides the\n  // detail highlight strip, it is what curates the members panel on a\n  // campaign's detail page: a related list takes its columns from the child's\n  // `highlightFields` minus the lookup it is scoped by, and this object ships\n  // no view at all, so dropping `crm_lead`/`crm_contact` here would leave that\n  // panel showing Status / Response Date and no person \u2014 measured and pinned in\n  // `test/view-references.test.ts` (#944).\n  highlightFields: ['crm_campaign', 'crm_lead', 'crm_contact', 'status', 'response_date'],\n\n  // Both groups render on detail pages as well as on forms, and keeping them\n  // that way is a constraint on the two lists above, not a free choice (#715).\n  // A synthesized detail page hoists the record title plus the first four\n  // highlightFields out of the body, so a group whose every field is hoisted\n  // keeps its heading on forms and silently disappears from detail pages\n  // (`field-group-shadowed`).\n  // `basic` was exactly that: member_number is the title, and campaign/lead/\n  // contact are the first three of the strip. `added_date` \u2014 the enrollment\n  // stamp, which describes the MEMBERSHIP rather than the person's response \u2014\n  // sits here rather than under `response` so the group has something of its\n  // own to show. Same resolution as `crm_task`'s shadowed `assignment` group\n  // (#582): move the field to the group it reads under, leave the strip alone.\n  fieldGroups: [\n    { key: 'basic',    label: 'Basic Information', icon: 'info' },\n    { key: 'response', label: 'Response Tracking', icon: 'activity' },\n  ],\n\n  fields: {\n    member_number: Field.autonumber({\n      label: 'Member Number',\n      format: 'CM-{00000}',\n      group: 'basic',\n    }),\n\n    crm_campaign: Field.lookup('crm_campaign', {\n      label: 'Campaign',\n      required: true,\n      storage: { notNull: true },\n      group: 'basic',\n\n      // Curates the members panel on a campaign \u2014 and it is the ONE mechanism\n      // that actually reaches that panel. Measured in #944 and restated in\n      // `test/view-references.test.ts`: a detail-page related list reads\n      // `relatedListColumns` on the CHILD's lookup first, and only without it\n      // falls back to the child's `highlightFields` minus this lookup. The\n      // child's `list` view is never consulted, which is why authoring one\n      // here would not have shown anything.\n      //\n      // It is a SUPERSET of the fallback it replaces \u2014 Lead / Contact /\n      // Status / Response Date, in that order \u2014 plus the one column the panel\n      // was missing. `added_date` is the enrollment stamp: `readonly: true`\n      // (#1667) and written on every enrollment by the two elevated sub-flows\n      // #1807 built for it, so a marketer could see WHEN a member responded\n      // but not when they were added, on a register whose whole subject is\n      // the enrollment. It sits after the person and before the response\n      // lifecycle, which is the order the row happens in.\n      //\n      // \u26D4 Deliberately NOT solved by adding `added_date` to\n      // `highlightFields`: that strip is hoisted out of the detail body, and\n      // `added_date` is the only field in the `basic` group that is neither\n      // the record title nor already in the strip \u2014 hoisting it would leave\n      // the group with nothing of its own and silently vanish its heading\n      // from every detail page (`field-group-shadowed`, the trap the note\n      // above this object's `fieldGroups` records being rescued from).\n      relatedListColumns: ['crm_lead', 'crm_contact', 'added_date', 'status', 'response_date'],\n    }),\n\n    // `deleteBehavior: 'cascade'` on BOTH party lookups (#696). A lookup\n    // defaults to `set_null`, and that default made every enrolled person\n    // permanently undeletable: deleting the lead cleared this column, the\n    // cleared row instantly violated `lead_or_contact_required` below, and the\n    // whole delete rolled back with a 400 naming an object the caller never\n    // touched (\"A campaign member must reference either a Lead or a Contact\",\n    // `\"object\":\"crm_lead\"`). A GDPR \"delete this person\" request could not be\n    // served through the API or the UI.\n    //\n    // Cascade rather than `restrict`: this is a JUNCTION row whose entire\n    // meaning is \"this person is enrolled in this campaign\". Once the person is\n    // gone the row denotes nothing, so keeping it (restrict) would only trade\n    // one undeletable person for a manual un-enrol chore, and the impact this\n    // fixes is undeletable people, not a confusing message. Cascade also makes\n    // the object's own rule unfalsifiable by construction: there is no longer a\n    // reachable state in which a stored member row breaks it.\n    crm_lead: Field.lookup('crm_lead', {\n      label: 'Lead',\n      group: 'basic',\n      deleteBehavior: 'cascade',\n      description: 'Set when the member was a Lead at enrollment time',\n    }),\n\n    crm_contact: Field.lookup('crm_contact', {\n      label: 'Contact',\n      group: 'basic',\n      deleteBehavior: 'cascade',\n      description: 'Set when the member is an existing Contact',\n    }),\n\n    // \u2B50 `readonly: true` \u2014 DECLARED, and it still costs no writer its write,\n    // but the reason CHANGED on the @objectstack/* 17.4.0 migration. It used to\n    // be \"the strip is an UPDATE-path rule and every writer here is an INSERT\".\n    // objectql 17.4.0 retired that: a static readonly field is now stripped from\n    // a NON-SYSTEM caller's INSERT payload inside `engine.insert` too, so an\n    // ordinary user-context create no longer seeds this column.\n    //\n    // Every writer is therefore elevated now, and the elevation is scoped as\n    // narrowly as AGENTS.md house rule 9 requires \u2014 the `campaign_enrollment`\n    // SCREEN flow stays `runAs: 'user'` and hands only the insert to\n    // `campaign_lead_member_enroll` / `campaign_contact_member_enroll`\n    // (`runAs: 'system'`, one `create_record` each); the marketing seed is a\n    // system write already. Nothing updates it: there is no `update_record`\n    // node, no hook and no action that writes `added_date`. This column's own\n    // two halves are pinned in `test/audit-stamp-readonly.test.ts` \u2014 the\n    // enrollment writers still stamp it, and a user-context UPDATE is stripped.\n    // Ruled #1667 (director seat, decision batch #74, 2026-09-07): an\n    // enrollment stamp nobody is meant to hand-edit gets the declaration that\n    // says so. \u26D4 The 16.x claim this note used to carry (\"every member landed\n    // with a null Added Date while the flag was on\") described an engine this\n    // repo no longer runs; \u26D4 do not resurrect it as a reason to open the\n    // column back up.\n    //\n    // Grouped under `basic`, not `response` (#715): it records when the\n    // membership was created, which is a fact about the enrollment, not a step\n    // in the response lifecycle the other stamps track.\n    added_date: Field.datetime({\n      label: 'Added Date',\n      group: 'basic',\n      readonly: true,\n    }),\n\n    // Writers, one per surviving value (#597):\n    //   sent         \u2014 campaign_enrollment flow, `create_campaign` (leads) and\n    //                  `add_contact_to_campaign` (contacts) stamp it on insert.\n    //   responded    \u2014 the `mark_responded` action (src/marketing/actions/campaign.actions.ts).\n    //   converted    \u2014 the member's lead converting; `campaign_lead_conversion_refresh`\n    //                  (src/sales/objects/lead.campaign-metrics.hook.ts) promotes\n    //                  the row when `crm_lead.is_converted` flips.\n    //   unsubscribed \u2014 set by a rep (or an opt-out request) on the member row;\n    //                  `campaign_member_optout_sync` round-trips it to the\n    //                  lead/contact's `email_opt_out`, which is what makes the\n    //                  enrollment flow's opt-out filter honour it next run.\n    //\n    // `opened` / `clicked` / `bounced` were removed here \u2014 see the object\n    // docblock. Nothing on the platform can produce them.\n    status: Field.select({\n      label: 'Status',\n      required: true,\n      storage: { notNull: true },\n      group: 'response',\n      trackHistory: true,\n      options: [\n        { label: 'Sent',      value: 'sent',      default: true, color: '#A0A0A0' },\n        { label: 'Responded', value: 'responded', color: '#00AA00' },\n        { label: 'Converted', value: 'converted', color: '#7C3AED' },\n        { label: 'Unsubscribed', value: 'unsubscribed', color: '#FF0000' },\n      ],\n    }),\n\n    // Written by the `mark_responded` action, and by\n    // `campaign_member_lifecycle` when it back-fills a member whose response\n    // was recorded by flipping `status` directly.\n    response_date: Field.datetime({\n      label: 'Response Date',\n      group: 'response',\n    }),\n\n    // Kept in lockstep with `status == \"responded\"` by\n    // `campaign_member_lifecycle` (beforeInsert/beforeUpdate) \u2014 a boolean that\n    // disagrees with the status it summarises is the shape the response\n    // surfaces cannot render, and it is what `test/seed-consistency.test.ts`\n    // already pins on the seed side.\n    has_responded: Field.boolean({\n      label: 'Has Responded',\n      defaultValue: false,\n      group: 'response',\n    }),\n  },\n\n  // Predicates below are TOTAL: every `record.x` read is `has()`-guarded, so the\n  // rule returns a verdict even when the merged record has no such key. See\n  // AGENTS.md \"Validation predicates must be TOTAL\" and\n  // test/object-validation-predicates.test.ts, which fails the build otherwise.\n  validations: [\n    {\n      name: 'lead_or_contact_required',\n      type: 'script',\n      severity: 'error',\n      message: 'A campaign member must reference either a Lead or a Contact',\n      condition: P`(!has(record.crm_lead) || isBlank(record.crm_lead)) && (!has(record.crm_contact) || isBlank(record.crm_contact))`,\n    },\n  ],\n});\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/sales/actions/index.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/sales/actions\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/sales/actions/index.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\n/**\n * Action Definitions Barrel\n *\n * Exports CRM action metadata. Every action ships an inline metadata\n * `body` (sandboxed JS) so the AppPlugin auto-binds the handler at\n * boot \u2014 no imperative `engine.registerAction(...)` wiring is needed.\n *\n * `ConvertLeadAction` is the only exception: it is a `flow`-typed\n * action and the screen flow under `src/sales/flows/lead-conversion.flow.ts`\n * carries the implementation.\n */\nexport { AddContactToCampaignAction, MarkPrimaryContactAction, SendEmailAction } from './contact.actions';\n// Activity logging: one registration per (kind \u00D7 object). Every export\n// forwarded from here must be ONE Action \u2014 the stack is built from\n// `Object.values(actions)`, so an exported array arrives as a nested list and\n// fails the schema parse. \u26D4 Never re-export `activityActionsFor` (the factory)\n// from here; the `crm_case` triple it also builds is service's and is forwarded\n// by `src/service/actions/index.ts`.\nexport {\n  LeadLogCallAction, LeadLogMeetingAction, LeadScheduleMeetingAction,\n  ContactLogCallAction, ContactLogMeetingAction, ContactScheduleMeetingAction,\n  AccountLogCallAction, AccountLogMeetingAction, AccountScheduleMeetingAction,\n  OpportunityLogCallAction, OpportunityLogMeetingAction, OpportunityScheduleMeetingAction,\n} from './activity-actions';\nexport { ConvertLeadAction, CreateCampaignAction, ScheduleFollowUpAction } from './lead.actions';\nexport { CloneOpportunityAction, MassUpdateStageAction, GenerateQuoteAction } from './opportunity.actions';\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/sales/actions/contact.actions.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/sales/actions\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/sales/actions/contact.actions.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport type { Action } from '@objectstack/spec/ui';\nimport { P } from '@objectstack/spec';\nimport { ACTOR_NAME_RESOLUTION_SOURCE } from './activity-actions';\n\n/**\n * Mark Contact as Primary.\n *\n * Demonstrates the L2 metadata-body action shape. The `body.source` runs\n * in the QuickJS sandbox via `actionBodyRunnerFactory`. The script receives\n * `(input, ctx)` where `ctx.recordId` is the contact id from the action\n * URL and `ctx.api.object('crm_contact').update(...)` is gated by `api.write`.\n */\nexport const MarkPrimaryContactAction: Action = {\n  name: 'mark_primary',\n  label: 'Mark as Primary Contact',\n  objectName: 'crm_contact',\n  icon: 'star',\n  type: 'script',\n  body: {\n    language: 'js',\n    source: `\n      const id = ctx.recordId;\n      if (!id) throw new Error('mark_primary requires a recordId');\n      await ctx.api.object('crm_contact').update({ id, is_primary: true }, { where: { id } });\n      return { ok: true, id, is_primary: true };\n    `,\n    capabilities: ['api.write'],\n    timeoutMs: 2000,\n  },\n  locations: ['record_header', 'list_item'],\n  visible: P`has(record.is_primary) && record.is_primary == false`,\n  confirmText: 'Mark this contact as the primary contact for the account?',\n  successMessage: 'Contact marked as primary!',\n  refreshAfter: true,\n};\n\n/**\n * Add selected contacts to a Campaign.\n *\n * The contact-side mirror of `create_campaign` on `crm_lead`, and the only\n * writer of `crm_campaign_member.crm_contact` \u2014 the lookup that lets a campaign\n * reach existing customers and not only leads. Every design decision below is\n * copied deliberately from the lead action rather than re-derived, so the two\n * paths cannot drift:\n *\n *   - PER-RECORD dispatch. `src/sales/views/contact.view.ts` wires this as the\n *     BARE-STRING form (`bulkActions: ['add_contact_to_campaign']`), which the\n *     renderer fans out once per selected row with that row's `recordId` and NO\n *     selection array. The body reads `ctx.recordId` and nothing else. \u26D4 Never\n *     add an `input.selectedIds` read: only the aggregate contract injects the\n *     underscore-prefixed builtin, and the strict params gate (ADR-0104)\n *     refuses an undeclared `selectedIds` param outright.\n *   - `type: 'script'` + `params`, never `type: 'modal'` \u2014 a modal action has\n *     no server dispatch, so its body never runs.\n *   - The campaign param is FIELD-BACKED (`field` + `objectOverride`) so the\n *     console resolves a record picker from\n *     `crm_campaign_member.crm_campaign`. A bare `{ type: 'lookup' }` cannot\n *     resolve a target object and degrades to a paste-the-ID textbox.\n *\n * One deliberate difference: the dedupe read scopes on `crm_contact`, so a\n * person enrolled as a LEAD and again as a CONTACT is not treated as a\n * duplicate. Those are two different records of two different relationships,\n * and `crm_campaign_member` keys them separately (see the two seed datasets in\n * `src/marketing/data/marketing.seed.ts`).\n */\nexport const AddContactToCampaignAction: Action = {\n  name: 'add_contact_to_campaign',\n  label: 'Add to Campaign',\n  objectName: 'crm_contact',\n  icon: 'send',\n  type: 'script',\n  body: {\n    language: 'js',\n    source: `\n      // Value key = the param's field name ('crm_campaign') since the param\n      // omits an explicit 'name'. Insert uses the REAL lookup field names on\n      // crm_campaign_member (crm_campaign / crm_contact).\n      const campaignId = input.crm_campaign ?? null;\n      if (!campaignId) throw new Error('add_contact_to_campaign requires a campaign id');\n      const ids = ctx.recordId ? [ctx.recordId] : [];\n      if (!ids.length) throw new Error('add_contact_to_campaign: no contact selected');\n      const raw = await ctx.api.object('crm_campaign_member').find({\n        where: { crm_campaign: campaignId },\n        fields: ['crm_contact'],\n        top: 5000,\n      });\n      const existingRows = Array.isArray(raw) ? raw : (raw?.records ?? []);\n      const existing = new Set(existingRows.map((r) => r.crm_contact));\n      const inserted = [];\n      let skipped = 0;\n      for (const contactId of ids) {\n        if (existing.has(contactId)) { skipped++; continue; }\n        const row = await ctx.api.object('crm_campaign_member').insert({\n          crm_campaign: campaignId,\n          crm_contact: contactId,\n          status: 'sent',\n        });\n        inserted.push(row?.id ?? null);\n      }\n      return { campaignId, count: inserted.length, skipped, ids: inserted };\n    `,\n    capabilities: ['api.read', 'api.write'],\n    timeoutMs: 10000,\n  },\n  locations: ['list_toolbar', 'list_item'],\n  params: [\n    {\n      field: 'crm_campaign',\n      objectOverride: 'crm_campaign_member',\n      label: 'Campaign',\n      required: true,\n    },\n  ],\n  // An opted-out contact must not be added to a campaign by hand either \u2014 the\n  // enrollment flow already filters them out, and a manual add-to-campaign is\n  // the obvious way around a filter nobody remembers is there. Same predicate\n  // the `send_email` action uses.\n  visible: P`has(record.email_opt_out) && record.email_opt_out == false`,\n  successMessage: 'Contacts added to campaign!',\n  refreshAfter: true,\n};\n\n/**\n * Send Email to Contact.\n *\n * Modal-typed action: collects subject + body, then logs an `activity`\n * record via the metadata body. Runs sandboxed under `api.write`.\n */\nexport const SendEmailAction: Action = {\n  name: 'send_email',\n  label: 'Send Email',\n  objectName: 'crm_contact',\n  icon: 'mail',\n  // script, not modal: modal submits die on GET /api/v1/meta/object/<target>\n  // \u2192 400 in 16.1.0; script actions POST /api/v1/actions/... and execute.\n  type: 'script',\n  body: {\n    language: 'js',\n    source: `\n      const record = ctx.record ?? {};\n      const recipientId = ctx.recordId ?? record.id ?? null;\n      const to = record.email ? String(record.email) : '';\n      const from = ctx.user?.email ?? 'noreply@hotcrm.local';\n      const userId = ctx.user?.id ?? null;\n      const subject = input.subject ? String(input.subject) : ('Email to ' + to);\n      const body = input.body ? String(input.body) : '';\n      const email = await ctx.api.object('sys_email').insert({\n        from_address: from,\n        to_addresses: to,\n        subject,\n        body_text: body,\n        status: 'queued',\n        related_object: 'crm_contact',\n        related_id: recipientId,\n        sent_by: userId,\n      });\n\n      ${ACTOR_NAME_RESOLUTION_SOURCE}\n\n      // Surface the email on the contact's unified activity timeline\n      // (the audit writer only logs generic CRUD; this is the semantic event).\n      const activity = await ctx.api.object('sys_activity').insert({\n        type: 'completed',\n        summary: 'Email: ' + subject,\n        actor_id: userId,\n        actor_name: actorName,\n        object_name: 'crm_contact',\n        record_id: recipientId,\n        record_label: record.full_name ?? record.name ?? to,\n        // ADR-0052 ActivityPointer: structured pointer to the rich source entity\n        // (the sys_email row) so the timeline renders a \"View source \u2192\" drill to\n        // the full email \u2014 the queryable replacement for stashing the id in metadata.\n        source_object: 'sys_email',\n        source_id: email?.id ?? null,\n        metadata: JSON.stringify({ kind: 'email', to, subject }),\n      });\n      // #592 scope item 3: every activity writer bumps interaction recency.\n      // An email is an interaction but NOT a calendar slot, so it writes no\n      // \\`crm_event\\` \u2014 which means it cannot ride the event hook's bubble and\n      // has to stamp the two timestamps itself. Both columns are deliberately\n      // non-readonly (see crm_account.last_activity_date's note): a readonly\n      // field is stripped from any non-system write whose caller supplied the\n      // key (#2948), and an action body runs under the sending rep's context.\n      if (recipientId) {\n        const nowIso = new Date().toISOString();\n        try {\n          await ctx.api.object('crm_contact').update(\n            { id: recipientId, last_contacted_date: nowIso },\n            { where: { id: recipientId } },\n          );\n        } catch (e) { /* best-effort recency; never fail the send */ }\n        const accountId = record.crm_account ? String(record.crm_account) : null;\n        if (accountId) {\n          try {\n            await ctx.api.object('crm_account').update(\n              { id: accountId, last_activity_date: nowIso.slice(0, 10) },\n              { where: { id: accountId } },\n            );\n          } catch (e) { /* best-effort recency; never fail the send */ }\n        }\n      }\n      return { emailId: email?.id, activityId: activity?.id };\n    `,\n    capabilities: ['api.read', 'api.write'],\n    timeoutMs: 5000,\n  },\n  locations: ['record_header', 'list_item'],\n  visible: P`has(record.email_opt_out) && record.email_opt_out == false`,\n  params: [\n    { name: 'subject', label: 'Subject', type: 'text', required: true },\n    { name: 'body', label: 'Body', type: 'textarea', required: true },\n  ],\n  refreshAfter: false,\n};\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/sales/actions/lead.actions.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/sales/actions\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/sales/actions/lead.actions.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport type { Action } from '@objectstack/spec/ui';\nimport { P } from '@objectstack/spec';\n\n/**\n * Convert Lead to Account, Contact, and Opportunity.\n *\n * Flow-typed action: invocation is delegated to the `lead_conversion`\n * flow defined under `src/sales/flows/`. The flow engine handles the screen\n * + server steps; no metadata body is required here.\n */\nexport const ConvertLeadAction: Action = {\n  name: 'convert_lead',\n  label: 'Convert Lead',\n  objectName: 'crm_lead',\n  icon: 'arrow-right-circle',\n  type: 'flow',\n  target: 'lead_conversion',\n  locations: ['record_header', 'list_item'],\n  // Convert is the lead's most basic outcome \u2014 surface it on ANY open lead\n  // (new / contacted / qualified), not just qualified. Gating to qualified-only\n  // hid the button on most seeded leads, so it read as \"conversion is missing\".\n  // Only already-converted or disqualified leads hide it.\n  //\n  // TOTALITY (AGENTS.md \u2192 \"Validation predicates must be TOTAL\", #630): every\n  // `record.x` read carries a `has(record.x)`, and the guards are arranged to\n  // fail CLOSED \u2014 an unknown record hides the button. That arrangement is a\n  // MEASUREMENT, not a preference. Measured in the browser on console 17.4.0 by\n  // instrumenting the shipped predicate evaluator: the record page evaluates this\n  // predicate twice against an EMPTY record (`record` is `{}`, zero keys) before\n  // the row lands, then re-evaluates it against the full row. So an absent\n  // `status` here means \"no record yet\", never \"a lead with no status\" \u2014 a lead\n  // with no status cannot exist, since `status` is `required` with\n  // `storage: { notNull: true }` and `defaultValue: 'new'` (src/sales/objects/lead.object.ts),\n  // and the REST payload this surface reads carries every declared column.\n  // Fail-open (`!has(record.status) || \u2026`) would therefore buy nothing and cost\n  // something real: Convert would flash on a disqualified lead for the\n  // pre-hydration beat, on an IRREVERSIBLE action.\n  // Unguarded, strict CEL aborted the whole predicate on those two renders\n  // (`[runtime] No such key: status`) and object-ui fell back to its own\n  // `fallback: false`, so this spelling states the policy the error path was\n  // already applying \u2014 minus the console warning on every lead page load. (#1890)\n  //\n  // \u26A0\uFE0F The approval term is the ONE fail-OPEN read in this predicate, and the\n  // asymmetry is deliberate rather than an oversight in an otherwise\n  // fail-closed arrangement (REQ-0005 step 7). The two terms above fail closed\n  // because an absent `status` means \"no record yet\" \u2014 a lead with no status\n  // cannot exist, since `status` is `required` with a `defaultValue`. An absent\n  // `conversion_approval_status` means something else entirely: a lead written\n  // before the column existed, which must convert the way it always did. And\n  // the shipped `not_required` default is the gate's OFF position, so treating\n  // \"not one of the two refusing verdicts\" as convertible is what makes the\n  // default install behave exactly as it did before this field. `lead.hook.ts`\n  // and `lead-conversion.flow.ts`'s `decision_approval` carry the same polarity\n  // \u2014 the three surfaces have to agree about what \"off\" means, or the button\n  // disappears on leads the write path would happily convert.\n  //\n  // \u26D4 Hiding this button is NOT the gate. It is the courtesy half; the control\n  // is the `beforeUpdate` refusal in `lead.hook.ts`, which a REST caller cannot\n  // route around.\n  visible: P`has(record.is_converted) && record.is_converted == false && has(record.status) && record.status != \"unqualified\" && record.status != \"converted\"\n    && (!has(record.conversion_approval_status) || (record.conversion_approval_status != \"pending\" && record.conversion_approval_status != \"rejected\"))`,\n  // NO `confirmText`. A screen flow IS the confirmation, and this one opens\n  // `Conversion Details` \u2014 a screen carrying the decision (`Create\n  // Opportunity?`, and the deal's name and amount), a Cancel button, and the\n  // suspected-duplicate warning that says something TRUE about THIS lead. A\n  // dialog in front of it costs every conversion one extra click to answer a\n  // question it cannot help anyone answer. Confirms are for DESTRUCTIVE actions\n  // with no follow-up UI \u2014 `close_case` / `escalate_case` in `case.actions.ts`\n  // are the shape that still earns one.\n  //\n  // Mechanism, measured on the console this app pinned at that taking\n  // (@objectstack/console 17.3.0, `dist/assets/`; this bundle read was \u26D4 NOT\n  // re-taken on any later pin \u2014 17.4.0, PR #1814, or 17.5.0) rather than\n  // assumed: the runner gates the dialog on\n  // the key's presence alone \u2014\n  //     if (action.confirmText && !await confirmHandler(evaluate(action.confirmText)))\n  //         return { success: false, error: 'Action cancelled by user' };\n  // \u2014 so REMOVING the key is what removes the dialog; there is no `confirm:\n  // false` to write, and no other key re-raises it.\n  successMessage: 'Lead converted successfully!',\n  refreshAfter: true,\n  // ADR-0011 \u2014 opt this Action in to AI, which materialises the\n  // `action_convert_lead` tool the `lead_qualification` skill references.\n  // Flow-typed with a target, so it has a headless path. `requiresConfirmation`\n  // is the only key the AI path reads: `actionLooksDestructive` consults\n  // `ai.requiresConfirmation` and nothing else, and the console's\n  // confirm-dialog string reached no AI code \u2014 so dropping `confirmText` above\n  // leaves the AI approval signal exactly where it was. The flag is SURFACED,\n  // not enforced \u2014 `list_actions` reports `requiresConfirmation: true` and the\n  // calling client decides what to do with it, while `run_action` dispatches\n  // the flow with no server-side pause. It warns the caller that this is\n  // irreversible; it is not a lock.\n  ai: {\n    exposed: true,\n    requiresConfirmation: true,\n    description:\n      'Converts a qualified lead into an account, contact and opportunity. Irreversible \u2014 requires human approval before it runs.',\n  },\n};\n\n/**\n * Schedule the next follow-up on a lead.\n *\n * The gap this fills: `log_call` / `log_meeting` record what already happened\n * (a `sys_activity` timeline entry), but nothing put the NEXT touch on the\n * rep's list. Filing that follow-up meant leaving the lead, opening the\n * Related tab, finding the Tasks block, and hand-picking the lead back as the\n * parent \u2014 four steps for the single most common thing a rep does after a call.\n *\n * Flow-typed, not `type: 'modal'`: modal actions are non-functional in 16.1.0\n * (the console resolves the action's `target` as an object name, so submitting\n * one dies on `GET /api/v1/meta/object/<target>` \u2192 400 \u2014 reproducible on the\n * pre-existing `log_call` too). The screen flow under\n * `src/sales/flows/schedule-followup.flow.ts` collects the same fields and does the\n * write; that mechanism is proven by `convert_lead` above.\n */\nexport const ScheduleFollowUpAction: Action = {\n  name: 'schedule_followup',\n  label: 'Schedule Follow-up',\n  objectName: 'crm_lead',\n  icon: 'calendar-plus',\n  type: 'flow',\n  target: 'schedule_followup',\n  locations: ['record_header', 'list_item'],\n  // A converted or disqualified lead has no next touch to schedule.\n  visible: P`has(record.is_converted) && record.is_converted == false && has(record.status) && record.status != \"unqualified\" && record.status != \"converted\"`,\n  successMessage: 'Follow-up scheduled.',\n  refreshAfter: true,\n  // ADR-0011 \u2014 materialises `action_schedule_followup` for the\n  // `lead_qualification` skill. Additive and reversible, so no approval gate.\n  ai: {\n    exposed: true,\n    description:\n      'Schedules the next follow-up task on a lead, assigned to its owner, so the next touch lands on the rep list.',\n  },\n};\n\n/**\n * Add selected leads to a Campaign.\n *\n * Script-typed action: collects a campaign id (param dialog) then writes one\n * `crm_campaign_member` record for the dispatched lead, skipping leads already\n * on the campaign. The chosen campaign arrives as `input.crm_campaign`; the\n * lead arrives as `ctx.recordId`.\n *\n * PER-RECORD dispatch, deliberately. `src/sales/views/lead.view.ts` wires this as the\n * BARE-STRING form \u2014 `bulkActions: ['create_campaign']` \u2014 and that string is a\n * dispatch contract, not a spelling of the other one:\n *\n *   - bare string    \u2192 the renderer promotes the action to a def carrying its\n *     own label / icon / params / `visible` and dispatches it ONCE PER selected\n *     row, each call carrying that row's `recordId` and NO selection array. A\n *     10-lead selection is 10 dispatches through this body, one lead each.\n *   - `bulkActionDefs` + `execution: 'aggregate'` \u2192 ONE dispatch for the whole\n *     selection, every id in the builtin `params._selectedIds` and no\n *     `recordId` (see `mass_update_stage` in `opportunity.actions.ts`).\n *\n * So multi-select enrollment already works here \u2014 it just arrives one lead at a\n * time. This body reads `ctx.recordId` and nothing else, which is exactly what\n * the fan-out delivers.\n *\n * \u26D4 Never add an `input.selectedIds` read (no underscore). Nothing can deliver\n * that key on either contract, so it is dead code and not a fallback: a\n * top-level `selectedIds` is never merged into the params bag, and a\n * `params.selectedIds` is refused by the strict params gate (ADR-0104) with\n * `Unknown action param \"selectedIds\" \u2014 not declared on this action`. The only\n * selection channel is the underscore-prefixed builtin, and only the aggregate\n * contract injects it (`@objectstack/spec` `ui/action-params.zod.ts`,\n * `ACTION_PARAM_BUILTIN_KEYS`).\n *\n * Switching this action to the aggregate contract would be a PRODUCT change \u2014\n * one audit entry and one dedupe read per run instead of per lead, and\n * all-or-nothing failure semantics \u2014 so it needs `lead.view.ts` changed with it\n * and is deliberately not done here.\n */\nexport const CreateCampaignAction: Action = {\n  name: 'create_campaign',\n  label: 'Add to Campaign',\n  objectName: 'crm_lead',\n  icon: 'send',\n  // script, not modal \u2014 a `type: 'modal'` action has NO server dispatch at all:\n  // the renderer just opens its `target`, and the runtime refuses it over REST\n  // (`headlessActionTypeError`, 400 \"a client-side action with no server\n  // dispatch\"), so its `body` never runs. To collect input and then run\n  // server-side, the shape is `type: 'script'` + `params` \u2014 the runner collects\n  // the same dialog. See ScheduleFollowUpAction.\n  type: 'script',\n  body: {\n    language: 'js',\n    source: `\n      // Value key = the param's field name ('crm_campaign') since the param\n      // omits an explicit 'name'. Insert uses the REAL lookup field names on\n      // crm_campaign_member (crm_campaign / crm_lead) \u2014 not the generic\n      // campaign_id / lead_id an earlier revision of the doc example taught,\n      // which don't exist here and left crm_campaign null \u2192 'Campaign required'\n      // validation failure.\n      const campaignId = input.crm_campaign ?? null;\n      if (!campaignId) throw new Error('create_campaign requires a campaign id');\n      // One lead per dispatch \u2014 the bare-string \\`bulkActions\\` wiring fans this\n      // body out once per selected row (see the note above). \\`ids\\` stays a\n      // list so the dedupe + skip loop below reads the same on both contracts,\n      // should this action ever move to an aggregate def.\n      const ids = ctx.recordId ? [ctx.recordId] : [];\n      if (!ids.length) throw new Error('create_campaign: no lead selected');\n      // Skip leads already on this campaign \u2014 the modal copy promises\n      // duplicates are skipped, and re-running the action on the same\n      // selection must not double-count marketing touches.\n      const raw = await ctx.api.object('crm_campaign_member').find({\n        where: { crm_campaign: campaignId },\n        fields: ['crm_lead'],\n        top: 5000,\n      });\n      const existingRows = Array.isArray(raw) ? raw : (raw?.records ?? []);\n      const existing = new Set(existingRows.map((r) => r.crm_lead));\n      const inserted = [];\n      let skipped = 0;\n      for (const leadId of ids) {\n        if (existing.has(leadId)) { skipped++; continue; }\n        const row = await ctx.api.object('crm_campaign_member').insert({\n          crm_campaign: campaignId,\n          crm_lead: leadId,\n          status: 'sent',\n        });\n        inserted.push(row?.id ?? null);\n      }\n      return { campaignId, count: inserted.length, skipped, ids: inserted };\n    `,\n    capabilities: ['api.read', 'api.write'],\n    timeoutMs: 10000,\n  },\n  // list_item gives every row a working record-scoped entry point. The\n  // list_toolbar button is single-record by construction: with no `_selectedIds`\n  // in the bag the dispatcher resolves a recordId from the grid selection, and a\n  // multi-row selection there is ambiguous, so it is refused client-side with\n  // \"This action runs on a single record \u2014 select exactly one row.\"\n  // Multi-lead enrollment is the SELECTION-BAR button instead, which the view's\n  // `bulkActions: ['create_campaign']` produces and which fans out per row.\n  locations: ['list_toolbar', 'list_item'],\n  params: [\n    // Field-backed param: `field` + `objectOverride` make the console resolve\n    // the widget from crm_campaign_member.crm_campaign (a lookup \u2192 crm_campaign),\n    // rendering a RECORD PICKER. A bare `{ type:'lookup' }` with no field can't\n    // resolve a target object and silently falls back to a paste-the-ID textbox.\n    {\n      field: 'crm_campaign',\n      objectOverride: 'crm_campaign_member',\n      label: 'Campaign',\n      required: true,\n    }\n  ],\n  successMessage: 'Leads added to campaign!',\n  refreshAfter: true,\n};\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/sales/actions/opportunity.actions.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/sales/actions\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/sales/actions/opportunity.actions.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport type { Action } from '@objectstack/spec/ui';\nimport { P } from '@objectstack/spec';\nimport { OPPORTUNITY_STAGE_OPTIONS, plainOptions } from '../objects/_picklists';\n\n/**\n * Clone Opportunity.\n *\n * Script-typed action: clones the current record into a new\n * `prospecting`-stage opportunity. Runs sandboxed under `api.read`\n * (to fetch the source) and `api.write` (to write the copy).\n */\nexport const CloneOpportunityAction: Action = {\n  name: 'clone_opportunity',\n  label: 'Clone Opportunity',\n  objectName: 'crm_opportunity',\n  icon: 'copy',\n  type: 'script',\n  body: {\n    language: 'js',\n    source: `\n      const id = ctx.recordId;\n      if (!id) throw new Error('clone_opportunity requires a recordId');\n      // Read the source from ctx.record (seeded by the runner for record-scoped\n      // actions \u2014 same source send_email uses). This avoids the in-sandbox\n      // find() that previously faulted, WHILE still copying the REQUIRED fields\n      // (crm_account / amount / close_date). The old minimal insert set only\n      // name+stage, so every clone failed the object's required-field + amount>0\n      // validations at runtime and no opportunity was ever created.\n      const src = ctx.record ?? {};\n      if (!src.crm_account) {\n        throw new Error('clone_opportunity: source account not loaded; cannot clone.');\n      }\n      // Give the clone a fresh 90-day close horizon so a copied past date can't\n      // trip the \"close date in the past\" validation on a new prospecting deal.\n      //\n      // The step is on the UTC calendar because the render below is\n      // (\\`toISOString()\\`). The base is \\`new Date()\\` \u2014 an instant, not a\n      // stored \\`YYYY-MM-DD\\` \u2014 so unlike quote.hook/task.hook there is no\n      // UTC-midnight anchor being read back on the wrong calendar here; the\n      // only mixture was the step itself. A local \\`getDate\\`/\\`setDate\\` step\n      // preserves WALL-CLOCK time, so a 90-day window containing a DST\n      // transition is 23 h or 25 h long and the rendered UTC day lands one off\n      // whenever the clone instant is within an hour of a UTC day boundary.\n      const horizon = new Date();\n      horizon.setUTCDate(horizon.getUTCDate() + 90);\n      const inserted = await ctx.api.object('crm_opportunity').insert({\n        name: 'Copy of ' + (src.name ?? ('opportunity ' + id)),\n        crm_account: src.crm_account,\n        primary_contact: src.primary_contact ?? null,\n        amount: src.amount ?? 1,\n        stage: 'prospecting',\n        probability: 10,\n        close_date: horizon.toISOString().slice(0, 10),\n        type: src.type ?? null,\n        lead_source: src.lead_source ?? null,\n        crm_campaign: src.crm_campaign ?? null,\n        // Explicit because an action body runs \\`isSystem\\`, so nothing stamps\n        // \\`owner_id\\` for it \u2014 see the note in activity-actions.ts (#548).\n        owner_id: ctx.user?.id ?? null,\n      });\n      return { id: inserted?.id ?? null };\n    `,\n    capabilities: ['api.read', 'api.write'],\n    timeoutMs: 5000,\n  },\n  locations: ['record_header', 'record_more'],\n  successMessage: 'Opportunity cloned successfully!',\n  refreshAfter: true,\n};\n\n/**\n * Mass Update Opportunity Stage.\n *\n * Both invocation halves work:\n *\n *   - SINGLE record (row selection / toolbar with one row): the console POSTs\n *     `{ recordId, params: { stage } }` and the body reads `ctx.recordId`.\n *   - MULTI record: the selection arrives in the BUILT-IN `_selectedIds`\n *     param \u2014 leading underscore \u2014 injected by the grid renderer for the\n *     view's `bulkActionDefs` entry with `execution: 'aggregate'`, which\n *     dispatches this action ONCE for the whole selection (no `recordId`).\n *\n * That underscore is the whole of the contract. A script body's `input` IS the\n * action's params bag (`@objectstack/runtime` `sandbox/body-runner.ts:338`), and\n * `_selectedIds` is one of the params gate's builtin keys (`@objectstack/spec`\n * `ui/action-params.zod.ts:70`, alongside `recordId` / `objectName`). Every\n * other shape is undeclared and cannot arrive: a top-level `selectedIds` is\n * never merged into the bag, and a `params.selectedIds` without the underscore\n * is refused by the strict params gate (ADR-0104). The console's own \"select\n * exactly one row\" toast fires precisely when `_selectedIds` was NOT injected,\n * which is what happens to a view carrying no bulk declaration at all \u2014 read\n * that toast as a missing declaration on the view, never as a platform limit.\n *\n * \u26D4 Do NOT declare `_selectedIds` in `params` below: builtin keys are injected\n * by the renderer, and the gate admits them without a declaration (declaring one\n * is not a supported authoring move). \u26D4 Do NOT re-add a no-underscore\n * `input.selectedIds` read either \u2014 nothing can deliver that key, so it would\n * be a limb that only ever reads `undefined`.\n */\nexport const MassUpdateStageAction: Action = {\n  name: 'mass_update_stage',\n  label: 'Update Stage',\n  objectName: 'crm_opportunity',\n  icon: 'layers',\n  type: 'script',\n  body: {\n    language: 'js',\n    source: `\n      const newStage = input.stage ?? null;\n      if (!newStage) throw new Error('mass_update_stage requires a stage');\n      // Selection first, single record as the fallback. An aggregate dispatch\n      // carries the whole selection in \\`_selectedIds\\` and NO recordId; a\n      // single-record dispatch carries recordId and no selection. The two are\n      // never both present, so the order only decides which shape wins if the\n      // platform ever sends both.\n      const selected = Array.isArray(input._selectedIds) ? input._selectedIds : [];\n      const ids = selected.length ? selected : (ctx.recordId ? [ctx.recordId] : []);\n      if (!ids.length) throw new Error('mass_update_stage: no opportunity selected');\n      const missed = [];\n      let firstCause = '';\n      let updated = 0;\n      for (const id of ids) {\n        // \\`update(data, options)\\` \u2014 \\`ctx.api\\` is the engine repo facade, whose\n        // update takes a DOCUMENT, not an id. \\`updateById(id, data)\\` exists on\n        // ObjectRepository but NOT on the facade the runtime builds when it has\n        // no scoped context, so this spelling is the only one live on both.\n        //\n        // An id that matches no row is a MISS, not an abort, and the engine has\n        // answered it both ways: through @objectstack/* 17.0.0-rc.6 \\`update\\`\n        // RESOLVED WITH NULL, and from 17.0.0 it REJECTS (RECORD_NOT_FOUND /\n        // 404). Both are handled here, and neither may end the loop \u2014 an\n        // uncaught rejection on the first stale id would leave every id after\n        // it unattempted, so re-running the action over the same selection\n        // would fail at the same row forever and the live rows behind it could\n        // never be covered. That is strictly worse than the silent-success\n        // failure #588 pulled this button for, because it is unrecoverable\n        // from the UI. Collect the miss, keep going, reject once at the end.\n        //\n        // The catch is deliberately cause-AGNOSTIC \u2014 but NOT because the cause\n        // is invisible. Read on 17.4.0 (\\`hostErrorToVm\\`; not re-read on 17.5.0), a host\n        // rejection reaches a body as \\`name\\` and \\`message\\` plus, when the host\n        // error carries them, \\`code\\`, \\`status\\`, \\`fields\\` and \\`userMessage\\` \u2014\n        // nothing else, so a stale id arrives branchable as\n        // \\`code === 'RECORD_NOT_FOUND'\\` while \\`details\\` really is dropped. The\n        // branch is not taken because every cause has the same outcome here \u2014\n        // the row did not move, so collect it and keep going \u2014 and narrowing\n        // the catch to a roster of known codes would let an unlisted cause\n        // abort the loop, the failure the paragraph above forbids. Message text\n        // is engine wording and not contract, so \\`firstCause\\` is carried\n        // verbatim and never parsed.\n        let row = null;\n        try {\n          row = await ctx.api.object('crm_opportunity').update(\n            { id: id, stage: newStage },\n            { where: { id: id } },\n          );\n        } catch (err) {\n          row = null;\n          if (!firstCause) firstCause = (err && err.message) ? String(err.message) : String(err);\n        }\n        // Count only what came back: counting the ATTEMPT is how a stale or\n        // invisible id turns into a success toast for a write that never\n        // happened (#588).\n        if (row) { updated++; } else { missed.push(id); }\n      }\n      // Aggregate dispatch is all-or-nothing (objectui#3139): a handler that\n      // cannot cover the whole selection must reject rather than report partial\n      // work, because the bar offers no per-row retry \u2014 the retry IS re-running\n      // the action over the selection, which is safe here since setting a stage\n      // is idempotent. Rows already moved in this run keep the new stage; the\n      // error names the ones that did not so the rep can see the difference.\n      if (missed.length) {\n        throw new Error(\n          'mass_update_stage: ' + missed.length + ' of ' + ids.length\n          + ' selected opportunities could not be updated (' + missed.join(', ')\n          + '). Re-run the action on the selection to retry.'\n          + (firstCause ? ' First cause: ' + firstCause : '')\n        );\n      }\n      return { stage: newStage, updated };\n    `,\n    capabilities: ['api.write'],\n    timeoutMs: 10000,\n  },\n  locations: ['list_toolbar'],\n  params: [\n    {\n      name: 'stage',\n      label: 'New Stage',\n      type: 'select',\n      required: true,\n      // Mirrors crm_opportunity.stage exactly \u2014 see _picklists.ts.\n      options: plainOptions(OPPORTUNITY_STAGE_OPTIONS),\n    }\n  ],\n  successMessage: 'Opportunities updated successfully!',\n  refreshAfter: true,\n};\n\n/**\n * Generate a Quote from this Opportunity.\n *\n * Flow-typed action: launches the `quote_generation` screen flow (name,\n * validity, discount) which creates the draft crm_quote and moves the deal\n * to `proposal`. Without this action the flow was unreachable from the UI \u2014\n * the CPQ leg (opportunity \u2192 quote) had no entry point.\n */\nexport const GenerateQuoteAction: Action = {\n  name: 'generate_quote',\n  label: 'Generate Quote',\n  objectName: 'crm_opportunity',\n  icon: 'receipt',\n  type: 'flow',\n  target: 'quote_generation',\n  // Mirror clone_opportunity's placement (header + overflow menu) so the action\n  // is reachable both as a primary button and from the \"\u2026\" menu on narrow\n  // viewports where the header collapses.\n  locations: ['record_header', 'record_more', 'list_item'],\n  visible: P`has(record.stage) && record.stage != \"closed_won\" && record.stage != \"closed_lost\"`,\n  successMessage: 'Quote created from opportunity!',\n  refreshAfter: true,\n};\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/marketing/actions/index.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/marketing/actions\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/marketing/actions/index.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\n/**\n * Marketing action barrel.\n *\n * The doctrine for this metadata type is written once, in\n * `src/sales/actions/index.ts`; this file is the marketing package's half of\n * the same file-by-file registration.\n */\nexport { EnrollLeadsAction, MarkRespondedAction } from './campaign.actions';\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/marketing/actions/campaign.actions.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/marketing/actions\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/marketing/actions/campaign.actions.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport type { Action } from '@objectstack/spec/ui';\nimport { P } from '@objectstack/spec';\n\n/**\n * Enroll leads or contacts into this campaign.\n *\n * Flow-typed action: launches the `campaign_enrollment` screen flow (pick the\n * member side and its segment, enroll everyone eligible). This action is the\n * flow's entry point, following the proven `convert_lead` / `generate_quote`\n * pattern \u2014 the console's flow-action trigger sends `{ recordId, objectName }`.\n *\n * \u26D4 Never rename `enroll_leads` to match the \"Enroll Members\" label. An action\n * name is a dispatch identifier that views, docs and the audit trail reference\n * by string; the label already carries the word correctly.\n */\nexport const EnrollLeadsAction: Action = {\n  name: 'enroll_leads',\n  label: 'Enroll Members',\n  objectName: 'crm_campaign',\n  icon: 'user-plus',\n  type: 'flow',\n  target: 'campaign_enrollment',\n  locations: ['record_header', 'record_more'],\n  // Enrollment only makes sense while the campaign is open \u2014 the flow\n  // double-checks this server-side.\n  visible: P`has(record.status) && (record.status == \"planning\" || record.status == \"in_progress\")`,\n  successMessage: 'Eligible members enrolled in campaign.',\n  refreshAfter: true,\n};\n\n/**\n * Mark a campaign member as having responded.\n *\n * The writer for the `responded` status, on the member row rather than on the\n * campaign: a rep hears back from one person, and one membership changes.\n * `num_responses` and `response_rate` are computed off that status, so an app\n * with no writer for it reports a structural zero on every campaign.\n *\n * The body stamps all three response fields together, rather than relying on\n * `campaign_member_lifecycle` to back-fill two of them. Both paths are\n * exercised (a rep can also flip `status` on the record itself, which the hook\n * catches) but an action that writes a status and leaves the record internally\n * inconsistent for the length of a hook dispatch is a shape the detail page can\n * render mid-flight, and this one is cheap to get right at the source.\n *\n * `record_header` + `list_item`: `crm_campaign_member` ships no view of its\n * own \u2014 its rows are surfaced by the members related list on a campaign's\n * detail page (columns come from `highlightFields`), and `list_item` is the\n * per-row entry point there.\n */\nexport const MarkRespondedAction: Action = {\n  name: 'mark_responded',\n  label: 'Mark Responded',\n  objectName: 'crm_campaign_member',\n  icon: 'reply',\n  // script, not modal \u2014 a `type: 'modal'` action has no server dispatch at all\n  // and its body never runs (see `create_campaign`'s note in lead.actions.ts).\n  type: 'script',\n  body: {\n    language: 'js',\n    source: `\n      const id = ctx.recordId;\n      if (!id) throw new Error('mark_responded requires a recordId');\n      const respondedAt = new Date().toISOString();\n      await ctx.api.object('crm_campaign_member').update(\n        { id, status: 'responded', has_responded: true, response_date: respondedAt },\n        { where: { id } },\n      );\n      return { id, status: 'responded', response_date: respondedAt };\n    `,\n    capabilities: ['api.write'],\n    timeoutMs: 5000,\n  },\n  locations: ['record_header', 'list_item'],\n  // Already-responded and converted members have nothing to record; an\n  // unsubscribed member must not be dragged back into the funnel by a\n  // mis-click (`campaign_member_optout_sync` has already opted that person out\n  // of email, and this action would not undo that \u2014 leaving the two records\n  // disagreeing about the same person).\n  visible: P`has(record.status) && record.status == \"sent\"`,\n  successMessage: 'Response recorded on this campaign member.',\n  refreshAfter: true,\n};\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/sales/dashboards/index.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/sales/dashboards\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/sales/dashboards/index.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\n/**\n * Dashboard Definitions Barrel\n *\n * ## Two i18n surfaces on a dashboard, and only one of them resolves (#1822)\n *\n * `@objectstack/spec` types BOTH `GlobalFilterSchema.label` and\n * `ChartAxisSchema.title` as `I18nLabelSchema` \u2014 `z.union([z.string(),\n * InlineLocaleMapSchema])` \u2014 so both accept `{ en, 'zh-CN', \u2026 }`. Only the\n * filter half is resolved against the viewer's locale. Measured on\n * `@objectstack/console@17.4.0`, driving the real Console in Chromium, not\n * read off a docblock:\n *\n *   - FILTER `label` and static option `label` \u2192 locale-aware. The renderer\n *     calls the inline-map resolver with the active language, so `zh-CN`\n *     renders the `zh-CN` value and `ja-JP` the `ja-JP` one. This is the\n *     spelling every `globalFilters[]` entry in this folder uses.\n *   - AXIS `title` \u2192 NOT locale-aware on 17.4.0 (the axis normaliser took the\n *     map's FIRST value, whatever the viewer's locale). Since\n *     `@objectstack/spec@17.5.0` the question no longer arises for this\n *     folder: a dataset-bound widget's `chartConfig` refuses `type`, `xAxis`,\n *     `yAxis` and `series` (ADR-0021 \u00B7 ADR-0049 D2) \u2014 the widget's `type`,\n *     `dimensions` and `values` are the only binding \u2014 so no widget here\n *     carries an axis title any more.\n *\n * \u26A0\uFE0F `GlobalFilterSchema.object` \u2014 documented upstream as resolving a\n * filter's field and option labels through `fields.<object>.<field>` \u2014 is\n * INERT in this Console build. Measured: a filter carrying `object` and no\n * `label` rendered the raw field name (`type`, not \u7C7B\u578B) and left its option\n * labels English. The definition builder never copies `object` out of the\n * authored filter. \u26D4 Do not reach for it instead of an inline map.\n */\n\nexport { ActivityDashboard } from './activity.dashboard';\nexport { CrmOverviewDashboard } from './crm.dashboard';\nexport { ExecutiveDashboard } from './executive.dashboard';\nexport { SalesDashboard } from './sales.dashboard';\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/sales/dashboards/activity.dashboard.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/sales/dashboards\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/sales/dashboards/activity.dashboard.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport type { Dashboard } from '@objectstack/spec/ui';\n\n/**\n * Sales Activity & Customer Health Dashboard (#592).\n *\n * The app had **no activity metric of any kind**: calls per rep, meetings\n * booked and activity per deal were unanswerable because the only trace of an\n * interaction was a `sys_activity` row with the interesting part inside a JSON\n * string, and `task_metrics` had shipped with no widget using it at all. This\n * dashboard is what `crm_event` makes possible, and it is where the churn story\n * finally has numbers behind it.\n *\n * # No `dateRange`, deliberately \u2014 a design choice, not a blocked one\n *\n * `crm_event.start_datetime` is a `Field.datetime()`, the exact column shape\n * that once zeroed the Service dashboard (#460): `driver-sql` 16.1.0 coerced a\n * datetime filter bound to epoch-millisecond INTEGER while every datetime in\n * the database is ISO TEXT, and SQLite orders every INTEGER before every TEXT \u2014\n * so `$gte` matched every row (no floor) and `$lte` matched none (empty\n * dashboard). That is history, not a live constraint. Both named preconditions\n * are fixed and released: objectstack#3912 (the coercion) and objectstack#3777\n * (a bare-date `$lte` dropping same-day rows) \u2014 both under the **17.0.0**\n * heading of the installed `driver-sql` and `service-analytics` CHANGELOGs,\n * and every pin since 17.0.0 carries both. `service.dashboard.ts` records\n * the same two\n * closures, which is why #1157 restored the Service picker; the two files\n * agree, and neither states an upstream fix as an unmet precondition.\n *\n * The reason this dashboard still carries no picker is therefore a PRODUCT\n * one, and it stands on its own: both questions a date range would answer are\n * already answered here, by widgets a dashboard range would narrow rather than\n * serve \u2014 the runtime ANDs `dateRange` into every widget query.\n *\n *   - The trend is on an AXIS, not in a filter. `activity_by_week` groups on\n *     the `event_metrics.start_datetime` dimension, which declares\n *     `dateGranularity: 'week'`; \"is the team speeding up or going quiet?\" is\n *     read ACROSS the history, so a picker would truncate the axis that is the\n *     whole point of the chart.\n *   - Recency is already SELF-SCOPED. The three quiet-account tiles each carry\n *     their own window on `crm_account.last_activity_date` \u2014 `$lt`\n *     `{30_days_ago}` / `{60_days_ago}` / `{90_days_ago}` \u2014 and \"quiet for 90\n *     days\" means ninety days, not ninety days re-cut by whatever the picker\n *     says. On the sibling dashboards that DO have one, that is spelled\n *     `filterBindings: { dateRange: false }`; here it would have to be spelled\n *     on every tile that matters.\n *\n * \u21D2 Adding a picker is a product judgement to be made on its merits, not a\n * platform unblock to be collected. If it is ever made, the work is a\n * `dateRange` plus explicit `filterBindings` opt-outs on the widgets above.\n *\n * No KPI tile declares a `trend`: a period-over-period delta is a measurement\n * and has to come from a real comparison query, not from a number typed by\n * hand (#500, #587).\n */\nexport const ActivityDashboard: Dashboard = {\n  name: 'sales_activity_dashboard',\n  label: 'Sales Activity',\n  description: 'Who is talking to customers, how often, and which accounts have gone quiet',\n\n  columns: 12,\n  gap: 4,\n  refreshIntervalSeconds: 300,\n\n  header: {\n    showTitle: true,\n    showDescription: true,\n  },\n\n  globalFilters: [\n    {\n      field: 'owner_id',\n      label: { en: 'Rep', 'zh-CN': '\u9500\u552E\u4EE3\u8868', 'es-ES': 'Representante', 'ja-JP': '\u62C5\u5F53\u8005' },\n      type: 'lookup',\n      scope: 'dashboard',\n      optionsFrom: { object: 'sys_user', valueField: 'id', labelField: 'name' },\n    },\n  ],\n\n  widgets: [\n    // \u2500\u2500\u2500 Row 1: what happened, and what is booked \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n    {\n      id: 'interactions_held',\n      title: 'Interactions Logged',\n      description: 'Calls and meetings that actually happened',\n      type: 'metric',\n      filter: { status: 'held' },\n      colorVariant: 'success',\n      dataset: 'event_metrics', values: ['event_count'],\n      layout: { x: 0, y: 0, w: 3, h: 2 },\n    },\n    {\n      id: 'meetings_booked',\n      title: 'Meetings Booked',\n      description: 'Meetings on the calendar that have not happened yet',\n      type: 'metric',\n      filter: { status: 'planned', type: 'meeting' },\n      colorVariant: 'blue',\n      dataset: 'event_metrics', values: ['event_count'],\n      layout: { x: 3, y: 0, w: 3, h: 2 },\n    },\n    {\n      id: 'customer_minutes',\n      title: 'Customer Minutes',\n      description: 'Total time spent in front of customers',\n      type: 'metric',\n      filter: { status: 'held' },\n      colorVariant: 'purple',\n      dataset: 'event_metrics', values: ['total_minutes'],\n      layout: { x: 6, y: 0, w: 3, h: 2 },\n    },\n    {\n      // First widget in the app to use `task_metrics`. The dataset shipped with\n      // the \"My Day\" work and then had no consumer at all (#592) \u2014 a semantic\n      // layer nobody queries is a maintenance cost with no reader.\n      id: 'tasks_completed',\n      title: 'Tasks Completed',\n      description: 'Follow-ups closed out \u2014 the other half of activity',\n      type: 'metric',\n      filter: { is_completed: true },\n      colorVariant: 'orange',\n      dataset: 'task_metrics', values: ['task_count'],\n      layout: { x: 9, y: 0, w: 3, h: 2 },\n    },\n\n    // \u2500\u2500\u2500 Row 2: who, and when \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n    {\n      id: 'activity_by_rep',\n      title: 'Activity by Rep',\n      description: 'Logged interactions per owner \u2014 the coverage question',\n      type: 'bar',\n      filter: { status: 'held' },\n      colorVariant: 'success',\n      dataset: 'event_metrics', dimensions: ['owner'], values: ['event_count'],\n      layout: { x: 0, y: 2, w: 6, h: 4 },\n      chartConfig: {\n        showLegend: false,\n        showDataLabels: true,\n        colors: ['#10B981'],\n      },\n    },\n    {\n      id: 'activity_by_week',\n      title: 'Activity Volume by Week',\n      description: 'Interactions per week \u2014 is the team speeding up or going quiet?',\n      type: 'area',\n      filter: { status: 'held' },\n      colorVariant: 'blue',\n      // The week bucket lives on the DIMENSION, not in a filter \u2014 see the\n      // header note on why the trend belongs on an axis here. The datetime\n      // filter bound itself works (objectstack#3912 / #3777, 17.0.0); putting\n      // the trend in a filter would narrow it, which is a different objection.\n      dataset: 'event_metrics', dimensions: ['start_datetime'], values: ['event_count'],\n      layout: { x: 6, y: 2, w: 6, h: 4 },\n      chartConfig: {\n        showLegend: false,\n        showDataLabels: false,\n        colors: ['#0EA5E9'],\n        interaction: { tooltips: true, brush: true },\n      },\n    },\n\n    // \u2500\u2500\u2500 Row 3: what the activity is about \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n    {\n      id: 'activity_mix',\n      title: 'Activity Mix',\n      description: 'Calls vs meetings vs demos',\n      type: 'donut',\n      filter: { status: 'held' },\n      colorVariant: 'purple',\n      dataset: 'event_metrics', dimensions: ['type'], values: ['event_count'],\n      layout: { x: 0, y: 6, w: 4, h: 4 },\n      chartConfig: {\n        showLegend: true,\n        showDataLabels: true,\n        colors: ['#4169E1', '#10B981', '#8B5CF6', '#F59E0B', '#0EA5E9', '#94A3B8'],\n      },\n    },\n    {\n      id: 'activity_by_record_type',\n      title: 'Where the Activity Lands',\n      description: 'Which part of the funnel is getting attention',\n      type: 'bar',\n      filter: { status: 'held' },\n      colorVariant: 'blue',\n      dataset: 'event_metrics', dimensions: ['related_to_type'], values: ['event_count'],\n      layout: { x: 4, y: 6, w: 4, h: 4 },\n      chartConfig: {\n        showLegend: false,\n        showDataLabels: true,\n        colors: ['#4169E1'],\n      },\n    },\n    {\n      // \"Activity per open deal\" as two honest numbers rather than one\n      // fabricated ratio: the semantic layer has no cross-dataset calculated\n      // measure, so a single \"1.8 activities/deal\" tile would have to be\n      // computed by the renderer over two independent queries \u2014 which nothing\n      // does today. A manager reads the pair; a made-up quotient would read as\n      // measured. Filed as a follow-up rather than faked here.\n      id: 'deal_activity',\n      title: 'Interactions on Deals',\n      description: 'Logged interactions linked to an opportunity \u2014 read against Open Deals \u2192',\n      type: 'metric',\n      filter: { status: 'held', related_to_type: 'crm_opportunity' },\n      colorVariant: 'success',\n      dataset: 'event_metrics', values: ['event_count'],\n      layout: { x: 8, y: 6, w: 2, h: 4 },\n    },\n    {\n      id: 'open_deals_for_activity',\n      title: 'Open Deals',\n      description: 'Opportunities still in play',\n      type: 'metric',\n      filter: { stage: { $nin: ['closed_won', 'closed_lost'] } },\n      colorVariant: 'blue',\n      dataset: 'opportunity_metrics', values: ['opp_count'],\n      layout: { x: 10, y: 6, w: 2, h: 4 },\n    },\n\n    // \u2500\u2500\u2500 Row 4: the churn story, now backed by a real signal \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n    // These window `crm_account.last_activity_date`, which is a `Field.date()`\n    // (TEXT `YYYY-MM-DD`) \u2014 the same shape `customer_churn_signals` already\n    // filters safely. Until #592 the column was written by nothing at all: the\n    // bubble that fed it was silently discarded on every invocation because\n    // the field was `readonly` (#2948). These three tiles are the reason that\n    // mattered.\n    {\n      id: 'quiet_accounts_30',\n      title: 'Quiet 30+ Days',\n      description: 'Active accounts with no logged interaction in a month',\n      type: 'metric',\n      filter: { is_active: true, last_activity_date: { $lt: '{30_days_ago}' } },\n      colorVariant: 'warning',\n      dataset: 'account_metrics', values: ['account_count'],\n      layout: { x: 0, y: 10, w: 4, h: 2 },\n    },\n    {\n      id: 'quiet_accounts_60',\n      title: 'Quiet 60+ Days',\n      description: 'Two months of silence \u2014 the at-risk threshold',\n      type: 'metric',\n      filter: { is_active: true, last_activity_date: { $lt: '{60_days_ago}' } },\n      colorVariant: 'orange',\n      dataset: 'account_metrics', values: ['account_count'],\n      layout: { x: 4, y: 10, w: 4, h: 2 },\n    },\n    {\n      id: 'quiet_accounts_90',\n      title: 'Quiet 90+ Days',\n      description: 'A quarter with no contact \u2014 intervene or write it off',\n      type: 'metric',\n      filter: { is_active: true, last_activity_date: { $lt: '{90_days_ago}' } },\n      colorVariant: 'danger',\n      dataset: 'account_metrics', values: ['account_count'],\n      layout: { x: 8, y: 10, w: 4, h: 2 },\n    },\n  ],\n};\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/sales/dashboards/shared-widgets.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/sales/dashboards\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/sales/dashboards/shared-widgets.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport type { Dashboard } from '@objectstack/spec/ui';\n\ntype Widget = Dashboard['widgets'][number];\ntype WidgetLayout = Widget['layout'];\n\n/**\n * Widgets shared verbatim across dashboards.\n *\n * The pipeline funnel appeared word-for-word in the CRM, Sales and Executive\n * dashboards, and the avg-deal-size KPI in CRM and Sales \u2014 three copies of\n * \"what counts as open pipeline\" that could (and did) drift independently.\n * Each factory owns the semantic definition once; callers position it with\n * `layout` and may narrow presentation-only details via `overrides`.\n */\n\n/**\n * Open-pipeline funnel by sales stage \u2014 identical semantics everywhere.\n *\n * No `chartConfig`: a dataset-bound widget is painted with the console's own\n * theme tokens, so the palette this factory used to declare never applied.\n * Verified in the browser against 16.1.0 \u2014 every fill in the rendered funnel is\n * `hsl(var(--chart-1))` \u2026 `hsl(var(--chart-5))`, and none of the five hex colors\n * (`#0EA5E9` \u2026 `#22C55E`) reaches the DOM. Keeping the block would leave\n * decoration that reads as if it were in effect (#500).\n *\n * No `colorVariant` either, on the same evidence: the executive dashboard's KPI\n * tiles declare four different variants (`success`, `blue`, `purple`, `orange`)\n * and render with byte-identical background, border and value colours.\n */\nexport const pipelineByStageFunnelWidget = (layout: WidgetLayout): Widget => ({\n  id: 'pipeline_by_stage',\n  title: 'Pipeline by Stage',\n  description: 'Open opportunity value at each sales stage',\n  type: 'funnel',\n  filter: { stage: { $nin: ['closed_won', 'closed_lost'] } },\n  dataset: 'opportunity_metrics', dimensions: ['stage'], values: ['total_amount'],\n  layout,\n  suppressWarnings: ['chart-config-missing'], // intentional default rendering\n});\n\n/**\n * Avg-deal-size KPI over closed-won deals. The measure is fixed; the time\n * scoping legitimately differs per dashboard (CRM follows the dashboard date\n * picker, Sales pins itself to QTD), so callers pass it in.\n *\n * No drill-through: `/reports/avg-deal-size` matched no registered report, and\n * no report covers average deal size, so the button was dead on every dashboard\n * that used this factory (#527). Re-add one here when such a report ships \u2014\n * sharing the widget means sharing the fix.\n */\nexport const avgDealSizeMetricWidget = (\n  layout: WidgetLayout,\n  overrides: Partial<Widget> = {},\n): Widget => ({\n  id: 'avg_deal_size',\n  title: 'Avg Deal Size',\n  description: 'Average value of closed-won deals',\n  type: 'metric',\n  filter: { stage: 'closed_won' },\n  colorVariant: 'orange',\n  dataset: 'opportunity_metrics', values: ['avg_amount'],\n  layout,\n  ...overrides,\n});\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/sales/dashboards/crm.dashboard.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/sales/dashboards\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/sales/dashboards/crm.dashboard.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport type { Dashboard } from '@objectstack/spec/ui';\nimport { avgDealSizeMetricWidget, pipelineByStageFunnelWidget } from './shared-widgets';\n\n/**\n * CRM Overview Dashboard\n *\n * Single-page snapshot of revenue, pipeline, and customer activity. Designed\n * to mirror the polished CRM dashboard reference at\n * https://github.com/objectstack-ai/objectui/tree/main/examples/crm/src/dashboards\n * \u2014 KPI tiles, an area-chart revenue trend, a lead-source donut, a\n * pipeline funnel, and a recent-deals table.\n *\n * This dashboard intentionally uses the framework's first-class metadata fields\n * (colorVariant, chartConfig, header, dateRange, descriptions, action buttons)\n * rather than ad-hoc hex strings stuffed into `options.color`.\n *\n * No KPI tile declares a `trend`. A period-over-period delta is a measurement,\n * so it has to come from a real comparison query (widget `compareTo`) once the\n * renderer supports it for dataset metrics \u2014 the percentages this file used to\n * carry were typed by hand and recomputed by nothing, so they kept asserting\n * the same \"+12.5% vs last month\" on any data, including an empty database.\n * Same rule as the executive dashboard (#500, #587).\n */\nexport const CrmOverviewDashboard: Dashboard = {\n  name: 'crm_overview_dashboard',\n  label: 'CRM Overview',\n  description: 'Revenue metrics, pipeline analytics, and deal insights',\n\n  columns: 12,\n  gap: 4,\n  refreshIntervalSeconds: 300,\n\n  header: {\n    showTitle: true,\n    showDescription: true,\n    // Header action buttons removed: `create_opportunity` / `create_lead` are not\n    // defined actions and `/reports` is not an in-app view route \u2014 all three were\n    // dead. Re-add real, wired-up actions here when available.\n  },\n\n  dateRange: {\n    field: 'close_date',\n    defaultRange: 'this_quarter',\n    allowCustomRange: true,\n  },\n\n  globalFilters: [\n    {\n      field: 'owner_id',\n      label: { en: 'Owner', 'zh-CN': '\u8D1F\u8D23\u4EBA', 'es-ES': 'Responsable', 'ja-JP': '\u62C5\u5F53\u8005' },\n      type: 'lookup',\n      scope: 'dashboard',\n      optionsFrom: { object: 'sys_user', valueField: 'id', labelField: 'name' },\n    },\n  ],\n\n  widgets: [\n    // \u2500\u2500\u2500 KPI Row \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n    {\n      id: 'total_revenue',\n      title: 'Total Revenue',\n      description: 'Closed-won revenue this period',\n      type: 'metric',\n      filter: { stage: 'closed_won' },\n      colorVariant: 'success',\n      dataset: 'opportunity_metrics', values: ['total_amount'],\n      layout: { x: 0, y: 0, w: 3, h: 2 },\n    },\n    {\n      id: 'active_deals',\n      title: 'Active Deals',\n      description: 'Open opportunities in the pipeline',\n      type: 'metric',\n      filter: { stage: { $nin: ['closed_won', 'closed_lost'] } },\n      colorVariant: 'blue',\n      dataset: 'opportunity_metrics', values: ['opp_count'],\n      layout: { x: 3, y: 0, w: 3, h: 2 },\n    },\n    {\n      id: 'won_deals',\n      title: 'Won Deals',\n      description: 'Closed-won deals this period',\n      type: 'metric',\n      filter: { stage: 'closed_won' },\n      colorVariant: 'purple',\n      dataset: 'opportunity_metrics', values: ['opp_count'],\n      layout: { x: 6, y: 0, w: 3, h: 2 },\n    },\n    // No overrides left once the fabricated trend is gone.\n    avgDealSizeMetricWidget({ x: 9, y: 0, w: 3, h: 2 }),\n\n    // \u2500\u2500\u2500 Charts Row 1 \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n    {\n      id: 'revenue_trends',\n      title: 'Revenue Trends',\n      description: 'Closed-won revenue over the last 12 months',\n      type: 'area',\n      filter: { stage: 'closed_won', close_date: { $gte: '{12_months_ago}' } },\n      filterBindings: { dateRange: false }, // self-scoped to 12 months \u2014 the date picker must not narrow it\n      colorVariant: 'success',\n      dataset: 'opportunity_metrics', dimensions: ['close_date'], values: ['total_amount'],\n      layout: { x: 0, y: 2, w: 9, h: 4 },\n      chartConfig: {\n        showLegend: false,\n        showDataLabels: false,\n        colors: ['#10B981'],\n        interaction: { tooltips: true, brush: true },\n      },\n      options: { dateGranularity: 'month' },\n    },\n    {\n      id: 'lead_source',\n      title: 'Lead Source',\n      description: 'Pipeline value by acquisition channel',\n      type: 'donut',\n      colorVariant: 'purple',\n      dataset: 'opportunity_metrics', dimensions: ['lead_source'], values: ['total_amount'],\n      layout: { x: 9, y: 2, w: 3, h: 4 },\n      chartConfig: {\n        showLegend: true,\n        showDataLabels: true,\n        colors: ['#4F46E5', '#06B6D4', '#10B981', '#F59E0B', '#EF4444', '#8B5CF6'],\n      },\n    },\n\n    // \u2500\u2500\u2500 Charts Row 2 \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n    pipelineByStageFunnelWidget({ x: 0, y: 6, w: 6, h: 4 }),\n    {\n      id: 'top_products',\n      title: 'Top Products',\n      description: 'Total list-price revenue by product category',\n      type: 'bar',\n      colorVariant: 'blue',\n      // crm_product has no `close_date`, so the date picker would fail it with\n      // `no such column`. ObjectStack 15 (framework#2501) injects every dashboard\n      // filter (dateRange + globalFilters) into each widget's query.\n      // The `owner_id` opt-out is SEMANTIC, not structural: since #548 every\n      // business object carries the injected `owner_id`, so the filter would now\n      // resolve \u2014 it just means nothing on a shared product catalog, where the\n      // column records whoever created the entry.\n      filterBindings: { dateRange: false, owner_id: false },\n      dataset: 'product_metrics', dimensions: ['category'], values: ['list_price_sum'],\n      layout: { x: 6, y: 6, w: 6, h: 4 },\n      chartConfig: {\n        showLegend: false,\n        showDataLabels: true,\n        colors: ['#4F46E5'],\n      },\n    },\n\n    // \u2500\u2500\u2500 Pipeline by Owner \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n    // A dashboard `table` binds to an analytics dataset (a cube), so it must\n    // aggregate \u2014 it cannot list raw records (ADR-0021). The previous\n    // \"Recent Opportunities\" table selected only the `opp_count` measure with\n    // no dimension, which renders a single summary row, not a per-deal list.\n    // For a true per-record listing, surface an object-bound ListView through\n    // app navigation instead (ADR-0017). Here we group by owner for a rep\n    // pipeline breakdown that renders one row per owner.\n    {\n      id: 'pipeline_by_owner',\n      title: 'Pipeline by Owner',\n      description: 'Open pipeline value and deal count per sales rep',\n      type: 'table',\n      filter: { stage: { $nin: ['closed_won', 'closed_lost'] } },\n      colorVariant: 'default',\n      dataset: 'opportunity_metrics', dimensions: ['owner'], values: ['total_amount', 'opp_count', 'avg_amount'],\n      layout: { x: 0, y: 10, w: 12, h: 4 },\n      options: {\n        sortBy: 'total_amount',\n        sortOrder: 'desc',\n        limit: 10,\n      },\n    },\n  ],\n};\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/sales/dashboards/executive.dashboard.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/sales/dashboards\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/sales/dashboards/executive.dashboard.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport type { Dashboard, InlineLocaleMap } from '@objectstack/spec/ui';\nimport { LEAD_SOURCE_OPTIONS } from '../objects/_picklists';\nimport { pipelineByStageFunnelWidget } from './shared-widgets';\n\n/**\n * `lead_source` filter option labels, keyed by the CANONICAL stored value.\n *\n * Only the WORDING is written here. The ROSTER is derived below from\n * {@link LEAD_SOURCE_OPTIONS} \u2014 the one constant `crm_lead`, `crm_contact` and\n * `crm_opportunity` each spread into their own `lead_source` field \u2014 so this\n * control can only ever offer values a record can actually hold. It used to\n * hand-copy six of the twelve, and one of those six was spelled `advertising`\n * against a canonical `advertisement`: picking it ANDed a term no row matches\n * into every bound widget and the whole dashboard read zero with no error and\n * no empty state (#1849).\n *\n * A value added to the constant with no row here renders `label: undefined`,\n * which `pnpm validate` rejects by name \u2014 the roster cannot drift back\n * silently, which is the property a second hand-copy could not have.\n *\n * The strings are the language packs' own, copied from\n * `src/sales/translations/<locale>/objects.pipeline.ts`\n * (`crm_lead.fields.lead_source.options`; ja-JP resolves them through\n * `src/sales/translations/ja-JP/_shared.ts`), so the filter bar does not coin a\n * second vocabulary for a value the record page already labels. They are\n * spelled inline rather than reached through `GlobalFilterSchema.object`,\n * which is inert in this Console build \u2014 measured on #1822, see `./index.ts`.\n */\nconst LEAD_SOURCE_FILTER_LABELS: Record<\n  string,\n  InlineLocaleMap & Record<'en' | 'zh-CN' | 'es-ES' | 'ja-JP', string>\n> = {\n  web:             { en: 'Web',             'zh-CN': '\u7F51\u7AD9',      'es-ES': 'Web',                'ja-JP': '\u30A6\u30A7\u30D6' },\n  referral:        { en: 'Referral',        'zh-CN': '\u63A8\u8350',      'es-ES': 'Referencia',         'ja-JP': '\u7D39\u4ECB' },\n  event:           { en: 'Event / Trade Show', 'zh-CN': '\u6D3B\u52A8 / \u5C55\u4F1A', 'es-ES': 'Evento / Feria', 'ja-JP': '\u30A4\u30D9\u30F3\u30C8\u30FB\u5C55\u793A\u4F1A' },\n  webinar:         { en: 'Webinar',         'zh-CN': '\u7EBF\u4E0A\u7814\u8BA8\u4F1A', 'es-ES': 'Seminario Web',      'ja-JP': '\u30A6\u30A7\u30D3\u30CA\u30FC' },\n  partner:         { en: 'Partner',         'zh-CN': '\u5408\u4F5C\u4F19\u4F34',   'es-ES': 'Socio',              'ja-JP': '\u30D1\u30FC\u30C8\u30CA\u30FC' },\n  advertisement:   { en: 'Advertisement',   'zh-CN': '\u5E7F\u544A',      'es-ES': 'Publicidad',         'ja-JP': '\u5E83\u544A' },\n  paid_search:     { en: 'Paid Search',     'zh-CN': '\u4ED8\u8D39\u641C\u7D22',   'es-ES': 'B\u00FAsqueda de Pago',   'ja-JP': '\u6709\u6599\u691C\u7D22' },\n  social:          { en: 'Social Media',    'zh-CN': '\u793E\u4EA4\u5A92\u4F53',   'es-ES': 'Redes Sociales',     'ja-JP': '\u30BD\u30FC\u30B7\u30E3\u30EB\u30E1\u30C7\u30A3\u30A2' },\n  content:         { en: 'Content / Blog',  'zh-CN': '\u5185\u5BB9 / \u535A\u5BA2', 'es-ES': 'Contenido / Blog',  'ja-JP': '\u30B3\u30F3\u30C6\u30F3\u30C4\u30FB\u30D6\u30ED\u30B0' },\n  cold_call:       { en: 'Cold Call',       'zh-CN': '\u964C\u751F\u62DC\u8BBF',   'es-ES': 'Llamada en Fr\u00EDo',    'ja-JP': '\u30B3\u30FC\u30EB\u30C9\u30B3\u30FC\u30EB' },\n  email_campaign:  { en: 'Email Campaign',  'zh-CN': '\u90AE\u4EF6\u8425\u9500',   'es-ES': 'Campa\u00F1a de Email',   'ja-JP': '\u30E1\u30FC\u30EB\u30AD\u30E3\u30F3\u30DA\u30FC\u30F3' },\n  other:           { en: 'Other',           'zh-CN': '\u5176\u4ED6',      'es-ES': 'Otro',               'ja-JP': '\u305D\u306E\u4ED6' },\n};\n\n/**\n * Executive Overview Dashboard\n *\n * High-level revenue, customer, and pipeline KPIs for company leadership.\n *\n * Widgets here are dataset-bound (ADR-0021), and the console's dataset widget\n * reads ONLY: type, dataset, dimensions, values, filter, filterBindings, and\n * layout. It builds charts and tables from the dataset's own field metadata\n * (labels, formats), so per-widget `chartConfig`, `colorVariant`, widget-level\n * `action*`, and free-form `options` (icons, formats, static trends, table\n * column specs) are never read \u2014 don't re-add them. In particular, metric-tile\n * trend deltas must come from real comparison queries (widget `compareTo`)\n * once the renderer supports them for dataset metrics; hardcoded percentages\n * previously carried here were fabrications and were removed (#500).\n * Date bucketing is likewise server-side (a dataset dimension's\n * `dateGranularity`, not widget options) \u2014 but see the note in\n * `opportunity_metrics` for why the trend widgets still group by raw dates.\n */\nexport const ExecutiveDashboard: Dashboard = {\n  name: 'executive_dashboard',\n  label: 'Executive Overview',\n  description: 'High-level revenue, customer, and pipeline KPIs for leadership',\n\n  columns: 12,\n  gap: 4,\n  refreshIntervalSeconds: 300, // 5 minutes\n\n  header: {\n    showTitle: true,\n    showDescription: true,\n    // Header action buttons removed: they referenced actions/routes that were\n    // never implemented (`export_dashboard_pdf`, `schedule_dashboard_email`,\n    // `customize_dashboard` are not defined anywhere), so they rendered as dead\n    // buttons. Re-add real, wired-up actions here if these features land.\n  },\n\n  dateRange: {\n    field: 'close_date',\n    defaultRange: 'this_quarter',\n    allowCustomRange: true,\n  },\n\n  globalFilters: [\n    {\n      field: 'owner_id',\n      label: { en: 'Owner', 'zh-CN': '\u8D1F\u8D23\u4EBA', 'es-ES': 'Responsable', 'ja-JP': '\u62C5\u5F53\u8005' },\n      type: 'lookup',\n      scope: 'dashboard',\n      optionsFrom: { object: 'sys_user', valueField: 'id', labelField: 'name' },\n    },\n    {\n      field: 'lead_source',\n      label: { en: 'Lead Source', 'zh-CN': '\u7EBF\u7D22\u6765\u6E90', 'es-ES': 'Origen del Prospecto', 'ja-JP': '\u30EA\u30FC\u30C9\u30BD\u30FC\u30B9' },\n      type: 'select',\n      scope: 'dashboard',\n      // Roster derived, wording from the language packs \u2014 see\n      // LEAD_SOURCE_FILTER_LABELS above. Order follows the canonical constant.\n      options: LEAD_SOURCE_OPTIONS.map(({ value }) => ({\n        value,\n        label: LEAD_SOURCE_FILTER_LABELS[String(value)],\n      })),\n    },\n  ],\n\n  widgets: [\n    // \u2500\u2500\u2500 Row 1: Headline KPIs \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n    {\n      id: 'total_revenue_ytd',\n      title: 'Total Revenue (YTD)',\n      description: 'Closed-won revenue this year',\n      type: 'metric',\n      filter: { stage: 'closed_won', close_date: { $gte: '{current_year_start}' } },\n      // Self-scoped to YTD; without this the injected dashboard dateRange\n      // (default this_quarter) is ANDed in and the tile shows quarter revenue.\n      filterBindings: { dateRange: false },\n      dataset: 'opportunity_metrics', values: ['total_amount'],\n      layout: { x: 0, y: 0, w: 3, h: 2 },\n    },\n    {\n      id: 'total_accounts',\n      title: 'Active Accounts',\n      description: 'Customers with at least one active relationship',\n      type: 'metric',\n      filter: { is_active: true },\n      // crm_account has neither `close_date` nor `lead_source`; opt this widget\n      // out of both dashboard filters bound to those fields. ObjectStack 15\n      // (framework#2501) injects every dashboard filter (dateRange + globalFilters)\n      // into each widget's query, so a widget on an object lacking a filter field\n      // fails with `no such column`. crm_account DOES have `owner_id` (injected\n      // into every business object, #548), so the owner filter is left to apply.\n      filterBindings: { dateRange: false, lead_source: false },\n      dataset: 'account_metrics', values: ['account_count'],\n      layout: { x: 3, y: 0, w: 3, h: 2 },\n    },\n    {\n      id: 'total_contacts',\n      title: 'Total Contacts',\n      description: 'People in our address book',\n      type: 'metric',\n      filterBindings: { dateRange: false }, // crm_contact has no close_date \u2014 opt out of the date picker\n      dataset: 'contact_metrics', values: ['contact_count'],\n      layout: { x: 6, y: 0, w: 3, h: 2 },\n    },\n    {\n      id: 'open_leads',\n      title: 'Open Leads',\n      description: 'Unconverted leads in the funnel',\n      type: 'metric',\n      filter: { is_converted: false },\n      filterBindings: { dateRange: false }, // crm_lead has no close_date \u2014 opt out of the date picker\n      dataset: 'lead_metrics', values: ['lead_count'],\n      layout: { x: 9, y: 0, w: 3, h: 2 },\n    },\n\n    // \u2500\u2500\u2500 Row 2: Revenue Analysis \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n    {\n      id: 'revenue_trend',\n      title: 'Revenue Trend',\n      description: 'Closed-won revenue over the last 12 months',\n      type: 'area',\n      filter: { stage: 'closed_won', close_date: { $gte: '{12_months_ago}' } },\n      filterBindings: { dateRange: false }, // self-scoped to 12 months \u2014 the date picker must not narrow it\n      dataset: 'opportunity_metrics', dimensions: ['close_date'], values: ['total_amount'],\n      layout: { x: 0, y: 2, w: 8, h: 4 },\n      // Default rendering is intentional: the dataset widget plots the selected\n      // dimension \u00D7 values directly; a chartConfig would duplicate them inertly.\n      suppressWarnings: ['chart-config-missing'],\n    },\n    {\n      id: 'revenue_by_industry',\n      title: 'Revenue by Industry',\n      description: 'YTD closed-won revenue split by customer industry',\n      type: 'donut',\n      filter: { stage: 'closed_won', close_date: { $gte: '{current_year_start}' } },\n      filterBindings: { dateRange: false }, // self-scoped to YTD \u2014 the date picker must not narrow it\n      dataset: 'opportunity_metrics', dimensions: ['account_industry'], values: ['total_amount'],\n      layout: { x: 8, y: 2, w: 4, h: 4 },\n      suppressWarnings: ['chart-config-missing'], // intentional default rendering (see revenue_trend)\n    },\n\n    // \u2500\u2500\u2500 Row 3: Pipeline & Activity \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n    // The funnel now comes from the shared factory (#539); its remaining inert\n    // config lives in shared-widgets.ts and is out of this PR's scope.\n    pipelineByStageFunnelWidget({ x: 0, y: 6, w: 6, h: 4 }),\n    {\n      id: 'new_accounts_by_month',\n      title: 'New Accounts',\n      description: 'Account creation cadence \u2014 last 6 months',\n      type: 'bar',\n      filter: { created_at: { $gte: '{6_months_ago}' } },\n      filterBindings: { dateRange: false, lead_source: false }, // crm_account has no close_date/lead_source; scopes itself by created_at\n      dataset: 'account_metrics', dimensions: ['created_at'], values: ['account_count'],\n      layout: { x: 6, y: 6, w: 6, h: 4 },\n      suppressWarnings: ['chart-config-missing'], // intentional default rendering (see revenue_trend)\n    },\n\n    // \u2500\u2500\u2500 Row 4: Revenue by Industry \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n    // A dashboard `table` binds to an analytics cube, so it aggregates rather\n    // than listing raw accounts (ADR-0021). The previous \"Top Accounts by\n    // Revenue\" table selected only the `account_count` measure with no\n    // dimension \u2014 a single summary row, not a customer ranking. Grouping by\n    // industry gives a real multi-row breakdown of book-of-business by sector;\n    // for a per-account list, use an object-bound ListView (ADR-0017).\n    // Column headers and number formats come from the dataset's dimension and\n    // measure metadata.\n    {\n      id: 'accounts_by_industry',\n      title: 'Accounts by Industry',\n      description: 'Total annual revenue and account count per industry',\n      type: 'table',\n      filterBindings: { dateRange: false, lead_source: false }, // crm_account has no close_date/lead_source \u2014 opt out of both\n      dataset: 'account_metrics', dimensions: ['industry'], values: ['annual_revenue_sum', 'account_count'],\n      layout: { x: 0, y: 10, w: 12, h: 4 },\n    },\n  ],\n};\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/sales/dashboards/sales.dashboard.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/sales/dashboards\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/sales/dashboards/sales.dashboard.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport type { Dashboard } from '@objectstack/spec/ui';\nimport { avgDealSizeMetricWidget, pipelineByStageFunnelWidget } from './shared-widgets';\n\n/**\n * Sales Performance Dashboard\n *\n * Pipeline analytics, win rate trends, and rep performance for the sales team.\n * Modeled after the polished CRM dashboard reference at\n * https://github.com/objectstack-ai/objectui/tree/main/examples/crm.\n *\n * No KPI tile declares a `trend`. A period-over-period delta is a measurement,\n * so it has to come from a real comparison query (widget `compareTo`) once the\n * renderer supports it for dataset metrics \u2014 the percentages this file used to\n * carry were typed by hand and recomputed by nothing, so they kept asserting\n * the same \"+8.4% vs last quarter\" on any data, including an empty database.\n * Same rule as the executive dashboard (#500, #587).\n */\nexport const SalesDashboard: Dashboard = {\n  name: 'sales_dashboard',\n  label: 'Sales Performance',\n  description: 'Pipeline analytics, win rate trends, and rep performance',\n\n  columns: 12,\n  gap: 4,\n  refreshIntervalSeconds: 180, // 3 minutes\n\n  header: {\n    showTitle: true,\n    // Keep the opening KPI row in the first viewport for a live demo. The\n    // description remains available in dashboard metadata and translations.\n    showDescription: false,\n    // Header action buttons removed: `create_opportunity` / `export_dashboard_pdf`\n    // are not defined actions, and `/reports/forecast` matches no report route \u2014\n    // all three were dead. Re-add real, wired-up actions here when available.\n  },\n\n  dateRange: {\n    field: 'close_date',\n    defaultRange: 'this_quarter',\n    allowCustomRange: true,\n  },\n\n  globalFilters: [\n    {\n      field: 'owner_id',\n      label: { en: 'Sales Rep', 'zh-CN': '\u9500\u552E\u4EE3\u8868', 'es-ES': 'Representante de Ventas', 'ja-JP': '\u55B6\u696D\u62C5\u5F53\u8005' },\n      type: 'lookup',\n      scope: 'dashboard',\n      optionsFrom: { object: 'sys_user', valueField: 'id', labelField: 'name' },\n    },\n    {\n      field: 'type',\n      label: { en: 'Deal Type', 'zh-CN': '\u5546\u673A\u7C7B\u578B', 'es-ES': 'Tipo de Oportunidad', 'ja-JP': '\u5546\u8AC7\u30BF\u30A4\u30D7' },\n      type: 'select',\n      scope: 'dashboard',\n      options: [\n        { value: 'new_business',       label: { en: 'New Business', 'zh-CN': '\u65B0\u4E1A\u52A1', 'es-ES': 'Nuevo Negocio', 'ja-JP': '\u65B0\u898F\u30D3\u30B8\u30CD\u30B9' } },\n        { value: 'existing_upgrade',   label: { en: 'Existing Customer - Upgrade', 'zh-CN': '\u8001\u5BA2\u6237\u5347\u7EA7', 'es-ES': 'Cliente Existente - Mejora', 'ja-JP': '\u65E2\u5B58\u9867\u5BA2 - \u30A2\u30C3\u30D7\u30B0\u30EC\u30FC\u30C9' } },\n        { value: 'existing_renewal',   label: { en: 'Existing Customer - Renewal', 'zh-CN': '\u8001\u5BA2\u6237\u7EED\u7EA6', 'es-ES': 'Cliente Existente - Renovaci\u00F3n', 'ja-JP': '\u65E2\u5B58\u9867\u5BA2 - \u66F4\u65B0' } },\n        { value: 'existing_expansion', label: { en: 'Existing Customer - Expansion', 'zh-CN': '\u8001\u5BA2\u6237\u62D3\u5C55', 'es-ES': 'Cliente Existente - Expansi\u00F3n', 'ja-JP': '\u65E2\u5B58\u9867\u5BA2 - \u62E1\u5927' } },\n      ],\n    },\n  ],\n\n  widgets: [\n    // \u2500\u2500\u2500 Row 1: Pipeline KPIs \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n    {\n      id: 'total_pipeline_value',\n      title: 'Total Pipeline',\n      description: 'Sum of open opportunity value',\n      type: 'metric',\n      filter: { stage: { $nin: ['closed_won', 'closed_lost'] } },\n      colorVariant: 'blue',\n      dataset: 'opportunity_metrics', values: ['total_amount'],\n      layout: { x: 0, y: 0, w: 3, h: 2 },\n    },\n    {\n      id: 'closed_won_qtd',\n      title: 'Closed Won (QTD)',\n      description: 'Revenue closed this quarter',\n      type: 'metric',\n      filter: { stage: 'closed_won', close_date: { $gte: '{current_quarter_start}' } },\n      filterBindings: { dateRange: false }, // self-scoped to QTD \u2014 the date picker must not re-window it\n      colorVariant: 'success',\n      dataset: 'opportunity_metrics', values: ['total_amount'],\n      layout: { x: 3, y: 0, w: 3, h: 2 },\n    },\n    {\n      id: 'open_opportunities',\n      title: 'Open Opportunities',\n      description: 'Active deals in flight',\n      type: 'metric',\n      filter: { stage: { $nin: ['closed_won', 'closed_lost'] } },\n      colorVariant: 'orange',\n      dataset: 'opportunity_metrics', values: ['opp_count'],\n      layout: { x: 6, y: 0, w: 3, h: 2 },\n    },\n    avgDealSizeMetricWidget({ x: 9, y: 0, w: 3, h: 2 }, {\n      description: 'Average value of closed-won deals this quarter',\n      filter: { stage: 'closed_won', close_date: { $gte: '{current_quarter_start}' } },\n      filterBindings: { dateRange: false }, // self-scoped to QTD \u2014 the date picker must not re-window it\n      colorVariant: 'purple',\n    }),\n\n    // \u2500\u2500\u2500 Row 2: Win / Loss KPIs \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n    //\n    // The ratio and its two inputs sit side by side ON PURPOSE (#593). A win\n    // rate is the failure mode #614 shipped: a wrong denominator raises no\n    // error, it just prints a plausible percentage. Showing \"62%\" next to\n    // \"8 won\" and \"5 lost\" means a reader can check the arithmetic at a\n    // glance, and a half that silently loses its filter stops being invisible.\n    //\n    // All three windows are the same self-scoped 12 months (`dateRange: false`\n    // so the header's date picker cannot re-window one of them and not the\n    // others \u2014 three tiles over three different windows would be worse than\n    // no tiles at all).\n    {\n      // NOTE: no `stage` filter here, and that is deliberate. Both halves of\n      // the ratio come from the DATASET's own measure filters \u2014 `won_count`\n      // over closed_won, `decided_count` over closed_won + closed_lost \u2014 so\n      // open pipeline is excluded by the measures. A widget-level\n      // `stage: {$in: [...]}` filter would narrow numerator and denominator\n      // alike, which is how a ratio quietly becomes a division by itself.\n      id: 'win_rate_12m',\n      title: 'Win Rate (12M)',\n      description: 'Deals won as a share of all deals settled in the last 12 months',\n      type: 'metric',\n      filter: { close_date: { $gte: '{12_months_ago}' } },\n      filterBindings: { dateRange: false },\n      colorVariant: 'success',\n      dataset: 'opportunity_metrics', values: ['win_rate'],\n      layout: { x: 0, y: 2, w: 4, h: 2 },\n    },\n    {\n      id: 'won_deals_12m',\n      title: 'Deals Won (12M)',\n      description: 'The numerator of the win rate',\n      type: 'metric',\n      filter: { close_date: { $gte: '{12_months_ago}' } },\n      filterBindings: { dateRange: false },\n      colorVariant: 'blue',\n      dataset: 'opportunity_metrics', values: ['won_count'],\n      layout: { x: 4, y: 2, w: 4, h: 2 },\n    },\n    {\n      id: 'lost_deals_12m',\n      title: 'Deals Lost (12M)',\n      description: 'The other half of the win-rate denominator',\n      type: 'metric',\n      filter: { close_date: { $gte: '{12_months_ago}' } },\n      filterBindings: { dateRange: false },\n      colorVariant: 'orange',\n      dataset: 'opportunity_metrics', values: ['lost_count'],\n      layout: { x: 8, y: 2, w: 4, h: 2 },\n    },\n\n    // \u2500\u2500\u2500 Row 3: Pipeline & Trends \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n    pipelineByStageFunnelWidget({ x: 0, y: 4, w: 6, h: 4 }),\n    {\n      id: 'monthly_revenue_trend',\n      title: 'Monthly Revenue Trend',\n      description: 'Closed-won revenue, last 12 months',\n      type: 'area',\n      filter: { stage: 'closed_won', close_date: { $gte: '{12_months_ago}' } },\n      filterBindings: { dateRange: false }, // self-scoped to 12 months \u2014 the date picker must not narrow it\n      colorVariant: 'success',\n      dataset: 'opportunity_metrics', dimensions: ['close_date'], values: ['total_amount'],\n      layout: { x: 6, y: 4, w: 6, h: 4 },\n      chartConfig: {\n        showLegend: false,\n        showDataLabels: false,\n        colors: ['#10B981'],\n        // No quota annotation line: ChartAnnotationSchema only takes a STATIC\n        // value, and the real quotas live per-owner/per-period in\n        // crm_forecast.quota (seeded 500k\u20131.5M \u2014 the old hardcoded 100000 was\n        // fiction). Quota vs. actual is the quota_attainment_by_rep table\n        // below, bound to the forecast_metrics dataset.\n        interaction: { tooltips: true, brush: true },\n      },\n      options: { dateGranularity: 'month' },\n    },\n\n    // \u2500\u2500\u2500 Row 4: Performance Breakdown \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n    {\n      id: 'pipeline_by_forecast_category',\n      title: 'Pipeline by Forecast Category',\n      description: 'Open pipeline grouped by sales forecast category',\n      type: 'horizontal-bar',\n      filter: { stage: { $nin: ['closed_won', 'closed_lost'] } },\n      colorVariant: 'blue',\n      dataset: 'opportunity_metrics', dimensions: ['forecast_category'], values: ['total_amount'],\n      layout: { x: 0, y: 8, w: 6, h: 4 },\n      chartConfig: {\n        showLegend: false,\n        showDataLabels: true,\n        colors: ['#4F46E5'],\n      },\n    },\n    {\n      id: 'lead_source_breakdown',\n      title: 'Lead Source',\n      description: 'Where our pipeline is coming from',\n      type: 'donut',\n      filter: { stage: { $nin: ['closed_lost'] } },\n      colorVariant: 'purple',\n      dataset: 'opportunity_metrics', dimensions: ['lead_source'], values: ['total_amount'],\n      layout: { x: 6, y: 8, w: 6, h: 4 },\n      chartConfig: {\n        showLegend: true,\n        showDataLabels: true,\n        colors: ['#4F46E5', '#06B6D4', '#10B981', '#F59E0B', '#EF4444', '#8B5CF6'],\n      },\n    },\n\n    // \u2500\u2500\u2500 Row 5: Rep Leaderboard \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n    // A dashboard `table` binds to an analytics cube and aggregates; it cannot\n    // list raw deals (ADR-0021). The previous \"Top Open Opportunities\" table\n    // selected only `opp_count` with no dimension \u2014 one summary row, not a deal\n    // ranking. Grouping open pipeline by owner yields a rep leaderboard (one\n    // row per rep). For a per-deal list, surface an object-bound ListView\n    // through app navigation (ADR-0017).\n    {\n      id: 'open_pipeline_by_owner',\n      title: 'Open Pipeline by Owner',\n      description: 'In-flight pipeline value, deal count and avg win probability per rep',\n      type: 'table',\n      filter: { stage: { $nin: ['closed_won', 'closed_lost'] } },\n      colorVariant: 'default',\n      dataset: 'opportunity_metrics', dimensions: ['owner'], values: ['total_amount', 'opp_count', 'avg_probability'],\n      layout: { x: 0, y: 12, w: 12, h: 4 },\n      options: {\n        sortBy: 'total_amount',\n        sortOrder: 'desc',\n        limit: 10,\n      },\n    },\n\n    // \u2500\u2500\u2500 Row 6: Quota Attainment \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n    // The real per-rep quota data (crm_forecast.quota) surfaced as a table:\n    // dashboard chart annotations cannot reference a dataset (static values\n    // only), so quota vs. actual gets its own widget instead of a fake line.\n    {\n      id: 'quota_attainment_by_rep',\n      title: 'Quota Attainment by Rep',\n      description: 'Current-quarter quota, closed revenue and attainment per rep, from forecast snapshots',\n      type: 'table',\n      colorVariant: 'default',\n      // crm_forecast has neither `close_date` nor `type`; opt out of the\n      // dashboard filters bound to those fields (framework#2501 injects every\n      // dashboard filter into each widget query). `owner` exists and applies.\n      filterBindings: { dateRange: false, type: false },\n      // ONE period, or the numbers are nonsense (#614). `crm_forecast` holds a\n      // row per owner PER PERIOD, and `quota_sum` / `closed_sum` are plain\n      // `sum` measures \u2014 so an unpinned query adds this quarter's quota to this\n      // month's quota to every settled quarter's quota and labels the total\n      // \"Quota\". On the shipped seeds that turned a rep's real 1,500,000\n      // quarterly quota into 7,940,000, with attainment wrong by the same\n      // construction (89% instead of 55%).\n      //\n      // Both halves of the key are needed. `period: 'quarter'` alone still sums\n      // every quarter ever snapshotted; `period_start` alone still merges the\n      // quarter row with the month row that opens the same quarter (Q3 and July\n      // both start on the 1st). Together they name exactly one snapshot per\n      // owner \u2014 the same (owner, period, period_start) tuple the snapshot sweep\n      // upserts on and the object indexes.\n      //\n      // `{current_quarter_start}` is resolved by the ANALYTICS path, verified\n      // rather than assumed: `queryDataset` runs both the dataset filter and the\n      // widget's `runtimeFilter` through `resolveFilterTokens`, which\n      // understands `{(current|last|next)_(week|month|quarter|year)_(start|end)}`\n      // and throws `FILTER_TOKEN_UNKNOWN` on anything else.\n      //\n      // The LIST path resolves the same macros, and has since 17.0.0-rc.0:\n      // `resolveFilterTokens()` was wired into the ObjectQL READ path (objectql\n      // `feat(filters): evaluate {filter-token} placeholders server-side`,\n      // #3582) ahead of the middleware chain, covering `find` / `findOne` /\n      // `count` / `aggregate` \u2014 the one gate every server-side read passes\n      // through, saved-view filters included. So this widget's filter and a\n      // saved view's filter now read the same way, and the sibling\n      // `this_quarter_forecasts` in `src/sales/views/forecast.view.ts` pins this same\n      // quarter with this same macro. Measured, not inferred:\n      // `test/forecast-current-quarter-view.test.ts` runs both filter shapes \u2014\n      // the `period_start` equality (#730) and the `close_date` range (#743) \u2014\n      // through a real engine and pins a three-way outcome (current quarter\n      // only: not zero rows, not every quarter). First taken on 17.0.0-rc.2;\n      // RE-RUN 2026-09-03 on 17.2.0 (#1467), RE-RUN on 17.3.0 (#1676, the PR\n      // #1577 pin) and RE-RUN again on 17.4.0 (PR #1814, #1807) \u2014 green all\n      // four times, so the outcome held on every pin it was taken on, not\n      // only the first. Not yet re-run on 17.5.0.\n      //\n      // What stood here before described the two paths as asymmetric and told\n      // the next author not to generalise between them. That was true on\n      // @objectstack 16.1.0 and expired at rc.0 (#744).\n      //\n      // Cost of pinning to the CURRENT quarter rather than the latest one: for\n      // the few hours between a quarter boundary and the 03:00 sweep that opens\n      // the new row, the table is empty. Empty is the honest state \u2014 the\n      // alternative renders last quarter's attainment under a header that says\n      // this one.\n      filter: { period: 'quarter', period_start: '{current_quarter_start}' },\n      dataset: 'forecast_metrics', dimensions: ['owner'], values: ['quota_sum', 'closed_sum', 'attainment'],\n      layout: { x: 0, y: 16, w: 12, h: 4 },\n      options: {\n        sortBy: 'attainment',\n        sortOrder: 'desc',\n        limit: 10,\n      },\n    },\n\n    // \u2500\u2500\u2500 Row 7: Win / Loss analysis \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n    //\n    // Three widgets over the settled half of the pipeline (#593). Each of the\n    // two win-rate breakdowns is a TABLE, not a bar chart, and that is the\n    // whole design: a bar of \"67%\" is unfalsifiable, whereas a row reading\n    // \"Won 2 \u00B7 Lost 1 \u00B7 Settled 3 \u00B7 67%\" carries its own proof. Perturb either\n    // half \u2014 win a deal that was lost, or lose one that was won \u2014 and three of\n    // those four numbers move. `test/win-loss-capture.test.ts` does exactly\n    // that against the real dataset executor and the real seeds.\n    //\n    // Both tables opt out of the header's `close_date` window\n    // (`dateRange: false`) for the reason the quota table does: a win rate over\n    // \"this quarter\" on a demo database is computed from whichever one or two\n    // deals happen to have settled inside it, which is noise wearing the\n    // costume of a KPI. Twelve months is the same window the row-2 tiles and\n    // the revenue trend use, so the dashboard tells one consistent story.\n    {\n      id: 'win_rate_by_owner',\n      title: 'Win / Loss by Rep',\n      description: 'Deals won, deals lost and win rate per rep \u2014 last 12 months',\n      type: 'table',\n      filter: { close_date: { $gte: '{12_months_ago}' } },\n      filterBindings: { dateRange: false },\n      colorVariant: 'default',\n      dataset: 'opportunity_metrics',\n      dimensions: ['owner'],\n      values: ['won_count', 'lost_count', 'decided_count', 'win_rate', 'won_amount'],\n      layout: { x: 0, y: 20, w: 6, h: 4 },\n      options: {\n        sortBy: 'decided_count',\n        sortOrder: 'desc',\n        limit: 10,\n      },\n    },\n    {\n      id: 'win_rate_by_lead_source',\n      title: 'Win / Loss by Lead Source',\n      description: 'Which sources produce deals that actually close \u2014 last 12 months',\n      type: 'table',\n      filter: { close_date: { $gte: '{12_months_ago}' } },\n      filterBindings: { dateRange: false },\n      colorVariant: 'default',\n      dataset: 'opportunity_metrics',\n      dimensions: ['lead_source'],\n      values: ['won_count', 'lost_count', 'decided_count', 'win_rate', 'won_amount'],\n      layout: { x: 6, y: 20, w: 6, h: 4 },\n      options: {\n        sortBy: 'decided_count',\n        sortOrder: 'desc',\n        limit: 12,\n      },\n    },\n    {\n      // The loss-reason breakdown the fields were declared for and never got.\n      //\n      // `loss_reason` is mandatory on every `closed_lost` record (see\n      // crm_opportunity), so this chart has no \"unattributed\" slice to\n      // apologise for \u2014 an empty chart here means no losses in the window,\n      // never \"nobody filled the field in\".\n      //\n      // Counts, not amounts: the question a loss review asks is \"how often did\n      // we lose for this reason\", and one large lost deal should not outweigh\n      // five recurring feature gaps. `lost_amount` is declared on the dataset\n      // for the revenue view of the same question.\n      id: 'loss_reason_breakdown',\n      title: 'Why We Lose',\n      description: 'Lost deals by reason \u2014 last 12 months',\n      type: 'donut',\n      filter: { stage: 'closed_lost', close_date: { $gte: '{12_months_ago}' } },\n      filterBindings: { dateRange: false },\n      colorVariant: 'orange',\n      dataset: 'opportunity_metrics', dimensions: ['loss_reason'], values: ['opp_count'],\n      layout: { x: 0, y: 24, w: 12, h: 4 },\n      chartConfig: {\n        showLegend: true,\n        showDataLabels: true,\n        colors: ['#EF4444', '#F59E0B', '#8B5CF6', '#06B6D4', '#4F46E5', '#10B981', '#64748B'],\n      },\n    },\n\n    // \u2500\u2500\u2500 Row 9: Pivot \u2014 Stage \u00D7 Lead Source \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n    {\n      id: 'pipeline_stage_by_source',\n      title: 'Pipeline by Stage \u00D7 Lead Source',\n      description: 'Cross-tab of open opportunity amount by stage and source',\n      type: 'pivot',\n      filter: { stage: { $nin: ['closed_won', 'closed_lost'] } },\n      colorVariant: 'default',\n      dataset: 'opportunity_metrics', dimensions: ['stage', 'lead_source'], values: ['total_amount'],\n      layout: { x: 0, y: 28, w: 12, h: 4 },\n    },\n  ],\n};\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/sales/datasets/index.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/sales/datasets\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/sales/datasets/index.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\n/** Analytics dataset barrel (ADR-0021). */\n\nexport { OpportunityDataset } from './opportunity.dataset';\nexport { AccountDataset } from './account.dataset';\nexport { ContactDataset } from './contact.dataset';\nexport { LeadDataset } from './lead.dataset';\nexport { TaskDataset } from './task.dataset';\nexport { EventDataset } from './event.dataset';\nexport { ForecastDataset } from './forecast.dataset';\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/sales/datasets/opportunity.dataset.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/sales/datasets\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/sales/datasets/opportunity.dataset.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport { defineDataset } from '@objectstack/spec/ui';\n\n/**\n * Opportunity analytics dataset (ADR-0021).\n *\n * The single semantic source of truth for pipeline metrics across the Sales,\n * CRM and Executive dashboards. Widgets bind to this dataset and select\n * measures BY NAME (`total_amount`, `avg_amount`, `opp_count`) so \"pipeline\n * revenue\" means the same thing everywhere.\n */\nexport const OpportunityDataset = defineDataset({\n  name: 'opportunity_metrics',\n  label: 'Opportunity Metrics',\n  description: 'Semantic layer for sales-pipeline counts and amounts',\n  object: 'crm_opportunity',\n\n  // Include the account relationship so dimensions can traverse it (the join is\n  // derived from the `crm_account` lookup \u2014 no hand-written ON clause).\n  include: ['crm_account'],\n\n  dimensions: [\n    { name: 'stage', label: 'Stage', field: 'stage', type: 'string' },\n    { name: 'lead_source', label: 'Lead Source', field: 'lead_source', type: 'string' },\n    { name: 'forecast_category', label: 'Forecast Category', field: 'forecast_category', type: 'string' },\n    { name: 'type', label: 'Deal Type', field: 'type', type: 'string' },\n    // Semantic name `owner`; column `owner_id`, the platform anchor (#548).\n    { name: 'owner', label: 'Owner', field: 'owner_id', type: 'lookup' },\n    // Win/loss attribution (#593). Both columns are now mandatory at close\n    // (`requiredWhen` on crm_opportunity), so grouping by either one over\n    // settled deals has no \"unattributed\" bucket to explain away.\n    { name: 'win_reason', label: 'Win Reason', field: 'win_reason', type: 'string' },\n    { name: 'loss_reason', label: 'Loss Reason', field: 'loss_reason', type: 'string' },\n    // v17 fixes scoped aggregate execution and SQLite's epoch bucketing.\n    // Trends and quarter coverage need different buckets over the same field,\n    // so each one is its own semantic dimension.\n    { name: 'close_date', label: 'Close Date', field: 'close_date', type: 'date', dateGranularity: 'month' },\n    { name: 'close_quarter', label: 'Close Quarter', field: 'close_date', type: 'date', dateGranularity: 'quarter' },\n    // Cross-object dimension: account industry via the crm_account relationship.\n    { name: 'account_industry', label: 'Account Industry', field: 'crm_account.industry', type: 'string' },\n  ],\n\n  measures: [\n    { name: 'opp_count', label: 'Opportunities', aggregate: 'count' },\n    { name: 'total_amount', label: 'Total Amount', aggregate: 'sum', field: 'amount', format: '0,0' },\n    { name: 'avg_amount', label: 'Avg Deal Size', aggregate: 'avg', field: 'amount', format: '0,0' },\n    { name: 'avg_probability', label: 'Avg Probability', aggregate: 'avg', field: 'probability', format: '0%' },\n\n    // \u2500\u2500\u2500 Win rate (#593) \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n    //\n    // A ratio is the most dangerous kind of measure: a wrong denominator does\n    // not error, it returns a plausible number (#614 rendered a 1,500,000\n    // quota as 7,940,000 because a filter was missing one of its two halves).\n    // So the two halves are declared here, ONCE, as named measures \u2014 not\n    // improvised per widget \u2014 and every widget that shows `win_rate` also\n    // shows `won_count` and `lost_count` beside it, so the reader can check\n    // the arithmetic that produced the percentage.\n    //\n    // Each carries its OWN `filter`, which the executor honours by running\n    // that measure as its own sub-query and merging the result back on the\n    // selected dimensions. That is what lets one widget row hold \"won 2, lost\n    // 1, 67%\" \u2014 the counts are over different row sets, and only a\n    // measure-level filter can say so. A widget-level `filter` cannot: it\n    // narrows the whole row set at once, which is exactly how you end up\n    // dividing a number by itself.\n    //\n    // `decided_count` is deliberately its own filtered count and NOT\n    // `derived: { op: 'sum', of: ['won_count', 'lost_count'] }`. Measured on\n    // 17.0.0-rc.1: a filtered measure contributes NO row for a group its\n    // filter selects nothing in \u2014 the count comes back absent, not 0 \u2014 and a\n    // derived measure over an absent input evaluates to null. Summing the two\n    // would therefore blank the win rate of any rep who has never lost a deal\n    // (100%, the group you least want to hide). Counting the union directly\n    // keeps the denominator present whenever the group has any settled deal at\n    // all. The remaining asymmetry \u2014 a group with losses but NO wins reports a\n    // null win rate rather than 0% \u2014 is a platform behaviour, not something a\n    // widget can paper over; it is pinned by `test/win-loss-capture.test.ts`\n    // and filed as #656. The tables show `lost_count` next to `win_rate`\n    // precisely so that a blank rate reads as \"0 wins out of 3\", not as\n    // \"no data\".\n    { name: 'won_count', label: 'Won Deals', aggregate: 'count', filter: { stage: 'closed_won' } },\n    { name: 'lost_count', label: 'Lost Deals', aggregate: 'count', filter: { stage: 'closed_lost' } },\n    {\n      name: 'decided_count',\n      label: 'Settled Deals',\n      aggregate: 'count',\n      filter: { stage: { $in: ['closed_won', 'closed_lost'] } },\n    },\n    { name: 'won_amount', label: 'Won Revenue', aggregate: 'sum', field: 'amount', filter: { stage: 'closed_won' }, format: '0,0' },\n    { name: 'lost_amount', label: 'Lost Revenue', aggregate: 'sum', field: 'amount', filter: { stage: 'closed_lost' }, format: '0,0' },\n    { name: 'win_rate', label: 'Win Rate', derived: { op: 'ratio', of: ['won_count', 'decided_count'] }, format: '0%' },\n  ],\n});\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/sales/datasets/account.dataset.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/sales/datasets\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/sales/datasets/account.dataset.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport { defineDataset } from '@objectstack/spec/ui';\n\n/** Account analytics dataset (ADR-0021). */\nexport const AccountDataset = defineDataset({\n  name: 'account_metrics',\n  label: 'Account Metrics',\n  description: 'Semantic layer for account counts by industry / type',\n  object: 'crm_account',\n  dimensions: [\n    { name: 'industry', label: 'Industry', field: 'industry', type: 'string' },\n    { name: 'type', label: 'Type', field: 'type', type: 'string' },\n    { name: 'created_at', label: 'Created', field: 'created_at', type: 'date', dateGranularity: 'month' },\n  ],\n  measures: [\n    { name: 'account_count', label: 'Accounts', aggregate: 'count' },\n    { name: 'annual_revenue_sum', label: 'Annual Revenue', aggregate: 'sum', field: 'annual_revenue', format: '0,0' },\n  ],\n});\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/sales/datasets/contact.dataset.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/sales/datasets\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/sales/datasets/contact.dataset.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport { defineDataset } from '@objectstack/spec/ui';\n\n/** Contact analytics dataset (ADR-0021). */\nexport const ContactDataset = defineDataset({\n  name: 'contact_metrics',\n  label: 'Contact Metrics',\n  description: 'Semantic layer for contact counts',\n  object: 'crm_contact',\n  dimensions: [],\n  measures: [{ name: 'contact_count', label: 'Contacts', aggregate: 'count' }],\n});\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/sales/datasets/lead.dataset.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/sales/datasets\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/sales/datasets/lead.dataset.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport { defineDataset } from '@objectstack/spec/ui';\n\n/** Lead analytics dataset (ADR-0021). */\nexport const LeadDataset = defineDataset({\n  name: 'lead_metrics',\n  label: 'Lead Metrics',\n  description: 'Semantic layer for lead counts',\n  object: 'crm_lead',\n  dimensions: [\n    { name: 'status', label: 'Status', field: 'status', type: 'string' },\n    { name: 'lead_source', label: 'Source', field: 'lead_source', type: 'string' },\n    { name: 'created_at', label: 'Created', field: 'created_at', type: 'date' },\n    { name: 'last_contacted_date', label: 'Last Contacted', field: 'last_contacted_date', type: 'date', dateGranularity: 'month' },\n  ],\n  measures: [{ name: 'lead_count', label: 'Leads', aggregate: 'count' }],\n});\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/sales/datasets/task.dataset.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/sales/datasets\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/sales/datasets/task.dataset.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport { defineDataset } from '@objectstack/spec/ui';\n\n/**\n * Task analytics dataset (ADR-0021).\n *\n * Added for the \"My Day\" dashboard \u2014 `crm_task` had views, seed data and\n * automation but no semantic layer, so a rep's own workload could not be\n * counted or broken down anywhere.\n *\n * `priority_rank` is exposed alongside `priority` so a breakdown can be\n * ordered by urgency; sorting on the raw select compares option strings and\n * inverts it (normal > low > high > urgent).\n */\nexport const TaskDataset = defineDataset({\n  name: 'task_metrics',\n  label: 'Task Metrics',\n  description: 'Semantic layer for task workload and completion',\n  object: 'crm_task',\n  dimensions: [\n    { name: 'status', label: 'Status', field: 'status', type: 'string' },\n    { name: 'priority', label: 'Priority', field: 'priority', type: 'string' },\n    { name: 'priority_rank', label: 'Urgency', field: 'priority_rank', type: 'number' },\n    { name: 'type', label: 'Type', field: 'type', type: 'string' },\n    { name: 'due_date', label: 'Due Date', field: 'due_date', type: 'date' },\n    { name: 'is_overdue', label: 'Overdue', field: 'is_overdue', type: 'boolean' },\n    { name: 'is_completed', label: 'Completed', field: 'is_completed', type: 'boolean' },\n  ],\n  measures: [\n    { name: 'task_count', label: 'Tasks', aggregate: 'count' },\n    { name: 'avg_progress', label: 'Avg Progress', aggregate: 'avg', field: 'progress_percent', format: '0.0%' },\n  ],\n});\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/sales/datasets/event.dataset.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/sales/datasets\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/sales/datasets/event.dataset.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport { defineDataset } from '@objectstack/spec/ui';\n\n/**\n * Event analytics dataset (ADR-0021) \u2014 the semantic layer #592 needed.\n *\n * Before this, the app had NO activity metric of any kind: calls per rep,\n * meetings booked and activity per deal were all unanswerable, because the\n * only trace of an interaction was a `sys_activity` row with the interesting\n * part inside a JSON string. `crm_event` is a real object, so it gets a real\n * cube.\n *\n * `related_to_type` is a dimension and the `related_to_*` lookups are not:\n * grouping by a lookup id yields a column per raw id, which reads as noise on\n * a chart. \"Which deals are starved of activity\" is answered by filtering to\n * `related_to_type = crm_opportunity` and counting, not by grouping on the id.\n *\n * `start_datetime` declares `dateGranularity: 'week'`: every widget built on\n * it asks \"how much activity per week\", and on @objectstack 17 a bucketed\n * dimension is honoured (see `test/dataset-granularity.test.ts` for the 16.x\n * history and why the buckets could not be declared before).\n */\nexport const EventDataset = defineDataset({\n  name: 'event_metrics',\n  label: 'Activity Metrics',\n  description: 'Semantic layer for meetings, calls and interaction recency',\n  object: 'crm_event',\n  dimensions: [\n    { name: 'type', label: 'Activity Type', field: 'type', type: 'string' },\n    { name: 'status', label: 'Status', field: 'status', type: 'string' },\n    // `owner` is the SEMANTIC name every widget/report selects by; the column\n    // behind it is the platform ownership anchor `owner_id` (#548).\n    { name: 'owner', label: 'Owner', field: 'owner_id', type: 'string' },\n    { name: 'related_to_type', label: 'Related To', field: 'related_to_type', type: 'string' },\n    {\n      name: 'start_datetime',\n      label: 'Activity Week',\n      field: 'start_datetime',\n      type: 'date',\n      dateGranularity: 'week',\n    },\n  ],\n  measures: [\n    { name: 'event_count', label: 'Activities', aggregate: 'count' },\n    {\n      name: 'total_minutes',\n      label: 'Minutes',\n      aggregate: 'sum',\n      field: 'duration_minutes',\n      format: '0,0',\n    },\n    {\n      name: 'avg_minutes',\n      label: 'Avg Duration',\n      aggregate: 'avg',\n      field: 'duration_minutes',\n      format: '0,0',\n    },\n  ],\n});\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/sales/datasets/forecast.dataset.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/sales/datasets\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/sales/datasets/forecast.dataset.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport { defineDataset } from '@objectstack/spec/ui';\n\n/**\n * Forecast analytics dataset (ADR-0021).\n *\n * `crm_forecast` carries the real per-owner, per-period quota and attainment\n * snapshots, but had no semantic layer \u2014 which is how the Sales dashboard\n * ended up annotating its revenue chart with a hardcoded quota of 100000\n * while the seeded quotas run 500k\u20131.5M. Widgets that talk about quota must\n * bind here instead of inventing numbers.\n *\n * ## The measures are NOT additive across periods (#614)\n *\n * One row per owner per period, and the table deliberately holds several\n * periods at once (a current quarter, a current month, several settled ones).\n * `quota_sum` and friends are plain `sum`s, so a query that does not pin the\n * period adds a quarter's quota to a month's quota to last quarter's quota and\n * calls the result \"Quota\" \u2014 the defect that shipped on\n * `quota_attainment_by_rep` until #614.\n *\n * Every consumer must therefore make the period unambiguous, one of two ways:\n *\n *   \u2022 group by `period_label` (unique per period, so each row IS one period) \u2014\n *     the shape a quota-over-time trend wants; or\n *   \u2022 filter to a single snapshot with `period` + `period_start`\n *     (`{ period: 'quarter', period_start: '{current_quarter_start}' }`) \u2014\n *     the shape a \"where do we stand right now\" scoreboard wants.\n *\n * `test/forecast-period-scope.test.ts` fails the build for any widget or report\n * that does neither, so the trap cannot be walked into twice.\n *\n * This constraint is deliberately NOT a dataset-level `filter` pinning the\n * latest quarter. A dataset filter is invisible at the call site: it would make\n * the very trend the `period` / `period_label` dimensions exist to serve return\n * a single row, with nothing on the widget to explain why. The failure mode of\n * a missing widget filter is a loud test; the failure mode of a hidden dataset\n * filter is silently missing data.\n */\nexport const ForecastDataset = defineDataset({\n  name: 'forecast_metrics',\n  label: 'Forecast Metrics',\n  description: 'Semantic layer for per-owner quota, attainment and pipeline coverage',\n  object: 'crm_forecast',\n\n  dimensions: [\n    // Semantic name `owner`; column `owner_id`, the platform anchor (#548).\n    { name: 'owner', label: 'Owner', field: 'owner_id', type: 'lookup' },\n    { name: 'period', label: 'Period Type', field: 'period', type: 'string' },\n    { name: 'period_label', label: 'Period', field: 'period_label', type: 'string' },\n    { name: 'period_start', label: 'Period Start', field: 'period_start', type: 'date' },\n  ],\n\n  measures: [\n    { name: 'quota_sum', label: 'Quota', aggregate: 'sum', field: 'quota', format: '0,0' },\n    { name: 'closed_sum', label: 'Closed', aggregate: 'sum', field: 'closed_amount', format: '0,0' },\n    { name: 'pipeline_sum', label: 'Pipeline', aggregate: 'sum', field: 'pipeline_amount', format: '0,0' },\n    { name: 'commit_sum', label: 'Commit', aggregate: 'sum', field: 'commit_amount', format: '0,0' },\n    // Derived ratio (ADR-0021 Q1) rather than avg(attainment_pct): summing\n    // closed and quota before dividing weights every rep/period by quota\n    // size, where an average of per-row percentages would not.\n    { name: 'attainment', label: 'Attainment', derived: { op: 'ratio', of: ['closed_sum', 'quota_sum'] }, format: '0%' },\n  ],\n});\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/revenue/datasets/index.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/revenue/datasets\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/revenue/datasets/index.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\n/**\n * Revenue datasets barrel.\n *\n * The doctrine for this metadata type is written once, in\n * `src/sales/datasets/index.ts`; this file is the revenue package's half of\n * the same file-by-file registration.\n */\n\nexport { ProductDataset } from './product.dataset';\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/revenue/datasets/product.dataset.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/revenue/datasets\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/revenue/datasets/product.dataset.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport { defineDataset } from '@objectstack/spec/ui';\n\n/** Product analytics dataset (ADR-0021) \u2014 catalog list-price rollups. */\nexport const ProductDataset = defineDataset({\n  name: 'product_metrics',\n  label: 'Product Metrics',\n  description: 'Semantic layer for product catalog counts and list price',\n  object: 'crm_product',\n  dimensions: [\n    { name: 'category', label: 'Category', field: 'category', type: 'string' },\n  ],\n  measures: [\n    { name: 'product_count', label: 'Products', aggregate: 'count' },\n    { name: 'list_price_sum', label: 'Total List Price', aggregate: 'sum', field: 'list_price', format: '0,0' },\n  ],\n});\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/sales/reports/index.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/sales/reports\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/sales/reports/index.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\n/**\n * Report Definitions Barrel\n *\n * ## Why these files annotate with `Report`, not `ReportInput`\n *\n * ObjectStack 17.0.0-rc.6 retired the `ReportInput` export and moved the bare\n * name onto the authoring shape, under the ADR-0122 convention that `X` is the\n * INPUT type and `XParsed` the post-parse one (defaults applied, transforms\n * run). The underlying type is unchanged \u2014 `z.input<typeof ReportSchema>`,\n * exactly what `ReportInput` named \u2014 so the annotations below still mean\n * \"authoring shape: optional fields with defaults may be omitted\".\n *\n * The rename is worth writing down because on rc.5 the name `Report` meant the\n * OPPOSITE (`z.infer`, the parsed shape). Anything that was annotated `Report`\n * before the upgrade silently changed meaning instead of failing to compile;\n * only `ReportInput` \u2014 removed outright \u2014 announced itself, via\n * `tsc --noEmit`. The same swap applies to `Action`, `Dashboard` and `Page`,\n * which this app also imports from `@objectstack/spec/ui` and which are all\n * used on authoring literals, i.e. the side the swap made more correct.\n */\n\nexport { AccountsByIndustryTypeReport } from './account.report';\nexport { LeadInflowByMonthSourceReport } from './lead.report';\nexport {\n  OpportunitiesByStageReport,\n  WonOpportunitiesByOwnerReport,\n  PipelineCoverageByQuarterReport,\n  OpportunityFunnelByOwnerStageReport,\n} from './opportunity.report';\nexport { CustomerChurnSignalsReport } from './churn.report';\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/sales/reports/account.report.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/sales/reports\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/sales/reports/account.report.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport type { Report } from '@objectstack/spec/ui';\n\nexport const AccountsByIndustryTypeReport: Report = {\n  name: 'accounts_by_industry_type',\n  label: 'Accounts by Industry and Type',\n  description: 'Matrix report showing accounts by industry and type',\n  dataset: 'account_metrics', rows: ['industry'], columns: ['type'], values: ['account_count', 'annual_revenue_sum'],\n  type: 'matrix',\n  runtimeFilter: { is_active: true },\n};\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/sales/reports/lead.report.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/sales/reports\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/sales/reports/lead.report.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport type { Report } from '@objectstack/spec/ui';\n\n/**\n * Lead engagement trend \u2014 matrix over `last_contacted_date` (a user-managed\n * datetime, so it can be set in seed data and varied across months for a\n * realistic demo). Lets a marketing-ops lead spot which channels we're\n * actively working month-over-month.\n *\n * `lead_metrics.last_contacted_date` declares the month bucket, so each column\n * represents one calendar month instead of a raw timestamp.\n */\nexport const LeadInflowByMonthSourceReport: Report = {\n  name: 'lead_inflow_by_month_source',\n  label: 'Lead Engagement by Month \u00D7 Source',\n  description: 'Contacted-lead volume per month, broken down by acquisition channel',\n  dataset: 'lead_metrics', rows: ['lead_source'], columns: ['last_contacted_date'], values: ['lead_count'],\n  type: 'matrix',\n  // A never-contacted lead has no engagement month, and grouping it produced a\n  // headerless '\u2014' column next to the real ones. This report counts CONTACTED\n  // leads (see the label/description), so the empty bucket is excluded at the\n  // source rather than rendered as a mystery column.\n  runtimeFilter: { last_contacted_date: { $ne: null } },\n};\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/sales/reports/opportunity.report.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/sales/reports\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/sales/reports/opportunity.report.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport type { Report } from '@objectstack/spec/ui';\n\nexport const OpportunitiesByStageReport: Report = {\n  name: 'opportunities_by_stage',\n  label: 'Opportunities by Stage',\n  description: 'Summary of opportunities grouped by stage',\n  dataset: 'opportunity_metrics', rows: ['stage'], values: ['total_amount', 'avg_probability'],\n  type: 'summary',\n  // `{current_year_start}` is a spec date macro (DATE_MACRO_TOKENS) resolved\n  // per-query, so the YTD window rolls with time instead of freezing the year\n  // the artifact was built into dist/objectstack.json.\n  runtimeFilter: { stage: { $ne: 'closed_lost' }, close_date: { $gte: '{current_year_start}' } },\n  chart: { type: 'bar', title: 'Pipeline by Stage', showLegend: true, xAxis: 'stage', yAxis: 'total_amount' }\n};\n\nexport const WonOpportunitiesByOwnerReport: Report = {\n  name: 'won_opportunities_by_owner',\n  label: 'Won Opportunities by Owner',\n  description: 'Closed won opportunities grouped by owner',\n  dataset: 'opportunity_metrics', rows: ['owner'], values: ['total_amount'],\n  type: 'summary',\n  runtimeFilter: { stage: 'closed_won' },\n  chart: { type: 'column', title: 'Revenue by Sales Rep', showLegend: false, xAxis: 'owner', yAxis: 'total_amount' }\n};\n\n/**\n * Quarterly pipeline coverage \u2014 the matrix view that powers the classic\n * sales-ops \"pipeline coverage\" conversation: each forecast category against\n * the quarter the deal is expected to close in. `close_quarter` is a dedicated\n * quarterly dimension over the same field; the trend widgets keep their\n * monthly `close_date` dimension.\n */\nexport const PipelineCoverageByQuarterReport: Report = {\n  name: 'pipeline_coverage_by_quarter',\n  label: 'Pipeline Coverage by Forecast \u00D7 Quarter',\n  description: 'Open pipeline amount by forecast category, bucketed by close quarter',\n  dataset: 'opportunity_metrics', rows: ['forecast_category'], columns: ['close_quarter'], values: ['total_amount', 'opp_count'],\n  type: 'matrix',\n  runtimeFilter: { stage: { $nin: ['closed_won', 'closed_lost'] } },\n};\n\n/**\n * Sales-rep funnel \u2014 two-level summary that mirrors how reps drill into their\n * own book of business. Exercises multi-level `rows` grouping (owner \u2192 stage)\n * over the dataset's measures.\n */\nexport const OpportunityFunnelByOwnerStageReport: Report = {\n  name: 'opportunity_funnel_owner_stage',\n  label: 'Opportunity Funnel by Owner \u2192 Stage',\n  description: 'Per-rep stage-by-stage pipeline funnel',\n  dataset: 'opportunity_metrics', rows: ['owner', 'stage'], values: ['total_amount', 'opp_count', 'avg_probability'],\n  type: 'summary',\n  runtimeFilter: { stage: { $ne: 'closed_lost' } },\n  chart: { type: 'funnel', title: 'Pipeline Funnel', showLegend: false, xAxis: 'stage', yAxis: 'total_amount' },\n};\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/sales/reports/churn.report.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/sales/reports\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/sales/reports/churn.report.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport type { Report } from '@objectstack/spec/ui';\n\n/**\n * Customer Churn Signals \u2014 a \"joined\" report that gives a Customer Success\n * Manager a one-screen view of the four populations that matter for\n * proactive churn intervention:\n *\n *   1. CSM-Flagged          \u2014 accounts a human has marked at_risk / churning\n *   2. At-Risk Accounts     \u2014 active accounts with no activity in 60+ days\n *   3. Silent High-Value    \u2014 strategic/enterprise accounts gone quiet (90+ days)\n *   4. Recently Closed-Lost \u2014 opportunities lost in the last 30 days\n *\n * Each block is an independent sub-report; the joined renderer stacks them\n * vertically. There is no container-level filter on this report \u2014 each block\n * carries its own scope because they query different objects (`crm_account`,\n * `crm_opportunity`) at different time horizons.\n *\n * Block 1 is deliberately FIRST and deliberately not time-windowed. Blocks 2-4\n * are all derived signals: the clock stopped, the tier is quiet, the deal was\n * lost. `crm_account.health_score` is the only churn signal in the model a\n * person *asserts* \u2014 a CSM who has been in the room sets `at_risk` or\n * `churning` by hand \u2014 so it is the strongest evidence on the page and it is\n * independent of every window below it. An account that is being talked to\n * daily and is still churning is invisible to blocks 2-4 by construction, and\n * that account is the whole reason this block exists (#1186).\n *\n * Time windows use the spec's date-macro placeholders (`{60_days_ago}`, \u2026,\n * DATE_MACRO_TOKENS in @objectstack/spec/data), which resolve per-query.\n * Computing the dates at module load froze them into dist/objectstack.json,\n * so every window silently stopped rolling on the day the artifact was built.\n *\n * Joined Reports demonstrate the spec's M3 capability: multi-block analytic\n * surfaces with shared chrome but independent data binding.\n */\nexport const CustomerChurnSignalsReport: Report = {\n  name: 'customer_churn_signals',\n  label: 'Customer Churn Signals',\n  description:\n    'Three-panel early-warning view: at-risk customers, silent high-value accounts, and recently-lost opportunities.',\n  type: 'joined',\n  blocks: [\n    {\n      // Named for the ACTOR, not the value, because `at_risk` is also a\n      // `health_score` option and `at_risk_accounts` is already the block\n      // below (a time window, nothing to do with the field). The two are\n      // allowed to overlap: this one asks \"who did a human flag\", that one\n      // asks \"whose clock stopped\".\n      name: 'csm_flagged_accounts',\n      label: 'CSM-Flagged Accounts',\n      description:\n        'Accounts a CSM has hand-flagged as at-risk or churning, grouped by type \u2014 human judgement, independent of the activity clock.',\n      type: 'summary',\n      dataset: 'account_metrics', rows: ['type'], values: ['account_count'],\n      // No date term on purpose (see the header). `is_active` matches the two\n      // account blocks below: a deactivated account has already churned, so it\n      // is not a retention queue item. Grouping by `type` separates a flagged\n      // CUSTOMER (revenue at risk today) from a flagged prospect or partner,\n      // which the grid view `crm_account.at_risk_accounts` cannot show \u2014 it is\n      // scoped to `type: 'customer'` before anything else.\n      runtimeFilter: {\n        is_active: true,\n        health_score: { $in: ['at_risk', 'churning'] },\n      },\n    },\n    {\n      name: 'at_risk_accounts',\n      label: 'At-Risk Accounts',\n      description: 'Active accounts with no activity in 60+ days, grouped by industry.',\n      type: 'summary',\n      dataset: 'account_metrics', rows: ['industry'], values: ['account_count'],\n      runtimeFilter: {\n        is_active: true,\n        last_activity_date: { $lt: '{60_days_ago}' },\n      },\n    },\n    {\n      name: 'silent_high_value',\n      label: 'Silent High-Value Accounts',\n      description: 'Strategic and enterprise accounts gone quiet for 90+ days, grouped by type.',\n      type: 'summary',\n      dataset: 'account_metrics', rows: ['type'], values: ['account_count'],\n      // \"High-value\" is the account's tier, not a revenue threshold: the\n      // strategic/enterprise tiers are exactly the book the CSM team owns.\n      runtimeFilter: {\n        is_active: true,\n        tier: { $in: ['strategic', 'enterprise'] },\n        last_activity_date: { $lt: '{90_days_ago}' },\n      },\n    },\n    {\n      name: 'recently_closed_lost',\n      label: 'Recently Lost Opportunities',\n      description: 'Opportunities closed-lost in the last 30 days \u2014 investigate before the customer fully churns.',\n      type: 'summary',\n      dataset: 'opportunity_metrics', rows: ['owner'], values: ['total_amount', 'opp_count'],\n      runtimeFilter: {\n        stage: 'closed_lost',\n        close_date: { $gte: '{30_days_ago}' },\n      },\n    },\n  ],\n};\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/sales/mappings/index.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/sales/mappings\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/sales/mappings/index.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\n/**\n * Import mapping barrel.\n *\n * Each entry is a reusable, governed column\u2192field projection referenced by\n * name from the import endpoint (`mappingName: 'crm_account_import'`), so a\n * customer loading their own spreadsheet never has to map columns by hand.\n * Templates with the matching headers live in `assets/import-templates/`, and\n * the business-facing walkthrough is\n * `content/docs/guides/importing-your-data.mdx`.\n */\n\nexport { AccountImportMapping } from './account_import.mapping';\nexport { ContactImportMapping } from './contact_import.mapping';\nexport { LeadImportMapping } from './lead_import.mapping';\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/sales/mappings/account_import.mapping.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/sales/mappings\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/sales/mappings/account_import.mapping.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport { defineMapping } from '@objectstack/spec/data';\nimport { INDUSTRY_SYNONYMS } from './_shared';\n\n/**\n * Account import mapping \u2014 \"here is my accounts spreadsheet, load it\".\n *\n * Used by passing `mappingName: 'crm_account_import'` to the import endpoint\n * (`POST /api/v1/data/crm_account/import/jobs`) instead of hand-building a\n * per-column mapping in the request. The columns below are the ones a normal\n * CRM/spreadsheet export carries; `assets/import-templates/accounts.csv` is a\n * ready-made sheet with exactly these headers.\n *\n * Behaviour worth knowing before changing anything here:\n *\n * - **Strict projection.** A named mapping emits ONLY the targets listed\n *   below \u2014 every other column in the customer's file is dropped rather than\n *   passed through (`packages/rest/src/import-mapping.ts`). That is the point:\n *   an export from another system carries dozens of columns that must not\n *   reach the write path. It also means a field that is not listed here can\n *   never be imported through this mapping.\n * - **Upsert key.** `crm_account.name` carries a unique index, so it is the\n *   natural business key: re-running the same file updates rather than\n *   duplicates. Source names are matched verbatim \u2014 the import path has no\n *   case/whitespace normalisation step, so \"Acme Corp\" and \"ACME Corp\" are two\n *   accounts. `trimWhitespace` (on by default) removes padding only.\n * - **`mode` / `upsertKey` are DEFAULTS.** An explicit `writeMode` /\n *   `matchFields` in the request still wins.\n */\nexport const AccountImportMapping = defineMapping({\n  name: 'crm_account_import',\n  label: 'Account Import (CSV)',\n  targetObject: 'crm_account',\n  sourceFormat: 'csv', // also accepted for .xlsx uploads \u2014 both are tabular\n  mode: 'upsert',\n  upsertKey: ['name'],\n\n  fieldMapping: [\n    { source: 'Account Name', target: 'name' },\n\n    {\n      source: 'Account Type',\n      target: 'type',\n      transform: 'map',\n      params: {\n        valueMap: {\n          'Client': 'customer',\n          'Reseller': 'partner',\n          'Churned': 'former',\n          'Lost Customer': 'former',\n        },\n      },\n    },\n\n    {\n      source: 'Industry',\n      target: 'industry',\n      transform: 'map',\n      params: { valueMap: INDUSTRY_SYNONYMS },\n    },\n\n    // The account hook rejects a website that is not http(s) \u2014 keep full URLs\n    // in the source sheet (see `src/sales/objects/account.hook.ts`).\n    { source: 'Website', target: 'website' },\n    { source: 'Phone', target: 'phone' },\n    { source: 'Annual Revenue', target: 'annual_revenue' },\n    { source: 'Employees', target: 'number_of_employees' },\n    { source: 'Description', target: 'description' },\n\n    // Owner resolution. VERIFIED against the platform import path\n    // (`packages/rest/src/import-runner.ts` \u2192 `resolveRef`): a reference cell\n    // is resolved against the referenced object by `id`, the field's\n    // `displayField`, then `name` / `title` / `label` / `full_name` / `email` /\n    // `username`. `sys_user` has an `email` column, so an owner-email cell\n    // resolves to that user's id \u2014 no separate resolution step is needed here.\n    // An address that matches no user FAILS the row (`reference_not_found`);\n    // leaving the cell BLANK is the supported fallback \u2014 the security\n    // middleware's insert-time stamp then makes the importing user the owner\n    // (the import write carries the importer's context, not `isSystem`).\n    //\n    // The target is `owner_id`, the platform ownership anchor \u2014 #548 retired\n    // the app-authored `owner` lookup this used to name. A resolved cell is\n    // therefore an ownership TRANSFER: it plants the row under someone other\n    // than the importer, which the #3004 guard denies unless the importing user\n    // holds `allowTransfer` (system_admin / sales_manager do). That is the\n    // intended posture \u2014 a bulk file that silently reassigns the book is\n    // exactly what the grant exists to gate.\n    { source: 'Account Owner Email', target: 'owner_id', transform: 'lookup' },\n\n    // Self-reference: a parent named later in the same file still resolves \u2014\n    // the runner flushes buffered creates and retries once (framework#3148).\n    { source: 'Parent Account', target: 'parent_account', transform: 'lookup' },\n\n    // NOT MAPPED \u2014 `billing_address` / `office_location` are structured\n    // (json-backed `address` / `location`) fields. A joined string is not a\n    // way in: the engine rejects it per row \u2014 measured, `Billing Address has an\n    // invalid address value: Invalid input: expected object, received string`.\n    // (The dry run does NOT predict that rejection; it reports the row ok.\n    // Framework-side, filed as objectstack-ai/objectstack#4633.)\n    // Address columns are therefore left out of the account template. A target\n    // may now name a declared PART of a compound field \u2014 `contact_import.mapping.ts`\n    // maps five columns into `mailing_address.street` \u2026 `.country` (#1836) \u2014 so\n    // adding address columns here would be a template change, not a platform gap.\n  ],\n});\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/sales/mappings/_shared.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/sales/mappings\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/sales/mappings/_shared.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\n/**\n * Shared value maps for the import mappings.\n *\n * The import path already matches a picklist cell against the field's option\n * VALUE exactly and its LABEL case-insensitively (`import-coerce.ts` \u2192\n * `matchOption`), so \"Technology\" (label) and \"technology\" (value) both land\n * without any help from us \u2014 but an upper-cased value does NOT: \"HR\" is\n * neither the value `hr` nor the label \"Human Resources\" (#1998). These maps\n * exist only for the vocabulary a spreadsheet uses that matches no option \u2014\n * the words a Salesforce/HubSpot/Excel export writes that HotCRM has no option\n * for (\"SaaS\", \"Trade Show\", \"Client\"), and the abbreviations our own shipped\n * templates write (\"HR\"). Anything not listed here falls through\n * untouched and is matched normally; an unknown value fails its row with\n * `invalid_option` rather than being silently dropped.\n *\n * Keep these lists small and defensible. They are a translation table for\n * known synonyms, NOT a \"make any spreadsheet work\" fallback \u2014 every entry\n * here is a value a real export produces, and the row-level error is the\n * intended outcome for everything else.\n */\n\n/** Foreign spellings \u2192 `INDUSTRY_OPTIONS` values (`src/sales/objects/_picklists.ts`). */\nexport const INDUSTRY_SYNONYMS: Record<string, string> = {\n  'SaaS': 'software',\n  'Saas': 'software',\n  'IT': 'technology',\n  'Tech': 'technology',\n  'Information Technology': 'technology',\n  'Financial Services': 'finance',\n  'Banking': 'finance',\n  'Insurance': 'finance',\n  'Health Care': 'healthcare',\n  'Pharmaceuticals': 'healthcare',\n  'E-commerce': 'retail',\n  'Ecommerce': 'retail',\n  'Consumer Goods': 'retail',\n  'Transportation': 'logistics',\n  'Utilities': 'energy',\n  'Oil & Gas': 'energy',\n  'Public Sector': 'government',\n  'Non Profit': 'nonprofit',\n  'Non-Profit': 'nonprofit',\n  'NGO': 'nonprofit',\n  'Travel & Hospitality': 'hospitality',\n};\n\n/** Foreign spellings \u2192 `LEAD_SOURCE_OPTIONS` values. */\nexport const LEAD_SOURCE_SYNONYMS: Record<string, string> = {\n  'Website': 'web',\n  'Web Site': 'web',\n  'Inbound': 'web',\n  'Word of mouth': 'referral',\n  'Customer Referral': 'referral',\n  'Trade Show': 'event',\n  'Conference': 'event',\n  'Seminar': 'webinar',\n  'Partner Referral': 'partner',\n  'Google Ads': 'paid_search',\n  'AdWords': 'paid_search',\n  'SEM': 'paid_search',\n  'LinkedIn': 'social',\n  'Facebook': 'social',\n  'X': 'social',\n  'Twitter': 'social',\n  'Blog': 'content',\n  'Whitepaper': 'content',\n  'Phone Inquiry': 'cold_call',\n  'Outbound': 'cold_call',\n  'Email': 'email_campaign',\n  'Newsletter': 'email_campaign',\n};\n\n/**\n * Spellings \u2192 `crm_contact.department` option values. The shipped\n * `assets/import-templates/contacts.csv` writes eight departments; seven are\n * option labels and land unaided, \"HR\" is the one that matches nothing (#1998).\n * \u26D4 The template is a customer-facing contract (#1836) \u2014 the fix lives here,\n * not in the file.\n */\nexport const DEPARTMENT_SYNONYMS: Record<string, string> = {\n  'HR': 'hr',\n};\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/sales/mappings/contact_import.mapping.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/sales/mappings\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/sales/mappings/contact_import.mapping.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport { defineMapping } from '@objectstack/spec/data';\nimport { DEPARTMENT_SYNONYMS, LEAD_SOURCE_SYNONYMS } from './_shared';\n\n/**\n * Contact import mapping \u2014 see `account_import.mapping.ts` for the shared\n * notes on strict projection and on `mode` / `upsertKey` acting as defaults.\n *\n * Contact-specific things to know:\n *\n * - **Accounts first.** `crm_contact.crm_account` is a REQUIRED master-detail\n *   link, so the \"Account Name\" column must name an account that already\n *   exists. Import accounts before contacts; a row whose account cannot be\n *   resolved fails with `reference_not_found` and nothing is written for it.\n * - **Email is the business key.** It is `required` + `unique` on the object,\n *   and `crm_contact`'s hook lowercases it and rejects a second contact with\n *   the same address \u2014 so `upsertKey: ['email']` matches how the object\n *   already behaves rather than inventing a second notion of identity.\n * - Address: the template's five `Mailing \u2026` columns stay as they are, and\n *   each one targets a part of the structured `mailing_address` field\n *   (`mailing_address.street`, \u2026) \u2014 the customer's file did not change when\n *   the five flat `mailing_*` fields became one `Field.address()` (#1836).\n */\nexport const ContactImportMapping = defineMapping({\n  name: 'crm_contact_import',\n  label: 'Contact Import (CSV)',\n  targetObject: 'crm_contact',\n  sourceFormat: 'csv',\n  mode: 'upsert',\n  upsertKey: ['email'],\n\n  fieldMapping: [\n    { source: 'Salutation', target: 'salutation' },\n    { source: 'First Name', target: 'first_name' },\n    { source: 'Last Name', target: 'last_name' },\n\n    // Required master-detail parent; resolved by account name.\n    { source: 'Account Name', target: 'crm_account', transform: 'lookup' },\n\n    { source: 'Title', target: 'title' },\n    {\n      source: 'Department',\n      target: 'department',\n      transform: 'map',\n      params: { valueMap: DEPARTMENT_SYNONYMS },\n    },\n    { source: 'Email', target: 'email' },\n    { source: 'Phone', target: 'phone' },\n    { source: 'Mobile', target: 'mobile' },\n\n    // Five template columns, one structured field: each column names a part\n    // of `mailing_address`, and the import assembles the parts one row maps\n    // into that field's single value.\n    { source: 'Mailing Street', target: 'mailing_address.street' },\n    { source: 'Mailing City', target: 'mailing_address.city' },\n    { source: 'Mailing State', target: 'mailing_address.state' },\n    { source: 'Mailing Postal Code', target: 'mailing_address.postalCode' },\n    { source: 'Mailing Country', target: 'mailing_address.country' },\n\n    {\n      source: 'Lead Source',\n      target: 'lead_source',\n      transform: 'map',\n      params: { valueMap: LEAD_SOURCE_SYNONYMS },\n    },\n\n    { source: 'Description', target: 'description' },\n\n    // Owner-email resolution, the blank-cell fallback, and why a filled cell\n    // needs `allowTransfer`: see the long note in `account_import.mapping.ts`.\n    { source: 'Contact Owner Email', target: 'owner_id', transform: 'lookup' },\n  ],\n});\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/sales/mappings/lead_import.mapping.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/sales/mappings\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/sales/mappings/lead_import.mapping.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport { defineMapping } from '@objectstack/spec/data';\nimport { INDUSTRY_SYNONYMS, LEAD_SOURCE_SYNONYMS } from './_shared';\n\n/**\n * Lead import mapping \u2014 see `account_import.mapping.ts` for the shared notes\n * on strict projection and on `mode` / `upsertKey` acting as defaults.\n *\n * Lead-specific things to know:\n *\n * - **Email is the business key** (`required` on the object), so a re-run of\n *   the same file updates the existing lead instead of creating a twin.\n * - **`status` has a default of `new`** \u2014 leave the column blank and the lead\n *   lands as New. `crm_lead`'s state machine only accepts an initial status,\n *   so importing a mid-lifecycle status is a normal write here, not a\n *   transition.\n * - **A blank owner lands with the IMPORTER, not with auto-assignment.**\n *   `lead_auto_assign` (`src/sales/objects/lead.hook.ts`) only routes a lead whose\n *   `owner_id` is still empty when the hook runs \u2014 and the import write carries\n *   the importer's own context, so the security middleware has ALREADY stamped\n *   `owner_id` to them by the time `beforeInsert` runs (the guard is an\n *   operation middleware, outside the hook phase). Measured on a real import\n *   before #548, when a field `defaultValue` produced the same outcome one step\n *   earlier: all 50 template rows landed owned by the importing user, none by\n *   the round-robin. Fill \"Lead Owner Email\" when the source file knows who\n *   owns the lead; otherwise reassign after the import.\n */\nexport const LeadImportMapping = defineMapping({\n  name: 'crm_lead_import',\n  label: 'Lead Import (CSV)',\n  targetObject: 'crm_lead',\n  sourceFormat: 'csv',\n  mode: 'upsert',\n  upsertKey: ['email'],\n\n  fieldMapping: [\n    { source: 'Salutation', target: 'salutation' },\n    { source: 'First Name', target: 'first_name' },\n    { source: 'Last Name', target: 'last_name' },\n    { source: 'Company', target: 'company' },\n    { source: 'Title', target: 'title' },\n\n    {\n      source: 'Industry',\n      target: 'industry',\n      transform: 'map',\n      params: { valueMap: INDUSTRY_SYNONYMS },\n    },\n\n    { source: 'Email', target: 'email' },\n    { source: 'Phone', target: 'phone' },\n    { source: 'Mobile', target: 'mobile' },\n    { source: 'Website', target: 'website' },\n\n    {\n      source: 'Lead Status',\n      target: 'status',\n      transform: 'map',\n      params: {\n        valueMap: {\n          'Open': 'new',\n          'Working': 'contacted',\n          'In Progress': 'contacted',\n          'Nurturing': 'contacted',\n          'Disqualified': 'unqualified',\n          'Closed - Not Converted': 'unqualified',\n        },\n      },\n    },\n\n    {\n      source: 'Lead Source',\n      target: 'lead_source',\n      transform: 'map',\n      params: { valueMap: LEAD_SOURCE_SYNONYMS },\n    },\n\n    { source: 'Annual Revenue', target: 'annual_revenue' },\n    { source: 'Employees', target: 'number_of_employees' },\n    { source: 'Description', target: 'description' },\n\n    // Owner-email resolution and the `allowTransfer` gate on a filled cell:\n    // see the long note in `account_import.mapping.ts`. The blank-cell\n    // behaviour differs \u2014 see the header comment above.\n    { source: 'Lead Owner Email', target: 'owner_id', transform: 'lookup' },\n\n    // NOT MAPPED \u2014 `crm_lead.address` is a structured (json-backed) `address`\n    // field; the import path cannot compose one from separate street/city/\n    // postcode columns, and a joined string is rejected per row. Same\n    // reasoning, and the same measurement, as the account mapping.\n  ],\n});\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/sales/apps/index.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/sales/apps\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/sales/apps/index.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\n/**\n * App Definitions Barrel\n */\n\nexport { CrmApp } from './crm.app';\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/sales/apps/crm.app.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/sales/apps\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/sales/apps/crm.app.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport { App } from '@objectstack/spec/ui';\n\n// The brand mark, inlined as a `data:` URI of `assets/icon.svg` (#2051), so it\n// travels inside the published artifact. The path it replaces,\n// `/runtime/assets/icon.svg` (#731), resolves only under `objectstack serve`\n// run from this repo \u2014 the CLI's `createRuntimeAssetsPlugin` mounts the\n// project's `assets/` there. A hosted install runs the artifact, which carried\n// the path but not the file, and its runtime mounts no `/runtime/assets/`: the\n// logo answered 404 on every hosted environment. The SVG's own bytes, with only\n// `%`, `#` and line breaks percent-encoded: a raw `#` would start a URL fragment\n// and a raw newline is stripped by the URL parser. `assets/icon.svg` stays the\n// single source \u2014 `test/app-branding-icon.test.ts` decodes this URI as a browser\n// does and requires the file's exact bytes back, so edit the file, then this.\nconst HOTCRM_ICON =\n  'data:image/svg+xml,' +\n  '<svg width=\"256\" height=\"256\" viewBox=\"0 0 256 256\" fill=\"none\" xmlns=\"http://www.w3.org/2000/svg\" role=\"img\" aria-label=\"HotCRM\">%0A' +\n  '  <rect x=\"16\" y=\"16\" width=\"224\" height=\"224\" rx=\"56\" fill=\"%23EA580C\"/>%0A' +\n  '  <path d=\"M76 64h40v52h24V64h40v128h-40v-52h-24v52H76z\" fill=\"%23FFFFFF\"/>%0A' +\n  '</svg>%0A';\n\n/**\n * HotCRM \u2014 navigation.\n *\n * Intentionally narrow. The app sells one story: \"the CRM that rewrites\n * itself when your business changes,\" and `content/docs/whats-new.mdx`\n * promises a nav \"a new user can find their way around in 30 seconds.\"\n *\n * ## One entry per destination, one exemplar per nav-item type (#1259)\n *\n * The sidebar had grown to 7 groups / 31 items, almost entirely through one\n * pattern: the same object surfaced again and again through its own views \u2014\n * `crm_event` had four entries, `crm_opportunity` three \u2014 while every list\n * page already carries a view-switcher tab strip that reaches all of them.\n * Those redundant view entries are gone; each removed destination stays one\n * click away on its object's tab strip \u2014 which the console builds from the\n * VIEW DESCRIPTORS in `src/<pkg>/views/*.view.ts`: the primary `list` plus every\n * `listViews` entry, one tab each, carrying that view's own `label`. So\n * reachability needs nothing authored; a `listViews` entry is on the strip by\n * existing. What `test/view-references.test.ts` \u2192 \"every named list view is\n * reachable\" holds is the half that CAN dangle \u2014 a navigation entry naming a\n * view no view file defines.\n *\n * What is NOT trimmed is the demonstration. This is the exemplar app, and\n * nav items come in six kinds \u2014 plain `object`, object + `viewName` (a view\n * entry), `page`, `dashboard`, `report`, `component`. **Every kind keeps at\n * least one entry**, because showing an author what each kind looks like is\n * part of what this app is for. `test/app-navigation-shape.test.ts` pins that\n * floor, so a future slimming pass cannot delete the last exemplar of a kind\n * without going red.\n *\n * Personalisation rides the platform's pin + recent mechanisms rather than\n * pre-materialising every possible entry for every user.\n */\nexport const CrmApp = App.create({\n  name: 'crm_enterprise',\n  label: 'HotCRM',\n  icon: 'briefcase',\n  // ADR-0063 \u00A71/\u00A72 \u2014 `defaultAgent` is a surface binding, not a custom-agent\n  // slot: the only resolvable values are the two PLATFORM agents, `ask` (data\n  // surface) and `build` (authoring surface). HotCRM is a data surface, so it\n  // binds `ask`; the app's own AI capability ships as skills (`src/*/skills/`),\n  // which attach to the platform agents by `surface` affinity. The app-authored\n  // agents this key used to name were retired in #512.\n  defaultAgent: 'ask',\n  // `logo` and `favicon` are the inlined `HOTCRM_ICON` above (#2051), never a\n  // server path: an install serves only what the artifact carries. The console\n  // passes each value through untouched \u2014 `logo` as the sidebar's `<img src>`,\n  // `favicon` as the favicon `link.href` \u2014 and a `data:` URI renders in both.\n  // `primaryColor` is the icon's tile fill (#2066): the mark and the theme are one orange.\n  branding: {\n    primaryColor: '#EA580C',\n    logo: HOTCRM_ICON,\n    favicon: HOTCRM_ICON,\n  },\n\n  navigation: [\n    // Pinned landing \u2014 single executive view, single click from launcher.\n    {\n      id: 'nav_home',\n      type: 'dashboard',\n      dashboardName: 'executive_dashboard',\n      label: 'Home',\n      icon: 'home',\n    },\n\n    {\n      id: 'group_sales',\n      type: 'group',\n      label: 'Sales',\n      icon: 'chart-line',\n      expanded: true,\n      children: [\n        { id: 'nav_lead',        type: 'object', objectName: 'crm_lead',        label: 'Leads',         icon: 'user-plus' },\n        { id: 'nav_account',     type: 'object', objectName: 'crm_account',     label: 'Accounts',      icon: 'building' },\n        // ADR-0047 interface page \u2014 the curated counterpart to the Accounts\n        // object entry (quick filters only; activates with spec > 9.2.0).\n        { id: 'nav_account_workbench', type: 'page', pageName: 'account_workbench', label: 'Account Workbench', icon: 'sliders-horizontal' },\n        { id: 'nav_contact',     type: 'object', objectName: 'crm_contact',     label: 'Contacts',      icon: 'user' },\n        // No separate \"Pipeline\" entry: the kanban board is another tab on\n        // this same list page \u2014 `pipeline_kanban` in\n        // `OpportunityViews.listViews`, which the switcher puts on the strip\n        // under its own label, *Sales Pipeline* \u2014 one click from here and\n        // zero clicks further than a second sidebar row. The\n        // view-entry exemplar duty this item used to carry now sits with the\n        // \"My Work\" items below, which are all object + `viewName`.\n        { id: 'nav_opportunity', type: 'object', objectName: 'crm_opportunity', label: 'Opportunities', icon: 'target' },\n        { id: 'nav_quote',       type: 'object', objectName: 'crm_quote',       label: 'Quotes',        icon: 'receipt' },\n        // Contracts close the sales cycle: quote \u2192 signed agreement \u2192 renewal.\n        // The object, its views and its renewal automation all shipped, but\n        // there was no way to reach any of it from the app.\n        { id: 'nav_contract',    type: 'object', objectName: 'crm_contract',    label: 'Contracts',     icon: 'file-signature' },\n        // Products sit here, not under Marketing (#1259): they are the\n        // revenue master data every quote line and opportunity line item\n        // points at \u2014 a sales object that happened to be filed next to\n        // campaigns.\n        { id: 'nav_product',     type: 'object', objectName: 'crm_product',     label: 'Products',      icon: 'package' },\n        { id: 'nav_sales_dashboard', type: 'dashboard', dashboardName: 'sales_dashboard', label: 'Sales Performance', icon: 'chart-line' },\n      ],\n    },\n\n    {\n      // Everything a rep owes someone. `crm_task` had views, seed data, a\n      // recurrence hook and two reminder flows, and no entry point \u2014 the only\n      // way to see a task was to open the record it hung off.\n      id: 'group_work',\n      type: 'group',\n      label: 'My Work',\n      icon: 'list-checks',\n      expanded: true,\n      // These are ListViews: they list the records themselves, which a\n      // dashboard widget (an aggregate over a dataset, ADR-0021) cannot. Both\n      // surfaces resolve `{current_user_id}` since objectstack#12230 \u2014 the\n      // Service dashboard's \"My Open Cases by Priority\" is the aggregate\n      // counterpart of \"My Cases\" (#510).\n      //\n      // Every item here is object + `viewName`, which makes this group the\n      // app's view-entry exemplar since #1259 retired the \"Pipeline\" row.\n      // The one exception is the approvals Inbox at the bottom \u2014 a\n      // `component` entry, and the app's only one.\n      children: [\n        { id: 'nav_my_tasks', type: 'object', objectName: 'crm_task', viewName: 'my_open_tasks', label: 'My Tasks', icon: 'circle-check' },\n        { id: 'nav_my_deals', type: 'object', objectName: 'crm_opportunity', viewName: 'my_open_deals', label: 'My Deals', icon: 'target' },\n        { id: 'nav_my_leads', type: 'object', objectName: 'crm_lead', viewName: 'my_leads', label: 'My Leads', icon: 'user-plus' },\n        // #592 \u2014 the rep's own calendar: a list of events, so a view, not a\n        // dashboard.\n        { id: 'nav_my_calendar', type: 'object', objectName: 'crm_event', viewName: 'my_events', label: 'My Calendar', icon: 'calendar-days' },\n        // No \"All Tasks\" entry: \"My Tasks\" opens the `crm_task` list page,\n        // whose tab strip leads with *All Tasks* \u2014 `TaskViews.list`, name\n        // `all_tasks`. It leads because it is the object's PRIMARY list: the\n        // switcher moves the primary to the front of the strip and marks it\n        // default, so nothing has to be authored to say so. The whole book is\n        // one tab away, and the sidebar keeps one row per object instead of\n        // two.\n        //\n        // \u2500\u2500 The approvals Inbox lives here, not in a group of its own (#1259)\n        //\n        // It used to be the single child of an \"Approvals\" group. Its content\n        // is a personal queue \u2014 the things waiting on *you* \u2014 which is what\n        // this group is; a one-item group next to it was structure without a\n        // distinction. Dissolving that group is why this entry moved, not any\n        // rule against single-item groups (Marketing is one and stays one).\n        //\n        // \"Inbox\" (zh-CN \u5F85\u6211\u5BA1\u6279) must land somewhere an approver can actually\n        // approve. It used to be `type: 'object'` on `sys_approval_request` \u2014\n        // the approvals plugin's raw request table, which is read-only: no row\n        // actions, no approve/reject, only Share on the record detail. The label\n        // promised an action the destination could not perform (#1123).\n        //\n        // `component` \u2014 not `url`. The platform's approval centre is a\n        // first-party console surface registered in the ComponentRegistry as\n        // `approvals:inbox` (registered by @objectstack/console itself, source\n        // `@object-ui/console`, rendering ApprovalsInboxPage) \u2014 exactly what the\n        // spec documents `component` for: \"a first-party UI shipped with the\n        // platform \u2014 typically admin/setup surfaces that have no row in any data\n        // store\". `url` is documented as the *external link* type, and taking it\n        // would mean hard-coding a console-internal route plus this app's own\n        // name (`/apps/crm_enterprise/system/approvals`) into metadata. A\n        // `componentRef` instead resolves against the *current* app base, so the\n        // entry keeps the user inside HotCRM's shell without naming the app, and\n        // a ref that ever stops resolving renders a loud \"Component not\n        // registered\" panel rather than silently bouncing to the console home.\n        //\n        // The read-only object list is not kept as a second \"history\" entry: the\n        // approval centre already subsumes it \u2014 My Pending / Submitted by me /\n        // All tabs plus a status filter (Pending / Approved / Rejected /\n        // Recalled / Returned for revision) \u2014 so a second entry would add a\n        // strictly weaker view of the same rows.\n        //\n        // `requiresObject` is retained: it is a base nav-item field on every\n        // item type, so the entry still hides itself on installs where\n        // @objectstack/plugin-approvals is absent and no approval exists to act\n        // on.\n        //\n        // There is no \"Processes\" item either: @objectstack/plugin-approvals\n        // registers sys_approval_request / sys_approval_action /\n        // sys_approval_approver / sys_approval_delegation \u2014 but neither a bare\n        // `sys_approval` nor a `sys_approval_process` object exists in any\n        // installed plugin (measured on the 17.2.0 rosters),\n        // so the old item's requiresObject guard hid it on every install,\n        // forever.\n        { id: 'nav_approval_requests', type: 'component', componentRef: 'approvals:inbox', label: 'Inbox', icon: 'inbox', requiresObject: 'sys_approval_request' },\n      ],\n    },\n\n    {\n      // #592 \u2014 activity was the app's largest blind spot: `crm_event` and its\n      // attendee rows had nowhere to be seen, and no dashboard anywhere counted\n      // an interaction. Kept as its own group rather than buried under Sales,\n      // because \"what happened with this customer, and when?\" is the question\n      // the whole batch was about.\n      id: 'group_activity',\n      type: 'group',\n      label: 'Activity',\n      icon: 'calendar-days',\n      expanded: true,\n      children: [\n        // One row for the object, one for the dashboard. The calendar and the\n        // interaction history are two more tabs on this same list page \u2014\n        // `event_calendar` and `held_events` in `EventViews.listViews`, which\n        // the switcher puts on the strip under each view's own label \u2014 #1259\n        // removed the sidebar duplicates, not the surfaces. `crm_event` had\n        // four sidebar rows;\n        // it was the single largest source of the nav's growth.\n        { id: 'nav_event',          type: 'object',    objectName: 'crm_event',   label: 'Events',          icon: 'calendar-days' },\n        { id: 'nav_activity_dashboard', type: 'dashboard', dashboardName: 'sales_activity_dashboard', label: 'Sales Activity', icon: 'activity' },\n      ],\n    },\n\n    {\n      // Campaigns drive lead_source and the campaign-member records that\n      // \"Add to Campaign\" writes \u2014 with no nav entry the marketing half of\n      // the data model was invisible.\n      //\n      // A single-item group on purpose (#1259). Marketing is a domain of its\n      // own, and a reader scanning the sidebar for \"where does campaign work\n      // live\" finds it by name. Item-count symmetry is not the goal; the\n      // Approvals group was dissolved because its item *was* personal work,\n      // not because one child is too few.\n      id: 'group_marketing',\n      type: 'group',\n      label: 'Marketing',\n      icon: 'megaphone',\n      children: [\n        { id: 'nav_campaign', type: 'object', objectName: 'crm_campaign', label: 'Campaigns', icon: 'megaphone' },\n      ],\n    },\n\n    {\n      id: 'group_service',\n      type: 'group',\n      label: 'Service',\n      icon: 'headset',\n      expanded: true,\n      // EMPTY ON PURPOSE \u2014 this group is a CONTAINER, not a menu.\n      //\n      // `crm_case`, `crm_knowledge_article`, `service_dashboard` and\n      // `sla_performance` belong to `app.objectstack.hotcrm.service`, and an\n      // app's own `navigation` may not name another package's object (ADR-0130\n      // \u00A71.5): the entry fails at author time with \"references object\n      // `crm_case` which is not defined in objects\". The module puts all three\n      // back through `navigationContributions` (ADR-0029 D7), and it can only\n      // aim at a group the app DECLARES \u2014 a module cannot create one inside an\n      // app it does not own. So the app publishes the anchor and the module\n      // fills it; `src/service/index.ts` holds the other half, and the two\n      // service items of *My Work* and *Insights* come back the same way.\n      //\n      // \u26D4 Do not \"tidy\" the group away: deleting it relocates all three\n      // contributed items to the app's top level with a\n      // `nav_contribution_group_missing` warning.\n      children: [],\n    },\n\n    {\n      id: 'group_insights',\n      type: 'group',\n      label: 'Insights',\n      icon: 'sparkles',\n      children: [\n        // Trimmed to three high-signal reports. Full report catalogue still\n        // ships as metadata; admins can pin more from the report picker.\n        { id: 'nav_crm_dashboard',            type: 'dashboard', dashboardName: 'crm_overview_dashboard', label: 'CRM Overview',      icon: 'layout-dashboard' },\n        { id: 'nav_forecast',                 type: 'object', objectName: 'crm_forecast',                 label: 'Forecasts',         icon: 'trending-up' },\n        { id: 'nav_report_pipeline_coverage', type: 'report', reportName: 'pipeline_coverage_by_quarter', label: 'Pipeline Coverage', icon: 'columns-3' },\n        { id: 'nav_report_lead_inflow',       type: 'report', reportName: 'lead_inflow_by_month_source',  label: 'Lead Inflow',       icon: 'trending-up' },\n      ],\n    },\n\n  ],\n});\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/sales/profiles/index.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/sales/profiles\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/sales/profiles/index.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\n/**\n * Profile Definitions Barrel\n *\n * \u2500\u2500\u2500 `allowExport` \u2014 the opt-in bulk-egress axis (@objectstack 17, #3544) \u2500\u2500\u2500\n *\n * This is the canonical note; the profiles point here.\n *\n * Before 17.0 the export axis was advisory: an unset `allowExport` inherited\n * read, so \"can list \u21D2 can export\" and the bit only ever hid a button. 17.0\n * makes it a real gate and inverts the default \u2014 `resolveUserExportAllowed`\n * (plugin-security) returns true only for an explicit `allowExport: true`, and\n * neither `viewAllRecords` nor `modifyAllRecords` substitutes for it. An unset\n * bit now DENIES.\n *\n * WHERE it is enforced, measured on a running dev server (#798). One route\n * carries bulk egress in this app: `GET /api/v1/data/:object/export`\n * (`csv` / `xlsx` / `json`), gated by `enforceExportPermission` \u2192\n * `security.canExport` in `@objectstack/rest`. A principal holding the grant\n * gets 200 and the rows; one without it gets 403 `EXPORT_NOT_PERMITTED`.\n *\n * A list view's `exportOptions` is NOT a second door \u2014 it declares which\n * formats the toolbar's Export button offers, and that button calls the very\n * same route. So the gate is object-wide and reachable with `curl`, which is\n * exactly why it has to be enforced server-side rather than by hiding a button.\n *\n * SHAPE (@objectstack/spec 17.0.0, #8010, maintainer ruling 2026-08-12): the\n * declaration is the OBJECT form `exportOptions: { formats: ['csv', 'xlsx'] }`.\n * The bare array this app used through 17.0.0-rc.6 is the legacy spelling; it\n * still parses and LIFTS to `{ formats: [...] }`, so `z.input` accepts both\n * while `z.output` \u2014 everything that reads loaded metadata, this app's own\n * guards included \u2014 only ever sees the object. That asymmetry is why the bump\n * to 17.0.0 blinded the guard below rather than failing it: the views still\n * declared their surfaces, and a reader testing the legacy array's `.length`\n * silently measured `undefined` on every one of them. Read `.formats`.\n * `'pdf'` left the format enum in the same change (#1301 NOT_PLANNED); this\n * app never declared it.\n *\n * `ReportService.assertExportAllowed` is a genuinely separate gate, but it\n * belongs to the `reports` capability (saved reports + emailed digests over\n * `sys_saved_report`), which this app does not require \u2014 `/api/v1/reports`\n * answers 501 on a default boot, and the Console's report page ships no export\n * affordance either way. It is not what any grant below lands on. Do not read\n * the rule below as depending on it: #798 was filed on exactly that reading.\n *\n * So the grants below are authored, not inherited. The rule, pinned by\n * `test/authorization-coverage.test.ts`:\n *\n *   a profile grants `allowExport` on an object IFF it already holds\n *   `allowRead` there AND the app ships an export surface for that object \u2014\n *   that is, a list view declaring `exportOptions`.\n *\n * That rule is an AUTHORING DISCIPLINE about which affordances this app ships,\n * not a statement about reachability: the export route exists for every\n * API-exposed object, so a grant on any of them would work. The discipline\n * keeps the grant list to objects a user can actually reach an export from,\n * so the permission table stays a description of the product rather than of\n * the platform. Reachability is pinned separately, by the `enable` guard at\n * the end of that same test file.\n *\n * That union is exactly `crm_account`, `crm_case`, `crm_contact`, `crm_lead`,\n * `crm_opportunity` today, each behind the `exportOptions` on its own list\n * view. Adding `exportOptions` to a view means adding the matching grant here\n * in the same change \u2014 the guard fails otherwise, which is the point: a\n * surface nobody can use is the failure this axis exists to make loud instead\n * of silent.\n *\n * A REPORT IS NOT AN EXPORT SURFACE. The Console's report page renders a chart\n * and a data table and offers no download (measured on a running server in\n * #798), and `ReportService`'s own export gate belongs to the `reports`\n * capability above. Until #817 the guard counted reports anyway, and\n * `crm_case` hung off that leg alone: the grant was live but reachable only by\n * `curl`, and deleting the case reports would have made the guard demand this\n * useful grant be deleted with them. #817 gave the Cases list view its own\n * `exportOptions` and retired the report leg, so a report over some future\n * dataset no longer conjures a grant requirement out of a page with no\n * download button.\n *\n * Export is READ-DERIVED (`export \u2286 list`), so the grant opens the door but\n * does not widen the rows: record scope, RLS and sharing still apply on top. A\n * `sales_rep` exporting `crm_opportunity` gets their own book, not the org's.\n *\n * `guest_portal` deliberately carries none. Per ADR-0090 D9 a set holding\n * `allowExport` is high-privilege and cannot be bound to the `everyone` or\n * `guest` anchors at all \u2014 granting it there would both hand anonymous\n * visitors bulk table egress and make the set unbindable.\n */\n/**\n * \u2500\u2500\u2500 `allowTransfer` \u2014 the ownership-transfer axis (#548) \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n *\n * This is the canonical note; the profiles point here.\n *\n * HotCRM has ONE owner column: the platform's `owner_id`, injected into every\n * business object by the registry (`applySystemFields`) and auto-stamped to the\n * inserting user. It is the column OWD, sharing rules, owner-scope widening and\n * the `is_private` row filter all read \u2014 so whoever can write it decides who may\n * see and edit the row.\n *\n * The app used to author its own `owner` lookup beside it. Reassigning that\n * field moved the record in every list and report and moved NO access at all,\n * and it did so for any user with plain edit rights \u2014 a transfer with none of\n * the transfer semantics. #548 removed it.\n *\n * With one column, ownership writes go through the platform's gate: an\n * insert planting a record under another user, or an update reassigning /\n * disowning one, is DENIED unless the caller holds `allowTransfer` \u2014 enforced\n * today through the ordinary insert/update door, not merely declared\n * (`@objectstack/spec` `permission.zod.ts`, the #3004 owner_id guard).\n * `modifyAllRecords` implies it. Two writes are deliberately NOT transfers and\n * need no grant: an insert leaving `owner_id` empty (auto-stamped to the\n * caller) and a form save echoing the unchanged owner back.\n *\n * The rule the grants below follow, pinned by\n * `test/authorization-coverage.test.ts`:\n *\n *   `allowTransfer` is granted IFF the set already holds `allowEdit` on that\n *   object, and only to `system_admin` (every business object) and\n *   `sales_manager` (exactly the objects it holds `modifyAllRecords` on \u2014 the\n *   sales book it owns the number for).\n *\n * On those objects `modifyAllRecords` already implies the bit, so authoring it\n * grants nothing new. It is authored anyway, for the same reason `allowExport`\n * is: the capability a persona is meant to have should be readable in the\n * profile, and it must survive a future narrowing of `modifyAllRecords` rather\n * than disappearing with it. Reps and service agents hold no transfer grant \u2014\n * for them ownership is assigned, never taken.\n */\n\nexport { GuestPortalProfile } from './guest-portal.profile';\nexport { MarketingUserProfile } from './marketing-user.profile';\nexport { SalesManagerProfile } from './sales-manager.profile';\nexport { SalesRepProfile } from './sales-rep.profile';\nexport { ServiceAgentProfile } from './service-agent.profile';\nexport { ServiceManagerProfile } from './service-agent.profile';\nexport { SystemAdminProfile } from './system-admin.profile';\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/sales/profiles/guest-portal.profile.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/sales/profiles\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/sales/profiles/guest-portal.profile.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\n/**\n * Guest Portal Profile\n *\n * Permission set applied to anonymous (unauthenticated) visitors who submit\n * the public Web-to-Lead and Web-to-Case forms.\n *\n * IRON-CLAD RULE: guests must NEVER be able to read existing CRM data.\n * The only thing they can do is INSERT a new `crm_lead` or `crm_case` row through\n * the form views whose `sharing.allowAnonymous = true`.\n *\n * Any new object added to the CRM stack is implicitly DENIED for guests \u2014\n * profile permissions are explicit-allow only.\n *\n * That includes every object granted to internal profiles by #488. In\n * particular `crm_knowledge_article` stays denied even though its `audience`\n * field marks some articles public: a customer-facing article surface would be\n * served by a portal view with `sharing.allowAnonymous`, never by widening the\n * guest set to read a CRM object.\n */\nexport const GuestPortalProfile = {\n  name: 'guest_portal',\n  label: 'Guest (Public Forms)',\n  description:\n    'Anonymous visitors submitting public Web-to-Lead / Web-to-Case forms. ' +\n    'INSERT-only on lead and case; no read/edit/delete on any object.',\n  // No `allowExport` anywhere below, deliberately: this set is bound to the\n  // `guest` anchor, and ADR-0090 D9 classes `allowExport` as a high-privilege\n  // bit no anchor may confer \u2014 the set would stop binding at all, on top of\n  // handing anonymous visitors bulk table egress. See `src/sales/profiles/index.ts`.\n  objects: {\n    crm_lead: {\n      allowCreate: true,\n      allowRead: false,\n      allowEdit: false,\n      allowDelete: false,\n      viewAllRecords: false,\n      modifyAllRecords: false,\n    },\n    crm_case: {\n      allowCreate: true,\n      allowRead: false,\n      allowEdit: false,\n      allowDelete: false,\n      viewAllRecords: false,\n      modifyAllRecords: false,\n    },\n  },\n};\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/sales/profiles/marketing-user.profile.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/sales/profiles\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/sales/profiles/marketing-user.profile.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nexport const MarketingUserProfile = {\n  name: 'marketing_user',\n  label: 'Marketing User',\n  objects: {\n    // `allowExport` where an export surface exists \u2014 canonical note in\n    // `src/sales/profiles/index.ts`. Lead and contact list exports are marketing's\n    // core targeting workflow; account/opportunity back the campaign-ROI\n    // reports. No `crm_case` grant here, so no export bit for it either.\n    crm_lead:        { allowCreate: true,  allowRead: true,  allowEdit: true,  allowDelete: false, viewAllRecords: true,  modifyAllRecords: false, allowExport: true },\n    crm_account:     { allowCreate: false, allowRead: true,  allowEdit: false, allowDelete: false, viewAllRecords: true,  modifyAllRecords: false, allowExport: true },\n    crm_contact:     { allowCreate: true,  allowRead: true,  allowEdit: true,  allowDelete: false, viewAllRecords: true,  modifyAllRecords: false, allowExport: true },\n    crm_campaign:    { allowCreate: true,  allowRead: true,  allowEdit: true,  allowDelete: false, viewAllRecords: true,  modifyAllRecords: false },\n    // Org-wide read: marketing attributes campaign \u2192 pipeline ROI, which needs\n    // every opportunity, not just self-owned. viewAllRecords was false here\n    // while every other object on this set is true \u2014 an oversight that hid all\n    // pipeline from marketing (and tripped security-private-no-readscope).\n    crm_opportunity: { allowCreate: false, allowRead: true,  allowEdit: false, allowDelete: false, viewAllRecords: true,  modifyAllRecords: false, allowExport: true },\n    // Campaign membership is THIS profile's core write surface: the\n    // \"Add to Campaign\" action (`src/sales/actions/lead.actions.ts`) inserts\n    // `crm_campaign_member` rows, and before #488 no permission set granted the\n    // object \u2014 the action failed for the only persona meant to run it. Rows\n    // derive from the campaign (controlled_by_parent), so there is no record\n    // scope to author \u2014 and as of 17.0.0-rc.4 that derivation does follow the\n    // campaign grant: MEASURED and pinned by\n    // `test/parent-derived-reach.test.ts`, master accessibility resolves through\n    // the same paths a direct read of the campaign takes, ownership and\n    // `sys_record_share` grants included. For THIS profile the delta is small \u2014\n    // `crm_campaign` is `public_read` and this set holds org-wide campaign read,\n    // so the rows are the same either way \u2014 but the grant is now scope that\n    // follows the campaigns above, not org-wide read in fact as it was through\n    // 17.0.0-rc.3 (objectstack-ai/objectstack#5386, #694).\n    // Deleting membership history stays a manager/admin privilege, matching\n    // every other object here.\n    crm_campaign_member: { allowCreate: true, allowRead: true, allowEdit: true, allowDelete: false, viewAllRecords: false, modifyAllRecords: false },\n    // Read-only reference: knowledge articles for campaign copy\n    // (public_read catalog).\n    // Reads the KB and may rate it; cannot author articles (#601).\n    crm_article_feedback: { allowCreate: true, allowRead: true, allowEdit: true, allowDelete: false, viewAllRecords: true, modifyAllRecords: false },\n    crm_knowledge_article: { allowCreate: false, allowRead: true, allowEdit: false, allowDelete: false, viewAllRecords: true, modifyAllRecords: false },\n    // The record Attachments panel, READ only: canonical note on `enable.files`\n    // in `src/sales/objects/index.ts` (#2029). Which attachments it lists\n    // derives from the parent record; upload and delete wait upstream.\n    sys_attachment: { allowCreate: false, allowRead: true, allowEdit: false, allowDelete: false, viewAllRecords: false, modifyAllRecords: false },\n    // The record Discussion panel, comments and activity: canonical note on\n    // `enable.feeds` in `src/sales/objects/index.ts` (#2029). Which threads it\n    // reaches derives from the parent record; deleting a comment waits upstream.\n    sys_comment:  { allowCreate: true,  allowRead: true, allowEdit: true,  allowDelete: false, viewAllRecords: false, modifyAllRecords: false },\n    sys_activity: { allowCreate: false, allowRead: true, allowEdit: false, allowDelete: false, viewAllRecords: false, modifyAllRecords: false },\n  },\n  fields: {\n    // Marketing reads pipeline for campaign ROI but never prices a deal, and\n    // account health is the renewal team's call \u2014 read, never write (#488).\n    'crm_opportunity.amount':   { readable: true, editable: false },\n    'crm_account.health_score': { readable: true, editable: false },\n  },\n  // The same private-deal row filter the sales_manager set carries: this\n  // profile also holds org-wide opportunity read, so it is one of the readers\n  // `crm_opportunity.is_private` has to hold back. See sales-manager.profile.ts\n  // for the full rationale.\n  rowLevelSecurity: [\n    {\n      name: 'opportunity_private_owner_only_marketing',\n      // A deal flagged Private is visible only to its owner, even to holders of\n      // org-wide opportunity read. (`rowLevelSecurity[].label` / `description`\n      // are display copy \u2014 the 17.7.0 liveness ledger marks both live: the\n      // permission editor draws them on the policy card. This policy authors\n      // neither, so its intent lives in this comment.)\n      object: 'crm_opportunity',\n      operation: 'select' as const,\n      using: 'is_private == false || owner_id == current_user.id',\n    },\n    // The platform's `member_default` set carries a wildcard owner-only-writes\n    // policy (`created_by == current_user.id` on update), and RLS policies are\n    // OR-combined \u2014 so without a policy of its own, this set's allowEdit on\n    // campaigns only reaches campaigns the user personally created. That also\n    // silently broke \"Add to Campaign\": enrolling a member is a write DERIVED\n    // from the campaign (controlled_by_parent), so it requires campaign edit at\n    // the row level. This is the one direction in which the ADR-0055 derivation\n    // really does narrow: a master RLS policy is exactly what it folds in, while\n    // ownership and `sys_record_share` grants are not (which is why the READ\n    // side of these member rows is org-wide \u2014 see the `crm_campaign_member`\n    // grant above and objectstack-ai/objectstack#5386, #694). This policy widens\n    // campaign updates to every holder of the set \u2014 exactly what the object\n    // grant above already declares. `id != null`\n    // is the pushdown-safe \"all rows\" predicate (verified: compiles to\n    // `{id: {$null: false}}`).\n    {\n      name: 'marketing_campaign_updates',\n      // Marketing users edit any campaign (and thereby enrol members into it),\n      // not only campaigns they created.\n      object: 'crm_campaign',\n      operation: 'update' as const,\n      using: 'id != null',\n    },\n    // Same widening for the member rows themselves: response tracking means\n    // updating rows the enrollment flow (system context) created, which the\n    // default owner-only-writes policy would otherwise deny.\n    {\n      name: 'marketing_campaign_member_updates',\n      // Marketing users update member response state on rows they did not\n      // personally create.\n      object: 'crm_campaign_member',\n      operation: 'update' as const,\n      using: 'id != null',\n    },\n  ],\n};\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/sales/profiles/sales-manager.profile.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/sales/profiles\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/sales/profiles/sales-manager.profile.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\n/**\n * Sales Manager Profile\n *\n * Org-wide on the sales stack: a manager owns the number, so they read and\n * modify every rep's record rather than only their own.\n */\nexport const SalesManagerProfile = {\n  name: 'sales_manager',\n  label: 'Sales Manager',\n  objects: {\n    // `allowTransfer` on exactly the objects this set holds `modifyAllRecords`\n    // on \u2014 the sales book a manager reassigns. Canonical note in\n    // `src/sales/profiles/index.ts`.\n    // `allowExport` where an export surface exists \u2014 canonical note in\n    // `src/sales/profiles/index.ts`. A manager owns the number, so the pipeline and\n    // book exports that feed offline forecasting are part of the job.\n    crm_lead:        { allowCreate: true,  allowRead: true, allowEdit: true,  allowDelete: true,  viewAllRecords: true,  modifyAllRecords: true, allowTransfer: true, allowExport: true },\n    crm_account:     { allowCreate: true,  allowRead: true, allowEdit: true,  allowDelete: true,  viewAllRecords: true,  modifyAllRecords: true, allowTransfer: true, allowExport: true },\n    crm_contact:     { allowCreate: true,  allowRead: true, allowEdit: true,  allowDelete: true,  viewAllRecords: true,  modifyAllRecords: true, allowTransfer: true, allowExport: true },\n    crm_opportunity: { allowCreate: true,  allowRead: true, allowEdit: true,  allowDelete: true,  viewAllRecords: true,  modifyAllRecords: true, allowTransfer: true, allowExport: true },\n    crm_quote:       { allowCreate: true,  allowRead: true, allowEdit: true,  allowDelete: true,  viewAllRecords: true,  modifyAllRecords: true, allowTransfer: true },\n    // No writeScope: `crm_contract` is `controlled_by_parent` under\n    // `crm_account` (#549), so a scope here would be inert \u2014 the write gate\n    // asks for EDIT on the account instead, which this set holds org-wide\n    // (`modifyAllRecords` above). That retires the #880 gap on BOTH editions:\n    // the contract an accepted quote drafts hangs under the rep, and the\n    // manager edits it because they can edit its account, not because of a\n    // hierarchy depth. `own_and_reports` was the app's only authored hierarchy\n    // scope; `requires: ['hierarchy-security']` stays declared (#1378 ruling).\n    // `allowDelete: false` must keep holding; `modifyAllRecords: false` keeps\n    // this off the super-user bypass. `test/contract-write-depth.test.ts`.\n    crm_contract:    { allowCreate: true,  allowRead: true, allowEdit: true,  allowDelete: false, viewAllRecords: true,  modifyAllRecords: false },\n    crm_product:     { allowCreate: true,  allowRead: true, allowEdit: true,  allowDelete: false, viewAllRecords: true,  modifyAllRecords: false },\n    crm_campaign:    { allowCreate: true,  allowRead: true, allowEdit: true,  allowDelete: false, viewAllRecords: true,  modifyAllRecords: false },\n    crm_case:        { allowCreate: false, allowRead: true, allowEdit: false, allowDelete: false, viewAllRecords: true,  modifyAllRecords: false, allowExport: true },\n    crm_task:        { allowCreate: true,  allowRead: true, allowEdit: true,  allowDelete: true,  viewAllRecords: true,  modifyAllRecords: true, allowTransfer: true },\n    // A manager coaches on activity, so this is org-wide read AND write on a\n    // private object \u2014 the same shape their `crm_task` grant already has.\n    // `crm_event_attendee` is `controlled_by_parent` (ADR-0055): no scope to\n    // author \u2014 one would be inert metadata. It narrows to the events this set\n    // can read, which is every event: `viewAllRecords` on `crm_event` above puts\n    // the whole activity stack in reach, so the derived attendee rows follow.\n    // MEASURED on 17.0.0-rc.4 and pinned by `test/parent-derived-reach.test.ts`,\n    // master accessibility resolves through the same paths a direct read of the\n    // event takes \u2014 ownership and `sys_record_share` grants folded in, not the\n    // master's row-level security policies alone. Until 17.0.0-rc.3 this grant\n    // was org-wide in FACT rather than by derivation, whatever the event grants\n    // said (#694); objectstack-ai/objectstack#5386 fixed that upstream and it\n    // shipped in rc.4. Same note in `sales-rep.profile.ts`.\n    crm_event:       { allowCreate: true,  allowRead: true, allowEdit: true,  allowDelete: true,  viewAllRecords: true,  modifyAllRecords: true, allowTransfer: true },\n    crm_event_attendee: { allowCreate: true, allowRead: true, allowEdit: true, allowDelete: true, viewAllRecords: false, modifyAllRecords: false },\n    // The forecast IS the manager's job: they read every rep's snapshot and\n    // adjust the committed number, so this is org-wide read AND write on a\n    // private object (#488 \u2014 the object had no grant at all).\n    crm_forecast:    { allowCreate: true,  allowRead: true, allowEdit: true,  allowDelete: false, viewAllRecords: true,  modifyAllRecords: true, allowTransfer: true },\n    // Knowledge is service-authored; sales reads it (public_read OWD).\n    // Reads the KB and may rate it; cannot author articles (#601).\n    crm_article_feedback: { allowCreate: true, allowRead: true, allowEdit: true, allowDelete: false, viewAllRecords: true, modifyAllRecords: false },\n    crm_knowledge_article: { allowCreate: false, allowRead: true, allowEdit: false, allowDelete: false, viewAllRecords: true, modifyAllRecords: false },\n    // Enrollment is marketing's job; a manager only reads the membership rows\n    // behind campaign ROI. `crm_campaign_member` is `controlled_by_parent`, so\n    // no readScope/viewAllRecords applies (ADR-0055) \u2014 but the rows do not\n    // \"follow the campaign\": the derivation resolves the master set through the\n    // master's RLS policies only (none narrow a select on `crm_campaign`), so\n    // this is org-wide read on every member row. The practical delta is small\n    // here \u2014 `crm_campaign` is `public_read` and this set reads every campaign\n    // anyway \u2014 so the intended derivation would return the same rows. See\n    // `campaign_member.object.ts` and objectstack-ai/objectstack#5386 (#694).\n    crm_campaign_member:   { allowCreate: false, allowRead: true, allowEdit: false, allowDelete: false, viewAllRecords: false, modifyAllRecords: false },\n    // Line items: full CRUD so a manager can fix pricing on any rep's deal or\n    // quote. Both objects are `controlled_by_parent`, so there is no scope to\n    // author \u2014 but that derivation does not narrow these rows to the deals and\n    // quotes the manager can read. MEASURED (see the note in\n    // `sales-rep.profile.ts` and `test/parent-derived-reach.test.ts`): the master\n    // set comes from the master's RLS policies only, never from ownership or a\n    // share. This set authors one such policy \u2014 the private-deal filter on\n    // `crm_opportunity` below \u2014 and none on `crm_quote`, so quote lines are\n    // org-wide, and opportunity lines are bounded by that policy and nothing\n    // else (the guard test pins the quote chain; the opportunity side follows\n    // from the same measured mechanism). Upstream gap:\n    // objectstack-ai/objectstack#5386 (#694).\n    crm_opportunity_line_item: { allowCreate: true, allowRead: true, allowEdit: true, allowDelete: true, viewAllRecords: false, modifyAllRecords: false },\n    crm_quote_line_item:       { allowCreate: true, allowRead: true, allowEdit: true, allowDelete: true, viewAllRecords: false, modifyAllRecords: false },\n    // The record Attachments panel, READ only: canonical note on `enable.files`\n    // in `src/sales/objects/index.ts` (#2029). Which attachments it lists\n    // derives from the parent record; upload and delete wait upstream.\n    sys_attachment: { allowCreate: false, allowRead: true, allowEdit: false, allowDelete: false, viewAllRecords: false, modifyAllRecords: false },\n    // The record Discussion panel, comments and activity: canonical note on\n    // `enable.feeds` in `src/sales/objects/index.ts` (#2029). Which threads it\n    // reaches derives from the parent record; deleting a comment waits upstream.\n    sys_comment:  { allowCreate: true,  allowRead: true, allowEdit: true,  allowDelete: false, viewAllRecords: false, modifyAllRecords: false },\n    sys_activity: { allowCreate: false, allowRead: true, allowEdit: false, allowDelete: false, viewAllRecords: false, modifyAllRecords: false },\n  },\n  fields: {\n    // Sensitive fields a manager must see in full. Authored explicitly rather\n    // than left absent: these are the fields other sets mask, and an unauthored\n    // grant reads as an oversight instead of a decision (#488).\n    'crm_opportunity.amount':   { readable: true, editable: true },\n    'crm_account.health_score': { readable: true, editable: true },\n    'crm_quote.internal_notes': { readable: true, editable: true },\n    // Case internal notes are the service team's working memory: a sales\n    // manager reads them for account context but never edits them.\n    'crm_case.internal_notes':  { readable: true, editable: false },\n  },\n  // ADR-0058: `crm_opportunity.is_private` is settable in the opportunity form\n  // (`opportunity.view.ts`) and, before this rule, was read by nothing \u2014 a\n  // checkbox that promised confidentiality and delivered none. Org-wide readers\n  // are exactly who it has to hold back, so the set that grants\n  // `viewAllRecords` on opportunities also carries the row filter that honours\n  // it. Compiles to `{ $or: [{ is_private: false }, { owner_id: <caller> }] }`.\n  //\n  // `owner_id`, not the app-authored `owner` lookup this used to name: #548\n  // retired that field. The predicate now keys on the SAME column the OWD /\n  // sharing owner-match reads, so \"its owner\" means one thing app-wide.\n  rowLevelSecurity: [\n    {\n      name: 'opportunity_private_owner_only',\n      // A deal flagged Private is visible only to its owner, even to holders of\n      // org-wide opportunity read. (`rowLevelSecurity[].label` / `description`\n      // are display copy \u2014 the 17.7.0 liveness ledger marks both live: the\n      // permission editor draws them on the policy card. This policy authors\n      // neither, so its intent lives in this comment.)\n      object: 'crm_opportunity',\n      operation: 'select' as const,\n      using: 'is_private == false || owner_id == current_user.id',\n    },\n  ],\n};\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/sales/profiles/sales-rep.profile.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/sales/profiles\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/sales/profiles/sales-rep.profile.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nexport const SalesRepProfile = {\n  name: 'sales_rep',\n  label: 'Sales Representative',\n  // A rep's book of business is private by design (own records + whatever a\n  // sharing rule or team grant extends). The objects below carry an explicit\n  // `readScope: 'own'` so the intent is authored, not inferred \u2014 this both\n  // silences the `security-private-no-readscope` liveness warning and pins the\n  // behavior: without it, a private-OWD object with allowRead but no scope is\n  // an under-specified grant the engine reads as \"own only\" anyway.\n  //\n  // What widens that scope today is narrower than it sounds: the territory /\n  // account-team rules are authored on `crm_account` ONLY, and a sharing rule\n  // widens the object it names \u2014 not the records hanging off it. So a rep who\n  // receives an account through a territory rule reads that account, while the\n  // tasks on it stay own-only and opportunities widen only through the\n  // >= $100k leadership rules. Quotes and contracts are the exception since\n  // #549 (ruling 2026-08-31): both are `controlled_by_parent` under the\n  // account, so they arrive with it \u2014 the same derivation as contacts.\n  //\n  // The `controlled_by_parent` grants below read as narrow, and as of\n  // 17.0.0-rc.4 they ARE. MEASURED and pinned by\n  // `test/parent-derived-reach.test.ts`: the ADR-0055 derivation resolves master\n  // accessibility through the same paths a direct read of the master takes \u2014\n  // owner scope AND `sys_record_share` grants, not the master's row-level\n  // security policies alone. A rep holding ONE account through a territory rule\n  // reads that account's contacts and no others, and reads line items only under\n  // the quotes they can reach. Writes derive the same way: a child of a master\n  // the rep cannot edit is refused. So each grant below is bounded by the\n  // parent's sharing, which is what it looks like.\n  //\n  // Until 17.0.0-rc.3 the same grants were org-wide reads and this note said so\n  // (#694): the derivation consulted master RLS policies only, and HotCRM\n  // authors none, so the master set was every record.\n  // objectstack-ai/objectstack#5386 fixed that upstream and it shipped in rc.4.\n  objects: {\n    // `allowExport` where an export surface exists \u2014 canonical note in\n    // `src/sales/profiles/index.ts`. Safe alongside `readScope: 'own'`: export is\n    // read-derived, so a rep's CSV carries their own book, not the org's.\n    crm_lead:        { allowCreate: true,  allowRead: true,  allowEdit: true,  allowDelete: false, viewAllRecords: false, modifyAllRecords: false, readScope: 'own' as const, allowExport: true },\n    crm_account:     { allowCreate: true,  allowRead: true,  allowEdit: true,  allowDelete: false, viewAllRecords: false, modifyAllRecords: false, readScope: 'own' as const, allowExport: true },\n    // NO readScope: `crm_contact` is `controlled_by_parent` (master-detail to\n    // crm_account), so a `readScope` here is inert \u2014 the sharing service only\n    // applies owner scope to `private` objects \u2014 and it read as a promise the\n    // engine never kept: it said \"own contacts only\" while access derived from\n    // the parent (#488). That derivation now delivers exactly \"the accounts the\n    // rep can read\": measured on 17.0.0-rc.4, a rep holding one territory\n    // account reads THAT account's contacts and no others (see the note at the\n    // top of this file, #694).\n    crm_contact:     { allowCreate: true,  allowRead: true,  allowEdit: true,  allowDelete: false, viewAllRecords: false, modifyAllRecords: false, allowExport: true },\n    crm_opportunity: { allowCreate: true,  allowRead: true,  allowEdit: true,  allowDelete: false, viewAllRecords: false, modifyAllRecords: false, readScope: 'own' as const, allowExport: true },\n    // NO readScope on quote/contract either: both are `controlled_by_parent`\n    // under `crm_account` (#549), so a scope here would be inert. A rep reads\n    // the quotes and contracts of every account they can reach, edits the\n    // quotes of accounts they can edit, and never edits a contract (object\n    // gate). `test/parent-derived-reach.test.ts` measures both levels.\n    crm_quote:       { allowCreate: true,  allowRead: true,  allowEdit: true,  allowDelete: false, viewAllRecords: false, modifyAllRecords: false },\n    crm_contract:    { allowCreate: false, allowRead: true,  allowEdit: false, allowDelete: false, viewAllRecords: false, modifyAllRecords: false },\n    crm_product:     { allowCreate: false, allowRead: true,  allowEdit: false, allowDelete: false, viewAllRecords: true,  modifyAllRecords: false },\n    crm_campaign:    { allowCreate: false, allowRead: true,  allowEdit: false, allowDelete: false, viewAllRecords: true,  modifyAllRecords: false },\n    crm_case:        { allowCreate: false, allowRead: true,  allowEdit: false, allowDelete: false, viewAllRecords: false, modifyAllRecords: false, readScope: 'own' as const, allowExport: true },\n    crm_task:        { allowCreate: true,  allowRead: true,  allowEdit: true,  allowDelete: true,  viewAllRecords: false, modifyAllRecords: false, readScope: 'own' as const },\n\n    // \u2500\u2500\u2500 Activity (#592) \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n    // `crm_event` is `private` like `crm_task` \u2014 a personal activity record \u2014\n    // so an explicit record scope is required alongside allowRead (an omitted\n    // scope silently means \"own only\" and reads as an unmade decision).\n    // `crm_event_attendee` is `controlled_by_parent`, so authoring a readScope\n    // here would be inert metadata the engine never applies. Its rows narrow to\n    // the events the rep can read \u2014 which, `crm_event` being private and\n    // own-scoped, is their own calendar (see the note at the top of this file,\n    // #694).\n    crm_event:       { allowCreate: true,  allowRead: true,  allowEdit: true,  allowDelete: true,  viewAllRecords: false, modifyAllRecords: false, readScope: 'own' as const },\n    crm_event_attendee: { allowCreate: true, allowRead: true, allowEdit: true, allowDelete: true, viewAllRecords: false, modifyAllRecords: false },\n    // Reference catalog (public_read OWD): reps read knowledge articles, which\n    // are authored by service.\n    // Reads the KB and may rate it; cannot author articles (#601).\n    crm_article_feedback: { allowCreate: true, allowRead: true, allowEdit: true, allowDelete: false, viewAllRecords: true, modifyAllRecords: false },\n    crm_knowledge_article: { allowCreate: false, allowRead: true, allowEdit: false, allowDelete: false, viewAllRecords: true,  modifyAllRecords: false },\n    // Forecast snapshots are written by the nightly `forecast.hook` job and the\n    // `revenue_forecasting` skill, never by hand \u2014 read-only, and only the rep's\n    // own snapshots (private OWD + explicit own scope, as above).\n    crm_forecast:          { allowCreate: false, allowRead: true, allowEdit: false, allowDelete: false, viewAllRecords: false, modifyAllRecords: false, readScope: 'own' as const },\n    // Product lines on deals and quotes. Both objects are\n    // `controlled_by_parent`, so there is no readScope to author \u2014 one would be\n    // inert metadata. That derivation scopes a rep to the lines under the deals\n    // and quotes they can reach: measured on 17.0.0-rc.4, a rep reads the lines\n    // of the one quote they own and none of the others (see the note at the top\n    // of this file, #694). Without these grants the opportunity \"Products\"\n    // related list and the whole CPQ path were denied for every non-admin user\n    // (#488).\n    crm_opportunity_line_item: { allowCreate: true, allowRead: true, allowEdit: true, allowDelete: true, viewAllRecords: false, modifyAllRecords: false },\n    crm_quote_line_item:       { allowCreate: true, allowRead: true, allowEdit: true, allowDelete: true, viewAllRecords: false, modifyAllRecords: false },\n    // Which campaign sourced a lead \u2014 read-only context, derived from the\n    // campaign (controlled_by_parent). Enrollment belongs to marketing_user.\n    crm_campaign_member:       { allowCreate: false, allowRead: true, allowEdit: false, allowDelete: false, viewAllRecords: false, modifyAllRecords: false },\n    // The record Attachments panel, READ only: canonical note on `enable.files`\n    // in `src/sales/objects/index.ts` (#2029). Which attachments it lists\n    // derives from the parent record; upload and delete wait upstream.\n    sys_attachment: { allowCreate: false, allowRead: true, allowEdit: false, allowDelete: false, viewAllRecords: false, modifyAllRecords: false },\n    // The record Discussion panel, comments and activity: canonical note on\n    // `enable.feeds` in `src/sales/objects/index.ts` (#2029). Which threads it\n    // reaches derives from the parent record; deleting a comment waits upstream.\n    sys_comment:  { allowCreate: true,  allowRead: true, allowEdit: true,  allowDelete: false, viewAllRecords: false, modifyAllRecords: false },\n    sys_activity: { allowCreate: false, allowRead: true, allowEdit: false, allowDelete: false, viewAllRecords: false, modifyAllRecords: false },\n  },\n  fields: {\n    'crm_account.annual_revenue':     { readable: true, editable: false },\n    'crm_account.description':        { readable: true, editable: true },\n    'crm_opportunity.amount':         { readable: true, editable: true },\n    'crm_opportunity.probability':    { readable: true, editable: true },\n    // Health score drives the renewal book and the at-risk views: reps see it,\n    // the renewal/CS process sets it. Readable (the `at_risk_accounts` view\n    // filters and sorts on it, and a masked field cannot be filtered) but never\n    // rep-editable \u2014 it was previously unauthored on every set (#488).\n    'crm_account.health_score':       { readable: true, editable: false },\n    // Quote internal notes stay rep-editable: `quote.hook` deliberately keeps\n    // them writable after a quote is sent, when nothing else is.\n    'crm_quote.internal_notes':       { readable: true, editable: true },\n    // Case internal notes are the service team's private working notes. A rep\n    // reads the case (own scope) for account context; the agent-only commentary\n    // inside it is masked \u2014 no view filters or sorts on this field, so masking\n    // costs nothing but the value itself.\n    'crm_case.internal_notes':        { readable: false, editable: false },\n  },\n};\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/sales/profiles/service-agent.profile.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/sales/profiles\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/sales/profiles/service-agent.profile.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nexport const ServiceAgentProfile = {\n  name: 'service_agent',\n  label: 'Service Agent',\n  objects: {\n    // Reference context an agent needs to work ANY ticket \u2014 a customer's cases\n    // are meaningless without seeing the account/contact behind them, so these\n    // are org-visible reads (viewAllRecords: true), NOT own-only. This was the\n    // security-private-no-readscope warning's real signal: allowRead on a\n    // private object with no scope had silently locked agents out of every\n    // account they didn't personally own.\n    // `allowExport` where an export surface exists \u2014 canonical note in\n    // `src/sales/profiles/index.ts`. `crm_opportunity` carries no export bit: this\n    // set has no read on it at all, and the axis never widens read.\n    crm_lead:        { allowCreate: false, allowRead: true,  allowEdit: false, allowDelete: false, viewAllRecords: true,  modifyAllRecords: false, allowExport: true },\n    crm_account:     { allowCreate: false, allowRead: true,  allowEdit: false, allowDelete: false, viewAllRecords: true,  modifyAllRecords: false, allowExport: true },\n    crm_contact:     { allowCreate: false, allowRead: true,  allowEdit: true,  allowDelete: false, viewAllRecords: true,  modifyAllRecords: false, allowExport: true },\n    crm_opportunity: { allowCreate: false, allowRead: false, allowEdit: false, allowDelete: false, viewAllRecords: false, modifyAllRecords: false },\n    // Cases + tasks: an agent's own queue by default (readScope: 'own').\n    // Cross-agent visibility exists for CASES only \u2014 the escalation rules widen\n    // open critical cases to service_manager / service_director. `crm_task` has\n    // no sharing rule at all, so an agent reading an account org-wide still\n    // sees only their own tasks on it (#549).\n    crm_case:        { allowCreate: true,  allowRead: true,  allowEdit: true,  allowDelete: false, viewAllRecords: false, modifyAllRecords: false, readScope: 'own' as const, allowExport: true },\n    // `allowTransfer` on `crm_task` ONLY \u2014 canonical note in\n    // `src/sales/profiles/index.ts`. Narrow and load-bearing: escalating a case fires\n    // `case_status_side_effects`, which opens the follow-up task OWNED BY the\n    // account owner (`case.hook.ts`). That insert runs on `ctx.api` with the\n    // agent's own context, so planting it under another user is a transfer and\n    // is denied without this bit \u2014 the case update would fail with it. This is\n    // \"assign work to a colleague\", not \"reassign the ticket\": the agent holds\n    // no transfer grant on `crm_case` or any customer record.\n    //\n    // \u26A0\uFE0F Escalation DOES now move a case to the `service_manager` pool (#1070),\n    // and it does so with no `crm_case` grant here \u2014 deliberately. That\n    // hand-off runs on the `beforeUpdate` seam, which the #3004 guard cannot\n    // see (measured, three readings, in `_case-assignment.ts`'s header and\n    // pinned in `test/case-assignment.test.ts`), so the case moves as part of\n    // the escalation write the automation is already performing rather than as\n    // an agent-initiated transfer. Doing it the other way \u2014 a `ctx.api` write\n    // from `afterUpdate` \u2014 WOULD need `crm_case.allowTransfer` here, which\n    // would let an agent reassign any case they can edit. That is a\n    // permission-model decision and is not being taken as a side effect of a\n    // hook: this line stays `crm_task` only.\n    crm_task:        { allowCreate: true,  allowRead: true,  allowEdit: true,  allowDelete: true,  viewAllRecords: false, modifyAllRecords: false, readScope: 'own' as const, allowTransfer: true },\n    // #592 \u2014 `log_call` / `log_meeting` are scoped to `crm_case` too, and an\n    // agent who cannot INSERT a `crm_event` gets a button that 403s. Same\n    // own-scoped shape as their tasks.\n    crm_event:       { allowCreate: true,  allowRead: true,  allowEdit: true,  allowDelete: true,  viewAllRecords: false, modifyAllRecords: false, readScope: 'own' as const },\n    crm_event_attendee: { allowCreate: true, allowRead: true, allowEdit: true, allowDelete: true, viewAllRecords: false, modifyAllRecords: false },\n    crm_product:     { allowCreate: false, allowRead: true,  allowEdit: false, allowDelete: false, viewAllRecords: true,  modifyAllRecords: false },\n    // The knowledge base is this team's own surface: agents draft and revise\n    // articles (draft \u2192 in_review \u2192 published is enforced by the KB flow, not by\n    // CRUD), and read every published article regardless of author. Archiving\n    // is destructive-by-policy, so deletion stays with admins. Before #488 the\n    // object had no grant at all \u2014 the \"Knowledge\" nav item was denied for\n    // everyone, including the agents it was built for.\n    // Agents rate the articles they use to close cases (#601). Create + edit\n    // their OWN row (`modifyAllRecords: false` keeps them off everyone else's\n    // vote); no delete \u2014 a withdrawn opinion is a changed verdict, not an\n    // erased one.\n    crm_article_feedback: { allowCreate: true, allowRead: true, allowEdit: true, allowDelete: false, viewAllRecords: true, modifyAllRecords: false },\n    crm_knowledge_article: { allowCreate: true, allowRead: true, allowEdit: true, allowDelete: false, viewAllRecords: true, modifyAllRecords: false },\n    // The record Attachments panel, READ only: canonical note on `enable.files`\n    // in `src/sales/objects/index.ts` (#2029). Which attachments it lists\n    // derives from the parent record; upload and delete wait upstream.\n    sys_attachment: { allowCreate: false, allowRead: true, allowEdit: false, allowDelete: false, viewAllRecords: false, modifyAllRecords: false },\n    // The record Discussion panel, comments and activity: canonical note on\n    // `enable.feeds` in `src/sales/objects/index.ts` (#2029). Which threads it\n    // reaches derives from the parent record; deleting a comment waits upstream.\n    sys_comment:  { allowCreate: true,  allowRead: true, allowEdit: true,  allowDelete: false, viewAllRecords: false, modifyAllRecords: false },\n    sys_activity: { allowCreate: false, allowRead: true, allowEdit: false, allowDelete: false, viewAllRecords: false, modifyAllRecords: false },\n  },\n  fields: {\n    'crm_case.is_sla_violated':        { readable: true, editable: false },\n    'crm_case.resolution_time_hours':  { readable: true, editable: false },\n    // Internal notes are the agent's working memory on a ticket \u2014 full access\n    // here, read-only for sales_manager, masked for sales_rep (#488).\n    'crm_case.internal_notes':         { readable: true, editable: true },\n    // Account health is renewal-team data an agent reads for context only.\n    'crm_account.health_score':        { readable: true, editable: false },\n  },\n};\n\n/**\n * The SERVICE MANAGER binding (#1779) \u2014 the same set, under the position's name.\n *\n * ### What was ruled\n *\n * `service_manager` is a declared position (`src/sales/sharing/positions.ts`) that\n * `case_escalation_sharing` names and that `case_escalation_reassign` routes\n * escalating cases to \u2014 measured, 35 of them on a demo box \u2014 and no permission\n * set reached it, so the persona was denied every CRM object (403). Director\n * seat, decision batch #92, 2026-09-08, under the maintainer's standing\n * \u300C\u7EE7\u7EED\u51B3\u7B56\u300D delegation: bind the EXISTING `service_agent` set to the\n * `service_manager` position. \u26D4 B (author a manager-specific profile) was\n * refused \u2014 no measured puller for a manager-only grant. \u26D4 C (reroute the\n * escalation pool) was refused \u2014 it deletes the persona's reason to exist.\n *\n * ### Why the binding is a NAME and not a key \u2014 measured, not inferred\n *\n * There is no authorable binding on either side. `PermissionSetSchema` rejects\n * `profiles` / `roles` / `users`, and `PositionSchema` rejects `permissionSets`\n * with its own prescription: capability reaches a position ONLY through\n * `sys_position_permission_set` rows, \"created in Setup or by an app's\n * `kernel:ready` binder\" \u2014 and a pure-metadata app ships neither.\n *\n * What it ships instead is a name. Measured on a fresh 17.3.0 SQLite box:\n * `sys_position_permission_set` holds exactly ONE row (`everyone` \u2192\n * `member_default`, the ADR-0090 D5 baseline the platform binds itself), and\n * yet `POST /api/v1/security/explain` for a `service_agent` position holder\n * answers `permissionSets: [service_agent, member_default]`, crediting the\n * object-level grant to `[service_agent]` `via: position:service_agent`. The\n * resolver is `resolvePermissionSets()` in `@objectstack/plugin-security`: it\n * matches the caller's POSITION NAMES against declared `PermissionSet.name`,\n * so a set named for a position is bound to it with no row at all.\n *\n * \u21D2 For this app, \"bind set X to position P\" has exactly one spelling: declare\n * X's grants under the name P. Hence this export rather than a new file.\n *\n * ### Why a spread and not a copy\n *\n * `objects` and `fields` are carried by REFERENCE, so the two personas share\n * one grant table and cannot drift: nothing here can widen the agent's grants,\n * and a future edit to them lands on both at once. That is the ruling's own\n * finding \u2014 escalation handling is the same object access as working a ticket \u2014\n * expressed in a way the next reader cannot half-apply. \u26D4 Do not expand this\n * into a literal second grant table to \"make it explicit\"; that would be\n * option B, refused, and it would let the two silently diverge.\n *\n * ### Reversal (ruling item 4)\n *\n * If a customer needs a manager grant that DIFFERS from an agent's, it comes\n * back as a product card with the puller named \u2014 and only then does this become\n * an authored set of its own.\n */\nexport const ServiceManagerProfile = {\n  ...ServiceAgentProfile,\n  name: 'service_manager',\n  label: 'Service Manager',\n};\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/sales/profiles/system-admin.profile.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/sales/profiles\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/sales/profiles/system-admin.profile.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\n/**\n * System Administrator Profile\n *\n * The admin set must cover EVERY business object this app ships. Permission\n * sets are explicit-allow only (see `guest-portal.profile.ts`), so an object\n * missing from this map is permission-denied for admins too: the object-level\n * CRUD gate rejects the call before OWD, sharing or `view_all_data` is ever\n * consulted. `test/authorization-coverage.test.ts` pins that coverage so a new\n * object cannot ship without landing here.\n */\nexport const SystemAdminProfile = {\n  name: 'system_admin',\n  label: 'System Administrator',\n  objects: {\n    // `allowTransfer` on every object \u2014 canonical note in `src/sales/profiles/index.ts`.\n    // The admin is the persona that reassigns ownership when someone leaves.\n    // `allowExport` on the five objects with an export surface \u2014 see the\n    // canonical note in `src/sales/profiles/index.ts`. It is authored even here:\n    // 17.0 gates export on the explicit bit, and `modifyAllRecords` does not\n    // stand in for it, so without these an admin cannot export either.\n    crm_lead:        { allowCreate: true, allowRead: true, allowEdit: true, allowDelete: true, viewAllRecords: true, modifyAllRecords: true, allowTransfer: true, allowExport: true },\n    crm_account:     { allowCreate: true, allowRead: true, allowEdit: true, allowDelete: true, viewAllRecords: true, modifyAllRecords: true, allowTransfer: true, allowExport: true },\n    crm_contact:     { allowCreate: true, allowRead: true, allowEdit: true, allowDelete: true, viewAllRecords: true, modifyAllRecords: true, allowTransfer: true, allowExport: true },\n    crm_opportunity: { allowCreate: true, allowRead: true, allowEdit: true, allowDelete: true, viewAllRecords: true, modifyAllRecords: true, allowTransfer: true, allowExport: true },\n    crm_quote:       { allowCreate: true, allowRead: true, allowEdit: true, allowDelete: true, viewAllRecords: true, modifyAllRecords: true, allowTransfer: true },\n    crm_contract:    { allowCreate: true, allowRead: true, allowEdit: true, allowDelete: true, viewAllRecords: true, modifyAllRecords: true, allowTransfer: true },\n    crm_product:     { allowCreate: true, allowRead: true, allowEdit: true, allowDelete: true, viewAllRecords: true, modifyAllRecords: true, allowTransfer: true },\n    crm_campaign:    { allowCreate: true, allowRead: true, allowEdit: true, allowDelete: true, viewAllRecords: true, modifyAllRecords: true, allowTransfer: true },\n    crm_case:        { allowCreate: true, allowRead: true, allowEdit: true, allowDelete: true, viewAllRecords: true, modifyAllRecords: true, allowTransfer: true, allowExport: true },\n    crm_task:        { allowCreate: true, allowRead: true, allowEdit: true, allowDelete: true, viewAllRecords: true, modifyAllRecords: true, allowTransfer: true },\n    crm_event:       { allowCreate: true, allowRead: true, allowEdit: true, allowDelete: true, viewAllRecords: true, modifyAllRecords: true, allowTransfer: true },\n    crm_event_attendee: { allowCreate: true, allowRead: true, allowEdit: true, allowDelete: true, viewAllRecords: true, modifyAllRecords: true, allowTransfer: true },\n    // The objects below shipped with navigation, views, hooks and seed data\n    // but no grant in ANY permission set (#488): \"Knowledge\" and \"Forecasts\"\n    // were permission-denied nav items for every user, admins included.\n    crm_forecast:              { allowCreate: true, allowRead: true, allowEdit: true, allowDelete: true, viewAllRecords: true, modifyAllRecords: true, allowTransfer: true },\n    crm_article_feedback:      { allowCreate: true, allowRead: true, allowEdit: true, allowDelete: true, viewAllRecords: true, modifyAllRecords: true, allowTransfer: true },\n    crm_knowledge_article:     { allowCreate: true, allowRead: true, allowEdit: true, allowDelete: true, viewAllRecords: true, modifyAllRecords: true, allowTransfer: true },\n    // Detail rows. Their RECORD-level access derives from the master\n    // (ADR-0055 `controlled_by_parent`), but object-level CRUD is a separate\n    // gate that is never derived \u2014 it has to be granted explicitly here.\n    crm_opportunity_line_item: { allowCreate: true, allowRead: true, allowEdit: true, allowDelete: true, viewAllRecords: true, modifyAllRecords: true, allowTransfer: true },\n    crm_quote_line_item:       { allowCreate: true, allowRead: true, allowEdit: true, allowDelete: true, viewAllRecords: true, modifyAllRecords: true, allowTransfer: true },\n    crm_campaign_member:       { allowCreate: true, allowRead: true, allowEdit: true, allowDelete: true, viewAllRecords: true, modifyAllRecords: true, allowTransfer: true },\n    // The record Attachments panel, READ only: canonical note on `enable.files`\n    // in `src/sales/objects/index.ts` (#2029). Which attachments it lists\n    // derives from the parent record; upload and delete wait upstream.\n    sys_attachment: { allowCreate: false, allowRead: true, allowEdit: false, allowDelete: false, viewAllRecords: false, modifyAllRecords: false },\n    // The record Discussion panel, comments and activity: canonical note on\n    // `enable.feeds` in `src/sales/objects/index.ts` (#2029). Which threads it\n    // reaches derives from the parent record; deleting a comment waits upstream.\n    sys_comment:  { allowCreate: true,  allowRead: true, allowEdit: true,  allowDelete: false, viewAllRecords: false, modifyAllRecords: false },\n    sys_activity: { allowCreate: false, allowRead: true, allowEdit: false, allowDelete: false, viewAllRecords: false, modifyAllRecords: false },\n  },\n  systemPermissions: [\n    'view_setup', 'manage_users', 'customize_application',\n    'view_all_data', 'modify_all_data', 'manage_profiles',\n    'manage_roles', 'manage_sharing',\n  ],\n};\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/sales/translations/index.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/sales/translations\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/sales/translations/index.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\n/**\n * Translation Definitions Barrel\n */\n\nexport { CrmTranslations } from './crm.translation';\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/sales/translations/en/app.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/sales/translations/en\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/sales/translations/en/app.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport type { TranslationData } from '@objectstack/spec/system';\n\n/**\n * English (en) \u2014 every translation namespace EXCEPT `objects`:\n * `apps`, `messages`, `dashboards`, `pages`.\n *\n * SPLIT AXIS (#1311): translation NAMESPACE first, then CRM DOMAIN FAMILY.\n * Everything that is not `objects` lives in `./app.ts`; `objects` \u2014 69-78% of\n * every bundle \u2014 is one file per CRM domain family, and a detail object\n * follows its master. A new row goes in the file for ITS family, never in\n * whichever file is already open: that is how one file re-grows past the 70%\n * advisory band `pnpm hygiene` prints. Full rule and rationale:\n * `src/sales/translations/en.ts`.\n *\n * A namespace `TranslationData` gains later lands here too, and the room is\n * measured: this file is the smaller half of the bundle, and the schema bounds\n * how many namespaces can ever arrive.\n */\nexport const appSurface: Omit<TranslationData, 'objects'> = {\n  apps: {\n    crm_enterprise: {\n      label: 'HotCRM',\n      description: 'Customer relationship management for sales, service, and marketing',\n      navigation: {\n        group_activity: { label: 'Activity' },\n        group_sales: { label: 'Sales' },\n        group_service: { label: 'Service' },\n        group_marketing: { label: 'Marketing' },\n      },\n    },\n  },\n  messages: {\n    'common.save': 'Save',\n    'common.cancel': 'Cancel',\n    'common.delete': 'Delete',\n    'common.edit': 'Edit',\n    'common.create': 'Create',\n    'common.search': 'Search',\n    'common.filter': 'Filter',\n    'common.export': 'Export',\n    'common.back': 'Back',\n    'common.confirm': 'Confirm',\n    'nav.sales': 'Sales',\n    'nav.service': 'Service',\n    'nav.marketing': 'Marketing',\n    'nav.products': 'Products',\n    'nav.analytics': 'Analytics',\n    'success.saved': 'Record saved successfully',\n    'success.converted': 'Lead converted successfully',\n    'confirm.delete': 'Are you sure you want to delete this record?',\n    'confirm.convert_lead': 'Convert this lead to account, contact, and opportunity?',\n    'error.required': 'This field is required',\n    'error.load_failed': 'Failed to load data',\n  },\n  dashboards: {\n    sales_activity_dashboard: {\n      label: 'Sales Activity',\n      description: 'Who is talking to customers, how often, and which accounts have gone quiet',\n      widgets: {\n        interactions_held: { title: 'Interactions Logged', description: 'Calls and meetings that actually happened' },\n        meetings_booked: { title: 'Meetings Booked', description: 'Meetings on the calendar that have not happened yet' },\n        customer_minutes: { title: 'Customer Minutes', description: 'Total time spent in front of customers' },\n        tasks_completed: { title: 'Tasks Completed', description: 'Follow-ups closed out \u2014 the other half of activity' },\n        activity_by_rep: { title: 'Activity by Rep', description: 'Logged interactions per owner' },\n        activity_by_week: { title: 'Activity Volume by Week', description: 'Interactions per week' },\n        activity_mix: { title: 'Activity Mix', description: 'Calls vs meetings vs demos' },\n        activity_by_record_type: { title: 'Where the Activity Lands', description: 'Which part of the funnel is getting attention' },\n        deal_activity: { title: 'Interactions on Deals', description: 'Logged interactions linked to an opportunity' },\n        open_deals_for_activity: { title: 'Open Deals', description: 'Opportunities still in play' },\n        quiet_accounts_30: { title: 'Quiet 30+ Days', description: 'Active accounts with no logged interaction in a month' },\n        quiet_accounts_60: { title: 'Quiet 60+ Days', description: 'Two months of silence \u2014 the at-risk threshold' },\n        quiet_accounts_90: { title: 'Quiet 90+ Days', description: 'A quarter with no contact' },\n      },\n    },\n    crm_overview_dashboard: {\n      label: 'CRM Overview',\n      description: 'Revenue metrics, pipeline analytics, and deal insights',\n      widgets: {\n        total_revenue: { title: 'Total Revenue', description: 'Closed-won revenue this period' },\n        active_deals: { title: 'Active Deals', description: 'Open opportunities in the pipeline' },\n        won_deals: { title: 'Won Deals', description: 'Closed-won deals this period' },\n        avg_deal_size: { title: 'Avg Deal Size', description: 'Average value of closed-won deals' },\n        revenue_trends: { title: 'Revenue Trends', description: 'Closed-won revenue over the last 12 months' },\n        lead_source: { title: 'Lead Source', description: 'Pipeline value by acquisition channel' },\n        pipeline_by_stage: { title: 'Pipeline by Stage', description: 'Open opportunity value at each sales stage' },\n        top_products: { title: 'Top Products', description: 'Total list-price revenue by product category' },\n        pipeline_by_owner: { title: 'Pipeline by Owner', description: 'Open pipeline value and deal count per sales rep' },\n      },\n    },\n    executive_dashboard: {\n      label: 'Executive Overview',\n      description: 'High-level revenue, customer, and pipeline KPIs for leadership',\n      widgets: {\n        total_revenue_ytd: { title: 'Total Revenue (YTD)', description: 'Closed-won revenue this year' },\n        total_accounts: { title: 'Active Accounts', description: 'Customers with at least one active relationship' },\n        total_contacts: { title: 'Total Contacts', description: 'People in our address book' },\n        open_leads: { title: 'Open Leads', description: 'Unconverted leads in the funnel' },\n        revenue_trend: { title: 'Revenue Trend', description: 'Closed-won revenue over the last 12 months' },\n        revenue_by_industry: { title: 'Revenue by Industry', description: 'YTD closed-won revenue split by customer industry' },\n        pipeline_by_stage: { title: 'Pipeline by Stage', description: 'Open opportunity value at each sales stage' },\n        new_accounts_by_month: { title: 'New Accounts', description: 'Account creation cadence \u2014 last 6 months' },\n        accounts_by_industry: { title: 'Accounts by Industry', description: 'Total annual revenue and account count per industry' },\n      },\n    },\n    sales_dashboard: {\n      label: 'Sales Performance',\n      description: 'Pipeline analytics, win rate trends, and rep performance',\n      widgets: {\n        total_pipeline_value: { title: 'Total Pipeline', description: 'Sum of open opportunity value' },\n        closed_won_qtd: { title: 'Closed Won (QTD)', description: 'Revenue closed this quarter' },\n        open_opportunities: { title: 'Open Opportunities', description: 'Active deals in flight' },\n        avg_deal_size: { title: 'Avg Deal Size', description: 'Average value of closed-won deals this quarter' },\n        pipeline_by_stage: { title: 'Pipeline by Stage', description: 'Open opportunity value at each sales stage' },\n        monthly_revenue_trend: { title: 'Monthly Revenue Trend', description: 'Closed-won revenue, last 12 months' },\n        pipeline_by_forecast_category: { title: 'Pipeline by Forecast Category', description: 'Open pipeline grouped by sales forecast category' },\n        lead_source_breakdown: { title: 'Lead Source', description: 'Where our pipeline is coming from' },\n        open_pipeline_by_owner: { title: 'Open Pipeline by Owner', description: 'In-flight pipeline value, deal count and avg win probability per rep' },\n        quota_attainment_by_rep: { title: 'Quota Attainment by Rep', description: 'Current-quarter quota, closed revenue and attainment per rep, from forecast snapshots' },\n        pipeline_stage_by_source: { title: 'Pipeline by Stage \u00D7 Lead Source', description: 'Cross-tab of open opportunity amount by stage and source' },\n        win_rate_12m: { title: 'Win Rate (12M)', description: 'Deals won as a share of all deals settled in the last 12 months' },\n        won_deals_12m: { title: 'Deals Won (12M)', description: 'The numerator of the win rate' },\n        lost_deals_12m: { title: 'Deals Lost (12M)', description: 'The other half of the win-rate denominator' },\n        win_rate_by_owner: { title: 'Win / Loss by Rep', description: 'Deals won, deals lost and win rate per rep \u2014 last 12 months' },\n        win_rate_by_lead_source: { title: 'Win / Loss by Lead Source', description: 'Which sources produce deals that actually close \u2014 last 12 months' },\n        loss_reason_breakdown: { title: 'Why We Lose', description: 'Lost deals by reason \u2014 last 12 months' },\n      },\n    },\n    service_dashboard: {\n      label: 'Customer Service',\n      description: 'Case load, SLA health, and resolution performance',\n      widgets: {\n        open_cases: { title: 'Open Cases', description: 'Cases that are not yet closed' },\n        critical_cases: { title: 'Critical Cases', description: 'Open cases marked as critical priority' },\n        avg_resolution_time: { title: 'Avg Resolution Time', description: 'Mean time to close, in hours' },\n        sla_violations: { title: 'SLA Violations', description: 'Cases that breached their SLA' },\n        cases_by_status: { title: 'Cases by Status', description: 'Workload distribution across the pipeline' },\n        cases_by_priority: { title: 'Cases by Priority', description: 'Open case mix by urgency' },\n        cases_by_origin: { title: 'Cases by Origin', description: 'Where our cases are coming from' },\n        daily_case_volume: { title: 'Daily Case Volume', description: 'New cases created over the last 30 days' },\n        sla_compliance_gauge: { title: 'SLA Compliance', description: 'Percent of cases resolved within SLA this period' },\n        kb_deflection_rate: { title: 'KB Deflection Rate', description: 'Share of closed cases resolved with a knowledge article' },\n        kb_resolved_cases: { title: 'Resolved by KB', description: 'Closed cases pointing at the article that resolved them' },\n        closed_cases_total: { title: 'Closed Cases', description: 'The denominator behind the deflection rate' },\n        top_resolving_articles: { title: 'Top Resolving Articles', description: 'Knowledge articles ranked by the closed cases they resolved' },\n        my_open_cases_by_priority: { title: 'My Open Cases by Priority', description: 'Your open cases and their SLA-violation rate, broken down by priority' },\n      },\n    },\n  },\n  pages: {\n    account_detail_page: {\n      label: 'Account Detail',\n      description: 'Slotted account record page \u2014 custom header + persistent discussion feed.',\n      // Required, though it equals the page source: a missing `title` falls\n      // back to `label`, and the header then read \"Account Detail\" instead of\n      // the account's name (#2042).\n      title: '{name}',\n      subtitle: '{industry} \u00B7 {type}',\n    },\n    account_workbench: {\n      label: 'Account Workbench',\n      description: 'Curated account list for the sales team: quick filters only, no view management.',\n    },\n    app_launcher_page: {\n      label: 'App Launcher',\n      description: 'Central hub for accessing all applications',\n      subtitle: 'Select an app to get started',\n      components: {\n        app_search: { label: 'Search Apps' },\n        app_grid: { label: 'Application Grid' },\n      },\n    },\n    case_detail_page: {\n      label: 'Case Detail',\n      description: 'Service-agent case record: highlights, SLA path, details and activity timeline.',\n      title: '{case_number} \u00B7 {subject}',\n      subtitle: '{crm_account}',\n      components: {\n        case_highlights: { label: 'Key Information' },\n        case_status_path: { label: 'Case Status Path' },\n      },\n    },\n    lead_detail_page: {\n      label: 'Lead Detail',\n      description: 'Comprehensive lead detail page with highlights, details, and related information',\n      title: '{first_name} {last_name}',\n      subtitle: '{company}',\n      components: {\n        lead_duplicate_alert_confirmed: { label: 'Confirmed Duplicate Alert' },\n        lead_duplicate_alert_suspected: { label: 'Suspected Duplicate Alert' },\n        lead_highlights: { label: 'Key Information' },\n        lead_path: { label: 'Lead Status Path' },\n        main_tabs: { label: 'Lead Information Tabs' },\n      },\n    },\n    opportunity_detail_page: {\n      label: 'Opportunity Detail',\n      description:\n        'Comprehensive opportunity detail page with path, highlights, details, and related lists',\n      title: '{name}',\n      subtitle: '{crm_account}',\n      components: {\n        opp_highlights: { label: 'Key Information' },\n        opp_stage_path: { label: 'Opportunity Stage Path' },\n      },\n    },\n    sales_home_page: {\n      label: 'Sales Home',\n      description: 'Sales team home page with key metrics and quick actions',\n      title: 'Sales Dashboard',\n      subtitle: 'Welcome back',\n      components: {\n        quick_create: { title: 'Quick Create', label: 'Quick Create' },\n        key_metrics: { title: 'Key Performance Indicators', label: 'Key Metrics' },\n        home_tabs: { label: 'Home Tabs' },\n        ai_briefing: {\n          title: 'Ask the AI Assistant',\n          label: 'Today with the AI Assistant',\n        },\n        upcoming_events: { title: 'Upcoming Events', label: 'Upcoming Events' },\n      },\n    },\n    utility_bar_page: {\n      label: 'Utility Bar',\n      description: 'Quick access utility bar with floating tools',\n      components: {\n        notifications_panel: { label: 'Notifications' },\n        quick_notes: { title: 'Quick Notes', label: 'Quick Notes' },\n        quick_search: { label: 'Quick Search' },\n      },\n    },\n  },\n};\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/sales/translations/en/_shared.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/sales/translations/en\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/sales/translations/en/_shared.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\n/**\n * English (en) \u2014 values shared by more than one part of this bundle.\n *\n * SPLIT AXIS (#1311): translation NAMESPACE first, then CRM DOMAIN FAMILY.\n * Everything that is not `objects` lives in `./app.ts`; `objects` \u2014 69-78% of\n * every bundle \u2014 is one file per CRM domain family, and a detail object\n * follows its master. A new row goes in the file for ITS family, never in\n * whichever file is already open: that is how one file re-grows past the 70%\n * advisory band `pnpm hygiene` prints. Full rule and rationale:\n * `src/sales/translations/en.ts`.\n *\n * Every constant here is spread into object rows that live in MORE THAN ONE\n * family file, so it cannot sit in any one of them. A value used by exactly\n * one family lives in that family's file instead \u2014 that split is mechanical,\n * not a judgement call.\n */\n\n/**\n * The activity family (#592) \u2014 `log_call`, `log_meeting` and\n * `schedule_meeting` are registered once PER OBJECT (lead, contact, account,\n * opportunity, case), because a body action with no `objectName` lands under a\n * dispatcher key nothing probes (#509). The labels are identical on every one\n * of them, so they are declared once here and spread into each object's\n * `_actions` \u2014 fifteen hand-copied blocks per locale is how a translation set\n * drifts.\n */\nexport const activityActions = {\n  log_call: {\n    label: 'Log a Call',\n    successMessage: 'Call logged successfully!',\n    params: {\n      subject: { label: 'Call Subject' },\n      duration: { label: 'Duration (minutes)' },\n      attendee_contacts: { label: 'Contact Attendees' },\n      attendee_users: { label: 'Internal Attendees' },\n      notes: { label: 'Call Notes' },\n    },\n  },\n  log_meeting: {\n    label: 'Log a Meeting',\n    successMessage: 'Meeting logged successfully!',\n    params: {\n      subject: { label: 'Meeting Subject' },\n      duration: { label: 'Duration (minutes)' },\n      attendee_contacts: { label: 'Contact Attendees' },\n      attendee_users: { label: 'Internal Attendees' },\n      notes: { label: 'Meeting Notes' },\n    },\n  },\n  schedule_meeting: {\n    label: 'Schedule a Meeting',\n    successMessage: 'Meeting scheduled!',\n    params: {\n      subject: { label: 'Meeting Subject' },\n      start_date: { label: 'Start Date (UTC)' },\n      start_time: { label: 'Start Time (UTC)' },\n      location: { label: 'Location' },\n      duration: { label: 'Duration (minutes)' },\n      attendee_contacts: { label: 'Contact Attendees' },\n      attendee_users: { label: 'Internal Attendees' },\n      notes: { label: 'Agenda' },\n    },\n  },\n};\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/sales/translations/en/objects.customer.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/sales/translations/en\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/sales/translations/en/objects.customer.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport type { ObjectTranslationData } from '@objectstack/spec/system';\n\nimport { activityActions } from './_shared';\n\n/**\n * English (en) \u2014 `objects` translations for the CUSTOMER family:\n * the customer record itself \u2014 accounts and the people at them.\n *\n * Roster: `crm_account`, `crm_contact`.\n *\n * SPLIT AXIS (#1311): translation NAMESPACE first, then CRM DOMAIN FAMILY.\n * Everything that is not `objects` lives in `./app.ts`; `objects` \u2014 69-78% of\n * every bundle \u2014 is one file per CRM domain family, and a detail object\n * follows its master. A new row goes in the file for ITS family, never in\n * whichever file is already open: that is how one file re-grows past the 70%\n * advisory band `pnpm hygiene` prints. Full rule and rationale:\n * `src/sales/translations/en.ts`.\n */\nexport const customer: Record<string, ObjectTranslationData> = {\n  crm_account: {\n    label: 'Account',\n    pluralLabel: 'Accounts',\n    fields: {\n      account_number: { label: 'Account Number' },\n      registration_number: {\n        label: 'Registration Number',\n        help: \"The counterparty's registered identity as issued by its own government registry. Not the Account Number, which we issue.\",\n      },\n      commercial_capability: {\n        label: 'Commercial Capability',\n        help: 'Whether new business may be opened against this account. Settlement Only accounts stay usable for billing and payment, but no new opportunity may be linked to them.',\n        options: { full: 'Full', settlement_only: 'Settlement Only' },\n      },\n      incumbent_vendor: { label: 'Incumbent Vendor', help: 'The supplier currently holding this account for the spend we are chasing.' },\n      annual_purchasing_budget: { label: 'Annual Purchasing Budget', help: 'What this account expects to spend with vendors this year \u2014 not its own revenue.' },\n      payment_cycle: {\n        label: 'Payment Cycle',\n        options: { prepaid: 'Prepaid', net_30: 'Net 30', net_60: 'Net 60', net_90: 'Net 90' },\n      },\n      approval_status: {\n        label: 'Approval Status',\n        help: 'Where this account stands in its sign-off. A new account starts Pending and is decided in the approval inbox.',\n        options: { pending: 'Pending', approved: 'Approved', rejected: 'Rejected' },\n      },\n      name: { label: 'Account Name', help: 'Legal name of the company or organization' },\n      type: {\n        label: 'Type',\n        options: { prospect: 'Prospect', customer: 'Customer', partner: 'Partner', former: 'Former Customer' },\n      },\n      industry: {\n        label: 'Industry',\n        options: {\n          technology: 'Technology', software: 'Software / SaaS', finance: 'Finance',\n          healthcare: 'Healthcare', retail: 'Retail', manufacturing: 'Manufacturing',\n          education: 'Education', real_estate: 'Real Estate', media: 'Media & Entertainment',\n          logistics: 'Logistics', hospitality: 'Hospitality', energy: 'Energy & Utilities',\n          government: 'Government', nonprofit: 'Non-profit', other: 'Other',\n        },\n      },\n      annual_revenue: { label: 'Annual Revenue' },\n      child_account_revenue: { label: 'Child Account Revenue', help: 'Sum of the annual revenue of the direct children of this account.' },\n      number_of_employees: { label: 'Number of Employees' },\n      phone: { label: 'Phone' },\n      website: { label: 'Website' },\n      billing_address: { label: 'Billing Address' },\n      billing_country: {\n        label: 'Billing Country',\n        help: 'Derived from Billing Address \u2014 the country exactly as entered, trimmed and upper-cased.',\n      },\n      territory: {\n        label: 'Territory',\n        help: 'Derived from Billing Address \u2014 the sales territory the sharing rules match on. Accounts outside the staffed territories are Other.',\n        options: { na: 'North America', emea: 'EMEA', other: 'Other' },\n      },\n      office_location: { label: 'Office Location' },\n      owner_id: { label: 'Account Owner' },\n      parent_account: { label: 'Parent Account', help: 'Parent company in hierarchy' },\n      description: { label: 'Description' },\n      is_active: { label: 'Active' },\n      last_activity_date: { label: 'Last Activity Date' },\n      brand_color: { label: 'Brand Color' },\n      logo: { label: 'Company Logo' },\n      tier: {\n        label: 'Customer Tier',\n        options: { strategic: 'Strategic', enterprise: 'Enterprise', mid_market: 'Mid-Market', smb: 'SMB' },\n      },\n      segment: {\n        label: 'Segment',\n        options: { net_new: 'Net New', growth: 'Growth', at_risk: 'At Risk', stable: 'Stable' },\n      },\n      health_score: {\n        label: 'Health Score',\n        help: 'CSM-maintained health indicator',\n        options: { healthy: 'Healthy', watching: 'Watching', at_risk: 'At Risk', churning: 'Churning' },\n      },\n      name_normalized: {\n        label: 'Account Name (Normalized)',\n        help: 'Match key for lead conversion: Account Name lower-cased, trimmed, with internal whitespace collapsed. Maintained by the account_protection hook \u2014 never edit directly.',\n      },\n      display_title: { label: 'Display Title' },\n    },\n    _views: {\n      all_accounts: { label: 'All Accounts', description: 'Primary account list with revenue & industry summaries' },\n      account_gallery: { label: 'Account Cards', description: 'Branded account cards with brand-color highlights' },\n      account_map: { label: 'Accounts by Location', description: 'Geospatial distribution of accounts' },\n      enterprise_accounts: { label: 'Enterprise Accounts', description: 'Accounts with the highest annual revenue' },\n      my_accounts: { label: 'My Accounts', description: 'Accounts owned by the current user' },\n      at_risk_accounts: { label: '\u26A0\uFE0F At-Risk Accounts' },\n    },\n    _sections: {\n      basic: { label: 'Basic Information' },\n      financials: { label: 'Financials' },\n      business_profile: { label: 'Business Profile' },\n      contact_info: { label: 'Contact Information' },\n      ownership: { label: 'Ownership & Status' },\n      branding: { label: 'Branding' },\n      system: { label: 'System' },\n      // Form section names on account.view.ts (#1100)\n      profile: { label: 'Profile' },\n      customer_success: { label: 'Customer Success' },\n      locations: { label: 'Locations' },\n      description: { label: 'Description' },\n    },\n    _actions: { ...activityActions },\n  },\n  crm_contact: {\n    label: 'Contact',\n    pluralLabel: 'Contacts',\n    fields: {\n      salutation: {\n        label: 'Salutation',\n        options: { mr: 'Mr.', ms: 'Ms.', mrs: 'Mrs.', dr: 'Dr.', prof: 'Prof.' },\n      },\n      first_name: { label: 'First Name' },\n      last_name: { label: 'Last Name' },\n      full_name: { label: 'Full Name' },\n      crm_account: { label: 'Account' },\n      email: { label: 'Email' },\n      phone: { label: 'Phone' },\n      mobile: { label: 'Mobile' },\n      title: { label: 'Title' },\n      department: {\n        label: 'Department',\n        options: {\n          executive: 'Executive', sales: 'Sales', marketing: 'Marketing',\n          engineering: 'Engineering', support: 'Support', finance: 'Finance',\n          hr: 'Human Resources', operations: 'Operations',\n        },\n      },\n      // Buying centre (REQ-0004) \u2014 the decision map. English is the source\n      // wording for the option VALUES; every other pack translates these.\n      buying_function: {\n        label: 'Buying Function',\n        options: {\n          decision_maker: 'Decision Maker', economic_buyer: 'Economic Buyer',\n          technical_evaluator: 'Technical Evaluator', user: 'User',\n          influencer: 'Influencer', gatekeeper: 'Gatekeeper',\n        },\n      },\n      attitude: {\n        label: 'Attitude to Us',\n        options: {\n          champion: 'Champion', supportive: 'Supportive', neutral: 'Neutral',\n          skeptical: 'Skeptical', blocker: 'Blocker',\n        },\n      },\n      relationship_strength: {\n        label: 'Relationship Strength',\n        options: {\n          distant: 'Distant', acquaintance: 'Acquaintance', working: 'Working Relationship',\n          strong: 'Strong', trusted_advisor: 'Trusted Advisor',\n        },\n      },\n      owner_id: { label: 'Contact Owner' },\n      description: { label: 'Description' },\n      is_primary: { label: 'Primary Contact', help: 'Is this the main contact for the account?' },\n      avatar: { label: 'Profile Picture' },\n      mailing_address: { label: 'Mailing Address' },\n      lead_source: {\n        label: 'Lead Source',\n        options: {\n          web: 'Web', referral: 'Referral', event: 'Event / Trade Show',\n          webinar: 'Webinar', partner: 'Partner', advertisement: 'Advertisement',\n          paid_search: 'Paid Search', social: 'Social Media', content: 'Content / Blog',\n          cold_call: 'Cold Call', email_campaign: 'Email Campaign', other: 'Other',\n        },\n      },\n      do_not_call: { label: 'Do Not Call' },\n      email_opt_out: { label: 'Email Opt Out' },\n      last_contacted_date: { label: 'Last Contacted' },\n    },\n    _views: {\n      all_contacts: { label: 'All Contacts' },\n      contact_directory: { label: 'People Directory' },\n      primary_contacts: { label: 'Primary Contacts' },\n    },\n    _sections: {\n      identity: { label: 'Identity' },\n      account_info: { label: 'Account & Title' },\n      buying_centre: { label: 'Buying Centre' },\n      contact_info: { label: 'Contact Information' },\n      mailing_address: { label: 'Mailing Address' },\n      additional: { label: 'Additional Info' },\n      preferences: { label: 'Communication Preferences' },\n      // Form section names on contact.view.ts (#1100). `contact_details` /\n      // `comm_preferences`, not `contact_info` / `preferences` \u2014 those are\n      // already fieldGroup keys with their own (longer) wording above.\n      contact_details: { label: 'Contact Info' },\n      comm_preferences: { label: 'Preferences' },\n    },\n    _actions: {\n      ...activityActions,\n      mark_primary: {\n        label: 'Mark as Primary Contact',\n        confirmText: 'Mark this contact as the primary contact for the account?',\n        successMessage: 'Contact marked as primary!',\n      },\n      send_email: {\n        label: 'Send Email',\n        params: {\n          subject: { label: 'Subject' },\n          body: { label: 'Body' },\n        },\n      },\n      add_contact_to_campaign: {\n        label: 'Add to Campaign',\n        successMessage: 'Contacts added to campaign!',\n        params: {\n          crm_campaign: { label: 'Campaign' },\n        },\n      },\n    },\n  },\n};\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/sales/translations/en/objects.pipeline.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/sales/translations/en\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/sales/translations/en/objects.pipeline.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport type { ObjectTranslationData } from '@objectstack/spec/system';\n\nimport { activityActions } from './_shared';\n\n/**\n * English (en) \u2014 `objects` translations for the PIPELINE family:\n * demand and the deals it becomes, plus the roll-up that forecasts them.\n *\n * Roster: `crm_lead`, `crm_opportunity`, `crm_opportunity_line_item`, `crm_forecast`.\n *\n * SPLIT AXIS (#1311): translation NAMESPACE first, then CRM DOMAIN FAMILY.\n * Everything that is not `objects` lives in `./app.ts`; `objects` \u2014 69-78% of\n * every bundle \u2014 is one file per CRM domain family, and a detail object\n * follows its master. A new row goes in the file for ITS family, never in\n * whichever file is already open: that is how one file re-grows past the 70%\n * advisory band `pnpm hygiene` prints. Full rule and rationale:\n * `src/sales/translations/en.ts`.\n */\nexport const pipeline: Record<string, ObjectTranslationData> = {\n  crm_lead: {\n    label: 'Lead',\n    pluralLabel: 'Leads',\n    fields: {\n      first_name: { label: 'First Name' },\n      last_name: { label: 'Last Name' },\n      company: { label: 'Company' },\n      title: { label: 'Title' },\n      email: { label: 'Email' },\n      phone: { label: 'Phone' },\n      status: {\n        label: 'Status',\n        options: {\n          new: 'New', contacted: 'Contacted', qualified: 'Qualified',\n          unqualified: 'Unqualified', converted: 'Converted',\n        },\n      },\n      lead_source: {\n        label: 'Lead Source',\n        options: {\n          web: 'Web', referral: 'Referral', event: 'Event / Trade Show',\n          webinar: 'Webinar', partner: 'Partner', advertisement: 'Advertisement',\n          paid_search: 'Paid Search', social: 'Social Media', content: 'Content / Blog',\n          cold_call: 'Cold Call', email_campaign: 'Email Campaign', other: 'Other',\n        },\n      },\n      owner_id: { label: 'Lead Owner' },\n      is_converted: { label: 'Converted' },\n      description: { label: 'Description' },\n      salutation: {\n        label: 'Salutation',\n        options: { mr: 'Mr.', ms: 'Ms.', mrs: 'Mrs.', dr: 'Dr.', prof: 'Prof.' },\n      },\n      full_name: { label: 'Full Name' },\n      industry: {\n        label: 'Industry',\n        options: {\n          technology: 'Technology', software: 'Software / SaaS', finance: 'Finance',\n          healthcare: 'Healthcare', retail: 'Retail', manufacturing: 'Manufacturing',\n          education: 'Education', real_estate: 'Real Estate', media: 'Media & Entertainment',\n          logistics: 'Logistics', hospitality: 'Hospitality', energy: 'Energy & Utilities',\n          government: 'Government', nonprofit: 'Non-profit', other: 'Other',\n        },\n      },\n      mobile: { label: 'Mobile' },\n      website: { label: 'Website' },\n      rating: { label: 'Lead Score', help: 'Lead quality score (1-5 stars)' },\n      converted_account: { label: 'Converted Account' },\n      converted_contact: { label: 'Converted Contact' },\n      converted_opportunity: { label: 'Converted Opportunity' },\n      converted_date: { label: 'Converted Date' },\n      address: { label: 'Address' },\n      annual_revenue: { label: 'Annual Revenue' },\n      number_of_employees: { label: 'Number of Employees' },\n      notes: { label: 'Notes', help: 'Working notes on this lead \u2014 supports formatting.' },\n      do_not_call: { label: 'Do Not Call' },\n      email_opt_out: { label: 'Email Opt Out' },\n      disqualification_reason: {\n        label: 'Disqualification Reason',\n        help: 'Required when status is Unqualified',\n        options: {\n          not_a_fit: 'Not a Fit', no_budget: 'No Budget', wrong_persona: 'Wrong Persona',\n          unreachable: 'Unreachable', duplicate: 'Duplicate', competitor: 'Competitor',\n          other: 'Other',\n        },\n      },\n      duplicate_of_type: {\n        label: 'Duplicate Of',\n        help: 'Which object holds the surviving record this lead repeats.',\n        // `erased` is a tombstone, not a choice: the form does not offer it\n        // (see `src/sales/views/lead.view.ts`), but a lead whose survivor was\n        // deleted carries it, so it needs a label wherever the record is\n        // READ \u2014 detail page, list column, export. Untranslated it would\n        // render as the raw `erased`.\n        options: { crm_lead: 'Lead', crm_contact: 'Contact', erased: 'Erased Record' },\n      },\n      duplicate_of_lead: { label: 'Duplicate Of Lead' },\n      duplicate_of_contact: { label: 'Duplicate Of Contact' },\n      duplicate_status: {\n        label: 'Duplicate Status',\n        help: 'Suspected = flagged automatically at intake. Confirmed = a human verified the match.',\n        options: { suspected: 'Suspected', confirmed: 'Confirmed' },\n      },\n      display_title: { label: 'Display Title' },\n      company_normalized: {\n        label: 'Company (Normalized)',\n        help: 'Match key for lead conversion: Company lower-cased, trimmed, with internal whitespace collapsed. Maintained by the lead_duplicate_check hook \u2014 never edit directly.',\n      },\n      next_followup_date: { label: 'Next Follow-up Date' },\n      last_contacted_date: { label: 'Last Contacted' },\n      need_type: {\n        label: 'Need Type',\n        help: 'What this prospect is asking for. Routing, prioritisation and demand reporting read this.',\n        options: {\n          new_implementation: 'New Implementation', expansion: 'Expansion',\n          replacement: 'Replacement', renewal: 'Renewal', consulting: 'Consulting',\n          support: 'Support & Maintenance', other: 'Other',\n        },\n      },\n      estimated_amount: {\n        label: 'Estimated Amount',\n        help: 'Estimated value of this demand, before qualification. Prefills the deal amount at conversion.',\n      },\n      conversion_approval_status: {\n        label: 'Conversion Approval',\n        help: 'Whether this lead has been signed off for conversion. Not Required means no approval is asked for \u2014 the shipped default.',\n        options: {\n          not_required: 'Not Required', pending: 'Pending',\n          approved: 'Approved', rejected: 'Rejected',\n        },\n      },\n    },\n    _views: {\n      all_leads: {\n        label: 'All Leads',\n        emptyState: { title: 'No Leads Yet', message: 'Get started by creating your first lead' },\n      },\n      kanban_by_status: { label: 'Lead Pipeline' },\n      calendar_by_created: { label: 'Lead Calendar' },\n      gallery_view: { label: 'Lead Cards' },\n      my_leads: { label: 'My Leads' },\n      high_priority: { label: 'High Priority' },\n      hot_leads: { label: '\uD83D\uDD25 Hot Leads' },\n      suspected_duplicates: {\n        label: 'Suspected Duplicates',\n        emptyState: {\n          title: 'No Suspected Duplicates',\n          message: 'Nothing to review \u2014 every re-captured email has been checked.',\n        },\n      },\n    },\n    _sections: {\n      identity: { label: 'Identity' },\n      company_info: { label: 'Company Information' },\n      contact_info: { label: 'Contact Information' },\n      qualification: { label: 'Qualification' },\n      assignment: { label: 'Assignment' },\n      address: { label: 'Address' },\n      additional: { label: 'Additional Info' },\n      preferences: { label: 'Communication Preferences' },\n      conversion: { label: 'Conversion' },\n      duplicates: { label: 'Duplicate Management' },\n      // The detail page's sections reference the groups above (#806), so it\n      // has no section names of its own.\n      // Form section names on lead.view.ts (#1100). The sections of the\n      // default form and of every named formView live here \u2014 add a form\n      // there, add its section names here. `address` / `qualification` above\n      // are reused (identical fieldGroup wording); every other name here is new.\n      contact_information: { label: 'Contact Information' },\n      lead_classification: { label: 'Lead Classification' },\n      company_information: { label: 'Company Information' },\n      additional_information: { label: 'Additional Information' },\n      privacy: { label: 'Privacy' },\n      general: { label: 'General' },\n      details: { label: 'Details' },\n      step_1_contact_details: { label: 'Step 1: Contact Details' },\n      step_2_company_information: { label: 'Step 2: Company Information' },\n      step_3_qualification: { label: 'Step 3: Qualification' },\n      step_4_review_and_convert: { label: 'Step 4: Review & Convert' },\n      primary_information: { label: 'Primary Information' },\n      extended_details: { label: 'Extended Details' },\n      quick_edit: { label: 'Quick Edit' },\n      update_lead_status: { label: 'Update Lead Status' },\n      tell_us_about_yourself: { label: 'Tell us about yourself' },\n      about_your_company: { label: 'About your company' },\n      how_can_we_help: { label: 'How can we help?' },\n      lead_information: { label: 'Lead Information' },\n      address_information: { label: 'Address Information' },\n      privacy_preferences: { label: 'Privacy Preferences' },\n    },\n    _actions: {\n      ...activityActions,\n      convert_lead: {\n        label: 'Convert Lead',\n        successMessage: 'Lead converted successfully!',\n      },\n      create_campaign: {\n        label: 'Add to Campaign',\n        successMessage: 'Leads added to campaign!',\n        params: {\n          crm_campaign: { label: 'Campaign' },\n        },\n      },\n      schedule_followup: {\n        label: 'Schedule Follow-up',\n        successMessage: 'Follow-up scheduled.',\n      },\n    },\n  },\n  crm_opportunity: {\n    label: 'Opportunity',\n    pluralLabel: 'Opportunities',\n    fields: {\n      name: { label: 'Opportunity Name' },\n      crm_account: { label: 'Account' },\n      primary_contact: { label: 'Primary Contact' },\n      owner_id: { label: 'Opportunity Owner' },\n      amount: { label: 'Amount' },\n      expected_revenue: { label: 'Expected Revenue' },\n      stage: {\n        label: 'Stage',\n        options: {\n          prospecting: 'Prospecting', qualification: 'Qualification',\n          needs_analysis: 'Needs Analysis', proposal: 'Proposal',\n          negotiation: 'Negotiation', closed_won: 'Closed Won', closed_lost: 'Closed Lost',\n        },\n      },\n      probability: { label: 'Probability (%)' },\n      close_date: { label: 'Close Date' },\n      type: {\n        label: 'Type',\n        options: {\n          new_business: 'New Business',\n          existing_upgrade: 'Existing Customer - Upgrade',\n          existing_renewal: 'Existing Customer - Renewal',\n          existing_expansion: 'Existing Customer - Expansion',\n        },\n      },\n      forecast_category: {\n        label: 'Forecast Category',\n        options: {\n          pipeline: 'Pipeline', best_case: 'Best Case',\n          commit: 'Commit', omitted: 'Omitted', closed: 'Closed',\n        },\n      },\n      description: { label: 'Description' },\n      next_step: { label: 'Next Step' },\n      lead_source: {\n        label: 'Lead Source',\n        options: {\n          web: 'Web', referral: 'Referral', event: 'Event / Trade Show',\n          webinar: 'Webinar', partner: 'Partner', advertisement: 'Advertisement',\n          paid_search: 'Paid Search', social: 'Social Media', content: 'Content / Blog',\n          cold_call: 'Cold Call', email_campaign: 'Email Campaign', other: 'Other',\n        },\n      },\n      crm_campaign: { label: 'Campaign', help: 'Marketing campaign that generated this opportunity' },\n      days_in_stage: { label: 'Days in Current Stage' },\n      stage_entry_date: {\n        label: 'Stage Entry Date',\n        help: 'Date this opportunity entered its current stage.',\n      },\n      is_private: { label: 'Private' },\n      approval_status: {\n        label: 'Approval Status',\n        options: { not_required: 'Not Required', pending: 'Pending', approved: 'Approved', rejected: 'Rejected' },\n      },\n      approved_date: { label: 'Approved Date' },\n      win_reason: {\n        label: 'Win Reason',\n        help: 'Why this deal was won. Required to close an opportunity as Won.',\n        options: {\n          better_product: 'Better Product', better_price: 'Better Price', relationship: 'Existing Relationship',\n          better_support: 'Better Support', best_fit: 'Best Fit / Features',\n          quote_accepted: 'Quote Accepted', other: 'Other',\n        },\n      },\n      loss_reason: {\n        label: 'Loss Reason',\n        help: 'Why this deal was lost. Required to close an opportunity as Lost.',\n        options: {\n          price: 'Price Too High', competitor: 'Lost to Competitor', no_budget: 'No Budget',\n          no_decision: 'No Decision', timing: 'Bad Timing', features: 'Missing Features', other: 'Other',\n        },\n      },\n      loss_details: {\n        label: 'Loss/Win Details',\n        help: 'Free-text context behind the win or loss reason.',\n      },\n      // REQ-0006 \u2014 qualification, the customer's procurement calendar, the\n      // deal narrative, the business line and the status-change gate.\n      will_bid: {\n        label: 'Will Bid',\n        help: 'Whether we intend to bid. Unset means the decision is open.',\n      },\n      controllability: { label: 'Controllability', options: { high: 'High', medium: 'Medium', low: 'Low' } },\n      priority: { label: 'Priority', options: { high: 'High', medium: 'Medium', low: 'Low' } },\n      deal_level: { label: 'Deal Level', options: { strategic: 'Strategic', key: 'Key', standard: 'Standard' } },\n      is_subcontracted: { label: 'Involves Subcontracting' },\n      subcontracting_note: { label: 'Subcontracting Note' },\n      customer_initiation_date: { label: 'Customer Initiation Date' },\n      expected_tender_date: { label: 'Expected Tender Date' },\n      expected_signing_date: { label: 'Expected Signing Date' },\n      expected_tender_amount: { label: 'Expected Tender Amount' },\n      expected_signing_amount: { label: 'Expected Signing Amount' },\n      business_line: {\n        label: 'Business Line',\n        options: {\n          product: 'Product', services: 'Professional Services', consulting: 'Consulting',\n          support: 'Support & Maintenance', other: 'Other',\n        },\n      },\n      customer_background: { label: 'Customer Background' },\n      project_background: { label: 'Project Background' },\n      risk_analysis: { label: 'Risk Analysis' },\n      payment_terms: { label: 'Payment Terms' },\n      requested_status: { label: 'Requested Status', options: { closed_won: 'Won', closed_lost: 'Lost' } },\n      status_change_approval_status: {\n        label: 'Status Change Approval',\n        options: { not_required: 'Not Required', pending: 'Pending', approved: 'Approved', rejected: 'Rejected' },\n      },\n      // REQ-0006 step 11 \u2014 the \u7ACB\u9879 (qualification) approval gate.\n      qualification_requested: {\n        label: 'Request Qualification Approval',\n        help: 'Tick to send this deal for qualification approval. A rejection clears it; tick it again to ask again.',\n      },\n      qualification_approval_status: {\n        label: 'Qualification Approval',\n        options: { not_required: 'Not Required', pending: 'Pending', approved: 'Approved', rejected: 'Rejected' },\n      },\n    },\n    _views: {\n      tender_this_quarter: {\n        label: 'Tender This Quarter',\n        emptyState: {\n          title: 'No Tenders Expected This Quarter',\n          message: 'This tab lists open deals whose customer-side tender date falls inside the current quarter. Record Expected Tender Date on a deal to see it here.',\n        },\n      },\n      open_opportunities: { label: 'Open Deals' },\n      all_opportunities: { label: 'All Opportunities' },\n      pipeline_kanban: { label: 'Sales Pipeline' },\n      close_date_calendar: { label: 'Forecast Calendar' },\n      deal_timeline: { label: 'Deal Timeline' },\n      deal_gallery: { label: 'Deal Cards' },\n      my_open_deals: { label: 'My Open Deals' },\n      stale_opportunities: { label: '\u26A0\uFE0F Stale Opportunities \u00B7 Longest in Stage First' },\n      closing_this_quarter: {\n        label: 'Closing This Quarter',\n        emptyState: {\n          title: 'No Deals Closing This Quarter',\n          message: 'This tab lists open commit and best-case deals with a close date inside the current quarter. Nothing matches right now \u2014 deals closing later are on the Open Deals tab.',\n        },\n      },\n    },\n    _sections: {\n      basic: { label: 'Basic Information' },\n      financials: { label: 'Financials' },\n      sales_process: { label: 'Sales Process' },\n      classification: { label: 'Classification' },\n      campaign: { label: 'Campaigns' },\n      notes: { label: 'Notes & Next Steps' },\n      qualification: { label: 'Qualification' },\n      narrative: { label: 'Deal Narrative' },\n      crm_forecast: { label: 'Forecast & Metrics' },\n      // The detail page's sections reference the groups above (#1452), so it\n      // has no section names of its own.\n      // Form section names on opportunity.view.ts (#1100)\n      overview: { label: 'Overview' },\n      forecast: { label: 'Forecast' },\n      sales_strategy: { label: 'Sales Strategy' },\n      win_loss: { label: 'Win / Loss' },\n    },\n    _actions: {\n      ...activityActions,\n      clone_opportunity: {\n        label: 'Clone Opportunity',\n        successMessage: 'Opportunity cloned successfully!',\n      },\n      mass_update_stage: {\n        label: 'Update Stage',\n        successMessage: 'Opportunities updated successfully!',\n        params: {\n          stage: { label: 'New Stage' },\n        },\n      },\n      generate_quote: {\n        label: 'Generate Quote',\n        successMessage: 'Quote created from opportunity!',\n      },\n    },\n  },\n  crm_opportunity_line_item: {\n    label: 'Opportunity Line Item',\n    pluralLabel: 'Opportunity Line Items',\n    description: 'Per-product pricing lines under an opportunity',\n    fields: {\n      crm_opportunity: { label: 'Opportunity' },\n      crm_product: { label: 'Product' },\n      description: { label: 'Description' },\n      quantity: { label: 'Quantity' },\n      list_price: { label: 'List Price', help: \"Auto-populated from the product's List Price.\" },\n      unit_price: {\n        label: 'Sales Price',\n        help: 'Negotiated unit price (may differ from list price)',\n      },\n      discount: { label: 'Discount %' },\n      total_price: { label: 'Total' },\n      line_number: { label: 'Line #' },\n    },\n    _sections: {\n      basic: { label: 'Line Item' },\n      pricing: { label: 'Pricing' },\n    },\n  },\n  crm_forecast: {\n    label: 'Forecast',\n    pluralLabel: 'Forecasts',\n    description: 'Periodic pipeline snapshot by owner used for revenue forecasting',\n    fields: {\n      owner_id: { label: 'Owner' },\n      period: { label: 'Period', options: { month: 'Month', quarter: 'Quarter' } },\n      period_start: {\n        label: 'Period Start',\n        help: 'Must be the first day of the period \u2014 e.g. 2026-08-01 for Aug 2026. A quarterly forecast must additionally start on a quarter boundary: January 1, April 1, July 1 or October 1.',\n      },\n      period_end: {\n        label: 'Period End',\n        help: 'Normally derived automatically from Period and Period Start. If set by hand, it must be the last day of that period \u2014 e.g. 2026-09-30 for a quarter starting 2026-07-01, or 2026-08-31 for Aug 2026.',\n      },\n      period_label: { label: 'Period', help: 'Human-friendly label, e.g. \"Q3 2026\" or \"Aug 2026\".' },\n      snapshot_date: { label: 'Snapshot Date', help: 'The day this snapshot was captured.' },\n      source: {\n        label: 'Source',\n        options: { scheduled: 'Scheduled snapshot', ai: 'AI skill', manual: 'Manual entry' },\n      },\n      quota: { label: 'Quota' },\n      pipeline_amount: {\n        label: 'Pipeline',\n        help: 'Sum of all open opportunities closing in this period (any stage).',\n      },\n      best_case_amount: {\n        label: 'Best Case',\n        help: 'Open opportunities in the Best Case or Commit forecast category.',\n      },\n      commit_amount: {\n        label: 'Commit',\n        help: 'Open opportunities in the Commit forecast category (owner-committed).',\n      },\n      closed_amount: { label: 'Closed Won', help: 'Already-closed-won amount in this period.' },\n      expected_amount: {\n        label: 'Expected',\n        help: 'Closed Won + Commit \u2014 what the owner reasonably expects to land.',\n      },\n      attainment_pct: { label: 'Attainment %', help: 'Closed Won \u00F7 Quota \u00D7 100. Reads 0% until a positive quota is set.' },\n      coverage_ratio: {\n        label: 'Coverage',\n        help: 'Pipeline \u00F7 (Quota \u2212 Closed Won) \u2014 whether enough pipeline remains to cover the gap. Reads 0 once the quota is already met.',\n      },\n      notes: { label: 'Notes' },\n      display_title: { label: 'Display Title' },\n      seed_key: {\n        label: 'Seed Key',\n        help: 'Demo-fixture identity. Written only by the seed loader; empty on every real snapshot.',\n      },\n    },\n    _views: {\n      all_forecasts: { label: 'All Forecasts' },\n      this_quarter_forecasts: {\n        label: 'This Quarter',\n        emptyState: {\n          title: 'This Quarter Has No Snapshots Yet',\n          message: 'Quarterly snapshots are written by the nightly forecast sweep. Until it has run once for the current quarter this view is empty \u2014 settled quarters are on the All tab.',\n        },\n      },\n      my_forecast: { label: 'My Forecast' },\n    },\n    _sections: {\n      basic: { label: 'Snapshot' },\n      amounts: { label: 'Amounts' },\n      meta: { label: 'Source' },\n      // Form section names on forecast.view.ts (#1100). `basic`'s label\n      // matches \"Snapshot\" but its key does not, so this form section\n      // needs its own entry; `notes` has no fieldGroup counterpart at all.\n      snapshot: { label: 'Snapshot' },\n      notes: { label: 'Notes' },\n    },\n  },\n};\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/sales/translations/en/objects.commerce.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/sales/translations/en\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/sales/translations/en/objects.commerce.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport type { ObjectTranslationData } from '@objectstack/spec/system';\n\n/**\n * English (en) \u2014 `objects` translations for the COMMERCE family:\n * what gets sold and on what paper \u2014 quotes, contracts, products.\n *\n * Roster: `crm_quote`, `crm_quote_line_item`, `crm_contract`, `crm_product`.\n *\n * SPLIT AXIS (#1311): translation NAMESPACE first, then CRM DOMAIN FAMILY.\n * Everything that is not `objects` lives in `./app.ts`; `objects` \u2014 69-78% of\n * every bundle \u2014 is one file per CRM domain family, and a detail object\n * follows its master. A new row goes in the file for ITS family, never in\n * whichever file is already open: that is how one file re-grows past the 70%\n * advisory band `pnpm hygiene` prints. Full rule and rationale:\n * `src/sales/translations/en.ts`.\n */\nexport const commerce: Record<string, ObjectTranslationData> = {\n  crm_quote: {\n    label: 'Quote',\n    pluralLabel: 'Quotes',\n    fields: {\n      quote_number: { label: 'Quote Number' },\n      name: { label: 'Quote Name' },\n      crm_account: { label: 'Account' },\n      crm_contact: {\n        label: 'Contact',\n        help: 'Required once the quote is Presented or Accepted \u2014 the drafted contract takes its Primary Contact from here.',\n      },\n      crm_opportunity: { label: 'Opportunity' },\n      owner_id: { label: 'Quote Owner' },\n      status: {\n        label: 'Status',\n        options: {\n          draft: 'Draft', in_review: 'In Review', presented: 'Presented',\n          accepted: 'Accepted', rejected: 'Rejected', expired: 'Expired',\n        },\n      },\n      quote_date: { label: 'Quote Date' },\n      expiration_date: { label: 'Expiration Date' },\n      subtotal: { label: 'Subtotal' },\n      discount: { label: 'Discount %' },\n      discount_amount: { label: 'Discount Amount' },\n      tax: { label: 'Tax' },\n      shipping_handling: { label: 'Shipping & Handling' },\n      total_price: { label: 'Total Price' },\n      payment_terms: {\n        label: 'Payment Terms',\n        options: {\n          net_15: 'Net 15', net_30: 'Net 30', net_60: 'Net 60',\n          net_90: 'Net 90', due_on_receipt: 'Due on Receipt',\n        },\n      },\n      shipping_terms: { label: 'Shipping Terms' },\n      billing_address: { label: 'Billing Address' },\n      shipping_address: { label: 'Shipping Address' },\n      description: { label: 'Description' },\n      internal_notes: { label: 'Internal Notes' },\n      display_title: { label: 'Display Title' },\n    },\n    _views: {\n      all_quotes: { label: 'All Quotes' },\n      quote_pipeline: { label: 'Quote Pipeline' },\n      quote_calendar: { label: 'Quote Calendar' },\n    },\n    _sections: {\n      basic: { label: 'Quote Information' },\n      pricing: { label: 'Pricing' },\n      terms: { label: 'Terms & Validity' },\n      address: { label: 'Addresses' },\n      system: { label: 'System' },\n      // Form section names on quote.view.ts (#1100). `quote_terms`, not\n      // `terms` \u2014 `terms` is already the fieldGroup key for \"Terms & Validity\".\n      quote: { label: 'Quote' },\n      totals: { label: 'Totals' },\n      quote_terms: { label: 'Terms' },\n      addresses_and_notes: { label: 'Addresses & Notes' },\n    },\n  },\n  crm_quote_line_item: {\n    label: 'Quote Line Item',\n    pluralLabel: 'Quote Line Items',\n    description: 'Per-product pricing lines under a quote',\n    fields: {\n      crm_quote: { label: 'Quote' },\n      crm_product: { label: 'Product' },\n      description: { label: 'Description' },\n      quantity: { label: 'Quantity' },\n      list_price: { label: 'List Price' },\n      unit_price: { label: 'Sales Price' },\n      discount: { label: 'Discount %' },\n      subtotal: { label: 'Subtotal' },\n      total_price: { label: 'Total' },\n      line_number: { label: 'Line #' },\n    },\n    _sections: {\n      basic: { label: 'Line Item' },\n      pricing: { label: 'Pricing' },\n    },\n  },\n  crm_contract: {\n    label: 'Contract',\n    pluralLabel: 'Contracts',\n    fields: {\n      contract_number: { label: 'Contract Number' },\n      crm_account: { label: 'Account' },\n      crm_contact: { label: 'Primary Contact' },\n      crm_opportunity: { label: 'Related Opportunity' },\n      owner_id: { label: 'Contract Owner' },\n      status: {\n        label: 'Status',\n        options: {\n          draft: 'Draft', in_approval: 'In Approval', activated: 'Activated',\n          expired: 'Expired', terminated: 'Terminated',\n        },\n      },\n      contract_term_months: { label: 'Contract Term (Months)' },\n      start_date: { label: 'Start Date' },\n      end_date: { label: 'End Date' },\n      contract_value: { label: 'Contract Value' },\n      billing_frequency: {\n        label: 'Billing Frequency',\n        options: {\n          monthly: 'Monthly', quarterly: 'Quarterly',\n          annually: 'Annually', one_time: 'One-time',\n        },\n      },\n      payment_terms: {\n        label: 'Payment Terms',\n        options: {\n          net_15: 'Net 15', net_30: 'Net 30', net_60: 'Net 60',\n          net_90: 'Net 90', due_on_receipt: 'Due on Receipt',\n        },\n      },\n      auto_renewal: { label: 'Auto Renewal' },\n      renewal_notice_days: { label: 'Renewal Notice (Days)' },\n      contract_type: {\n        label: 'Contract Type',\n        options: {\n          subscription: 'Subscription', service: 'Service Agreement', license: 'License',\n          partnership: 'Partnership', nda: 'NDA', msa: 'MSA',\n        },\n      },\n      signed_date: { label: 'Signed Date' },\n      signed_by: { label: 'Signed By' },\n      document_url: { label: 'Contract Document' },\n      special_terms: { label: 'Special Terms' },\n      description: { label: 'Description' },\n      billing_address: { label: 'Billing Address' },\n    },\n    _views: {\n      all_contracts: { label: 'All Contracts' },\n      renewal_calendar: { label: 'Renewal Calendar' },\n      contract_gantt: { label: 'Contract Terms' },\n      contract_timeline: { label: 'Contract Timeline' },\n    },\n    _sections: {\n      basic: { label: 'Contract Information' },\n      parties: { label: 'Parties' },\n      terms: { label: 'Terms & Dates' },\n      value: { label: 'Contract Value' },\n      status: { label: 'Status & Approval' },\n      renewal: { label: 'Renewal' },\n      // Form section names on contract.view.ts (#1100). `contract_terms`,\n      // not `terms` \u2014 `terms` is already the fieldGroup key for \"Terms & Dates\".\n      contract_terms: { label: 'Terms' },\n      signing_and_documents: { label: 'Signing & Documents' },\n      notes: { label: 'Notes' },\n    },\n  },\n  crm_product: {\n    label: 'Product',\n    pluralLabel: 'Products',\n    fields: {\n      product_code: { label: 'Product Code' },\n      name: { label: 'Product Name' },\n      description: { label: 'Description' },\n      category: {\n        label: 'Category',\n        options: {\n          software: 'Software', hardware: 'Hardware', service: 'Service',\n          subscription: 'Subscription', support: 'Support',\n        },\n      },\n      family: {\n        label: 'Product Family',\n        options: {\n          enterprise: 'Enterprise Solutions', smb: 'SMB Solutions',\n          services: 'Professional Services', cloud: 'Cloud Services',\n        },\n      },\n      list_price: { label: 'List Price' },\n      cost: { label: 'Cost' },\n      sku: { label: 'SKU' },\n      is_active: { label: 'Active' },\n      product_manager: { label: 'Product Manager' },\n      image: { label: 'Product Image' },\n      datasheet: { label: 'Datasheet' },\n      display_title: { label: 'Display Title' },\n    },\n    _views: {\n      all_products: { label: 'All Products' },\n      product_catalog: { label: 'Product Catalog' },\n    },\n    _sections: {\n      basic: { label: 'Product Information' },\n      pricing: { label: 'Pricing' },\n      metadata: { label: 'Resources' },\n      // Form section names on product.view.ts (#1100)\n      product_info: { label: 'Product Info' },\n      pricing_info: { label: 'Pricing' },\n      media: { label: 'Media' },\n    },\n  },\n};\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/sales/translations/en/objects.service.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/sales/translations/en\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/sales/translations/en/objects.service.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport type { ObjectTranslationData } from '@objectstack/spec/system';\n\nimport { activityActions } from './_shared';\n\n/**\n * English (en) \u2014 `objects` translations for the SERVICE family:\n * post-sale support \u2014 cases and the knowledge that deflects them.\n *\n * Roster: `crm_case`, `crm_knowledge_article`, `crm_article_feedback`.\n *\n * SPLIT AXIS (#1311): translation NAMESPACE first, then CRM DOMAIN FAMILY.\n * Everything that is not `objects` lives in `./app.ts`; `objects` \u2014 69-78% of\n * every bundle \u2014 is one file per CRM domain family, and a detail object\n * follows its master. A new row goes in the file for ITS family, never in\n * whichever file is already open: that is how one file re-grows past the 70%\n * advisory band `pnpm hygiene` prints. Full rule and rationale:\n * `src/sales/translations/en.ts`.\n */\nexport const service: Record<string, ObjectTranslationData> = {\n  crm_case: {\n    label: 'Case',\n    pluralLabel: 'Cases',\n    fields: {\n      case_number: { label: 'Case Number' },\n      subject: { label: 'Subject' },\n      description: { label: 'Description' },\n      crm_account: { label: 'Account' },\n      crm_contact: { label: 'Contact' },\n      status: {\n        label: 'Status',\n        options: {\n          new: 'New', in_progress: 'In Progress', waiting_customer: 'Waiting on Customer',\n          waiting_support: 'Waiting on Support', escalated: 'Escalated',\n          resolved: 'Resolved', closed: 'Closed',\n        },\n      },\n      priority: {\n        label: 'Priority',\n        options: { low: 'Low', medium: 'Medium', high: 'High', critical: 'Critical' },\n      },\n      type: {\n        label: 'Case Type',\n        options: {\n          question: 'Question', problem: 'Problem',\n          feature_request: 'Feature Request', bug: 'Bug',\n        },\n      },\n      origin: {\n        label: 'Case Origin',\n        options: { email: 'Email', phone: 'Phone', web: 'Web', chat: 'Chat', social_media: 'Social Media' },\n      },\n      owner_id: { label: 'Case Owner' },\n      closed_date: { label: 'Closed Date' },\n      first_response_date: { label: 'First Response Date' },\n      resolution_time_hours: { label: 'Resolution Time (Hours)' },\n      sla_due_date: { label: 'SLA Due Date', help: 'Set from the case priority and the account\u2019s Customer Tier, in calendar hours: nights, weekends and holidays count.' },\n      is_sla_violated: { label: 'SLA Violated' },\n      is_escalated: { label: 'Escalated' },\n      escalation_reason: { label: 'Escalation Reason' },\n      resolution: { label: 'Resolution' },\n      resolved_by_article: { label: 'Resolved by Article', help: 'Knowledge article that resolved this case \u2014 the deflection signal.' },\n      internal_notes: { label: 'Internal Notes', help: 'Internal notes; not visible to the customer.' },\n      is_closed: { label: 'Is Closed' },\n      display_title: { label: 'Display Title' },\n      priority_rank: { label: 'Priority Rank' },\n      escalated_date: { label: 'Escalated Date' },\n    },\n    _views: {\n      all_cases: { label: 'All Cases' },\n      case_workflow: { label: 'Service Workflow' },\n      sla_calendar: { label: 'SLA Calendar' },\n      case_timeline: { label: 'Case Timeline' },\n      unassigned_triage: {\n        label: 'Unassigned \u2014 triage',\n        emptyState: {\n          title: 'Nothing waiting for triage',\n          message: 'Every case has an owner. Cases appear here when they arrive with no owner \u2014 typically a web-to-case submission that arrived while nobody held the Service Agent position.',\n        },\n      },\n      escalated_cases: { label: 'Escalated Cases' },\n      my_open_cases: { label: 'My Open Cases' },\n      sla_at_risk: { label: '\u23F0 SLA at Risk' },\n    },\n    _sections: {\n      basic: { label: 'Case Information' },\n      origin: { label: 'Origin & Routing' },\n      sla: { label: 'SLA & Priority' },\n      resolution: { label: 'Resolution' },\n      escalation: { label: 'Escalation' },\n      system: { label: 'System' },\n      // The detail page's sections reference the groups above (#970), so it\n      // has no section names of its own.\n      // Form section names on case.view.ts (#1100).\n      case: { label: 'Case' },\n      how_can_we_help: { label: 'How can we help?' },\n    },\n    _actions: {\n      ...activityActions,\n      escalate_case: {\n        label: 'Escalate Case',\n        confirmText: 'This will escalate the case to the escalation team. Continue?',\n        successMessage: 'Case escalated successfully!',\n      },\n      close_case: {\n        label: 'Close Case',\n        confirmText: 'Are you sure you want to close this case?',\n        successMessage: 'Case closed successfully!',\n      },\n      claim_case: {\n        label: 'Claim Case',\n        successMessage: 'Case claimed \u2014 it is yours now.',\n      },\n    },\n  },\n  crm_knowledge_article: {\n    label: 'Knowledge Article',\n    pluralLabel: 'Knowledge Base',\n    description: 'Reusable answers and how-to guides for customers and agents',\n    fields: {\n      article_number: { label: 'Article #' },\n      title: { label: 'Title' },\n      summary: { label: 'Summary', help: 'One-paragraph TL;DR shown in search results and AI citations.' },\n      body: { label: 'Body', help: 'Full article content (Markdown).' },\n      category: {\n        label: 'Category',\n        options: {\n          getting_started: 'Getting Started', how_to: 'How-To',\n          troubleshooting: 'Troubleshooting', billing: 'Billing & Pricing', api: 'API & Integrations',\n          release_notes: 'Release Notes', policy: 'Policy',\n        },\n      },\n      tags: {\n        label: 'Tags',\n        options: {\n          auth: 'Auth', sso: 'SSO', mobile: 'Mobile', email: 'Email',\n          reports: 'Reports', performance: 'Performance', data_import: 'Data Import',\n          webhooks: 'Webhooks',\n        },\n      },\n      status: {\n        label: 'Status',\n        options: { draft: 'Draft', in_review: 'In Review', published: 'Published', archived: 'Archived' },\n      },\n      audience: {\n        label: 'Audience',\n        help: 'Public articles are visible in the customer portal; internal articles are agent-only.',\n        options: { public: 'Public', internal: 'Internal' },\n      },\n      language: {\n        label: 'Language',\n        options: { en: 'English', zh_cn: 'Simplified Chinese', es_es: 'Spanish', ja_jp: 'Japanese' },\n      },\n      owner_id: { label: 'Owner' },\n      related_to_case: { label: 'Source Case', help: 'Case this article was authored from (optional).' },\n      published_at: { label: 'Published At' },\n      last_reviewed_at: { label: 'Last Reviewed' },\n      helpful_count: { label: 'Helpful', help: 'Recounted from crm_article_feedback \u2014 never typed in.' },\n      not_helpful_count: { label: 'Not Helpful', help: 'Recounted from crm_article_feedback \u2014 never typed in.' },\n      display_title: { label: 'Display Title' },\n    },\n    _views: {\n      all_articles: { label: 'All Articles' },\n      published_articles: { label: 'Published' },\n      my_drafts: { label: 'My Drafts' },\n    },\n    _sections: {\n      basic: { label: 'Article Information' },\n      content: { label: 'Content' },\n      taxonomy: { label: 'Categorization' },\n      metrics: { label: 'Engagement' },\n      engagement: { label: 'Engagement' },\n      // Form section name on knowledge_article.view.ts (#1100)\n      article: { label: 'Article' },\n    },\n    _actions: {\n      mark_article_helpful: {\n        label: 'Helpful',\n        successMessage: 'Thanks \u2014 recorded as helpful.',\n      },\n      mark_article_not_helpful: {\n        label: 'Not Helpful',\n        successMessage: 'Thanks \u2014 recorded as not helpful.',\n      },\n    },\n  },\n  crm_article_feedback: {\n    label: 'Article Feedback',\n    pluralLabel: 'Article Feedback',\n    description: 'One reader\u2019s helpful / not-helpful verdict on a knowledge article',\n    fields: {\n      feedback_number: { label: 'Feedback #' },\n      owner_id: { label: 'Reader' },\n      crm_knowledge_article: { label: 'Article', help: 'Knowledge article this feedback is about.' },\n      verdict: {\n        label: 'Verdict',\n        options: { helpful: 'Helpful', not_helpful: 'Not Helpful' },\n      },\n      comment: { label: 'Comment', help: 'Optional note explaining the verdict \u2014 read by the article\u2019s author.' },\n    },\n    _sections: {\n      basic: { label: 'Feedback' },\n    },\n  },\n};\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/sales/translations/en/objects.activity.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/sales/translations/en\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/sales/translations/en/objects.activity.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport type { ObjectTranslationData } from '@objectstack/spec/system';\n\n/**\n * English (en) \u2014 `objects` translations for the ACTIVITY family:\n * the interaction log \u2014 tasks, events, and who attended.\n *\n * Roster: `crm_task`, `crm_event`, `crm_event_attendee`.\n *\n * SPLIT AXIS (#1311): translation NAMESPACE first, then CRM DOMAIN FAMILY.\n * Everything that is not `objects` lives in `./app.ts`; `objects` \u2014 69-78% of\n * every bundle \u2014 is one file per CRM domain family, and a detail object\n * follows its master. A new row goes in the file for ITS family, never in\n * whichever file is already open: that is how one file re-grows past the 70%\n * advisory band `pnpm hygiene` prints. Full rule and rationale:\n * `src/sales/translations/en.ts`.\n */\nexport const activity: Record<string, ObjectTranslationData> = {\n  crm_task: {\n    label: 'Task',\n    pluralLabel: 'Tasks',\n    fields: {\n      subject: { label: 'Subject' },\n      description: { label: 'Description' },\n      status: {\n        label: 'Status',\n        options: {\n          not_started: 'Not Started', in_progress: 'In Progress', waiting: 'Waiting',\n          completed: 'Completed', deferred: 'Deferred',\n        },\n      },\n      priority: {\n        label: 'Priority',\n        options: { low: 'Low', normal: 'Normal', high: 'High', urgent: 'Urgent' },\n      },\n      type: {\n        label: 'Task Type',\n        options: {\n          call: 'Call', email: 'Email', meeting: 'Meeting',\n          follow_up: 'Follow-up', demo: 'Demo', other: 'Other',\n        },\n      },\n      due_date: { label: 'Due Date' },\n      reminder_date: { label: 'Reminder Date/Time' },\n      completed_date: { label: 'Completed Date' },\n      owner_id: { label: 'Assigned To' },\n      related_to_type: {\n        label: 'Related To Type',\n        options: {\n          crm_account: 'Account', crm_contact: 'Contact', crm_opportunity: 'Opportunity',\n          crm_lead: 'Lead', crm_case: 'Case',\n        },\n      },\n      related_to_account: { label: 'Related Account' },\n      related_to_contact: { label: 'Related Contact' },\n      related_to_opportunity: { label: 'Related Opportunity' },\n      related_to_lead: { label: 'Related Lead' },\n      related_to_case: { label: 'Related Case' },\n      is_recurring: { label: 'Recurring Task' },\n      recurrence_type: {\n        label: 'Recurrence Type',\n        options: { daily: 'Daily', weekly: 'Weekly', monthly: 'Monthly', yearly: 'Yearly' },\n      },\n      recurrence_interval: { label: 'Recurrence Interval' },\n      recurrence_end_date: { label: 'Recurrence End Date' },\n      is_completed: { label: 'Is Completed' },\n      is_overdue: { label: 'Is Overdue' },\n      progress_percent: { label: 'Progress (%)' },\n      priority_rank: { label: 'Priority Rank' },\n      reminder_sent: { label: 'Reminder Sent' },\n    },\n    _views: {\n      all_tasks: { label: 'All Tasks' },\n      task_board: { label: 'Task Board' },\n      task_calendar: { label: 'Task Schedule' },\n      task_gantt: { label: 'Execution Plan' },\n      task_timeline: { label: 'Worklog Timeline' },\n      my_open_tasks: { label: 'My Open Tasks' },\n      todays_tasks: { label: '\uD83D\uDCC5 My Priority Tasks' },\n      overdue_tasks: { label: '\u23F0 Open Tasks \u00B7 Most Overdue First' },\n    },\n    _sections: {\n      basic: { label: 'Task Information' },\n      scheduling: { label: 'Scheduling' },\n      related: { label: 'Related Records' },\n      recurrence: { label: 'Recurrence' },\n      effort: { label: 'Progress & Effort' },\n      system: { label: 'System' },\n      // Form section names on task.view.ts (#1100)\n      task: { label: 'Task' },\n      related_records: { label: 'Related Records' },\n      recurrence_and_effort: { label: 'Recurrence & Effort' },\n    },\n  },\n  crm_event: {\n    label: 'Event',\n    pluralLabel: 'Events',\n    description: 'Meetings, calls and other scheduled interactions with customers',\n    fields: {\n      subject: { label: 'Subject' },\n      description: { label: 'Description' },\n      type: {\n        label: 'Event Type',\n        options: {\n          meeting: 'Meeting', call: 'Call', demo: 'Demo',\n          webinar: 'Webinar', onsite_visit: 'Onsite Visit', other: 'Other',\n        },\n      },\n      status: {\n        label: 'Status',\n        options: {\n          planned: 'Planned', held: 'Held', cancelled: 'Cancelled', no_show: 'No Show',\n        },\n      },\n      owner_id: { label: 'Assigned To' },\n      start_datetime: { label: 'Start' },\n      end_datetime: { label: 'End' },\n      all_day: { label: 'All Day Event' },\n      duration_minutes: { label: 'Duration (minutes)' },\n      location: { label: 'Location', help: 'Room, address, or meeting link' },\n      related_to_type: {\n        label: 'Related To Type',\n        options: {\n          crm_account: 'Account', crm_contact: 'Contact', crm_opportunity: 'Opportunity',\n          crm_lead: 'Lead', crm_case: 'Case',\n        },\n      },\n      related_to_account: { label: 'Related Account' },\n      related_to_contact: { label: 'Related Contact' },\n      related_to_opportunity: { label: 'Related Opportunity' },\n      related_to_lead: { label: 'Related Lead' },\n      related_to_case: { label: 'Related Case' },\n      outcome_notes: { label: 'Outcome Notes', help: 'What was agreed, and what happens next' },\n    },\n    _views: {\n      all_events: { label: 'All Events' },\n      event_calendar: { label: 'Event Calendar' },\n      event_timeline: { label: 'Team Schedule' },\n      my_events: { label: 'My Calendar' },\n      upcoming_events: { label: '\uD83D\uDCC5 Upcoming \u00B7 Soonest First' },\n      held_events: { label: '\u2705 Interaction History' },\n    },\n    _sections: {\n      basic: { label: 'Event Information' },\n      schedule: { label: 'Schedule' },\n      related: { label: 'Related Records' },\n      outcome: { label: 'Outcome' },\n      // Form section names on event.view.ts (#1100). `related_records`,\n      // not `related` \u2014 `related` is already the fieldGroup key above.\n      event: { label: 'Event' },\n      related_records: { label: 'Related Records' },\n    },\n  },\n  crm_event_attendee: {\n    label: 'Event Attendee',\n    pluralLabel: 'Event Attendees',\n    description: 'A person invited to or present at an event',\n    fields: {\n      attendee_number: { label: 'Attendee Number' },\n      crm_event: { label: 'Event' },\n      attendee_type: {\n        label: 'Attendee Type',\n        options: { contact: 'Contact', lead: 'Lead', user: 'User', external: 'External' },\n      },\n      crm_contact: { label: 'Contact', help: 'Set when the attendee is an existing customer contact' },\n      crm_lead: { label: 'Lead', help: 'Set when the attendee is still an unconverted lead' },\n      sys_user: { label: 'User', help: 'Set when the attendee is a colleague' },\n      external_name: {\n        label: 'External Attendee',\n        help: 'Name of an attendee who is in no CRM object \u2014 set when Attendee Type is External',\n      },\n      response: {\n        label: 'Response',\n        options: {\n          no_response: 'No Response', accepted: 'Accepted',\n          declined: 'Declined', tentative: 'Tentative',\n        },\n      },\n      is_organizer: { label: 'Organizer' },\n      invited_date: { label: 'Invited' },\n    },\n    _views: {\n      all_event_attendees: { label: 'Event Attendees' },\n    },\n    _sections: {\n      basic: { label: 'Attendee' },\n      response: { label: 'Invitation' },\n      // Form section names on event_attendee.view.ts (#1100) \u2014 same English\n      // text as the fieldGroups above, but a distinct key: `attendee` /\n      // `invitation` are not `basic` / `response`.\n      attendee: { label: 'Attendee' },\n      invitation: { label: 'Invitation' },\n    },\n  },\n};\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/sales/translations/en/objects.marketing.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/sales/translations/en\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/sales/translations/en/objects.marketing.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport type { ObjectTranslationData } from '@objectstack/spec/system';\n\n/**\n * English (en) \u2014 `objects` translations for the MARKETING family:\n * demand generation \u2014 campaigns and their membership.\n *\n * Roster: `crm_campaign`, `crm_campaign_member`.\n *\n * SPLIT AXIS (#1311): translation NAMESPACE first, then CRM DOMAIN FAMILY.\n * Everything that is not `objects` lives in `./app.ts`; `objects` \u2014 69-78% of\n * every bundle \u2014 is one file per CRM domain family, and a detail object\n * follows its master. A new row goes in the file for ITS family, never in\n * whichever file is already open: that is how one file re-grows past the 70%\n * advisory band `pnpm hygiene` prints. Full rule and rationale:\n * `src/sales/translations/en.ts`.\n */\nexport const marketing: Record<string, ObjectTranslationData> = {\n  crm_campaign: {\n    label: 'Campaign',\n    pluralLabel: 'Campaigns',\n    fields: {\n      campaign_code: { label: 'Campaign Code' },\n      name: { label: 'Campaign Name' },\n      description: { label: 'Description' },\n      type: {\n        label: 'Campaign Type',\n        options: {\n          email: 'Email', webinar: 'Webinar', trade_show: 'Trade Show',\n          conference: 'Conference', direct_mail: 'Direct Mail', social_media: 'Social Media',\n          content: 'Content Marketing', partner: 'Partner Marketing',\n        },\n      },\n      channel: {\n        label: 'Primary Channel',\n        options: {\n          digital: 'Digital', social: 'Social', email: 'Email',\n          events: 'Events', partner: 'Partner',\n        },\n      },\n      status: {\n        label: 'Status',\n        options: {\n          planning: 'Planning', in_progress: 'In Progress',\n          completed: 'Completed', aborted: 'Aborted',\n        },\n      },\n      start_date: { label: 'Start Date' },\n      end_date: { label: 'End Date' },\n      budgeted_cost: { label: 'Budgeted Cost' },\n      actual_cost: { label: 'Actual Cost' },\n      expected_revenue: { label: 'Expected Revenue' },\n      actual_revenue: { label: 'Actual Revenue' },\n      target_size: { label: 'Target Size', help: 'Target number of leads/contacts' },\n      num_sent: { label: 'Number Sent' },\n      num_responses: { label: 'Number of Responses' },\n      num_leads: { label: 'Number of Leads' },\n      num_converted_leads: { label: 'Converted Leads' },\n      num_opportunities: { label: 'Opportunities Created' },\n      num_won_opportunities: { label: 'Won Opportunities' },\n      response_rate: { label: 'Response Rate %' },\n      roi: { label: 'ROI %' },\n      owner_id: { label: 'Campaign Owner' },\n      landing_page_url: { label: 'Landing Page' },\n      is_active: { label: 'Active' },\n      display_title: { label: 'Display Title' },\n    },\n    _views: {\n      all_campaigns: { label: 'All Campaigns' },\n      campaign_gantt: { label: 'Campaign Schedule' },\n      campaign_calendar: { label: 'Launch Calendar' },\n      campaign_timeline: { label: 'Marketing Timeline' },\n    },\n    _sections: {\n      basic: { label: 'Campaign Information' },\n      schedule: { label: 'Schedule' },\n      budget: { label: 'Budget & ROI' },\n      metrics: { label: 'Performance' },\n      assignment: { label: 'Ownership' },\n      assets: { label: 'Campaign Assets' },\n    },\n    _actions: {\n      enroll_leads: {\n        label: 'Enroll Members',\n        successMessage: 'Eligible members enrolled in campaign.',\n      },\n    },\n  },\n  crm_campaign_member: {\n    label: 'Campaign Member',\n    pluralLabel: 'Campaign Members',\n    description: 'Leads and contacts touched by a campaign, with response status',\n    fields: {\n      member_number: { label: 'Member Number' },\n      crm_campaign: { label: 'Campaign' },\n      crm_lead: { label: 'Lead', help: 'Set when the member was a Lead at enrollment time' },\n      crm_contact: { label: 'Contact', help: 'Set when the member is an existing Contact' },\n      status: {\n        label: 'Status',\n        options: {\n          sent: 'Sent', responded: 'Responded',\n          converted: 'Converted', unsubscribed: 'Unsubscribed',\n        },\n      },\n      added_date: { label: 'Added Date' },\n      response_date: { label: 'Response Date' },\n      has_responded: { label: 'Has Responded' },\n    },\n    _sections: {\n      basic: { label: 'Basic Information' },\n      response: { label: 'Response Tracking' },\n    },\n    _actions: {\n      mark_responded: {\n        label: 'Mark Responded',\n        successMessage: 'Response recorded on this campaign member.',\n      },\n    },\n  },\n};\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/sales/translations/en.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/sales/translations\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/sales/translations/en.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport type { TranslationData } from '@objectstack/spec/system';\n\nimport { appSurface } from './en/app';\nimport { customer } from './en/objects.customer';\nimport { pipeline } from './en/objects.pipeline';\nimport { commerce } from './en/objects.commerce';\nimport { service } from './en/objects.service';\nimport { activity } from './en/objects.activity';\nimport { marketing } from './en/objects.marketing';\n\n/**\n * English (en) \u2014 CRM App Translations\n *\n * Per-locale file: one file per language, following the `per_locale` convention.\n * Each file exports a single `TranslationData` object for its locale.\n *\n * SPLIT AXIS (#1311): translation NAMESPACE first, then CRM DOMAIN FAMILY.\n *\n * This bundle was one file and it had reached 88.6% of the 100KB source cap\n * `pnpm hygiene` enforces, growing ~1.2KB a day. It is now assembled from\n * `./<locale>/`, on an axis measured rather than guessed:\n *\n *   - every namespace that is NOT `objects` \u2014 `apps`, `messages`,\n *     `dashboards`, `datasets`, `pages`, and any namespace `TranslationData`\n *     gains later \u2014 lives in `app.ts`. Measured: those namespaces together\n *     are under a quarter of the bundle, and the schema bounds how many can\n *     ever arrive, so one file holds them with room left;\n *   - `objects` is 69-78% of every bundle, so it is partitioned again, one\n *     file per CRM domain family \u2014 `customer`, `pipeline`, `commerce`,\n *     `service`, `activity`, `marketing` \u2014 and a DETAIL object follows its\n *     master: line items follow their quote or opportunity,\n *     `crm_event_attendee` follows `crm_event`, `crm_campaign_member`\n *     follows `crm_campaign`, `crm_article_feedback` follows\n *     `crm_knowledge_article`.\n *\n * A namespace axis ALONE was measured and rejected: it leaves `objects` at\n * 65.7KB, 3.9KB under the advisory band, which `objects` growth crosses in\n * about nine days. The family axis puts the largest part at 24.2% of the cap.\n *\n * \u26A0\uFE0F A new object translation belongs in the file for ITS family. Do not add\n * it to whichever file is already open \u2014 that is how one file re-grows past\n * the band, which is what split this bundle in the first place.\n *\n * \u26A0\uFE0F A value used by more than one family lives in `<locale>/_shared.ts`. A\n * value used by exactly one family lives in that family's file.\n *\n * \u26A0\uFE0F The key order below is LOAD-BEARING, not cosmetic. `objectstack build`\n * serialises this object into `dist/objectstack.json` in insertion order and\n * never sorts it, so listing the rows here \u2014 rather than spreading the family\n * files \u2014 is what keeps the built artifact byte-identical across the split.\n * The order is this bundle's own historical accretion order and differs\n * between locales; reordering it rewrites the artifact.\n */\nexport const en: TranslationData = {\n  objects: {\n    crm_account: customer.crm_account,\n    crm_contact: customer.crm_contact,\n    crm_knowledge_article: service.crm_knowledge_article,\n    crm_forecast: pipeline.crm_forecast,\n    crm_lead: pipeline.crm_lead,\n    crm_opportunity: pipeline.crm_opportunity,\n    crm_case: service.crm_case,\n    crm_contract: commerce.crm_contract,\n    crm_product: commerce.crm_product,\n    crm_quote: commerce.crm_quote,\n    crm_task: activity.crm_task,\n    crm_campaign: marketing.crm_campaign,\n    crm_event: activity.crm_event,\n    crm_event_attendee: activity.crm_event_attendee,\n    crm_article_feedback: service.crm_article_feedback,\n    crm_campaign_member: marketing.crm_campaign_member,\n    crm_opportunity_line_item: pipeline.crm_opportunity_line_item,\n    crm_quote_line_item: commerce.crm_quote_line_item,\n  },\n  ...appSurface,\n};\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/sales/translations/zh-CN/app.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/sales/translations/zh-CN\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/sales/translations/zh-CN/app.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport type { TranslationData } from '@objectstack/spec/system';\n\nimport { QUOTE_DISCOUNT_CEILING } from '../../objects/_thresholds';\n\n/**\n * \u7B80\u4F53\u4E2D\u6587 (zh-CN) \u2014 every translation namespace EXCEPT `objects`:\n * `apps`, `messages`, `dashboards`, `datasets`, `pages`, `flows`.\n *\n * SPLIT AXIS (#1311): translation NAMESPACE first, then CRM DOMAIN FAMILY.\n * Everything that is not `objects` lives in `./app.ts`; `objects` \u2014 69-78% of\n * every bundle \u2014 is one file per CRM domain family, and a detail object\n * follows its master. A new row goes in the file for ITS family, never in\n * whichever file is already open: that is how one file re-grows past the 70%\n * advisory band `pnpm hygiene` prints. Full rule and rationale:\n * `src/sales/translations/zh-CN.ts`.\n *\n * A namespace `TranslationData` gains later lands here too, and the room is\n * measured: this file is the smaller half of the bundle, and the schema bounds\n * how many namespaces can ever arrive.\n */\nexport const appSurface: Omit<TranslationData, 'objects'> = {\n  apps: {\n    crm_enterprise: {\n      label: 'HotCRM',\n      description: '\u6DB5\u76D6\u9500\u552E\u3001\u670D\u52A1\u548C\u5E02\u573A\u8425\u9500\u7684\u5BA2\u6237\u5173\u7CFB\u7BA1\u7406\u7CFB\u7EDF',\n      // Keyed by navigation-node `id` (a flat keyspace regardless of depth).\n      navigation: {\n        group_activity: { label: '\u6D3B\u52A8' },\n        nav_event: { label: '\u6D3B\u52A8' },\n        nav_activity_dashboard: { label: '\u9500\u552E\u6D3B\u52A8' },\n        nav_my_calendar: { label: '\u6211\u7684\u65E5\u5386' },\n        nav_home: { label: '\u9996\u9875' },\n\n        group_sales: { label: '\u9500\u552E' },\n        nav_lead: { label: '\u7EBF\u7D22' },\n        nav_account: { label: '\u5BA2\u6237' },\n        nav_account_workbench: { label: '\u5BA2\u6237\u5DE5\u4F5C\u53F0' },\n        nav_contact: { label: '\u8054\u7CFB\u4EBA' },\n        nav_opportunity: { label: '\u5546\u673A' },\n        nav_quote: { label: '\u62A5\u4EF7' },\n        nav_contract: { label: '\u5408\u540C' },\n        nav_product: { label: '\u4EA7\u54C1' },\n        nav_sales_dashboard: { label: '\u9500\u552E\u4E1A\u7EE9' },\n\n        group_work: { label: '\u6211\u7684\u5DE5\u4F5C' },\n        nav_my_tasks: { label: '\u6211\u7684\u4EFB\u52A1' },\n        nav_my_deals: { label: '\u6211\u7684\u5546\u673A' },\n        nav_my_leads: { label: '\u6211\u7684\u7EBF\u7D22' },\n        nav_my_cases: { label: '\u6211\u7684\u5DE5\u5355' },\n        nav_approval_requests: { label: '\u5F85\u6211\u5BA1\u6279' },\n\n        group_marketing: { label: '\u5E02\u573A\u8425\u9500' },\n        nav_campaign: { label: '\u8425\u9500\u6D3B\u52A8' },\n\n        group_service: { label: '\u670D\u52A1' },\n        nav_case: { label: '\u5DE5\u5355' },\n        nav_knowledge: { label: '\u77E5\u8BC6\u5E93' },\n        nav_service_dashboard: { label: '\u670D\u52A1\u6982\u89C8' },\n\n        group_insights: { label: '\u6570\u636E\u6D1E\u5BDF' },\n        nav_crm_dashboard: { label: 'CRM \u603B\u89C8' },\n        nav_forecast: { label: '\u9500\u552E\u9884\u6D4B' },\n        nav_report_pipeline_coverage: { label: '\u7BA1\u9053\u8986\u76D6\u7387' },\n        nav_report_lead_inflow: { label: '\u7EBF\u7D22\u6D41\u5165' },\n        nav_report_sla: { label: 'SLA \u8FBE\u6210' },\n      },\n    },\n  },\n  messages: {\n    'common.save': '\u4FDD\u5B58',\n    'common.cancel': '\u53D6\u6D88',\n    'common.delete': '\u5220\u9664',\n    'common.edit': '\u7F16\u8F91',\n    'common.create': '\u65B0\u5EFA',\n    'common.search': '\u641C\u7D22',\n    'common.filter': '\u7B5B\u9009',\n    'common.export': '\u5BFC\u51FA',\n    'common.back': '\u8FD4\u56DE',\n    'common.confirm': '\u786E\u8BA4',\n    'nav.sales': '\u9500\u552E',\n    'nav.service': '\u670D\u52A1',\n    'nav.marketing': '\u8425\u9500',\n    'nav.products': '\u4EA7\u54C1',\n    'nav.analytics': '\u6570\u636E\u5206\u6790',\n    'success.saved': '\u8BB0\u5F55\u4FDD\u5B58\u6210\u529F',\n    'success.converted': '\u7EBF\u7D22\u8F6C\u5316\u6210\u529F',\n    'confirm.delete': '\u786E\u5B9A\u8981\u5220\u9664\u6B64\u8BB0\u5F55\u5417\uFF1F',\n    'confirm.convert_lead': '\u5C06\u6B64\u7EBF\u7D22\u8F6C\u5316\u4E3A\u5BA2\u6237\u3001\u8054\u7CFB\u4EBA\u548C\u5546\u673A\uFF1F',\n    'error.required': '\u6B64\u5B57\u6BB5\u4E3A\u5FC5\u586B\u9879',\n    'error.load_failed': '\u6570\u636E\u52A0\u8F7D\u5931\u8D25',\n  },\n  dashboards: {\n    sales_activity_dashboard: {\n      label: '\u9500\u552E\u6D3B\u52A8',\n      description: '\u8C01\u5728\u548C\u5BA2\u6237\u6C9F\u901A\u3001\u9891\u7387\u5982\u4F55\uFF0C\u4EE5\u53CA\u54EA\u4E9B\u5BA2\u6237\u5DF2\u7ECF\u6C89\u9ED8',\n      widgets: {\n        interactions_held: { title: '\u5DF2\u8BB0\u5F55\u4E92\u52A8', description: '\u771F\u5B9E\u53D1\u751F\u8FC7\u7684\u901A\u8BDD\u4E0E\u4F1A\u8BAE' },\n        meetings_booked: { title: '\u5DF2\u9884\u7EA6\u4F1A\u8BAE', description: '\u5DF2\u6392\u5165\u65E5\u5386\u4F46\u5C1A\u672A\u4E3E\u884C\u7684\u4F1A\u8BAE' },\n        customer_minutes: { title: '\u5BA2\u6237\u63A5\u89E6\u5206\u949F\u6570', description: '\u9762\u5411\u5BA2\u6237\u7684\u603B\u65F6\u957F' },\n        tasks_completed: { title: '\u5DF2\u5B8C\u6210\u4EFB\u52A1', description: '\u5DF2\u95ED\u73AF\u7684\u8DDF\u8FDB\u4E8B\u9879\u2014\u2014\u6D3B\u52A8\u7684\u53E6\u4E00\u534A' },\n        activity_by_rep: { title: '\u6309\u9500\u552E\u4EE3\u8868\u7EDF\u8BA1\u7684\u6D3B\u52A8', description: '\u6BCF\u4F4D\u8D1F\u8D23\u4EBA\u8BB0\u5F55\u7684\u4E92\u52A8\u6570' },\n        activity_by_week: { title: '\u6BCF\u5468\u6D3B\u52A8\u91CF', description: '\u6BCF\u5468\u4E92\u52A8\u6570' },\n        activity_mix: { title: '\u6D3B\u52A8\u6784\u6210', description: '\u901A\u8BDD\u3001\u4F1A\u8BAE\u4E0E\u6F14\u793A\u7684\u5360\u6BD4' },\n        activity_by_record_type: { title: '\u6D3B\u52A8\u843D\u5728\u54EA\u91CC', description: '\u6F0F\u6597\u7684\u54EA\u4E2A\u73AF\u8282\u83B7\u5F97\u4E86\u5173\u6CE8' },\n        deal_activity: { title: '\u5546\u673A\u4E0A\u7684\u4E92\u52A8', description: '\u5173\u8054\u5230\u5546\u673A\u7684\u5DF2\u8BB0\u5F55\u4E92\u52A8' },\n        open_deals_for_activity: { title: '\u8FDB\u884C\u4E2D\u7684\u5546\u673A', description: '\u4ECD\u5728\u63A8\u8FDB\u7684\u5546\u673A\u6570' },\n        quiet_accounts_30: { title: '\u6C89\u9ED8 30 \u5929\u4EE5\u4E0A', description: '\u4E00\u4E2A\u6708\u5185\u6CA1\u6709\u4EFB\u4F55\u4E92\u52A8\u8BB0\u5F55\u7684\u6D3B\u8DC3\u5BA2\u6237' },\n        quiet_accounts_60: { title: '\u6C89\u9ED8 60 \u5929\u4EE5\u4E0A', description: '\u4E24\u4E2A\u6708\u65E0\u8054\u7CFB\u2014\u2014\u98CE\u9669\u9608\u503C' },\n        quiet_accounts_90: { title: '\u6C89\u9ED8 90 \u5929\u4EE5\u4E0A', description: '\u6574\u6574\u4E00\u4E2A\u5B63\u5EA6\u6CA1\u6709\u8054\u7CFB' },\n      },\n    },\n    crm_overview_dashboard: {\n      label: 'CRM \u603B\u89C8',\n      description: '\u6536\u5165\u6307\u6807\u3001\u7BA1\u9053\u5206\u6790\u4E0E\u5546\u673A\u6D1E\u5BDF',\n      widgets: {\n        total_revenue: { title: '\u603B\u6536\u5165', description: '\u672C\u671F\u5DF2\u6210\u4EA4\u6536\u5165' },\n        active_deals: { title: '\u6D3B\u8DC3\u5546\u673A', description: '\u7BA1\u9053\u4E2D\u8FDB\u884C\u4E2D\u7684\u5546\u673A' },\n        won_deals: { title: '\u8D62\u5355\u6570', description: '\u672C\u671F\u5DF2\u7ED3\u6848\u5546\u673A\u4E2D\u8D62\u5355\u7684\u603B\u6570' },\n        avg_deal_size: { title: '\u5E73\u5747\u8BA2\u5355\u91D1\u989D', description: '\u5DF2\u6210\u4EA4\u5546\u673A\u7684\u5E73\u5747\u91D1\u989D' },\n        revenue_trends: { title: '\u6536\u5165\u8D8B\u52BF', description: '\u8FC7\u53BB 12 \u4E2A\u6708\u7684\u5DF2\u6210\u4EA4\u6536\u5165' },\n        lead_source: { title: '\u7EBF\u7D22\u6765\u6E90', description: '\u6309\u83B7\u5BA2\u6E20\u9053\u7EDF\u8BA1\u7684\u7BA1\u9053\u91D1\u989D' },\n        pipeline_by_stage: { title: '\u9636\u6BB5\u7BA1\u9053\u5206\u5E03', description: '\u6309\u9636\u6BB5\u7EDF\u8BA1\u7684\u8FDB\u884C\u4E2D\u5546\u673A\u91D1\u989D' },\n        top_products: { title: '\u70ED\u95E8\u4EA7\u54C1', description: '\u6309\u4EA7\u54C1\u7C7B\u522B\u7EDF\u8BA1\u7684\u76EE\u5F55\u4EF7\u6536\u5165' },\n        pipeline_by_owner: { title: '\u6309\u8D1F\u8D23\u4EBA\u7EDF\u8BA1\u7BA1\u9053', description: '\u5404\u9500\u552E\u8D1F\u8D23\u4EBA\u7684\u8FDB\u884C\u4E2D\u7BA1\u9053\u91D1\u989D\u4E0E\u5546\u673A\u6570' },\n      },\n    },\n    executive_dashboard: {\n      label: '\u9AD8\u7BA1\u603B\u89C8',\n      description: '\u9762\u5411\u7BA1\u7406\u5C42\u7684\u6536\u5165\u3001\u5BA2\u6237\u4E0E\u7BA1\u9053\u9AD8\u9636\u6307\u6807',\n      widgets: {\n        total_revenue_ytd: { title: '\u5E74\u5EA6\u7D2F\u8BA1\u6536\u5165', description: '\u672C\u5E74\u5EA6\u5DF2\u6210\u4EA4\u6536\u5165' },\n        total_accounts: { title: '\u6D3B\u8DC3\u5BA2\u6237', description: '\u81F3\u5C11\u5B58\u5728\u4E00\u9879\u6D3B\u8DC3\u5173\u7CFB\u7684\u5BA2\u6237' },\n        total_contacts: { title: '\u8054\u7CFB\u4EBA\u603B\u6570', description: '\u901A\u8BAF\u5F55\u4E2D\u7684\u8054\u7CFB\u4EBA' },\n        open_leads: { title: '\u672A\u8F6C\u5316\u7EBF\u7D22', description: '\u6F0F\u6597\u4E2D\u5C1A\u672A\u8F6C\u5316\u7684\u7EBF\u7D22' },\n        revenue_trend: { title: '\u6536\u5165\u8D8B\u52BF', description: '\u8FC7\u53BB 12 \u4E2A\u6708\u7684\u5DF2\u6210\u4EA4\u6536\u5165' },\n        revenue_by_industry: { title: '\u884C\u4E1A\u6536\u5165\u5206\u5E03', description: '\u672C\u5E74\u5EA6\u5DF2\u6210\u4EA4\u6536\u5165\u6309\u5BA2\u6237\u884C\u4E1A\u62C6\u5206' },\n        pipeline_by_stage: { title: '\u9636\u6BB5\u7BA1\u9053\u5206\u5E03', description: '\u6309\u9636\u6BB5\u7EDF\u8BA1\u7684\u8FDB\u884C\u4E2D\u5546\u673A\u91D1\u989D' },\n        new_accounts_by_month: { title: '\u65B0\u589E\u5BA2\u6237', description: '\u8FC7\u53BB 6 \u4E2A\u6708\u7684\u5BA2\u6237\u521B\u5EFA\u8282\u594F' },\n        accounts_by_industry: { title: '\u6309\u884C\u4E1A\u7EDF\u8BA1\u5BA2\u6237', description: '\u5404\u884C\u4E1A\u7684\u5E74\u8425\u6536\u603B\u989D\u4E0E\u5BA2\u6237\u6570' },\n      },\n    },\n    sales_dashboard: {\n      label: '\u9500\u552E\u4E1A\u7EE9',\n      description: '\u7BA1\u9053\u5206\u6790\u3001\u8D62\u7387\u8D8B\u52BF\u53CA\u9500\u552E\u4EE3\u8868\u7EE9\u6548',\n      widgets: {\n        total_pipeline_value: { title: '\u7BA1\u9053\u603B\u989D', description: '\u6240\u6709\u8FDB\u884C\u4E2D\u5546\u673A\u91D1\u989D\u5408\u8BA1' },\n        closed_won_qtd: { title: '\u672C\u5B63\u5EA6\u5DF2\u6210\u4EA4', description: '\u672C\u5B63\u5EA6\u5DF2\u8D62\u5F97\u7684\u6536\u5165' },\n        open_opportunities: { title: '\u8FDB\u884C\u4E2D\u5546\u673A', description: '\u6B63\u5728\u63A8\u8FDB\u7684\u6D3B\u8DC3\u5546\u673A' },\n        avg_deal_size: { title: '\u5E73\u5747\u8BA2\u5355\u91D1\u989D', description: '\u672C\u5B63\u5EA6\u5DF2\u6210\u4EA4\u5546\u673A\u7684\u5E73\u5747\u91D1\u989D' },\n        pipeline_by_stage: { title: '\u9636\u6BB5\u7BA1\u9053\u5206\u5E03', description: '\u6309\u9636\u6BB5\u7EDF\u8BA1\u7684\u8FDB\u884C\u4E2D\u5546\u673A\u91D1\u989D' },\n        monthly_revenue_trend: { title: '\u6708\u5EA6\u6536\u5165\u8D8B\u52BF', description: '\u8FC7\u53BB 12 \u4E2A\u6708\u7684\u5DF2\u6210\u4EA4\u6536\u5165' },\n        pipeline_by_forecast_category: { title: '\u9884\u6D4B\u7C7B\u522B\u7BA1\u9053\u5206\u5E03', description: '\u6309\u9884\u6D4B\u7C7B\u522B\u7EDF\u8BA1\u7684\u8FDB\u884C\u4E2D\u7BA1\u9053\u91D1\u989D' },\n        lead_source_breakdown: { title: '\u7EBF\u7D22\u6765\u6E90\u5206\u5E03', description: '\u6309\u6765\u6E90\u7EDF\u8BA1\u7684\u7EBF\u7D22\u6570\u91CF' },\n        open_pipeline_by_owner: { title: '\u6309\u8D1F\u8D23\u4EBA\u7EDF\u8BA1\u8FDB\u884C\u4E2D\u7BA1\u9053', description: '\u5404\u9500\u552E\u8D1F\u8D23\u4EBA\u7684\u8FDB\u884C\u4E2D\u7BA1\u9053\u91D1\u989D\u3001\u5546\u673A\u6570\u4E0E\u5E73\u5747\u8D62\u5355\u6982\u7387' },\n        quota_attainment_by_rep: { title: '\u6309\u9500\u552E\u4EE3\u8868\u7EDF\u8BA1\u914D\u989D\u8FBE\u6210', description: '\u6765\u81EA\u9884\u6D4B\u5FEB\u7167\u7684\u5404\u9500\u552E\u4EE3\u8868\u672C\u5B63\u5EA6\u914D\u989D\u3001\u5DF2\u6210\u4EA4\u6536\u5165\u4E0E\u8FBE\u6210\u7387' },\n        pipeline_stage_by_source: { title: '\u9636\u6BB5 \u00D7 \u7EBF\u7D22\u6765\u6E90', description: '\u6309\u9636\u6BB5\u548C\u6765\u6E90\u4EA4\u53C9\u7EDF\u8BA1\u8FDB\u884C\u4E2D\u5546\u673A\u91D1\u989D' },\n        win_rate_12m: { title: '\u8D62\u7387\uFF08\u8FD1 12 \u4E2A\u6708\uFF09', description: '\u8FD1 12 \u4E2A\u6708\u5DF2\u7ED3\u5355\u5546\u673A\u4E2D\u8D62\u5355\u6240\u5360\u7684\u6BD4\u4F8B' },\n        won_deals_12m: { title: '\u8D62\u5355\u6570\uFF08\u8FD1 12 \u4E2A\u6708\uFF09', description: '\u8D62\u7387\u7684\u5206\u5B50' },\n        lost_deals_12m: { title: '\u4E22\u5355\u6570\uFF08\u8FD1 12 \u4E2A\u6708\uFF09', description: '\u8D62\u7387\u5206\u6BCD\u7684\u53E6\u4E00\u534A' },\n        win_rate_by_owner: { title: '\u6309\u9500\u552E\u4EE3\u8868\u7EDF\u8BA1\u8D62/\u4E22\u5355', description: '\u8FD1 12 \u4E2A\u6708\u5404\u9500\u552E\u4EE3\u8868\u7684\u8D62\u5355\u6570\u3001\u4E22\u5355\u6570\u4E0E\u8D62\u7387' },\n        win_rate_by_lead_source: { title: '\u6309\u7EBF\u7D22\u6765\u6E90\u7EDF\u8BA1\u8D62/\u4E22\u5355', description: '\u8FD1 12 \u4E2A\u6708\u54EA\u4E9B\u6765\u6E90\u5E26\u6765\u7684\u5546\u673A\u771F\u6B63\u6210\u4EA4' },\n        loss_reason_breakdown: { title: '\u4E22\u5355\u539F\u56E0\u5206\u6790', description: '\u8FD1 12 \u4E2A\u6708\u4E22\u5355\u6309\u539F\u56E0\u5206\u5E03' },\n      },\n    },\n    service_dashboard: {\n      label: '\u5BA2\u6237\u670D\u52A1',\n      description: '\u5DE5\u5355\u8D1F\u8F7D\u3001SLA \u5065\u5EB7\u5EA6\u4E0E\u5904\u7406\u7EE9\u6548',\n      widgets: {\n        open_cases: { title: '\u672A\u5173\u95ED\u5DE5\u5355', description: '\u5C1A\u672A\u5173\u95ED\u7684\u5DE5\u5355' },\n        critical_cases: { title: '\u4E25\u91CD\u5DE5\u5355', description: '\u6807\u8BB0\u4E3A\u4E25\u91CD\u4F18\u5148\u7EA7\u7684\u672A\u5173\u95ED\u5DE5\u5355' },\n        avg_resolution_time: { title: '\u5E73\u5747\u89E3\u51B3\u65F6\u957F', description: '\u5173\u95ED\u5DE5\u5355\u7684\u5E73\u5747\u5904\u7406\u65F6\u957F\uFF08\u5C0F\u65F6\uFF09' },\n        sla_violations: { title: 'SLA \u8FDD\u7EA6', description: '\u5DF2\u8D85\u51FA SLA \u7684\u5DE5\u5355' },\n        cases_by_status: { title: '\u6309\u72B6\u6001\u5206\u5E03', description: '\u5DE5\u5355\u5728\u5404\u5904\u7406\u9636\u6BB5\u7684\u5206\u5E03' },\n        cases_by_priority: { title: '\u6309\u4F18\u5148\u7EA7\u5206\u5E03', description: '\u672A\u5173\u95ED\u5DE5\u5355\u6309\u7D27\u6025\u7A0B\u5EA6\u7684\u5206\u5E03' },\n        cases_by_origin: { title: '\u6309\u6765\u6E90\u5206\u5E03', description: '\u5DE5\u5355\u7684\u6765\u6E90\u6E20\u9053' },\n        daily_case_volume: { title: '\u6BCF\u65E5\u5DE5\u5355\u91CF', description: '\u8FC7\u53BB 30 \u5929\u7684\u65B0\u5EFA\u5DE5\u5355' },\n        sla_compliance_gauge: { title: 'SLA \u8FBE\u6210\u7387', description: '\u672C\u671F SLA \u5185\u89E3\u51B3\u5DE5\u5355\u7684\u5360\u6BD4' },\n        kb_deflection_rate: { title: '\u77E5\u8BC6\u5E93\u8F6C\u79FB\u7387', description: '\u5DF2\u5173\u95ED\u5DE5\u5355\u4E2D\u7531\u77E5\u8BC6\u6587\u7AE0\u89E3\u51B3\u7684\u5360\u6BD4' },\n        kb_resolved_cases: { title: '\u77E5\u8BC6\u5E93\u89E3\u51B3\u6570', description: '\u5DF2\u5173\u8054\u89E3\u51B3\u6587\u7AE0\u7684\u5DF2\u5173\u95ED\u5DE5\u5355' },\n        closed_cases_total: { title: '\u5DF2\u5173\u95ED\u5DE5\u5355', description: '\u8F6C\u79FB\u7387\u7684\u5206\u6BCD' },\n        top_resolving_articles: { title: '\u89E3\u51B3\u5DE5\u5355\u6700\u591A\u7684\u6587\u7AE0', description: '\u6309\u89E3\u51B3\u7684\u5DF2\u5173\u95ED\u5DE5\u5355\u6570\u6392\u540D\u7684\u77E5\u8BC6\u6587\u7AE0' },\n        my_open_cases_by_priority: { title: '\u6211\u7684\u672A\u5173\u95ED\u5DE5\u5355\uFF08\u6309\u4F18\u5148\u7EA7\uFF09', description: '\u4F60\u7684\u672A\u5173\u95ED\u5DE5\u5355\u53CA\u5176 SLA \u8FDD\u7EA6\u7387\uFF0C\u6309\u4F18\u5148\u7EA7\u7EC6\u5206' },\n      },\n    },\n  },\n  // `title` / `subtitle` translate the page's `page:header`; `title` falls back\n  // to `label` when omitted, so it is authored only where the two differ.\n  // Header strings carrying `{field}` tokens keep the token spelling verbatim \u2014\n  // the console substitutes on the raw key, so a translated token resolves to\n  // nothing and the header renders blank.\n  datasets: {\n    account_metrics: {\n      label: '\u5BA2\u6237\u6307\u6807',\n      description: '\u6309\u884C\u4E1A\u4E0E\u7C7B\u578B\u7EDF\u8BA1\u5BA2\u6237\u6570\u91CF\u7684\u8BED\u4E49\u5C42',\n      dimensions: {\n        industry: {\n          label: '\u884C\u4E1A',\n        },\n        type: {\n          label: '\u7C7B\u578B',\n        },\n        created_at: {\n          label: '\u521B\u5EFA\u65F6\u95F4',\n        },\n      },\n      measures: {\n        account_count: {\n          label: '\u5BA2\u6237\u6570',\n        },\n        annual_revenue_sum: {\n          label: '\u5E74\u8425\u6536',\n        },\n      },\n    },\n    case_metrics: {\n      label: '\u5DE5\u5355\u6307\u6807',\n      description: '\u7EDF\u8BA1\u5DE5\u5355\u6570\u91CF\u3001\u89E3\u51B3\u65F6\u957F\u4E0E SLA \u7684\u8BED\u4E49\u5C42',\n      dimensions: {\n        created_at: {\n          label: '\u521B\u5EFA\u65F6\u95F4',\n        },\n        origin: {\n          label: '\u6765\u6E90',\n        },\n        priority: {\n          label: '\u4F18\u5148\u7EA7',\n        },\n        resolved_article: {\n          label: '\u89E3\u51B3\u7528\u77E5\u8BC6\u6587\u7AE0',\n        },\n        status: {\n          label: '\u72B6\u6001',\n        },\n        type: {\n          label: '\u7C7B\u578B',\n        },\n      },\n      measures: {\n        avg_resolution: {\n          label: '\u5E73\u5747\u89E3\u51B3\u65F6\u957F\uFF08\u5C0F\u65F6\uFF09',\n        },\n        avg_sla_violated: {\n          label: 'SLA \u8FDD\u7EA6\u7387',\n        },\n        case_count: {\n          label: '\u5DE5\u5355\u6570',\n        },\n        closed_count: {\n          label: '\u5DF2\u5173\u95ED\u5DE5\u5355',\n        },\n        kb_deflection_rate: {\n          label: '\u77E5\u8BC6\u5E93\u81EA\u52A9\u89E3\u51B3\u7387',\n        },\n        kb_resolved_count: {\n          label: '\u77E5\u8BC6\u5E93\u89E3\u51B3\u6570',\n        },\n        sla_compliance_rate: {\n          label: 'SLA \u8FBE\u6807\u7387',\n        },\n        sla_met_count: {\n          label: 'SLA \u8FBE\u6807\u5DE5\u5355',\n        },\n      },\n    },\n    contact_metrics: {\n      label: '\u8054\u7CFB\u4EBA\u6307\u6807',\n      description: '\u7EDF\u8BA1\u8054\u7CFB\u4EBA\u6570\u91CF\u7684\u8BED\u4E49\u5C42',\n      measures: {\n        contact_count: {\n          label: '\u8054\u7CFB\u4EBA\u6570',\n        },\n      },\n    },\n    event_metrics: {\n      label: '\u6D3B\u52A8\u6307\u6807',\n      description: '\u7EDF\u8BA1\u4F1A\u8BAE\u3001\u901A\u8BDD\u4E0E\u4E92\u52A8\u65B0\u8FD1\u5EA6\u7684\u8BED\u4E49\u5C42',\n      dimensions: {\n        owner: {\n          label: '\u8D1F\u8D23\u4EBA',\n        },\n        related_to_type: {\n          label: '\u5173\u8054\u5BF9\u8C61',\n        },\n        start_datetime: {\n          label: '\u6D3B\u52A8\u5468',\n        },\n        status: {\n          label: '\u72B6\u6001',\n        },\n        type: {\n          label: '\u6D3B\u52A8\u7C7B\u578B',\n        },\n      },\n      measures: {\n        avg_minutes: {\n          label: '\u5E73\u5747\u65F6\u957F',\n        },\n        event_count: {\n          label: '\u6D3B\u52A8\u6570',\n        },\n        total_minutes: {\n          label: '\u603B\u5206\u949F\u6570',\n        },\n      },\n    },\n    forecast_metrics: {\n      label: '\u9500\u552E\u9884\u6D4B\u6307\u6807',\n      description: '\u6309\u8D1F\u8D23\u4EBA\u7EDF\u8BA1\u914D\u989D\u3001\u8FBE\u6210\u7387\u4E0E\u7BA1\u9053\u8986\u76D6\u500D\u6570\u7684\u8BED\u4E49\u5C42',\n      dimensions: {\n        owner: {\n          label: '\u8D1F\u8D23\u4EBA',\n        },\n        period: {\n          label: '\u5468\u671F\u7C7B\u578B',\n        },\n        period_label: {\n          label: '\u5468\u671F',\n        },\n        period_start: {\n          label: '\u5468\u671F\u5F00\u59CB',\n        },\n      },\n      measures: {\n        attainment: {\n          label: '\u8FBE\u6210\u7387',\n        },\n        closed_sum: {\n          label: '\u5DF2\u6210\u4EA4',\n        },\n        commit_sum: {\n          label: '\u627F\u8BFA',\n        },\n        pipeline_sum: {\n          label: '\u9500\u552E\u7BA1\u9053',\n        },\n        quota_sum: {\n          label: '\u914D\u989D',\n        },\n      },\n    },\n    lead_metrics: {\n      label: '\u7EBF\u7D22\u6307\u6807',\n      description: '\u7EDF\u8BA1\u7EBF\u7D22\u6570\u91CF\u7684\u8BED\u4E49\u5C42',\n      dimensions: {\n        created_at: {\n          label: '\u521B\u5EFA\u65F6\u95F4',\n        },\n        last_contacted_date: {\n          label: '\u6700\u8FD1\u8054\u7CFB',\n        },\n        lead_source: {\n          label: '\u6765\u6E90',\n        },\n        status: {\n          label: '\u72B6\u6001',\n        },\n      },\n      measures: {\n        lead_count: {\n          label: '\u7EBF\u7D22\u6570',\n        },\n      },\n    },\n    opportunity_metrics: {\n      label: '\u5546\u673A\u6307\u6807',\n      description: '\u7EDF\u8BA1\u9500\u552E\u7BA1\u9053\u6570\u91CF\u4E0E\u91D1\u989D\u7684\u8BED\u4E49\u5C42',\n      dimensions: {\n        account_industry: {\n          label: '\u5BA2\u6237\u884C\u4E1A',\n        },\n        close_date: {\n          label: '\u9884\u8BA1\u6210\u4EA4\u65E5',\n        },\n        close_quarter: {\n          label: '\u6210\u4EA4\u5B63\u5EA6',\n        },\n        forecast_category: {\n          label: '\u9884\u6D4B\u7C7B\u522B',\n        },\n        lead_source: {\n          label: '\u7EBF\u7D22\u6765\u6E90',\n        },\n        loss_reason: {\n          label: '\u5931\u5355\u539F\u56E0',\n        },\n        owner: {\n          label: '\u8D1F\u8D23\u4EBA',\n        },\n        stage: {\n          label: '\u9636\u6BB5',\n        },\n        type: {\n          label: '\u5546\u673A\u7C7B\u578B',\n        },\n        win_reason: {\n          label: '\u8D62\u5355\u539F\u56E0',\n        },\n      },\n      measures: {\n        avg_amount: {\n          label: '\u5E73\u5747\u5355\u7B14\u91D1\u989D',\n        },\n        avg_probability: {\n          label: '\u5E73\u5747\u8D62\u5355\u6982\u7387',\n        },\n        decided_count: {\n          label: '\u5DF2\u5B9A\u5C40\u5546\u673A',\n        },\n        lost_amount: {\n          label: '\u5931\u5355\u91D1\u989D',\n        },\n        lost_count: {\n          label: '\u5931\u5355\u6570',\n        },\n        opp_count: {\n          label: '\u5546\u673A\u6570',\n        },\n        total_amount: {\n          label: '\u603B\u91D1\u989D',\n        },\n        win_rate: {\n          label: '\u8D62\u5355\u7387',\n        },\n        won_amount: {\n          label: '\u8D62\u5355\u91D1\u989D',\n        },\n        won_count: {\n          label: '\u8D62\u5355\u6570',\n        },\n      },\n    },\n    product_metrics: {\n      label: '\u4EA7\u54C1\u6307\u6807',\n      description: '\u7EDF\u8BA1\u4EA7\u54C1\u76EE\u5F55\u6570\u91CF\u4E0E\u6807\u4EF7\u7684\u8BED\u4E49\u5C42',\n      dimensions: {\n        category: {\n          label: '\u7C7B\u522B',\n        },\n      },\n      measures: {\n        list_price_sum: {\n          label: '\u6807\u4EF7\u5408\u8BA1',\n        },\n        product_count: {\n          label: '\u4EA7\u54C1\u6570',\n        },\n      },\n    },\n    task_metrics: {\n      label: '\u4EFB\u52A1\u6307\u6807',\n      description: '\u7EDF\u8BA1\u4EFB\u52A1\u5DE5\u4F5C\u91CF\u4E0E\u5B8C\u6210\u60C5\u51B5\u7684\u8BED\u4E49\u5C42',\n      dimensions: {\n        due_date: {\n          label: '\u622A\u6B62\u65E5\u671F',\n        },\n        is_completed: {\n          label: '\u5DF2\u5B8C\u6210',\n        },\n        is_overdue: {\n          label: '\u5DF2\u903E\u671F',\n        },\n        priority: {\n          label: '\u4F18\u5148\u7EA7',\n        },\n        priority_rank: {\n          label: '\u7D27\u6025\u5EA6',\n        },\n        status: {\n          label: '\u72B6\u6001',\n        },\n        type: {\n          label: '\u7C7B\u578B',\n        },\n      },\n      measures: {\n        avg_progress: {\n          label: '\u5E73\u5747\u8FDB\u5EA6',\n        },\n        task_count: {\n          label: '\u4EFB\u52A1\u6570',\n        },\n      },\n    },\n  },\n  pages: {\n    account_detail_page: {\n      label: '\u5BA2\u6237\u8BE6\u60C5',\n      description: '\u63D2\u69FD\u5F0F\u5BA2\u6237\u8BB0\u5F55\u9875\u2014\u2014\u81EA\u5B9A\u4E49\u9875\u5934 + \u5E38\u9A7B\u8BA8\u8BBA\u533A\u3002',\n      title: '{name}',\n      subtitle: '{industry} \u00B7 {type}',\n      components: {\n        account_chatter: { label: '\u8BA8\u8BBA' },\n      },\n    },\n    account_workbench: {\n      label: '\u5BA2\u6237\u5DE5\u4F5C\u53F0',\n      description: '\u9762\u5411\u9500\u552E\u56E2\u961F\u7684\u7CBE\u9009\u5BA2\u6237\u5217\u8868\uFF1A\u4EC5\u63D0\u4F9B\u5FEB\u6377\u7B5B\u9009\uFF0C\u4E0D\u542B\u89C6\u56FE\u7BA1\u7406\u3002',\n    },\n    app_launcher_page: {\n      label: '\u5E94\u7528\u4E2D\u5FC3',\n      description: '\u8BBF\u95EE\u5168\u90E8\u5E94\u7528\u7684\u7EDF\u4E00\u5165\u53E3',\n      subtitle: '\u9009\u62E9\u4E00\u4E2A\u5E94\u7528\u5F00\u59CB\u4F7F\u7528',\n      components: {\n        app_search: { label: '\u641C\u7D22\u5E94\u7528' },\n        app_grid: { label: '\u5E94\u7528\u7F51\u683C' },\n      },\n    },\n    case_detail_page: {\n      label: '\u5DE5\u5355\u8BE6\u60C5',\n      description: '\u5BA2\u670D\u5DE5\u5355\u8BB0\u5F55\u9875\uFF1A\u5173\u952E\u4FE1\u606F\u3001SLA \u8FDB\u5EA6\u3001\u660E\u7EC6\u4E0E\u6D3B\u52A8\u65F6\u95F4\u7EBF\u3002',\n      title: '{case_number} \u00B7 {subject}',\n      subtitle: '{crm_account}',\n      components: {\n        case_highlights: { label: '\u5173\u952E\u4FE1\u606F' },\n        case_status_path: { label: '\u5DE5\u5355\u72B6\u6001\u8FDB\u5EA6' },\n        case_details: { label: '\u5DE5\u5355\u660E\u7EC6' },\n      },\n    },\n    lead_detail_page: {\n      label: '\u7EBF\u7D22\u8BE6\u60C5',\n      description: '\u5B8C\u6574\u7684\u7EBF\u7D22\u8BE6\u60C5\u9875\uFF0C\u5305\u542B\u5173\u952E\u4FE1\u606F\u3001\u660E\u7EC6\u4E0E\u76F8\u5173\u8BB0\u5F55\u3002',\n      title: '{first_name} {last_name}',\n      subtitle: '{company}',\n      components: {\n        lead_duplicate_alert_confirmed: { label: '\u5DF2\u786E\u8BA4\u91CD\u590D\u63D0\u9192' },\n        lead_duplicate_alert_suspected: { label: '\u7591\u4F3C\u91CD\u590D\u63D0\u9192' },\n        lead_highlights: { label: '\u5173\u952E\u4FE1\u606F' },\n        lead_path: { label: '\u7EBF\u7D22\u72B6\u6001\u8FDB\u5EA6' },\n        main_tabs: { label: '\u7EBF\u7D22\u4FE1\u606F\u6807\u7B7E\u9875' },\n        lead_details: { label: '\u7EBF\u7D22\u660E\u7EC6' },\n        related_accordion: { label: '\u76F8\u5173\u8BB0\u5F55' },\n        related_tasks: { title: '\u5F85\u529E\u4EFB\u52A1', label: '\u4EFB\u52A1' },\n        lead_activity: { label: '\u6D3B\u52A8\u65F6\u95F4\u7EBF' },\n        lead_history: { label: '\u5B57\u6BB5\u5386\u53F2' },\n      },\n    },\n    opportunity_detail_page: {\n      label: '\u5546\u673A\u8BE6\u60C5',\n      description: '\u5B8C\u6574\u7684\u5546\u673A\u8BE6\u60C5\u9875\uFF0C\u5305\u542B\u9636\u6BB5\u8FDB\u5EA6\u3001\u5173\u952E\u4FE1\u606F\u3001\u660E\u7EC6\u4E0E\u76F8\u5173\u5217\u8868\u3002',\n      title: '{name}',\n      subtitle: '{crm_account}',\n      components: {\n        opp_highlights: { label: '\u5173\u952E\u4FE1\u606F' },\n        opp_stage_path: { label: '\u5546\u673A\u9636\u6BB5\u8FDB\u5EA6' },\n        opp_details: { label: '\u5546\u673A\u660E\u7EC6' },\n      },\n    },\n    sales_home_page: {\n      label: '\u9500\u552E\u4E3B\u9875',\n      description: '\u9500\u552E\u56E2\u961F\u4E3B\u9875\uFF0C\u6C47\u603B\u5173\u952E\u6307\u6807\u4E0E\u5FEB\u6377\u64CD\u4F5C',\n      title: '\u9500\u552E\u770B\u677F',\n      subtitle: '\u6B22\u8FCE\u56DE\u6765',\n      components: {\n        kpi_revenue_won: {\n          label: '\u8D62\u5355\u8425\u6536',\n        },\n        kpi_deals_won: {\n          label: '\u8D62\u5355\u6570',\n        },\n        kpi_pipeline_value: {\n          label: '\u9500\u552E\u7BA1\u9053\u91D1\u989D',\n        },\n        kpi_open_leads: {\n          label: '\u5F00\u653E\u7EBF\u7D22',\n        },\n        home_upcoming_events: {\n          label: '\uD83D\uDCC5 \u5373\u5C06\u5F00\u59CB \u00B7 \u6700\u8FD1\u4F18\u5148',\n        },\n        quick_create: { title: '\u5FEB\u901F\u521B\u5EFA', label: '\u5FEB\u901F\u521B\u5EFA' },\n        key_metrics: { title: '\u5173\u952E\u7EE9\u6548\u6307\u6807', label: '\u5173\u952E\u6307\u6807' },\n        home_tabs: { label: '\u4E3B\u9875\u6807\u7B7E\u9875' },\n        home_my_leads: { label: '\u6211\u7684\u7EBF\u7D22' },\n        home_my_deals: { label: '\u6211\u7684\u8FDB\u884C\u4E2D\u5546\u673A' },\n        home_my_tasks: { label: '\u6211\u7684\u5F85\u529E\u4EFB\u52A1' },\n        ai_briefing: {\n          title: '\u8BE2\u95EE AI \u52A9\u624B',\n          label: 'AI \u52A9\u624B\u4ECA\u65E5\u901F\u89C8',\n        },\n        upcoming_events: { title: '\u5373\u5C06\u5F00\u59CB\u7684\u6D3B\u52A8', label: '\u5373\u5C06\u5F00\u59CB\u7684\u6D3B\u52A8' },\n      },\n    },\n    utility_bar_page: {\n      label: '\u5DE5\u5177\u680F',\n      description: '\u60AC\u6D6E\u5DE5\u5177\u7684\u5FEB\u6377\u8BBF\u95EE\u680F',\n      components: {\n        notifications_panel: { label: '\u901A\u77E5' },\n        quick_notes: { title: '\u5FEB\u901F\u7B14\u8BB0', label: '\u5FEB\u901F\u7B14\u8BB0' },\n        quick_search: { label: '\u5FEB\u901F\u641C\u7D22' },\n      },\n    },\n  },\n  // Screen-flow copy (#1210, #1975). Keyed `flows.<flow>.label`,\n  // `screens.<node>.title` and `screens.<node>.fields.<field>.{label,placeholder}`\n  // \u2014 the keys `os lint`'s `i18n/missing-flow` names, read by the console's\n  // flow runner since @objectstack 17.7.0 (the spec's `flows` liveness row is\n  // `live` there). A screen with no authored `title` shows its flow's label in\n  // every locale, so each `screen_1.title` repeats the flow label. Since\n  // 18.0.0-next.0 three more surfaces are keys the engine reads in the run's\n  // locale, and `i18n/missing-flow` names each missing one: a select field's\n  // `options.<value>` (worded as the object field's own option in this pack),\n  // an authored screen `description`, and a refusing `end` node's\n  // `refusals.<node>.message`. A translated description or message is a text\n  // slot like the one it translates, so a hole in it is `{{ }}`.\n  // The discount ceiling is interpolated from `QUOTE_DISCOUNT_CEILING`, never\n  // retyped: the number lives in `_thresholds.ts` alone (#1711).\n  flows: {\n    campaign_enrollment: {\n      label: '\u5C06\u6210\u5458\u52A0\u5165\u8425\u9500\u6D3B\u52A8',\n      screens: {\n        screen_1: {\n          title: '\u5C06\u6210\u5458\u52A0\u5165\u8425\u9500\u6D3B\u52A8',\n          fields: {\n            memberSource: { label: '\u52A0\u5165\u7684\u6210\u5458\u7C7B\u578B', options: { leads: '\u7EBF\u7D22', contacts: '\u8054\u7CFB\u4EBA' } },\n            leadStatus: { label: '\u52A0\u5165\u4EE5\u4E0B\u72B6\u6001\u7684\u7EBF\u7D22', options: { new: '\u65B0\u5EFA', contacted: '\u5DF2\u8054\u7CFB', qualified: '\u5DF2\u786E\u8BA4' } },\n            contactDepartment: {\n              label: '\u52A0\u5165\u4EE5\u4E0B\u90E8\u95E8\u7684\u8054\u7CFB\u4EBA',\n              options: { executive: '\u7BA1\u7406\u5C42', sales: '\u9500\u552E\u90E8', marketing: '\u5E02\u573A\u90E8', engineering: '\u5DE5\u7A0B\u90E8', support: '\u652F\u6301\u90E8', finance: '\u8D22\u52A1\u90E8', hr: '\u4EBA\u529B\u8D44\u6E90', operations: '\u8FD0\u8425\u90E8' },\n            },\n          },\n        },\n      },\n    },\n    escalate_case: {\n      label: '\u5347\u7EA7\u5DE5\u5355',\n      screens: { screen_1: { title: '\u5347\u7EA7\u5DE5\u5355', fields: { reason: { label: '\u5347\u7EA7\u539F\u56E0' } } } },\n    },\n    close_case: {\n      label: '\u5173\u95ED\u5DE5\u5355',\n      screens: {\n        screen_1: {\n          title: '\u5173\u95ED\u5DE5\u5355',\n          fields: {\n            resolution: { label: '\u89E3\u51B3\u65B9\u6848' },\n            resolved_by_article: { label: '\u901A\u8FC7\u77E5\u8BC6\u6587\u7AE0\u89E3\u51B3\uFF08\u53EF\u9009\uFF09' },\n          },\n        },\n      },\n    },\n    claim_case: {\n      label: '\u8BA4\u9886\u5DE5\u5355',\n      screens: {\n        screen_1: {\n          title: '\u8BA4\u9886\u5DE5\u5355',\n          fields: {\n            claimStatus: {\n              label: '\u5904\u7406\u72B6\u6001',\n              options: { in_progress: '\u5904\u7406\u4E2D', waiting_customer: '\u7B49\u5F85\u5BA2\u6237\u56DE\u590D', waiting_support: '\u7B49\u5F85\u652F\u6301\u56DE\u590D' },\n            },\n          },\n        },\n      },\n    },\n    lead_conversion: {\n      label: '\u7EBF\u7D22\u8F6C\u5316\u6D41\u7A0B',\n      screens: {\n        screen_1: {\n          title: '\u7EBF\u7D22\u8F6C\u5316\u6D41\u7A0B',\n          // The duplicate warning's text is a variable the flow assigns; this\n          // key can only carry the hole that shows it.\n          description: '{{duplicateWarning}}',\n          fields: {\n            createOpportunity: { label: '\u662F\u5426\u521B\u5EFA\u5546\u673A\uFF1F' },\n            opportunityName: { label: '\u5546\u673A\u540D\u79F0' },\n            opportunityAmount: { label: '\u5546\u673A\u91D1\u989D' },\n            closeDate: { label: '\u9884\u8BA1\u6210\u4EA4\u65E5\u671F' },\n          },\n        },\n        refuse_confirmed_duplicate: {\n          title: '\u8F6C\u5316\u88AB\u62D2\u7EDD',\n          description:\n            '\u8BE5\u7EBF\u7D22\u7684\u300C\u91CD\u590D\u72B6\u6001\u300D\u4E3A\u300C\u5DF2\u786E\u8BA4\u91CD\u590D\u300D\uFF1A\u5BA1\u6838\u4EBA\u5DF2\u5C06\u5176\u4E0E\u73B0\u6709\u8BB0\u5F55\u6BD4\u5BF9\uFF0C\u5E76\u8BB0\u5F55\u4E3A\u91CD\u590D\u3002\u8F6C\u5316\u4F1A\u4E3A\u540C\u4E00\u4E70\u5BB6\u518D\u521B\u5EFA\u4E00\u4E2A\u5BA2\u6237\u3001\u8054\u7CFB\u4EBA\u548C\u5546\u673A\u3002\u672C\u7EBF\u7D22\u7684\u300C\u91CD\u590D\u7EBF\u7D22\u7BA1\u7406\u300D\u90E8\u5206\u5217\u51FA\u4E86\u4FDD\u7559\u7684\u8BB0\u5F55\uFF1B\u8BF7\u6539\u4E3A\u4EE5\u91CD\u590D\u4E3A\u7531\u5C06\u6B64\u7EBF\u7D22\u8BBE\u4E3A\u300C\u672A\u901A\u8FC7\u300D\u3002\u53EA\u6709\u5BA1\u6838\u4EBA\u4FEE\u6539\u8BE5\u7ED3\u8BBA\u540E\u624D\u80FD\u91CD\u65B0\u8F6C\u5316\u3002',\n        },\n        refuse_unapproved: {\n          title: '\u8F6C\u5316\u88AB\u62D2\u7EDD',\n          description:\n            '\u8BE5\u7EBF\u7D22\u5C1A\u672A\u83B7\u51C6\u8F6C\u5316\u3002\u5FC5\u987B\u7531\u5BA1\u6279\u4EBA\u6279\u51C6\u540E\uFF0C\u624D\u80FD\u8F6C\u5316\u4E3A\u5BA2\u6237\u3001\u8054\u7CFB\u4EBA\u548C\u5546\u673A\uFF1B\u7EBF\u7D22\u4E0A\u7684\u300C\u8F6C\u5316\u5BA1\u6279\u300D\u5B57\u6BB5\u663E\u793A\u8BE5\u51B3\u5B9A\u4ECD\u5728\u5F85\u5BA1\u6279\u8FD8\u662F\u5DF2\u88AB\u9A73\u56DE\u3002\u5728\u6B64\u671F\u95F4\u8BF7\u7EE7\u7EED\u8DDF\u8FDB\u8BE5\u7EBF\u7D22\u2014\u2014\u5B83\u7684\u4EFB\u4F55\u5185\u5BB9\u90FD\u6CA1\u6709\u88AB\u51BB\u7ED3\u3002',\n        },\n        refuse_no_match_key: {\n          title: '\u8F6C\u5316\u88AB\u62D2\u7EDD',\n          description:\n            '\u8BE5\u7EBF\u7D22\u7684\u516C\u53F8\u6CA1\u6709\u5339\u914D\u952E\uFF0C\u56E0\u6B64\u8F6C\u5316\u65E0\u6CD5\u5224\u65AD\u5B83\u5C5E\u4E8E\u54EA\u4E2A\u5BA2\u6237\uFF0C\u4E5F\u4E0D\u4F1A\u53BB\u731C\u6D4B\uFF1A\u731C\u6D4B\u53EF\u80FD\u4F1A\u628A\u8054\u7CFB\u4EBA\u548C\u5546\u673A\u5F52\u5230\u53E6\u4E00\u4E2A\u5BA2\u6237\u540D\u4E0B\u3002\u4FDD\u5B58\u7EBF\u7D22\u7684\u300C\u516C\u53F8\u300D\u4F1A\u91CD\u65B0\u751F\u6210\u5339\u914D\u952E\uFF0C\u8BF7\u91CD\u65B0\u4FDD\u5B58\u540E\u518D\u8F6C\u5316\u3002\u5C1A\u672A\u521B\u5EFA\u4EFB\u4F55\u8BB0\u5F55\u3002',\n        },\n      },\n    },\n    schedule_followup: {\n      label: '\u5B89\u6392\u8DDF\u8FDB',\n      screens: {\n        screen_1: {\n          title: '\u5B89\u6392\u8DDF\u8FDB',\n          fields: {\n            subject: { label: '\u4E0B\u4E00\u6B65\u505A\u4EC0\u4E48\uFF1F' },\n            dueDate: { label: '\u622A\u6B62\u65E5\u671F' },\n            activityType: {\n              label: '\u6D3B\u52A8\u7C7B\u578B',\n              options: { call: '\u7535\u8BDD', email: '\u90AE\u4EF6', meeting: '\u4F1A\u8BAE', follow_up: '\u8DDF\u8FDB', demo: '\u6F14\u793A', other: '\u5176\u4ED6' },\n            },\n            priority: { label: '\u4F18\u5148\u7EA7', options: { low: '\u4F4E', normal: '\u666E\u901A', high: '\u9AD8', urgent: '\u7D27\u6025' } },\n            notes: { label: '\u5907\u6CE8' },\n          },\n        },\n      },\n    },\n    quote_generation: {\n      label: '\u4ECE\u5546\u673A\u751F\u6210\u62A5\u4EF7\u5355',\n      refusals: { refuse_held: { message: '\u9700\u5148\u5B8C\u6210\u7ACB\u9879\u5BA1\u6279\uFF1A\u8BF7\u52FE\u9009\u300C\u7533\u8BF7\u7ACB\u9879\u5BA1\u6279\u300D\u3002\u5C1A\u672A\u521B\u5EFA\u4EFB\u4F55\u5185\u5BB9\u3002' } },\n      screens: {\n        screen_1: {\n          title: '\u4ECE\u5546\u673A\u751F\u6210\u62A5\u4EF7\u5355',\n          fields: {\n            quoteName: { label: '\u62A5\u4EF7\u540D\u79F0' },\n            expirationDays: { label: '\u6709\u6548\u671F\uFF08\u5929\uFF09' },\n            discount: { label: `\u6298\u6263 % (\u2264 ${QUOTE_DISCOUNT_CEILING})`, placeholder: `0-${QUOTE_DISCOUNT_CEILING}` },\n          },\n        },\n      },\n    },\n  },\n};\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/sales/translations/zh-CN/_shared.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/sales/translations/zh-CN\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/sales/translations/zh-CN/_shared.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\n/**\n * \u7B80\u4F53\u4E2D\u6587 (zh-CN) \u2014 values shared by more than one part of this bundle.\n *\n * SPLIT AXIS (#1311): translation NAMESPACE first, then CRM DOMAIN FAMILY.\n * Everything that is not `objects` lives in `./app.ts`; `objects` \u2014 69-78% of\n * every bundle \u2014 is one file per CRM domain family, and a detail object\n * follows its master. A new row goes in the file for ITS family, never in\n * whichever file is already open: that is how one file re-grows past the 70%\n * advisory band `pnpm hygiene` prints. Full rule and rationale:\n * `src/sales/translations/zh-CN.ts`.\n *\n * Every constant here is spread into object rows that live in MORE THAN ONE\n * family file, so it cannot sit in any one of them. A value used by exactly\n * one family lives in that family's file instead \u2014 that split is mechanical,\n * not a judgement call.\n */\n\n/**\n * \u6D3B\u52A8\u52A8\u4F5C\u65CF\uFF08#592\uFF09\uFF1A`log_call` / `log_meeting` / `schedule_meeting` \u5728\n * \u7EBF\u7D22\u3001\u8054\u7CFB\u4EBA\u3001\u5BA2\u6237\u3001\u5546\u673A\u3001\u5DE5\u5355\u4E0A\u5404\u6CE8\u518C\u4E00\u6B21\uFF08\u65E0 `objectName` \u7684\u811A\u672C\u52A8\u4F5C\u4F1A\u843D\u5230\n * \u8C03\u5EA6\u5668\u4ECE\u4E0D\u63A2\u6D4B\u7684\u952E\u4E0A\u2014\u2014\u89C1 #509\uFF09\u3002\u4E94\u4E2A\u5BF9\u8C61\u7684\u6587\u6848\u5B8C\u5168\u76F8\u540C\uFF0C\u56E0\u6B64\u5728\u6B64\u58F0\u660E\u4E00\u6B21\u5E76\n * \u5C55\u5F00\u5230\u5404\u5BF9\u8C61\u7684 `_actions`\uFF1A\u6BCF\u4E2A\u8BED\u8A00\u624B\u6284\u5341\u4E94\u4EFD\u6B63\u662F\u8BD1\u6587\u8D70\u6837\u7684\u5F00\u7AEF\u3002\n */\nexport const activityActions = {\n  log_call: {\n    label: '\u8BB0\u5F55\u901A\u8BDD',\n    successMessage: '\u901A\u8BDD\u8BB0\u5F55\u6210\u529F\uFF01',\n    params: {\n      subject: { label: '\u901A\u8BDD\u4E3B\u9898' },\n      duration: { label: '\u65F6\u957F\uFF08\u5206\u949F\uFF09' },\n      attendee_contacts: { label: '\u8054\u7CFB\u4EBA\u53C2\u4E0E\u8005' },\n      attendee_users: { label: '\u5185\u90E8\u53C2\u4E0E\u8005' },\n      notes: { label: '\u901A\u8BDD\u8BB0\u5F55' },\n    },\n  },\n  log_meeting: {\n    label: '\u8BB0\u5F55\u4F1A\u8BAE',\n    successMessage: '\u4F1A\u8BAE\u8BB0\u5F55\u6210\u529F\uFF01',\n    params: {\n      subject: { label: '\u4F1A\u8BAE\u4E3B\u9898' },\n      duration: { label: '\u65F6\u957F\uFF08\u5206\u949F\uFF09' },\n      attendee_contacts: { label: '\u8054\u7CFB\u4EBA\u53C2\u4F1A\u4EBA' },\n      attendee_users: { label: '\u5185\u90E8\u53C2\u4F1A\u4EBA' },\n      notes: { label: '\u4F1A\u8BAE\u7EAA\u8981' },\n    },\n  },\n  schedule_meeting: {\n    label: '\u5B89\u6392\u4F1A\u8BAE',\n    successMessage: '\u4F1A\u8BAE\u5DF2\u5B89\u6392\uFF01',\n    params: {\n      subject: { label: '\u4F1A\u8BAE\u4E3B\u9898' },\n      start_date: { label: '\u5F00\u59CB\u65E5\u671F\uFF08UTC\uFF09' },\n      start_time: { label: '\u5F00\u59CB\u65F6\u95F4\uFF08UTC\uFF09' },\n      location: { label: '\u5730\u70B9' },\n      duration: { label: '\u65F6\u957F\uFF08\u5206\u949F\uFF09' },\n      attendee_contacts: { label: '\u8054\u7CFB\u4EBA\u53C2\u4F1A\u4EBA' },\n      attendee_users: { label: '\u5185\u90E8\u53C2\u4F1A\u4EBA' },\n      notes: { label: '\u4F1A\u8BAE\u8BAE\u7A0B' },\n    },\n  },\n};\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/sales/translations/zh-CN/objects.customer.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/sales/translations/zh-CN\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/sales/translations/zh-CN/objects.customer.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport type { ObjectTranslationData } from '@objectstack/spec/system';\n\nimport { activityActions } from './_shared';\n\n/**\n * \u7B80\u4F53\u4E2D\u6587 (zh-CN) \u2014 `objects` translations for the CUSTOMER family:\n * the customer record itself \u2014 accounts and the people at them.\n *\n * Roster: `crm_account`, `crm_contact`.\n *\n * SPLIT AXIS (#1311): translation NAMESPACE first, then CRM DOMAIN FAMILY.\n * Everything that is not `objects` lives in `./app.ts`; `objects` \u2014 69-78% of\n * every bundle \u2014 is one file per CRM domain family, and a detail object\n * follows its master. A new row goes in the file for ITS family, never in\n * whichever file is already open: that is how one file re-grows past the 70%\n * advisory band `pnpm hygiene` prints. Full rule and rationale:\n * `src/sales/translations/zh-CN.ts`.\n */\nexport const customer: Record<string, ObjectTranslationData> = {\n  crm_account: {\n    label: '\u5BA2\u6237',\n    pluralLabel: '\u5BA2\u6237',\n    description: '\u4E0E\u6211\u4EEC\u6709\u4E1A\u52A1\u5F80\u6765\u7684\u516C\u53F8\u548C\u7EC4\u7EC7',\n    fields: {\n      account_number: { label: '\u5BA2\u6237\u7F16\u53F7' },\n      registration_number: {\n        label: '\u767B\u8BB0\u8BC1\u4EF6\u53F7',\n        help: '\u5BF9\u65B9\u5728\u5176\u6240\u5C5E\u653F\u5E9C\u767B\u8BB0\u673A\u5173\u53D6\u5F97\u7684\u767B\u8BB0\u6807\u8BC6\u3002\u4E0D\u540C\u4E8E\u7531\u6211\u65B9\u53D1\u653E\u7684\u5BA2\u6237\u7F16\u53F7\u3002',\n      },\n      commercial_capability: {\n        label: '\u5546\u52A1\u80FD\u529B',\n        help: '\u8BE5\u5BA2\u6237\u662F\u5426\u53EF\u4EE5\u627F\u63A5\u65B0\u4E1A\u52A1\u3002\u4EC5\u7ED3\u7B97\u7C7B\u5BA2\u6237\u4F9D\u7136\u53EF\u7528\u4E8E\u5F00\u7968\u4E0E\u6536\u4ED8\u6B3E\uFF0C\u4F46\u4E0D\u80FD\u5173\u8054\u65B0\u7684\u5546\u673A\u3002',\n        options: { full: '\u5B8C\u6574', settlement_only: '\u4EC5\u7ED3\u7B97' },\n      },\n      incumbent_vendor: { label: '\u73B0\u6709\u4F9B\u5E94\u5546', help: '\u5F53\u524D\u627F\u63A5\u8BE5\u5BA2\u6237\u8FD9\u90E8\u5206\u652F\u51FA\u7684\u4F9B\u5E94\u5546\u3002' },\n      annual_purchasing_budget: { label: '\u5E74\u5EA6\u91C7\u8D2D\u9884\u7B97', help: '\u8BE5\u5BA2\u6237\u672C\u5E74\u5EA6\u9884\u8BA1\u5411\u4F9B\u5E94\u5546\u652F\u51FA\u7684\u91D1\u989D\uFF0C\u800C\u975E\u5176\u81EA\u8EAB\u8425\u6536\u3002' },\n      payment_cycle: {\n        label: '\u4ED8\u6B3E\u5468\u671F',\n        options: { prepaid: '\u9884\u4ED8', net_30: '30 \u5929', net_60: '60 \u5929', net_90: '90 \u5929' },\n      },\n      approval_status: {\n        label: '\u5BA1\u6279\u72B6\u6001',\n        help: '\u8BE5\u5BA2\u6237\u7684\u5BA1\u6279\u8FDB\u5C55\u3002\u65B0\u5EFA\u5BA2\u6237\u521D\u59CB\u4E3A\u5F85\u5BA1\u6279\uFF0C\u5E76\u5728\u5BA1\u6279\u6536\u4EF6\u7BB1\u4E2D\u88C1\u5B9A\u3002',\n        options: { pending: '\u5F85\u5BA1\u6279', approved: '\u5DF2\u901A\u8FC7', rejected: '\u5DF2\u9A73\u56DE' },\n      },\n      name: { label: '\u5BA2\u6237\u540D\u79F0', help: '\u516C\u53F8\u6216\u7EC4\u7EC7\u7684\u6CD5\u5B9A\u540D\u79F0' },\n      type: {\n        label: '\u7C7B\u578B',\n        options: { prospect: '\u6F5C\u5728\u5BA2\u6237', customer: '\u6B63\u5F0F\u5BA2\u6237', partner: '\u5408\u4F5C\u4F19\u4F34', former: '\u524D\u5BA2\u6237' },\n      },\n      industry: {\n        label: '\u884C\u4E1A',\n        options: {\n          technology: '\u79D1\u6280', software: '\u8F6F\u4EF6 / SaaS', finance: '\u91D1\u878D',\n          healthcare: '\u533B\u7597', retail: '\u96F6\u552E', manufacturing: '\u5236\u9020',\n          education: '\u6559\u80B2', real_estate: '\u623F\u5730\u4EA7', media: '\u4F20\u5A92\u5A31\u4E50',\n          logistics: '\u7269\u6D41', hospitality: '\u9152\u5E97\u65C5\u6E38', energy: '\u80FD\u6E90\u516C\u7528\u4E8B\u4E1A',\n          government: '\u653F\u5E9C', nonprofit: '\u975E\u8425\u5229', other: '\u5176\u4ED6',\n        },\n      },\n      annual_revenue: { label: '\u5E74\u8425\u6536' },\n      child_account_revenue: { label: '\u5B50\u516C\u53F8\u5E74\u8425\u6536\u5408\u8BA1', help: '\u672C\u5BA2\u6237\u76F4\u5C5E\u5B50\u516C\u53F8\u7684\u5E74\u8425\u6536\u5408\u8BA1\u3002' },\n      number_of_employees: { label: '\u5458\u5DE5\u4EBA\u6570' },\n      phone: { label: '\u7535\u8BDD' },\n      website: { label: '\u7F51\u7AD9' },\n      billing_address: { label: '\u8D26\u5355\u5730\u5740' },\n      billing_country: {\n        label: '\u8D26\u5355\u56FD\u5BB6',\n        help: '\u7531\u8D26\u5355\u5730\u5740\u63A8\u5BFC\u2014\u2014\u6309\u5F55\u5165\u539F\u6837\u53BB\u9664\u9996\u5C3E\u7A7A\u683C\u5E76\u8F6C\u4E3A\u5927\u5199\u3002',\n      },\n      territory: {\n        label: '\u9500\u552E\u533A\u57DF',\n        help: '\u7531\u8D26\u5355\u5730\u5740\u63A8\u5BFC\u2014\u2014\u533A\u57DF\u5171\u4EAB\u89C4\u5219\u636E\u6B64\u5339\u914D\u3002\u4E0D\u5C5E\u4E8E\u5DF2\u914D\u7F6E\u533A\u57DF\u7684\u5BA2\u6237\u4E3A\u201C\u5176\u4ED6\u201D\u3002',\n        options: { na: '\u5317\u7F8E', emea: '\u6B27\u6D32\u3001\u4E2D\u4E1C\u4E0E\u975E\u6D32', other: '\u5176\u4ED6' },\n      },\n      office_location: { label: '\u529E\u516C\u5730\u70B9' },\n      owner_id: { label: '\u5BA2\u6237\u8D1F\u8D23\u4EBA' },\n      parent_account: { label: '\u6BCD\u516C\u53F8', help: '\u5C42\u7EA7\u7ED3\u6784\u4E2D\u7684\u6BCD\u516C\u53F8' },\n      description: { label: '\u63CF\u8FF0' },\n      is_active: { label: '\u662F\u5426\u6D3B\u8DC3' },\n      last_activity_date: { label: '\u6700\u8FD1\u6D3B\u52A8\u65E5\u671F' },\n      brand_color: { label: '\u54C1\u724C\u8272' },\n      logo: { label: '\u516C\u53F8\u6807\u8BC6' },\n      tier: {\n        label: '\u5BA2\u6237\u5206\u5C42',\n        options: { strategic: '\u6218\u7565\u5BA2\u6237', enterprise: '\u4F01\u4E1A\u5BA2\u6237', mid_market: '\u4E2D\u578B\u5BA2\u6237', smb: '\u4E2D\u5C0F\u5BA2\u6237' },\n      },\n      segment: {\n        label: '\u5BA2\u6237\u7EC6\u5206',\n        options: { net_new: '\u5168\u65B0\u5BA2\u6237', growth: '\u589E\u957F\u5BA2\u6237', at_risk: '\u98CE\u9669\u5BA2\u6237', stable: '\u7A33\u5B9A\u5BA2\u6237' },\n      },\n      health_score: {\n        label: '\u5065\u5EB7\u5EA6',\n        help: '\u5BA2\u6237\u6210\u529F\u7ECF\u7406\u7EF4\u62A4\u7684\u5065\u5EB7\u5EA6\u6307\u6807',\n        options: { healthy: '\u5065\u5EB7', watching: '\u5173\u6CE8', at_risk: '\u98CE\u9669', churning: '\u6D41\u5931\u4E2D' },\n      },\n      name_normalized: { label: '\u5BA2\u6237\u540D\u79F0\uFF08\u89C4\u8303\u5316\uFF09', help: '\u7EBF\u7D22\u8F6C\u5316\u7684\u5339\u914D\u952E\uFF1A\u5BA2\u6237\u540D\u79F0\u8F6C\u5C0F\u5199\u3001\u53BB\u9664\u9996\u5C3E\u7A7A\u683C\u3001\u5185\u90E8\u8FDE\u7EED\u7A7A\u767D\u5408\u5E76\u4E3A\u4E00\u4E2A\u7A7A\u683C\u3002\u7531 account_protection \u94A9\u5B50\u7EF4\u62A4\u2014\u2014\u8BF7\u52FF\u76F4\u63A5\u7F16\u8F91\u3002' },\n      display_title: { label: '\u663E\u793A\u540D\u79F0' },\n    },\n    _views: {\n      all_accounts: {\n        label: '\u5168\u90E8\u5BA2\u6237', description: '\u5BA2\u6237\u4E3B\u5217\u8868\uFF0C\u5305\u542B\u8425\u6536\u4E0E\u884C\u4E1A\u6458\u8981',\n        bulkActions: {\n          delete: {\n            label: '\u5220\u9664',\n            confirmLabel: '\u5220\u9664',\n            confirmText: '\u786E\u5B9A\u8981\u6C38\u4E45\u5220\u9664 {{count}} \u4E2A\u5BA2\u6237\u5417\uFF1F\u6B64\u64CD\u4F5C\u65E0\u6CD5\u64A4\u9500\u3002',\n          },\n          transfer_owner: {\n            label: '\u8F6C\u79FB\u8D1F\u8D23\u4EBA',\n            confirmText: '\u786E\u5B9A\u8981\u8F6C\u79FB {{count}} \u4E2A\u5BA2\u6237\u7684\u8D1F\u8D23\u4EBA\u5417\uFF1F',\n            params: {\n              owner_id: {\n                label: '\u65B0\u8D1F\u8D23\u4EBA',\n              },\n            },\n          },\n          update_tier: {\n            label: '\u66F4\u65B0\u5BA2\u6237\u7B49\u7EA7',\n            confirmText: '\u786E\u5B9A\u8981\u5C06 {{count}} \u4E2A\u5BA2\u6237\u7684\u7B49\u7EA7\u66F4\u65B0\u4E3A {{tier}} \u5417\uFF1F',\n            params: {\n              tier: {\n                label: '\u5BA2\u6237\u7B49\u7EA7',\n              },\n            },\n          },\n        },\n      },\n      account_gallery: { label: '\u5BA2\u6237\u5361\u7247', description: '\u4F7F\u7528\u54C1\u724C\u8272\u9AD8\u4EAE\u7684\u5BA2\u6237\u5361\u7247\u89C6\u56FE' },\n      account_map: { label: '\u5BA2\u6237\u5730\u56FE', description: '\u5BA2\u6237\u7684\u5730\u7406\u5206\u5E03' },\n      enterprise_accounts: { label: '\u4F01\u4E1A\u5BA2\u6237', description: '\u5E74\u8425\u6536\u6700\u9AD8\u7684\u5927\u5BA2\u6237' },\n      my_accounts: { label: '\u6211\u7684\u5BA2\u6237', description: '\u7531\u5F53\u524D\u7528\u6237\u8D1F\u8D23\u7684\u5BA2\u6237' },\n      at_risk_accounts: { label: '\u26A0\uFE0F \u98CE\u9669\u5BA2\u6237' },\n    },\n    _sections: {\n      basic: { label: '\u57FA\u672C\u4FE1\u606F' },\n      financials: { label: '\u8D22\u52A1\u4FE1\u606F' },\n      business_profile: { label: '\u4E1A\u52A1\u4FE1\u606F' },\n      contact_info: { label: '\u8054\u7CFB\u4FE1\u606F' },\n      ownership: { label: '\u5F52\u5C5E\u4E0E\u72B6\u6001' },\n      branding: { label: '\u54C1\u724C' },\n      system: { label: '\u7CFB\u7EDF' },\n      // account.view.ts \u8868\u5355\u533A\u5757\u540D\u79F0 (#1100)\n      profile: { label: '\u8D44\u6599' },\n      customer_success: { label: '\u5BA2\u6237\u6210\u529F' },\n      locations: { label: '\u5730\u5740\u4FE1\u606F' },\n      description: { label: '\u63CF\u8FF0' },\n    },\n    _actions: { ...activityActions },\n  },\n  crm_contact: {\n    label: '\u8054\u7CFB\u4EBA',\n    pluralLabel: '\u8054\u7CFB\u4EBA',\n    description: '\u5BA2\u6237\u4E0E\u5546\u673A\u7684\u5173\u952E\u4EBA\u7269\u8054\u7CFB\u4EBA',\n    fields: {\n      salutation: {\n        label: '\u79F0\u8C13',\n        options: { mr: '\u5148\u751F', ms: '\u5973\u58EB', mrs: '\u592B\u4EBA', dr: '\u535A\u58EB', prof: '\u6559\u6388' },\n      },\n      first_name: { label: '\u540D' },\n      last_name: { label: '\u59D3' },\n      full_name: { label: '\u5168\u540D' },\n      crm_account: { label: '\u6240\u5C5E\u5BA2\u6237' },\n      email: { label: '\u90AE\u7BB1' },\n      phone: { label: '\u7535\u8BDD' },\n      mobile: { label: '\u624B\u673A' },\n      title: { label: '\u804C\u4F4D' },\n      department: {\n        label: '\u90E8\u95E8',\n        options: {\n          executive: '\u7BA1\u7406\u5C42', sales: '\u9500\u552E\u90E8', marketing: '\u5E02\u573A\u90E8',\n          engineering: '\u5DE5\u7A0B\u90E8', support: '\u652F\u6301\u90E8', finance: '\u8D22\u52A1\u90E8',\n          hr: '\u4EBA\u529B\u8D44\u6E90', operations: '\u8FD0\u8425\u90E8',\n        },\n      },\n      // \u91C7\u8D2D\u51B3\u7B56\u5708 (REQ-0004)\u3002\u82F1\u6587\u6807\u7B7E\u662F 'Buying Function' \u800C\u975E 'Buying Role'\uFF1A\n      // \u5E73\u53F0\u7684 security-role-word \u89C4\u5219\u5728\u5BF9\u8C61\u58F0\u660E\u4E0A\u4FDD\u7559\u4E86\u82F1\u6587 role \u4E00\u8BCD\uFF08ADR-0090 D3\uFF09\u3002\n      // \u8BE5\u89C4\u5219\u53EA\u5339\u914D\u82F1\u6587\uFF0C\u4E0D\u8BFB\u8BED\u8A00\u5305\uFF0C\u6240\u4EE5\u4E2D\u6587\u8FD9\u91CC\u7528\u672C\u5730\u8BFB\u8005\u771F\u6B63\u5728\u8BF4\u7684\u8BCD\u3002\n      buying_function: {\n        label: '\u91C7\u8D2D\u89D2\u8272',\n        options: {\n          decision_maker: '\u51B3\u7B56\u8005', economic_buyer: '\u9884\u7B97\u51B3\u7B56\u4EBA',\n          technical_evaluator: '\u6280\u672F\u8BC4\u4F30\u4EBA', user: '\u4F7F\u7528\u8005',\n          influencer: '\u5F71\u54CD\u8005', gatekeeper: '\u5B88\u95E8\u4EBA',\n        },\n      },\n      attitude: {\n        label: '\u5BF9\u6211\u53F8\u6001\u5EA6',\n        options: {\n          champion: '\u62E5\u62A4\u8005', supportive: '\u652F\u6301', neutral: '\u4E2D\u7ACB',\n          skeptical: '\u5B58\u7591', blocker: '\u53CD\u5BF9\u8005',\n        },\n      },\n      relationship_strength: {\n        label: '\u4E0E\u9500\u552E\u5173\u7CFB\u5F3A\u5EA6',\n        options: {\n          distant: '\u758F\u8FDC', acquaintance: '\u4E00\u822C\u8BA4\u8BC6', working: '\u5DE5\u4F5C\u5F80\u6765',\n          strong: '\u5173\u7CFB\u7D27\u5BC6', trusted_advisor: '\u53EF\u4FE1\u987E\u95EE',\n        },\n      },\n      owner_id: { label: '\u8054\u7CFB\u4EBA\u8D1F\u8D23\u4EBA' },\n      description: { label: '\u63CF\u8FF0' },\n      is_primary: { label: '\u4E3B\u8981\u8054\u7CFB\u4EBA', help: '\u662F\u5426\u4E3A\u8BE5\u5BA2\u6237\u7684\u4E3B\u8981\u8054\u7CFB\u4EBA\uFF1F' },\n      mailing_address: { label: '\u90AE\u5BC4\u5730\u5740' },\n      lead_source: {\n        label: '\u7EBF\u7D22\u6765\u6E90',\n        options: {\n          web: '\u7F51\u7AD9', referral: '\u63A8\u8350', event: '\u6D3B\u52A8 / \u5C55\u4F1A',\n          webinar: '\u7EBF\u4E0A\u7814\u8BA8\u4F1A', partner: '\u5408\u4F5C\u4F19\u4F34', advertisement: '\u5E7F\u544A',\n          paid_search: '\u4ED8\u8D39\u641C\u7D22', social: '\u793E\u4EA4\u5A92\u4F53', content: '\u5185\u5BB9 / \u535A\u5BA2',\n          cold_call: '\u964C\u751F\u62DC\u8BBF', email_campaign: '\u90AE\u4EF6\u8425\u9500', other: '\u5176\u4ED6',\n        },\n      },\n      do_not_call: { label: '\u7981\u6B62\u81F4\u7535' },\n      email_opt_out: { label: '\u62D2\u7EDD\u90AE\u4EF6' },\n      last_contacted_date: { label: '\u6700\u8FD1\u8054\u7CFB\u65F6\u95F4' },\n      avatar: { label: '\u5934\u50CF' },\n    },\n    _views: {\n      all_contacts: { label: '\u5168\u90E8\u8054\u7CFB\u4EBA' },\n      contact_directory: { label: '\u8054\u7CFB\u4EBA\u76EE\u5F55' },\n      primary_contacts: { label: '\u4E3B\u8981\u8054\u7CFB\u4EBA' },\n    },\n    _actions: {\n      ...activityActions,\n      mark_primary: {\n        label: '\u8BBE\u4E3A\u4E3B\u8981\u8054\u7CFB\u4EBA',\n        confirmText: '\u662F\u5426\u5C06\u6B64\u8054\u7CFB\u4EBA\u8BBE\u4E3A\u8BE5\u5BA2\u6237\u7684\u4E3B\u8981\u8054\u7CFB\u4EBA\uFF1F',\n        successMessage: '\u5DF2\u8BBE\u4E3A\u4E3B\u8981\u8054\u7CFB\u4EBA\uFF01',\n      },\n      send_email: {\n        label: '\u53D1\u9001\u90AE\u4EF6',\n        params: {\n          subject: { label: '\u4E3B\u9898' },\n          body: { label: '\u6B63\u6587' },\n        },\n      },\n      add_contact_to_campaign: {\n        label: '\u52A0\u5165\u8425\u9500\u6D3B\u52A8',\n        successMessage: '\u8054\u7CFB\u4EBA\u5DF2\u52A0\u5165\u8425\u9500\u6D3B\u52A8\uFF01',\n        params: {\n          crm_campaign: { label: '\u8425\u9500\u6D3B\u52A8' },\n        },\n      },\n    },\n    _sections: {\n      identity: { label: '\u8EAB\u4EFD\u4FE1\u606F' },\n      account_info: { label: '\u5BA2\u6237\u4E0E\u804C\u52A1' },\n      buying_centre: { label: '\u91C7\u8D2D\u51B3\u7B56\u5708' },\n      contact_info: { label: '\u8054\u7CFB\u65B9\u5F0F' },\n      mailing_address: { label: '\u90AE\u5BC4\u5730\u5740' },\n      additional: { label: '\u9644\u52A0\u4FE1\u606F' },\n      preferences: { label: '\u6C9F\u901A\u504F\u597D' },\n      // contact.view.ts \u8868\u5355\u533A\u5757\u540D\u79F0 (#1100)\n      contact_details: { label: '\u8054\u7CFB\u4FE1\u606F' },\n      comm_preferences: { label: '\u504F\u597D\u8BBE\u7F6E' },\n    },\n  },\n};\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/sales/translations/zh-CN/objects.pipeline.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/sales/translations/zh-CN\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/sales/translations/zh-CN/objects.pipeline.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport type { ObjectTranslationData } from '@objectstack/spec/system';\n\nimport { activityActions } from './_shared';\n\n/**\n * \u7B80\u4F53\u4E2D\u6587 (zh-CN) \u2014 `objects` translations for the PIPELINE family:\n * demand and the deals it becomes, plus the roll-up that forecasts them.\n *\n * Roster: `crm_lead`, `crm_opportunity`, `crm_opportunity_line_item`, `crm_forecast`.\n *\n * SPLIT AXIS (#1311): translation NAMESPACE first, then CRM DOMAIN FAMILY.\n * Everything that is not `objects` lives in `./app.ts`; `objects` \u2014 69-78% of\n * every bundle \u2014 is one file per CRM domain family, and a detail object\n * follows its master. A new row goes in the file for ITS family, never in\n * whichever file is already open: that is how one file re-grows past the 70%\n * advisory band `pnpm hygiene` prints. Full rule and rationale:\n * `src/sales/translations/zh-CN.ts`.\n */\nexport const pipeline: Record<string, ObjectTranslationData> = {\n  crm_lead: {\n    _validations: {\n      disqualification_reason_required: {\n        message: '\u7EBF\u7D22\u6807\u8BB0\u4E3A\u4E0D\u5408\u683C\u65F6\u5FC5\u987B\u586B\u5199\u53D6\u6D88\u8D44\u683C\u539F\u56E0',\n      },\n      duplicate_disqualification_requires_survivor: {\n        message: '\u4EE5\u91CD\u590D\u4E3A\u7531\u53D6\u6D88\u7EBF\u7D22\u8D44\u683C\u65F6\uFF0C\u5FC5\u987B\u6307\u660E\u4FDD\u7559\u7684\u8BB0\u5F55\u5E76\u5C06\u91CD\u590D\u72B6\u6001\u8BBE\u4E3A\u5DF2\u786E\u8BA4',\n      },\n      email_required: {\n        message: '\u7535\u5B50\u90AE\u4EF6\u4E3A\u5FC5\u586B\u9879',\n      },\n      lead_status_progression: {\n        message: '\u65E0\u6548\u7684\u7EBF\u7D22\u72B6\u6001\u6D41\u8F6C',\n      },\n    },\n    label: '\u7EBF\u7D22',\n    pluralLabel: '\u7EBF\u7D22',\n    description: '\u5C1A\u672A\u786E\u8BA4\u7684\u6F5C\u5728\u5BA2\u6237',\n    fields: {\n      salutation: {\n        label: '\u79F0\u8C13',\n        options: { mr: '\u5148\u751F', ms: '\u5973\u58EB', mrs: '\u592B\u4EBA', dr: '\u535A\u58EB', prof: '\u6559\u6388' },\n      },\n      first_name: { label: '\u540D' },\n      last_name: { label: '\u59D3' },\n      full_name: { label: '\u5168\u540D' },\n      company: { label: '\u516C\u53F8' },\n      title: { label: '\u804C\u4F4D' },\n      email: { label: '\u90AE\u7BB1' },\n      phone: { label: '\u7535\u8BDD' },\n      industry: {\n        label: '\u884C\u4E1A',\n        options: {\n          technology: '\u79D1\u6280', software: '\u8F6F\u4EF6 / SaaS', finance: '\u91D1\u878D',\n          healthcare: '\u533B\u7597', retail: '\u96F6\u552E', manufacturing: '\u5236\u9020',\n          education: '\u6559\u80B2', real_estate: '\u623F\u5730\u4EA7', media: '\u4F20\u5A92\u5A31\u4E50',\n          logistics: '\u7269\u6D41', hospitality: '\u9152\u5E97\u65C5\u6E38', energy: '\u80FD\u6E90\u516C\u7528\u4E8B\u4E1A',\n          government: '\u653F\u5E9C', nonprofit: '\u975E\u8425\u5229', other: '\u5176\u4ED6',\n        },\n      },\n      status: {\n        label: '\u72B6\u6001',\n        options: {\n          // \u5DF2\u786E\u8BA4 / \u672A\u901A\u8FC7 \u662F\u540C\u4E00\u4E2A\u52A8\u4F5C(\u7EBF\u7D22\u786E\u8BA4)\u7684\u6B63\u53CD\u4E24\u9762;\u539F\u5148\u7684\n          // \u5DF2\u786E\u8BA4 / \u4E0D\u5408\u683C \u51FA\u81EA\u4E24\u5957\u8BF4\u6CD5,\u5728\u72B6\u6001\u6761\u4E0A\u5E76\u6392\u65F6\u8BFB\u8D77\u6765\u4E0D\u6210\u5BF9\u3002\n          new: '\u65B0\u5EFA', contacted: '\u5DF2\u8054\u7CFB', qualified: '\u5DF2\u786E\u8BA4',\n          unqualified: '\u672A\u901A\u8FC7', converted: '\u5DF2\u8F6C\u5316',\n        },\n      },\n      lead_source: {\n        label: '\u7EBF\u7D22\u6765\u6E90',\n        options: {\n          web: '\u7F51\u7AD9', referral: '\u63A8\u8350', event: '\u6D3B\u52A8 / \u5C55\u4F1A',\n          webinar: '\u7EBF\u4E0A\u7814\u8BA8\u4F1A', partner: '\u5408\u4F5C\u4F19\u4F34', advertisement: '\u5E7F\u544A',\n          paid_search: '\u4ED8\u8D39\u641C\u7D22', social: '\u793E\u4EA4\u5A92\u4F53', content: '\u5185\u5BB9 / \u535A\u5BA2',\n          cold_call: '\u964C\u751F\u62DC\u8BBF', email_campaign: '\u90AE\u4EF6\u8425\u9500', other: '\u5176\u4ED6',\n        },\n      },\n      owner_id: { label: '\u7EBF\u7D22\u8D1F\u8D23\u4EBA' },\n      is_converted: { label: '\u5DF2\u8F6C\u5316' },\n      description: { label: '\u63CF\u8FF0' },\n      mobile: { label: '\u624B\u673A' },\n      website: { label: '\u7F51\u7AD9' },\n      rating: { label: '\u7EBF\u7D22\u8BC4\u5206', help: '\u7EBF\u7D22\u8D28\u91CF\u8BC4\u5206\uFF081-5 \u661F\uFF09' },\n      converted_account: { label: '\u8F6C\u5316\u5BA2\u6237' },\n      converted_contact: { label: '\u8F6C\u5316\u8054\u7CFB\u4EBA' },\n      converted_opportunity: { label: '\u8F6C\u5316\u5546\u673A' },\n      converted_date: { label: '\u8F6C\u5316\u65E5\u671F' },\n      address: { label: '\u5730\u5740' },\n      annual_revenue: { label: '\u5E74\u8425\u6536' },\n      number_of_employees: { label: '\u5458\u5DE5\u4EBA\u6570' },\n      notes: { label: '\u5907\u6CE8', help: '\u672C\u7EBF\u7D22\u7684\u5DE5\u4F5C\u5907\u6CE8\u2014\u2014\u652F\u6301\u683C\u5F0F\u6392\u7248\u3002' },\n      do_not_call: { label: '\u7981\u6B62\u81F4\u7535' },\n      email_opt_out: { label: '\u62D2\u6536\u90AE\u4EF6' },\n      disqualification_reason: {\n        // \u72B6\u6001\u91CC\u7684 unqualified \u8BD1\u4F5C\u300C\u672A\u901A\u8FC7\u300D,\u6240\u4EE5\u8FD9\u91CC\u8DDF\u7740\u53EB\u300C\u672A\u901A\u8FC7\u539F\u56E0\u300D\n        // \u800C\u4E0D\u662F\u300C\u53D6\u6D88\u8D44\u683C\u539F\u56E0\u300D\u2014\u2014 \u4E24\u4E2A\u5B57\u6BB5\u5728\u540C\u4E00\u5F20\u8868\u5355\u4E0A\u4E0B\u76F8\u90BB,\u7528\u8BCD\u5FC5\u987B\u6210\u5BF9\u3002\n        label: '\u672A\u901A\u8FC7\u539F\u56E0',\n        help: '\u72B6\u6001\u4E3A\u300C\u672A\u901A\u8FC7\u300D\u65F6\u5FC5\u586B',\n        options: {\n          not_a_fit: '\u9700\u6C42\u4E0D\u5339\u914D', no_budget: '\u9884\u7B97\u4E0D\u8DB3', wrong_persona: '\u8054\u7CFB\u4EBA\u89D2\u8272\u4E0D\u7B26',\n          unreachable: '\u65E0\u6CD5\u8054\u7CFB', duplicate: '\u91CD\u590D\u7EBF\u7D22', competitor: '\u9009\u62E9\u4E86\u7ADE\u4E89\u5BF9\u624B',\n          other: '\u5176\u4ED6',\n        },\n      },\n      duplicate_of_type: {\n        help: '\u4FDD\u7559\u4E0B\u6765\u7684\u90A3\u6761\u8BB0\u5F55\u6240\u5C5E\u7684\u5BF9\u8C61\u7C7B\u578B\u3002',\n        label: '\u91CD\u590D\u4E8E',\n        // `erased` \u662F\u5893\u7891\u503C\uFF0C\u4E0D\u662F\u53EF\u9009\u9879\uFF1A\u8868\u5355\u4E0D\u63D0\u4F9B\u5B83\uFF08\u89C1\n        // `src/sales/views/lead.view.ts`\uFF09\uFF0C\u4F46\u5E78\u5B58\u8BB0\u5F55\u88AB\u5220\u9664\u540E\u7EBF\u7D22\u4F1A\u5E26\u7740\u5B83\uFF0C\n        // \u6240\u4EE5\u51E1\u662F\u8BFB\u53D6\u8BB0\u5F55\u7684\u5730\u65B9\u90FD\u9700\u8981\u6807\u7B7E\uFF0C\u5426\u5219\u4F1A\u663E\u793A\u539F\u59CB\u503C `erased`\u3002\n        options: { crm_lead: '\u7EBF\u7D22', crm_contact: '\u8054\u7CFB\u4EBA', erased: '\u8BB0\u5F55\u5DF2\u5220\u9664' },\n      },\n      duplicate_of_lead: { label: '\u91CD\u590D\u7684\u7EBF\u7D22' },\n      duplicate_of_contact: { label: '\u91CD\u590D\u7684\u8054\u7CFB\u4EBA' },\n      duplicate_status: {\n        help: '\u7591\u4F3C = \u5F55\u5165\u65F6\u81EA\u52A8\u6807\u8BB0\uFF1B\u5DF2\u786E\u8BA4 = \u4EBA\u5DE5\u6838\u5B9E\u8FC7\u5339\u914D\u3002',\n        // \u7591\u4F3C = \u5F55\u5165\u65F6\u81EA\u52A8\u6807\u8BB0;\u5DF2\u786E\u8BA4 = \u4EBA\u5DE5\u6838\u5BF9\u540E\u7684\u5224\u5B9A\u3002\u4E24\u8005\u662F\u540C\u4E00\n        // \u5224\u65AD\u7684\u4E24\u4E2A\u9636\u6BB5,\u6240\u4EE5\u5171\u7528\u4E00\u4E2A\u5B57\u6BB5\u800C\u4E0D\u662F\u5404\u5360\u4E00\u5957\u94FE\u63A5\u5B57\u6BB5\u3002\n        label: '\u91CD\u590D\u72B6\u6001',\n        options: { suspected: '\u7591\u4F3C\u91CD\u590D', confirmed: '\u5DF2\u786E\u8BA4\u91CD\u590D' },\n      },\n      display_title: { label: '\u663E\u793A\u540D\u79F0' },\n      company_normalized: { label: '\u516C\u53F8\u540D\u79F0\uFF08\u89C4\u8303\u5316\uFF09', help: '\u7EBF\u7D22\u8F6C\u5316\u7684\u5339\u914D\u952E\uFF1A\u516C\u53F8\u540D\u79F0\u8F6C\u5C0F\u5199\u3001\u53BB\u9664\u9996\u5C3E\u7A7A\u683C\u3001\u5185\u90E8\u8FDE\u7EED\u7A7A\u767D\u5408\u5E76\u4E3A\u4E00\u4E2A\u7A7A\u683C\u3002\u7531 lead_duplicate_check \u94A9\u5B50\u7EF4\u62A4\u2014\u2014\u8BF7\u52FF\u76F4\u63A5\u7F16\u8F91\u3002' },\n      next_followup_date: { label: '\u4E0B\u6B21\u8DDF\u8FDB\u65E5\u671F' },\n      last_contacted_date: { label: '\u6700\u8FD1\u8054\u7CFB\u65F6\u95F4' },\n      need_type: {\n        label: '\u9700\u6C42\u7C7B\u578B',\n        help: '\u5BA2\u6237\u60F3\u8981\u4EC0\u4E48\u3002\u7EBF\u7D22\u5206\u6D3E\u3001\u4F18\u5148\u7EA7\u6392\u5E8F\u548C\u9700\u6C42\u5206\u6790\u90FD\u8BFB\u8FD9\u4E2A\u5B57\u6BB5\u3002',\n        options: {\n          new_implementation: '\u65B0\u5EFA\u5B9E\u65BD', expansion: '\u6269\u5BB9\u589E\u8D2D',\n          replacement: '\u66FF\u6362\u8FC1\u79FB', renewal: '\u7EED\u7EA6', consulting: '\u54A8\u8BE2\u670D\u52A1',\n          support: '\u8FD0\u7EF4\u652F\u6301', other: '\u5176\u4ED6',\n        },\n      },\n      estimated_amount: {\n        label: '\u9884\u8BA1\u91D1\u989D',\n        help: '\u8D44\u683C\u5224\u5B9A\u4E4B\u524D\u5BF9\u8BE5\u9700\u6C42\u91D1\u989D\u7684\u4F30\u7B97\u3002\u8F6C\u5316\u65F6\u7528\u4E8E\u9884\u586B\u5546\u673A\u91D1\u989D\u3002',\n      },\n      conversion_approval_status: {\n        label: '\u8F6C\u5316\u5BA1\u6279',\n        help: '\u8BE5\u7EBF\u7D22\u662F\u5426\u5DF2\u83B7\u51C6\u8F6C\u5316\u3002\u300C\u65E0\u9700\u5BA1\u6279\u300D\u8868\u793A\u4E0D\u8D70\u5BA1\u6279\u6D41\u7A0B\u2014\u2014\u8FD9\u662F\u4EA7\u54C1\u7684\u51FA\u5382\u9ED8\u8BA4\u503C\u3002',\n        options: {\n          not_required: '\u65E0\u9700\u5BA1\u6279', pending: '\u5F85\u5BA1\u6279',\n          approved: '\u5BA1\u6279\u901A\u8FC7', rejected: '\u5BA1\u6279\u9A73\u56DE',\n        },\n      },\n    },\n    _views: {\n      all_leads: {\n        label: '\u5168\u90E8\u7EBF\u7D22',\n        emptyState: { title: '\u8FD8\u6CA1\u6709\u7EBF\u7D22', message: '\u521B\u5EFA\u7B2C\u4E00\u6761\u7EBF\u7D22\uFF0C\u4ECE\u8FD9\u91CC\u5F00\u59CB' },\n      },\n      kanban_by_status: { label: '\u7EBF\u7D22\u6D41\u6C34\u7EBF' },\n      calendar_by_created: { label: '\u7EBF\u7D22\u65E5\u5386' },\n      gallery_view: { label: '\u7EBF\u7D22\u5361\u7247' },\n      my_leads: { label: '\u6211\u7684\u7EBF\u7D22' },\n      high_priority: { label: '\u9AD8\u4F18\u5148\u7EA7' },\n      hot_leads: { label: '\uD83D\uDD25 \u9AD8\u70ED\u5EA6\u7EBF\u7D22' },\n      suspected_duplicates: {\n        label: '\u7591\u4F3C\u91CD\u590D\u7EBF\u7D22',\n        emptyState: { title: '\u6CA1\u6709\u7591\u4F3C\u91CD\u590D', message: '\u65E0\u9700\u590D\u6838\u2014\u2014\u6BCF\u4E2A\u91CD\u590D\u5F55\u5165\u7684\u90AE\u7BB1\u90FD\u5DF2\u68C0\u67E5\u8FC7\u3002' },\n      },\n    },\n    _sections: {\n      // Object-level section keys (lead.object.ts), used by record forms and\n      // by the detail page, whose sections reference these groups (#806)\n      address: { label: '\u5730\u5740' },\n      identity: { label: '\u8EAB\u4EFD\u4FE1\u606F' },\n      company_info: { label: '\u516C\u53F8\u4FE1\u606F' },\n      contact_info: { label: '\u8054\u7CFB\u65B9\u5F0F' },\n      qualification: { label: '\u8D44\u683C\u8BC4\u4F30' },\n      assignment: { label: '\u5206\u914D' },\n      additional: { label: '\u9644\u52A0\u4FE1\u606F' },\n      preferences: { label: '\u6C9F\u901A\u504F\u597D' },\n      conversion: { label: '\u8F6C\u5316' },\n      duplicates: { label: '\u91CD\u590D\u7EBF\u7D22\u7BA1\u7406' },\n      // lead.view.ts \u8868\u5355\u533A\u5757\u540D\u79F0 (#1100) \u2014\u2014 \u9ED8\u8BA4\u8868\u5355\u4E0E\u6BCF\u4E00\u4E2A\u5177\u540D formView\n      // \u7684\u533A\u5757\u540D\u5B57\u90FD\u4F4F\u5728\u8FD9\u91CC\uFF1A\u90A3\u8FB9\u65B0\u589E\u4E00\u4E2A\u8868\u5355\uFF0C\u8FD9\u91CC\u5C31\u8865\u4E0A\u5B83\u7684\u533A\u5757\u540D\u3002\n      contact_information: { label: '\u8054\u7CFB\u4FE1\u606F' },\n      lead_classification: { label: '\u7EBF\u7D22\u5206\u7C7B' },\n      company_information: { label: '\u516C\u53F8\u4FE1\u606F' },\n      additional_information: { label: '\u9644\u52A0\u4FE1\u606F' },\n      privacy: { label: '\u9690\u79C1' },\n      general: { label: '\u5E38\u89C4\u4FE1\u606F' },\n      details: { label: '\u8BE6\u60C5' },\n      step_1_contact_details: { label: '\u7B2C\u4E00\u6B65\uFF1A\u8054\u7CFB\u65B9\u5F0F' },\n      step_2_company_information: { label: '\u7B2C\u4E8C\u6B65\uFF1A\u516C\u53F8\u4FE1\u606F' },\n      step_3_qualification: { label: '\u7B2C\u4E09\u6B65\uFF1A\u8D44\u8D28\u5BA1\u6838' },\n      step_4_review_and_convert: { label: '\u7B2C\u56DB\u6B65\uFF1A\u5BA1\u6838\u5E76\u8F6C\u5316' },\n      primary_information: { label: '\u4E3B\u8981\u4FE1\u606F' },\n      extended_details: { label: '\u6269\u5C55\u4FE1\u606F' },\n      quick_edit: { label: '\u5FEB\u901F\u7F16\u8F91' },\n      update_lead_status: { label: '\u66F4\u65B0\u7EBF\u7D22\u72B6\u6001' },\n      tell_us_about_yourself: { label: '\u8BF7\u4ECB\u7ECD\u4E00\u4E0B\u60A8\u81EA\u5DF1' },\n      about_your_company: { label: '\u60A8\u7684\u516C\u53F8\u4FE1\u606F' },\n      how_can_we_help: { label: '\u6211\u4EEC\u80FD\u5E2E\u60A8\u4EC0\u4E48\uFF1F' },\n      lead_information: { label: '\u7EBF\u7D22\u4FE1\u606F' },\n      address_information: { label: '\u5730\u5740\u4FE1\u606F' },\n      privacy_preferences: { label: '\u9690\u79C1\u504F\u597D' },\n    },\n    _actions: {\n      ...activityActions,\n      convert_lead: {\n        label: '\u8F6C\u5316\u7EBF\u7D22',\n        successMessage: '\u7EBF\u7D22\u8F6C\u5316\u6210\u529F\uFF01',\n      },\n      create_campaign: {\n        label: '\u52A0\u5165\u8425\u9500\u6D3B\u52A8',\n        successMessage: '\u5DF2\u5C06\u7EBF\u7D22\u52A0\u5165\u8425\u9500\u6D3B\u52A8\uFF01',\n        params: {\n          crm_campaign: { label: '\u8425\u9500\u6D3B\u52A8' },\n        },\n      },\n      schedule_followup: {\n        label: '\u5B89\u6392\u8DDF\u8FDB',\n        successMessage: '\u8DDF\u8FDB\u4EFB\u52A1\u5DF2\u521B\u5EFA\u3002',\n      },\n    },\n  },\n  crm_opportunity: {\n    _validations: {\n      amount_positive: {\n        message: '\u91D1\u989D\u5FC5\u987B\u5927\u4E8E\u96F6',\n      },\n      close_date_future: {\n        message: '\u9664\u975E\u5546\u673A\u5DF2\u7ED3\u675F\uFF0C\u5426\u5219\u9884\u8BA1\u6210\u4EA4\u65E5\u4E0D\u5E94\u65E9\u4E8E\u4ECA\u5929',\n      },\n      opportunity_stage_progression: {\n        message: '\u65E0\u6548\u7684\u5546\u673A\u9636\u6BB5\u6D41\u8F6C',\n      },\n    },\n    label: '\u5546\u673A',\n    pluralLabel: '\u5546\u673A',\n    description: '\u9500\u552E\u6D41\u7A0B\u4E2D\u7684\u5546\u673A\u4E0E\u4EA4\u6613',\n    fields: {\n      name: { label: '\u5546\u673A\u540D\u79F0' },\n      crm_account: { label: '\u6240\u5C5E\u5BA2\u6237' },\n      primary_contact: { label: '\u4E3B\u8981\u8054\u7CFB\u4EBA' },\n      owner_id: { label: '\u5546\u673A\u8D1F\u8D23\u4EBA' },\n      amount: { label: '\u91D1\u989D' },\n      expected_revenue: { label: '\u9884\u671F\u6536\u5165' },\n      stage: {\n        label: '\u9636\u6BB5',\n        options: {\n          prospecting: '\u5BFB\u627E\u5BA2\u6237', qualification: '\u8D44\u683C\u5BA1\u67E5',\n          needs_analysis: '\u9700\u6C42\u5206\u6790', proposal: '\u63D0\u6848',\n          negotiation: '\u8C08\u5224', closed_won: '\u6210\u4EA4', closed_lost: '\u5931\u8D25',\n        },\n      },\n      probability: { label: '\u6210\u4EA4\u6982\u7387 (%)' },\n      close_date: { label: '\u9884\u8BA1\u6210\u4EA4\u65E5\u671F' },\n      type: {\n        label: '\u7C7B\u578B',\n        options: {\n          new_business: '\u65B0\u4E1A\u52A1',\n          existing_upgrade: '\u8001\u5BA2\u6237\u5347\u7EA7',\n          existing_renewal: '\u8001\u5BA2\u6237\u7EED\u7EA6',\n          existing_expansion: '\u8001\u5BA2\u6237\u62D3\u5C55',\n        },\n      },\n      forecast_category: {\n        label: '\u9884\u6D4B\u7C7B\u522B',\n        options: {\n          pipeline: '\u7BA1\u9053', best_case: '\u6700\u4F73\u60C5\u51B5',\n          commit: '\u627F\u8BFA', omitted: '\u5DF2\u6392\u9664', closed: '\u5DF2\u5173\u95ED',\n        },\n      },\n      description: { label: '\u63CF\u8FF0' },\n      next_step: { label: '\u4E0B\u4E00\u6B65' },\n      lead_source: {\n        label: '\u7EBF\u7D22\u6765\u6E90',\n        options: {\n          web: '\u7F51\u7AD9', referral: '\u63A8\u8350', event: '\u6D3B\u52A8 / \u5C55\u4F1A',\n          webinar: '\u7EBF\u4E0A\u7814\u8BA8\u4F1A', partner: '\u5408\u4F5C\u4F19\u4F34', advertisement: '\u5E7F\u544A',\n          paid_search: '\u4ED8\u8D39\u641C\u7D22', social: '\u793E\u4EA4\u5A92\u4F53', content: '\u5185\u5BB9 / \u535A\u5BA2',\n          cold_call: '\u964C\u751F\u62DC\u8BBF', email_campaign: '\u90AE\u4EF6\u8425\u9500', other: '\u5176\u4ED6',\n        },\n      },\n      crm_campaign: { label: '\u8425\u9500\u6D3B\u52A8', help: '\u5E26\u6765\u6B64\u5546\u673A\u7684\u8425\u9500\u6D3B\u52A8' },\n      days_in_stage: { label: '\u5F53\u524D\u9636\u6BB5\u5929\u6570' },\n      stage_entry_date: { label: '\u8FDB\u5165\u5F53\u524D\u9636\u6BB5\u65E5\u671F', help: '\u672C\u5546\u673A\u8FDB\u5165\u5F53\u524D\u9636\u6BB5\u7684\u65E5\u671F\u3002' },\n      is_private: { label: '\u79C1\u5BC6' },\n      approval_status: {\n        label: '\u5BA1\u6279\u72B6\u6001',\n        options: { not_required: '\u65E0\u9700\u5BA1\u6279', pending: '\u5BA1\u6279\u4E2D', approved: '\u5DF2\u6279\u51C6', rejected: '\u5DF2\u9A73\u56DE' },\n      },\n      approved_date: { label: '\u6279\u51C6\u65F6\u95F4' },\n      win_reason: {\n        help: '\u8D62\u5355\u539F\u56E0\u3002\u5C06\u5546\u673A\u5173\u95ED\u4E3A\"\u6210\u4EA4\"\u65F6\u5FC5\u586B\u3002',\n        label: '\u8D62\u5355\u539F\u56E0',\n        options: {\n          better_product: '\u4EA7\u54C1\u66F4\u4F18', better_price: '\u4EF7\u683C\u66F4\u4F18', relationship: '\u5BA2\u6237\u5173\u7CFB',\n          better_support: '\u652F\u6301\u66F4\u597D', best_fit: '\u6700\u4F73\u5951\u5408',\n          quote_accepted: '\u62A5\u4EF7\u88AB\u63A5\u53D7', other: '\u5176\u4ED6',\n        },\n      },\n      loss_reason: {\n        help: '\u4E22\u5355\u539F\u56E0\u3002\u5C06\u5546\u673A\u5173\u95ED\u4E3A\"\u5931\u8D25\"\u65F6\u5FC5\u586B\u3002',\n        label: '\u4E22\u5355\u539F\u56E0',\n        options: {\n          price: '\u4EF7\u683C\u8FC7\u9AD8', competitor: '\u8F93\u7ED9\u7ADE\u4E89\u5BF9\u624B', no_budget: '\u65E0\u9884\u7B97',\n          no_decision: '\u672A\u51B3\u7B56', timing: '\u65F6\u673A\u4E0D\u5408\u9002', features: '\u529F\u80FD\u7F3A\u5931', other: '\u5176\u4ED6',\n        },\n      },\n      loss_details: { label: '\u8D62/\u4E22\u5355\u8BE6\u60C5', help: '\u8D62\u5355\u6216\u4E22\u5355\u539F\u56E0\u7684\u8865\u5145\u8BF4\u660E\u3002' },\n      // REQ-0006 \u2014 \u8D44\u683C\u8BC4\u4F30\u3001\u5BA2\u6237\u4FA7\u91C7\u8D2D\u65E5\u7A0B\u3001\u5546\u673A\u53D9\u8FF0\u3001\u4E1A\u52A1\u7EBF\u4E0E\u72B6\u6001\u53D8\u66F4\u5BA1\u6279\u3002\n      will_bid: { label: '\u662F\u5426\u6295\u6807', help: '\u6211\u65B9\u662F\u5426\u6253\u7B97\u6295\u6807\u3002\u7559\u7A7A\u8868\u793A\u5C1A\u672A\u51B3\u5B9A\u3002' },\n      controllability: { label: '\u53EF\u63A7\u6027', options: { high: '\u9AD8', medium: '\u4E2D', low: '\u4F4E' } },\n      priority: { label: '\u4F18\u5148\u7EA7', options: { high: '\u9AD8', medium: '\u4E2D', low: '\u4F4E' } },\n      deal_level: { label: '\u5546\u673A\u7EA7\u522B', options: { strategic: '\u6218\u7565\u7EA7', key: '\u91CD\u70B9', standard: '\u666E\u901A' } },\n      is_subcontracted: { label: '\u6D89\u53CA\u5206\u5305' },\n      subcontracting_note: { label: '\u5206\u5305\u8BF4\u660E' },\n      customer_initiation_date: { label: '\u5BA2\u6237\u7ACB\u9879\u65E5\u671F' },\n      expected_tender_date: { label: '\u9884\u8BA1\u62DB\u6807\u65E5\u671F' },\n      expected_signing_date: { label: '\u9884\u8BA1\u7B7E\u7EA6\u65E5\u671F' },\n      expected_tender_amount: { label: '\u9884\u8BA1\u62DB\u6807\u91D1\u989D' },\n      expected_signing_amount: { label: '\u9884\u8BA1\u7B7E\u7EA6\u91D1\u989D' },\n      business_line: {\n        label: '\u4E1A\u52A1\u7EBF',\n        options: { product: '\u4EA7\u54C1', services: '\u4E13\u4E1A\u670D\u52A1', consulting: '\u54A8\u8BE2\u670D\u52A1', support: '\u8FD0\u7EF4\u652F\u6301', other: '\u5176\u4ED6' },\n      },\n      customer_background: { label: '\u5BA2\u6237\u7B80\u4ECB' },\n      project_background: { label: '\u9879\u76EE\u80CC\u666F' },\n      risk_analysis: { label: '\u98CE\u9669\u5206\u6790' },\n      payment_terms: { label: '\u4ED8\u6B3E\u6761\u6B3E' },\n      requested_status: { label: '\u7533\u8BF7\u53D8\u66F4\u72B6\u6001', options: { closed_won: '\u8D62\u5355', closed_lost: '\u4E22\u5355' } },\n      status_change_approval_status: {\n        label: '\u72B6\u6001\u53D8\u66F4\u5BA1\u6279',\n        options: { not_required: '\u65E0\u9700\u5BA1\u6279', pending: '\u5BA1\u6279\u4E2D', approved: '\u5DF2\u6279\u51C6', rejected: '\u5DF2\u9A73\u56DE' },\n      },\n      // REQ-0006 \u7B2C 11 \u6B65 \u2014 \u7ACB\u9879\u5BA1\u6279\u3002\n      qualification_requested: {\n        label: '\u7533\u8BF7\u7ACB\u9879\u5BA1\u6279',\n        help: '\u52FE\u9009\u540E\u63D0\u4EA4\u7ACB\u9879\u5BA1\u6279\u3002\u5BA1\u6279\u88AB\u9A73\u56DE\u65F6\u4F1A\u81EA\u52A8\u53D6\u6D88\u52FE\u9009\uFF1B\u518D\u6B21\u52FE\u9009\u5373\u53EF\u91CD\u65B0\u7533\u8BF7\u3002',\n      },\n      qualification_approval_status: {\n        label: '\u7ACB\u9879\u5BA1\u6279',\n        options: { not_required: '\u65E0\u9700\u5BA1\u6279', pending: '\u5BA1\u6279\u4E2D', approved: '\u5DF2\u6279\u51C6', rejected: '\u5DF2\u9A73\u56DE' },\n      },\n    },\n    _views: {\n      tender_this_quarter: {\n        label: '\u672C\u5B63\u5EA6\u9884\u8BA1\u62DB\u6807',\n        emptyState: {\n          title: '\u672C\u5B63\u5EA6\u6682\u65E0\u9884\u8BA1\u62DB\u6807\u7684\u5546\u673A',\n          message: '\u672C\u6807\u7B7E\u9875\u5217\u51FA\u5BA2\u6237\u4FA7\u9884\u8BA1\u62DB\u6807\u65E5\u671F\u843D\u5728\u5F53\u524D\u5B63\u5EA6\u5185\u7684\u8FDB\u884C\u4E2D\u5546\u673A\u3002\u5728\u5546\u673A\u4E0A\u586B\u5199\u201C\u9884\u8BA1\u62DB\u6807\u65E5\u671F\u201D\u540E\uFF0C\u5B83\u5C31\u4F1A\u51FA\u73B0\u5728\u8FD9\u91CC\u3002',\n        },\n      },\n      open_opportunities: { label: '\u8FDB\u884C\u4E2D\u5546\u673A' },\n      all_opportunities: { label: '\u5168\u90E8\u5546\u673A' },\n      pipeline_kanban: { label: '\u9500\u552E\u6D41\u6C34\u7EBF' },\n      close_date_calendar: { label: '\u9884\u6D4B\u65E5\u5386' },\n      deal_timeline: { label: '\u5546\u673A\u65F6\u95F4\u7EBF' },\n      deal_gallery: { label: '\u5546\u673A\u5361\u7247' },\n      my_open_deals: { label: '\u6211\u7684\u8FDB\u884C\u4E2D\u5546\u673A' },\n      stale_opportunities: { label: '\u26A0\uFE0F \u505C\u6EDE\u5546\u673A \u00B7 \u6309\u9636\u6BB5\u505C\u7559\u65F6\u95F4\u6392\u5E8F' },\n      closing_this_quarter: {\n        label: '\u672C\u5B63\u5EA6\u5F85\u6210\u4EA4\u5546\u673A',\n        emptyState: {\n          title: '\u672C\u5B63\u5EA6\u6682\u65E0\u5F85\u6210\u4EA4\u5546\u673A',\n          message: '\u672C\u6807\u7B7E\u9875\u5217\u51FA\u9884\u8BA1\u6210\u4EA4\u65E5\u671F\u843D\u5728\u5F53\u524D\u5B63\u5EA6\u5185\u3001\u4E14\u5904\u4E8E\u627F\u8BFA\uFF08Commit\uFF09\u6216\u6700\u4F73\u53EF\u80FD\uFF08Best Case\uFF09\u7684\u8FDB\u884C\u4E2D\u5546\u673A\u3002\u5F53\u524D\u6CA1\u6709\u7B26\u5408\u6761\u4EF6\u7684\u8BB0\u5F55\u2014\u2014\u9884\u8BA1\u6210\u4EA4\u65E5\u671F\u66F4\u665A\u7684\u5546\u673A\u8BF7\u89C1\u201C\u8FDB\u884C\u4E2D\u5546\u673A\u201D\u6807\u7B7E\u9875\u3002',\n        },\n      },\n    },\n    _sections: {\n      // Object-level section keys (opportunity.object.ts), used by record forms\n      // and by the detail page, whose sections reference these groups (#1452)\n      crm_forecast: { label: '\u9636\u6BB5\u4E0E\u9884\u6D4B' },\n      basic: { label: '\u57FA\u672C\u4FE1\u606F' },\n      financials: { label: '\u8D22\u52A1\u4FE1\u606F' },\n      sales_process: { label: '\u9500\u552E\u6D41\u7A0B' },\n      classification: { label: '\u5206\u7C7B' },\n      campaign: { label: '\u8425\u9500\u6D3B\u52A8' },\n      notes: { label: '\u5907\u6CE8\u4E0E\u4E0B\u4E00\u6B65' },\n      qualification: { label: '\u8D44\u683C\u8BC4\u4F30' },\n      narrative: { label: '\u5546\u673A\u53D9\u8FF0' },\n      // opportunity.view.ts \u8868\u5355\u533A\u5757\u540D\u79F0 (#1100)\n      overview: { label: '\u6982\u89C8' },\n      forecast: { label: '\u9884\u6D4B' },\n      sales_strategy: { label: '\u9500\u552E\u7B56\u7565' },\n      win_loss: { label: '\u8D62\u5355/\u8F93\u5355' },\n    },\n    _actions: {\n      ...activityActions,\n      clone_opportunity: {\n        label: '\u514B\u9686\u5546\u673A',\n        successMessage: '\u5546\u673A\u514B\u9686\u6210\u529F\uFF01',\n      },\n      generate_quote: {\n        label: '\u751F\u6210\u62A5\u4EF7\u5355',\n        successMessage: '\u5DF2\u6839\u636E\u5546\u673A\u521B\u5EFA\u62A5\u4EF7\u5355\uFF01',\n      },\n      mass_update_stage: {\n        label: '\u66F4\u65B0\u9636\u6BB5',\n        successMessage: '\u5546\u673A\u9636\u6BB5\u5DF2\u66F4\u65B0\uFF01',\n        params: {\n          stage: {\n            label: '\u65B0\u9636\u6BB5',\n            options: {\n              prospecting: '\u5BFB\u627E\u5BA2\u6237', qualification: '\u8D44\u683C\u5BA1\u67E5',\n              needs_analysis: '\u9700\u6C42\u5206\u6790', proposal: '\u63D0\u6848',\n              negotiation: '\u8C08\u5224', closed_won: '\u6210\u4EA4', closed_lost: '\u5931\u8D25',\n            },\n          },\n        },\n      },\n    },\n  },\n  crm_opportunity_line_item: {\n    _validations: {\n      unit_price_positive: {\n        message: '\u9500\u552E\u4EF7\u683C\u4E0D\u80FD\u4E3A\u8D1F\u6570',\n      },\n    },\n    label: '\u5546\u673A\u4EA7\u54C1\u660E\u7EC6',\n    pluralLabel: '\u5546\u673A\u4EA7\u54C1\u660E\u7EC6',\n    description: '\u5546\u673A\u4E0B\u6309\u4EA7\u54C1\u62C6\u5206\u7684\u62A5\u4EF7\u884C',\n    fields: {\n      crm_opportunity: { label: '\u5173\u8054\u5546\u673A' },\n      crm_product: { label: '\u4EA7\u54C1' },\n      description: { label: '\u63CF\u8FF0' },\n      quantity: { label: '\u6570\u91CF' },\n      list_price: { label: '\u6807\u4EF7', help: '\u81EA\u52A8\u53D6\u81EA\u4EA7\u54C1\u7684\u76EE\u5F55\u4EF7' },\n      unit_price: { label: '\u9500\u552E\u5355\u4EF7', help: '\u534F\u5546\u540E\u7684\u5355\u4EF7\uFF08\u53EF\u4E0E\u76EE\u5F55\u4EF7\u4E0D\u540C\uFF09' },\n      discount: { label: '\u6298\u6263\uFF08%\uFF09' },\n      total_price: { label: '\u603B\u8BA1' },\n      line_number: { label: '\u884C\u53F7' },\n    },\n    _sections: {\n      basic: { label: '\u660E\u7EC6\u884C' },\n      pricing: { label: '\u4EF7\u683C' },\n    },\n  },\n  crm_forecast: {\n    _validations: {\n      period_end_after_start: {\n        message: '\u5468\u671F\u7ED3\u675F\u5FC5\u987B\u665A\u4E8E\u5468\u671F\u5F00\u59CB\u3002',\n      },\n      period_end_matches_calendar_period: {\n        message: '\u5468\u671F\u7ED3\u675F\u5FC5\u987B\u662F\u8BE5\u5468\u671F\u7684\u6700\u540E\u4E00\u5929\u2014\u2014\u4F8B\u5982\u4EE5 2026-07-01 \u5F00\u59CB\u7684\u5B63\u5EA6\u5BF9\u5E94 2026-09-30\uFF0C2026 \u5E74 8 \u6708\u5BF9\u5E94 2026-08-31\u3002',\n      },\n      period_start_first_of_period: {\n        message: '\u5468\u671F\u5F00\u59CB\u5FC5\u987B\u662F\u8BE5\u5468\u671F\u7684\u7B2C\u4E00\u5929\u2014\u2014\u4F8B\u5982 2026 \u5E74 8 \u6708\u5BF9\u5E94 2026-08-01\u3002',\n      },\n      quarter_starts_on_quarter_boundary: {\n        message: '\u5B63\u5EA6\u9884\u6D4B\u5FC5\u987B\u4ECE\u5B63\u5EA6\u8FB9\u754C\u5F00\u59CB\u2014\u20141 \u6708 1 \u65E5\u30014 \u6708 1 \u65E5\u30017 \u6708 1 \u65E5\u6216 10 \u6708 1 \u65E5\u3002',\n      },\n      snapshot_amounts_non_negative: {\n        message: '\u5FEB\u7167\u91D1\u989D\u4E0D\u80FD\u4E3A\u8D1F\u6570\u3002',\n      },\n    },\n    label: '\u9500\u552E\u9884\u6D4B',\n    pluralLabel: '\u9500\u552E\u9884\u6D4B',\n    description: '\u6309\u9500\u552E\u8D1F\u8D23\u4EBA\u5B9A\u671F\u8BB0\u5F55\u7684\u7BA1\u9053\u5FEB\u7167\uFF0C\u7528\u4E8E\u6536\u5165\u9884\u6D4B',\n    fields: {\n      owner_id: { label: '\u8D1F\u8D23\u4EBA' },\n      period: { label: '\u5468\u671F', options: { month: '\u6708\u5EA6', quarter: '\u5B63\u5EA6' } },\n      period_start: {\n        label: '\u5468\u671F\u8D77\u59CB',\n        help: '\u5FC5\u987B\u662F\u6240\u5728\u5468\u671F\u7684\u7B2C\u4E00\u5929\u2014\u2014\u4F8B\u5982 2026 \u5E74 8 \u6708\u5BF9\u5E94 2026-08-01\u3002\u5B63\u5EA6\u9884\u6D4B\u8FD8\u5FC5\u987B\u843D\u5728\u5B63\u5EA6\u8FB9\u754C\u4E0A\uFF1A1 \u6708 1 \u65E5\u30014 \u6708 1 \u65E5\u30017 \u6708 1 \u65E5\u6216 10 \u6708 1 \u65E5\u3002',\n      },\n      period_end: {\n        label: '\u5468\u671F\u622A\u6B62',\n        help: '\u901A\u5E38\u6839\u636E\"\u5468\u671F\"\u548C\"\u5468\u671F\u8D77\u59CB\"\u81EA\u52A8\u63A8\u7B97\u3002\u5982\u624B\u52A8\u586B\u5199\uFF0C\u5FC5\u987B\u662F\u8BE5\u5468\u671F\u7684\u6700\u540E\u4E00\u5929\u2014\u2014\u4F8B\u5982\u8D77\u59CB\u4E3A 2026-07-01 \u7684\u5B63\u5EA6\u5BF9\u5E94 2026-09-30\uFF0C2026 \u5E74 8 \u6708\u5BF9\u5E94 2026-08-31\u3002',\n      },\n      period_label: { label: '\u5468\u671F\u6807\u7B7E', help: '\u6613\u8BFB\u7684\u5468\u671F\u6807\u7B7E\uFF0C\u4F8B\u5982\"2026 \u5E74\u7B2C\u4E09\u5B63\u5EA6\"\u6216\"2026 \u5E74 8 \u6708\"\u3002' },\n      snapshot_date: { label: '\u5FEB\u7167\u65E5\u671F', help: '\u672C\u6B21\u5FEB\u7167\u7684\u91C7\u96C6\u65E5\u671F\u3002' },\n      source: {\n        label: '\u6765\u6E90',\n        options: { scheduled: '\u5B9A\u65F6\u5FEB\u7167', ai: 'AI \u6280\u80FD', manual: '\u624B\u5DE5\u5F55\u5165' },\n      },\n      quota: { label: '\u914D\u989D' },\n      pipeline_amount: { label: '\u7BA1\u9053\u91D1\u989D', help: '\u672C\u5468\u671F\u5185\u6240\u6709\u9884\u8BA1\u7ED3\u5355\u7684\u8FDB\u884C\u4E2D\u5546\u673A\u91D1\u989D\u5408\u8BA1\uFF08\u4E0D\u9650\u9636\u6BB5\uFF09\u3002' },\n      best_case_amount: { label: '\u6700\u4F73\u60C5\u51B5', help: '\u9884\u6D4B\u7C7B\u522B\u4E3A\"\u6700\u4F73\u60C5\u51B5\"\u6216\"\u627F\u8BFA\"\u7684\u8FDB\u884C\u4E2D\u5546\u673A\u3002' },\n      commit_amount: { label: '\u627F\u8BFA\u91D1\u989D', help: '\u9884\u6D4B\u7C7B\u522B\u4E3A\"\u627F\u8BFA\"\u7684\u8FDB\u884C\u4E2D\u5546\u673A\uFF08\u8D1F\u8D23\u4EBA\u5DF2\u627F\u8BFA\uFF09\u3002' },\n      closed_amount: { label: '\u5DF2\u6210\u4EA4\u91D1\u989D', help: '\u672C\u5468\u671F\u5185\u5DF2\u8D62\u5355\u7684\u91D1\u989D\u3002' },\n      expected_amount: { label: '\u9884\u671F\u91D1\u989D', help: '\u5DF2\u6210\u4EA4 + \u627F\u8BFA\u2014\u2014\u8D1F\u8D23\u4EBA\u5408\u7406\u9884\u671F\u80FD\u62FF\u4E0B\u7684\u91D1\u989D\u3002' },\n      attainment_pct: { label: '\u8FBE\u6210\u7387\uFF08%\uFF09', help: '\u5DF2\u6210\u4EA4 \u00F7 \u914D\u989D \u00D7 100\u3002\u914D\u989D\u4E3A\u6B63\u6570\u4E4B\u524D\u663E\u793A 0%\u3002' },\n      coverage_ratio: { label: '\u8986\u76D6\u500D\u6570', help: '\u7BA1\u9053\u91D1\u989D \u00F7\uFF08\u914D\u989D \u2212 \u5DF2\u6210\u4EA4\uFF09\u2014\u2014\u5224\u65AD\u5269\u4F59\u7F3A\u53E3\u662F\u5426\u6709\u8DB3\u591F\u7BA1\u9053\u8986\u76D6\u3002\u914D\u989D\u5DF2\u8FBE\u6210\u65F6\u663E\u793A 0\u3002' },\n      notes: { label: '\u5907\u6CE8' },\n      display_title: { label: '\u663E\u793A\u540D\u79F0' },\n      seed_key: { label: '\u79CD\u5B50\u6807\u8BC6', help: '\u6F14\u793A\u6570\u636E\u6807\u8BC6\u3002\u4EC5\u7531\u79CD\u5B50\u52A0\u8F7D\u5668\u5199\u5165\uFF1B\u771F\u5B9E\u5FEB\u7167\u4E0A\u59CB\u7EC8\u4E3A\u7A7A\u3002' },\n    },\n    _views: {\n      all_forecasts: { label: '\u5168\u90E8\u9884\u6D4B' },\n      this_quarter_forecasts: {\n        label: '\u672C\u5B63\u5EA6',\n        emptyState: {\n          title: '\u672C\u5B63\u5EA6\u5C1A\u65E0\u5FEB\u7167',\n          message: '\u5B63\u5EA6\u5FEB\u7167\u7531\u6BCF\u665A\u7684\u9884\u6D4B\u626B\u63CF\u4EFB\u52A1\u5199\u5165\u3002\u5728\u5B83\u4E3A\u5F53\u524D\u5B63\u5EA6\u9996\u6B21\u8DD1\u5B8C\u4E4B\u524D\uFF0C\u672C\u89C6\u56FE\u4E3A\u7A7A\u2014\u2014\u5DF2\u7ED3\u675F\u7684\u5B63\u5EA6\u8BF7\u89C1\u201C\u5168\u90E8\u201D\u6807\u7B7E\u9875\u3002',\n        },\n      },\n      my_forecast: { label: '\u6211\u7684\u9884\u6D4B' },\n    },\n    _sections: {\n      basic: { label: '\u5FEB\u7167' },\n      amounts: { label: '\u91D1\u989D' },\n      meta: { label: '\u6765\u6E90' },\n      // forecast.view.ts \u8868\u5355\u533A\u5757\u540D\u79F0 (#1100)\n      snapshot: { label: '\u5FEB\u7167' },\n      notes: { label: '\u5907\u6CE8' },\n    },\n  },\n};\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/sales/translations/zh-CN/objects.commerce.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/sales/translations/zh-CN\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/sales/translations/zh-CN/objects.commerce.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport type { ObjectTranslationData } from '@objectstack/spec/system';\n\n/**\n * \u7B80\u4F53\u4E2D\u6587 (zh-CN) \u2014 `objects` translations for the COMMERCE family:\n * what gets sold and on what paper \u2014 quotes, contracts, products.\n *\n * Roster: `crm_quote`, `crm_quote_line_item`, `crm_contract`, `crm_product`.\n *\n * SPLIT AXIS (#1311): translation NAMESPACE first, then CRM DOMAIN FAMILY.\n * Everything that is not `objects` lives in `./app.ts`; `objects` \u2014 69-78% of\n * every bundle \u2014 is one file per CRM domain family, and a detail object\n * follows its master. A new row goes in the file for ITS family, never in\n * whichever file is already open: that is how one file re-grows past the 70%\n * advisory band `pnpm hygiene` prints. Full rule and rationale:\n * `src/sales/translations/zh-CN.ts`.\n */\nexport const commerce: Record<string, ObjectTranslationData> = {\n  crm_quote: {\n    _validations: {\n      discount_within_ceiling: {\n        message: '\u6298\u6263\u4E0D\u80FD\u8D85\u8FC7 60%',\n      },\n      expiration_after_quote: {\n        message: '\u5931\u6548\u65E5\u671F\u5FC5\u987B\u665A\u4E8E\u62A5\u4EF7\u65E5\u671F',\n      },\n      quote_status_progression: {\n        message: '\u65E0\u6548\u7684\u62A5\u4EF7\u5355\u72B6\u6001\u6D41\u8F6C',\n      },\n    },\n    label: '\u62A5\u4EF7\u5355',\n    pluralLabel: '\u62A5\u4EF7\u5355',\n    description: '\u53D1\u9001\u7ED9\u5BA2\u6237\u7684\u4EF7\u683C\u62A5\u4EF7',\n    fields: {\n      quote_number: { label: '\u62A5\u4EF7\u5355\u7F16\u53F7' },\n      name: { label: '\u62A5\u4EF7\u540D\u79F0' },\n      crm_account: { label: '\u6240\u5C5E\u5BA2\u6237' },\n      crm_opportunity: { label: '\u5173\u8054\u5546\u673A' },\n      status: {\n        label: '\u72B6\u6001',\n        options: {\n          draft: '\u8349\u7A3F', in_review: '\u5BA1\u6838\u4E2D', presented: '\u5DF2\u63D0\u4EA4', accepted: '\u5DF2\u63A5\u53D7',\n          rejected: '\u5DF2\u62D2\u7EDD', expired: '\u5DF2\u8FC7\u671F',\n        },\n      },\n      total_price: { label: '\u603B\u91D1\u989D' },\n      discount: { label: '\u6298\u6263 (%)' },\n      expiration_date: { label: '\u5230\u671F\u65E5\u671F' },\n      description: { label: '\u63CF\u8FF0' },\n      crm_contact: {\n        label: '\u8054\u7CFB\u4EBA',\n        help: '\u62A5\u4EF7\u8FDB\u5165\u300C\u5DF2\u63D0\u4EA4\u300D\u6216\u300C\u5DF2\u63A5\u53D7\u300D\u540E\u5FC5\u586B \u2014\u2014 \u8D77\u8349\u7684\u5408\u540C\u4ECE\u8FD9\u91CC\u53D6\u4E3B\u8981\u8054\u7CFB\u4EBA\u3002',\n      },\n      owner_id: { label: '\u62A5\u4EF7\u8D1F\u8D23\u4EBA' },\n      quote_date: { label: '\u62A5\u4EF7\u65E5\u671F' },\n      subtotal: { label: '\u5C0F\u8BA1' },\n      discount_amount: { label: '\u6298\u6263\u91D1\u989D' },\n      tax: { label: '\u7A0E\u989D' },\n      shipping_handling: { label: '\u8FD0\u8D39\u53CA\u624B\u7EED\u8D39' },\n      payment_terms: {\n        label: '\u4ED8\u6B3E\u6761\u6B3E',\n        options: {\n          net_15: '15 \u5929\u8D26\u671F', net_30: '30 \u5929\u8D26\u671F', net_60: '60 \u5929\u8D26\u671F',\n          net_90: '90 \u5929\u8D26\u671F', due_on_receipt: '\u8D27\u5230\u4ED8\u6B3E',\n        },\n      },\n      shipping_terms: { label: '\u8FD0\u8F93\u6761\u6B3E' },\n      billing_address: { label: '\u8D26\u5355\u5730\u5740' },\n      shipping_address: { label: '\u6536\u8D27\u5730\u5740' },\n      internal_notes: { label: '\u5185\u90E8\u5907\u6CE8' },\n      display_title: { label: '\u663E\u793A\u540D\u79F0' },\n    },\n    _views: {\n      all_quotes: { label: '\u5168\u90E8\u62A5\u4EF7\u5355' },\n      quote_pipeline: { label: '\u62A5\u4EF7\u6D41\u6C34\u7EBF' },\n      quote_calendar: { label: '\u62A5\u4EF7\u65E5\u5386' },\n    },\n    _sections: {\n      basic: { label: '\u62A5\u4EF7\u4FE1\u606F' },\n      pricing: { label: '\u4EF7\u683C' },\n      terms: { label: '\u6761\u6B3E\u4E0E\u6709\u6548\u671F' },\n      address: { label: '\u5730\u5740' },\n      system: { label: '\u7CFB\u7EDF' },\n      // quote.view.ts \u8868\u5355\u533A\u5757\u540D\u79F0 (#1100)\n      quote: { label: '\u62A5\u4EF7\u5355' },\n      totals: { label: '\u5408\u8BA1' },\n      quote_terms: { label: '\u6761\u6B3E' },\n      addresses_and_notes: { label: '\u5730\u5740\u4E0E\u5907\u6CE8' },\n    },\n  },\n  crm_quote_line_item: {\n    _validations: {\n      discount_within_ceiling: {\n        message: '\u884C\u6298\u6263\u4E0D\u80FD\u8D85\u8FC7 60%',\n      },\n      unit_price_positive: {\n        message: '\u9500\u552E\u4EF7\u683C\u4E0D\u80FD\u4E3A\u8D1F\u6570',\n      },\n    },\n    label: '\u62A5\u4EF7\u5355\u660E\u7EC6',\n    pluralLabel: '\u62A5\u4EF7\u5355\u660E\u7EC6',\n    description: '\u62A5\u4EF7\u5355\u4E0B\u6309\u4EA7\u54C1\u62C6\u5206\u7684\u62A5\u4EF7\u884C',\n    fields: {\n      crm_quote: { label: '\u5173\u8054\u62A5\u4EF7\u5355' },\n      crm_product: { label: '\u4EA7\u54C1' },\n      description: { label: '\u63CF\u8FF0' },\n      quantity: { label: '\u6570\u91CF' },\n      list_price: { label: '\u6807\u4EF7' },\n      unit_price: { label: '\u9500\u552E\u5355\u4EF7' },\n      discount: { label: '\u6298\u6263\uFF08%\uFF09' },\n      subtotal: { label: '\u5C0F\u8BA1' },\n      total_price: { label: '\u603B\u8BA1' },\n      line_number: { label: '\u884C\u53F7' },\n    },\n    _sections: {\n      basic: { label: '\u660E\u7EC6\u884C' },\n      pricing: { label: '\u4EF7\u683C' },\n    },\n  },\n  crm_contract: {\n    _validations: {\n      end_after_start: {\n        message: '\u7ED3\u675F\u65E5\u671F\u5FC5\u987B\u665A\u4E8E\u5F00\u59CB\u65E5\u671F',\n      },\n      contract_status_progression: {\n        message: '\u65E0\u6548\u7684\u5408\u540C\u72B6\u6001\u6D41\u8F6C',\n      },\n    },\n    label: '\u5408\u540C',\n    pluralLabel: '\u5408\u540C',\n    description: '\u4E0E\u5BA2\u6237\u7B7E\u7F72\u7684\u6CD5\u5F8B\u5408\u540C',\n    fields: {\n      contract_number: { label: '\u5408\u540C\u7F16\u53F7' },\n      crm_account: { label: '\u6240\u5C5E\u5BA2\u6237' },\n      status: {\n        label: '\u72B6\u6001',\n        options: {\n          draft: '\u8349\u7A3F', in_approval: '\u5BA1\u6279\u4E2D', activated: '\u5DF2\u6FC0\u6D3B',\n          expired: '\u5DF2\u8FC7\u671F', terminated: '\u5DF2\u7EC8\u6B62',\n        },\n      },\n      start_date: { label: '\u5F00\u59CB\u65E5\u671F' },\n      end_date: { label: '\u7ED3\u675F\u65E5\u671F' },\n      contract_value: { label: '\u5408\u540C\u91D1\u989D' },\n      description: { label: '\u63CF\u8FF0' },\n      crm_contact: { label: '\u4E3B\u8981\u8054\u7CFB\u4EBA' },\n      crm_opportunity: { label: '\u5173\u8054\u5546\u673A' },\n      owner_id: { label: '\u5408\u540C\u8D1F\u8D23\u4EBA' },\n      contract_term_months: { label: '\u5408\u540C\u671F\u9650\uFF08\u6708\uFF09' },\n      billing_frequency: {\n        label: '\u8BA1\u8D39\u5468\u671F',\n        options: { monthly: '\u6309\u6708', quarterly: '\u6309\u5B63\u5EA6', annually: '\u6309\u5E74', one_time: '\u4E00\u6B21\u6027' },\n      },\n      payment_terms: {\n        label: '\u4ED8\u6B3E\u6761\u6B3E',\n        options: {\n          net_15: '15 \u5929\u8D26\u671F', net_30: '30 \u5929\u8D26\u671F', net_60: '60 \u5929\u8D26\u671F',\n          net_90: '90 \u5929\u8D26\u671F', due_on_receipt: '\u8D27\u5230\u4ED8\u6B3E',\n        },\n      },\n      auto_renewal: { label: '\u81EA\u52A8\u7EED\u7EA6' },\n      renewal_notice_days: { label: '\u7EED\u7EA6\u901A\u77E5\uFF08\u5929\uFF09' },\n      contract_type: {\n        label: '\u5408\u540C\u7C7B\u578B',\n        options: {\n          subscription: '\u8BA2\u9605\u5408\u540C', service: '\u670D\u52A1\u534F\u8BAE', license: '\u6388\u6743\u8BB8\u53EF',\n          partnership: '\u5408\u4F5C\u534F\u8BAE', nda: '\u4FDD\u5BC6\u534F\u8BAE', msa: '\u4E3B\u670D\u52A1\u534F\u8BAE',\n        },\n      },\n      signed_date: { label: '\u7B7E\u7F72\u65E5\u671F' },\n      signed_by: { label: '\u7B7E\u7F72\u4EBA' },\n      document_url: { label: '\u5408\u540C\u6587\u6863' },\n      special_terms: { label: '\u7279\u6B8A\u6761\u6B3E' },\n      billing_address: { label: '\u8D26\u5355\u5730\u5740' },\n    },\n    _views: {\n      all_contracts: { label: '\u5168\u90E8\u5408\u540C' },\n      renewal_calendar: { label: '\u7EED\u7EA6\u65E5\u5386' },\n      contract_gantt: { label: '\u5408\u540C\u6761\u6B3E' },\n      contract_timeline: { label: '\u5408\u540C\u65F6\u95F4\u7EBF' },\n    },\n    _sections: {\n      basic: { label: '\u5408\u540C\u4FE1\u606F' },\n      parties: { label: '\u7B7E\u7EA6\u65B9' },\n      terms: { label: '\u6761\u6B3E\u4E0E\u65E5\u671F' },\n      value: { label: '\u5408\u540C\u91D1\u989D' },\n      status: { label: '\u72B6\u6001\u4E0E\u5BA1\u6279' },\n      renewal: { label: '\u7EED\u7EA6' },\n      // contract.view.ts \u8868\u5355\u533A\u5757\u540D\u79F0 (#1100)\n      contract_terms: { label: '\u6761\u6B3E' },\n      signing_and_documents: { label: '\u7B7E\u7F72\u4E0E\u6587\u4EF6' },\n      notes: { label: '\u5907\u6CE8' },\n    },\n  },\n  crm_product: {\n    _validations: {\n      cost_less_than_price: {\n        message: '\u6210\u672C\u5E94\u4F4E\u4E8E\u6807\u4EF7',\n      },\n      price_positive: {\n        message: '\u6807\u4EF7\u5FC5\u987B\u4E3A\u6B63\u6570',\n      },\n    },\n    label: '\u4EA7\u54C1',\n    pluralLabel: '\u4EA7\u54C1',\n    description: '\u516C\u53F8\u63D0\u4F9B\u7684\u4EA7\u54C1\u4E0E\u670D\u52A1',\n    fields: {\n      product_code: { label: '\u4EA7\u54C1\u4EE3\u7801' },\n      name: { label: '\u4EA7\u54C1\u540D\u79F0' },\n      category: {\n        label: '\u4EA7\u54C1\u7C7B\u522B',\n        options: {\n          software: '\u8F6F\u4EF6', hardware: '\u786C\u4EF6', service: '\u670D\u52A1',\n          subscription: '\u8BA2\u9605', support: '\u652F\u6301\u670D\u52A1',\n        },\n      },\n      cost: { label: '\u6210\u672C' },\n      is_active: { label: '\u662F\u5426\u542F\u7528' },\n      description: { label: '\u63CF\u8FF0' },\n      family: {\n        label: '\u4EA7\u54C1\u7CFB\u5217',\n        options: {\n          enterprise: '\u4F01\u4E1A\u7EA7\u65B9\u6848', smb: '\u4E2D\u5C0F\u4F01\u4E1A\u65B9\u6848',\n          services: '\u4E13\u4E1A\u670D\u52A1', cloud: '\u4E91\u670D\u52A1',\n        },\n      },\n      list_price: { label: '\u6807\u4EF7' },\n      sku: { label: 'SKU' },\n      product_manager: { label: '\u4EA7\u54C1\u7ECF\u7406' },\n      image: { label: '\u4EA7\u54C1\u56FE\u7247' },\n      datasheet: { label: '\u89C4\u683C\u4E66' },\n      display_title: { label: '\u663E\u793A\u540D\u79F0' },\n    },\n    _views: {\n      all_products: { label: '\u5168\u90E8\u4EA7\u54C1' },\n      product_catalog: { label: '\u4EA7\u54C1\u76EE\u5F55' },\n    },\n    _sections: {\n      basic: { label: '\u4EA7\u54C1\u4FE1\u606F' },\n      pricing: { label: '\u4EF7\u683C' },\n      metadata: { label: '\u8D44\u6E90' },\n      // product.view.ts \u8868\u5355\u533A\u5757\u540D\u79F0 (#1100)\n      product_info: { label: '\u4EA7\u54C1\u4FE1\u606F' },\n      pricing_info: { label: '\u5B9A\u4EF7' },\n      media: { label: '\u5A92\u4F53' },\n    },\n  },\n};\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/sales/translations/zh-CN/objects.service.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/sales/translations/zh-CN\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/sales/translations/zh-CN/objects.service.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport type { ObjectTranslationData } from '@objectstack/spec/system';\n\nimport { activityActions } from './_shared';\n\n/**\n * \u7B80\u4F53\u4E2D\u6587 (zh-CN) \u2014 `objects` translations for the SERVICE family:\n * post-sale support \u2014 cases and the knowledge that deflects them.\n *\n * Roster: `crm_case`, `crm_knowledge_article`, `crm_article_feedback`.\n *\n * SPLIT AXIS (#1311): translation NAMESPACE first, then CRM DOMAIN FAMILY.\n * Everything that is not `objects` lives in `./app.ts`; `objects` \u2014 69-78% of\n * every bundle \u2014 is one file per CRM domain family, and a detail object\n * follows its master. A new row goes in the file for ITS family, never in\n * whichever file is already open: that is how one file re-grows past the 70%\n * advisory band `pnpm hygiene` prints. Full rule and rationale:\n * `src/sales/translations/zh-CN.ts`.\n */\nexport const service: Record<string, ObjectTranslationData> = {\n  crm_case: {\n    _validations: {\n      resolution_required_for_closed: {\n        message: '\u5173\u95ED\u5DE5\u5355\u65F6\u5FC5\u987B\u586B\u5199\u89E3\u51B3\u65B9\u6848',\n      },\n      escalation_reason_required: {\n        message: '\u5347\u7EA7\u5DE5\u5355\u65F6\u5FC5\u987B\u586B\u5199\u5347\u7EA7\u539F\u56E0',\n      },\n      case_status_progression: {\n        message: '\u65E0\u6548\u7684\u72B6\u6001\u6D41\u8F6C',\n      },\n    },\n    label: '\u5DE5\u5355',\n    pluralLabel: '\u5DE5\u5355',\n    description: '\u5BA2\u6237\u652F\u6301\u5DE5\u5355\u4E0E\u670D\u52A1\u8BF7\u6C42',\n    fields: {\n      case_number: { label: '\u5DE5\u5355\u7F16\u53F7' },\n      subject: { label: '\u4E3B\u9898' },\n      description: { label: '\u63CF\u8FF0' },\n      crm_account: { label: '\u6240\u5C5E\u5BA2\u6237' },\n      crm_contact: { label: '\u8054\u7CFB\u4EBA' },\n      status: {\n        label: '\u72B6\u6001',\n        options: {\n          new: '\u65B0\u5EFA', in_progress: '\u5904\u7406\u4E2D',\n          waiting_customer: '\u7B49\u5F85\u5BA2\u6237\u56DE\u590D', waiting_support: '\u7B49\u5F85\u652F\u6301\u56DE\u590D',\n          escalated: '\u5DF2\u5347\u7EA7', resolved: '\u5DF2\u89E3\u51B3', closed: '\u5DF2\u5173\u95ED',\n        },\n      },\n      priority: {\n        // `critical` MUST NOT render \u7D27\u6025 \u2014 that word belongs to\n        // `crm_task.priority.urgent`, and the two vocabularies are different\n        // sets (case: low/medium/high/critical \u00B7 task: low/normal/high/urgent).\n        // When both rendered \u7D27\u6025 the screen showed one word for two values the\n        // model treats as distinct, which is how a case value ends up in a task\n        // predicate (`src/sales/views/task.view.ts` carries the tombstone of that\n        // crossing). Maintainer ruling 2026-08-31, #1342: case `critical` is\n        // \u4E25\u91CD, task `urgent` keeps \u7D27\u6025. en/es-ES/ja-JP already separate them\n        // (Critical/Urgent \u00B7 Cr\u00EDtica/Urgente \u00B7 \u91CD\u5927/\u7DCA\u6025); zh-CN was the outlier.\n        label: '\u4F18\u5148\u7EA7',\n        options: { low: '\u4F4E', medium: '\u4E2D', high: '\u9AD8', critical: '\u4E25\u91CD' },\n      },\n      type: {\n        label: '\u7C7B\u578B',\n        options: {\n          question: '\u54A8\u8BE2', problem: '\u6545\u969C', feature_request: '\u529F\u80FD\u9700\u6C42', bug: '\u7F3A\u9677',\n        },\n      },\n      owner_id: { label: '\u8D1F\u8D23\u4EBA' },\n      origin: {\n        label: '\u5DE5\u5355\u6765\u6E90',\n        options: { email: '\u90AE\u4EF6', phone: '\u7535\u8BDD', web: '\u7F51\u7AD9', chat: '\u5728\u7EBF\u5BA2\u670D', social_media: '\u793E\u4EA4\u5A92\u4F53' },\n      },\n      closed_date: { label: '\u5173\u95ED\u65E5\u671F' },\n      first_response_date: { label: '\u9996\u6B21\u54CD\u5E94\u65E5\u671F' },\n      resolution_time_hours: { label: '\u89E3\u51B3\u8017\u65F6\uFF08\u5C0F\u65F6\uFF09' },\n      sla_due_date: { label: 'SLA \u5230\u671F', help: '\u6309\u5DE5\u5355\u4F18\u5148\u7EA7\u4E0E\u6240\u5C5E\u5BA2\u6237\u7684\u5BA2\u6237\u5206\u5C42\u8BBE\u5B9A\uFF0C\u4EE5\u65E5\u5386\u5C0F\u65F6\u8BA1\uFF1A\u591C\u95F4\u3001\u5468\u672B\u4E0E\u8282\u5047\u65E5\u90FD\u8BA1\u5165\u3002' },\n      is_sla_violated: { label: 'SLA \u8FDD\u53CD' },\n      is_escalated: { label: '\u5DF2\u5347\u7EA7' },\n      escalation_reason: { label: '\u5347\u7EA7\u539F\u56E0' },\n      resolution: { label: '\u89E3\u51B3\u65B9\u6848' },\n      resolved_by_article: { label: '\u89E3\u51B3\u8BE5\u5DE5\u5355\u7684\u77E5\u8BC6\u6587\u7AE0', help: '\u89E3\u51B3\u6B64\u5DE5\u5355\u7684\u77E5\u8BC6\u5E93\u6587\u7AE0 \u2014\u2014 \u8F6C\u79FB\u7387\u7684\u7EDF\u8BA1\u53E3\u5F84\u3002' },\n      internal_notes: { label: '\u5185\u90E8\u5907\u6CE8', help: '\u5185\u90E8\u5907\u6CE8\uFF0C\u5BA2\u6237\u4E0D\u53EF\u89C1' },\n      is_closed: { label: '\u662F\u5426\u5173\u95ED' },\n      display_title: { label: '\u663E\u793A\u540D\u79F0' },\n      priority_rank: { label: '\u4F18\u5148\u7EA7\u6392\u5E8F' },\n      escalated_date: { label: '\u5347\u7EA7\u65E5\u671F' },\n    },\n    _views: {\n      all_cases: { label: '\u5168\u90E8\u5DE5\u5355' },\n      case_workflow: { label: '\u670D\u52A1\u6D41\u8F6C' },\n      sla_calendar: { label: 'SLA \u65E5\u5386' },\n      case_timeline: { label: '\u5DE5\u5355\u65F6\u95F4\u7EBF' },\n      unassigned_triage: {\n        label: '\u672A\u5206\u6D3E \u2014 \u5F85\u5206\u8BCA',\n        emptyState: {\n          title: '\u6CA1\u6709\u5F85\u5206\u8BCA\u7684\u5DE5\u5355',\n          message: '\u6240\u6709\u5DE5\u5355\u90FD\u6709\u8D1F\u8D23\u4EBA\u3002\u5F53\u5DE5\u5355\u5230\u8FBE\u65F6\u6CA1\u6709\u8D1F\u8D23\u4EBA\uFF0C\u5C31\u4F1A\u51FA\u73B0\u5728\u8FD9\u91CC \u2014\u2014 \u901A\u5E38\u662F\u5728\u65E0\u4EBA\u62C5\u4EFB\u300C\u5BA2\u670D\u4E13\u5458\u300D\u804C\u4F4D\u671F\u95F4\u63D0\u4EA4\u7684\u7F51\u9875\u8F6C\u5DE5\u5355\u3002',\n        },\n      },\n      escalated_cases: { label: '\u5DF2\u5347\u7EA7\u5DE5\u5355' },\n      my_open_cases: { label: '\u6211\u7684\u5F85\u5904\u7406\u5DE5\u5355' },\n      sla_at_risk: { label: '\u23F0 SLA \u98CE\u9669\u9884\u8B66' },\n    },\n    _actions: {\n      ...activityActions,\n      escalate_case: {\n        label: '\u5347\u7EA7\u5DE5\u5355',\n        confirmText: '\u6B64\u64CD\u4F5C\u4F1A\u5C06\u5DE5\u5355\u5347\u7EA7\u5230\u5347\u7EA7\u5904\u7406\u56E2\u961F\uFF0C\u662F\u5426\u7EE7\u7EED\uFF1F',\n        successMessage: '\u5DE5\u5355\u5347\u7EA7\u6210\u529F\uFF01',\n      },\n      close_case: {\n        label: '\u5173\u95ED\u5DE5\u5355',\n        confirmText: '\u786E\u5B9A\u8981\u5173\u95ED\u6B64\u5DE5\u5355\u5417\uFF1F',\n        successMessage: '\u5DE5\u5355\u5DF2\u6210\u529F\u5173\u95ED\uFF01',\n      },\n      claim_case: {\n        label: '\u8BA4\u9886\u5DE5\u5355',\n        successMessage: '\u5DE5\u5355\u5DF2\u8BA4\u9886\uFF0C\u73B0\u5728\u5F52\u4F60\u8D1F\u8D23\u3002',\n      },\n    },\n    _sections: {\n      // case.view.ts \u8868\u5355\u533A\u5757\u540D\u79F0 (#1100)\u3002\n      case: { label: '\u5DE5\u5355' },\n      how_can_we_help: { label: '\u6211\u4EEC\u80FD\u5E2E\u60A8\u4EC0\u4E48\uFF1F' },\n      // Object-level section keys (case.object.ts), used by record forms and\n      // by the detail page, whose sections reference these groups (#970)\n      basic: { label: '\u5DE5\u5355\u4FE1\u606F' },\n      origin: { label: '\u6765\u6E90\u4E0E\u8DEF\u7531' },\n      sla: { label: 'SLA \u4E0E\u4F18\u5148\u7EA7' },\n      resolution: { label: '\u89E3\u51B3\u65B9\u6848' },\n      escalation: { label: '\u5347\u7EA7' },\n      system: { label: '\u7CFB\u7EDF' },\n    },\n  },\n  crm_knowledge_article: {\n    _validations: {\n      published_requires_body: {\n        message: '\u6CA1\u6709\u6B63\u6587\u7684\u6587\u7AE0\u65E0\u6CD5\u53D1\u5E03\u3002',\n      },\n      published_requires_summary: {\n        message: '\u5DF2\u53D1\u5E03\u7684\u6587\u7AE0\u5E94\u586B\u5199\u6458\u8981\uFF0C\u4F9B\u641C\u7D22\u7ED3\u679C\u4E0E AI \u5F15\u7528\u4F7F\u7528\u3002',\n      },\n    },\n    label: '\u77E5\u8BC6\u6587\u7AE0',\n    pluralLabel: '\u77E5\u8BC6\u5E93',\n    description: '\u9762\u5411\u5BA2\u6237\u548C\u5750\u5E2D\u7684\u53EF\u590D\u7528\u95EE\u7B54\u4E0E\u64CD\u4F5C\u6307\u5357',\n    fields: {\n      article_number: { label: '\u6587\u7AE0\u7F16\u53F7' },\n      title: { label: '\u6807\u9898' },\n      summary: { label: '\u6458\u8981', help: '\u4E00\u6BB5\u8BDD\u6458\u8981\uFF0C\u663E\u793A\u5728\u641C\u7D22\u7ED3\u679C\u548C AI \u5F15\u7528\u4E2D\u3002' },\n      body: { label: '\u6B63\u6587', help: '\u6587\u7AE0\u6B63\u6587\uFF08Markdown\uFF09\u3002' },\n      category: {\n        label: '\u5206\u7C7B',\n        options: {\n          getting_started: '\u5165\u95E8\u6307\u5357', how_to: '\u64CD\u4F5C\u6307\u5357',\n          troubleshooting: '\u6545\u969C\u6392\u67E5', billing: '\u8D26\u52A1\u4E0E\u4EF7\u683C', api: 'API \u4E0E\u96C6\u6210',\n          release_notes: '\u7248\u672C\u8BF4\u660E',\n          policy: '\u653F\u7B56\u5236\u5EA6',\n        },\n      },\n      tags: {\n        label: '\u6807\u7B7E',\n        options: {\n          auth: '\u8EAB\u4EFD\u8BA4\u8BC1', sso: '\u5355\u70B9\u767B\u5F55', mobile: '\u79FB\u52A8\u7AEF', email: '\u90AE\u4EF6',\n          reports: '\u62A5\u8868', performance: '\u6027\u80FD', data_import: '\u6570\u636E\u5BFC\u5165', webhooks: 'Webhook',\n        },\n      },\n      status: {\n        label: '\u72B6\u6001',\n        options: { draft: '\u8349\u7A3F', in_review: '\u5BA1\u6838\u4E2D', published: '\u5DF2\u53D1\u5E03', archived: '\u5DF2\u5F52\u6863' },\n      },\n      audience: { label: '\u53D7\u4F17', options: { public: '\u516C\u5F00', internal: '\u4EC5\u5185\u90E8' }, help: '\u516C\u5F00\u6587\u7AE0\u5728\u5BA2\u6237\u95E8\u6237\u53EF\u89C1\uFF1B\u5185\u90E8\u6587\u7AE0\u4EC5\u5BA2\u670D\u53EF\u89C1\u3002' },\n      language: {\n        label: '\u8BED\u8A00',\n        options: { en: '\u82F1\u8BED', zh_cn: '\u7B80\u4F53\u4E2D\u6587', es_es: '\u897F\u73ED\u7259\u8BED', ja_jp: '\u65E5\u8BED' },\n      },\n      owner_id: { label: '\u8D1F\u8D23\u4EBA' },\n      related_to_case: { label: '\u6765\u6E90\u5DE5\u5355', help: '\u672C\u6587\u6240\u4F9D\u636E\u7684\u5DE5\u5355\uFF08\u53EF\u9009\uFF09\u3002' },\n      published_at: { label: '\u53D1\u5E03\u65F6\u95F4' },\n      last_reviewed_at: { label: '\u6700\u8FD1\u590D\u6838' },\n      helpful_count: { label: '\u6709\u7528', help: '\u7531 crm_article_feedback \u91CD\u65B0\u7EDF\u8BA1\u5F97\u51FA\uFF0C\u4E0D\u53EF\u624B\u5DE5\u586B\u5199\u3002' },\n      not_helpful_count: { label: '\u6CA1\u7528', help: '\u7531 crm_article_feedback \u91CD\u65B0\u7EDF\u8BA1\u5F97\u51FA\uFF0C\u4E0D\u53EF\u624B\u5DE5\u586B\u5199\u3002' },\n      display_title: { label: '\u663E\u793A\u540D\u79F0' },\n    },\n    _views: {\n      all_articles: { label: '\u5168\u90E8\u6587\u7AE0' },\n      published_articles: { label: '\u5DF2\u53D1\u5E03' },\n      my_drafts: { label: '\u6211\u7684\u8349\u7A3F' },\n    },\n    _sections: {\n      basic: { label: '\u6587\u7AE0\u4FE1\u606F' },\n      content: { label: '\u5185\u5BB9' },\n      taxonomy: { label: '\u5206\u7C7B' },\n      metrics: { label: '\u4E92\u52A8\u6570\u636E' },\n      engagement: { label: '\u4E92\u52A8\u6570\u636E' },\n      // knowledge_article.view.ts \u8868\u5355\u533A\u5757\u540D\u79F0 (#1100)\n      article: { label: '\u6587\u7AE0' },\n    },\n    _actions: {\n      mark_article_helpful: {\n        label: '\u6709\u7528',\n        successMessage: '\u5DF2\u8BB0\u5F55\u4E3A\u300C\u6709\u7528\u300D\uFF0C\u8C22\u8C22\u53CD\u9988\u3002',\n      },\n      mark_article_not_helpful: {\n        label: '\u6CA1\u7528',\n        successMessage: '\u5DF2\u8BB0\u5F55\u4E3A\u300C\u6CA1\u7528\u300D\uFF0C\u8C22\u8C22\u53CD\u9988\u3002',\n      },\n    },\n  },\n  crm_article_feedback: {\n    label: '\u6587\u7AE0\u53CD\u9988',\n    pluralLabel: '\u6587\u7AE0\u53CD\u9988',\n    description: '\u8BFB\u8005\u5BF9\u67D0\u7BC7\u77E5\u8BC6\u6587\u7AE0\u7684\u300C\u6709\u7528 / \u6CA1\u7528\u300D\u8BC4\u4EF7',\n    fields: {\n      feedback_number: { label: '\u53CD\u9988\u7F16\u53F7' },\n      owner_id: { label: '\u8BFB\u8005' },\n      crm_knowledge_article: { label: '\u6587\u7AE0', help: '\u672C\u6761\u53CD\u9988\u9488\u5BF9\u7684\u77E5\u8BC6\u6587\u7AE0\u3002' },\n      verdict: {\n        label: '\u8BC4\u4EF7',\n        options: { helpful: '\u6709\u7528', not_helpful: '\u6CA1\u7528' },\n      },\n      comment: { label: '\u5907\u6CE8', help: '\u53EF\u9009\u8BF4\u660E\uFF0C\u4F5C\u8005\u53EF\u89C1\u3002' },\n    },\n    _sections: {\n      basic: { label: '\u53CD\u9988' },\n    },\n  },\n};\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/sales/translations/zh-CN/objects.activity.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/sales/translations/zh-CN\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/sales/translations/zh-CN/objects.activity.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport type { ObjectTranslationData } from '@objectstack/spec/system';\n\n/**\n * \u7B80\u4F53\u4E2D\u6587 (zh-CN) \u2014 `objects` translations for the ACTIVITY family:\n * the interaction log \u2014 tasks, events, and who attended.\n *\n * Roster: `crm_task`, `crm_event`, `crm_event_attendee`.\n *\n * SPLIT AXIS (#1311): translation NAMESPACE first, then CRM DOMAIN FAMILY.\n * Everything that is not `objects` lives in `./app.ts`; `objects` \u2014 69-78% of\n * every bundle \u2014 is one file per CRM domain family, and a detail object\n * follows its master. A new row goes in the file for ITS family, never in\n * whichever file is already open: that is how one file re-grows past the 70%\n * advisory band `pnpm hygiene` prints. Full rule and rationale:\n * `src/sales/translations/zh-CN.ts`.\n */\nexport const activity: Record<string, ObjectTranslationData> = {\n  crm_task: {\n    _validations: {\n      completed_date_required: {\n        message: '\u72B6\u6001\u4E3A\u5DF2\u5B8C\u6210\u65F6\u5FC5\u987B\u586B\u5199\u5B8C\u6210\u65E5\u671F',\n      },\n      recurrence_fields_required: {\n        message: '\u91CD\u590D\u4EFB\u52A1\u5FC5\u987B\u586B\u5199\u91CD\u590D\u7C7B\u578B',\n      },\n      related_to_required: {\n        message: '\u81F3\u5C11\u9700\u8981\u9009\u62E9\u4E00\u6761\u5173\u8054\u8BB0\u5F55',\n      },\n    },\n    label: '\u4EFB\u52A1',\n    pluralLabel: '\u4EFB\u52A1',\n    description: '\u6D3B\u52A8\u4E0E\u5F85\u529E\u4E8B\u9879',\n    fields: {\n      subject: { label: '\u4E3B\u9898' },\n      description: { label: '\u63CF\u8FF0' },\n      status: {\n        label: '\u72B6\u6001',\n        options: {\n          not_started: '\u672A\u5F00\u59CB', in_progress: '\u8FDB\u884C\u4E2D', waiting: '\u7B49\u5F85\u4E2D',\n          completed: '\u5DF2\u5B8C\u6210', deferred: '\u5DF2\u63A8\u8FDF',\n        },\n      },\n      priority: {\n        // `urgent` KEEPS \u7D27\u6025, and \u26D4 nothing may re-point it at `crm_case`'s\n        // top value: the two vocabularies are different sets (task:\n        // low/normal/high/urgent \u00B7 case: low/medium/high/critical), so the two\n        // zh-CN words must stay different or the screen stops distinguishing\n        // two values the model treats as distinct \u2014 the crossing\n        // `src/sales/views/task.view.ts` carries the tombstone of. Maintainer ruling\n        // 2026-08-31, #1342: \u7D27\u6025 stays here (urgent is this object's literal\n        // word) and case `critical` moved to \u4E25\u91CD.\n        label: '\u4F18\u5148\u7EA7',\n        options: { low: '\u4F4E', normal: '\u666E\u901A', high: '\u9AD8', urgent: '\u7D27\u6025' },\n      },\n      due_date: { label: '\u622A\u6B62\u65E5\u671F' },\n      type: {\n        label: '\u4EFB\u52A1\u7C7B\u578B',\n        options: {\n          call: '\u7535\u8BDD', email: '\u90AE\u4EF6', meeting: '\u4F1A\u8BAE',\n          follow_up: '\u8DDF\u8FDB', demo: '\u6F14\u793A', other: '\u5176\u4ED6',\n        },\n      },\n      reminder_date: { label: '\u63D0\u9192\u65F6\u95F4' },\n      completed_date: { label: '\u5B8C\u6210\u65E5\u671F' },\n      owner_id: { label: '\u8D1F\u8D23\u4EBA' },\n      related_to_type: {\n        label: '\u5173\u8054\u5BF9\u8C61\u7C7B\u578B',\n        options: {\n          crm_account: '\u5BA2\u6237', crm_contact: '\u8054\u7CFB\u4EBA', crm_opportunity: '\u5546\u673A',\n          crm_lead: '\u7EBF\u7D22', crm_case: '\u5DE5\u5355',\n        },\n      },\n      related_to_account: { label: '\u5173\u8054\u5BA2\u6237' },\n      related_to_contact: { label: '\u5173\u8054\u8054\u7CFB\u4EBA' },\n      related_to_opportunity: { label: '\u5173\u8054\u5546\u673A' },\n      related_to_lead: { label: '\u5173\u8054\u7EBF\u7D22' },\n      related_to_case: { label: '\u5173\u8054\u5DE5\u5355' },\n      is_recurring: { label: '\u91CD\u590D\u4EFB\u52A1' },\n      recurrence_type: {\n        label: '\u91CD\u590D\u7C7B\u578B',\n        options: { daily: '\u6BCF\u65E5', weekly: '\u6BCF\u5468', monthly: '\u6BCF\u6708', yearly: '\u6BCF\u5E74' },\n      },\n      recurrence_interval: { label: '\u91CD\u590D\u95F4\u9694' },\n      recurrence_end_date: { label: '\u91CD\u590D\u7ED3\u675F\u65E5\u671F' },\n      is_completed: { label: '\u662F\u5426\u5B8C\u6210' },\n      is_overdue: { label: '\u662F\u5426\u903E\u671F' },\n      progress_percent: { label: '\u8FDB\u5EA6\uFF08%\uFF09' },\n      priority_rank: { label: '\u4F18\u5148\u7EA7\u6392\u5E8F' },\n      reminder_sent: { label: '\u63D0\u9192\u5DF2\u53D1\u9001' },\n    },\n    _sections: {\n      basic: { label: '\u4EFB\u52A1\u4FE1\u606F' },\n      scheduling: { label: '\u65E5\u7A0B\u5B89\u6392' },\n      related: { label: '\u5173\u8054\u8BB0\u5F55' },\n      recurrence: { label: '\u91CD\u590D\u89C4\u5219' },\n      system: { label: '\u7CFB\u7EDF' },\n      effort: { label: '\u8FDB\u5EA6\u4E0E\u5DE5\u65F6' },\n      // task.view.ts \u8868\u5355\u533A\u5757\u540D\u79F0 (#1100)\n      task: { label: '\u4EFB\u52A1' },\n      related_records: { label: '\u5173\u8054\u8BB0\u5F55' },\n      recurrence_and_effort: { label: '\u91CD\u590D\u4E0E\u5DE5\u65F6' },\n    },\n    _views: {\n      all_tasks: { label: '\u5168\u90E8\u4EFB\u52A1' },\n      task_board: { label: '\u4EFB\u52A1\u770B\u677F' },\n      task_calendar: { label: '\u4EFB\u52A1\u65E5\u7A0B' },\n      task_gantt: { label: '\u6267\u884C\u8BA1\u5212' },\n      task_timeline: { label: '\u5DE5\u65F6\u65F6\u95F4\u7EBF' },\n      my_open_tasks: { label: '\u6211\u7684\u5F85\u529E\u4EFB\u52A1' },\n      todays_tasks: { label: '\uD83D\uDCC5 \u6211\u7684\u4F18\u5148\u4EFB\u52A1' },\n      overdue_tasks: { label: '\u23F0 \u5F85\u529E\u4EFB\u52A1 \u00B7 \u6309\u903E\u671F\u65F6\u957F\u6392\u5E8F' },\n    },\n  },\n  crm_event: {\n    _validations: {\n      end_after_start: {\n        message: '\u7ED3\u675F\u65F6\u95F4\u5FC5\u987B\u665A\u4E8E\u5F00\u59CB\u65F6\u95F4',\n      },\n      related_to_required: {\n        message: '\u81F3\u5C11\u9700\u8981\u9009\u62E9\u4E00\u6761\u5173\u8054\u8BB0\u5F55',\n      },\n    },\n    label: '\u6D3B\u52A8',\n    pluralLabel: '\u6D3B\u52A8',\n    description: '\u4E0E\u5BA2\u6237\u7684\u4F1A\u8BAE\u3001\u901A\u8BDD\u53CA\u5176\u4ED6\u5DF2\u5B89\u6392\u7684\u4E92\u52A8',\n    fields: {\n      subject: { label: '\u4E3B\u9898' },\n      description: { label: '\u63CF\u8FF0' },\n      type: {\n        label: '\u6D3B\u52A8\u7C7B\u578B',\n        options: {\n          meeting: '\u4F1A\u8BAE', call: '\u7535\u8BDD', demo: '\u6F14\u793A',\n          webinar: '\u7EBF\u4E0A\u7814\u8BA8\u4F1A', onsite_visit: '\u4E0A\u95E8\u62DC\u8BBF', other: '\u5176\u4ED6',\n        },\n      },\n      status: {\n        label: '\u72B6\u6001',\n        options: {\n          planned: '\u5DF2\u8BA1\u5212', held: '\u5DF2\u4E3E\u884C', cancelled: '\u5DF2\u53D6\u6D88', no_show: '\u5BA2\u6237\u672A\u5230',\n        },\n      },\n      owner_id: { label: '\u8D1F\u8D23\u4EBA' },\n      start_datetime: { label: '\u5F00\u59CB\u65F6\u95F4' },\n      end_datetime: { label: '\u7ED3\u675F\u65F6\u95F4' },\n      all_day: { label: '\u5168\u5929\u6D3B\u52A8' },\n      duration_minutes: { label: '\u65F6\u957F\uFF08\u5206\u949F\uFF09' },\n      location: { label: '\u5730\u70B9', help: '\u4F1A\u8BAE\u5BA4\u3001\u5730\u5740\u6216\u4F1A\u8BAE\u94FE\u63A5' },\n      related_to_type: {\n        label: '\u5173\u8054\u5BF9\u8C61\u7C7B\u578B',\n        options: {\n          crm_account: '\u5BA2\u6237', crm_contact: '\u8054\u7CFB\u4EBA', crm_opportunity: '\u5546\u673A',\n          crm_lead: '\u7EBF\u7D22', crm_case: '\u5DE5\u5355',\n        },\n      },\n      related_to_account: { label: '\u5173\u8054\u5BA2\u6237' },\n      related_to_contact: { label: '\u5173\u8054\u8054\u7CFB\u4EBA' },\n      related_to_opportunity: { label: '\u5173\u8054\u5546\u673A' },\n      related_to_lead: { label: '\u5173\u8054\u7EBF\u7D22' },\n      related_to_case: { label: '\u5173\u8054\u5DE5\u5355' },\n      outcome_notes: { label: '\u4F1A\u540E\u7EAA\u8981', help: '\u8FBE\u6210\u4E86\u4EC0\u4E48\u5171\u8BC6\uFF0C\u4E0B\u4E00\u6B65\u505A\u4EC0\u4E48' },\n    },\n    _sections: {\n      basic: { label: '\u6D3B\u52A8\u4FE1\u606F' },\n      schedule: { label: '\u65E5\u7A0B\u5B89\u6392' },\n      related: { label: '\u5173\u8054\u8BB0\u5F55' },\n      outcome: { label: '\u7ED3\u679C' },\n      // event.view.ts \u8868\u5355\u533A\u5757\u540D\u79F0 (#1100)\n      event: { label: '\u6D3B\u52A8' },\n      related_records: { label: '\u5173\u8054\u8BB0\u5F55' },\n    },\n    _views: {\n      all_events: { label: '\u5168\u90E8\u6D3B\u52A8' },\n      event_calendar: { label: '\u6D3B\u52A8\u65E5\u5386' },\n      event_timeline: { label: '\u56E2\u961F\u65E5\u7A0B' },\n      my_events: { label: '\u6211\u7684\u65E5\u5386' },\n      upcoming_events: { label: '\uD83D\uDCC5 \u5373\u5C06\u5F00\u59CB \u00B7 \u6309\u65F6\u95F4\u5347\u5E8F' },\n      held_events: { label: '\u2705 \u4E92\u52A8\u5386\u53F2' },\n    },\n  },\n  crm_event_attendee: {\n    _validations: {\n      attendee_resolves: {\n        message: '\u53C2\u4E0E\u8005\u5FC5\u987B\u586B\u5199\u5176\u53C2\u4E0E\u8005\u7C7B\u578B\u6240\u6307\u7684\u4E00\u65B9\u2014\u2014\u8054\u7CFB\u4EBA\u7C7B\u578B\u9700\u8981\u586B\u5199\u8054\u7CFB\u4EBA\uFF0C\u5916\u90E8\u7C7B\u578B\u9700\u8981\u586B\u5199\u5916\u90E8\u53C2\u4E0E\u8005\u59D3\u540D',\n      },\n      attendee_type_exclusive: {\n        message: '\u53C2\u4E0E\u8005\u53EA\u80FD\u6307\u5B9A\u4E00\u65B9\u2014\u2014\u8BF7\u6E05\u7A7A\u5176\u53C2\u4E0E\u8005\u7C7B\u578B\u672A\u6307\u660E\u7684\u6240\u6709\u5B57\u6BB5',\n      },\n    },\n    label: '\u6D3B\u52A8\u53C2\u4E0E\u8005',\n    pluralLabel: '\u6D3B\u52A8\u53C2\u4E0E\u8005',\n    description: '\u53D7\u9080\u53C2\u52A0\u6216\u5B9E\u9645\u51FA\u5E2D\u6D3B\u52A8\u7684\u4EBA\u5458',\n    fields: {\n      attendee_number: { label: '\u53C2\u4E0E\u8005\u7F16\u53F7' },\n      crm_event: { label: '\u6D3B\u52A8' },\n      attendee_type: {\n        label: '\u53C2\u4E0E\u8005\u7C7B\u578B',\n        options: { contact: '\u8054\u7CFB\u4EBA', lead: '\u7EBF\u7D22', user: '\u5185\u90E8\u7528\u6237', external: '\u5916\u90E8\u6765\u5BBE' },\n      },\n      crm_contact: { label: '\u8054\u7CFB\u4EBA', help: '\u53C2\u4E0E\u8005\u662F\u5DF2\u6709\u5BA2\u6237\u8054\u7CFB\u4EBA\u65F6\u586B\u5199' },\n      crm_lead: { label: '\u7EBF\u7D22', help: '\u53C2\u4E0E\u8005\u4ECD\u662F\u672A\u8F6C\u5316\u7EBF\u7D22\u65F6\u586B\u5199' },\n      sys_user: { label: '\u5185\u90E8\u7528\u6237', help: '\u53C2\u4E0E\u8005\u662F\u540C\u4E8B\u65F6\u586B\u5199' },\n      external_name: { label: '\u5916\u90E8\u53C2\u4E0E\u8005', help: '\u4E0D\u5728\u4EFB\u4F55 CRM \u5BF9\u8C61\u4E2D\u7684\u53C2\u4E0E\u8005\u59D3\u540D\u2014\u2014\u53C2\u4E0E\u8005\u7C7B\u578B\u4E3A\u300C\u5916\u90E8\u6765\u5BBE\u300D\u65F6\u586B\u5199' },\n      response: {\n        label: '\u56DE\u590D',\n        options: {\n          no_response: '\u672A\u56DE\u590D', accepted: '\u5DF2\u63A5\u53D7',\n          declined: '\u5DF2\u62D2\u7EDD', tentative: '\u5F85\u5B9A',\n        },\n      },\n      is_organizer: { label: '\u7EC4\u7EC7\u8005' },\n      invited_date: { label: '\u9080\u8BF7\u65F6\u95F4' },\n    },\n    _sections: {\n      basic: { label: '\u53C2\u4E0E\u8005' },\n      response: { label: '\u9080\u8BF7' },\n      // event_attendee.view.ts \u8868\u5355\u533A\u5757\u540D\u79F0 (#1100)\n      attendee: { label: '\u53C2\u4E0E\u8005' },\n      invitation: { label: '\u9080\u8BF7' },\n    },\n    _views: {\n      all_event_attendees: { label: '\u6D3B\u52A8\u53C2\u4E0E\u8005' },\n    },\n  },\n};\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/sales/translations/zh-CN/objects.marketing.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/sales/translations/zh-CN\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/sales/translations/zh-CN/objects.marketing.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport type { ObjectTranslationData } from '@objectstack/spec/system';\n\n/**\n * \u7B80\u4F53\u4E2D\u6587 (zh-CN) \u2014 `objects` translations for the MARKETING family:\n * demand generation \u2014 campaigns and their membership.\n *\n * Roster: `crm_campaign`, `crm_campaign_member`.\n *\n * SPLIT AXIS (#1311): translation NAMESPACE first, then CRM DOMAIN FAMILY.\n * Everything that is not `objects` lives in `./app.ts`; `objects` \u2014 69-78% of\n * every bundle \u2014 is one file per CRM domain family, and a detail object\n * follows its master. A new row goes in the file for ITS family, never in\n * whichever file is already open: that is how one file re-grows past the 70%\n * advisory band `pnpm hygiene` prints. Full rule and rationale:\n * `src/sales/translations/zh-CN.ts`.\n */\nexport const marketing: Record<string, ObjectTranslationData> = {\n  crm_campaign: {\n    _validations: {\n      end_after_start: {\n        message: '\u7ED3\u675F\u65E5\u671F\u5FC5\u987B\u665A\u4E8E\u5F00\u59CB\u65E5\u671F',\n      },\n      actual_cost_within_budget: {\n        message: '\u5B9E\u9645\u6210\u672C\u8D85\u51FA\u9884\u7B97\u6210\u672C',\n      },\n    },\n    label: '\u8425\u9500\u6D3B\u52A8',\n    pluralLabel: '\u8425\u9500\u6D3B\u52A8',\n    description: '\u5E02\u573A\u8425\u9500\u6D3B\u52A8\u4E0E\u63A8\u5E7F',\n    fields: {\n      campaign_code: { label: '\u6D3B\u52A8\u4EE3\u7801' },\n      name: { label: '\u6D3B\u52A8\u540D\u79F0' },\n      type: {\n        label: '\u7C7B\u578B',\n        options: {\n          email: '\u90AE\u4EF6\u8425\u9500', webinar: '\u7EBF\u4E0A\u7814\u8BA8\u4F1A', trade_show: '\u5C55\u4F1A',\n          conference: '\u884C\u4E1A\u4F1A\u8BAE', direct_mail: '\u76F4\u90AE', social_media: '\u793E\u4EA4\u5A92\u4F53',\n          content: '\u5185\u5BB9\u8425\u9500', partner: '\u4F19\u4F34\u8054\u5408\u8425\u9500',\n        },\n      },\n      status: {\n        label: '\u72B6\u6001',\n        options: {\n          planning: '\u89C4\u5212\u4E2D', in_progress: '\u8FDB\u884C\u4E2D',\n          completed: '\u5DF2\u5B8C\u6210', aborted: '\u5DF2\u4E2D\u6B62',\n        },\n      },\n      start_date: { label: '\u5F00\u59CB\u65E5\u671F' },\n      end_date: { label: '\u7ED3\u675F\u65E5\u671F' },\n      expected_revenue: { label: '\u9884\u671F\u6536\u5165' },\n      description: { label: '\u63CF\u8FF0' },\n      channel: {\n        label: '\u4E3B\u8981\u6E20\u9053',\n        options: { digital: '\u6570\u5B57\u6E20\u9053', social: '\u793E\u4EA4\u5A92\u4F53', email: '\u90AE\u4EF6', events: '\u7EBF\u4E0B\u6D3B\u52A8', partner: '\u5408\u4F5C\u4F19\u4F34' },\n      },\n      budgeted_cost: { label: '\u9884\u7B97\u6210\u672C' },\n      actual_cost: { label: '\u5B9E\u9645\u6210\u672C' },\n      actual_revenue: { label: '\u5B9E\u9645\u6536\u5165' },\n      target_size: { label: '\u76EE\u6807\u4EBA\u6570', help: '\u76EE\u6807\u7EBF\u7D22/\u8054\u7CFB\u4EBA\u6570\u91CF' },\n      num_sent: { label: '\u53D1\u9001\u6570\u91CF' },\n      num_responses: { label: '\u54CD\u5E94\u6570\u91CF' },\n      num_leads: { label: '\u7EBF\u7D22\u6570\u91CF' },\n      num_converted_leads: { label: '\u5DF2\u8F6C\u5316\u7EBF\u7D22\u6570' },\n      num_opportunities: { label: '\u5DF2\u521B\u5EFA\u5546\u673A\u6570' },\n      num_won_opportunities: { label: '\u5DF2\u8D62\u5F97\u5546\u673A' },\n      response_rate: { label: '\u54CD\u5E94\u7387\uFF08%\uFF09' },\n      roi: { label: '\u6295\u8D44\u56DE\u62A5\u7387\uFF08%\uFF09' },\n      owner_id: { label: '\u6D3B\u52A8\u8D1F\u8D23\u4EBA' },\n      landing_page_url: { label: '\u7740\u9646\u9875' },\n      is_active: { label: '\u662F\u5426\u542F\u7528' },\n      display_title: { label: '\u663E\u793A\u540D\u79F0' },\n    },\n    _sections: {\n      basic: { label: '\u6D3B\u52A8\u4FE1\u606F' },\n      schedule: { label: '\u65E5\u7A0B\u5B89\u6392' },\n      budget: { label: '\u9884\u7B97\u4E0E\u6295\u8D44\u56DE\u62A5' },\n      metrics: { label: '\u6548\u679C\u6570\u636E' },\n      assignment: { label: '\u5F52\u5C5E' },\n      assets: { label: '\u6D3B\u52A8\u7D20\u6750' },\n    },\n    _views: {\n      all_campaigns: { label: '\u5168\u90E8\u8425\u9500\u6D3B\u52A8' },\n      campaign_gantt: { label: '\u6D3B\u52A8\u6392\u671F' },\n      campaign_calendar: { label: '\u6D3B\u52A8\u65E5\u5386' },\n      campaign_timeline: { label: '\u8425\u9500\u65F6\u95F4\u7EBF' },\n    },\n    _actions: {\n      enroll_leads: {\n        label: '\u6279\u91CF\u52A0\u5165\u6210\u5458',\n        successMessage: '\u7B26\u5408\u6761\u4EF6\u7684\u6210\u5458\u5DF2\u52A0\u5165\u8425\u9500\u6D3B\u52A8\u3002',\n      },\n    },\n  },\n  crm_campaign_member: {\n    _validations: {\n      lead_or_contact_required: {\n        message: '\u8425\u9500\u6D3B\u52A8\u6210\u5458\u5FC5\u987B\u5173\u8054\u7EBF\u7D22\u6216\u8054\u7CFB\u4EBA\u4E4B\u4E00',\n      },\n    },\n    // \u300C\u8425\u9500\u6D3B\u52A8\u6210\u5458\u300D, not \u300C\u6D3B\u52A8\u6210\u5458\u300D: this object's master is `crm_campaign`\n    // (\u8425\u9500\u6D3B\u52A8), while \u300C\u6D3B\u52A8\u300D is already this pack's label for `crm_event` and\n    // \u300C\u6D3B\u52A8\u53C2\u4E0E\u8005\u300D its child `crm_event_attendee`. Dropping \u300C\u8425\u9500\u300D put a\n    // marketing object inside the calendar family's name space (#810).\n    label: '\u8425\u9500\u6D3B\u52A8\u6210\u5458',\n    pluralLabel: '\u8425\u9500\u6D3B\u52A8\u6210\u5458',\n    description: '\u8425\u9500\u6D3B\u52A8\u6240\u89E6\u8FBE\u7684\u7EBF\u7D22\u4E0E\u8054\u7CFB\u4EBA\u53CA\u5176\u54CD\u5E94\u72B6\u6001',\n    fields: {\n      member_number: { label: '\u6210\u5458\u7F16\u53F7' },\n      crm_campaign: { label: '\u8425\u9500\u6D3B\u52A8' },\n      crm_lead: { label: '\u7EBF\u7D22', help: '\u6210\u5458\u52A0\u5165\u65F6\u8EAB\u4EFD\u4E3A\u7EBF\u7D22\u7684\uFF0C\u8BB0\u5F55\u5728\u6B64' },\n      crm_contact: { label: '\u8054\u7CFB\u4EBA', help: '\u6210\u5458\u4E3A\u5DF2\u6709\u8054\u7CFB\u4EBA\u7684\uFF0C\u8BB0\u5F55\u5728\u6B64' },\n      status: {\n        label: '\u72B6\u6001',\n        options: {\n          sent: '\u5DF2\u53D1\u9001', responded: '\u5DF2\u54CD\u5E94',\n          converted: '\u5DF2\u8F6C\u5316', unsubscribed: '\u5DF2\u9000\u8BA2',\n        },\n      },\n      added_date: { label: '\u52A0\u5165\u65F6\u95F4' },\n      response_date: { label: '\u54CD\u5E94\u65F6\u95F4' },\n      has_responded: { label: '\u5DF2\u54CD\u5E94' },\n    },\n    _sections: {\n      basic: { label: '\u57FA\u672C\u4FE1\u606F' },\n      response: { label: '\u54CD\u5E94\u8DDF\u8E2A' },\n    },\n    _actions: {\n      mark_responded: {\n        label: '\u6807\u8BB0\u4E3A\u5DF2\u54CD\u5E94',\n        successMessage: '\u5DF2\u8BB0\u5F55\u8BE5\u8425\u9500\u6D3B\u52A8\u6210\u5458\u7684\u54CD\u5E94\u3002',\n      },\n    },\n  },\n};\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/sales/translations/zh-CN.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/sales/translations\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/sales/translations/zh-CN.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport type { TranslationData } from '@objectstack/spec/system';\n\nimport { appSurface } from './zh-CN/app';\nimport { customer } from './zh-CN/objects.customer';\nimport { pipeline } from './zh-CN/objects.pipeline';\nimport { commerce } from './zh-CN/objects.commerce';\nimport { service } from './zh-CN/objects.service';\nimport { activity } from './zh-CN/objects.activity';\nimport { marketing } from './zh-CN/objects.marketing';\n\n/**\n * \u7B80\u4F53\u4E2D\u6587 (zh-CN) \u2014 CRM App Translations\n *\n * Per-locale file: one file per language, following the `per_locale` convention.\n *\n * SPLIT AXIS (#1311): translation NAMESPACE first, then CRM DOMAIN FAMILY.\n *\n * This bundle was one file and it had reached 88.6% of the 100KB source cap\n * `pnpm hygiene` enforces, growing ~1.2KB a day. It is now assembled from\n * `./<locale>/`, on an axis measured rather than guessed:\n *\n *   - every namespace that is NOT `objects` \u2014 `apps`, `messages`,\n *     `dashboards`, `datasets`, `pages`, and any namespace `TranslationData`\n *     gains later \u2014 lives in `app.ts`. Measured: those namespaces together\n *     are under a quarter of the bundle, and the schema bounds how many can\n *     ever arrive, so one file holds them with room left;\n *   - `objects` is 69-78% of every bundle, so it is partitioned again, one\n *     file per CRM domain family \u2014 `customer`, `pipeline`, `commerce`,\n *     `service`, `activity`, `marketing` \u2014 and a DETAIL object follows its\n *     master: line items follow their quote or opportunity,\n *     `crm_event_attendee` follows `crm_event`, `crm_campaign_member`\n *     follows `crm_campaign`, `crm_article_feedback` follows\n *     `crm_knowledge_article`.\n *\n * A namespace axis ALONE was measured and rejected: it leaves `objects` at\n * 65.7KB, 3.9KB under the advisory band, which `objects` growth crosses in\n * about nine days. The family axis puts the largest part at 24.2% of the cap.\n *\n * \u26A0\uFE0F A new object translation belongs in the file for ITS family. Do not add\n * it to whichever file is already open \u2014 that is how one file re-grows past\n * the band, which is what split this bundle in the first place.\n *\n * \u26A0\uFE0F A value used by more than one family lives in `<locale>/_shared.ts`. A\n * value used by exactly one family lives in that family's file.\n *\n * \u26A0\uFE0F The key order below is LOAD-BEARING, not cosmetic. `objectstack build`\n * serialises this object into `dist/objectstack.json` in insertion order and\n * never sorts it, so listing the rows here \u2014 rather than spreading the family\n * files \u2014 is what keeps the built artifact byte-identical across the split.\n * The order is this bundle's own historical accretion order and differs\n * between locales; reordering it rewrites the artifact.\n */\nexport const zhCN: TranslationData = {\n  objects: {\n    crm_account: customer.crm_account,\n    crm_contact: customer.crm_contact,\n    crm_knowledge_article: service.crm_knowledge_article,\n    crm_forecast: pipeline.crm_forecast,\n    crm_lead: pipeline.crm_lead,\n    crm_quote: commerce.crm_quote,\n    crm_contract: commerce.crm_contract,\n    crm_case: service.crm_case,\n    crm_task: activity.crm_task,\n    crm_campaign: marketing.crm_campaign,\n    crm_product: commerce.crm_product,\n    crm_opportunity: pipeline.crm_opportunity,\n    crm_event: activity.crm_event,\n    crm_event_attendee: activity.crm_event_attendee,\n    crm_article_feedback: service.crm_article_feedback,\n    crm_campaign_member: marketing.crm_campaign_member,\n    crm_opportunity_line_item: pipeline.crm_opportunity_line_item,\n    crm_quote_line_item: commerce.crm_quote_line_item,\n  },\n  ...appSurface,\n};\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/sales/translations/ja-JP/app.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/sales/translations/ja-JP\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/sales/translations/ja-JP/app.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport type { TranslationData } from '@objectstack/spec/system';\n\nimport { QUOTE_DISCOUNT_CEILING } from '../../objects/_thresholds';\n\n/**\n * \u65E5\u672C\u8A9E (ja-JP) \u2014 every translation namespace EXCEPT `objects`:\n * `apps`, `messages`, `dashboards`, `datasets`, `pages`, `flows`.\n *\n * SPLIT AXIS (#1311): translation NAMESPACE first, then CRM DOMAIN FAMILY.\n * Everything that is not `objects` lives in `./app.ts`; `objects` \u2014 69-78% of\n * every bundle \u2014 is one file per CRM domain family, and a detail object\n * follows its master. A new row goes in the file for ITS family, never in\n * whichever file is already open: that is how one file re-grows past the 70%\n * advisory band `pnpm hygiene` prints. Full rule and rationale:\n * `src/sales/translations/ja-JP.ts`.\n *\n * A namespace `TranslationData` gains later lands here too, and the room is\n * measured: this file is the smaller half of the bundle, and the schema bounds\n * how many namespaces can ever arrive.\n */\nexport const appSurface: Omit<TranslationData, 'objects'> = {\n  apps: {\n    crm_enterprise: {\n      label: 'HotCRM',\n      description: '\u55B6\u696D\u30FB\u30B5\u30FC\u30D3\u30B9\u30FB\u30DE\u30FC\u30B1\u30C6\u30A3\u30F3\u30B0\u5411\u3051\u9867\u5BA2\u95A2\u4FC2\u7BA1\u7406\u30B7\u30B9\u30C6\u30E0',\n      // Keyed by navigation-node `id` (a flat keyspace regardless of depth).\n      navigation: {\n        nav_home: { label: '\u30DB\u30FC\u30E0' },\n\n        group_sales: { label: '\u55B6\u696D' },\n        nav_lead: { label: '\u30EA\u30FC\u30C9' },\n        nav_account: { label: '\u53D6\u5F15\u5148' },\n        nav_account_workbench: { label: '\u53D6\u5F15\u5148\u30EF\u30FC\u30AF\u30D9\u30F3\u30C1' },\n        nav_contact: { label: '\u53D6\u5F15\u5148\u8CAC\u4EFB\u8005' },\n        nav_opportunity: { label: '\u5546\u8AC7' },\n        nav_quote: { label: '\u898B\u7A4D' },\n        nav_contract: { label: '\u5951\u7D04' },\n        nav_product: { label: '\u88FD\u54C1' },\n        nav_sales_dashboard: { label: '\u55B6\u696D\u5B9F\u7E3E' },\n\n        group_work: { label: '\u30DE\u30A4\u30EF\u30FC\u30AF' },\n        nav_my_tasks: { label: '\u79C1\u306E\u30BF\u30B9\u30AF' },\n        nav_my_deals: { label: '\u79C1\u306E\u5546\u8AC7' },\n        nav_my_leads: { label: '\u79C1\u306E\u30EA\u30FC\u30C9' },\n        nav_my_cases: { label: '\u79C1\u306E\u30B1\u30FC\u30B9' },\n        nav_my_calendar: { label: '\u30DE\u30A4\u30AB\u30EC\u30F3\u30C0\u30FC' },\n        nav_approval_requests: { label: '\u53D7\u4FE1\u30C8\u30EC\u30A4' },\n\n        group_activity: { label: '\u6D3B\u52D5' },\n        nav_event: { label: '\u30A4\u30D9\u30F3\u30C8' },\n        nav_activity_dashboard: { label: '\u55B6\u696D\u6D3B\u52D5' },\n\n        group_marketing: { label: '\u30DE\u30FC\u30B1\u30C6\u30A3\u30F3\u30B0' },\n        nav_campaign: { label: '\u30AD\u30E3\u30F3\u30DA\u30FC\u30F3' },\n\n        group_service: { label: '\u30B5\u30FC\u30D3\u30B9' },\n        nav_case: { label: '\u30B1\u30FC\u30B9' },\n        nav_knowledge: { label: '\u30CA\u30EC\u30C3\u30B8\u30D9\u30FC\u30B9' },\n        nav_service_dashboard: { label: '\u30B5\u30FC\u30D3\u30B9\u6982\u8981' },\n\n        group_insights: { label: '\u30A4\u30F3\u30B5\u30A4\u30C8' },\n        nav_crm_dashboard: { label: 'CRM \u6982\u8981' },\n        nav_forecast: { label: '\u30D5\u30A9\u30FC\u30AD\u30E3\u30B9\u30C8' },\n        nav_report_pipeline_coverage: { label: '\u30D1\u30A4\u30D7\u30E9\u30A4\u30F3\u30AB\u30D0\u30EC\u30C3\u30B8' },\n        nav_report_lead_inflow: { label: '\u30EA\u30FC\u30C9\u6D41\u5165' },\n        nav_report_sla: { label: 'SLA \u5B9F\u7E3E' },\n      },\n    },\n  },\n  messages: {\n    'common.save': '\u4FDD\u5B58',\n    'common.cancel': '\u30AD\u30E3\u30F3\u30BB\u30EB',\n    'common.delete': '\u524A\u9664',\n    'common.edit': '\u7DE8\u96C6',\n    'common.create': '\u65B0\u898F\u4F5C\u6210',\n    'common.search': '\u691C\u7D22',\n    'common.filter': '\u30D5\u30A3\u30EB\u30BF\u30FC',\n    'common.export': '\u30A8\u30AF\u30B9\u30DD\u30FC\u30C8',\n    'common.back': '\u623B\u308B',\n    'common.confirm': '\u78BA\u8A8D',\n    'nav.sales': '\u55B6\u696D',\n    'nav.service': '\u30B5\u30FC\u30D3\u30B9',\n    'nav.marketing': '\u30DE\u30FC\u30B1\u30C6\u30A3\u30F3\u30B0',\n    'nav.products': '\u88FD\u54C1',\n    'nav.analytics': '\u30A2\u30CA\u30EA\u30C6\u30A3\u30AF\u30B9',\n    'success.saved': '\u30EC\u30B3\u30FC\u30C9\u3092\u4FDD\u5B58\u3057\u307E\u3057\u305F',\n    'success.converted': '\u30EA\u30FC\u30C9\u3092\u5909\u63DB\u3057\u307E\u3057\u305F',\n    'confirm.delete': '\u3053\u306E\u30EC\u30B3\u30FC\u30C9\u3092\u524A\u9664\u3057\u3066\u3082\u3088\u308D\u3057\u3044\u3067\u3059\u304B\uFF1F',\n    'confirm.convert_lead': '\u3053\u306E\u30EA\u30FC\u30C9\u3092\u53D6\u5F15\u5148\u30FB\u53D6\u5F15\u5148\u8CAC\u4EFB\u8005\u30FB\u5546\u8AC7\u306B\u5909\u63DB\u3057\u307E\u3059\u304B\uFF1F',\n    'error.required': '\u3053\u306E\u9805\u76EE\u306F\u5FC5\u9808\u3067\u3059',\n    'error.load_failed': '\u30C7\u30FC\u30BF\u306E\u8AAD\u307F\u8FBC\u307F\u306B\u5931\u6557\u3057\u307E\u3057\u305F',\n  },\n  dashboards: {\n    sales_activity_dashboard: {\n      label: '\u55B6\u696D\u6D3B\u52D5',\n      description: '\u8AB0\u304C\u3069\u308C\u3060\u3051\u9867\u5BA2\u3068\u8A71\u3057\u3066\u3044\u308B\u304B\u3001\u3069\u306E\u53D6\u5F15\u5148\u304C\u6C88\u9ED9\u3057\u3066\u3044\u308B\u304B',\n      widgets: {\n        interactions_held: { title: '\u8A18\u9332\u6E08\u307F\u306E\u5BFE\u8A71', description: '\u5B9F\u969B\u306B\u884C\u308F\u308C\u305F\u96FB\u8A71\u3068\u4F1A\u8B70' },\n        meetings_booked: { title: '\u8A2D\u5B9A\u6E08\u307F\u306E\u4F1A\u8B70', description: '\u30AB\u30EC\u30F3\u30C0\u30FC\u4E0A\u306B\u3042\u308A\u672A\u5B9F\u65BD\u306E\u4F1A\u8B70' },\n        customer_minutes: { title: '\u9867\u5BA2\u63A5\u89E6\u6642\u9593\uFF08\u5206\uFF09', description: '\u9867\u5BA2\u3068\u5411\u304D\u5408\u3063\u305F\u7DCF\u6642\u9593' },\n        tasks_completed: { title: '\u5B8C\u4E86\u30BF\u30B9\u30AF', description: '\u30AF\u30ED\u30FC\u30BA\u3057\u305F\u30D5\u30A9\u30ED\u30FC\u30A2\u30C3\u30D7' },\n        activity_by_rep: { title: '\u62C5\u5F53\u8005\u5225\u306E\u6D3B\u52D5', description: '\u62C5\u5F53\u8005\u3054\u3068\u306E\u8A18\u9332\u6E08\u307F\u5BFE\u8A71\u6570' },\n        activity_by_week: { title: '\u9031\u6B21\u306E\u6D3B\u52D5\u91CF', description: '\u9031\u3042\u305F\u308A\u306E\u5BFE\u8A71\u6570' },\n        activity_mix: { title: '\u6D3B\u52D5\u306E\u5185\u8A33', description: '\u96FB\u8A71\u30FB\u4F1A\u8B70\u30FB\u30C7\u30E2\u306E\u6BD4\u7387' },\n        activity_by_record_type: { title: '\u6D3B\u52D5\u306E\u5BFE\u8C61', description: '\u30D5\u30A1\u30CD\u30EB\u306E\u3069\u3053\u306B\u6CE8\u529B\u3057\u3066\u3044\u308B\u304B' },\n        deal_activity: { title: '\u5546\u8AC7\u4E0A\u306E\u5BFE\u8A71', description: '\u5546\u8AC7\u306B\u7D10\u3065\u304F\u8A18\u9332\u6E08\u307F\u5BFE\u8A71' },\n        open_deals_for_activity: { title: '\u30AA\u30FC\u30D7\u30F3\u5546\u8AC7', description: '\u9032\u884C\u4E2D\u306E\u5546\u8AC7\u6570' },\n        quiet_accounts_30: { title: '30 \u65E5\u4EE5\u4E0A\u6C88\u9ED9', description: '1 \u304B\u6708\u9593\u5BFE\u8A71\u8A18\u9332\u306E\u306A\u3044\u30A2\u30AF\u30C6\u30A3\u30D6\u53D6\u5F15\u5148' },\n        quiet_accounts_60: { title: '60 \u65E5\u4EE5\u4E0A\u6C88\u9ED9', description: '2 \u304B\u6708\u306E\u6C88\u9ED9 \u2014 \u30EA\u30B9\u30AF\u95BE\u5024' },\n        quiet_accounts_90: { title: '90 \u65E5\u4EE5\u4E0A\u6C88\u9ED9', description: '\u56DB\u534A\u671F\u306B\u308F\u305F\u308A\u63A5\u89E6\u306A\u3057' },\n      },\n    },\n    crm_overview_dashboard: {\n      label: 'CRM \u6982\u8981',\n      description: '\u58F2\u4E0A\u6307\u6A19\u3001\u30D1\u30A4\u30D7\u30E9\u30A4\u30F3\u5206\u6790\u3001\u5546\u8AC7\u30A4\u30F3\u30B5\u30A4\u30C8',\n      widgets: {\n        total_revenue: { title: '\u7DCF\u58F2\u4E0A', description: '\u5F53\u671F\u306E\u6210\u7ACB\u6E08\u307F\u58F2\u4E0A' },\n        active_deals: { title: '\u9032\u884C\u4E2D\u306E\u5546\u8AC7', description: '\u30D1\u30A4\u30D7\u30E9\u30A4\u30F3\u4E0A\u306E\u30AA\u30FC\u30D7\u30F3\u5546\u8AC7' },\n        won_deals: { title: '\u6210\u7ACB\u5546\u8AC7\u6570', description: '\u5F53\u671F\u306B\u6210\u7ACB\u3057\u305F\u5546\u8AC7\u306E\u7DCF\u6570' },\n        avg_deal_size: { title: '\u5E73\u5747\u5546\u8AC7\u898F\u6A21', description: '\u6210\u7ACB\u6E08\u307F\u5546\u8AC7\u306E\u5E73\u5747\u91D1\u984D' },\n        revenue_trends: { title: '\u58F2\u4E0A\u30C8\u30EC\u30F3\u30C9', description: '\u904E\u53BB12\u304B\u6708\u306E\u6210\u7ACB\u6E08\u307F\u58F2\u4E0A' },\n        lead_source: { title: '\u30EA\u30FC\u30C9\u30BD\u30FC\u30B9', description: '\u7372\u5F97\u30C1\u30E3\u30CD\u30EB\u5225\u306E\u30D1\u30A4\u30D7\u30E9\u30A4\u30F3\u91D1\u984D' },\n        pipeline_by_stage: { title: '\u30B9\u30C6\u30FC\u30B8\u5225\u30D1\u30A4\u30D7\u30E9\u30A4\u30F3', description: '\u5404\u55B6\u696D\u30B9\u30C6\u30FC\u30B8\u306E\u30AA\u30FC\u30D7\u30F3\u5546\u8AC7\u91D1\u984D' },\n        top_products: { title: '\u58F2\u308C\u7B4B\u88FD\u54C1', description: '\u88FD\u54C1\u30AB\u30C6\u30B4\u30EA\u5225\u306E\u5B9A\u4FA1\u30D9\u30FC\u30B9\u58F2\u4E0A' },\n        pipeline_by_owner: { title: '\u62C5\u5F53\u8005\u5225\u30D1\u30A4\u30D7\u30E9\u30A4\u30F3', description: '\u55B6\u696D\u62C5\u5F53\u8005\u3054\u3068\u306E\u30AA\u30FC\u30D7\u30F3\u30D1\u30A4\u30D7\u30E9\u30A4\u30F3\u91D1\u984D\u3068\u5546\u8AC7\u6570' },\n      },\n    },\n    executive_dashboard: {\n      label: '\u30A8\u30B0\u30BC\u30AF\u30C6\u30A3\u30D6\u6982\u8981',\n      description: '\u7D4C\u55B6\u5C64\u5411\u3051\u306E\u58F2\u4E0A\u30FB\u9867\u5BA2\u30FB\u30D1\u30A4\u30D7\u30E9\u30A4\u30F3\u306E\u4E3B\u8981KPI',\n      widgets: {\n        total_revenue_ytd: { title: '\u5E74\u5EA6\u7D2F\u8A08\u58F2\u4E0A', description: '\u672C\u5E74\u5EA6\u306E\u6210\u7ACB\u6E08\u307F\u58F2\u4E0A' },\n        total_accounts: { title: '\u30A2\u30AF\u30C6\u30A3\u30D6\u53D6\u5F15\u5148', description: '\u5C11\u306A\u304F\u3068\u30821\u3064\u306E\u6709\u52B9\u306A\u95A2\u4FC2\u3092\u6301\u3064\u9867\u5BA2' },\n        total_contacts: { title: '\u53D6\u5F15\u5148\u8CAC\u4EFB\u8005\u6570', description: '\u540D\u7C3F\u306B\u767B\u9332\u3055\u308C\u305F\u53D6\u5F15\u5148\u8CAC\u4EFB\u8005' },\n        open_leads: { title: '\u30AA\u30FC\u30D7\u30F3\u30EA\u30FC\u30C9', description: '\u672A\u5909\u63DB\u306E\u30EA\u30FC\u30C9' },\n        revenue_trend: { title: '\u58F2\u4E0A\u30C8\u30EC\u30F3\u30C9', description: '\u904E\u53BB12\u304B\u6708\u306E\u6210\u7ACB\u6E08\u307F\u58F2\u4E0A' },\n        revenue_by_industry: { title: '\u696D\u7A2E\u5225\u58F2\u4E0A', description: '\u672C\u5E74\u5EA6\u306E\u6210\u7ACB\u6E08\u307F\u58F2\u4E0A\u3092\u696D\u7A2E\u5225\u306B\u5206\u985E' },\n        pipeline_by_stage: { title: '\u30B9\u30C6\u30FC\u30B8\u5225\u30D1\u30A4\u30D7\u30E9\u30A4\u30F3', description: '\u5404\u55B6\u696D\u30B9\u30C6\u30FC\u30B8\u306E\u30AA\u30FC\u30D7\u30F3\u5546\u8AC7\u91D1\u984D' },\n        new_accounts_by_month: { title: '\u65B0\u898F\u53D6\u5F15\u5148', description: '\u904E\u53BB6\u304B\u6708\u306E\u53D6\u5F15\u5148\u4F5C\u6210\u30DA\u30FC\u30B9' },\n        accounts_by_industry: { title: '\u696D\u7A2E\u5225\u53D6\u5F15\u5148', description: '\u696D\u7A2E\u3054\u3068\u306E\u5E74\u9593\u58F2\u4E0A\u5408\u8A08\u3068\u53D6\u5F15\u5148\u6570' },\n      },\n    },\n    sales_dashboard: {\n      label: '\u55B6\u696D\u5B9F\u7E3E',\n      description: '\u30D1\u30A4\u30D7\u30E9\u30A4\u30F3\u5206\u6790\u3001\u52DD\u7387\u30C8\u30EC\u30F3\u30C9\u3001\u62C5\u5F53\u8005\u5225\u30D1\u30D5\u30A9\u30FC\u30DE\u30F3\u30B9',\n      widgets: {\n        total_pipeline_value: { title: '\u30D1\u30A4\u30D7\u30E9\u30A4\u30F3\u5408\u8A08', description: '\u30AA\u30FC\u30D7\u30F3\u5546\u8AC7\u91D1\u984D\u306E\u5408\u8A08' },\n        closed_won_qtd: { title: '\u4ECA\u56DB\u534A\u671F\u6210\u7ACB\u984D', description: '\u4ECA\u56DB\u534A\u671F\u306B\u6210\u7ACB\u3057\u305F\u58F2\u4E0A' },\n        open_opportunities: { title: '\u30AA\u30FC\u30D7\u30F3\u5546\u8AC7', description: '\u9032\u884C\u4E2D\u306E\u30A2\u30AF\u30C6\u30A3\u30D6\u5546\u8AC7' },\n        avg_deal_size: { title: '\u5E73\u5747\u5546\u8AC7\u898F\u6A21', description: '\u4ECA\u56DB\u534A\u671F\u306E\u6210\u7ACB\u6E08\u307F\u5546\u8AC7\u306E\u5E73\u5747\u91D1\u984D' },\n        pipeline_by_stage: { title: '\u30B9\u30C6\u30FC\u30B8\u5225\u30D1\u30A4\u30D7\u30E9\u30A4\u30F3', description: '\u5404\u55B6\u696D\u30B9\u30C6\u30FC\u30B8\u306E\u30AA\u30FC\u30D7\u30F3\u5546\u8AC7\u91D1\u984D' },\n        monthly_revenue_trend: { title: '\u6708\u6B21\u58F2\u4E0A\u30C8\u30EC\u30F3\u30C9', description: '\u904E\u53BB12\u304B\u6708\u306E\u6210\u7ACB\u6E08\u307F\u58F2\u4E0A' },\n        pipeline_by_forecast_category: { title: '\u4E88\u6E2C\u30AB\u30C6\u30B4\u30EA\u5225\u30D1\u30A4\u30D7\u30E9\u30A4\u30F3', description: '\u58F2\u4E0A\u4E88\u6E2C\u30AB\u30C6\u30B4\u30EA\u5225\u306E\u30AA\u30FC\u30D7\u30F3\u30D1\u30A4\u30D7\u30E9\u30A4\u30F3\u91D1\u984D' },\n        lead_source_breakdown: { title: '\u30EA\u30FC\u30C9\u30BD\u30FC\u30B9', description: '\u30D1\u30A4\u30D7\u30E9\u30A4\u30F3\u306E\u6D41\u5165\u5143' },\n        open_pipeline_by_owner: { title: '\u62C5\u5F53\u8005\u5225\u30AA\u30FC\u30D7\u30F3\u30D1\u30A4\u30D7\u30E9\u30A4\u30F3', description: '\u55B6\u696D\u62C5\u5F53\u8005\u3054\u3068\u306E\u9032\u884C\u4E2D\u30D1\u30A4\u30D7\u30E9\u30A4\u30F3\u91D1\u984D\u30FB\u5546\u8AC7\u6570\u30FB\u5E73\u5747\u52DD\u7387' },\n        quota_attainment_by_rep: { title: '\u62C5\u5F53\u8005\u5225\u30CE\u30EB\u30DE\u9054\u6210\u72B6\u6CC1', description: '\u4E88\u6E2C\u30B9\u30CA\u30C3\u30D7\u30B7\u30E7\u30C3\u30C8\u306B\u57FA\u3065\u304F\u62C5\u5F53\u8005\u5225\u306E\u4ECA\u56DB\u534A\u671F\u30CE\u30EB\u30DE\u30FB\u6210\u7D04\u53CE\u76CA\u30FB\u9054\u6210\u7387' },\n        pipeline_stage_by_source: { title: '\u30B9\u30C6\u30FC\u30B8 \u00D7 \u30EA\u30FC\u30C9\u30BD\u30FC\u30B9', description: '\u30B9\u30C6\u30FC\u30B8\u3068\u30BD\u30FC\u30B9\u5225\u306E\u9032\u884C\u4E2D\u5546\u8AC7\u91D1\u984D\u306E\u30AF\u30ED\u30B9\u96C6\u8A08' },\n        win_rate_12m: { title: '\u52DD\u7387\uFF08\u76F4\u8FD112\u304B\u6708\uFF09', description: '\u76F4\u8FD112\u304B\u6708\u306B\u6C7A\u7740\u3057\u305F\u5546\u8AC7\u306E\u3046\u3061\u6210\u7ACB\u3057\u305F\u5272\u5408' },\n        won_deals_12m: { title: '\u6210\u7ACB\u5546\u8AC7\u6570\uFF08\u76F4\u8FD112\u304B\u6708\uFF09', description: '\u52DD\u7387\u306E\u5206\u5B50' },\n        lost_deals_12m: { title: '\u5931\u6CE8\u5546\u8AC7\u6570\uFF08\u76F4\u8FD112\u304B\u6708\uFF09', description: '\u52DD\u7387\u306E\u5206\u6BCD\u306E\u3082\u3046\u534A\u5206' },\n        win_rate_by_owner: { title: '\u62C5\u5F53\u8005\u5225 \u53D7\u6CE8\uFF0F\u5931\u6CE8', description: '\u76F4\u8FD112\u304B\u6708\u306E\u62C5\u5F53\u8005\u3054\u3068\u306E\u6210\u7ACB\u6570\u30FB\u5931\u6CE8\u6570\u30FB\u52DD\u7387' },\n        win_rate_by_lead_source: { title: '\u30EA\u30FC\u30C9\u30BD\u30FC\u30B9\u5225 \u53D7\u6CE8\uFF0F\u5931\u6CE8', description: '\u5B9F\u969B\u306B\u6210\u7ACB\u306B\u3064\u306A\u304C\u308B\u306E\u306F\u3069\u306E\u30BD\u30FC\u30B9\u304B \u2014 \u76F4\u8FD112\u304B\u6708' },\n        loss_reason_breakdown: { title: '\u5931\u6CE8\u306E\u7406\u7531', description: '\u76F4\u8FD112\u304B\u6708\u306E\u5931\u6CE8\u5546\u8AC7\u3092\u7406\u7531\u5225\u306B\u96C6\u8A08' },\n      },\n    },\n    service_dashboard: {\n      label: '\u30AB\u30B9\u30BF\u30DE\u30FC\u30B5\u30FC\u30D3\u30B9',\n      description: '\u30B1\u30FC\u30B9\u8CA0\u8377\u3001SLA\u5065\u5168\u6027\u3001\u89E3\u6C7A\u30D1\u30D5\u30A9\u30FC\u30DE\u30F3\u30B9',\n      widgets: {\n        open_cases: { title: '\u30AA\u30FC\u30D7\u30F3\u30B1\u30FC\u30B9', description: '\u307E\u3060\u30AF\u30ED\u30FC\u30BA\u3055\u308C\u3066\u3044\u306A\u3044\u30B1\u30FC\u30B9' },\n        critical_cases: { title: '\u91CD\u5927\u30B1\u30FC\u30B9', description: '\u512A\u5148\u5EA6\u300C\u91CD\u5927\u300D\u306E\u30AA\u30FC\u30D7\u30F3\u30B1\u30FC\u30B9' },\n        avg_resolution_time: { title: '\u5E73\u5747\u89E3\u6C7A\u6642\u9593', description: '\u30AF\u30ED\u30FC\u30BA\u307E\u3067\u306E\u5E73\u5747\u6642\u9593\uFF08\u6642\uFF09' },\n        sla_violations: { title: 'SLA \u9055\u53CD', description: 'SLA \u3092\u8D85\u904E\u3057\u305F\u30B1\u30FC\u30B9' },\n        cases_by_status: { title: '\u30B9\u30C6\u30FC\u30BF\u30B9\u5225\u30B1\u30FC\u30B9', description: '\u30D1\u30A4\u30D7\u30E9\u30A4\u30F3\u5168\u4F53\u306E\u30EF\u30FC\u30AF\u30ED\u30FC\u30C9\u5206\u5E03' },\n        cases_by_priority: { title: '\u512A\u5148\u5EA6\u5225\u30B1\u30FC\u30B9', description: '\u7DCA\u6025\u5EA6\u5225\u306E\u30AA\u30FC\u30D7\u30F3\u30B1\u30FC\u30B9\u69CB\u6210' },\n        cases_by_origin: { title: '\u767A\u751F\u6E90\u5225\u30B1\u30FC\u30B9', description: '\u30B1\u30FC\u30B9\u306E\u6D41\u5165\u30C1\u30E3\u30CD\u30EB' },\n        daily_case_volume: { title: '\u65E5\u6B21\u30B1\u30FC\u30B9\u4EF6\u6570', description: '\u904E\u53BB30\u65E5\u9593\u306E\u65B0\u898F\u30B1\u30FC\u30B9' },\n        sla_compliance_gauge: { title: 'SLA \u9054\u6210\u7387', description: '\u5F53\u671F SLA \u5185\u306B\u89E3\u6C7A\u3057\u305F\u30B1\u30FC\u30B9\u306E\u5272\u5408' },\n        kb_deflection_rate: { title: '\u30CA\u30EC\u30C3\u30B8\u89E3\u6C7A\u7387', description: '\u30AF\u30ED\u30FC\u30BA\u3057\u305F\u30B1\u30FC\u30B9\u306E\u3046\u3061\u30CA\u30EC\u30C3\u30B8\u8A18\u4E8B\u3067\u89E3\u6C7A\u3057\u305F\u5272\u5408' },\n        kb_resolved_cases: { title: '\u30CA\u30EC\u30C3\u30B8\u3067\u89E3\u6C7A', description: '\u89E3\u6C7A\u3057\u305F\u8A18\u4E8B\u304C\u7D10\u3065\u304F\u30AF\u30ED\u30FC\u30BA\u6E08\u307F\u30B1\u30FC\u30B9' },\n        closed_cases_total: { title: '\u30AF\u30ED\u30FC\u30BA\u6E08\u307F\u30B1\u30FC\u30B9', description: '\u30CA\u30EC\u30C3\u30B8\u89E3\u6C7A\u7387\u306E\u5206\u6BCD' },\n        top_resolving_articles: { title: '\u89E3\u6C7A\u4EF6\u6570\u306E\u591A\u3044\u8A18\u4E8B', description: '\u89E3\u6C7A\u3057\u305F\u30AF\u30ED\u30FC\u30BA\u6E08\u307F\u30B1\u30FC\u30B9\u6570\u3067\u4E26\u3079\u305F\u30CA\u30EC\u30C3\u30B8\u8A18\u4E8B' },\n        my_open_cases_by_priority: { title: '\u512A\u5148\u5EA6\u5225\u306E\u79C1\u306E\u30AA\u30FC\u30D7\u30F3\u30B1\u30FC\u30B9', description: '\u3042\u306A\u305F\u306E\u30AA\u30FC\u30D7\u30F3\u30B1\u30FC\u30B9\u3068\u305D\u306ESLA\u9055\u53CD\u7387\u3092\u512A\u5148\u5EA6\u5225\u306B\u96C6\u8A08' },\n      },\n    },\n  },\n  // `title` / `subtitle` translate the page's `page:header`; `title` falls back\n  // to `label` when omitted, so it is authored only where the two differ.\n  // Header strings carrying `{field}` tokens keep the token spelling verbatim \u2014\n  // the console substitutes on the raw key, so a translated token resolves to\n  // nothing and the header renders blank.\n  datasets: {\n    account_metrics: {\n      label: '\u53D6\u5F15\u5148\u6307\u6A19',\n      description: '\u696D\u7A2E\u30FB\u7A2E\u5225\u3054\u3068\u306B\u53D6\u5F15\u5148\u6570\u3092\u96C6\u8A08\u3059\u308B\u30BB\u30DE\u30F3\u30C6\u30A3\u30C3\u30AF\u30EC\u30A4\u30E4\u30FC',\n      dimensions: {\n        industry: {\n          label: '\u696D\u7A2E',\n        },\n        type: {\n          label: '\u7A2E\u5225',\n        },\n        created_at: {\n          label: '\u4F5C\u6210\u65E5',\n        },\n      },\n      measures: {\n        account_count: {\n          label: '\u53D6\u5F15\u5148\u6570',\n        },\n        annual_revenue_sum: {\n          label: '\u5E74\u9593\u58F2\u4E0A',\n        },\n      },\n    },\n    case_metrics: {\n      label: '\u30B1\u30FC\u30B9\u6307\u6A19',\n      description: '\u30B1\u30FC\u30B9\u6570\u30FB\u89E3\u6C7A\u6642\u9593\u30FBSLA \u3092\u96C6\u8A08\u3059\u308B\u30BB\u30DE\u30F3\u30C6\u30A3\u30C3\u30AF\u30EC\u30A4\u30E4\u30FC',\n      dimensions: {\n        created_at: {\n          label: '\u4F5C\u6210\u65E5',\n        },\n        origin: {\n          label: '\u767A\u751F\u5143',\n        },\n        priority: {\n          label: '\u512A\u5148\u5EA6',\n        },\n        resolved_article: {\n          label: '\u89E3\u6C7A\u306B\u4F7F\u7528\u3057\u305F\u30CA\u30EC\u30C3\u30B8\u8A18\u4E8B',\n        },\n        status: {\n          label: '\u30B9\u30C6\u30FC\u30BF\u30B9',\n        },\n        type: {\n          label: '\u7A2E\u5225',\n        },\n      },\n      measures: {\n        avg_resolution: {\n          label: '\u5E73\u5747\u89E3\u6C7A\u6642\u9593\uFF08\u6642\u9593\uFF09',\n        },\n        avg_sla_violated: {\n          label: 'SLA \u9055\u53CD\u7387',\n        },\n        case_count: {\n          label: '\u30B1\u30FC\u30B9\u6570',\n        },\n        closed_count: {\n          label: '\u30AF\u30ED\u30FC\u30BA\u6E08\u307F\u30B1\u30FC\u30B9',\n        },\n        kb_deflection_rate: {\n          label: '\u30CA\u30EC\u30C3\u30B8\u30D9\u30FC\u30B9\u81EA\u5DF1\u89E3\u6C7A\u7387',\n        },\n        kb_resolved_count: {\n          label: '\u30CA\u30EC\u30C3\u30B8\u30D9\u30FC\u30B9\u3067\u89E3\u6C7A\u3057\u305F\u4EF6\u6570',\n        },\n        sla_compliance_rate: {\n          label: 'SLA \u9075\u5B88\u7387',\n        },\n        sla_met_count: {\n          label: 'SLA \u3092\u6E80\u305F\u3057\u305F\u30B1\u30FC\u30B9',\n        },\n      },\n    },\n    contact_metrics: {\n      label: '\u53D6\u5F15\u5148\u8CAC\u4EFB\u8005\u6307\u6A19',\n      description: '\u53D6\u5F15\u5148\u8CAC\u4EFB\u8005\u6570\u3092\u96C6\u8A08\u3059\u308B\u30BB\u30DE\u30F3\u30C6\u30A3\u30C3\u30AF\u30EC\u30A4\u30E4\u30FC',\n      measures: {\n        contact_count: {\n          label: '\u53D6\u5F15\u5148\u8CAC\u4EFB\u8005\u6570',\n        },\n      },\n    },\n    event_metrics: {\n      label: '\u6D3B\u52D5\u6307\u6A19',\n      description: '\u4F1A\u8B70\u30FB\u901A\u8A71\u30FB\u63A5\u89E6\u306E\u65B0\u3057\u3055\u3092\u96C6\u8A08\u3059\u308B\u30BB\u30DE\u30F3\u30C6\u30A3\u30C3\u30AF\u30EC\u30A4\u30E4\u30FC',\n      dimensions: {\n        owner: {\n          label: '\u6240\u6709\u8005',\n        },\n        related_to_type: {\n          label: '\u95A2\u9023\u5148',\n        },\n        start_datetime: {\n          label: '\u6D3B\u52D5\u9031',\n        },\n        status: {\n          label: '\u30B9\u30C6\u30FC\u30BF\u30B9',\n        },\n        type: {\n          label: '\u6D3B\u52D5\u7A2E\u5225',\n        },\n      },\n      measures: {\n        avg_minutes: {\n          label: '\u5E73\u5747\u6240\u8981\u6642\u9593',\n        },\n        event_count: {\n          label: '\u6D3B\u52D5\u4EF6\u6570',\n        },\n        total_minutes: {\n          label: '\u5408\u8A08\u5206\u6570',\n        },\n      },\n    },\n    forecast_metrics: {\n      label: '\u30D5\u30A9\u30FC\u30AD\u30E3\u30B9\u30C8\u6307\u6A19',\n      description: '\u62C5\u5F53\u8005\u3054\u3068\u306E\u76EE\u6A19\u30FB\u9054\u6210\u7387\u30FB\u30D1\u30A4\u30D7\u30E9\u30A4\u30F3\u30AB\u30D0\u30EC\u30C3\u30B8\u3092\u96C6\u8A08\u3059\u308B\u30BB\u30DE\u30F3\u30C6\u30A3\u30C3\u30AF\u30EC\u30A4\u30E4\u30FC',\n      dimensions: {\n        owner: {\n          label: '\u6240\u6709\u8005',\n        },\n        period: {\n          label: '\u671F\u9593\u7A2E\u5225',\n        },\n        period_label: {\n          label: '\u671F\u9593',\n        },\n        period_start: {\n          label: '\u671F\u9593\u958B\u59CB',\n        },\n      },\n      measures: {\n        attainment: {\n          label: '\u9054\u6210\u7387',\n        },\n        closed_sum: {\n          label: '\u30AF\u30ED\u30FC\u30BA\u6E08\u307F',\n        },\n        commit_sum: {\n          label: '\u30B3\u30DF\u30C3\u30C8',\n        },\n        pipeline_sum: {\n          label: '\u30D1\u30A4\u30D7\u30E9\u30A4\u30F3',\n        },\n        quota_sum: {\n          label: '\u76EE\u6A19',\n        },\n      },\n    },\n    lead_metrics: {\n      label: '\u30EA\u30FC\u30C9\u6307\u6A19',\n      description: '\u30EA\u30FC\u30C9\u6570\u3092\u96C6\u8A08\u3059\u308B\u30BB\u30DE\u30F3\u30C6\u30A3\u30C3\u30AF\u30EC\u30A4\u30E4\u30FC',\n      dimensions: {\n        created_at: {\n          label: '\u4F5C\u6210\u65E5',\n        },\n        last_contacted_date: {\n          label: '\u6700\u7D42\u63A5\u89E6\u65E5',\n        },\n        lead_source: {\n          label: '\u30BD\u30FC\u30B9',\n        },\n        status: {\n          label: '\u30B9\u30C6\u30FC\u30BF\u30B9',\n        },\n      },\n      measures: {\n        lead_count: {\n          label: '\u30EA\u30FC\u30C9\u6570',\n        },\n      },\n    },\n    opportunity_metrics: {\n      label: '\u5546\u8AC7\u6307\u6A19',\n      description: '\u55B6\u696D\u30D1\u30A4\u30D7\u30E9\u30A4\u30F3\u306E\u4EF6\u6570\u3068\u91D1\u984D\u3092\u96C6\u8A08\u3059\u308B\u30BB\u30DE\u30F3\u30C6\u30A3\u30C3\u30AF\u30EC\u30A4\u30E4\u30FC',\n      dimensions: {\n        account_industry: {\n          label: '\u53D6\u5F15\u5148\u306E\u696D\u7A2E',\n        },\n        close_date: {\n          label: '\u5B8C\u4E86\u4E88\u5B9A\u65E5',\n        },\n        close_quarter: {\n          label: '\u5B8C\u4E86\u56DB\u534A\u671F',\n        },\n        forecast_category: {\n          label: '\u30D5\u30A9\u30FC\u30AD\u30E3\u30B9\u30C8\u533A\u5206',\n        },\n        lead_source: {\n          label: '\u30EA\u30FC\u30C9\u30BD\u30FC\u30B9',\n        },\n        loss_reason: {\n          label: '\u5931\u6CE8\u7406\u7531',\n        },\n        owner: {\n          label: '\u6240\u6709\u8005',\n        },\n        stage: {\n          label: '\u30B9\u30C6\u30FC\u30B8',\n        },\n        type: {\n          label: '\u5546\u8AC7\u7A2E\u5225',\n        },\n        win_reason: {\n          label: '\u53D7\u6CE8\u7406\u7531',\n        },\n      },\n      measures: {\n        avg_amount: {\n          label: '\u5E73\u5747\u5546\u8AC7\u91D1\u984D',\n        },\n        avg_probability: {\n          label: '\u5E73\u5747\u78BA\u5EA6',\n        },\n        decided_count: {\n          label: '\u6C7A\u7740\u3057\u305F\u5546\u8AC7',\n        },\n        lost_amount: {\n          label: '\u5931\u6CE8\u91D1\u984D',\n        },\n        lost_count: {\n          label: '\u5931\u6CE8\u4EF6\u6570',\n        },\n        opp_count: {\n          label: '\u5546\u8AC7\u6570',\n        },\n        total_amount: {\n          label: '\u5408\u8A08\u91D1\u984D',\n        },\n        win_rate: {\n          label: '\u53D7\u6CE8\u7387',\n        },\n        won_amount: {\n          label: '\u53D7\u6CE8\u91D1\u984D',\n        },\n        won_count: {\n          label: '\u53D7\u6CE8\u4EF6\u6570',\n        },\n      },\n    },\n    product_metrics: {\n      label: '\u88FD\u54C1\u6307\u6A19',\n      description: '\u88FD\u54C1\u30AB\u30BF\u30ED\u30B0\u306E\u4EF6\u6570\u3068\u5B9A\u4FA1\u3092\u96C6\u8A08\u3059\u308B\u30BB\u30DE\u30F3\u30C6\u30A3\u30C3\u30AF\u30EC\u30A4\u30E4\u30FC',\n      dimensions: {\n        category: {\n          label: '\u30AB\u30C6\u30B4\u30EA',\n        },\n      },\n      measures: {\n        list_price_sum: {\n          label: '\u5B9A\u4FA1\u5408\u8A08',\n        },\n        product_count: {\n          label: '\u88FD\u54C1\u6570',\n        },\n      },\n    },\n    task_metrics: {\n      label: '\u30BF\u30B9\u30AF\u6307\u6A19',\n      description: '\u30BF\u30B9\u30AF\u306E\u4F5C\u696D\u91CF\u3068\u5B8C\u4E86\u72B6\u6CC1\u3092\u96C6\u8A08\u3059\u308B\u30BB\u30DE\u30F3\u30C6\u30A3\u30C3\u30AF\u30EC\u30A4\u30E4\u30FC',\n      dimensions: {\n        due_date: {\n          label: '\u671F\u9650',\n        },\n        is_completed: {\n          label: '\u5B8C\u4E86\u6E08\u307F',\n        },\n        is_overdue: {\n          label: '\u671F\u9650\u8D85\u904E',\n        },\n        priority: {\n          label: '\u512A\u5148\u5EA6',\n        },\n        priority_rank: {\n          label: '\u7DCA\u6025\u5EA6',\n        },\n        status: {\n          label: '\u30B9\u30C6\u30FC\u30BF\u30B9',\n        },\n        type: {\n          label: '\u7A2E\u5225',\n        },\n      },\n      measures: {\n        avg_progress: {\n          label: '\u5E73\u5747\u9032\u6357',\n        },\n        task_count: {\n          label: '\u30BF\u30B9\u30AF\u6570',\n        },\n      },\n    },\n  },\n  pages: {\n    account_detail_page: {\n      label: '\u53D6\u5F15\u5148\u8A73\u7D30',\n      description: '\u30B9\u30ED\u30C3\u30C8\u69CB\u6210\u306E\u53D6\u5F15\u5148\u30EC\u30B3\u30FC\u30C9\u30DA\u30FC\u30B8 \u2014 \u30AB\u30B9\u30BF\u30E0\u30D8\u30C3\u30C0\u30FC\u3068\u5E38\u8A2D\u306E\u30C7\u30A3\u30B9\u30AB\u30C3\u30B7\u30E7\u30F3\u30D5\u30A3\u30FC\u30C9\u3002',\n      title: '{name}',\n      subtitle: '{industry} \u00B7 {type}',\n      components: {\n        account_chatter: { label: '\u30C7\u30A3\u30B9\u30AB\u30C3\u30B7\u30E7\u30F3' },\n      },\n    },\n    account_workbench: {\n      label: '\u53D6\u5F15\u5148\u30EF\u30FC\u30AF\u30D9\u30F3\u30C1',\n      description: '\u55B6\u696D\u30C1\u30FC\u30E0\u5411\u3051\u306B\u53B3\u9078\u3057\u305F\u53D6\u5F15\u5148\u30EA\u30B9\u30C8\u3002\u30AF\u30A4\u30C3\u30AF\u30D5\u30A3\u30EB\u30BF\u30FC\u306E\u307F\u3067\u3001\u30D3\u30E5\u30FC\u7BA1\u7406\u306F\u884C\u3044\u307E\u305B\u3093\u3002',\n    },\n    app_launcher_page: {\n      label: '\u30A2\u30D7\u30EA\u30E9\u30F3\u30C1\u30E3\u30FC',\n      description: '\u3059\u3079\u3066\u306E\u30A2\u30D7\u30EA\u30B1\u30FC\u30B7\u30E7\u30F3\u306B\u30A2\u30AF\u30BB\u30B9\u3059\u308B\u305F\u3081\u306E\u7D71\u5408\u30CF\u30D6',\n      subtitle: '\u958B\u59CB\u3059\u308B\u30A2\u30D7\u30EA\u3092\u9078\u629E\u3057\u3066\u304F\u3060\u3055\u3044',\n      components: {\n        app_search: { label: '\u30A2\u30D7\u30EA\u3092\u691C\u7D22' },\n        app_grid: { label: '\u30A2\u30D7\u30EA\u30B0\u30EA\u30C3\u30C9' },\n      },\n    },\n    case_detail_page: {\n      label: '\u30B1\u30FC\u30B9\u8A73\u7D30',\n      description: '\u30B5\u30FC\u30D3\u30B9\u62C5\u5F53\u8005\u5411\u3051\u306E\u30B1\u30FC\u30B9\u30EC\u30B3\u30FC\u30C9\u30DA\u30FC\u30B8\uFF1A\u30CF\u30A4\u30E9\u30A4\u30C8\u3001SLA \u30D1\u30B9\u3001\u8A73\u7D30\u3001\u6D3B\u52D5\u30BF\u30A4\u30E0\u30E9\u30A4\u30F3\u3002',\n      title: '{case_number} \u00B7 {subject}',\n      subtitle: '{crm_account}',\n      components: {\n        case_highlights: { label: '\u91CD\u8981\u60C5\u5831' },\n        case_status_path: { label: '\u30B1\u30FC\u30B9\u30B9\u30C6\u30FC\u30BF\u30B9\u306E\u9032\u6357' },\n        case_details: { label: '\u30B1\u30FC\u30B9\u8A73\u7D30\u60C5\u5831' },\n      },\n    },\n    lead_detail_page: {\n      label: '\u30EA\u30FC\u30C9\u8A73\u7D30',\n      description: '\u30CF\u30A4\u30E9\u30A4\u30C8\u30FB\u8A73\u7D30\u30FB\u95A2\u9023\u60C5\u5831\u3092\u5099\u3048\u305F\u30EA\u30FC\u30C9\u306E\u7DCF\u5408\u8A73\u7D30\u30DA\u30FC\u30B8\u3002',\n      title: '{first_name} {last_name}',\n      subtitle: '{company}',\n      components: {\n        lead_duplicate_alert_confirmed: { label: '\u91CD\u8907\u78BA\u5B9A\u306E\u8B66\u544A' },\n        lead_duplicate_alert_suspected: { label: '\u91CD\u8907\u306E\u7591\u3044\u306E\u8B66\u544A' },\n        lead_highlights: { label: '\u91CD\u8981\u60C5\u5831' },\n        lead_path: { label: '\u30EA\u30FC\u30C9\u30B9\u30C6\u30FC\u30BF\u30B9\u306E\u9032\u6357' },\n        main_tabs: { label: '\u30EA\u30FC\u30C9\u60C5\u5831\u30BF\u30D6' },\n        lead_details: { label: '\u30EA\u30FC\u30C9\u8A73\u7D30\u60C5\u5831' },\n        related_accordion: { label: '\u95A2\u9023\u30EC\u30B3\u30FC\u30C9' },\n        related_tasks: { title: '\u672A\u5B8C\u4E86\u306E\u30BF\u30B9\u30AF', label: '\u30BF\u30B9\u30AF' },\n        lead_activity: { label: '\u6D3B\u52D5\u30BF\u30A4\u30E0\u30E9\u30A4\u30F3' },\n        lead_history: { label: '\u9805\u76EE\u5C65\u6B74' },\n      },\n    },\n    opportunity_detail_page: {\n      label: '\u5546\u8AC7\u8A73\u7D30',\n      description: '\u30B9\u30C6\u30FC\u30B8\u30D1\u30B9\u30FB\u30CF\u30A4\u30E9\u30A4\u30C8\u30FB\u8A73\u7D30\u30FB\u95A2\u9023\u30EA\u30B9\u30C8\u3092\u5099\u3048\u305F\u5546\u8AC7\u306E\u7DCF\u5408\u8A73\u7D30\u30DA\u30FC\u30B8\u3002',\n      title: '{name}',\n      subtitle: '{crm_account}',\n      components: {\n        opp_highlights: { label: '\u91CD\u8981\u60C5\u5831' },\n        opp_stage_path: { label: '\u5546\u8AC7\u30B9\u30C6\u30FC\u30B8\u306E\u9032\u6357' },\n        opp_details: { label: '\u5546\u8AC7\u8A73\u7D30\u60C5\u5831' },\n      },\n    },\n    sales_home_page: {\n      label: '\u55B6\u696D\u30DB\u30FC\u30E0',\n      description: '\u4E3B\u8981\u6307\u6A19\u3068\u30AF\u30A4\u30C3\u30AF\u30A2\u30AF\u30B7\u30E7\u30F3\u3092\u307E\u3068\u3081\u305F\u55B6\u696D\u30C1\u30FC\u30E0\u306E\u30DB\u30FC\u30E0\u30DA\u30FC\u30B8',\n      title: '\u55B6\u696D\u30C0\u30C3\u30B7\u30E5\u30DC\u30FC\u30C9',\n      subtitle: '\u304A\u304B\u3048\u308A\u306A\u3055\u3044',\n      components: {\n        kpi_revenue_won: {\n          label: '\u53D7\u6CE8\u58F2\u4E0A',\n        },\n        kpi_deals_won: {\n          label: '\u53D7\u6CE8\u4EF6\u6570',\n        },\n        kpi_pipeline_value: {\n          label: '\u30D1\u30A4\u30D7\u30E9\u30A4\u30F3\u91D1\u984D',\n        },\n        kpi_open_leads: {\n          label: '\u30AA\u30FC\u30D7\u30F3\u30EA\u30FC\u30C9',\n        },\n        home_upcoming_events: {\n          label: '\uD83D\uDCC5 \u958B\u50AC\u4E88\u5B9A \u00B7 \u76F4\u8FD1\u9806',\n        },\n        quick_create: { title: '\u30AF\u30A4\u30C3\u30AF\u4F5C\u6210', label: '\u30AF\u30A4\u30C3\u30AF\u4F5C\u6210' },\n        key_metrics: { title: '\u4E3B\u8981\u696D\u7E3E\u8A55\u4FA1\u6307\u6A19', label: '\u4E3B\u8981\u6307\u6A19' },\n        home_tabs: { label: '\u30DB\u30FC\u30E0\u30BF\u30D6' },\n        home_my_leads: { label: '\u79C1\u306E\u30EA\u30FC\u30C9' },\n        home_my_deals: { label: '\u79C1\u306E\u30AA\u30FC\u30D7\u30F3\u5546\u8AC7' },\n        home_my_tasks: { label: '\u79C1\u306E\u30AA\u30FC\u30D7\u30F3\u30BF\u30B9\u30AF' },\n        ai_briefing: {\n          title: 'AI \u30A2\u30B7\u30B9\u30BF\u30F3\u30C8\u306B\u8CEA\u554F',\n          label: '\u4ECA\u65E5\u306E AI \u30A2\u30B7\u30B9\u30BF\u30F3\u30C8',\n        },\n        upcoming_events: { title: '\u4ECA\u5F8C\u306E\u4E88\u5B9A', label: '\u4ECA\u5F8C\u306E\u4E88\u5B9A' },\n      },\n    },\n    utility_bar_page: {\n      label: '\u30E6\u30FC\u30C6\u30A3\u30EA\u30C6\u30A3\u30D0\u30FC',\n      description: '\u30D5\u30ED\u30FC\u30C6\u30A3\u30F3\u30B0\u30C4\u30FC\u30EB\u3078\u306E\u30AF\u30A4\u30C3\u30AF\u30A2\u30AF\u30BB\u30B9\u30D0\u30FC',\n      components: {\n        notifications_panel: { label: '\u901A\u77E5' },\n        quick_notes: { title: '\u30AF\u30A4\u30C3\u30AF\u30E1\u30E2', label: '\u30AF\u30A4\u30C3\u30AF\u30E1\u30E2' },\n        quick_search: { label: '\u30AF\u30A4\u30C3\u30AF\u691C\u7D22' },\n      },\n    },\n  },\n  // Screen-flow copy (#1210, #1975). Keyed `flows.<flow>.label`,\n  // `screens.<node>.title` and `screens.<node>.fields.<field>.{label,placeholder}`\n  // \u2014 the keys `os lint`'s `i18n/missing-flow` names, read by the console's\n  // flow runner since @objectstack 17.7.0 (the spec's `flows` liveness row is\n  // `live` there). A screen with no authored `title` shows its flow's label in\n  // every locale, so each `screen_1.title` repeats the flow label. Since\n  // 18.0.0-next.0 three more surfaces are keys the engine reads in the run's\n  // locale, and `i18n/missing-flow` names each missing one: a select field's\n  // `options.<value>` (worded as the object field's own option in this pack),\n  // an authored screen `description`, and a refusing `end` node's\n  // `refusals.<node>.message`. A translated description or message is a text\n  // slot like the one it translates, so a hole in it is `{{ }}`.\n  // The discount ceiling is interpolated from `QUOTE_DISCOUNT_CEILING`, never\n  // retyped: the number lives in `_thresholds.ts` alone (#1711).\n  flows: {\n    campaign_enrollment: {\n      label: '\u30AD\u30E3\u30F3\u30DA\u30FC\u30F3\u306B\u30E1\u30F3\u30D0\u30FC\u3092\u767B\u9332',\n      screens: {\n        screen_1: {\n          title: '\u30AD\u30E3\u30F3\u30DA\u30FC\u30F3\u306B\u30E1\u30F3\u30D0\u30FC\u3092\u767B\u9332',\n          fields: {\n            memberSource: { label: '\u767B\u9332\u3059\u308B\u30E1\u30F3\u30D0\u30FC\u306E\u7A2E\u985E', options: { leads: '\u30EA\u30FC\u30C9', contacts: '\u53D6\u5F15\u5148\u8CAC\u4EFB\u8005' } },\n            leadStatus: { label: '\u767B\u9332\u3059\u308B\u30EA\u30FC\u30C9\u306E\u30B9\u30C6\u30FC\u30BF\u30B9', options: { new: '\u65B0\u898F', contacted: '\u30B3\u30F3\u30BF\u30AF\u30C8\u6E08\u307F', qualified: '\u9069\u683C' } },\n            contactDepartment: {\n              label: '\u767B\u9332\u3059\u308B\u53D6\u5F15\u5148\u8CAC\u4EFB\u8005\u306E\u90E8\u9580',\n              options: { executive: '\u7D4C\u55B6\u5C64', sales: '\u55B6\u696D\u90E8', marketing: '\u30DE\u30FC\u30B1\u30C6\u30A3\u30F3\u30B0\u90E8', engineering: '\u30A8\u30F3\u30B8\u30CB\u30A2\u30EA\u30F3\u30B0\u90E8', support: '\u30B5\u30DD\u30FC\u30C8\u90E8', finance: '\u7D4C\u7406\u90E8', hr: '\u4EBA\u4E8B\u90E8', operations: '\u30AA\u30DA\u30EC\u30FC\u30B7\u30E7\u30F3\u90E8' },\n            },\n          },\n        },\n      },\n    },\n    escalate_case: {\n      label: '\u30B1\u30FC\u30B9\u3092\u30A8\u30B9\u30AB\u30EC\u30FC\u30C8',\n      screens: { screen_1: { title: '\u30B1\u30FC\u30B9\u3092\u30A8\u30B9\u30AB\u30EC\u30FC\u30C8', fields: { reason: { label: '\u30A8\u30B9\u30AB\u30EC\u30FC\u30B7\u30E7\u30F3\u7406\u7531' } } } },\n    },\n    close_case: {\n      label: '\u30B1\u30FC\u30B9\u3092\u30AF\u30ED\u30FC\u30BA',\n      screens: {\n        screen_1: {\n          title: '\u30B1\u30FC\u30B9\u3092\u30AF\u30ED\u30FC\u30BA',\n          fields: {\n            resolution: { label: '\u89E3\u6C7A\u5185\u5BB9' },\n            resolved_by_article: { label: '\u89E3\u6C7A\u306B\u4F7F\u3063\u305F\u30CA\u30EC\u30C3\u30B8\u8A18\u4E8B\uFF08\u4EFB\u610F\uFF09' },\n          },\n        },\n      },\n    },\n    claim_case: {\n      label: '\u30B1\u30FC\u30B9\u3092\u5F15\u304D\u53D7\u3051\u308B',\n      screens: {\n        screen_1: {\n          title: '\u30B1\u30FC\u30B9\u3092\u5F15\u304D\u53D7\u3051\u308B',\n          fields: {\n            claimStatus: {\n              label: '\u5BFE\u5FDC\u72B6\u6CC1',\n              options: { in_progress: '\u5BFE\u5FDC\u4E2D', waiting_customer: '\u9867\u5BA2\u306E\u56DE\u7B54\u5F85\u3061', waiting_support: '\u30B5\u30DD\u30FC\u30C8\u306E\u56DE\u7B54\u5F85\u3061' },\n            },\n          },\n        },\n      },\n    },\n    lead_conversion: {\n      label: '\u30EA\u30FC\u30C9\u5909\u63DB\u30D7\u30ED\u30BB\u30B9',\n      screens: {\n        screen_1: {\n          title: '\u30EA\u30FC\u30C9\u5909\u63DB\u30D7\u30ED\u30BB\u30B9',\n          // The duplicate warning's text is a variable the flow assigns; this\n          // key can only carry the hole that shows it.\n          description: '{{duplicateWarning}}',\n          fields: {\n            createOpportunity: { label: '\u5546\u8AC7\u3092\u4F5C\u6210\u3057\u307E\u3059\u304B\uFF1F' },\n            opportunityName: { label: '\u5546\u8AC7\u540D' },\n            opportunityAmount: { label: '\u5546\u8AC7\u91D1\u984D' },\n            closeDate: { label: '\u5B8C\u4E86\u4E88\u5B9A\u65E5' },\n          },\n        },\n        refuse_confirmed_duplicate: {\n          title: '\u5909\u63DB\u306F\u62D2\u5426\u3055\u308C\u307E\u3057\u305F',\n          description:\n            '\u3053\u306E\u30EA\u30FC\u30C9\u306E\u91CD\u8907\u30B9\u30C6\u30FC\u30BF\u30B9\u306F\u300C\u91CD\u8907\u78BA\u5B9A\u300D\u3067\u3059\u3002\u30EC\u30D3\u30E5\u30FC\u62C5\u5F53\u8005\u304C\u65E2\u5B58\u306E\u30EC\u30B3\u30FC\u30C9\u3068\u7167\u5408\u3057\u3001\u91CD\u8907\u3067\u3042\u308B\u3068\u8A18\u9332\u3057\u307E\u3057\u305F\u3002\u5909\u63DB\u3059\u308B\u3068\u3001\u540C\u3058\u8CFC\u5165\u8005\u306B\u5BFE\u3057\u3066\u53D6\u5F15\u5148\u30FB\u53D6\u5F15\u5148\u8CAC\u4EFB\u8005\u30FB\u5546\u8AC7\u304C\u3082\u3046 1 \u4EF6\u305A\u3064\u4F5C\u6210\u3055\u308C\u307E\u3059\u3002\u6B8B\u3059\u30EC\u30B3\u30FC\u30C9\u306F\u3053\u306E\u30EA\u30FC\u30C9\u306E\u300C\u91CD\u8907\u7BA1\u7406\u300D\u30BB\u30AF\u30B7\u30E7\u30F3\u306B\u8868\u793A\u3055\u308C\u3066\u3044\u307E\u3059\u3002\u4EE3\u308F\u308A\u306B\u3001\u3053\u306E\u30EA\u30FC\u30C9\u3092\u91CD\u8907\u3068\u3057\u3066\u4E0D\u9069\u683C\u306B\u3057\u3066\u304F\u3060\u3055\u3044\u3002\u5909\u63DB\u3092\u518D\u3073\u53EF\u80FD\u306B\u3067\u304D\u308B\u306E\u306F\u3001\u305D\u306E\u5224\u5B9A\u3092\u898B\u76F4\u3059\u30EC\u30D3\u30E5\u30FC\u62C5\u5F53\u8005\u3060\u3051\u3067\u3059\u3002',\n        },\n        refuse_unapproved: {\n          title: '\u5909\u63DB\u306F\u62D2\u5426\u3055\u308C\u307E\u3057\u305F',\n          description:\n            '\u3053\u306E\u30EA\u30FC\u30C9\u306F\u307E\u3060\u5909\u63DB\u306E\u627F\u8A8D\u3092\u5F97\u3066\u3044\u307E\u305B\u3093\u3002\u53D6\u5F15\u5148\u30FB\u53D6\u5F15\u5148\u8CAC\u4EFB\u8005\u30FB\u5546\u8AC7\u306B\u5909\u63DB\u3059\u308B\u306B\u306F\u3001\u5148\u306B\u627F\u8A8D\u8005\u306E\u627F\u8A8D\u304C\u5FC5\u8981\u3067\u3059\u3002\u30EA\u30FC\u30C9\u306E\u300C\u30B3\u30F3\u30D0\u30FC\u30B8\u30E7\u30F3\u627F\u8A8D\u300D\u9805\u76EE\u3067\u3001\u5224\u65AD\u304C\u307E\u3060\u627F\u8A8D\u5F85\u3061\u304B\u3001\u5374\u4E0B\u3055\u308C\u305F\u304B\u3092\u78BA\u8A8D\u3067\u304D\u307E\u3059\u3002\u305D\u308C\u307E\u3067\u306E\u9593\u3082\u30EA\u30FC\u30C9\u3078\u306E\u5BFE\u5FDC\u306F\u7D9A\u3051\u3066\u304F\u3060\u3055\u3044\u3002\u51CD\u7D50\u3055\u308C\u308B\u3082\u306E\u306F\u3042\u308A\u307E\u305B\u3093\u3002',\n        },\n        refuse_no_match_key: {\n          title: '\u5909\u63DB\u306F\u62D2\u5426\u3055\u308C\u307E\u3057\u305F',\n          description:\n            '\u3053\u306E\u30EA\u30FC\u30C9\u306E\u4F1A\u793E\u540D\u306B\u306F\u7167\u5408\u30AD\u30FC\u304C\u306A\u3044\u305F\u3081\u3001\u5909\u63DB\u3067\u306F\u3069\u306E\u53D6\u5F15\u5148\u306B\u5C5E\u3059\u308B\u304B\u3092\u5224\u65AD\u3067\u304D\u305A\u3001\u63A8\u6E2C\u3082\u3057\u307E\u305B\u3093\u3002\u63A8\u6E2C\u3059\u308B\u3068\u3001\u53D6\u5F15\u5148\u8CAC\u4EFB\u8005\u3068\u5546\u8AC7\u304C\u5225\u306E\u9867\u5BA2\u306E\u4E0B\u306B\u767B\u9332\u3055\u308C\u308B\u304A\u305D\u308C\u304C\u3042\u308A\u307E\u3059\u3002\u30EA\u30FC\u30C9\u306E\u300C\u4F1A\u793E\u540D\u300D\u3092\u4FDD\u5B58\u3059\u308B\u3068\u30AD\u30FC\u304C\u518D\u4F5C\u6210\u3055\u308C\u308B\u306E\u3067\u3001\u3082\u3046\u4E00\u5EA6\u4FDD\u5B58\u3057\u3066\u304B\u3089\u5909\u63DB\u3057\u3066\u304F\u3060\u3055\u3044\u3002\u4F55\u3082\u4F5C\u6210\u3055\u308C\u3066\u3044\u307E\u305B\u3093\u3002',\n        },\n      },\n    },\n    schedule_followup: {\n      label: '\u30D5\u30A9\u30ED\u30FC\u30A2\u30C3\u30D7\u3092\u8A2D\u5B9A',\n      screens: {\n        screen_1: {\n          title: '\u30D5\u30A9\u30ED\u30FC\u30A2\u30C3\u30D7\u3092\u8A2D\u5B9A',\n          fields: {\n            subject: { label: '\u6B21\u306E\u30B9\u30C6\u30C3\u30D7\u306F\uFF1F' },\n            dueDate: { label: '\u671F\u9650' },\n            activityType: {\n              label: '\u6D3B\u52D5\u7A2E\u5225',\n              options: { call: '\u96FB\u8A71', email: '\u30E1\u30FC\u30EB', meeting: '\u4F1A\u8B70', follow_up: '\u30D5\u30A9\u30ED\u30FC\u30A2\u30C3\u30D7', demo: '\u30C7\u30E2', other: '\u305D\u306E\u4ED6' },\n            },\n            priority: { label: '\u512A\u5148\u5EA6', options: { low: '\u4F4E', normal: '\u901A\u5E38', high: '\u9AD8', urgent: '\u7DCA\u6025' } },\n            notes: { label: '\u30E1\u30E2' },\n          },\n        },\n      },\n    },\n    quote_generation: {\n      label: '\u5546\u8AC7\u304B\u3089\u898B\u7A4D\u3092\u4F5C\u6210',\n      refusals: { refuse_held: { message: '\u5148\u306B\u6848\u4EF6\u5316\u627F\u8A8D\u304C\u5FC5\u8981\u3067\u3059\u3002\u300C\u6848\u4EF6\u5316\u627F\u8A8D\u3092\u7533\u8ACB\u300D\u306B\u30C1\u30A7\u30C3\u30AF\u3092\u5165\u308C\u3066\u304F\u3060\u3055\u3044\u3002\u4F55\u3082\u4F5C\u6210\u3055\u308C\u3066\u3044\u307E\u305B\u3093\u3002' } },\n      screens: {\n        screen_1: {\n          title: '\u5546\u8AC7\u304B\u3089\u898B\u7A4D\u3092\u4F5C\u6210',\n          fields: {\n            quoteName: { label: '\u898B\u7A4D\u540D' },\n            expirationDays: { label: '\u6709\u52B9\u671F\u9593\uFF08\u65E5\uFF09' },\n            discount: { label: `\u5272\u5F15\u7387 % (\u2264 ${QUOTE_DISCOUNT_CEILING})`, placeholder: `0-${QUOTE_DISCOUNT_CEILING}` },\n          },\n        },\n      },\n    },\n  },\n};\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/sales/translations/ja-JP/_shared.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/sales/translations/ja-JP\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/sales/translations/ja-JP/_shared.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\n/**\n * \u65E5\u672C\u8A9E (ja-JP) \u2014 values shared by more than one part of this bundle.\n *\n * SPLIT AXIS (#1311): translation NAMESPACE first, then CRM DOMAIN FAMILY.\n * Everything that is not `objects` lives in `./app.ts`; `objects` \u2014 69-78% of\n * every bundle \u2014 is one file per CRM domain family, and a detail object\n * follows its master. A new row goes in the file for ITS family, never in\n * whichever file is already open: that is how one file re-grows past the 70%\n * advisory band `pnpm hygiene` prints. Full rule and rationale:\n * `src/sales/translations/ja-JP.ts`.\n *\n * Every constant here is spread into object rows that live in MORE THAN ONE\n * family file, so it cannot sit in any one of them. A value used by exactly\n * one family lives in that family's file instead \u2014 that split is mechanical,\n * not a judgement call.\n */\n\n/**\n * \u6D3B\u52D5\u30A2\u30AF\u30B7\u30E7\u30F3\u7FA4\uFF08#592\uFF09: `log_call` / `log_meeting` / `schedule_meeting` \u306F\n * \u30EA\u30FC\u30C9\u30FB\u53D6\u5F15\u5148\u8CAC\u4EFB\u8005\u30FB\u53D6\u5F15\u5148\u30FB\u5546\u8AC7\u30FB\u30B1\u30FC\u30B9\u306E\u5404\u30AA\u30D6\u30B8\u30A7\u30AF\u30C8\u3054\u3068\u306B\u767B\u9332\u3055\u308C\u308B\n * \uFF08`objectName` \u3092\u6301\u305F\u306A\u3044\u30B9\u30AF\u30EA\u30D7\u30C8\u30A2\u30AF\u30B7\u30E7\u30F3\u306F\u30C7\u30A3\u30B9\u30D1\u30C3\u30C1\u30E3\u304C\u53C2\u7167\u3057\u306A\u3044\n * \u30AD\u30FC\u306B\u767B\u9332\u3055\u308C\u308B\u305F\u3081 \u2014 #509\uFF09\u3002\u6587\u8A00\u306F 5 \u30AA\u30D6\u30B8\u30A7\u30AF\u30C8\u3067\u540C\u4E00\u306A\u306E\u3067\u3001\u3053\u3053\u3067\n * \u4E00\u5EA6\u3060\u3051\u5B9A\u7FA9\u3057\u3066\u5404 `_actions` \u306B\u5C55\u958B\u3059\u308B\u3002\n */\nexport const activityActions = {\n  log_call: {\n    label: '\u96FB\u8A71\u3092\u8A18\u9332',\n    successMessage: '\u96FB\u8A71\u3092\u8A18\u9332\u3057\u307E\u3057\u305F\uFF01',\n    params: {\n      subject: { label: '\u96FB\u8A71\u306E\u4EF6\u540D' },\n      duration: { label: '\u6240\u8981\u6642\u9593\uFF08\u5206\uFF09' },\n      attendee_contacts: { label: '\u53D6\u5F15\u5148\u8CAC\u4EFB\u8005\u306E\u53C2\u52A0\u8005' },\n      attendee_users: { label: '\u793E\u5185\u53C2\u52A0\u8005' },\n      notes: { label: '\u901A\u8A71\u30E1\u30E2' },\n    },\n  },\n  log_meeting: {\n    label: '\u4F1A\u8B70\u3092\u8A18\u9332',\n    successMessage: '\u4F1A\u8B70\u3092\u8A18\u9332\u3057\u307E\u3057\u305F\uFF01',\n    params: {\n      subject: { label: '\u4F1A\u8B70\u306E\u4EF6\u540D' },\n      duration: { label: '\u6240\u8981\u6642\u9593\uFF08\u5206\uFF09' },\n      attendee_contacts: { label: '\u53D6\u5F15\u5148\u8CAC\u4EFB\u8005\u306E\u53C2\u52A0\u8005' },\n      attendee_users: { label: '\u793E\u5185\u53C2\u52A0\u8005' },\n      notes: { label: '\u8B70\u4E8B\u30E1\u30E2' },\n    },\n  },\n  schedule_meeting: {\n    label: '\u4F1A\u8B70\u3092\u8A2D\u5B9A',\n    successMessage: '\u4F1A\u8B70\u3092\u8A2D\u5B9A\u3057\u307E\u3057\u305F\uFF01',\n    params: {\n      subject: { label: '\u4F1A\u8B70\u306E\u4EF6\u540D' },\n      start_date: { label: '\u958B\u59CB\u65E5 (UTC)' },\n      start_time: { label: '\u958B\u59CB\u6642\u523B (UTC)' },\n      location: { label: '\u5834\u6240' },\n      duration: { label: '\u6240\u8981\u6642\u9593\uFF08\u5206\uFF09' },\n      attendee_contacts: { label: '\u53D6\u5F15\u5148\u8CAC\u4EFB\u8005\u306E\u53C2\u52A0\u8005' },\n      attendee_users: { label: '\u793E\u5185\u53C2\u52A0\u8005' },\n      notes: { label: '\u30A2\u30B8\u30A7\u30F3\u30C0' },\n    },\n  },\n};\n\n/**\n * \u5171\u6709\u30D4\u30C3\u30AF\u30EA\u30B9\u30C8\uFF08`_picklists.ts`\uFF09\u306F\u8907\u6570\u30AA\u30D6\u30B8\u30A7\u30AF\u30C8\u3067\u540C\u4E00\u306E\u5024\u96C6\u5408\u3092\u6301\u3064\u3002\n * \u8A33\u8A9E\u304C\u30AA\u30D6\u30B8\u30A7\u30AF\u30C8\u3054\u3068\u306B\u3076\u308C\u308B\u3068\u3001\u540C\u3058\u30D4\u30C3\u30AF\u30EA\u30B9\u30C8\u304C\u753B\u9762\u306B\u3088\u3063\u3066\u5225\u306E\u8A00\u8449\u3067\n * \u8868\u793A\u3055\u308C\u308B\u4E0D\u5177\u5408\u306B\u306A\u308B\uFF08#494\uFF09\u3002\u3053\u3053\u3067\u4E00\u5EA6\u3060\u3051\u5B9A\u7FA9\u3057\u3066\u5404\u6240\u306B\u5C55\u958B\u3059\u308B\u3002\n * \u30AD\u30FC\u306F\u8868\u793A\u30E9\u30D9\u30EB\u3067\u306F\u306A\u304F **\u4FDD\u5B58\u5024** \u3067\u3042\u308B\u3053\u3068\u306B\u6CE8\u610F\uFF08#494 \u306E\u4E3B\u56E0\uFF09\u3002\n */\nexport const salutationOptions = { mr: 'Mr.', ms: 'Ms.', mrs: 'Mrs.', dr: '\u535A\u58EB', prof: '\u6559\u6388' };\n\nexport const industryOptions = {\n  technology: '\u30C6\u30AF\u30CE\u30ED\u30B8\u30FC', software: '\u30BD\u30D5\u30C8\u30A6\u30A7\u30A2 / SaaS', finance: '\u91D1\u878D',\n  healthcare: '\u30D8\u30EB\u30B9\u30B1\u30A2', retail: '\u5C0F\u58F2', manufacturing: '\u88FD\u9020',\n  education: '\u6559\u80B2', real_estate: '\u4E0D\u52D5\u7523', media: '\u30E1\u30C7\u30A3\u30A2\u30FB\u30A8\u30F3\u30BF\u30E1',\n  logistics: '\u7269\u6D41', hospitality: '\u30DB\u30B9\u30D4\u30BF\u30EA\u30C6\u30A3', energy: '\u30A8\u30CD\u30EB\u30AE\u30FC\u30FB\u516C\u76CA',\n  government: '\u653F\u5E9C\u30FB\u884C\u653F', nonprofit: '\u975E\u55B6\u5229', other: '\u305D\u306E\u4ED6',\n};\n\nexport const leadSourceOptions = {\n  web: '\u30A6\u30A7\u30D6', referral: '\u7D39\u4ECB', event: '\u30A4\u30D9\u30F3\u30C8\u30FB\u5C55\u793A\u4F1A',\n  webinar: '\u30A6\u30A7\u30D3\u30CA\u30FC', partner: '\u30D1\u30FC\u30C8\u30CA\u30FC', advertisement: '\u5E83\u544A',\n  paid_search: '\u6709\u6599\u691C\u7D22', social: '\u30BD\u30FC\u30B7\u30E3\u30EB\u30E1\u30C7\u30A3\u30A2', content: '\u30B3\u30F3\u30C6\u30F3\u30C4\u30FB\u30D6\u30ED\u30B0',\n  cold_call: '\u30B3\u30FC\u30EB\u30C9\u30B3\u30FC\u30EB', email_campaign: '\u30E1\u30FC\u30EB\u30AD\u30E3\u30F3\u30DA\u30FC\u30F3', other: '\u305D\u306E\u4ED6',\n};\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/sales/translations/ja-JP/objects.customer.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/sales/translations/ja-JP\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/sales/translations/ja-JP/objects.customer.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport type { ObjectTranslationData } from '@objectstack/spec/system';\n\nimport { activityActions, salutationOptions, industryOptions, leadSourceOptions } from './_shared';\n\n/**\n * \u65E5\u672C\u8A9E (ja-JP) \u2014 `objects` translations for the CUSTOMER family:\n * the customer record itself \u2014 accounts and the people at them.\n *\n * Roster: `crm_account`, `crm_contact`.\n *\n * SPLIT AXIS (#1311): translation NAMESPACE first, then CRM DOMAIN FAMILY.\n * Everything that is not `objects` lives in `./app.ts`; `objects` \u2014 69-78% of\n * every bundle \u2014 is one file per CRM domain family, and a detail object\n * follows its master. A new row goes in the file for ITS family, never in\n * whichever file is already open: that is how one file re-grows past the 70%\n * advisory band `pnpm hygiene` prints. Full rule and rationale:\n * `src/sales/translations/ja-JP.ts`.\n */\nexport const customer: Record<string, ObjectTranslationData> = {\n  crm_account: {\n    label: '\u53D6\u5F15\u5148',\n    pluralLabel: '\u53D6\u5F15\u5148',\n    description: '\u5F53\u793E\u3068\u53D6\u5F15\u306E\u3042\u308B\u4F01\u696D\u30FB\u7D44\u7E54',\n    fields: {\n      account_number: { label: '\u53D6\u5F15\u5148\u756A\u53F7' },\n      registration_number: {\n        label: '\u767B\u8A18\u756A\u53F7',\n        help: '\u53D6\u5F15\u5148\u304C\u81EA\u56FD\u306E\u767B\u8A18\u6A5F\u95A2\u304B\u3089\u4EA4\u4ED8\u3055\u308C\u305F\u767B\u8A18\u4E0A\u306E\u8B58\u5225\u756A\u53F7\u3002\u5F53\u793E\u304C\u63A1\u756A\u3059\u308B\u53D6\u5F15\u5148\u756A\u53F7\u3068\u306F\u7570\u306A\u308A\u307E\u3059\u3002',\n      },\n      commercial_capability: {\n        label: '\u5546\u8AC7\u53EF\u5426\u533A\u5206',\n        help: '\u3053\u306E\u53D6\u5F15\u5148\u306B\u5BFE\u3057\u3066\u65B0\u898F\u306E\u5546\u8AC7\u3092\u958B\u59CB\u3067\u304D\u308B\u304B\u3069\u3046\u304B\u3002\u6C7A\u6E08\u306E\u307F\u306E\u53D6\u5F15\u5148\u306F\u8ACB\u6C42\u30FB\u5165\u91D1\u306B\u306F\u5F15\u304D\u7D9A\u304D\u5229\u7528\u3067\u304D\u307E\u3059\u304C\u3001\u65B0\u898F\u5546\u8AC7\u3092\u95A2\u9023\u4ED8\u3051\u308B\u3053\u3068\u306F\u3067\u304D\u307E\u305B\u3093\u3002',\n        options: { full: '\u5236\u9650\u306A\u3057', settlement_only: '\u6C7A\u6E08\u306E\u307F' },\n      },\n      incumbent_vendor: { label: '\u73FE\u884C\u30D9\u30F3\u30C0\u30FC', help: '\u5F53\u793E\u304C\u72D9\u3063\u3066\u3044\u308B\u652F\u51FA\u3092\u73FE\u5728\u53D7\u6CE8\u3057\u3066\u3044\u308B\u30D9\u30F3\u30C0\u30FC\u3002' },\n      annual_purchasing_budget: { label: '\u5E74\u9593\u8ABF\u9054\u4E88\u7B97', help: '\u3053\u306E\u53D6\u5F15\u5148\u304C\u4ECA\u5E74\u5EA6\u30D9\u30F3\u30C0\u30FC\u306B\u652F\u51FA\u3059\u308B\u898B\u8FBC\u307F\u984D\u3067\u3042\u308A\u3001\u81EA\u793E\u306E\u58F2\u4E0A\u9AD8\u3067\u306F\u3042\u308A\u307E\u305B\u3093\u3002' },\n      payment_cycle: {\n        label: '\u652F\u6255\u30B5\u30A4\u30AF\u30EB',\n        options: { prepaid: '\u524D\u6255\u3044', net_30: '30\u65E5', net_60: '60\u65E5', net_90: '90\u65E5' },\n      },\n      approval_status: {\n        label: '\u627F\u8A8D\u30B9\u30C6\u30FC\u30BF\u30B9',\n        help: '\u3053\u306E\u53D6\u5F15\u5148\u306E\u627F\u8A8D\u72B6\u6CC1\u3002\u65B0\u898F\u53D6\u5F15\u5148\u306F\u627F\u8A8D\u5F85\u3061\u3067\u4F5C\u6210\u3055\u308C\u3001\u627F\u8A8D\u30C8\u30EC\u30A4\u3067\u5224\u65AD\u3055\u308C\u307E\u3059\u3002',\n        options: { pending: '\u627F\u8A8D\u5F85\u3061', approved: '\u627F\u8A8D\u6E08\u307F', rejected: '\u5374\u4E0B' },\n      },\n      name: { label: '\u53D6\u5F15\u5148\u540D', help: '\u4F1A\u793E\u307E\u305F\u306F\u7D44\u7E54\u306E\u6B63\u5F0F\u540D\u79F0' },\n      name_normalized: {\n        label: '\u53D6\u5F15\u5148\u540D\uFF08\u6B63\u898F\u5316\uFF09',\n        help: '\u30EA\u30FC\u30C9\u5909\u63DB\u306E\u7167\u5408\u30AD\u30FC\u3002\u53D6\u5F15\u5148\u540D\u3092\u5C0F\u6587\u5B57\u5316\u3057\u3001\u524D\u5F8C\u306E\u7A7A\u767D\u3092\u9664\u53BB\u3057\u3066\u3001\u5185\u90E8\u306E\u9023\u7D9A\u3059\u308B\u7A7A\u767D\u3092 1 \u3064\u306B\u307E\u3068\u3081\u305F\u3082\u306E\u3002account_protection \u30D5\u30C3\u30AF\u304C\u81EA\u52D5\u3067\u7DAD\u6301\u3057\u307E\u3059 \u2014 \u76F4\u63A5\u7DE8\u96C6\u3057\u306A\u3044\u3067\u304F\u3060\u3055\u3044\u3002',\n      },\n      display_title: { label: '\u8868\u793A\u540D' },\n      type: {\n        label: '\u30BF\u30A4\u30D7',\n        options: { prospect: '\u898B\u8FBC\u307F\u5BA2', customer: '\u9867\u5BA2', partner: '\u30D1\u30FC\u30C8\u30CA\u30FC', former: '\u904E\u53BB\u306E\u53D6\u5F15\u5148' },\n      },\n      industry: {\n        label: '\u696D\u7A2E',\n        options: { ...industryOptions },\n      },\n      annual_revenue: { label: '\u5E74\u9593\u58F2\u4E0A' },\n      child_account_revenue: { label: '\u5B50\u4F1A\u793E\u5E74\u9593\u58F2\u4E0A\u5408\u8A08', help: '\u76F4\u5C5E\u306E\u5B50\u53D6\u5F15\u5148\u306E\u5E74\u9593\u58F2\u4E0A\u306E\u5408\u8A08\u3002' },\n      number_of_employees: { label: '\u5F93\u696D\u54E1\u6570' },\n      phone: { label: '\u96FB\u8A71\u756A\u53F7' },\n      website: { label: 'Web\u30B5\u30A4\u30C8' },\n      billing_address: { label: '\u8ACB\u6C42\u5148\u4F4F\u6240' },\n      billing_country: {\n        label: '\u8ACB\u6C42\u5148\u56FD',\n        help: '\u8ACB\u6C42\u5148\u4F4F\u6240\u304B\u3089\u5C0E\u51FA \u2014 \u5165\u529B\u3055\u308C\u305F\u56FD\u540D\u3092\u305D\u306E\u307E\u307E\u3001\u524D\u5F8C\u306E\u7A7A\u767D\u3092\u9664\u53BB\u3057\u5927\u6587\u5B57\u5316\u3057\u305F\u5024\u3002',\n      },\n      territory: {\n        label: '\u30C6\u30EA\u30C8\u30EA\u30FC',\n        help: '\u8ACB\u6C42\u5148\u4F4F\u6240\u304B\u3089\u5C0E\u51FA \u2014 \u30C6\u30EA\u30C8\u30EA\u30FC\u5171\u6709\u30EB\u30FC\u30EB\u304C\u7167\u5408\u3059\u308B\u55B6\u696D\u30C6\u30EA\u30C8\u30EA\u30FC\u3002\u62C5\u5F53\u30C1\u30FC\u30E0\u306E\u306A\u3044\u30C6\u30EA\u30C8\u30EA\u30FC\u306E\u53D6\u5F15\u5148\u306F\u300C\u305D\u306E\u4ED6\u300D\u3002',\n        options: { na: '\u5317\u7C73', emea: 'EMEA', other: '\u305D\u306E\u4ED6' },\n      },\n      office_location: { label: '\u30AA\u30D5\u30A3\u30B9\u6240\u5728\u5730' },\n      owner_id: { label: '\u53D6\u5F15\u5148\u6240\u6709\u8005' },\n      parent_account: { label: '\u89AA\u53D6\u5F15\u5148', help: '\u968E\u5C64\u69CB\u9020\u306B\u304A\u3051\u308B\u89AA\u4F1A\u793E' },\n      description: { label: '\u8AAC\u660E' },\n      is_active: { label: '\u6709\u52B9' },\n      last_activity_date: { label: '\u6700\u7D42\u6D3B\u52D5\u65E5' },\n      brand_color: { label: '\u30D6\u30E9\u30F3\u30C9\u30AB\u30E9\u30FC' },\n      logo: { label: '\u4F1A\u793E\u30ED\u30B4' },\n      tier: {\n        label: '\u9867\u5BA2\u30E9\u30F3\u30AF',\n        options: {\n          strategic: '\u6226\u7565\u9867\u5BA2', enterprise: '\u30A8\u30F3\u30BF\u30FC\u30D7\u30E9\u30A4\u30BA',\n          mid_market: '\u30DF\u30C3\u30C9\u30DE\u30FC\u30B1\u30C3\u30C8', smb: '\u4E2D\u5C0F\u4F01\u696D',\n        },\n      },\n      segment: {\n        label: '\u9867\u5BA2\u30BB\u30B0\u30E1\u30F3\u30C8',\n        options: { net_new: '\u65B0\u898F\u7372\u5F97', growth: '\u6210\u9577', at_risk: '\u30EA\u30B9\u30AF\u3042\u308A', stable: '\u5B89\u5B9A' },\n      },\n      health_score: {\n        label: '\u30D8\u30EB\u30B9\u30B9\u30B3\u30A2',\n        help: '\u30AB\u30B9\u30BF\u30DE\u30FC\u30B5\u30AF\u30BB\u30B9\u62C5\u5F53\uFF08CSM\uFF09\u304C\u7BA1\u7406\u3059\u308B\u5065\u5168\u6027\u306E\u6307\u6A19',\n        options: { healthy: '\u826F\u597D', watching: '\u8981\u89B3\u5BDF', at_risk: '\u30EA\u30B9\u30AF\u3042\u308A', churning: '\u89E3\u7D04\u9032\u884C\u4E2D' },\n      },\n    },\n    _views: {\n      all_accounts: {\n        label: '\u5168\u53D6\u5F15\u5148', description: '\u58F2\u4E0A\u3068\u696D\u7A2E\u3092\u542B\u3080\u53D6\u5F15\u5148\u306E\u4E00\u89A7',\n        bulkActions: {\n          delete: {\n            label: '\u524A\u9664',\n            confirmLabel: '\u524A\u9664',\n            confirmText: '{{count}} \u4EF6\u306E\u53D6\u5F15\u5148\u3092\u5B8C\u5168\u306B\u524A\u9664\u3057\u307E\u3059\u304B\uFF1F\u3053\u306E\u64CD\u4F5C\u306F\u53D6\u308A\u6D88\u305B\u307E\u305B\u3093\u3002',\n          },\n          transfer_owner: {\n            label: '\u6240\u6709\u8005\u306E\u5909\u66F4',\n            confirmText: '{{count}} \u4EF6\u306E\u53D6\u5F15\u5148\u306E\u6240\u6709\u8005\u3092\u5909\u66F4\u3057\u307E\u3059\u304B\uFF1F',\n            params: {\n              owner_id: {\n                label: '\u65B0\u3057\u3044\u6240\u6709\u8005',\n              },\n            },\n          },\n          update_tier: {\n            label: '\u9867\u5BA2\u30E9\u30F3\u30AF\u306E\u66F4\u65B0',\n            confirmText: '{{count}} \u4EF6\u306E\u53D6\u5F15\u5148\u306E\u9867\u5BA2\u30E9\u30F3\u30AF\u3092 {{tier}} \u306B\u66F4\u65B0\u3057\u307E\u3059\u304B\uFF1F',\n            params: {\n              tier: {\n                label: '\u9867\u5BA2\u30E9\u30F3\u30AF',\n              },\n            },\n          },\n        },\n      },\n      account_gallery: { label: '\u53D6\u5F15\u5148\u30AB\u30FC\u30C9', description: '\u30D6\u30E9\u30F3\u30C9\u30AB\u30E9\u30FC\u4ED8\u304D\u306E\u30AB\u30FC\u30C9\u30D3\u30E5\u30FC' },\n      account_map: { label: '\u53D6\u5F15\u5148\u30DE\u30C3\u30D7', description: '\u53D6\u5F15\u5148\u306E\u5730\u7406\u7684\u5206\u5E03' },\n      enterprise_accounts: { label: '\u30A8\u30F3\u30BF\u30FC\u30D7\u30E9\u30A4\u30BA\u53D6\u5F15\u5148', description: '\u5E74\u5546\u6700\u4E0A\u4F4D\u306E\u4E3B\u8981\u9867\u5BA2' },\n      my_accounts: { label: '\u79C1\u306E\u53D6\u5F15\u5148', description: '\u81EA\u5206\u304C\u6240\u6709\u3059\u308B\u53D6\u5F15\u5148' },\n      at_risk_accounts: { label: '\u26A0\uFE0F \u30EA\u30B9\u30AF\u306E\u3042\u308B\u53D6\u5F15\u5148' },\n    },\n    _sections: {\n      basic: { label: '\u57FA\u672C\u60C5\u5831' },\n      financials: { label: '\u8CA1\u52D9\u60C5\u5831' },\n      business_profile: { label: '\u30D3\u30B8\u30CD\u30B9\u60C5\u5831' },\n      contact_info: { label: '\u9023\u7D61\u5148\u60C5\u5831' },\n      ownership: { label: '\u6240\u6709\u8005\u30FB\u30B9\u30C6\u30FC\u30BF\u30B9' },\n      branding: { label: '\u30D6\u30E9\u30F3\u30C7\u30A3\u30F3\u30B0' },\n      system: { label: '\u30B7\u30B9\u30C6\u30E0' },\n      // account.view.ts \u306E\u30D5\u30A9\u30FC\u30E0\u30BB\u30AF\u30B7\u30E7\u30F3\u540D (#1100)\n      profile: { label: '\u30D7\u30ED\u30D5\u30A3\u30FC\u30EB' },\n      customer_success: { label: '\u30AB\u30B9\u30BF\u30DE\u30FC\u30B5\u30AF\u30BB\u30B9' },\n      locations: { label: '\u6240\u5728\u5730' },\n      description: { label: '\u8AAC\u660E' },\n    },\n    _actions: { ...activityActions },\n  },\n  crm_contact: {\n    label: '\u53D6\u5F15\u5148\u8CAC\u4EFB\u8005',\n    pluralLabel: '\u53D6\u5F15\u5148\u8CAC\u4EFB\u8005',\n    description: '\u53D6\u5F15\u5148\u306B\u6240\u5C5E\u3059\u308B\u62C5\u5F53\u8005',\n    fields: {\n      salutation: { label: '\u656C\u79F0', options: { ...salutationOptions } },\n      first_name: { label: '\u540D' },\n      last_name: { label: '\u59D3' },\n      full_name: { label: '\u6C0F\u540D' },\n      crm_account: { label: '\u53D6\u5F15\u5148' },\n      email: { label: '\u30E1\u30FC\u30EB' },\n      phone: { label: '\u96FB\u8A71' },\n      mobile: { label: '\u643A\u5E2F\u96FB\u8A71' },\n      title: { label: '\u5F79\u8077' },\n      department: {\n        label: '\u90E8\u9580',\n        options: {\n          executive: '\u7D4C\u55B6\u5C64', sales: '\u55B6\u696D\u90E8', marketing: '\u30DE\u30FC\u30B1\u30C6\u30A3\u30F3\u30B0\u90E8',\n          engineering: '\u30A8\u30F3\u30B8\u30CB\u30A2\u30EA\u30F3\u30B0\u90E8', support: '\u30B5\u30DD\u30FC\u30C8\u90E8', finance: '\u7D4C\u7406\u90E8',\n          hr: '\u4EBA\u4E8B\u90E8', operations: '\u30AA\u30DA\u30EC\u30FC\u30B7\u30E7\u30F3\u90E8',\n        },\n      },\n      // \u30D0\u30A4\u30A4\u30F3\u30B0\u30BB\u30F3\u30BF\u30FC (REQ-0004) \u2014 \u610F\u601D\u6C7A\u5B9A\u306E\u30DE\u30C3\u30D7\u3002\u82F1\u8A9E\u30E9\u30D9\u30EB\u306F\n      // 'Buying Role' \u3067\u306F\u306A\u304F 'Buying Function'\uFF1Asecurity-role-word \u30EB\u30FC\u30EB\u304C\n      // \u5BA3\u8A00\u5074\u3067\u82F1\u5358\u8A9E role \u3092\u4E88\u7D04\u3057\u3066\u3044\u308B (ADR-0090 D3)\u3002\u540C\u30EB\u30FC\u30EB\u306F\u82F1\u8A9E\u306E\u307F\u3092\n      // \u8AAD\u307F\u8A00\u8A9E\u30D1\u30C3\u30AF\u306B\u306F\u53CA\u3070\u306A\u3044\u305F\u3081\u3001\u3053\u3053\u3067\u306F\u65E5\u672C\u8A9E\u3068\u3057\u3066\u81EA\u7136\u306A\u8A9E\u3092\u4F7F\u3046\u3002\n      buying_function: {\n        label: '\u8CFC\u8CB7\u5F79\u5272',\n        options: {\n          decision_maker: '\u6C7A\u88C1\u8005', economic_buyer: '\u4E88\u7B97\u6C7A\u88C1\u8005',\n          technical_evaluator: '\u6280\u8853\u8A55\u4FA1\u8005', user: '\u5229\u7528\u8005',\n          influencer: '\u5F71\u97FF\u8005', gatekeeper: '\u30B2\u30FC\u30C8\u30AD\u30FC\u30D1\u30FC',\n        },\n      },\n      attitude: {\n        label: '\u81EA\u793E\u3078\u306E\u614B\u5EA6',\n        options: {\n          champion: '\u63A8\u9032\u8005', supportive: '\u597D\u610F\u7684', neutral: '\u4E2D\u7ACB',\n          skeptical: '\u61D0\u7591\u7684', blocker: '\u53CD\u5BFE\u8005',\n        },\n      },\n      relationship_strength: {\n        label: '\u95A2\u4FC2\u306E\u5F37\u3055',\n        options: {\n          distant: '\u758E\u9060', acquaintance: '\u9854\u898B\u77E5\u308A', working: '\u696D\u52D9\u4E0A\u306E\u95A2\u4FC2',\n          strong: '\u5F37\u3044', trusted_advisor: '\u4FE1\u983C\u3055\u308C\u308B\u30A2\u30C9\u30D0\u30A4\u30B6\u30FC',\n        },\n      },\n      owner_id: { label: '\u53D6\u5F15\u5148\u8CAC\u4EFB\u8005\u306E\u6240\u6709\u8005' },\n      description: { label: '\u8AAC\u660E' },\n      is_primary: { label: '\u4E3B\u62C5\u5F53\u8005', help: '\u3053\u306E\u53D6\u5F15\u5148\u306E\u4E3B\u62C5\u5F53\u8005\u304B\u3069\u3046\u304B' },\n      avatar: { label: '\u30D7\u30ED\u30D5\u30A3\u30FC\u30EB\u753B\u50CF' },\n      mailing_address: { label: '\u90F5\u9001\u5148\u4F4F\u6240' },\n      lead_source: { label: '\u30EA\u30FC\u30C9\u30BD\u30FC\u30B9', options: { ...leadSourceOptions } },\n      do_not_call: { label: '\u96FB\u8A71\u62D2\u5426' },\n      email_opt_out: { label: '\u30E1\u30FC\u30EB\u914D\u4FE1\u505C\u6B62' },\n      last_contacted_date: { label: '\u6700\u7D42\u63A5\u89E6\u65E5\u6642' },\n    },\n    _views: {\n      all_contacts: { label: '\u5168\u53D6\u5F15\u5148\u8CAC\u4EFB\u8005' },\n      contact_directory: { label: '\u8CAC\u4EFB\u8005\u30C7\u30A3\u30EC\u30AF\u30C8\u30EA' },\n      primary_contacts: { label: '\u4E3B\u62C5\u5F53\u8005' },\n    },\n    _sections: {\n      identity: { label: '\u57FA\u672C\u60C5\u5831' },\n      account_info: { label: '\u53D6\u5F15\u5148\u30FB\u5F79\u8077' },\n      buying_centre: { label: '\u30D0\u30A4\u30A4\u30F3\u30B0\u30BB\u30F3\u30BF\u30FC' },\n      contact_info: { label: '\u9023\u7D61\u5148\u60C5\u5831' },\n      mailing_address: { label: '\u90F5\u9001\u5148\u4F4F\u6240' },\n      additional: { label: '\u305D\u306E\u4ED6\u306E\u60C5\u5831' },\n      preferences: { label: '\u30B3\u30DF\u30E5\u30CB\u30B1\u30FC\u30B7\u30E7\u30F3\u8A2D\u5B9A' },\n      // contact.view.ts \u306E\u30D5\u30A9\u30FC\u30E0\u30BB\u30AF\u30B7\u30E7\u30F3\u540D (#1100)\n      contact_details: { label: '\u9023\u7D61\u5148\u60C5\u5831' },\n      comm_preferences: { label: '\u8A2D\u5B9A' },\n    },\n    _actions: {\n      ...activityActions,\n      mark_primary: {\n        label: '\u4E3B\u62C5\u5F53\u8005\u306B\u8A2D\u5B9A',\n        confirmText: '\u3053\u306E\u8CAC\u4EFB\u8005\u3092\u53D6\u5F15\u5148\u306E\u4E3B\u62C5\u5F53\u8005\u306B\u8A2D\u5B9A\u3057\u307E\u3059\u304B\uFF1F',\n        successMessage: '\u4E3B\u62C5\u5F53\u8005\u306B\u8A2D\u5B9A\u3057\u307E\u3057\u305F\uFF01',\n      },\n      send_email: {\n        label: '\u30E1\u30FC\u30EB\u9001\u4FE1',\n        params: {\n          subject: { label: '\u4EF6\u540D' },\n          body: { label: '\u672C\u6587' },\n        },\n      },\n      add_contact_to_campaign: {\n        label: '\u30AD\u30E3\u30F3\u30DA\u30FC\u30F3\u306B\u8FFD\u52A0',\n        successMessage: '\u53D6\u5F15\u5148\u8CAC\u4EFB\u8005\u3092\u30AD\u30E3\u30F3\u30DA\u30FC\u30F3\u306B\u8FFD\u52A0\u3057\u307E\u3057\u305F\uFF01',\n        params: {\n          crm_campaign: { label: '\u30AD\u30E3\u30F3\u30DA\u30FC\u30F3' },\n        },\n      },\n    },\n  },\n};\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/sales/translations/ja-JP/objects.pipeline.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/sales/translations/ja-JP\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/sales/translations/ja-JP/objects.pipeline.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport type { ObjectTranslationData } from '@objectstack/spec/system';\n\nimport { activityActions, salutationOptions, industryOptions, leadSourceOptions } from './_shared';\n\n/**\n * \u65E5\u672C\u8A9E (ja-JP) \u2014 `objects` translations for the PIPELINE family:\n * demand and the deals it becomes, plus the roll-up that forecasts them.\n *\n * Roster: `crm_lead`, `crm_opportunity`, `crm_opportunity_line_item`, `crm_forecast`.\n *\n * SPLIT AXIS (#1311): translation NAMESPACE first, then CRM DOMAIN FAMILY.\n * Everything that is not `objects` lives in `./app.ts`; `objects` \u2014 69-78% of\n * every bundle \u2014 is one file per CRM domain family, and a detail object\n * follows its master. A new row goes in the file for ITS family, never in\n * whichever file is already open: that is how one file re-grows past the 70%\n * advisory band `pnpm hygiene` prints. Full rule and rationale:\n * `src/sales/translations/ja-JP.ts`.\n */\nconst opportunityStageOptions = {\n  prospecting: '\u898B\u8FBC\u307F\u8ABF\u67FB', qualification: '\u9078\u5B9A',\n  needs_analysis: '\u30CB\u30FC\u30BA\u5206\u6790', proposal: '\u63D0\u6848',\n  negotiation: '\u4EA4\u6E09', closed_won: '\u6210\u7ACB', closed_lost: '\u4E0D\u6210\u7ACB',\n};\n\nexport const pipeline: Record<string, ObjectTranslationData> = {\n  crm_lead: {\n    _validations: {\n      disqualification_reason_required: {\n        message: '\u30EA\u30FC\u30C9\u3092\u300C\u5BFE\u8C61\u5916\u300D\u306B\u3059\u308B\u5834\u5408\u306F\u5931\u683C\u7406\u7531\u304C\u5FC5\u8981\u3067\u3059',\n      },\n      duplicate_disqualification_requires_survivor: {\n        message: '\u91CD\u8907\u3092\u7406\u7531\u306B\u30EA\u30FC\u30C9\u3092\u5931\u683C\u3068\u3059\u308B\u5834\u5408\u306F\u3001\u6B8B\u3059\u30EC\u30B3\u30FC\u30C9\u3092\u6307\u5B9A\u3057\u3001\u91CD\u8907\u30B9\u30C6\u30FC\u30BF\u30B9\u3092\u300C\u78BA\u8A8D\u6E08\u307F\u300D\u306B\u3059\u308B\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059',\n      },\n      email_required: {\n        message: '\u30E1\u30FC\u30EB\u30A2\u30C9\u30EC\u30B9\u306F\u5FC5\u9808\u3067\u3059',\n      },\n      lead_status_progression: {\n        message: '\u7121\u52B9\u306A\u30EA\u30FC\u30C9\u30B9\u30C6\u30FC\u30BF\u30B9\u9077\u79FB\u3067\u3059',\n      },\n    },\n    label: '\u30EA\u30FC\u30C9',\n    pluralLabel: '\u30EA\u30FC\u30C9',\n    description: '\u307E\u3060\u9069\u683C\u5224\u5B9A\u3092\u53D7\u3051\u3066\u3044\u306A\u3044\u898B\u8FBC\u307F\u5BA2',\n    fields: {\n      salutation: { label: '\u656C\u79F0', options: { ...salutationOptions } },\n      first_name: { label: '\u540D' },\n      last_name: { label: '\u59D3' },\n      full_name: { label: '\u6C0F\u540D' },\n      display_title: { label: '\u8868\u793A\u540D' },\n      company: { label: '\u4F1A\u793E\u540D' },\n      company_normalized: {\n        label: '\u4F1A\u793E\u540D\uFF08\u6B63\u898F\u5316\uFF09',\n        help: '\u30EA\u30FC\u30C9\u5909\u63DB\u306E\u7167\u5408\u30AD\u30FC\u3002\u4F1A\u793E\u540D\u3092\u5C0F\u6587\u5B57\u5316\u3057\u3001\u524D\u5F8C\u306E\u7A7A\u767D\u3092\u9664\u53BB\u3057\u3066\u3001\u5185\u90E8\u306E\u9023\u7D9A\u3059\u308B\u7A7A\u767D\u3092 1 \u3064\u306B\u307E\u3068\u3081\u305F\u3082\u306E\u3002lead_duplicate_check \u30D5\u30C3\u30AF\u304C\u81EA\u52D5\u3067\u7DAD\u6301\u3057\u307E\u3059 \u2014 \u76F4\u63A5\u7DE8\u96C6\u3057\u306A\u3044\u3067\u304F\u3060\u3055\u3044\u3002',\n      },\n      title: { label: '\u5F79\u8077' },\n      email: { label: '\u30E1\u30FC\u30EB' },\n      phone: { label: '\u96FB\u8A71' },\n      industry: {\n        label: '\u696D\u7A2E',\n        options: { ...industryOptions },\n      },\n      status: {\n        label: '\u30B9\u30C6\u30FC\u30BF\u30B9',\n        options: {\n          new: '\u65B0\u898F', contacted: '\u30B3\u30F3\u30BF\u30AF\u30C8\u6E08\u307F', qualified: '\u9069\u683C',\n          unqualified: '\u4E0D\u9069\u683C', converted: '\u5909\u63DB\u6E08\u307F',\n        },\n      },\n      lead_source: { label: '\u30EA\u30FC\u30C9\u30BD\u30FC\u30B9', options: { ...leadSourceOptions } },\n      owner_id: { label: '\u30EA\u30FC\u30C9\u6240\u6709\u8005' },\n      is_converted: { label: '\u5909\u63DB\u6E08\u307F' },\n      description: { label: '\u8AAC\u660E' },\n      mobile: { label: '\u643A\u5E2F\u96FB\u8A71' },\n      website: { label: 'Web\u30B5\u30A4\u30C8' },\n      rating: { label: '\u30EA\u30FC\u30C9\u30B9\u30B3\u30A2', help: '\u30EA\u30FC\u30C9\u306E\u54C1\u8CEA\u30B9\u30B3\u30A2\uFF081\u301C5 \u6BB5\u968E\uFF09' },\n      converted_account: { label: '\u5909\u63DB\u5F8C\u306E\u53D6\u5F15\u5148' },\n      converted_contact: { label: '\u5909\u63DB\u5F8C\u306E\u53D6\u5F15\u5148\u8CAC\u4EFB\u8005' },\n      converted_opportunity: { label: '\u5909\u63DB\u5F8C\u306E\u5546\u8AC7' },\n      converted_date: { label: '\u5909\u63DB\u65E5' },\n      address: { label: '\u4F4F\u6240' },\n      annual_revenue: { label: '\u5E74\u9593\u58F2\u4E0A' },\n      number_of_employees: { label: '\u5F93\u696D\u54E1\u6570' },\n      notes: { label: '\u30E1\u30E2', help: '\u3053\u306E\u30EA\u30FC\u30C9\u306B\u95A2\u3059\u308B\u4F5C\u696D\u30E1\u30E2 \u2014 \u66F8\u5F0F\u8A2D\u5B9A\u306B\u5BFE\u5FDC\u3002' },\n      do_not_call: { label: '\u96FB\u8A71\u62D2\u5426' },\n      email_opt_out: { label: '\u30E1\u30FC\u30EB\u914D\u4FE1\u505C\u6B62' },\n      next_followup_date: { label: '\u6B21\u56DE\u30D5\u30A9\u30ED\u30FC\u30A2\u30C3\u30D7\u65E5' },\n      last_contacted_date: { label: '\u6700\u7D42\u63A5\u89E6\u65E5\u6642' },\n      need_type: {\n        label: '\u30CB\u30FC\u30BA\u7A2E\u5225',\n        help: '\u3053\u306E\u898B\u8FBC\u5BA2\u304C\u4F55\u3092\u6C42\u3081\u3066\u3044\u308B\u304B\u3002\u5272\u308A\u5F53\u3066\u30FB\u512A\u5148\u9806\u4F4D\u4ED8\u3051\u30FB\u9700\u8981\u5206\u6790\u304C\u3053\u306E\u9805\u76EE\u3092\u53C2\u7167\u3057\u307E\u3059\u3002',\n        options: {\n          new_implementation: '\u65B0\u898F\u5C0E\u5165', expansion: '\u62E1\u5F35\u30FB\u8FFD\u52A0',\n          replacement: '\u5165\u308C\u66FF\u3048\u30FB\u79FB\u884C', renewal: '\u66F4\u65B0', consulting: '\u30B3\u30F3\u30B5\u30EB\u30C6\u30A3\u30F3\u30B0',\n          support: '\u4FDD\u5B88\u30FB\u30B5\u30DD\u30FC\u30C8', other: '\u305D\u306E\u4ED6',\n        },\n      },\n      estimated_amount: {\n        label: '\u4E88\u60F3\u91D1\u984D',\n        help: '\u30AF\u30AA\u30EA\u30D5\u30A3\u30B1\u30FC\u30B7\u30E7\u30F3\u524D\u306E\u9700\u8981\u91D1\u984D\u306E\u898B\u7A4D\u308A\u3002\u30B3\u30F3\u30D0\u30FC\u30B8\u30E7\u30F3\u6642\u306B\u5546\u8AC7\u91D1\u984D\u3078\u521D\u671F\u5024\u3068\u3057\u3066\u5165\u308A\u307E\u3059\u3002',\n      },\n      conversion_approval_status: {\n        label: '\u30B3\u30F3\u30D0\u30FC\u30B8\u30E7\u30F3\u627F\u8A8D',\n        help: '\u3053\u306E\u898B\u8FBC\u5BA2\u304C\u30B3\u30F3\u30D0\u30FC\u30B8\u30E7\u30F3\u306E\u627F\u8A8D\u3092\u5F97\u3066\u3044\u308B\u304B\u3002\u300C\u627F\u8A8D\u4E0D\u8981\u300D\u306F\u627F\u8A8D\u3092\u6C42\u3081\u306A\u3044\u72B6\u614B\u3067\u3001\u51FA\u8377\u6642\u306E\u65E2\u5B9A\u5024\u3067\u3059\u3002',\n        options: {\n          not_required: '\u627F\u8A8D\u4E0D\u8981', pending: '\u627F\u8A8D\u5F85\u3061',\n          approved: '\u627F\u8A8D\u6E08\u307F', rejected: '\u5374\u4E0B',\n        },\n      },\n      disqualification_reason: {\n        label: '\u4E0D\u9069\u683C\u7406\u7531',\n        help: '\u30B9\u30C6\u30FC\u30BF\u30B9\u304C\u300C\u4E0D\u9069\u683C\u300D\u306E\u5834\u5408\u306F\u5FC5\u9808',\n        options: {\n          not_a_fit: '\u30CB\u30FC\u30BA\u304C\u5408\u308F\u306A\u3044', no_budget: '\u4E88\u7B97\u306A\u3057', wrong_persona: '\u62C5\u5F53\u8005\u304C\u7570\u306A\u308B',\n          unreachable: '\u9023\u7D61\u4E0D\u80FD', duplicate: '\u91CD\u8907\u30EA\u30FC\u30C9', competitor: '\u7AF6\u5408\u4ED6\u793E\u306B\u6C7A\u5B9A',\n          other: '\u305D\u306E\u4ED6',\n        },\n      },\n      duplicate_of_type: {\n        label: '\u91CD\u8907\u5BFE\u8C61',\n        help: '\u91CD\u8907\u5143\u3068\u3057\u3066\u6B8B\u308B\u30EC\u30B3\u30FC\u30C9\u304C\u5C5E\u3059\u308B\u30AA\u30D6\u30B8\u30A7\u30AF\u30C8\u306E\u7A2E\u5225\u3002',\n        // `erased` \u306F\u5893\u7891\u5024\u3067\u3042\u308A\u9078\u629E\u80A2\u3067\u306F\u306A\u3044\u3002\u30D5\u30A9\u30FC\u30E0\u306B\u306F\u8868\u793A\u3057\u306A\u3044\n        // \uFF08`src/sales/views/lead.view.ts` \u3092\u53C2\u7167\uFF09\u304C\u3001\u6B8B\u5B58\u30EC\u30B3\u30FC\u30C9\u304C\u524A\u9664\u3055\u308C\u305F\n        // \u30EA\u30FC\u30C9\u306F\u3053\u306E\u5024\u3092\u4FDD\u6301\u3059\u308B\u305F\u3081\u3001\u30EC\u30B3\u30FC\u30C9\u3092\u8AAD\u3080\u5834\u6240\u3067\u306F\u30E9\u30D9\u30EB\u304C\u8981\u308B\u3002\n        options: { crm_lead: '\u30EA\u30FC\u30C9', crm_contact: '\u53D6\u5F15\u5148\u8CAC\u4EFB\u8005', erased: '\u524A\u9664\u6E08\u307F\u30EC\u30B3\u30FC\u30C9' },\n      },\n      duplicate_of_lead: { label: '\u91CD\u8907\u3059\u308B\u30EA\u30FC\u30C9' },\n      duplicate_of_contact: { label: '\u91CD\u8907\u3059\u308B\u53D6\u5F15\u5148\u8CAC\u4EFB\u8005' },\n      duplicate_status: {\n        label: '\u91CD\u8907\u30B9\u30C6\u30FC\u30BF\u30B9',\n        help: '\u300C\u91CD\u8907\u306E\u7591\u3044\u300D= \u767B\u9332\u6642\u306B\u81EA\u52D5\u3067\u4ED8\u4E0E\u3002\u300C\u91CD\u8907\u78BA\u5B9A\u300D= \u62C5\u5F53\u8005\u304C\u4E00\u81F4\u3092\u78BA\u8A8D\u6E08\u307F\u3002',\n        options: { suspected: '\u91CD\u8907\u306E\u7591\u3044', confirmed: '\u91CD\u8907\u78BA\u5B9A' },\n      },\n    },\n    _views: {\n      all_leads: {\n        label: '\u5168\u30EA\u30FC\u30C9',\n        emptyState: { title: '\u30EA\u30FC\u30C9\u304C\u307E\u3060\u3042\u308A\u307E\u305B\u3093', message: '\u6700\u521D\u306E\u30EA\u30FC\u30C9\u3092\u4F5C\u6210\u3057\u3066\u59CB\u3081\u307E\u3057\u3087\u3046' },\n      },\n      kanban_by_status: { label: '\u30EA\u30FC\u30C9\u30D1\u30A4\u30D7\u30E9\u30A4\u30F3' },\n      calendar_by_created: { label: '\u30EA\u30FC\u30C9\u30AB\u30EC\u30F3\u30C0\u30FC' },\n      gallery_view: { label: '\u30EA\u30FC\u30C9\u30AB\u30FC\u30C9' },\n      my_leads: { label: '\u79C1\u306E\u30EA\u30FC\u30C9' },\n      high_priority: { label: '\u512A\u5148\u5EA6\u9AD8' },\n      hot_leads: { label: '\uD83D\uDD25 \u30DB\u30C3\u30C8\u30EA\u30FC\u30C9' },\n      suspected_duplicates: {\n        label: '\u91CD\u8907\u306E\u7591\u3044\u304C\u3042\u308B\u30EA\u30FC\u30C9',\n        emptyState: {\n          title: '\u91CD\u8907\u306E\u7591\u3044\u306F\u3042\u308A\u307E\u305B\u3093',\n          message: '\u78BA\u8A8D\u306F\u4E0D\u8981\u3067\u3059 \u2014 \u518D\u767B\u9332\u3055\u308C\u305F\u30E1\u30FC\u30EB\u30A2\u30C9\u30EC\u30B9\u306F\u3059\u3079\u3066\u30C1\u30A7\u30C3\u30AF\u6E08\u307F\u3067\u3059\u3002',\n        },\n      },\n    },\n    _sections: {\n      // \u30AA\u30D6\u30B8\u30A7\u30AF\u30C8\u5B9A\u7FA9\u306E\u30BB\u30AF\u30B7\u30E7\u30F3\u30AD\u30FC\uFF08lead.object.ts\uFF09\u2014 \u5165\u529B\u30D5\u30A9\u30FC\u30E0\u3068\u3001\n      // \u3053\u308C\u3089\u306E\u30B0\u30EB\u30FC\u30D7\u3092\u53C2\u7167\u3059\u308B\u8A73\u7D30\u30DA\u30FC\u30B8\u306E\u30BB\u30AF\u30B7\u30E7\u30F3\uFF08#806\uFF09\u3067\u4F7F\u7528\n      address: { label: '\u4F4F\u6240' },\n      identity: { label: '\u57FA\u672C\u60C5\u5831' },\n      company_info: { label: '\u4F1A\u793E\u60C5\u5831' },\n      contact_info: { label: '\u9023\u7D61\u5148\u60C5\u5831' },\n      qualification: { label: '\u9069\u683C\u5224\u5B9A' },\n      assignment: { label: '\u62C5\u5F53\u8005' },\n      additional: { label: '\u305D\u306E\u4ED6\u306E\u60C5\u5831' },\n      preferences: { label: '\u30B3\u30DF\u30E5\u30CB\u30B1\u30FC\u30B7\u30E7\u30F3\u8A2D\u5B9A' },\n      conversion: { label: '\u5909\u63DB' },\n      duplicates: { label: '\u91CD\u8907\u7BA1\u7406' },\n      // lead.view.ts \u306E\u30D5\u30A9\u30FC\u30E0\u30BB\u30AF\u30B7\u30E7\u30F3\u540D (#1100) \u2014 \u30C7\u30D5\u30A9\u30EB\u30C8\u30D5\u30A9\u30FC\u30E0\u3068\n      // \u540D\u524D\u4ED8\u304D formView \u3059\u3079\u3066\u306E\u30BB\u30AF\u30B7\u30E7\u30F3\u540D\u304C\u3053\u3053\u306B\u96C6\u307E\u308B\u3002\u3042\u3061\u3089\u306B\u30D5\u30A9\u30FC\u30E0\u3092\n      // \u8FFD\u52A0\u3057\u305F\u3089\u3001\u305D\u306E\u30BB\u30AF\u30B7\u30E7\u30F3\u540D\u3092\u3053\u3053\u306B\u8FFD\u52A0\u3059\u308B\u3002\n      contact_information: { label: '\u9023\u7D61\u5148\u60C5\u5831' },\n      lead_classification: { label: '\u30EA\u30FC\u30C9\u5206\u985E' },\n      company_information: { label: '\u4F1A\u793E\u60C5\u5831' },\n      additional_information: { label: '\u8FFD\u52A0\u60C5\u5831' },\n      privacy: { label: '\u30D7\u30E9\u30A4\u30D0\u30B7\u30FC' },\n      general: { label: '\u4E00\u822C' },\n      details: { label: '\u8A73\u7D30' },\n      step_1_contact_details: { label: '\u30B9\u30C6\u30C3\u30D71\uFF1A\u9023\u7D61\u5148\u60C5\u5831' },\n      step_2_company_information: { label: '\u30B9\u30C6\u30C3\u30D72\uFF1A\u4F1A\u793E\u60C5\u5831' },\n      step_3_qualification: { label: '\u30B9\u30C6\u30C3\u30D73\uFF1A\u8CC7\u683C\u8A55\u4FA1' },\n      step_4_review_and_convert: { label: '\u30B9\u30C6\u30C3\u30D74\uFF1A\u78BA\u8A8D\u3068\u5909\u63DB' },\n      primary_information: { label: '\u4E3B\u8981\u60C5\u5831' },\n      extended_details: { label: '\u8A73\u7D30\u60C5\u5831' },\n      quick_edit: { label: '\u30AF\u30A4\u30C3\u30AF\u7DE8\u96C6' },\n      update_lead_status: { label: '\u30EA\u30FC\u30C9\u30B9\u30C6\u30FC\u30BF\u30B9\u3092\u66F4\u65B0' },\n      tell_us_about_yourself: { label: '\u3042\u306A\u305F\u306B\u3064\u3044\u3066\u6559\u3048\u3066\u304F\u3060\u3055\u3044' },\n      about_your_company: { label: '\u8CB4\u793E\u306B\u3064\u3044\u3066' },\n      how_can_we_help: { label: '\u3069\u306E\u3088\u3046\u306A\u3054\u7528\u4EF6\u3067\u3057\u3087\u3046\u304B\uFF1F' },\n      lead_information: { label: '\u30EA\u30FC\u30C9\u60C5\u5831' },\n      address_information: { label: '\u4F4F\u6240\u60C5\u5831' },\n      privacy_preferences: { label: '\u30D7\u30E9\u30A4\u30D0\u30B7\u30FC\u8A2D\u5B9A' },\n    },\n    _actions: {\n      ...activityActions,\n      convert_lead: {\n        label: '\u30EA\u30FC\u30C9\u5909\u63DB',\n        successMessage: '\u30EA\u30FC\u30C9\u306E\u5909\u63DB\u306B\u6210\u529F\u3057\u307E\u3057\u305F\uFF01',\n      },\n      create_campaign: {\n        label: '\u30AD\u30E3\u30F3\u30DA\u30FC\u30F3\u306B\u8FFD\u52A0',\n        successMessage: '\u30AD\u30E3\u30F3\u30DA\u30FC\u30F3\u306B\u8FFD\u52A0\u3057\u307E\u3057\u305F\uFF01',\n        params: {\n          crm_campaign: { label: '\u30AD\u30E3\u30F3\u30DA\u30FC\u30F3' },\n        },\n      },\n      schedule_followup: {\n        label: '\u30D5\u30A9\u30ED\u30FC\u30A2\u30C3\u30D7\u3092\u8A2D\u5B9A',\n        successMessage: '\u30D5\u30A9\u30ED\u30FC\u30A2\u30C3\u30D7\u3092\u8A2D\u5B9A\u3057\u307E\u3057\u305F\u3002',\n      },\n    },\n  },\n  crm_opportunity: {\n    _validations: {\n      amount_positive: {\n        message: '\u91D1\u984D\u306F 0 \u3088\u308A\u5927\u304D\u3044\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059',\n      },\n      close_date_future: {\n        message: '\u5546\u8AC7\u304C\u30AF\u30ED\u30FC\u30BA\u3057\u3066\u3044\u308B\u5834\u5408\u3092\u9664\u304D\u3001\u5B8C\u4E86\u4E88\u5B9A\u65E5\u3092\u904E\u53BB\u306B\u8A2D\u5B9A\u3059\u308B\u3053\u3068\u306F\u3067\u304D\u307E\u305B\u3093',\n      },\n      opportunity_stage_progression: {\n        message: '\u7121\u52B9\u306A\u5546\u8AC7\u30B9\u30C6\u30FC\u30B8\u9077\u79FB\u3067\u3059',\n      },\n    },\n    label: '\u5546\u8AC7',\n    pluralLabel: '\u5546\u8AC7',\n    description: '\u30D1\u30A4\u30D7\u30E9\u30A4\u30F3\u4E0A\u306E\u5546\u8AC7\u30FB\u6848\u4EF6',\n    fields: {\n      name: { label: '\u5546\u8AC7\u540D' },\n      crm_account: { label: '\u53D6\u5F15\u5148' },\n      primary_contact: { label: '\u4E3B\u62C5\u5F53\u8005' },\n      owner_id: { label: '\u5546\u8AC7\u6240\u6709\u8005' },\n      amount: { label: '\u91D1\u984D' },\n      expected_revenue: { label: '\u671F\u5F85\u53CE\u76CA' },\n      stage: {\n        label: '\u30B9\u30C6\u30FC\u30B8',\n        options: { ...opportunityStageOptions },\n      },\n      probability: { label: '\u78BA\u5EA6 (%)' },\n      close_date: { label: '\u5B8C\u4E86\u4E88\u5B9A\u65E5' },\n      type: {\n        label: '\u30BF\u30A4\u30D7',\n        options: {\n          new_business: '\u65B0\u898F\u30D3\u30B8\u30CD\u30B9',\n          existing_upgrade: '\u65E2\u5B58\u9867\u5BA2 - \u30A2\u30C3\u30D7\u30B0\u30EC\u30FC\u30C9',\n          existing_renewal: '\u65E2\u5B58\u9867\u5BA2 - \u66F4\u65B0',\n          existing_expansion: '\u65E2\u5B58\u9867\u5BA2 - \u62E1\u5927',\n        },\n      },\n      forecast_category: {\n        label: '\u58F2\u4E0A\u4E88\u6E2C\u30AB\u30C6\u30B4\u30EA',\n        options: {\n          pipeline: '\u30D1\u30A4\u30D7\u30E9\u30A4\u30F3', best_case: '\u30D9\u30B9\u30C8\u30B1\u30FC\u30B9',\n          commit: '\u30B3\u30DF\u30C3\u30C8', omitted: '\u9664\u5916', closed: '\u5B8C\u4E86',\n        },\n      },\n      description: { label: '\u8AAC\u660E' },\n      next_step: { label: '\u6B21\u306E\u30B9\u30C6\u30C3\u30D7' },\n      lead_source: { label: '\u30EA\u30FC\u30C9\u30BD\u30FC\u30B9', options: { ...leadSourceOptions } },\n      crm_campaign: { label: '\u30AD\u30E3\u30F3\u30DA\u30FC\u30F3', help: '\u3053\u306E\u5546\u8AC7\u3092\u751F\u307F\u51FA\u3057\u305F\u30DE\u30FC\u30B1\u30C6\u30A3\u30F3\u30B0\u30AD\u30E3\u30F3\u30DA\u30FC\u30F3' },\n      days_in_stage: { label: '\u73FE\u30B9\u30C6\u30FC\u30B8\u6EDE\u5728\u65E5\u6570' },\n      stage_entry_date: { label: '\u30B9\u30C6\u30FC\u30B8\u958B\u59CB\u65E5', help: '\u3053\u306E\u5546\u8AC7\u304C\u73FE\u5728\u306E\u30B9\u30C6\u30FC\u30B8\u306B\u5165\u3063\u305F\u65E5\u3002' },\n      is_private: { label: '\u975E\u516C\u958B' },\n      approval_status: {\n        label: '\u627F\u8A8D\u30B9\u30C6\u30FC\u30BF\u30B9',\n        options: { not_required: '\u627F\u8A8D\u4E0D\u8981', pending: '\u627F\u8A8D\u5F85\u3061', approved: '\u627F\u8A8D\u6E08\u307F', rejected: '\u5374\u4E0B' },\n      },\n      approved_date: { label: '\u627F\u8A8D\u65E5' },\n      // #593 \u2014 \u5546\u8AC7\u30AF\u30ED\u30FC\u30BA\u6642\u306B\u5FC5\u9808\u3002\u5931\u6CE8\u7406\u7531\u306F\u55B6\u696D\u30C0\u30C3\u30B7\u30E5\u30DC\u30FC\u30C9\u306E\n      // \u5185\u8A33\u30A6\u30A3\u30B8\u30A7\u30C3\u30C8\u306B\u3082\u51FA\u308B\u305F\u3081\u3001\u4FDD\u5B58\u5024\u304C\u305D\u306E\u307E\u307E\u753B\u9762\u306B\u51FA\u3066\u306F\u3044\u3051\u306A\u3044\u3002\n      win_reason: {\n        label: '\u53D7\u6CE8\u7406\u7531',\n        help: '\u53D7\u6CE8\u306B\u81F3\u3063\u305F\u7406\u7531\u3002\u5546\u8AC7\u3092\u300C\u6210\u7ACB\u300D\u3067\u30AF\u30ED\u30FC\u30BA\u3059\u308B\u969B\u306B\u5FC5\u9808\u3067\u3059\u3002',\n        options: {\n          better_product: '\u88FD\u54C1\u304C\u512A\u308C\u3066\u3044\u308B', better_price: '\u4FA1\u683C\u304C\u512A\u308C\u3066\u3044\u308B',\n          relationship: '\u65E2\u5B58\u306E\u95A2\u4FC2', better_support: '\u30B5\u30DD\u30FC\u30C8\u304C\u512A\u308C\u3066\u3044\u308B',\n          best_fit: '\u6700\u9069\u306A\u6A5F\u80FD\u30FB\u9069\u5408\u6027',\n          quote_accepted: '\u898B\u7A4D\u627F\u8A8D', other: '\u305D\u306E\u4ED6',\n        },\n      },\n      loss_reason: {\n        label: '\u5931\u6CE8\u7406\u7531',\n        help: '\u5931\u6CE8\u3057\u305F\u7406\u7531\u3002\u5546\u8AC7\u3092\u300C\u4E0D\u6210\u7ACB\u300D\u3067\u30AF\u30ED\u30FC\u30BA\u3059\u308B\u969B\u306B\u5FC5\u9808\u3067\u3059\u3002',\n        options: {\n          price: '\u4FA1\u683C\u304C\u9AD8\u3059\u304E\u308B', competitor: '\u7AF6\u5408\u4ED6\u793E\u306B\u6557\u5317',\n          no_budget: '\u4E88\u7B97\u306A\u3057', no_decision: '\u610F\u601D\u6C7A\u5B9A\u306A\u3057',\n          timing: '\u30BF\u30A4\u30DF\u30F3\u30B0\u4E0D\u9069', features: '\u6A5F\u80FD\u4E0D\u8DB3', other: '\u305D\u306E\u4ED6',\n        },\n      },\n      loss_details: { label: '\u53D7\u6CE8\u30FB\u5931\u6CE8\u306E\u8A73\u7D30', help: '\u53D7\u6CE8\u30FB\u5931\u6CE8\u7406\u7531\u306E\u88DC\u8DB3\u8AAC\u660E\uFF08\u81EA\u7531\u8A18\u8FF0\uFF09\u3002' },\n      // REQ-0006 \u2014 \u9069\u683C\u5224\u5B9A\u3001\u9867\u5BA2\u5074\u306E\u8ABF\u9054\u30B9\u30B1\u30B8\u30E5\u30FC\u30EB\u3001\u5546\u8AC7\u306E\u7D4C\u7DEF\u3001\u4E8B\u696D\u533A\u5206\u3001\u30B9\u30C6\u30FC\u30BF\u30B9\u5909\u66F4\u627F\u8A8D\u3002\n      will_bid: { label: '\u5165\u672D\u4E88\u5B9A', help: '\u5165\u672D\u3059\u308B\u610F\u5411\u304C\u3042\u308B\u304B\u3069\u3046\u304B\u3002\u672A\u8A2D\u5B9A\u306F\u5224\u65AD\u304C\u4FDD\u7559\u4E2D\u3067\u3042\u308B\u3053\u3068\u3092\u793A\u3057\u307E\u3059\u3002' },\n      controllability: { label: '\u30B3\u30F3\u30C8\u30ED\u30FC\u30EB\u5EA6', options: { high: '\u9AD8', medium: '\u4E2D', low: '\u4F4E' } },\n      priority: { label: '\u512A\u5148\u5EA6', options: { high: '\u9AD8', medium: '\u4E2D', low: '\u4F4E' } },\n      deal_level: { label: '\u5546\u8AC7\u30E9\u30F3\u30AF', options: { strategic: '\u6226\u7565', key: '\u91CD\u70B9', standard: '\u6A19\u6E96' } },\n      is_subcontracted: { label: '\u5916\u6CE8\u3042\u308A' },\n      subcontracting_note: { label: '\u5916\u6CE8\u30E1\u30E2' },\n      customer_initiation_date: { label: '\u9867\u5BA2\u306E\u6848\u4EF6\u5316\u65E5' },\n      expected_tender_date: { label: '\u5165\u672D\u4E88\u5B9A\u65E5' },\n      expected_signing_date: { label: '\u5951\u7D04\u7DE0\u7D50\u4E88\u5B9A\u65E5' },\n      expected_tender_amount: { label: '\u5165\u672D\u4E88\u5B9A\u91D1\u984D' },\n      expected_signing_amount: { label: '\u5951\u7D04\u4E88\u5B9A\u91D1\u984D' },\n      business_line: {\n        label: '\u4E8B\u696D\u533A\u5206',\n        options: {\n          product: '\u88FD\u54C1', services: '\u30D7\u30ED\u30D5\u30A7\u30C3\u30B7\u30E7\u30CA\u30EB\u30B5\u30FC\u30D3\u30B9', consulting: '\u30B3\u30F3\u30B5\u30EB\u30C6\u30A3\u30F3\u30B0',\n          support: '\u4FDD\u5B88\u30FB\u30B5\u30DD\u30FC\u30C8', other: '\u305D\u306E\u4ED6',\n        },\n      },\n      customer_background: { label: '\u9867\u5BA2\u6982\u8981' },\n      project_background: { label: '\u30D7\u30ED\u30B8\u30A7\u30AF\u30C8\u80CC\u666F' },\n      risk_analysis: { label: '\u30EA\u30B9\u30AF\u5206\u6790' },\n      payment_terms: { label: '\u652F\u6255\u6761\u4EF6' },\n      requested_status: { label: '\u7533\u8ACB\u30B9\u30C6\u30FC\u30BF\u30B9', options: { closed_won: '\u53D7\u6CE8', closed_lost: '\u5931\u6CE8' } },\n      status_change_approval_status: {\n        label: '\u30B9\u30C6\u30FC\u30BF\u30B9\u5909\u66F4\u627F\u8A8D',\n        options: { not_required: '\u627F\u8A8D\u4E0D\u8981', pending: '\u627F\u8A8D\u5F85\u3061', approved: '\u627F\u8A8D\u6E08\u307F', rejected: '\u5374\u4E0B' },\n      },\n      // REQ-0006 \u30B9\u30C6\u30C3\u30D7 11 \u2014 \u6848\u4EF6\u5316\uFF08\u7ACB\u9879\uFF09\u627F\u8A8D\u3002\n      qualification_requested: {\n        label: '\u6848\u4EF6\u5316\u627F\u8A8D\u3092\u7533\u8ACB',\n        help: '\u30C1\u30A7\u30C3\u30AF\u3059\u308B\u3068\u3053\u306E\u5546\u8AC7\u3092\u6848\u4EF6\u5316\u627F\u8A8D\u306B\u56DE\u3057\u307E\u3059\u3002\u5374\u4E0B\u3055\u308C\u308B\u3068\u30C1\u30A7\u30C3\u30AF\u304C\u5916\u308C\u307E\u3059\u3002\u518D\u5EA6\u30C1\u30A7\u30C3\u30AF\u3059\u308B\u3068\u6539\u3081\u3066\u7533\u8ACB\u3067\u304D\u307E\u3059\u3002',\n      },\n      qualification_approval_status: {\n        label: '\u6848\u4EF6\u5316\u627F\u8A8D',\n        options: { not_required: '\u627F\u8A8D\u4E0D\u8981', pending: '\u627F\u8A8D\u5F85\u3061', approved: '\u627F\u8A8D\u6E08\u307F', rejected: '\u5374\u4E0B' },\n      },\n    },\n    _views: {\n      tender_this_quarter: {\n        label: '\u4ECA\u56DB\u534A\u671F\u306B\u5165\u672D\u4E88\u5B9A',\n        emptyState: {\n          title: '\u4ECA\u56DB\u534A\u671F\u306B\u5165\u672D\u4E88\u5B9A\u306E\u5546\u8AC7\u306F\u3042\u308A\u307E\u305B\u3093',\n          message: '\u3053\u306E\u30BF\u30D6\u306B\u306F\u3001\u9867\u5BA2\u5074\u306E\u5165\u672D\u4E88\u5B9A\u65E5\u304C\u4ECA\u56DB\u534A\u671F\u5185\u306B\u3042\u308B\u30AA\u30FC\u30D7\u30F3\u5546\u8AC7\u304C\u8868\u793A\u3055\u308C\u307E\u3059\u3002\u5546\u8AC7\u306B\u300C\u5165\u672D\u4E88\u5B9A\u65E5\u300D\u3092\u5165\u529B\u3059\u308B\u3068\u3001\u3053\u3053\u306B\u8868\u793A\u3055\u308C\u307E\u3059\u3002',\n        },\n      },\n      open_opportunities: { label: '\u9032\u884C\u4E2D\u306E\u5546\u8AC7' },\n      all_opportunities: { label: '\u5168\u5546\u8AC7' },\n      pipeline_kanban: { label: '\u30BB\u30FC\u30EB\u30B9\u30D1\u30A4\u30D7\u30E9\u30A4\u30F3' },\n      close_date_calendar: { label: '\u4E88\u6E2C\u30AB\u30EC\u30F3\u30C0\u30FC' },\n      deal_timeline: { label: '\u5546\u8AC7\u30BF\u30A4\u30E0\u30E9\u30A4\u30F3' },\n      deal_gallery: { label: '\u5546\u8AC7\u30AB\u30FC\u30C9' },\n      my_open_deals: { label: '\u79C1\u306E\u30AA\u30FC\u30D7\u30F3\u5546\u8AC7' },\n      stale_opportunities: { label: '\u26A0\uFE0F \u505C\u6EDE\u5546\u8AC7 \u00B7 \u30B9\u30C6\u30FC\u30B8\u6EDE\u5728\u304C\u9577\u3044\u9806' },\n      closing_this_quarter: {\n        label: '\u4ECA\u56DB\u534A\u671F\u306B\u30AF\u30ED\u30FC\u30BA\u4E88\u5B9A',\n        emptyState: {\n          title: '\u4ECA\u56DB\u534A\u671F\u306B\u30AF\u30ED\u30FC\u30BA\u4E88\u5B9A\u306E\u5546\u8AC7\u306F\u3042\u308A\u307E\u305B\u3093',\n          message: '\u3053\u306E\u30BF\u30D6\u306B\u306F\u3001\u5B8C\u4E86\u4E88\u5B9A\u65E5\u304C\u4ECA\u56DB\u534A\u671F\u5185\u306B\u3042\u308B\u30B3\u30DF\u30C3\u30C8\uFF0F\u30D9\u30B9\u30C8\u30B1\u30FC\u30B9\u306E\u30AA\u30FC\u30D7\u30F3\u5546\u8AC7\u304C\u8868\u793A\u3055\u308C\u307E\u3059\u3002\u73FE\u5728\u8A72\u5F53\u3059\u308B\u5546\u8AC7\u306F\u3042\u308A\u307E\u305B\u3093\u3002\u305D\u308C\u4EE5\u964D\u306B\u30AF\u30ED\u30FC\u30BA\u3059\u308B\u5546\u8AC7\u306F\u300C\u30AA\u30FC\u30D7\u30F3\u5546\u8AC7\u300D\u30BF\u30D6\u306B\u3042\u308A\u307E\u3059\u3002',\n        },\n      },\n    },\n    _sections: {\n      // \u30AA\u30D6\u30B8\u30A7\u30AF\u30C8\u5B9A\u7FA9\u306E\u30BB\u30AF\u30B7\u30E7\u30F3\u30AD\u30FC\uFF08opportunity.object.ts\uFF09\u2014 \u5165\u529B\u30D5\u30A9\u30FC\u30E0\u3068\u3001\n      // \u3053\u308C\u3089\u306E\u30B0\u30EB\u30FC\u30D7\u3092\u53C2\u7167\u3059\u308B\u8A73\u7D30\u30DA\u30FC\u30B8\u306E\u30BB\u30AF\u30B7\u30E7\u30F3\uFF08#1452\uFF09\u3067\u4F7F\u7528\n      crm_forecast: { label: '\u30B9\u30C6\u30FC\u30B8\u30FB\u58F2\u4E0A\u4E88\u6E2C' },\n      basic: { label: '\u57FA\u672C\u60C5\u5831' },\n      financials: { label: '\u8CA1\u52D9\u60C5\u5831' },\n      sales_process: { label: '\u55B6\u696D\u30D7\u30ED\u30BB\u30B9' },\n      classification: { label: '\u5206\u985E' },\n      campaign: { label: '\u30AD\u30E3\u30F3\u30DA\u30FC\u30F3' },\n      notes: { label: '\u30E1\u30E2\u30FB\u6B21\u306E\u30B9\u30C6\u30C3\u30D7' },\n      qualification: { label: '\u9069\u683C\u5224\u5B9A' },\n      narrative: { label: '\u5546\u8AC7\u306E\u7D4C\u7DEF' },\n      // opportunity.view.ts \u306E\u30D5\u30A9\u30FC\u30E0\u30BB\u30AF\u30B7\u30E7\u30F3\u540D (#1100)\n      overview: { label: '\u6982\u8981' },\n      forecast: { label: '\u4E88\u6E2C' },\n      sales_strategy: { label: '\u55B6\u696D\u6226\u7565' },\n      win_loss: { label: '\u53D7\u6CE8\uFF0F\u5931\u6CE8' },\n    },\n    _actions: {\n      ...activityActions,\n      clone_opportunity: {\n        label: '\u5546\u8AC7\u3092\u8907\u88FD',\n        successMessage: '\u5546\u8AC7\u3092\u8907\u88FD\u3057\u307E\u3057\u305F\uFF01',\n      },\n      mass_update_stage: {\n        label: '\u30B9\u30C6\u30FC\u30B8\u66F4\u65B0',\n        successMessage: '\u5546\u8AC7\u30B9\u30C6\u30FC\u30B8\u3092\u66F4\u65B0\u3057\u307E\u3057\u305F\uFF01',\n        params: {\n          stage: {\n            label: '\u65B0\u3057\u3044\u30B9\u30C6\u30FC\u30B8',\n            options: { ...opportunityStageOptions },\n          },\n        },\n      },\n      generate_quote: {\n        label: '\u898B\u7A4D\u3092\u4F5C\u6210',\n        successMessage: '\u5546\u8AC7\u304B\u3089\u898B\u7A4D\u3092\u4F5C\u6210\u3057\u307E\u3057\u305F\uFF01',\n      },\n    },\n  },\n  crm_opportunity_line_item: {\n    _validations: {\n      unit_price_positive: {\n        message: '\u8CA9\u58F2\u4FA1\u683C\u3092\u8CA0\u306E\u5024\u306B\u3059\u308B\u3053\u3068\u306F\u3067\u304D\u307E\u305B\u3093',\n      },\n    },\n    label: '\u5546\u8AC7\u5546\u54C1\u660E\u7D30',\n    pluralLabel: '\u5546\u8AC7\u5546\u54C1\u660E\u7D30',\n    description: '\u5546\u8AC7\u914D\u4E0B\u306E\u88FD\u54C1\u5225\u4FA1\u683C\u660E\u7D30\u884C',\n    fields: {\n      crm_opportunity: { label: '\u5546\u8AC7' },\n      crm_product: { label: '\u88FD\u54C1' },\n      description: { label: '\u8AAC\u660E' },\n      quantity: { label: '\u6570\u91CF' },\n      list_price: { label: '\u5B9A\u4FA1', help: '\u88FD\u54C1\u306E\u30AB\u30BF\u30ED\u30B0\u4FA1\u683C\u304B\u3089\u81EA\u52D5\u5165\u529B\u3055\u308C\u307E\u3059' },\n      unit_price: { label: '\u8CA9\u58F2\u4FA1\u683C', help: '\u4EA4\u6E09\u5F8C\u306E\u5358\u4FA1\uFF08\u5B9A\u4FA1\u3068\u7570\u306A\u308B\u5834\u5408\u304C\u3042\u308A\u307E\u3059\uFF09' },\n      discount: { label: '\u5272\u5F15\u7387\uFF08%\uFF09' },\n      total_price: { label: '\u5408\u8A08' },\n      line_number: { label: '\u884C\u756A\u53F7' },\n    },\n    _sections: {\n      basic: { label: '\u660E\u7D30\u884C' },\n      pricing: { label: '\u4FA1\u683C' },\n    },\n  },\n  crm_forecast: {\n    _validations: {\n      period_end_after_start: {\n        message: '\u671F\u9593\u7D42\u4E86\u306F\u671F\u9593\u958B\u59CB\u3088\u308A\u5F8C\u3067\u3042\u308B\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059\u3002',\n      },\n      period_end_matches_calendar_period: {\n        message: '\u671F\u9593\u7D42\u4E86\u306F\u305D\u306E\u671F\u9593\u306E\u6700\u7D42\u65E5\u3067\u3042\u308B\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059\u3002\u4F8B\uFF1A2026-07-01 \u958B\u59CB\u306E\u56DB\u534A\u671F\u306A\u3089 2026-09-30\u30012026 \u5E74 8 \u6708\u306A\u3089 2026-08-31\u3002',\n      },\n      period_start_first_of_period: {\n        message: '\u671F\u9593\u958B\u59CB\u306F\u305D\u306E\u671F\u9593\u306E\u521D\u65E5\u3067\u3042\u308B\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059\u3002\u4F8B\uFF1A2026 \u5E74 8 \u6708\u306A\u3089 2026-08-01\u3002',\n      },\n      quarter_starts_on_quarter_boundary: {\n        message: '\u56DB\u534A\u671F\u30D5\u30A9\u30FC\u30AD\u30E3\u30B9\u30C8\u306F\u56DB\u534A\u671F\u306E\u5883\u754C\uFF081 \u6708 1 \u65E5\u30014 \u6708 1 \u65E5\u30017 \u6708 1 \u65E5\u300110 \u6708 1 \u65E5\uFF09\u304B\u3089\u958B\u59CB\u3059\u308B\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059\u3002',\n      },\n      snapshot_amounts_non_negative: {\n        message: '\u30B9\u30CA\u30C3\u30D7\u30B7\u30E7\u30C3\u30C8\u91D1\u984D\u306F\u8CA0\u306E\u5024\u306B\u3067\u304D\u307E\u305B\u3093\u3002',\n      },\n    },\n    label: '\u30D5\u30A9\u30FC\u30AD\u30E3\u30B9\u30C8',\n    pluralLabel: '\u30D5\u30A9\u30FC\u30AD\u30E3\u30B9\u30C8',\n    description: '\u62C5\u5F53\u8005\u3054\u3068\u306E\u5B9A\u671F\u30D1\u30A4\u30D7\u30E9\u30A4\u30F3\u30B9\u30CA\u30C3\u30D7\u30B7\u30E7\u30C3\u30C8\u3067\u53CE\u76CA\u4E88\u6E2C\u306B\u4F7F\u7528',\n    fields: {\n      owner_id: { label: '\u62C5\u5F53\u8005' },\n      period: { label: '\u671F\u9593', options: { month: '\u6708\u6B21', quarter: '\u56DB\u534A\u671F' } },\n      period_start: {\n        label: '\u671F\u9593\u958B\u59CB',\n        help: '\u671F\u9593\u306E\u521D\u65E5\u3067\u3042\u308B\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059 \u2014 \u4F8B: 2026 \u5E74 8 \u6708\u306A\u3089 2026-08-01\u3002\u56DB\u534A\u671F\u306E\u30D5\u30A9\u30FC\u30AD\u30E3\u30B9\u30C8\u306F\u3055\u3089\u306B\u56DB\u534A\u671F\u306E\u5883\u754C\uFF081 \u6708 1 \u65E5\u30FB4 \u6708 1 \u65E5\u30FB7 \u6708 1 \u65E5\u30FB10 \u6708 1 \u65E5\uFF09\u3067\u958B\u59CB\u3059\u308B\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059\u3002',\n      },\n      period_end: {\n        label: '\u671F\u9593\u7D42\u4E86',\n        help: '\u901A\u5E38\u306F\u300C\u671F\u9593\u300D\u3068\u300C\u671F\u9593\u958B\u59CB\u300D\u304B\u3089\u81EA\u52D5\u7684\u306B\u7B97\u51FA\u3055\u308C\u307E\u3059\u3002\u624B\u52D5\u3067\u5165\u529B\u3059\u308B\u5834\u5408\u306F\u3001\u305D\u306E\u671F\u9593\u306E\u6700\u7D42\u65E5\u3067\u3042\u308B\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059 \u2014 \u4F8B: 2026-07-01 \u958B\u59CB\u306E\u56DB\u534A\u671F\u306A\u3089 2026-09-30\u30012026 \u5E74 8 \u6708\u306A\u3089 2026-08-31\u3002',\n      },\n      period_label: {\n        label: '\u671F\u9593',\n        help: '\u300C2026 \u5E74\u7B2C 3 \u56DB\u534A\u671F\u300D\u300C2026 \u5E74 8 \u6708\u300D\u306E\u3088\u3046\u306A\u8AAD\u307F\u3084\u3059\u3044\u671F\u9593\u30E9\u30D9\u30EB\u3002',\n      },\n      display_title: { label: '\u8868\u793A\u540D' },\n      snapshot_date: { label: '\u30B9\u30CA\u30C3\u30D7\u30B7\u30E7\u30C3\u30C8\u65E5', help: '\u3053\u306E\u30B9\u30CA\u30C3\u30D7\u30B7\u30E7\u30C3\u30C8\u3092\u53D6\u5F97\u3057\u305F\u65E5\u3002' },\n      source: {\n        label: '\u30BD\u30FC\u30B9',\n        options: { scheduled: '\u5B9A\u671F\u30B9\u30CA\u30C3\u30D7\u30B7\u30E7\u30C3\u30C8', ai: 'AI \u30B9\u30AD\u30EB', manual: '\u624B\u52D5\u5165\u529B' },\n      },\n      quota: { label: '\u30AF\u30A9\u30FC\u30BF' },\n      pipeline_amount: {\n        label: '\u30D1\u30A4\u30D7\u30E9\u30A4\u30F3',\n        help: '\u3053\u306E\u671F\u9593\u306B\u30AF\u30ED\u30FC\u30BA\u4E88\u5B9A\u306E\u30AA\u30FC\u30D7\u30F3\u5546\u8AC7\u306E\u5408\u8A08\u91D1\u984D\uFF08\u30B9\u30C6\u30FC\u30B8\u3092\u554F\u308F\u306A\u3044\uFF09\u3002',\n      },\n      best_case_amount: {\n        label: '\u30D9\u30B9\u30C8\u30B1\u30FC\u30B9',\n        help: '\u58F2\u4E0A\u4E88\u6E2C\u30AB\u30C6\u30B4\u30EA\u304C\u300C\u30D9\u30B9\u30C8\u30B1\u30FC\u30B9\u300D\u307E\u305F\u306F\u300C\u30B3\u30DF\u30C3\u30C8\u300D\u306E\u30AA\u30FC\u30D7\u30F3\u5546\u8AC7\u3002',\n      },\n      commit_amount: {\n        label: '\u30B3\u30DF\u30C3\u30C8',\n        help: '\u58F2\u4E0A\u4E88\u6E2C\u30AB\u30C6\u30B4\u30EA\u304C\u300C\u30B3\u30DF\u30C3\u30C8\u300D\u306E\u30AA\u30FC\u30D7\u30F3\u5546\u8AC7\uFF08\u62C5\u5F53\u8005\u304C\u30B3\u30DF\u30C3\u30C8\u6E08\u307F\uFF09\u3002',\n      },\n      closed_amount: { label: '\u30AF\u30ED\u30FC\u30BA', help: '\u3053\u306E\u671F\u9593\u306B\u3059\u3067\u306B\u6210\u7ACB\u3057\u305F\u91D1\u984D\u3002' },\n      expected_amount: {\n        label: '\u4E88\u60F3',\n        help: '\u30AF\u30ED\u30FC\u30BA + \u30B3\u30DF\u30C3\u30C8 \u2014 \u62C5\u5F53\u8005\u304C\u7121\u7406\u306A\u304F\u7740\u5730\u3092\u898B\u8FBC\u3081\u308B\u91D1\u984D\u3002',\n      },\n      attainment_pct: {\n        label: '\u9054\u6210\u7387 %',\n        help: '\u30AF\u30ED\u30FC\u30BA \u00F7 \u30AF\u30A9\u30FC\u30BF \u00D7 100\u3002\u30AF\u30A9\u30FC\u30BF\u304C\u6B63\u306E\u5024\u306B\u306A\u308B\u307E\u3067\u306F 0% \u3068\u8868\u793A\u3055\u308C\u307E\u3059\u3002',\n      },\n      coverage_ratio: {\n        label: '\u30AB\u30D0\u30EC\u30C3\u30B8',\n        help: '\u30D1\u30A4\u30D7\u30E9\u30A4\u30F3 \u00F7\uFF08\u30AF\u30A9\u30FC\u30BF \u2212 \u30AF\u30ED\u30FC\u30BA\uFF09\u2014 \u6B8B\u308A\u306E\u5DEE\u5206\u3092\u57CB\u3081\u308B\u30D1\u30A4\u30D7\u30E9\u30A4\u30F3\u304C\u5341\u5206\u304B\u3069\u3046\u304B\u3002\u30AF\u30A9\u30FC\u30BF\u9054\u6210\u6E08\u307F\u306E\u5834\u5408\u306F 0 \u3068\u8868\u793A\u3055\u308C\u307E\u3059\u3002',\n      },\n      notes: { label: '\u30E1\u30E2' },\n      seed_key: {\n        label: '\u30B7\u30FC\u30C9\u30AD\u30FC',\n        help: '\u30C7\u30E2\u30C7\u30FC\u30BF\u306E\u8B58\u5225\u5B50\u3002\u30B7\u30FC\u30C9\u30ED\u30FC\u30C0\u30FC\u3060\u3051\u304C\u66F8\u304D\u8FBC\u307F\u3001\u5B9F\u969B\u306E\u30B9\u30CA\u30C3\u30D7\u30B7\u30E7\u30C3\u30C8\u3067\u306F\u5E38\u306B\u7A7A\u3067\u3059\u3002',\n      },\n    },\n    _views: {\n      all_forecasts: { label: '\u3059\u3079\u3066\u306E\u30D5\u30A9\u30FC\u30AD\u30E3\u30B9\u30C8' },\n      this_quarter_forecasts: {\n        label: '\u4ECA\u56DB\u534A\u671F',\n        emptyState: {\n          title: '\u4ECA\u56DB\u534A\u671F\u306E\u30B9\u30CA\u30C3\u30D7\u30B7\u30E7\u30C3\u30C8\u306F\u307E\u3060\u3042\u308A\u307E\u305B\u3093',\n          message: '\u56DB\u534A\u671F\u30B9\u30CA\u30C3\u30D7\u30B7\u30E7\u30C3\u30C8\u306F\u591C\u9593\u306E\u30D5\u30A9\u30FC\u30AD\u30E3\u30B9\u30C8\u96C6\u8A08\u304C\u66F8\u304D\u8FBC\u307F\u307E\u3059\u3002\u4ECA\u56DB\u534A\u671F\u5206\u304C\u4E00\u5EA6\u5B9F\u884C\u3055\u308C\u308B\u307E\u3067\u3053\u306E\u30D3\u30E5\u30FC\u306F\u7A7A\u3067\u3059\u3002\u78BA\u5B9A\u6E08\u307F\u306E\u56DB\u534A\u671F\u306F\u300C\u3059\u3079\u3066\u300D\u30BF\u30D6\u306B\u3042\u308A\u307E\u3059\u3002',\n        },\n      },\n      my_forecast: { label: '\u81EA\u5206\u306E\u30D5\u30A9\u30FC\u30AD\u30E3\u30B9\u30C8' },\n    },\n    _sections: {\n      basic: { label: '\u30B9\u30CA\u30C3\u30D7\u30B7\u30E7\u30C3\u30C8' },\n      amounts: { label: '\u91D1\u984D' },\n      meta: { label: '\u30BD\u30FC\u30B9' },\n      // forecast.view.ts \u306E\u30D5\u30A9\u30FC\u30E0\u30BB\u30AF\u30B7\u30E7\u30F3\u540D (#1100)\n      snapshot: { label: '\u30B9\u30CA\u30C3\u30D7\u30B7\u30E7\u30C3\u30C8' },\n      notes: { label: '\u30E1\u30E2' },\n    },\n  },\n};\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/sales/translations/ja-JP/objects.commerce.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/sales/translations/ja-JP\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/sales/translations/ja-JP/objects.commerce.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport type { ObjectTranslationData } from '@objectstack/spec/system';\n\n/**\n * \u65E5\u672C\u8A9E (ja-JP) \u2014 `objects` translations for the COMMERCE family:\n * what gets sold and on what paper \u2014 quotes, contracts, products.\n *\n * Roster: `crm_quote`, `crm_quote_line_item`, `crm_contract`, `crm_product`.\n *\n * SPLIT AXIS (#1311): translation NAMESPACE first, then CRM DOMAIN FAMILY.\n * Everything that is not `objects` lives in `./app.ts`; `objects` \u2014 69-78% of\n * every bundle \u2014 is one file per CRM domain family, and a detail object\n * follows its master. A new row goes in the file for ITS family, never in\n * whichever file is already open: that is how one file re-grows past the 70%\n * advisory band `pnpm hygiene` prints. Full rule and rationale:\n * `src/sales/translations/ja-JP.ts`.\n */\nconst paymentTermsOptions = {\n  net_15: '15 \u65E5\u4EE5\u5185\u6255\u3044', net_30: '30 \u65E5\u4EE5\u5185\u6255\u3044', net_60: '60 \u65E5\u4EE5\u5185\u6255\u3044',\n  net_90: '90 \u65E5\u4EE5\u5185\u6255\u3044', due_on_receipt: '\u8ACB\u6C42\u66F8\u53D7\u9818\u6642\u6255\u3044',\n};\n\nexport const commerce: Record<string, ObjectTranslationData> = {\n  crm_quote: {\n    _validations: {\n      discount_within_ceiling: {\n        message: '\u5272\u5F15\u7387\u306F 60% \u3092\u8D85\u3048\u3089\u308C\u307E\u305B\u3093',\n      },\n      expiration_after_quote: {\n        message: '\u6709\u52B9\u671F\u9650\u306F\u898B\u7A4D\u65E5\u3088\u308A\u5F8C\u3067\u3042\u308B\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059',\n      },\n      quote_status_progression: {\n        message: '\u7121\u52B9\u306A\u898B\u7A4D\u30B9\u30C6\u30FC\u30BF\u30B9\u9077\u79FB\u3067\u3059',\n      },\n    },\n    label: '\u898B\u7A4D',\n    pluralLabel: '\u898B\u7A4D',\n    description: '\u9867\u5BA2\u306B\u63D0\u793A\u3059\u308B\u4FA1\u683C\u898B\u7A4D',\n    fields: {\n      quote_number: { label: '\u898B\u7A4D\u756A\u53F7' },\n      name: { label: '\u898B\u7A4D\u540D' },\n      display_title: { label: '\u8868\u793A\u540D' },\n      crm_account: { label: '\u53D6\u5F15\u5148' },\n      crm_contact: {\n        label: '\u53D6\u5F15\u5148\u8CAC\u4EFB\u8005',\n        help: '\u898B\u7A4D\u304C\u300C\u63D0\u793A\u6E08\u307F\u300D\u307E\u305F\u306F\u300C\u627F\u8A8D\u6E08\u307F\u300D\u306B\u306A\u3063\u305F\u6642\u70B9\u3067\u5FC5\u9808\u3067\u3059\u3002\u4F5C\u6210\u3055\u308C\u308B\u5951\u7D04\u306E\u4E3B\u62C5\u5F53\u8005\u306F\u3053\u3053\u304B\u3089\u5F15\u304D\u7D99\u304C\u308C\u307E\u3059\u3002',\n      },\n      crm_opportunity: { label: '\u5546\u8AC7' },\n      owner_id: { label: '\u898B\u7A4D\u62C5\u5F53\u8005' },\n      status: {\n        label: '\u30B9\u30C6\u30FC\u30BF\u30B9',\n        options: {\n          draft: '\u4E0B\u66F8\u304D', in_review: '\u30EC\u30D3\u30E5\u30FC\u4E2D', presented: '\u63D0\u793A\u6E08\u307F',\n          accepted: '\u627F\u8A8D\u6E08\u307F', rejected: '\u5374\u4E0B', expired: '\u671F\u9650\u5207\u308C',\n        },\n      },\n      quote_date: { label: '\u898B\u7A4D\u65E5' },\n      expiration_date: { label: '\u6709\u52B9\u671F\u9650' },\n      subtotal: { label: '\u5C0F\u8A08' },\n      discount: { label: '\u5272\u5F15\u7387(%)' },\n      discount_amount: { label: '\u5272\u5F15\u984D' },\n      tax: { label: '\u7A0E\u984D' },\n      shipping_handling: { label: '\u914D\u9001\u30FB\u624B\u6570\u6599' },\n      total_price: { label: '\u5408\u8A08\u91D1\u984D' },\n      payment_terms: { label: '\u652F\u6255\u6761\u4EF6', options: { ...paymentTermsOptions } },\n      shipping_terms: { label: '\u914D\u9001\u6761\u4EF6' },\n      billing_address: { label: '\u8ACB\u6C42\u5148\u4F4F\u6240' },\n      shipping_address: { label: '\u914D\u9001\u5148\u4F4F\u6240' },\n      description: { label: '\u8AAC\u660E' },\n      internal_notes: { label: '\u5185\u90E8\u30E1\u30E2' },\n    },\n    _views: {\n      all_quotes: { label: '\u5168\u898B\u7A4D' },\n      quote_pipeline: { label: '\u898B\u7A4D\u30D1\u30A4\u30D7\u30E9\u30A4\u30F3' },\n      quote_calendar: { label: '\u898B\u7A4D\u30AB\u30EC\u30F3\u30C0\u30FC' },\n    },\n    _sections: {\n      basic: { label: '\u898B\u7A4D\u60C5\u5831' },\n      pricing: { label: '\u4FA1\u683C' },\n      terms: { label: '\u6761\u4EF6\u30FB\u6709\u52B9\u671F\u9650' },\n      address: { label: '\u4F4F\u6240' },\n      system: { label: '\u30B7\u30B9\u30C6\u30E0' },\n      // quote.view.ts \u306E\u30D5\u30A9\u30FC\u30E0\u30BB\u30AF\u30B7\u30E7\u30F3\u540D (#1100)\n      quote: { label: '\u898B\u7A4D\u66F8' },\n      totals: { label: '\u5408\u8A08' },\n      quote_terms: { label: '\u5951\u7D04\u6761\u4EF6' },\n      addresses_and_notes: { label: '\u4F4F\u6240\u3068\u5099\u8003' },\n    },\n  },\n  crm_quote_line_item: {\n    _validations: {\n      discount_within_ceiling: {\n        message: '\u660E\u7D30\u306E\u5272\u5F15\u7387\u306F 60% \u3092\u8D85\u3048\u3089\u308C\u307E\u305B\u3093',\n      },\n      unit_price_positive: {\n        message: '\u8CA9\u58F2\u4FA1\u683C\u3092\u8CA0\u306E\u5024\u306B\u3059\u308B\u3053\u3068\u306F\u3067\u304D\u307E\u305B\u3093',\n      },\n    },\n    label: '\u898B\u7A4D\u660E\u7D30',\n    pluralLabel: '\u898B\u7A4D\u660E\u7D30',\n    description: '\u898B\u7A4D\u914D\u4E0B\u306E\u88FD\u54C1\u5225\u4FA1\u683C\u660E\u7D30\u884C',\n    fields: {\n      crm_quote: { label: '\u898B\u7A4D' },\n      crm_product: { label: '\u88FD\u54C1' },\n      description: { label: '\u8AAC\u660E' },\n      quantity: { label: '\u6570\u91CF' },\n      list_price: { label: '\u5B9A\u4FA1' },\n      unit_price: { label: '\u8CA9\u58F2\u4FA1\u683C' },\n      discount: { label: '\u5272\u5F15\u7387\uFF08%\uFF09' },\n      subtotal: { label: '\u5C0F\u8A08' },\n      total_price: { label: '\u5408\u8A08' },\n      line_number: { label: '\u884C\u756A\u53F7' },\n    },\n    _sections: {\n      basic: { label: '\u660E\u7D30\u884C' },\n      pricing: { label: '\u4FA1\u683C' },\n    },\n  },\n  crm_contract: {\n    _validations: {\n      end_after_start: {\n        message: '\u7D42\u4E86\u65E5\u306F\u958B\u59CB\u65E5\u3088\u308A\u5F8C\u3067\u3042\u308B\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059',\n      },\n      contract_status_progression: {\n        message: '\u7121\u52B9\u306A\u5951\u7D04\u30B9\u30C6\u30FC\u30BF\u30B9\u9077\u79FB\u3067\u3059',\n      },\n    },\n    label: '\u5951\u7D04',\n    pluralLabel: '\u5951\u7D04',\n    description: '\u9867\u5BA2\u3068\u7DE0\u7D50\u3057\u305F\u6CD5\u7684\u306A\u5951\u7D04\u30FB\u5408\u610F',\n    fields: {\n      contract_number: { label: '\u5951\u7D04\u756A\u53F7' },\n      crm_account: { label: '\u53D6\u5F15\u5148' },\n      crm_contact: { label: '\u4E3B\u62C5\u5F53\u8005' },\n      crm_opportunity: { label: '\u95A2\u9023\u5546\u8AC7' },\n      owner_id: { label: '\u5951\u7D04\u62C5\u5F53\u8005' },\n      status: {\n        label: '\u30B9\u30C6\u30FC\u30BF\u30B9',\n        options: {\n          draft: '\u4E0B\u66F8\u304D', in_approval: '\u627F\u8A8D\u4E2D', activated: '\u6709\u52B9',\n          expired: '\u671F\u9650\u5207\u308C', terminated: '\u89E3\u7D04',\n        },\n      },\n      contract_term_months: { label: '\u5951\u7D04\u671F\u9593\uFF08\u6708\uFF09' },\n      start_date: { label: '\u958B\u59CB\u65E5' },\n      end_date: { label: '\u7D42\u4E86\u65E5' },\n      contract_value: { label: '\u5951\u7D04\u91D1\u984D' },\n      billing_frequency: {\n        label: '\u8ACB\u6C42\u983B\u5EA6',\n        options: { monthly: '\u6708\u6B21', quarterly: '\u56DB\u534A\u671F', annually: '\u5E74\u6B21', one_time: '\u4E00\u62EC' },\n      },\n      payment_terms: { label: '\u652F\u6255\u6761\u4EF6', options: { ...paymentTermsOptions } },\n      auto_renewal: { label: '\u81EA\u52D5\u66F4\u65B0' },\n      renewal_notice_days: { label: '\u66F4\u65B0\u901A\u77E5\uFF08\u65E5\uFF09' },\n      contract_type: {\n        label: '\u5951\u7D04\u7A2E\u5225',\n        options: {\n          subscription: '\u30B5\u30D6\u30B9\u30AF\u30EA\u30D7\u30B7\u30E7\u30F3\u5951\u7D04', service: '\u30B5\u30FC\u30D3\u30B9\u5951\u7D04',\n          license: '\u30E9\u30A4\u30BB\u30F3\u30B9\u5951\u7D04', partnership: '\u30D1\u30FC\u30C8\u30CA\u30FC\u30B7\u30C3\u30D7\u5951\u7D04',\n          nda: '\u79D8\u5BC6\u4FDD\u6301\u5951\u7D04 (NDA)', msa: '\u57FA\u672C\u5951\u7D04 (MSA)',\n        },\n      },\n      signed_date: { label: '\u7F72\u540D\u65E5' },\n      signed_by: { label: '\u7F72\u540D\u8005' },\n      document_url: { label: '\u5951\u7D04\u66F8\u985E' },\n      special_terms: { label: '\u7279\u7D04\u4E8B\u9805' },\n      description: { label: '\u8AAC\u660E' },\n      billing_address: { label: '\u8ACB\u6C42\u5148\u4F4F\u6240' },\n    },\n    _views: {\n      all_contracts: { label: '\u5168\u5951\u7D04' },\n      renewal_calendar: { label: '\u66F4\u65B0\u30AB\u30EC\u30F3\u30C0\u30FC' },\n      contract_gantt: { label: '\u5951\u7D04\u671F\u9593' },\n      contract_timeline: { label: '\u5951\u7D04\u30BF\u30A4\u30E0\u30E9\u30A4\u30F3' },\n    },\n    _sections: {\n      basic: { label: '\u5951\u7D04\u60C5\u5831' },\n      parties: { label: '\u5951\u7D04\u5F53\u4E8B\u8005' },\n      terms: { label: '\u5951\u7D04\u6761\u4EF6\u30FB\u671F\u9593' },\n      value: { label: '\u5951\u7D04\u91D1\u984D' },\n      status: { label: '\u30B9\u30C6\u30FC\u30BF\u30B9\u30FB\u627F\u8A8D' },\n      renewal: { label: '\u66F4\u65B0' },\n      // contract.view.ts \u306E\u30D5\u30A9\u30FC\u30E0\u30BB\u30AF\u30B7\u30E7\u30F3\u540D (#1100)\n      contract_terms: { label: '\u5951\u7D04\u6761\u4EF6' },\n      signing_and_documents: { label: '\u7F72\u540D\u3068\u66F8\u985E' },\n      notes: { label: '\u5099\u8003' },\n    },\n  },\n  crm_product: {\n    _validations: {\n      cost_less_than_price: {\n        message: '\u539F\u4FA1\u306F\u5B9A\u4FA1\u3088\u308A\u4F4E\u304F\u3057\u3066\u304F\u3060\u3055\u3044',\n      },\n      price_positive: {\n        message: '\u5B9A\u4FA1\u306F\u6B63\u306E\u5024\u3067\u3042\u308B\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059',\n      },\n    },\n    label: '\u88FD\u54C1',\n    pluralLabel: '\u88FD\u54C1',\n    description: '\u81EA\u793E\u304C\u63D0\u4F9B\u3059\u308B\u88FD\u54C1\u30FB\u30B5\u30FC\u30D3\u30B9',\n    fields: {\n      product_code: { label: '\u88FD\u54C1\u30B3\u30FC\u30C9' },\n      name: { label: '\u88FD\u54C1\u540D' },\n      display_title: { label: '\u8868\u793A\u540D' },\n      description: { label: '\u8AAC\u660E' },\n      category: {\n        label: '\u30AB\u30C6\u30B4\u30EA',\n        options: {\n          software: '\u30BD\u30D5\u30C8\u30A6\u30A7\u30A2', hardware: '\u30CF\u30FC\u30C9\u30A6\u30A7\u30A2', service: '\u30B5\u30FC\u30D3\u30B9',\n          subscription: '\u30B5\u30D6\u30B9\u30AF\u30EA\u30D7\u30B7\u30E7\u30F3', support: '\u30B5\u30DD\u30FC\u30C8',\n        },\n      },\n      family: {\n        label: '\u88FD\u54C1\u30D5\u30A1\u30DF\u30EA',\n        options: {\n          enterprise: '\u30A8\u30F3\u30BF\u30FC\u30D7\u30E9\u30A4\u30BA\u5411\u3051\u30BD\u30EA\u30E5\u30FC\u30B7\u30E7\u30F3', smb: '\u4E2D\u5C0F\u4F01\u696D\u5411\u3051\u30BD\u30EA\u30E5\u30FC\u30B7\u30E7\u30F3',\n          services: '\u30D7\u30ED\u30D5\u30A7\u30C3\u30B7\u30E7\u30CA\u30EB\u30B5\u30FC\u30D3\u30B9', cloud: '\u30AF\u30E9\u30A6\u30C9\u30B5\u30FC\u30D3\u30B9',\n        },\n      },\n      list_price: { label: '\u5B9A\u4FA1' },\n      cost: { label: '\u30B3\u30B9\u30C8' },\n      sku: { label: 'SKU' },\n      is_active: { label: '\u6709\u52B9' },\n      product_manager: { label: '\u30D7\u30ED\u30C0\u30AF\u30C8\u30DE\u30CD\u30FC\u30B8\u30E3\u30FC' },\n      image: { label: '\u88FD\u54C1\u753B\u50CF' },\n      datasheet: { label: '\u30C7\u30FC\u30BF\u30B7\u30FC\u30C8' },\n    },\n    _views: {\n      all_products: { label: '\u5168\u88FD\u54C1' },\n      product_catalog: { label: '\u88FD\u54C1\u30AB\u30BF\u30ED\u30B0' },\n    },\n    _sections: {\n      basic: { label: '\u88FD\u54C1\u60C5\u5831' },\n      pricing: { label: '\u4FA1\u683C' },\n      metadata: { label: '\u95A2\u9023\u8CC7\u6599' },\n      // product.view.ts \u306E\u30D5\u30A9\u30FC\u30E0\u30BB\u30AF\u30B7\u30E7\u30F3\u540D (#1100)\n      product_info: { label: '\u88FD\u54C1\u60C5\u5831' },\n      pricing_info: { label: '\u4FA1\u683C' },\n      media: { label: '\u30E1\u30C7\u30A3\u30A2' },\n    },\n  },\n};\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/sales/translations/ja-JP/objects.service.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/sales/translations/ja-JP\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/sales/translations/ja-JP/objects.service.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport type { ObjectTranslationData } from '@objectstack/spec/system';\n\nimport { activityActions } from './_shared';\n\n/**\n * \u65E5\u672C\u8A9E (ja-JP) \u2014 `objects` translations for the SERVICE family:\n * post-sale support \u2014 cases and the knowledge that deflects them.\n *\n * Roster: `crm_case`, `crm_knowledge_article`, `crm_article_feedback`.\n *\n * SPLIT AXIS (#1311): translation NAMESPACE first, then CRM DOMAIN FAMILY.\n * Everything that is not `objects` lives in `./app.ts`; `objects` \u2014 69-78% of\n * every bundle \u2014 is one file per CRM domain family, and a detail object\n * follows its master. A new row goes in the file for ITS family, never in\n * whichever file is already open: that is how one file re-grows past the 70%\n * advisory band `pnpm hygiene` prints. Full rule and rationale:\n * `src/sales/translations/ja-JP.ts`.\n */\nexport const service: Record<string, ObjectTranslationData> = {\n  crm_case: {\n    _validations: {\n      resolution_required_for_closed: {\n        message: '\u30B1\u30FC\u30B9\u3092\u30AF\u30ED\u30FC\u30BA\u3059\u308B\u306B\u306F\u89E3\u6C7A\u5185\u5BB9\u304C\u5FC5\u8981\u3067\u3059',\n      },\n      escalation_reason_required: {\n        message: '\u30B1\u30FC\u30B9\u3092\u30A8\u30B9\u30AB\u30EC\u30FC\u30B7\u30E7\u30F3\u3059\u308B\u306B\u306F\u7406\u7531\u304C\u5FC5\u8981\u3067\u3059',\n      },\n      case_status_progression: {\n        message: '\u7121\u52B9\u306A\u30B9\u30C6\u30FC\u30BF\u30B9\u9077\u79FB\u3067\u3059',\n      },\n    },\n    label: '\u30B1\u30FC\u30B9',\n    pluralLabel: '\u30B1\u30FC\u30B9',\n    description: '\u30AB\u30B9\u30BF\u30DE\u30FC\u30B5\u30DD\u30FC\u30C8\u306E\u30B1\u30FC\u30B9\u3068\u30B5\u30FC\u30D3\u30B9\u4F9D\u983C',\n    fields: {\n      case_number: { label: '\u30B1\u30FC\u30B9\u756A\u53F7' },\n      subject: { label: '\u4EF6\u540D' },\n      display_title: { label: '\u8868\u793A\u540D' },\n      description: { label: '\u8AAC\u660E' },\n      crm_account: { label: '\u53D6\u5F15\u5148' },\n      crm_contact: { label: '\u53D6\u5F15\u5148\u8CAC\u4EFB\u8005' },\n      status: {\n        label: '\u30B9\u30C6\u30FC\u30BF\u30B9',\n        options: {\n          new: '\u65B0\u898F', in_progress: '\u5BFE\u5FDC\u4E2D',\n          waiting_customer: '\u9867\u5BA2\u306E\u56DE\u7B54\u5F85\u3061', waiting_support: '\u30B5\u30DD\u30FC\u30C8\u306E\u56DE\u7B54\u5F85\u3061',\n          escalated: '\u30A8\u30B9\u30AB\u30EC\u30FC\u30B7\u30E7\u30F3\u6E08', resolved: '\u89E3\u6C7A\u6E08', closed: '\u30AF\u30ED\u30FC\u30BA\u6E08',\n        },\n      },\n      priority: {\n        label: '\u512A\u5148\u5EA6',\n        options: { low: '\u4F4E', medium: '\u4E2D', high: '\u9AD8', critical: '\u91CD\u5927' },\n      },\n      priority_rank: { label: '\u512A\u5148\u5EA6\u30E9\u30F3\u30AF' },\n      type: {\n        label: '\u30B1\u30FC\u30B9\u7A2E\u5225',\n        options: {\n          question: '\u554F\u3044\u5408\u308F\u305B', problem: '\u4E0D\u5177\u5408',\n          feature_request: '\u6A5F\u80FD\u8981\u671B', bug: '\u30D0\u30B0',\n        },\n      },\n      origin: {\n        label: '\u30B1\u30FC\u30B9\u767A\u751F\u5143',\n        options: { email: '\u30E1\u30FC\u30EB', phone: '\u96FB\u8A71', web: '\u30A6\u30A7\u30D6', chat: '\u30C1\u30E3\u30C3\u30C8', social_media: '\u30BD\u30FC\u30B7\u30E3\u30EB\u30E1\u30C7\u30A3\u30A2' },\n      },\n      owner_id: { label: '\u30B1\u30FC\u30B9\u62C5\u5F53\u8005' },\n      closed_date: { label: '\u30AF\u30ED\u30FC\u30BA\u65E5' },\n      first_response_date: { label: '\u521D\u56DE\u5FDC\u7B54\u65E5' },\n      resolution_time_hours: { label: '\u89E3\u6C7A\u6642\u9593\uFF08\u6642\u9593\uFF09' },\n      sla_due_date: { label: 'SLA\u671F\u9650', help: '\u30B1\u30FC\u30B9\u306E\u512A\u5148\u5EA6\u3068\u53D6\u5F15\u5148\u306E\u9867\u5BA2\u30E9\u30F3\u30AF\u304B\u3089\u8A2D\u5B9A\u3055\u308C\u3001\u66A6\u6642\u9593\u3067\u6570\u3048\u307E\u3059\u3002\u591C\u9593\u30FB\u9031\u672B\u30FB\u795D\u65E5\u3082\u3059\u3079\u3066\u542B\u307E\u308C\u307E\u3059\u3002' },\n      is_sla_violated: { label: 'SLA\u9055\u53CD' },\n      is_escalated: { label: '\u30A8\u30B9\u30AB\u30EC\u30FC\u30B7\u30E7\u30F3\u6E08' },\n      escalated_date: { label: '\u30A8\u30B9\u30AB\u30EC\u30FC\u30B7\u30E7\u30F3\u65E5' },\n      escalation_reason: { label: '\u30A8\u30B9\u30AB\u30EC\u30FC\u30B7\u30E7\u30F3\u7406\u7531' },\n      resolution: { label: '\u89E3\u6C7A\u5185\u5BB9' },\n      resolved_by_article: { label: '\u89E3\u6C7A\u3057\u305F\u30CA\u30EC\u30C3\u30B8\u8A18\u4E8B', help: '\u3053\u306E\u30B1\u30FC\u30B9\u3092\u89E3\u6C7A\u3057\u305F\u30CA\u30EC\u30C3\u30B8\u8A18\u4E8B \u2014 \u9038\u3089\u3057\u7387\u306E\u6307\u6A19\u3002' },\n      internal_notes: { label: '\u5185\u90E8\u30E1\u30E2', help: '\u9867\u5BA2\u306B\u306F\u8868\u793A\u3055\u308C\u306A\u3044\u793E\u5185\u5411\u3051\u30E1\u30E2' },\n      is_closed: { label: '\u30AF\u30ED\u30FC\u30BA\u6E08' },\n    },\n    _views: {\n      all_cases: { label: '\u5168\u30B1\u30FC\u30B9' },\n      case_workflow: { label: '\u30B5\u30FC\u30D3\u30B9\u30D5\u30ED\u30FC' },\n      sla_calendar: { label: 'SLA \u30AB\u30EC\u30F3\u30C0\u30FC' },\n      case_timeline: { label: '\u30B1\u30FC\u30B9\u30BF\u30A4\u30E0\u30E9\u30A4\u30F3' },\n      unassigned_triage: {\n        label: '\u672A\u5272\u308A\u5F53\u3066 \u2014 \u30C8\u30EA\u30A2\u30FC\u30B8',\n        emptyState: {\n          title: '\u30C8\u30EA\u30A2\u30FC\u30B8\u5F85\u3061\u306F\u3042\u308A\u307E\u305B\u3093',\n          message: '\u3059\u3079\u3066\u306E\u30B1\u30FC\u30B9\u306B\u6240\u6709\u8005\u304C\u3044\u307E\u3059\u3002\u6240\u6709\u8005\u306E\u306A\u3044\u30B1\u30FC\u30B9\u306F\u3053\u3053\u306B\u8868\u793A\u3055\u308C\u307E\u3059 \u2014 \u901A\u5E38\u306F\u3001\u30B5\u30FC\u30D3\u30B9\u30A8\u30FC\u30B8\u30A7\u30F3\u30C8\u306E\u8077\u4F4D\u3092\u8AB0\u3082\u4FDD\u6301\u3057\u3066\u3044\u306A\u3044\u9593\u306B\u5C4A\u3044\u305F Web-to-Case \u306E\u9001\u4FE1\u3067\u3059\u3002',\n        },\n      },\n      escalated_cases: { label: '\u30A8\u30B9\u30AB\u30EC\u30FC\u30C8\u3057\u305F\u30B1\u30FC\u30B9' },\n      my_open_cases: { label: '\u79C1\u306E\u30AA\u30FC\u30D7\u30F3\u30B1\u30FC\u30B9' },\n      sla_at_risk: { label: '\u23F0 SLA \u30EA\u30B9\u30AF\u3042\u308A' },\n    },\n    _sections: {\n      // case.view.ts \u306E\u30D5\u30A9\u30FC\u30E0\u30BB\u30AF\u30B7\u30E7\u30F3\u540D (#1100)\u3002\n      case: { label: '\u30B1\u30FC\u30B9' },\n      how_can_we_help: { label: '\u3069\u306E\u3088\u3046\u306A\u3054\u7528\u4EF6\u3067\u3057\u3087\u3046\u304B\uFF1F' },\n      // \u30AA\u30D6\u30B8\u30A7\u30AF\u30C8\u5B9A\u7FA9\u306E\u30BB\u30AF\u30B7\u30E7\u30F3\u30AD\u30FC\uFF08case.object.ts\uFF09\u2014 \u5165\u529B\u30D5\u30A9\u30FC\u30E0\u3068\u3001\n      // \u3053\u308C\u3089\u306E\u30B0\u30EB\u30FC\u30D7\u3092\u53C2\u7167\u3059\u308B\u8A73\u7D30\u30DA\u30FC\u30B8\u306E\u30BB\u30AF\u30B7\u30E7\u30F3\uFF08#970\uFF09\u3067\u4F7F\u7528\n      basic: { label: '\u30B1\u30FC\u30B9\u60C5\u5831' },\n      origin: { label: '\u767A\u751F\u5143\u30FB\u632F\u308A\u5206\u3051' },\n      sla: { label: 'SLA\u30FB\u512A\u5148\u5EA6' },\n      resolution: { label: '\u89E3\u6C7A' },\n      escalation: { label: '\u30A8\u30B9\u30AB\u30EC\u30FC\u30B7\u30E7\u30F3' },\n      system: { label: '\u30B7\u30B9\u30C6\u30E0' },\n    },\n    _actions: {\n      ...activityActions,\n      escalate_case: {\n        label: '\u30B1\u30FC\u30B9\u3092\u30A8\u30B9\u30AB\u30EC\u30FC\u30C8',\n        confirmText: '\u3053\u306E\u30B1\u30FC\u30B9\u3092\u30A8\u30B9\u30AB\u30EC\u30FC\u30B7\u30E7\u30F3\u30C1\u30FC\u30E0\u3078\u5F15\u304D\u7D99\u304E\u307E\u3059\u3002\u7D9A\u884C\u3057\u307E\u3059\u304B\uFF1F',\n        successMessage: '\u30B1\u30FC\u30B9\u3092\u30A8\u30B9\u30AB\u30EC\u30FC\u30C8\u3057\u307E\u3057\u305F\uFF01',\n      },\n      close_case: {\n        label: '\u30B1\u30FC\u30B9\u3092\u30AF\u30ED\u30FC\u30BA',\n        confirmText: '\u3053\u306E\u30B1\u30FC\u30B9\u3092\u30AF\u30ED\u30FC\u30BA\u3057\u3066\u3082\u3088\u308D\u3057\u3044\u3067\u3059\u304B\uFF1F',\n        successMessage: '\u30B1\u30FC\u30B9\u3092\u30AF\u30ED\u30FC\u30BA\u3057\u307E\u3057\u305F\uFF01',\n      },\n      claim_case: {\n        label: '\u30B1\u30FC\u30B9\u3092\u5F15\u304D\u53D7\u3051\u308B',\n        successMessage: '\u30B1\u30FC\u30B9\u3092\u5F15\u304D\u53D7\u3051\u307E\u3057\u305F\u3002\u62C5\u5F53\u8005\u306F\u3042\u306A\u305F\u3067\u3059\u3002',\n      },\n    },\n  },\n  crm_knowledge_article: {\n    _validations: {\n      published_requires_body: {\n        message: '\u672C\u6587\u306E\u306A\u3044\u8A18\u4E8B\u306F\u516C\u958B\u3067\u304D\u307E\u305B\u3093\u3002',\n      },\n      published_requires_summary: {\n        message: '\u516C\u958B\u6E08\u307F\u306E\u8A18\u4E8B\u306B\u306F\u3001\u691C\u7D22\u7D50\u679C\u3068 AI \u306E\u5F15\u7528\u306E\u305F\u3081\u306B\u6982\u8981\u3092\u8A18\u8F09\u3057\u3066\u304F\u3060\u3055\u3044\u3002',\n      },\n    },\n    label: '\u30CA\u30EC\u30C3\u30B8\u8A18\u4E8B',\n    pluralLabel: '\u30CA\u30EC\u30C3\u30B8\u30D9\u30FC\u30B9',\n    description: '\u9867\u5BA2\u3068\u30A8\u30FC\u30B8\u30A7\u30F3\u30C8\u304C\u518D\u5229\u7528\u3067\u304D\u308B\u56DE\u7B54\u3068\u30CF\u30A6\u30C4\u30FC\u30AC\u30A4\u30C9',\n    fields: {\n      article_number: { label: '\u8A18\u4E8B\u756A\u53F7' },\n      title: { label: '\u30BF\u30A4\u30C8\u30EB' },\n      display_title: { label: '\u8868\u793A\u540D' },\n      summary: { label: '\u8981\u7D04', help: '\u691C\u7D22\u7D50\u679C\u3084 AI \u306E\u5F15\u7528\u306B\u8868\u793A\u3055\u308C\u308B 1 \u6BB5\u843D\u306E\u8981\u7D04\u3002' },\n      body: { label: '\u672C\u6587', help: '\u8A18\u4E8B\u306E\u672C\u6587\uFF08Markdown\uFF09\u3002' },\n      category: {\n        label: '\u30AB\u30C6\u30B4\u30EA',\n        options: {\n          getting_started: '\u306F\u3058\u3081\u306B', how_to: '\u30CF\u30A6\u30C4\u30FC',\n          troubleshooting: '\u30C8\u30E9\u30D6\u30EB\u30B7\u30E5\u30FC\u30C6\u30A3\u30F3\u30B0', billing: '\u8ACB\u6C42\u3068\u6599\u91D1', api: 'API \u3068\u9023\u643A',\n          release_notes: '\u30EA\u30EA\u30FC\u30B9\u30CE\u30FC\u30C8', policy: '\u30DD\u30EA\u30B7\u30FC',\n        },\n      },\n      tags: {\n        label: '\u30BF\u30B0',\n        options: {\n          auth: '\u8A8D\u8A3C', sso: 'SSO', mobile: '\u30E2\u30D0\u30A4\u30EB', email: '\u30E1\u30FC\u30EB',\n          reports: '\u30EC\u30DD\u30FC\u30C8', performance: '\u30D1\u30D5\u30A9\u30FC\u30DE\u30F3\u30B9',\n          data_import: '\u30C7\u30FC\u30BF\u30A4\u30F3\u30DD\u30FC\u30C8', webhooks: 'Webhook',\n        },\n      },\n      status: {\n        label: '\u30B9\u30C6\u30FC\u30BF\u30B9',\n        options: { draft: '\u4E0B\u66F8\u304D', in_review: '\u30EC\u30D3\u30E5\u30FC\u4E2D', published: '\u516C\u958B\u6E08\u307F', archived: '\u30A2\u30FC\u30AB\u30A4\u30D6' },\n      },\n      audience: {\n        label: '\u5BFE\u8C61',\n        help: '\u516C\u958B\u8A18\u4E8B\u306F\u30AB\u30B9\u30BF\u30DE\u30FC\u30DD\u30FC\u30BF\u30EB\u306B\u8868\u793A\u3055\u308C\u3001\u793E\u5185\u8A18\u4E8B\u306F\u30A8\u30FC\u30B8\u30A7\u30F3\u30C8\u306E\u307F\u304C\u95B2\u89A7\u3067\u304D\u307E\u3059\u3002',\n        options: { public: '\u516C\u958B', internal: '\u793E\u5185' },\n      },\n      language: {\n        label: '\u8A00\u8A9E',\n        options: { en: '\u82F1\u8A9E', zh_cn: '\u7C21\u4F53\u5B57\u4E2D\u56FD\u8A9E', es_es: '\u30B9\u30DA\u30A4\u30F3\u8A9E', ja_jp: '\u65E5\u672C\u8A9E' },\n      },\n      owner_id: { label: '\u6240\u6709\u8005' },\n      related_to_case: { label: '\u5143\u306E\u30B1\u30FC\u30B9', help: '\u3053\u306E\u8A18\u4E8B\u306E\u5143\u306B\u306A\u3063\u305F\u30B1\u30FC\u30B9\uFF08\u4EFB\u610F\uFF09\u3002' },\n      published_at: { label: '\u516C\u958B\u65E5\u6642' },\n      last_reviewed_at: { label: '\u6700\u7D42\u30EC\u30D3\u30E5\u30FC' },\n      helpful_count: { label: '\u5F79\u306B\u7ACB\u3063\u305F', help: 'crm_article_feedback \u304B\u3089\u518D\u96C6\u8A08\u3055\u308C\u307E\u3059\u3002\u624B\u5165\u529B\u306F\u3067\u304D\u307E\u305B\u3093\u3002' },\n      not_helpful_count: { label: '\u5F79\u306B\u7ACB\u305F\u306A\u304B\u3063\u305F', help: 'crm_article_feedback \u304B\u3089\u518D\u96C6\u8A08\u3055\u308C\u307E\u3059\u3002\u624B\u5165\u529B\u306F\u3067\u304D\u307E\u305B\u3093\u3002' },\n    },\n    _views: {\n      all_articles: { label: '\u3059\u3079\u3066\u306E\u8A18\u4E8B' },\n      published_articles: { label: '\u516C\u958B\u6E08\u307F' },\n      my_drafts: { label: '\u81EA\u5206\u306E\u4E0B\u66F8\u304D' },\n    },\n    _sections: {\n      basic: { label: '\u8A18\u4E8B\u60C5\u5831' },\n      content: { label: '\u30B3\u30F3\u30C6\u30F3\u30C4' },\n      taxonomy: { label: '\u5206\u985E' },\n      metrics: { label: '\u5229\u7528\u72B6\u6CC1' },\n      engagement: { label: '\u5229\u7528\u72B6\u6CC1' },\n      // knowledge_article.view.ts \u306E\u30D5\u30A9\u30FC\u30E0\u30BB\u30AF\u30B7\u30E7\u30F3\u540D (#1100)\n      article: { label: '\u8A18\u4E8B' },\n    },\n    _actions: {\n      mark_article_helpful: {\n        label: '\u5F79\u306B\u7ACB\u3063\u305F',\n        successMessage: '\u300C\u5F79\u306B\u7ACB\u3063\u305F\u300D\u3068\u3057\u3066\u8A18\u9332\u3057\u307E\u3057\u305F\u3002\u3042\u308A\u304C\u3068\u3046\u3054\u3056\u3044\u307E\u3059\u3002',\n      },\n      mark_article_not_helpful: {\n        label: '\u5F79\u306B\u7ACB\u305F\u306A\u304B\u3063\u305F',\n        successMessage: '\u300C\u5F79\u306B\u7ACB\u305F\u306A\u304B\u3063\u305F\u300D\u3068\u3057\u3066\u8A18\u9332\u3057\u307E\u3057\u305F\u3002\u3042\u308A\u304C\u3068\u3046\u3054\u3056\u3044\u307E\u3059\u3002',\n      },\n    },\n  },\n  crm_article_feedback: {\n    label: '\u8A18\u4E8B\u30D5\u30A3\u30FC\u30C9\u30D0\u30C3\u30AF',\n    pluralLabel: '\u8A18\u4E8B\u30D5\u30A3\u30FC\u30C9\u30D0\u30C3\u30AF',\n    description: '\u30CA\u30EC\u30C3\u30B8\u8A18\u4E8B\u306B\u5BFE\u3059\u308B\u8AAD\u8005\u306E\u300C\u5F79\u306B\u7ACB\u3063\u305F / \u5F79\u306B\u7ACB\u305F\u306A\u304B\u3063\u305F\u300D\u8A55\u4FA1',\n    fields: {\n      feedback_number: { label: '\u30D5\u30A3\u30FC\u30C9\u30D0\u30C3\u30AF\u756A\u53F7' },\n      owner_id: { label: '\u8AAD\u8005' },\n      crm_knowledge_article: { label: '\u8A18\u4E8B', help: '\u3053\u306E\u30D5\u30A3\u30FC\u30C9\u30D0\u30C3\u30AF\u306E\u5BFE\u8C61\u3068\u306A\u308B\u30CA\u30EC\u30C3\u30B8\u8A18\u4E8B\u3002' },\n      verdict: {\n        label: '\u8A55\u4FA1',\n        options: { helpful: '\u5F79\u306B\u7ACB\u3063\u305F', not_helpful: '\u5F79\u306B\u7ACB\u305F\u306A\u304B\u3063\u305F' },\n      },\n      comment: { label: '\u30B3\u30E1\u30F3\u30C8', help: '\u8A55\u4FA1\u306E\u7406\u7531\uFF08\u4EFB\u610F\uFF09 \u2014 \u8A18\u4E8B\u306E\u4F5C\u6210\u8005\u304C\u8AAD\u307F\u307E\u3059\u3002' },\n    },\n    _sections: {\n      basic: { label: '\u30D5\u30A3\u30FC\u30C9\u30D0\u30C3\u30AF' },\n    },\n  },\n};\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/sales/translations/ja-JP/objects.activity.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/sales/translations/ja-JP\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/sales/translations/ja-JP/objects.activity.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport type { ObjectTranslationData } from '@objectstack/spec/system';\n\n/**\n * \u65E5\u672C\u8A9E (ja-JP) \u2014 `objects` translations for the ACTIVITY family:\n * the interaction log \u2014 tasks, events, and who attended.\n *\n * Roster: `crm_task`, `crm_event`, `crm_event_attendee`.\n *\n * SPLIT AXIS (#1311): translation NAMESPACE first, then CRM DOMAIN FAMILY.\n * Everything that is not `objects` lives in `./app.ts`; `objects` \u2014 69-78% of\n * every bundle \u2014 is one file per CRM domain family, and a detail object\n * follows its master. A new row goes in the file for ITS family, never in\n * whichever file is already open: that is how one file re-grows past the 70%\n * advisory band `pnpm hygiene` prints. Full rule and rationale:\n * `src/sales/translations/ja-JP.ts`.\n */\nconst relatedToTypeOptions = {\n  crm_account: '\u53D6\u5F15\u5148', crm_contact: '\u53D6\u5F15\u5148\u8CAC\u4EFB\u8005', crm_opportunity: '\u5546\u8AC7',\n  crm_lead: '\u30EA\u30FC\u30C9', crm_case: '\u30B1\u30FC\u30B9',\n};\n\nexport const activity: Record<string, ObjectTranslationData> = {\n  crm_task: {\n    _validations: {\n      completed_date_required: {\n        message: '\u30B9\u30C6\u30FC\u30BF\u30B9\u304C\u300C\u5B8C\u4E86\u300D\u306E\u5834\u5408\u306F\u5B8C\u4E86\u65E5\u304C\u5FC5\u8981\u3067\u3059',\n      },\n      recurrence_fields_required: {\n        message: '\u7E70\u308A\u8FD4\u3057\u30BF\u30B9\u30AF\u306B\u306F\u7E70\u308A\u8FD4\u3057\u7A2E\u5225\u304C\u5FC5\u8981\u3067\u3059',\n      },\n      related_to_required: {\n        message: '\u95A2\u9023\u30EC\u30B3\u30FC\u30C9\u3092\u5C11\u306A\u304F\u3068\u3082 1 \u4EF6\u9078\u629E\u3057\u3066\u304F\u3060\u3055\u3044',\n      },\n    },\n    label: '\u30BF\u30B9\u30AF',\n    pluralLabel: '\u30BF\u30B9\u30AF',\n    description: '\u6D3B\u52D5\u3068 ToDo',\n    fields: {\n      subject: { label: '\u4EF6\u540D' },\n      description: { label: '\u8AAC\u660E' },\n      status: {\n        label: '\u30B9\u30C6\u30FC\u30BF\u30B9',\n        options: {\n          not_started: '\u672A\u7740\u624B', in_progress: '\u9032\u884C\u4E2D', waiting: '\u5F85\u6A5F\u4E2D',\n          completed: '\u5B8C\u4E86', deferred: '\u4FDD\u7559',\n        },\n      },\n      priority: {\n        label: '\u512A\u5148\u5EA6',\n        options: { low: '\u4F4E', normal: '\u901A\u5E38', high: '\u9AD8', urgent: '\u7DCA\u6025' },\n      },\n      priority_rank: { label: '\u512A\u5148\u5EA6\u30E9\u30F3\u30AF' },\n      type: {\n        label: '\u30BF\u30B9\u30AF\u7A2E\u5225',\n        options: {\n          call: '\u96FB\u8A71', email: '\u30E1\u30FC\u30EB', meeting: '\u4F1A\u8B70',\n          follow_up: '\u30D5\u30A9\u30ED\u30FC\u30A2\u30C3\u30D7', demo: '\u30C7\u30E2', other: '\u305D\u306E\u4ED6',\n        },\n      },\n      due_date: { label: '\u671F\u9650' },\n      reminder_date: { label: '\u30EA\u30DE\u30A4\u30F3\u30C0\u30FC\u65E5\u6642' },\n      reminder_sent: { label: '\u30EA\u30DE\u30A4\u30F3\u30C0\u30FC\u9001\u4FE1\u6E08\u307F' },\n      completed_date: { label: '\u5B8C\u4E86\u65E5' },\n      owner_id: { label: '\u62C5\u5F53\u8005' },\n      related_to_type: {\n        label: '\u95A2\u9023\u30AA\u30D6\u30B8\u30A7\u30AF\u30C8\u7A2E\u5225',\n        options: { ...relatedToTypeOptions },\n      },\n      related_to_account: { label: '\u95A2\u9023\u53D6\u5F15\u5148' },\n      related_to_contact: { label: '\u95A2\u9023\u53D6\u5F15\u5148\u8CAC\u4EFB\u8005' },\n      related_to_opportunity: { label: '\u95A2\u9023\u5546\u8AC7' },\n      related_to_lead: { label: '\u95A2\u9023\u30EA\u30FC\u30C9' },\n      related_to_case: { label: '\u95A2\u9023\u30B1\u30FC\u30B9' },\n      is_recurring: { label: '\u7E70\u308A\u8FD4\u3057\u30BF\u30B9\u30AF' },\n      recurrence_type: {\n        label: '\u7E70\u308A\u8FD4\u3057\u7A2E\u5225',\n        options: { daily: '\u6BCE\u65E5', weekly: '\u6BCE\u9031', monthly: '\u6BCE\u6708', yearly: '\u6BCE\u5E74' },\n      },\n      recurrence_interval: { label: '\u7E70\u308A\u8FD4\u3057\u9593\u9694' },\n      recurrence_end_date: { label: '\u7E70\u308A\u8FD4\u3057\u7D42\u4E86\u65E5' },\n      is_completed: { label: '\u5B8C\u4E86\u6E08' },\n      is_overdue: { label: '\u671F\u9650\u8D85\u904E' },\n      progress_percent: { label: '\u9032\u6357\uFF08%\uFF09' },\n    },\n    _views: {\n      all_tasks: { label: '\u5168\u30BF\u30B9\u30AF' },\n      task_board: { label: '\u30BF\u30B9\u30AF\u30DC\u30FC\u30C9' },\n      task_calendar: { label: '\u30BF\u30B9\u30AF\u30AB\u30EC\u30F3\u30C0\u30FC' },\n      task_gantt: { label: '\u5B9F\u884C\u8A08\u753B' },\n      task_timeline: { label: '\u5DE5\u6570\u30BF\u30A4\u30E0\u30E9\u30A4\u30F3' },\n      my_open_tasks: { label: '\u79C1\u306E\u30AA\u30FC\u30D7\u30F3\u30BF\u30B9\u30AF' },\n      todays_tasks: { label: '\uD83D\uDCC5 \u79C1\u306E\u512A\u5148\u30BF\u30B9\u30AF' },\n      overdue_tasks: { label: '\u23F0 \u30AA\u30FC\u30D7\u30F3\u30BF\u30B9\u30AF \u00B7 \u671F\u9650\u8D85\u904E\u304C\u9577\u3044\u9806' },\n    },\n    _sections: {\n      basic: { label: '\u30BF\u30B9\u30AF\u60C5\u5831' },\n      scheduling: { label: '\u30B9\u30B1\u30B8\u30E5\u30FC\u30EB' },\n      related: { label: '\u95A2\u9023\u30EC\u30B3\u30FC\u30C9' },\n      recurrence: { label: '\u7E70\u308A\u8FD4\u3057' },\n      effort: { label: '\u9032\u6357\u30FB\u5DE5\u6570' },\n      system: { label: '\u30B7\u30B9\u30C6\u30E0' },\n      // task.view.ts \u306E\u30D5\u30A9\u30FC\u30E0\u30BB\u30AF\u30B7\u30E7\u30F3\u540D (#1100)\n      task: { label: '\u30BF\u30B9\u30AF' },\n      related_records: { label: '\u95A2\u9023\u30EC\u30B3\u30FC\u30C9' },\n      recurrence_and_effort: { label: '\u7E70\u308A\u8FD4\u3057\u3068\u5DE5\u6570' },\n    },\n  },\n  crm_event: {\n    _validations: {\n      end_after_start: {\n        message: '\u7D42\u4E86\u6642\u523B\u306F\u958B\u59CB\u6642\u523B\u3088\u308A\u5F8C\u3067\u3042\u308B\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059',\n      },\n      related_to_required: {\n        message: '\u95A2\u9023\u30EC\u30B3\u30FC\u30C9\u3092\u5C11\u306A\u304F\u3068\u3082 1 \u4EF6\u9078\u629E\u3057\u3066\u304F\u3060\u3055\u3044',\n      },\n    },\n    label: '\u30A4\u30D9\u30F3\u30C8',\n    pluralLabel: '\u30A4\u30D9\u30F3\u30C8',\n    description: '\u9867\u5BA2\u3068\u306E\u4F1A\u8B70\u30FB\u96FB\u8A71\u306A\u3069\u306E\u4E88\u5B9A\u3055\u308C\u305F\u5BFE\u8A71',\n    fields: {\n      subject: { label: '\u4EF6\u540D' },\n      description: { label: '\u8AAC\u660E' },\n      type: {\n        label: '\u30A4\u30D9\u30F3\u30C8\u7A2E\u5225',\n        options: {\n          meeting: '\u4F1A\u8B70', call: '\u96FB\u8A71', demo: '\u30C7\u30E2',\n          webinar: '\u30A6\u30A7\u30D3\u30CA\u30FC', onsite_visit: '\u8A2A\u554F', other: '\u305D\u306E\u4ED6',\n        },\n      },\n      status: {\n        label: '\u30B9\u30C6\u30FC\u30BF\u30B9',\n        options: {\n          planned: '\u4E88\u5B9A', held: '\u5B9F\u65BD\u6E08\u307F', cancelled: '\u30AD\u30E3\u30F3\u30BB\u30EB', no_show: '\u7121\u65AD\u6B20\u5E2D',\n        },\n      },\n      owner_id: { label: '\u62C5\u5F53\u8005' },\n      start_datetime: { label: '\u958B\u59CB' },\n      end_datetime: { label: '\u7D42\u4E86' },\n      all_day: { label: '\u7D42\u65E5\u30A4\u30D9\u30F3\u30C8' },\n      duration_minutes: { label: '\u6240\u8981\u6642\u9593\uFF08\u5206\uFF09' },\n      location: { label: '\u5834\u6240', help: '\u4F1A\u8B70\u5BA4\u30FB\u4F4F\u6240\u30FB\u4F1A\u8B70\u30EA\u30F3\u30AF' },\n      related_to_type: {\n        label: '\u95A2\u9023\u30EC\u30B3\u30FC\u30C9\u7A2E\u5225',\n        options: { ...relatedToTypeOptions },\n      },\n      related_to_account: { label: '\u95A2\u9023\u53D6\u5F15\u5148' },\n      related_to_contact: { label: '\u95A2\u9023\u53D6\u5F15\u5148\u8CAC\u4EFB\u8005' },\n      related_to_opportunity: { label: '\u95A2\u9023\u5546\u8AC7' },\n      related_to_lead: { label: '\u95A2\u9023\u30EA\u30FC\u30C9' },\n      related_to_case: { label: '\u95A2\u9023\u30B1\u30FC\u30B9' },\n      outcome_notes: { label: '\u7D50\u679C\u30E1\u30E2', help: '\u5408\u610F\u4E8B\u9805\u3068\u6B21\u306E\u30A2\u30AF\u30B7\u30E7\u30F3' },\n    },\n    _views: {\n      all_events: { label: '\u3059\u3079\u3066\u306E\u30A4\u30D9\u30F3\u30C8' },\n      event_calendar: { label: '\u30A4\u30D9\u30F3\u30C8\u30AB\u30EC\u30F3\u30C0\u30FC' },\n      event_timeline: { label: '\u30C1\u30FC\u30E0\u30B9\u30B1\u30B8\u30E5\u30FC\u30EB' },\n      my_events: { label: '\u30DE\u30A4\u30AB\u30EC\u30F3\u30C0\u30FC' },\n      upcoming_events: { label: '\uD83D\uDCC5 \u958B\u50AC\u4E88\u5B9A \u00B7 \u76F4\u8FD1\u9806' },\n      held_events: { label: '\u2705 \u5BFE\u8A71\u5C65\u6B74' },\n    },\n    _sections: {\n      basic: { label: '\u30A4\u30D9\u30F3\u30C8\u60C5\u5831' },\n      schedule: { label: '\u30B9\u30B1\u30B8\u30E5\u30FC\u30EB' },\n      related: { label: '\u95A2\u9023\u30EC\u30B3\u30FC\u30C9' },\n      outcome: { label: '\u5B9F\u65BD\u7D50\u679C' },\n      // event.view.ts \u306E\u30D5\u30A9\u30FC\u30E0\u30BB\u30AF\u30B7\u30E7\u30F3\u540D (#1100)\n      event: { label: '\u30A4\u30D9\u30F3\u30C8' },\n      related_records: { label: '\u95A2\u9023\u30EC\u30B3\u30FC\u30C9' },\n    },\n  },\n  crm_event_attendee: {\n    _validations: {\n      attendee_resolves: {\n        message: '\u53C2\u52A0\u8005\u306F\u53C2\u52A0\u8005\u7A2E\u5225\u304C\u793A\u3059\u76F8\u624B\u3092\u6307\u5B9A\u3059\u308B\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059\u3002\u53D6\u5F15\u5148\u8CAC\u4EFB\u8005\u306E\u5834\u5408\u306F\u53D6\u5F15\u5148\u8CAC\u4EFB\u8005\u3092\u3001\u793E\u5916\u306E\u5834\u5408\u306F\u793E\u5916\u53C2\u52A0\u8005\u540D\u3092\u5165\u529B\u3057\u3066\u304F\u3060\u3055\u3044',\n      },\n      attendee_type_exclusive: {\n        message: '\u53C2\u52A0\u8005\u304C\u6307\u5B9A\u3067\u304D\u308B\u76F8\u624B\u306F 1 \u3064\u3060\u3051\u3067\u3059\u3002\u53C2\u52A0\u8005\u7A2E\u5225\u304C\u793A\u3055\u306A\u3044\u9805\u76EE\u306F\u3059\u3079\u3066\u7A7A\u306B\u3057\u3066\u304F\u3060\u3055\u3044',\n      },\n    },\n    label: '\u30A4\u30D9\u30F3\u30C8\u53C2\u52A0\u8005',\n    pluralLabel: '\u30A4\u30D9\u30F3\u30C8\u53C2\u52A0\u8005',\n    description: '\u30A4\u30D9\u30F3\u30C8\u306B\u62DB\u5F85\u3055\u308C\u305F\u3001\u307E\u305F\u306F\u51FA\u5E2D\u3057\u305F\u4EBA',\n    fields: {\n      attendee_number: { label: '\u53C2\u52A0\u8005\u756A\u53F7' },\n      crm_event: { label: '\u30A4\u30D9\u30F3\u30C8' },\n      attendee_type: {\n        label: '\u53C2\u52A0\u8005\u7A2E\u5225',\n        options: { contact: '\u53D6\u5F15\u5148\u8CAC\u4EFB\u8005', lead: '\u30EA\u30FC\u30C9', user: '\u793E\u5185\u30E6\u30FC\u30B6\u30FC', external: '\u793E\u5916\u30B2\u30B9\u30C8' },\n      },\n      crm_contact: { label: '\u53D6\u5F15\u5148\u8CAC\u4EFB\u8005', help: '\u53C2\u52A0\u8005\u304C\u65E2\u5B58\u306E\u53D6\u5F15\u5148\u8CAC\u4EFB\u8005\u3067\u3042\u308B\u5834\u5408\u306B\u8A2D\u5B9A\u3057\u307E\u3059' },\n      crm_lead: { label: '\u30EA\u30FC\u30C9', help: '\u53C2\u52A0\u8005\u304C\u307E\u3060\u5909\u63DB\u3055\u308C\u3066\u3044\u306A\u3044\u30EA\u30FC\u30C9\u3067\u3042\u308B\u5834\u5408\u306B\u8A2D\u5B9A\u3057\u307E\u3059' },\n      sys_user: { label: '\u793E\u5185\u30E6\u30FC\u30B6\u30FC', help: '\u53C2\u52A0\u8005\u304C\u793E\u5185\u306E\u540C\u50DA\u3067\u3042\u308B\u5834\u5408\u306B\u8A2D\u5B9A\u3057\u307E\u3059' },\n      external_name: { label: '\u793E\u5916\u53C2\u52A0\u8005', help: 'CRM \u306E\u3069\u306E\u30AA\u30D6\u30B8\u30A7\u30AF\u30C8\u306B\u3082\u5B58\u5728\u3057\u306A\u3044\u53C2\u52A0\u8005\u306E\u6C0F\u540D \u2014 \u53C2\u52A0\u8005\u7A2E\u5225\u304C\u300C\u793E\u5916\u30B2\u30B9\u30C8\u300D\u306E\u3068\u304D\u306B\u8A2D\u5B9A\u3057\u307E\u3059' },\n      response: {\n        label: '\u56DE\u7B54',\n        options: {\n          no_response: '\u672A\u56DE\u7B54', accepted: '\u627F\u8AFE',\n          declined: '\u8F9E\u9000', tentative: '\u4EEE\u627F\u8AFE',\n        },\n      },\n      is_organizer: { label: '\u4E3B\u50AC\u8005' },\n      invited_date: { label: '\u62DB\u5F85\u65E5\u6642' },\n    },\n    _views: {\n      all_event_attendees: { label: '\u30A4\u30D9\u30F3\u30C8\u53C2\u52A0\u8005' },\n    },\n    _sections: {\n      basic: { label: '\u53C2\u52A0\u8005' },\n      response: { label: '\u62DB\u5F85' },\n      // event_attendee.view.ts \u306E\u30D5\u30A9\u30FC\u30E0\u30BB\u30AF\u30B7\u30E7\u30F3\u540D (#1100)\n      attendee: { label: '\u53C2\u52A0\u8005' },\n      invitation: { label: '\u62DB\u5F85' },\n    },\n  },\n};\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/sales/translations/ja-JP/objects.marketing.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/sales/translations/ja-JP\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/sales/translations/ja-JP/objects.marketing.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport type { ObjectTranslationData } from '@objectstack/spec/system';\n\n/**\n * \u65E5\u672C\u8A9E (ja-JP) \u2014 `objects` translations for the MARKETING family:\n * demand generation \u2014 campaigns and their membership.\n *\n * Roster: `crm_campaign`, `crm_campaign_member`.\n *\n * SPLIT AXIS (#1311): translation NAMESPACE first, then CRM DOMAIN FAMILY.\n * Everything that is not `objects` lives in `./app.ts`; `objects` \u2014 69-78% of\n * every bundle \u2014 is one file per CRM domain family, and a detail object\n * follows its master. A new row goes in the file for ITS family, never in\n * whichever file is already open: that is how one file re-grows past the 70%\n * advisory band `pnpm hygiene` prints. Full rule and rationale:\n * `src/sales/translations/ja-JP.ts`.\n */\nexport const marketing: Record<string, ObjectTranslationData> = {\n  crm_campaign: {\n    _validations: {\n      end_after_start: {\n        message: '\u7D42\u4E86\u65E5\u306F\u958B\u59CB\u65E5\u3088\u308A\u5F8C\u3067\u3042\u308B\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059',\n      },\n      actual_cost_within_budget: {\n        message: '\u5B9F\u7E3E\u30B3\u30B9\u30C8\u304C\u4E88\u7B97\u30B3\u30B9\u30C8\u3092\u8D85\u3048\u3066\u3044\u307E\u3059',\n      },\n    },\n    label: '\u30AD\u30E3\u30F3\u30DA\u30FC\u30F3',\n    pluralLabel: '\u30AD\u30E3\u30F3\u30DA\u30FC\u30F3',\n    description: '\u30DE\u30FC\u30B1\u30C6\u30A3\u30F3\u30B0\u30AD\u30E3\u30F3\u30DA\u30FC\u30F3\u3068\u65BD\u7B56',\n    fields: {\n      campaign_code: { label: '\u30AD\u30E3\u30F3\u30DA\u30FC\u30F3\u30B3\u30FC\u30C9' },\n      name: { label: '\u30AD\u30E3\u30F3\u30DA\u30FC\u30F3\u540D' },\n      display_title: { label: '\u8868\u793A\u540D' },\n      description: { label: '\u8AAC\u660E' },\n      type: {\n        label: '\u30AD\u30E3\u30F3\u30DA\u30FC\u30F3\u7A2E\u5225',\n        options: {\n          email: '\u30E1\u30FC\u30EB', webinar: '\u30A6\u30A7\u30D3\u30CA\u30FC', trade_show: '\u5C55\u793A\u4F1A',\n          conference: '\u30AB\u30F3\u30D5\u30A1\u30EC\u30F3\u30B9', direct_mail: '\u30C0\u30A4\u30EC\u30AF\u30C8\u30E1\u30FC\u30EB',\n          social_media: '\u30BD\u30FC\u30B7\u30E3\u30EB\u30E1\u30C7\u30A3\u30A2', content: '\u30B3\u30F3\u30C6\u30F3\u30C4\u30DE\u30FC\u30B1\u30C6\u30A3\u30F3\u30B0',\n          partner: '\u30D1\u30FC\u30C8\u30CA\u30FC\u30DE\u30FC\u30B1\u30C6\u30A3\u30F3\u30B0',\n        },\n      },\n      channel: {\n        label: '\u4E3B\u8981\u30C1\u30E3\u30CD\u30EB',\n        options: {\n          digital: '\u30C7\u30B8\u30BF\u30EB', social: '\u30BD\u30FC\u30B7\u30E3\u30EB', email: '\u30E1\u30FC\u30EB',\n          events: '\u30A4\u30D9\u30F3\u30C8', partner: '\u30D1\u30FC\u30C8\u30CA\u30FC',\n        },\n      },\n      status: {\n        label: '\u30B9\u30C6\u30FC\u30BF\u30B9',\n        options: {\n          planning: '\u8A08\u753B\u4E2D', in_progress: '\u5B9F\u65BD\u4E2D',\n          completed: '\u5B8C\u4E86', aborted: '\u4E2D\u6B62',\n        },\n      },\n      start_date: { label: '\u958B\u59CB\u65E5' },\n      end_date: { label: '\u7D42\u4E86\u65E5' },\n      budgeted_cost: { label: '\u4E88\u7B97\u30B3\u30B9\u30C8' },\n      actual_cost: { label: '\u5B9F\u30B3\u30B9\u30C8' },\n      expected_revenue: { label: '\u4E88\u6E2C\u58F2\u4E0A' },\n      actual_revenue: { label: '\u5B9F\u53CE\u76CA' },\n      target_size: { label: '\u30BF\u30FC\u30B2\u30C3\u30C8\u898F\u6A21', help: '\u5BFE\u8C61\u3068\u3059\u308B\u30EA\u30FC\u30C9\u30FB\u53D6\u5F15\u5148\u8CAC\u4EFB\u8005\u306E\u76EE\u6A19\u4EF6\u6570' },\n      num_sent: { label: '\u9001\u4FE1\u6570' },\n      num_responses: { label: '\u5FDC\u7B54\u6570' },\n      num_leads: { label: '\u30EA\u30FC\u30C9\u6570' },\n      num_converted_leads: { label: '\u5909\u63DB\u6E08\u30EA\u30FC\u30C9\u6570' },\n      num_opportunities: { label: '\u4F5C\u6210\u6E08\u5546\u8AC7\u6570' },\n      num_won_opportunities: { label: '\u53D7\u6CE8\u5546\u8AC7' },\n      response_rate: { label: '\u5FDC\u7B54\u7387\uFF08%\uFF09' },\n      roi: { label: 'ROI\uFF08%\uFF09' },\n      owner_id: { label: '\u30AD\u30E3\u30F3\u30DA\u30FC\u30F3\u62C5\u5F53\u8005' },\n      landing_page_url: { label: '\u30E9\u30F3\u30C7\u30A3\u30F3\u30B0\u30DA\u30FC\u30B8' },\n      is_active: { label: '\u6709\u52B9' },\n    },\n    _views: {\n      all_campaigns: { label: '\u5168\u30AD\u30E3\u30F3\u30DA\u30FC\u30F3' },\n      campaign_gantt: { label: '\u30AD\u30E3\u30F3\u30DA\u30FC\u30F3\u65E5\u7A0B' },\n      campaign_calendar: { label: '\u30AD\u30E3\u30F3\u30DA\u30FC\u30F3\u30AB\u30EC\u30F3\u30C0\u30FC' },\n      campaign_timeline: { label: '\u30DE\u30FC\u30B1\u30C6\u30A3\u30F3\u30B0\u30BF\u30A4\u30E0\u30E9\u30A4\u30F3' },\n    },\n    _sections: {\n      basic: { label: '\u30AD\u30E3\u30F3\u30DA\u30FC\u30F3\u60C5\u5831' },\n      schedule: { label: '\u30B9\u30B1\u30B8\u30E5\u30FC\u30EB' },\n      budget: { label: '\u4E88\u7B97\u30FBROI' },\n      metrics: { label: '\u5B9F\u7E3E' },\n      assignment: { label: '\u62C5\u5F53\u8005' },\n      assets: { label: '\u30AD\u30E3\u30F3\u30DA\u30FC\u30F3\u30A2\u30BB\u30C3\u30C8' },\n    },\n    _actions: {\n      enroll_leads: {\n        label: '\u30E1\u30F3\u30D0\u30FC\u3092\u4E00\u62EC\u767B\u9332',\n        successMessage: '\u5BFE\u8C61\u30E1\u30F3\u30D0\u30FC\u3092\u30AD\u30E3\u30F3\u30DA\u30FC\u30F3\u306B\u767B\u9332\u3057\u307E\u3057\u305F\u3002',\n      },\n    },\n  },\n  crm_campaign_member: {\n    _validations: {\n      lead_or_contact_required: {\n        message: '\u30AD\u30E3\u30F3\u30DA\u30FC\u30F3\u30E1\u30F3\u30D0\u30FC\u306F\u30EA\u30FC\u30C9\u307E\u305F\u306F\u53D6\u5F15\u5148\u8CAC\u4EFB\u8005\u306E\u3044\u305A\u308C\u304B\u3092\u53C2\u7167\u3059\u308B\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059',\n      },\n    },\n    label: '\u30AD\u30E3\u30F3\u30DA\u30FC\u30F3\u30E1\u30F3\u30D0\u30FC',\n    pluralLabel: '\u30AD\u30E3\u30F3\u30DA\u30FC\u30F3\u30E1\u30F3\u30D0\u30FC',\n    description: '\u30AD\u30E3\u30F3\u30DA\u30FC\u30F3\u306E\u5BFE\u8C61\u3068\u306A\u3063\u305F\u30EA\u30FC\u30C9\u30FB\u53D6\u5F15\u5148\u8CAC\u4EFB\u8005\u3068\u305D\u306E\u53CD\u5FDC\u72B6\u6CC1',\n    fields: {\n      member_number: { label: '\u30E1\u30F3\u30D0\u30FC\u756A\u53F7' },\n      crm_campaign: { label: '\u30AD\u30E3\u30F3\u30DA\u30FC\u30F3' },\n      crm_lead: { label: '\u30EA\u30FC\u30C9', help: '\u767B\u9332\u6642\u70B9\u3067\u30EA\u30FC\u30C9\u3060\u3063\u305F\u30E1\u30F3\u30D0\u30FC\u306B\u8A2D\u5B9A\u3055\u308C\u307E\u3059' },\n      crm_contact: { label: '\u53D6\u5F15\u5148\u8CAC\u4EFB\u8005', help: '\u65E2\u5B58\u306E\u53D6\u5F15\u5148\u8CAC\u4EFB\u8005\u3067\u3042\u308B\u30E1\u30F3\u30D0\u30FC\u306B\u8A2D\u5B9A\u3055\u308C\u307E\u3059' },\n      status: {\n        label: '\u30B9\u30C6\u30FC\u30BF\u30B9',\n        options: {\n          sent: '\u9001\u4FE1\u6E08', responded: '\u5FDC\u7B54\u6E08',\n          converted: '\u5909\u63DB\u6E08', unsubscribed: '\u914D\u4FE1\u505C\u6B62',\n        },\n      },\n      added_date: { label: '\u8FFD\u52A0\u65E5\u6642' },\n      response_date: { label: '\u5FDC\u7B54\u65E5\u6642' },\n      has_responded: { label: '\u5FDC\u7B54\u6E08' },\n    },\n    _sections: {\n      basic: { label: '\u57FA\u672C\u60C5\u5831' },\n      response: { label: '\u53CD\u5FDC\u30C8\u30E9\u30C3\u30AD\u30F3\u30B0' },\n    },\n    _actions: {\n      mark_responded: {\n        label: '\u5FDC\u7B54\u6E08\u306B\u3059\u308B',\n        successMessage: '\u3053\u306E\u30AD\u30E3\u30F3\u30DA\u30FC\u30F3\u30E1\u30F3\u30D0\u30FC\u306E\u5FDC\u7B54\u3092\u8A18\u9332\u3057\u307E\u3057\u305F\u3002',\n      },\n    },\n  },\n};\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/sales/translations/ja-JP.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/sales/translations\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/sales/translations/ja-JP.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport type { TranslationData } from '@objectstack/spec/system';\n\nimport { appSurface } from './ja-JP/app';\nimport { customer } from './ja-JP/objects.customer';\nimport { pipeline } from './ja-JP/objects.pipeline';\nimport { commerce } from './ja-JP/objects.commerce';\nimport { service } from './ja-JP/objects.service';\nimport { activity } from './ja-JP/objects.activity';\nimport { marketing } from './ja-JP/objects.marketing';\n\n/**\n * \u65E5\u672C\u8A9E (ja-JP) \u2014 CRM App Translations\n *\n * Per-locale file: one file per language, following the `per_locale` convention.\n *\n * SPLIT AXIS (#1311): translation NAMESPACE first, then CRM DOMAIN FAMILY.\n *\n * This bundle was one file and it had reached 88.6% of the 100KB source cap\n * `pnpm hygiene` enforces, growing ~1.2KB a day. It is now assembled from\n * `./<locale>/`, on an axis measured rather than guessed:\n *\n *   - every namespace that is NOT `objects` \u2014 `apps`, `messages`,\n *     `dashboards`, `datasets`, `pages`, and any namespace `TranslationData`\n *     gains later \u2014 lives in `app.ts`. Measured: those namespaces together\n *     are under a quarter of the bundle, and the schema bounds how many can\n *     ever arrive, so one file holds them with room left;\n *   - `objects` is 69-78% of every bundle, so it is partitioned again, one\n *     file per CRM domain family \u2014 `customer`, `pipeline`, `commerce`,\n *     `service`, `activity`, `marketing` \u2014 and a DETAIL object follows its\n *     master: line items follow their quote or opportunity,\n *     `crm_event_attendee` follows `crm_event`, `crm_campaign_member`\n *     follows `crm_campaign`, `crm_article_feedback` follows\n *     `crm_knowledge_article`.\n *\n * A namespace axis ALONE was measured and rejected: it leaves `objects` at\n * 65.7KB, 3.9KB under the advisory band, which `objects` growth crosses in\n * about nine days. The family axis puts the largest part at 24.2% of the cap.\n *\n * \u26A0\uFE0F A new object translation belongs in the file for ITS family. Do not add\n * it to whichever file is already open \u2014 that is how one file re-grows past\n * the band, which is what split this bundle in the first place.\n *\n * \u26A0\uFE0F A value used by more than one family lives in `<locale>/_shared.ts`. A\n * value used by exactly one family lives in that family's file.\n *\n * \u26A0\uFE0F The key order below is LOAD-BEARING, not cosmetic. `objectstack build`\n * serialises this object into `dist/objectstack.json` in insertion order and\n * never sorts it, so listing the rows here \u2014 rather than spreading the family\n * files \u2014 is what keeps the built artifact byte-identical across the split.\n * The order is this bundle's own historical accretion order and differs\n * between locales; reordering it rewrites the artifact.\n */\nexport const jaJP: TranslationData = {\n  objects: {\n    crm_account: customer.crm_account,\n    crm_contact: customer.crm_contact,\n    crm_knowledge_article: service.crm_knowledge_article,\n    crm_forecast: pipeline.crm_forecast,\n    crm_lead: pipeline.crm_lead,\n    crm_opportunity: pipeline.crm_opportunity,\n    crm_case: service.crm_case,\n    crm_contract: commerce.crm_contract,\n    crm_product: commerce.crm_product,\n    crm_quote: commerce.crm_quote,\n    crm_task: activity.crm_task,\n    crm_campaign: marketing.crm_campaign,\n    crm_event: activity.crm_event,\n    crm_event_attendee: activity.crm_event_attendee,\n    crm_article_feedback: service.crm_article_feedback,\n    crm_campaign_member: marketing.crm_campaign_member,\n    crm_opportunity_line_item: pipeline.crm_opportunity_line_item,\n    crm_quote_line_item: commerce.crm_quote_line_item,\n  },\n  ...appSurface,\n};\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/sales/translations/es-ES/app.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/sales/translations/es-ES\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/sales/translations/es-ES/app.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport type { TranslationData } from '@objectstack/spec/system';\n\nimport { QUOTE_DISCOUNT_CEILING } from '../../objects/_thresholds';\n\n/**\n * Espa\u00F1ol (es-ES) \u2014 every translation namespace EXCEPT `objects`:\n * `apps`, `messages`, `dashboards`, `datasets`, `pages`, `flows`.\n *\n * SPLIT AXIS (#1311): translation NAMESPACE first, then CRM DOMAIN FAMILY.\n * Everything that is not `objects` lives in `./app.ts`; `objects` \u2014 69-78% of\n * every bundle \u2014 is one file per CRM domain family, and a detail object\n * follows its master. A new row goes in the file for ITS family, never in\n * whichever file is already open: that is how one file re-grows past the 70%\n * advisory band `pnpm hygiene` prints. Full rule and rationale:\n * `src/sales/translations/es-ES.ts`.\n *\n * A namespace `TranslationData` gains later lands here too, and the room is\n * measured: this file is the smaller half of the bundle, and the schema bounds\n * how many namespaces can ever arrive.\n */\nexport const appSurface: Omit<TranslationData, 'objects'> = {\n  apps: {\n    crm_enterprise: {\n      label: 'HotCRM',\n      description: 'Gesti\u00F3n de relaciones con clientes para ventas, servicio y marketing',\n      // Indexado por el `id` del nodo de navegaci\u00F3n (espacio de nombres plano,\n      // sea cual sea la profundidad del nodo).\n      navigation: {\n        group_activity: { label: 'Actividad' },\n        nav_event: { label: 'Eventos' },\n        nav_activity_dashboard: { label: 'Actividad de Ventas' },\n        nav_my_calendar: { label: 'Mi Calendario' },\n        nav_home: { label: 'Inicio' },\n\n        group_sales: { label: 'Ventas' },\n        nav_lead: { label: 'Prospectos' },\n        nav_account: { label: 'Cuentas' },\n        nav_account_workbench: { label: 'Mesa de Trabajo de Cuentas' },\n        nav_contact: { label: 'Contactos' },\n        nav_opportunity: { label: 'Oportunidades' },\n        nav_quote: { label: 'Cotizaciones' },\n        nav_contract: { label: 'Contratos' },\n        nav_product: { label: 'Productos' },\n        nav_sales_dashboard: { label: 'Rendimiento de Ventas' },\n\n        group_work: { label: 'Mi Trabajo' },\n        nav_my_tasks: { label: 'Mis Tareas' },\n        nav_my_deals: { label: 'Mis Negocios' },\n        nav_my_leads: { label: 'Mis Prospectos' },\n        nav_my_cases: { label: 'Mis Casos' },\n        nav_approval_requests: { label: 'Bandeja de Entrada' },\n\n        group_service: { label: 'Servicio' },\n        nav_case: { label: 'Casos' },\n        nav_knowledge: { label: 'Conocimiento' },\n        nav_service_dashboard: { label: 'Resumen de Servicio' },\n\n        group_marketing: { label: 'Marketing' },\n        nav_campaign: { label: 'Campa\u00F1as' },\n\n        group_insights: { label: 'An\u00E1lisis' },\n        nav_crm_dashboard: { label: 'Resumen CRM' },\n        nav_forecast: { label: 'Previsiones' },\n        nav_report_pipeline_coverage: { label: 'Cobertura del Pipeline' },\n        nav_report_lead_inflow: { label: 'Entrada de Prospectos' },\n        nav_report_sla: { label: 'Cumplimiento de SLA' },\n      },\n    },\n  },\n  messages: {\n    'common.save': 'Guardar',\n    'common.cancel': 'Cancelar',\n    'common.delete': 'Eliminar',\n    'common.edit': 'Editar',\n    'common.create': 'Crear',\n    'common.search': 'Buscar',\n    'common.filter': 'Filtrar',\n    'common.export': 'Exportar',\n    'common.back': 'Volver',\n    'common.confirm': 'Confirmar',\n    'nav.sales': 'Ventas',\n    'nav.service': 'Servicio',\n    'nav.marketing': 'Marketing',\n    'nav.products': 'Productos',\n    'nav.analytics': 'Anal\u00EDtica',\n    'success.saved': 'Registro guardado exitosamente',\n    'success.converted': 'Prospecto convertido exitosamente',\n    'confirm.delete': '\u00BFEst\u00E1 seguro de que desea eliminar este registro?',\n    'confirm.convert_lead': '\u00BFConvertir este prospecto en cuenta, contacto y oportunidad?',\n    'error.required': 'Este campo es obligatorio',\n    'error.load_failed': 'Error al cargar los datos',\n  },\n  dashboards: {\n    sales_activity_dashboard: {\n      label: 'Actividad de ventas',\n      description: 'Qui\u00E9n habla con los clientes, con qu\u00E9 frecuencia y qu\u00E9 cuentas se han quedado en silencio',\n      widgets: {\n        interactions_held: { title: 'Interacciones registradas', description: 'Llamadas y reuniones que realmente ocurrieron' },\n        meetings_booked: { title: 'Reuniones agendadas', description: 'Reuniones en el calendario que a\u00FAn no ocurren' },\n        customer_minutes: { title: 'Minutos con clientes', description: 'Tiempo total frente a clientes' },\n        tasks_completed: { title: 'Tareas completadas', description: 'Seguimientos cerrados \u2014 la otra mitad de la actividad' },\n        activity_by_rep: { title: 'Actividad por representante', description: 'Interacciones registradas por responsable' },\n        activity_by_week: { title: 'Volumen de actividad por semana', description: 'Interacciones por semana' },\n        activity_mix: { title: 'Composici\u00F3n de la actividad', description: 'Llamadas vs reuniones vs demostraciones' },\n        activity_by_record_type: { title: 'D\u00F3nde cae la actividad', description: 'Qu\u00E9 parte del embudo recibe atenci\u00F3n' },\n        deal_activity: { title: 'Interacciones en oportunidades', description: 'Interacciones vinculadas a una oportunidad' },\n        open_deals_for_activity: { title: 'Oportunidades abiertas', description: 'Oportunidades a\u00FAn en juego' },\n        quiet_accounts_30: { title: 'Silencio 30+ d\u00EDas', description: 'Cuentas activas sin interacci\u00F3n en un mes' },\n        quiet_accounts_60: { title: 'Silencio 60+ d\u00EDas', description: 'Dos meses de silencio \u2014 el umbral de riesgo' },\n        quiet_accounts_90: { title: 'Silencio 90+ d\u00EDas', description: 'Un trimestre sin contacto' },\n      },\n    },\n    crm_overview_dashboard: {\n      label: 'Resumen CRM',\n      description: 'M\u00E9tricas de ingresos, anal\u00EDtica de pipeline e informaci\u00F3n de oportunidades',\n      widgets: {\n        total_revenue: { title: 'Ingresos totales', description: 'Ingresos cerrados ganados en este per\u00EDodo' },\n        active_deals: { title: 'Negocios activos', description: 'Oportunidades abiertas en el pipeline' },\n        won_deals: { title: 'Negocios ganados', description: 'Negocios cerrados ganados en este per\u00EDodo' },\n        avg_deal_size: { title: 'Tama\u00F1o medio del negocio', description: 'Valor medio de los negocios cerrados ganados' },\n        revenue_trends: { title: 'Tendencia de ingresos', description: 'Ingresos cerrados ganados de los \u00FAltimos 12 meses' },\n        lead_source: { title: 'Origen del prospecto', description: 'Valor del pipeline por canal de adquisici\u00F3n' },\n        pipeline_by_stage: { title: 'Pipeline por etapa', description: 'Valor de oportunidades abiertas en cada etapa de venta' },\n        top_products: { title: 'Productos principales', description: 'Ingresos a precio de lista por categor\u00EDa de producto' },\n        pipeline_by_owner: { title: 'Pipeline por responsable', description: 'Valor del pipeline abierto y n\u00FAmero de negocios por comercial' },\n      },\n    },\n    executive_dashboard: {\n      label: 'Vista ejecutiva',\n      description: 'KPI de alto nivel sobre ingresos, clientes y pipeline para la direcci\u00F3n',\n      widgets: {\n        total_revenue_ytd: { title: 'Ingresos totales (YTD)', description: 'Ingresos cerrados ganados en lo que va del a\u00F1o' },\n        total_accounts: { title: 'Cuentas activas', description: 'Clientes con al menos una relaci\u00F3n activa' },\n        total_contacts: { title: 'Total de contactos', description: 'Personas en nuestra agenda' },\n        open_leads: { title: 'Prospectos abiertos', description: 'Prospectos sin convertir en el embudo' },\n        revenue_trend: { title: 'Tendencia de ingresos', description: 'Ingresos cerrados ganados de los \u00FAltimos 12 meses' },\n        revenue_by_industry: { title: 'Ingresos por industria', description: 'Ingresos YTD ganados separados por industria del cliente' },\n        pipeline_by_stage: { title: 'Pipeline por etapa', description: 'Valor de oportunidades abiertas en cada etapa de venta' },\n        new_accounts_by_month: { title: 'Cuentas nuevas', description: 'Ritmo de creaci\u00F3n de cuentas en los \u00FAltimos 6 meses' },\n        accounts_by_industry: { title: 'Cuentas por sector', description: 'Ingreso anual total y n\u00FAmero de cuentas por sector' },\n      },\n    },\n    sales_dashboard: {\n      label: 'Rendimiento de ventas',\n      description: 'Anal\u00EDtica de pipeline, tendencias de tasa de \u00E9xito y rendimiento de los representantes',\n      widgets: {\n        total_pipeline_value: { title: 'Pipeline total', description: 'Suma del valor de las oportunidades abiertas' },\n        closed_won_qtd: { title: 'Cerrado ganado (trimestre)', description: 'Ingresos cerrados este trimestre' },\n        open_opportunities: { title: 'Oportunidades abiertas', description: 'Negocios activos en curso' },\n        avg_deal_size: { title: 'Tama\u00F1o medio del negocio', description: 'Valor medio de los negocios cerrados ganados este trimestre' },\n        pipeline_by_stage: { title: 'Pipeline por etapa', description: 'Valor de oportunidades abiertas en cada etapa de venta' },\n        monthly_revenue_trend: { title: 'Tendencia mensual de ingresos', description: 'Ingresos cerrados ganados de los \u00FAltimos 12 meses' },\n        pipeline_by_forecast_category: { title: 'Pipeline por categor\u00EDa de pron\u00F3stico', description: 'Pipeline abierto agrupado por categor\u00EDa de pron\u00F3stico de ventas' },\n        lead_source_breakdown: { title: 'Origen del prospecto', description: 'De d\u00F3nde proviene nuestro pipeline' },\n        open_pipeline_by_owner: { title: 'Pipeline abierto por responsable', description: 'Valor del pipeline en curso, n\u00FAmero de negocios y probabilidad media de cierre por comercial' },\n        quota_attainment_by_rep: { title: 'Cumplimiento de cuota por representante', description: 'Cuota del trimestre actual, ingresos cerrados y cumplimiento por representante, seg\u00FAn instant\u00E1neas de pron\u00F3stico' },\n        pipeline_stage_by_source: { title: 'Pipeline por Etapa \u00D7 Origen', description: 'Tabla cruzada del importe de oportunidades abiertas por etapa y origen' },\n        win_rate_12m: { title: 'Tasa de \u00E9xito (12M)', description: 'Negocios ganados como porcentaje de todos los negocios resueltos en los \u00FAltimos 12 meses' },\n        won_deals_12m: { title: 'Negocios ganados (12M)', description: 'El numerador de la tasa de \u00E9xito' },\n        lost_deals_12m: { title: 'Negocios perdidos (12M)', description: 'La otra mitad del denominador de la tasa de \u00E9xito' },\n        win_rate_by_owner: { title: 'Ganados / perdidos por representante', description: 'Negocios ganados, negocios perdidos y tasa de \u00E9xito por representante \u2014 \u00FAltimos 12 meses' },\n        win_rate_by_lead_source: { title: 'Ganados / perdidos por origen del prospecto', description: 'Qu\u00E9 or\u00EDgenes producen negocios que realmente se cierran \u2014 \u00FAltimos 12 meses' },\n        loss_reason_breakdown: { title: 'Por qu\u00E9 perdemos', description: 'Negocios perdidos por motivo \u2014 \u00FAltimos 12 meses' },\n      },\n    },\n    service_dashboard: {\n      label: 'Servicio al cliente',\n      description: 'Carga de casos, salud del SLA y rendimiento de resoluci\u00F3n',\n      widgets: {\n        open_cases: { title: 'Casos abiertos', description: 'Casos que a\u00FAn no se han cerrado' },\n        critical_cases: { title: 'Casos cr\u00EDticos', description: 'Casos abiertos marcados como prioridad cr\u00EDtica' },\n        avg_resolution_time: { title: 'Tiempo medio de resoluci\u00F3n', description: 'Tiempo medio hasta el cierre, en horas' },\n        sla_violations: { title: 'Incumplimientos de SLA', description: 'Casos que incumplieron su SLA' },\n        cases_by_status: { title: 'Casos por estado', description: 'Distribuci\u00F3n de la carga a lo largo del pipeline' },\n        cases_by_priority: { title: 'Casos por prioridad', description: 'Mezcla de casos abiertos por urgencia' },\n        cases_by_origin: { title: 'Casos por origen', description: 'De d\u00F3nde provienen nuestros casos' },\n        daily_case_volume: { title: 'Volumen diario de casos', description: 'Casos nuevos creados en los \u00FAltimos 30 d\u00EDas' },\n        sla_compliance_gauge: { title: 'Cumplimiento de SLA', description: 'Porcentaje de casos resueltos dentro del SLA en este per\u00EDodo' },\n        kb_deflection_rate: { title: 'Tasa de Desv\u00EDo por KB', description: 'Proporci\u00F3n de casos cerrados resueltos con un art\u00EDculo de la base de conocimiento' },\n        kb_resolved_cases: { title: 'Resueltos por KB', description: 'Casos cerrados que se\u00F1alan el art\u00EDculo que los resolvi\u00F3' },\n        closed_cases_total: { title: 'Casos Cerrados', description: 'El denominador de la tasa de desv\u00EDo' },\n        top_resolving_articles: { title: 'Art\u00EDculos que M\u00E1s Resuelven', description: 'Art\u00EDculos de la base de conocimiento ordenados por los casos cerrados que resolvieron' },\n        my_open_cases_by_priority: { title: 'Mis casos abiertos por prioridad', description: 'Tus casos abiertos y su tasa de incumplimiento de SLA, desglosados por prioridad' },\n      },\n    },\n  },\n  // `title` / `subtitle` son las propiedades del componente `page:header`.\n  // Los marcadores `{\u2026}` se sustituyen sobre la cadena TRADUCIDA, as\u00ED que el\n  // token debe conservarse tal cual: traducido, no resuelve y se ve vac\u00EDo.\n  datasets: {\n    account_metrics: {\n      label: 'M\u00E9tricas de cuentas',\n      description: 'Capa sem\u00E1ntica para el recuento de cuentas por sector y tipo',\n      dimensions: {\n        industry: {\n          label: 'Sector',\n        },\n        type: {\n          label: 'Tipo',\n        },\n        created_at: {\n          label: 'Creado',\n        },\n      },\n      measures: {\n        account_count: {\n          label: 'Cuentas',\n        },\n        annual_revenue_sum: {\n          label: 'Ingresos anuales',\n        },\n      },\n    },\n    case_metrics: {\n      label: 'M\u00E9tricas de casos',\n      description: 'Capa sem\u00E1ntica para el recuento de casos, el tiempo de resoluci\u00F3n y el SLA',\n      dimensions: {\n        created_at: {\n          label: 'Creado',\n        },\n        origin: {\n          label: 'Origen',\n        },\n        priority: {\n          label: 'Prioridad',\n        },\n        resolved_article: {\n          label: 'Art\u00EDculo de resoluci\u00F3n',\n        },\n        status: {\n          label: 'Estado',\n        },\n        type: {\n          label: 'Tipo',\n        },\n      },\n      measures: {\n        avg_resolution: {\n          label: 'Resoluci\u00F3n media (h)',\n        },\n        avg_sla_violated: {\n          label: 'Tasa de incumplimiento del SLA',\n        },\n        case_count: {\n          label: 'Casos',\n        },\n        closed_count: {\n          label: 'Casos cerrados',\n        },\n        kb_deflection_rate: {\n          label: 'Tasa de desv\u00EDo por base de conocimiento',\n        },\n        kb_resolved_count: {\n          label: 'Resueltos por base de conocimiento',\n        },\n        sla_compliance_rate: {\n          label: 'Tasa de cumplimiento del SLA',\n        },\n        sla_met_count: {\n          label: 'Casos dentro del SLA',\n        },\n      },\n    },\n    contact_metrics: {\n      label: 'M\u00E9tricas de contactos',\n      description: 'Capa sem\u00E1ntica para el recuento de contactos',\n      measures: {\n        contact_count: {\n          label: 'Contactos',\n        },\n      },\n    },\n    event_metrics: {\n      label: 'M\u00E9tricas de actividad',\n      description: 'Capa sem\u00E1ntica para reuniones, llamadas y recencia de interacci\u00F3n',\n      dimensions: {\n        owner: {\n          label: 'Propietario',\n        },\n        related_to_type: {\n          label: 'Relacionado con',\n        },\n        start_datetime: {\n          label: 'Semana de actividad',\n        },\n        status: {\n          label: 'Estado',\n        },\n        type: {\n          label: 'Tipo de actividad',\n        },\n      },\n      measures: {\n        avg_minutes: {\n          label: 'Duraci\u00F3n media',\n        },\n        event_count: {\n          label: 'Actividades',\n        },\n        total_minutes: {\n          label: 'Minutos',\n        },\n      },\n    },\n    forecast_metrics: {\n      label: 'M\u00E9tricas de previsi\u00F3n',\n      description: 'Capa sem\u00E1ntica para cuota, cumplimiento y cobertura de pipeline por propietario',\n      dimensions: {\n        owner: {\n          label: 'Propietario',\n        },\n        period: {\n          label: 'Tipo de periodo',\n        },\n        period_label: {\n          label: 'Periodo',\n        },\n        period_start: {\n          label: 'Inicio del periodo',\n        },\n      },\n      measures: {\n        attainment: {\n          label: 'Cumplimiento',\n        },\n        closed_sum: {\n          label: 'Cerrado',\n        },\n        commit_sum: {\n          label: 'Comprometido',\n        },\n        pipeline_sum: {\n          label: 'Pipeline',\n        },\n        quota_sum: {\n          label: 'Cuota',\n        },\n      },\n    },\n    lead_metrics: {\n      label: 'M\u00E9tricas de prospectos',\n      description: 'Capa sem\u00E1ntica para el recuento de prospectos',\n      dimensions: {\n        created_at: {\n          label: 'Creado',\n        },\n        last_contacted_date: {\n          label: '\u00DAltimo contacto',\n        },\n        lead_source: {\n          label: 'Origen',\n        },\n        status: {\n          label: 'Estado',\n        },\n      },\n      measures: {\n        lead_count: {\n          label: 'Prospectos',\n        },\n      },\n    },\n    opportunity_metrics: {\n      label: 'M\u00E9tricas de oportunidades',\n      description: 'Capa sem\u00E1ntica para el recuento y los importes del pipeline de ventas',\n      dimensions: {\n        account_industry: {\n          label: 'Sector de la cuenta',\n        },\n        close_date: {\n          label: 'Fecha de cierre',\n        },\n        close_quarter: {\n          label: 'Trimestre de cierre',\n        },\n        forecast_category: {\n          label: 'Categor\u00EDa de previsi\u00F3n',\n        },\n        lead_source: {\n          label: 'Origen del prospecto',\n        },\n        loss_reason: {\n          label: 'Motivo de p\u00E9rdida',\n        },\n        owner: {\n          label: 'Propietario',\n        },\n        stage: {\n          label: 'Etapa',\n        },\n        type: {\n          label: 'Tipo de negocio',\n        },\n        win_reason: {\n          label: 'Motivo de ganancia',\n        },\n      },\n      measures: {\n        avg_amount: {\n          label: 'Tama\u00F1o medio del negocio',\n        },\n        avg_probability: {\n          label: 'Probabilidad media',\n        },\n        decided_count: {\n          label: 'Negocios resueltos',\n        },\n        lost_amount: {\n          label: 'Ingresos perdidos',\n        },\n        lost_count: {\n          label: 'Negocios perdidos',\n        },\n        opp_count: {\n          label: 'Oportunidades',\n        },\n        total_amount: {\n          label: 'Importe total',\n        },\n        win_rate: {\n          label: 'Tasa de ganancia',\n        },\n        won_amount: {\n          label: 'Ingresos ganados',\n        },\n        won_count: {\n          label: 'Negocios ganados',\n        },\n      },\n    },\n    product_metrics: {\n      label: 'M\u00E9tricas de productos',\n      description: 'Capa sem\u00E1ntica para el recuento del cat\u00E1logo y el precio de lista',\n      dimensions: {\n        category: {\n          label: 'Categor\u00EDa',\n        },\n      },\n      measures: {\n        list_price_sum: {\n          label: 'Precio de lista total',\n        },\n        product_count: {\n          label: 'Productos',\n        },\n      },\n    },\n    task_metrics: {\n      label: 'M\u00E9tricas de tareas',\n      description: 'Capa sem\u00E1ntica para la carga de trabajo y la finalizaci\u00F3n de tareas',\n      dimensions: {\n        due_date: {\n          label: 'Fecha de vencimiento',\n        },\n        is_completed: {\n          label: 'Completada',\n        },\n        is_overdue: {\n          label: 'Vencida',\n        },\n        priority: {\n          label: 'Prioridad',\n        },\n        priority_rank: {\n          label: 'Urgencia',\n        },\n        status: {\n          label: 'Estado',\n        },\n        type: {\n          label: 'Tipo',\n        },\n      },\n      measures: {\n        avg_progress: {\n          label: 'Progreso medio',\n        },\n        task_count: {\n          label: 'Tareas',\n        },\n      },\n    },\n  },\n  pages: {\n    account_detail_page: {\n      label: 'Detalle de Cuenta',\n      description: 'P\u00E1gina de registro de cuenta por slots: cabecera personalizada + feed de discusi\u00F3n permanente.',\n      title: '{name}',\n      subtitle: '{industry} \u00B7 {type}',\n      components: {\n        account_chatter: { label: 'Discusi\u00F3n' },\n      },\n    },\n    account_workbench: {\n      label: 'Mesa de Trabajo de Cuentas',\n      description: 'Lista de cuentas curada para el equipo comercial: solo filtros r\u00E1pidos, sin gesti\u00F3n de vistas.',\n    },\n    app_launcher_page: {\n      label: 'Lanzador de Aplicaciones',\n      description: 'Punto de acceso central a todas las aplicaciones',\n      subtitle: 'Seleccione una aplicaci\u00F3n para empezar',\n      components: {\n        app_search: { label: 'Buscar Aplicaciones' },\n        app_grid: { label: 'Cuadr\u00EDcula de Aplicaciones' },\n      },\n    },\n    case_detail_page: {\n      label: 'Detalle de Caso',\n      description: 'P\u00E1gina de caso para el agente de servicio: datos destacados, progreso del SLA, detalles y cronolog\u00EDa de actividad.',\n      title: '{case_number} \u00B7 {subject}',\n      subtitle: '{crm_account}',\n      components: {\n        case_highlights: { label: 'Informaci\u00F3n Clave' },\n        case_status_path: { label: 'Progreso del Estado del Caso' },\n        case_details: { label: 'Detalles del Caso' },\n      },\n    },\n    lead_detail_page: {\n      label: 'Detalle de Prospecto',\n      description: 'P\u00E1gina completa de detalle del prospecto, con datos destacados, detalles e informaci\u00F3n relacionada',\n      title: '{first_name} {last_name}',\n      subtitle: '{company}',\n      components: {\n        lead_duplicate_alert_confirmed: { label: 'Aviso de duplicado confirmado' },\n        lead_duplicate_alert_suspected: { label: 'Aviso de duplicado sospechoso' },\n        lead_highlights: { label: 'Informaci\u00F3n Clave' },\n        lead_path: { label: 'Progreso del Estado del Prospecto' },\n        main_tabs: { label: 'Pesta\u00F1as de Informaci\u00F3n del Prospecto' },\n        lead_details: { label: 'Detalles del Prospecto' },\n        related_accordion: { label: 'Registros Relacionados' },\n        related_tasks: { title: 'Tareas Abiertas', label: 'Tareas' },\n        lead_activity: { label: 'Cronolog\u00EDa de Actividad' },\n        lead_history: { label: 'Historial de Campos' },\n      },\n    },\n    opportunity_detail_page: {\n      label: 'Detalle de Oportunidad',\n      description: 'P\u00E1gina completa de detalle de la oportunidad, con recorrido de etapas, datos destacados, detalles y listas relacionadas',\n      title: '{name}',\n      subtitle: '{crm_account}',\n      components: {\n        opp_highlights: { label: 'Informaci\u00F3n Clave' },\n        opp_stage_path: { label: 'Progreso de Etapa de la Oportunidad' },\n        opp_details: { label: 'Detalles de la Oportunidad' },\n      },\n    },\n    sales_home_page: {\n      label: 'Inicio de Ventas',\n      description: 'P\u00E1gina de inicio del equipo comercial con m\u00E9tricas clave y acciones r\u00E1pidas',\n      title: 'Panel de Ventas',\n      subtitle: 'Bienvenido de nuevo',\n      components: {\n        kpi_revenue_won: {\n          label: 'Ingresos (ganados)',\n        },\n        kpi_deals_won: {\n          label: 'Negocios ganados',\n        },\n        kpi_pipeline_value: {\n          label: 'Valor del pipeline',\n        },\n        kpi_open_leads: {\n          label: 'Prospectos abiertos',\n        },\n        home_upcoming_events: {\n          label: '\uD83D\uDCC5 Pr\u00F3ximos \u00B7 M\u00E1s cercanos primero',\n        },\n        quick_create: { title: 'Creaci\u00F3n R\u00E1pida', label: 'Creaci\u00F3n R\u00E1pida' },\n        key_metrics: { title: 'Indicadores Clave de Rendimiento', label: 'M\u00E9tricas Clave' },\n        home_tabs: { label: 'Pesta\u00F1as de Inicio' },\n        home_my_leads: { label: 'Mis Prospectos' },\n        home_my_deals: { label: 'Mis Negocios Abiertos' },\n        home_my_tasks: { label: 'Mis Tareas Abiertas' },\n        ai_briefing: {\n          title: 'Preg\u00FAntale al Asistente de IA',\n          label: 'Hoy con el Asistente de IA',\n        },\n        upcoming_events: { title: 'Pr\u00F3ximos Eventos', label: 'Pr\u00F3ximos Eventos' },\n      },\n    },\n    utility_bar_page: {\n      label: 'Barra de Utilidades',\n      description: 'Barra de acceso r\u00E1pido con herramientas flotantes',\n      components: {\n        notifications_panel: { label: 'Notificaciones' },\n        quick_notes: { title: 'Notas R\u00E1pidas', label: 'Notas R\u00E1pidas' },\n        quick_search: { label: 'B\u00FAsqueda R\u00E1pida' },\n      },\n    },\n  },\n  // Screen-flow copy (#1210, #1975). Keyed `flows.<flow>.label`,\n  // `screens.<node>.title` and `screens.<node>.fields.<field>.{label,placeholder}`\n  // \u2014 the keys `os lint`'s `i18n/missing-flow` names, read by the console's\n  // flow runner since @objectstack 17.7.0 (the spec's `flows` liveness row is\n  // `live` there). A screen with no authored `title` shows its flow's label in\n  // every locale, so each `screen_1.title` repeats the flow label. Since\n  // 18.0.0-next.0 three more surfaces are keys the engine reads in the run's\n  // locale, and `i18n/missing-flow` names each missing one: a select field's\n  // `options.<value>` (worded as the object field's own option in this pack),\n  // an authored screen `description`, and a refusing `end` node's\n  // `refusals.<node>.message`. A translated description or message is a text\n  // slot like the one it translates, so a hole in it is `{{ }}`.\n  // The discount ceiling is interpolated from `QUOTE_DISCOUNT_CEILING`, never\n  // retyped: the number lives in `_thresholds.ts` alone (#1711).\n  flows: {\n    campaign_enrollment: {\n      label: 'Inscribir miembros en la campa\u00F1a',\n      screens: {\n        screen_1: {\n          title: 'Inscribir miembros en la campa\u00F1a',\n          fields: {\n            memberSource: { label: 'Tipo de miembro a inscribir', options: { leads: 'Prospectos', contacts: 'Contactos' } },\n            leadStatus: { label: 'Inscribir prospectos con estado', options: { new: 'Nuevo', contacted: 'Contactado', qualified: 'Calificado' } },\n            contactDepartment: {\n              label: 'Inscribir contactos del departamento',\n              options: { executive: 'Ejecutivo', sales: 'Ventas', marketing: 'Marketing', engineering: 'Ingenier\u00EDa', support: 'Soporte', finance: 'Finanzas', hr: 'Recursos Humanos', operations: 'Operaciones' },\n            },\n          },\n        },\n      },\n    },\n    escalate_case: {\n      label: 'Escalar Caso',\n      screens: { screen_1: { title: 'Escalar Caso', fields: { reason: { label: 'Motivo de Escalaci\u00F3n' } } } },\n    },\n    close_case: {\n      label: 'Cerrar Caso',\n      screens: {\n        screen_1: {\n          title: 'Cerrar Caso',\n          fields: {\n            resolution: { label: 'Resoluci\u00F3n' },\n            resolved_by_article: { label: 'Resuelto con art\u00EDculo (opcional)' },\n          },\n        },\n      },\n    },\n    claim_case: {\n      label: 'Tomar Caso',\n      screens: {\n        screen_1: {\n          title: 'Tomar Caso',\n          fields: {\n            claimStatus: {\n              label: 'Estado de trabajo',\n              options: { in_progress: 'En Curso', waiting_customer: 'Esperando al Cliente', waiting_support: 'Esperando a Soporte' },\n            },\n          },\n        },\n      },\n    },\n    lead_conversion: {\n      label: 'Proceso de conversi\u00F3n de prospecto',\n      screens: {\n        screen_1: {\n          title: 'Proceso de conversi\u00F3n de prospecto',\n          // The duplicate warning's text is a variable the flow assigns; this\n          // key can only carry the hole that shows it.\n          description: '{{duplicateWarning}}',\n          fields: {\n            createOpportunity: { label: '\u00BFCrear oportunidad?' },\n            opportunityName: { label: 'Nombre de Oportunidad' },\n            opportunityAmount: { label: 'Monto de la Oportunidad' },\n            closeDate: { label: 'Fecha de Cierre' },\n          },\n        },\n        refuse_confirmed_duplicate: {\n          title: 'Conversi\u00F3n rechazada',\n          description:\n            'El Estado del Duplicado de este prospecto es Confirmado: un revisor lo compar\u00F3 con un registro existente y registr\u00F3 que lo repite. Convertirlo crear\u00EDa una segunda cuenta, contacto y oportunidad para el mismo comprador. La secci\u00F3n Gesti\u00F3n de Duplicados de este prospecto indica el registro que se conserva; descalifique este prospecto como duplicado. Solo un revisor que cambie ese veredicto vuelve a habilitar la conversi\u00F3n.',\n        },\n        refuse_unapproved: {\n          title: 'Conversi\u00F3n rechazada',\n          description:\n            'Este prospecto no ha sido aprobado para la conversi\u00F3n. Un aprobador debe darle el visto bueno antes de que pueda convertirse en una cuenta, un contacto y una oportunidad; el campo Aprobaci\u00F3n de Conversi\u00F3n del prospecto muestra si la decisi\u00F3n sigue pendiente o fue rechazada. Mientras tanto, siga trabajando el prospecto: nada de \u00E9l queda bloqueado.',\n        },\n        refuse_no_match_key: {\n          title: 'Conversi\u00F3n rechazada',\n          description:\n            'La empresa de este prospecto no tiene clave de coincidencia, as\u00ED que la conversi\u00F3n no puede saber a qu\u00E9 cuenta pertenece y no lo va a adivinar: una suposici\u00F3n podr\u00EDa archivar el contacto y la oportunidad bajo otro cliente. Guardar la Empresa del prospecto reconstruye la clave, as\u00ED que gu\u00E1rdela de nuevo y luego convi\u00E9rtalo. No se ha creado nada.',\n        },\n      },\n    },\n    schedule_followup: {\n      label: 'Programar Seguimiento',\n      screens: {\n        screen_1: {\n          title: 'Programar Seguimiento',\n          fields: {\n            subject: { label: '\u00BFCu\u00E1l es el siguiente paso?' },\n            dueDate: { label: 'Fecha L\u00EDmite' },\n            activityType: {\n              label: 'Tipo de Actividad',\n              options: { call: 'Llamada', email: 'Email', meeting: 'Reuni\u00F3n', follow_up: 'Seguimiento', demo: 'Demostraci\u00F3n', other: 'Otro' },\n            },\n            priority: { label: 'Prioridad', options: { low: 'Baja', normal: 'Normal', high: 'Alta', urgent: 'Urgente' } },\n            notes: { label: 'Notas' },\n          },\n        },\n      },\n    },\n    quote_generation: {\n      label: 'Generar cotizaci\u00F3n desde la oportunidad',\n      refusals: { refuse_held: { message: 'Primero va la aprobaci\u00F3n de calificaci\u00F3n: marque Solicitar Aprobaci\u00F3n de Calificaci\u00F3n. No se cre\u00F3 nada.' } },\n      screens: {\n        screen_1: {\n          title: 'Generar cotizaci\u00F3n desde la oportunidad',\n          fields: {\n            quoteName: { label: 'Nombre de Cotizaci\u00F3n' },\n            expirationDays: { label: 'V\u00E1lida por (d\u00EDas)' },\n            discount: { label: `Descuento % (\u2264 ${QUOTE_DISCOUNT_CEILING})`, placeholder: `0-${QUOTE_DISCOUNT_CEILING}` },\n          },\n        },\n      },\n    },\n  },\n};\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/sales/translations/es-ES/_shared.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/sales/translations/es-ES\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/sales/translations/es-ES/_shared.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\n/**\n * Espa\u00F1ol (es-ES) \u2014 values shared by more than one part of this bundle.\n *\n * SPLIT AXIS (#1311): translation NAMESPACE first, then CRM DOMAIN FAMILY.\n * Everything that is not `objects` lives in `./app.ts`; `objects` \u2014 69-78% of\n * every bundle \u2014 is one file per CRM domain family, and a detail object\n * follows its master. A new row goes in the file for ITS family, never in\n * whichever file is already open: that is how one file re-grows past the 70%\n * advisory band `pnpm hygiene` prints. Full rule and rationale:\n * `src/sales/translations/es-ES.ts`.\n *\n * Every constant here is spread into object rows that live in MORE THAN ONE\n * family file, so it cannot sit in any one of them. A value used by exactly\n * one family lives in that family's file instead \u2014 that split is mechanical,\n * not a judgement call.\n */\n\n/**\n * Familia de acciones de actividad (#592): `log_call`, `log_meeting` y\n * `schedule_meeting` se registran una vez POR OBJETO (prospecto, contacto,\n * cuenta, oportunidad, caso), porque una acci\u00F3n de script sin `objectName`\n * queda bajo una clave que el despachador nunca consulta (#509). Los textos son\n * id\u00E9nticos en los cinco, as\u00ED que se declaran una vez aqu\u00ED.\n */\nexport const activityActions = {\n  log_call: {\n    label: 'Registrar llamada',\n    successMessage: '\u00A1Llamada registrada exitosamente!',\n    params: {\n      subject: { label: 'Asunto de la llamada' },\n      duration: { label: 'Duraci\u00F3n (minutos)' },\n      attendee_contacts: { label: 'Contactos participantes' },\n      attendee_users: { label: 'Participantes internos' },\n      notes: { label: 'Notas de la llamada' },\n    },\n  },\n  log_meeting: {\n    label: 'Registrar reuni\u00F3n',\n    successMessage: '\u00A1Reuni\u00F3n registrada exitosamente!',\n    params: {\n      subject: { label: 'Asunto de la reuni\u00F3n' },\n      duration: { label: 'Duraci\u00F3n (minutos)' },\n      attendee_contacts: { label: 'Contactos participantes' },\n      attendee_users: { label: 'Participantes internos' },\n      notes: { label: 'Notas de la reuni\u00F3n' },\n    },\n  },\n  schedule_meeting: {\n    label: 'Programar reuni\u00F3n',\n    successMessage: '\u00A1Reuni\u00F3n programada!',\n    params: {\n      subject: { label: 'Asunto de la reuni\u00F3n' },\n      start_date: { label: 'Fecha de inicio (UTC)' },\n      start_time: { label: 'Hora de inicio (UTC)' },\n      location: { label: 'Ubicaci\u00F3n' },\n      duration: { label: 'Duraci\u00F3n (minutos)' },\n      attendee_contacts: { label: 'Contactos participantes' },\n      attendee_users: { label: 'Participantes internos' },\n      notes: { label: 'Agenda' },\n    },\n  },\n};\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/sales/translations/es-ES/objects.customer.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/sales/translations/es-ES\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/sales/translations/es-ES/objects.customer.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport type { ObjectTranslationData } from '@objectstack/spec/system';\n\nimport { activityActions } from './_shared';\n\n/**\n * Espa\u00F1ol (es-ES) \u2014 `objects` translations for the CUSTOMER family:\n * the customer record itself \u2014 accounts and the people at them.\n *\n * Roster: `crm_account`, `crm_contact`.\n *\n * SPLIT AXIS (#1311): translation NAMESPACE first, then CRM DOMAIN FAMILY.\n * Everything that is not `objects` lives in `./app.ts`; `objects` \u2014 69-78% of\n * every bundle \u2014 is one file per CRM domain family, and a detail object\n * follows its master. A new row goes in the file for ITS family, never in\n * whichever file is already open: that is how one file re-grows past the 70%\n * advisory band `pnpm hygiene` prints. Full rule and rationale:\n * `src/sales/translations/es-ES.ts`.\n */\nexport const customer: Record<string, ObjectTranslationData> = {\n  crm_account: {\n    label: 'Cuenta',\n    pluralLabel: 'Cuentas',\n    description: 'Empresas y organizaciones con las que mantenemos relaci\u00F3n comercial',\n    fields: {\n      account_number: { label: 'N\u00FAmero de Cuenta' },\n      registration_number: {\n        label: 'N\u00FAmero de Registro',\n        help: 'La identidad registrada de la contraparte, emitida por su propio registro gubernamental. No es el N\u00FAmero de Cuenta, que emitimos nosotros.',\n      },\n      commercial_capability: {\n        label: 'Capacidad Comercial',\n        help: 'Si se puede abrir nuevo negocio con esta cuenta. Las cuentas de Solo Liquidaci\u00F3n siguen siendo utilizables para facturaci\u00F3n y pagos, pero no se les puede vincular ninguna oportunidad nueva.',\n        options: { full: 'Completa', settlement_only: 'Solo Liquidaci\u00F3n' },\n      },\n      incumbent_vendor: { label: 'Proveedor Actual', help: 'El proveedor que actualmente atiende el gasto que perseguimos en esta cuenta.' },\n      annual_purchasing_budget: { label: 'Presupuesto Anual de Compras', help: 'Lo que esta cuenta espera gastar con proveedores este a\u00F1o, no sus propios ingresos.' },\n      payment_cycle: {\n        label: 'Ciclo de Pago',\n        options: { prepaid: 'Prepago', net_30: '30 d\u00EDas', net_60: '60 d\u00EDas', net_90: '90 d\u00EDas' },\n      },\n      approval_status: {\n        label: 'Estado de Aprobaci\u00F3n',\n        help: 'En qu\u00E9 punto de su aprobaci\u00F3n est\u00E1 esta cuenta. Una cuenta nueva comienza Pendiente y se decide en la bandeja de aprobaciones.',\n        options: { pending: 'Pendiente', approved: 'Aprobada', rejected: 'Rechazada' },\n      },\n      name: { label: 'Nombre de Cuenta', help: 'Nombre legal de la empresa u organizaci\u00F3n' },\n      name_normalized: {\n        label: 'Nombre de Cuenta (Normalizado)',\n        help: 'Clave de coincidencia para la conversi\u00F3n de prospectos: el Nombre de Cuenta en min\u00FAsculas, sin espacios sobrantes y con los espacios internos reducidos a uno. Lo mantiene el hook account_protection \u2014 nunca lo edite directamente.',\n      },\n      display_title: { label: 'T\u00EDtulo Mostrado' },\n      type: {\n        label: 'Tipo',\n        // `former` is 'Former Customer' in account.object.ts; the `en` bundle\n        // had truncated it to 'Former', and translating that truncation gave\n        // a bare 'Anterior' \u2014 an adjective with no noun, next to three option\n        // labels that are all nouns.\n        options: { prospect: 'Prospecto', customer: 'Cliente', partner: 'Socio', former: 'Cliente Anterior' },\n      },\n      industry: {\n        label: 'Industria',\n        options: {\n          technology: 'Tecnolog\u00EDa', software: 'Software / SaaS', finance: 'Finanzas',\n          healthcare: 'Salud', retail: 'Comercio', manufacturing: 'Manufactura',\n          education: 'Educaci\u00F3n', real_estate: 'Inmobiliaria', media: 'Medios y Entretenimiento',\n          logistics: 'Log\u00EDstica', hospitality: 'Hosteler\u00EDa', energy: 'Energ\u00EDa y Servicios P\u00FAblicos',\n          government: 'Gobierno', nonprofit: 'Sin \u00C1nimo de Lucro', other: 'Otro',\n        },\n      },\n      annual_revenue: { label: 'Ingresos Anuales' },\n      child_account_revenue: { label: 'Ingresos de Cuentas Hijas', help: 'Suma de los ingresos anuales de las cuentas hijas directas.' },\n      number_of_employees: { label: 'N\u00FAmero de Empleados' },\n      phone: { label: 'Tel\u00E9fono' },\n      website: { label: 'Sitio Web' },\n      billing_address: { label: 'Direcci\u00F3n de Facturaci\u00F3n' },\n      billing_country: {\n        label: 'Pa\u00EDs de Facturaci\u00F3n',\n        help: 'Derivado de la Direcci\u00F3n de Facturaci\u00F3n \u2014 el pa\u00EDs tal como se introdujo, sin espacios y en may\u00FAsculas.',\n      },\n      territory: {\n        label: 'Territorio',\n        help: 'Derivado de la Direcci\u00F3n de Facturaci\u00F3n \u2014 el territorio de ventas que usan las reglas de compartici\u00F3n. Las cuentas fuera de los territorios con equipo asignado son Otro.',\n        options: { na: 'Norteam\u00E9rica', emea: 'EMEA', other: 'Otro' },\n      },\n      office_location: { label: 'Ubicaci\u00F3n de Oficina' },\n      owner_id: { label: 'Propietario de Cuenta' },\n      parent_account: { label: 'Cuenta Matriz', help: 'Empresa matriz en la jerarqu\u00EDa' },\n      description: { label: 'Descripci\u00F3n' },\n      is_active: { label: 'Activo' },\n      last_activity_date: { label: 'Fecha de \u00DAltima Actividad' },\n      brand_color: { label: 'Color de Marca' },\n      logo: { label: 'Logo de la Empresa' },\n      tier: {\n        label: 'Nivel de Cliente',\n        options: {\n          strategic: 'Estrat\u00E9gico', enterprise: 'Gran Empresa',\n          mid_market: 'Mediana Empresa', smb: 'PYME',\n        },\n      },\n      segment: {\n        label: 'Segmento',\n        options: {\n          net_new: 'Cliente Nuevo', growth: 'Crecimiento',\n          at_risk: 'En Riesgo', stable: 'Estable',\n        },\n      },\n      health_score: {\n        label: '\u00CDndice de Salud',\n        help: 'Indicador de salud mantenido por el CSM',\n        options: {\n          healthy: 'Saludable', watching: 'En Observaci\u00F3n',\n          at_risk: 'En Riesgo', churning: 'En Fuga',\n        },\n      },\n    },\n    _views: {\n      all_accounts: {\n        label: 'Todas las Cuentas', description: 'Lista maestra de cuentas con ingresos e industria',\n        bulkActions: {\n          delete: {\n            label: 'Eliminar',\n            confirmLabel: 'Eliminar',\n            confirmText: '\u00BFEliminar permanentemente {{count}} cuenta(s)? Esta acci\u00F3n no se puede deshacer.',\n          },\n          transfer_owner: {\n            label: 'Transferir propietario',\n            confirmText: '\u00BFTransferir la propiedad de {{count}} cuenta(s)?',\n            params: {\n              owner_id: {\n                label: 'Nuevo propietario',\n              },\n            },\n          },\n          update_tier: {\n            label: 'Actualizar nivel',\n            confirmText: '\u00BFActualizar el nivel de {{count}} cuenta(s) a {{tier}}?',\n            params: {\n              tier: {\n                label: 'Nivel de cliente',\n              },\n            },\n          },\n        },\n      },\n      account_gallery: { label: 'Galer\u00EDa de Cuentas', description: 'Vista de tarjetas con colores de marca' },\n      account_map: { label: 'Mapa de Cuentas', description: 'Distribuci\u00F3n geogr\u00E1fica de cuentas' },\n      enterprise_accounts: { label: 'Cuentas Empresariales', description: 'Cuentas con mayores ingresos anuales' },\n      my_accounts: { label: 'Mis Cuentas', description: 'Cuentas asignadas al usuario actual' },\n      at_risk_accounts: { label: '\u26A0\uFE0F Cuentas en Riesgo' },\n    },\n    _sections: {\n      basic: { label: 'Informaci\u00F3n B\u00E1sica' },\n      financials: { label: 'Datos Financieros' },\n      business_profile: { label: 'Perfil de Negocio' },\n      contact_info: { label: 'Informaci\u00F3n de Contacto' },\n      ownership: { label: 'Propiedad y Estado' },\n      branding: { label: 'Identidad de Marca' },\n      system: { label: 'Sistema' },\n      // Nombres de secci\u00F3n del formulario en account.view.ts (#1100)\n      profile: { label: 'Perfil' },\n      customer_success: { label: '\u00C9xito del Cliente' },\n      locations: { label: 'Ubicaciones' },\n      description: { label: 'Descripci\u00F3n' },\n    },\n    _actions: { ...activityActions },\n  },\n  crm_contact: {\n    label: 'Contacto',\n    pluralLabel: 'Contactos',\n    description: 'Personas asociadas a las cuentas',\n    fields: {\n      // Mismo juego de valores que `crm_lead.salutation` \u2014 trad\u00FAzcanse igual.\n      salutation: {\n        label: 'T\u00EDtulo',\n        options: { mr: 'Sr.', ms: 'Srta.', mrs: 'Sra.', dr: 'Dr.', prof: 'Prof.' },\n      },\n      first_name: { label: 'Nombre' },\n      last_name: { label: 'Apellido' },\n      full_name: { label: 'Nombre Completo' },\n      crm_account: { label: 'Cuenta' },\n      email: { label: 'Correo Electr\u00F3nico' },\n      phone: { label: 'Tel\u00E9fono' },\n      mobile: { label: 'M\u00F3vil' },\n      title: { label: 'Cargo' },\n      department: {\n        label: 'Departamento',\n        options: {\n          executive: 'Ejecutivo', sales: 'Ventas', marketing: 'Marketing',\n          engineering: 'Ingenier\u00EDa', support: 'Soporte', finance: 'Finanzas',\n          hr: 'Recursos Humanos', operations: 'Operaciones',\n        },\n      },\n      // Centro de compra (REQ-0004) \u2014 el mapa de la decisi\u00F3n. La etiqueta\n      // inglesa es 'Buying Function' y no 'Buying Role': la regla\n      // security-role-word reserva la palabra inglesa `role` en las\n      // declaraciones (ADR-0090 D3). Esa regla s\u00F3lo lee ingl\u00E9s y no alcanza\n      // los paquetes de idioma, as\u00ED que aqu\u00ED va el t\u00E9rmino natural.\n      buying_function: {\n        label: 'Rol de Compra',\n        options: {\n          decision_maker: 'Decisor', economic_buyer: 'Comprador Econ\u00F3mico',\n          technical_evaluator: 'Evaluador T\u00E9cnico', user: 'Usuario',\n          influencer: 'Influenciador', gatekeeper: 'Guardi\u00E1n',\n        },\n      },\n      attitude: {\n        label: 'Actitud hacia Nosotros',\n        options: {\n          champion: 'Defensor', supportive: 'Favorable', neutral: 'Neutral',\n          skeptical: 'Esc\u00E9ptico', blocker: 'Bloqueador',\n        },\n      },\n      relationship_strength: {\n        label: 'Fuerza de la Relaci\u00F3n',\n        options: {\n          distant: 'Distante', acquaintance: 'Conocido', working: 'Relaci\u00F3n de Trabajo',\n          strong: 'Fuerte', trusted_advisor: 'Asesor de Confianza',\n        },\n      },\n      owner_id: { label: 'Propietario de Contacto' },\n      description: { label: 'Descripci\u00F3n' },\n      is_primary: { label: 'Contacto Principal', help: '\u00BFEs este el contacto principal de la cuenta?' },\n      avatar: { label: 'Foto de Perfil' },\n      mailing_address: { label: 'Direcci\u00F3n de Correo' },\n      // Juego compartido con `crm_lead.lead_source` y\n      // `crm_opportunity.lead_source` \u2014 los tres deben coincidir literalmente.\n      lead_source: {\n        label: 'Origen del Prospecto',\n        options: {\n          web: 'Web', referral: 'Referencia', event: 'Evento / Feria',\n          webinar: 'Seminario Web', partner: 'Socio', advertisement: 'Publicidad',\n          paid_search: 'B\u00FAsqueda de Pago', social: 'Redes Sociales', content: 'Contenido / Blog',\n          cold_call: 'Llamada en Fr\u00EDo', email_campaign: 'Campa\u00F1a de Email', other: 'Otro',\n        },\n      },\n      do_not_call: { label: 'No Llamar' },\n      email_opt_out: { label: 'Excluir de Correos' },\n      last_contacted_date: { label: '\u00DAltimo contacto' },\n    },\n    _views: {\n      all_contacts: { label: 'Todos los Contactos' },\n      contact_directory: { label: 'Directorio de Contactos' },\n      primary_contacts: { label: 'Contactos Principales' },\n    },\n    _sections: {\n      identity: { label: 'Identidad' },\n      account_info: { label: 'Cuenta y Cargo' },\n      buying_centre: { label: 'Centro de Compra' },\n      contact_info: { label: 'Informaci\u00F3n de Contacto' },\n      mailing_address: { label: 'Direcci\u00F3n de Correo' },\n      additional: { label: 'Informaci\u00F3n Adicional' },\n      preferences: { label: 'Preferencias de Comunicaci\u00F3n' },\n      // Nombres de secci\u00F3n del formulario en contact.view.ts (#1100)\n      contact_details: { label: 'Informaci\u00F3n de Contacto' },\n      comm_preferences: { label: 'Preferencias' },\n    },\n    _actions: {\n      ...activityActions,\n      mark_primary: {\n        label: 'Marcar como Principal',\n        confirmText: '\u00BFEstablecer este contacto como contacto principal de la cuenta?',\n        successMessage: '\u00A1Establecido como contacto principal!',\n      },\n      send_email: {\n        label: 'Enviar Correo',\n        params: {\n          subject: { label: 'Asunto' },\n          body: { label: 'Cuerpo' },\n        },\n      },\n      add_contact_to_campaign: {\n        label: 'A\u00F1adir a Campa\u00F1a',\n        successMessage: '\u00A1Contactos a\u00F1adidos a la campa\u00F1a!',\n        params: {\n          crm_campaign: { label: 'Campa\u00F1a' },\n        },\n      },\n    },\n  },\n};\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/sales/translations/es-ES/objects.pipeline.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/sales/translations/es-ES\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/sales/translations/es-ES/objects.pipeline.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport type { ObjectTranslationData } from '@objectstack/spec/system';\n\nimport { activityActions } from './_shared';\n\n/**\n * Espa\u00F1ol (es-ES) \u2014 `objects` translations for the PIPELINE family:\n * demand and the deals it becomes, plus the roll-up that forecasts them.\n *\n * Roster: `crm_lead`, `crm_opportunity`, `crm_opportunity_line_item`, `crm_forecast`.\n *\n * SPLIT AXIS (#1311): translation NAMESPACE first, then CRM DOMAIN FAMILY.\n * Everything that is not `objects` lives in `./app.ts`; `objects` \u2014 69-78% of\n * every bundle \u2014 is one file per CRM domain family, and a detail object\n * follows its master. A new row goes in the file for ITS family, never in\n * whichever file is already open: that is how one file re-grows past the 70%\n * advisory band `pnpm hygiene` prints. Full rule and rationale:\n * `src/sales/translations/es-ES.ts`.\n */\nexport const pipeline: Record<string, ObjectTranslationData> = {\n  crm_lead: {\n    _validations: {\n      disqualification_reason_required: {\n        message: 'El motivo de descalificaci\u00F3n es obligatorio cuando un prospecto no est\u00E1 cualificado',\n      },\n      duplicate_disqualification_requires_survivor: {\n        message: 'Descalificar un prospecto como duplicado exige nombrar el registro superviviente y marcar el estado de duplicado como Confirmado',\n      },\n      email_required: {\n        message: 'El correo electr\u00F3nico es obligatorio',\n      },\n      lead_status_progression: {\n        message: 'Transici\u00F3n de estado de prospecto no v\u00E1lida',\n      },\n    },\n    label: 'Prospecto',\n    pluralLabel: 'Prospectos',\n    description: 'Clientes potenciales todav\u00EDa sin calificar',\n    fields: {\n      first_name: { label: 'Nombre' },\n      last_name: { label: 'Apellido' },\n      company: { label: 'Empresa' },\n      company_normalized: {\n        label: 'Empresa (Normalizado)',\n        help: 'Clave de coincidencia para la conversi\u00F3n de prospectos: la Empresa en min\u00FAsculas, sin espacios sobrantes y con los espacios internos reducidos a uno. Lo mantiene el hook lead_duplicate_check \u2014 nunca lo edite directamente.',\n      },\n      display_title: { label: 'T\u00EDtulo Mostrado' },\n      title: { label: 'Cargo' },\n      email: { label: 'Correo Electr\u00F3nico' },\n      phone: { label: 'Tel\u00E9fono' },\n      status: {\n        label: 'Estado',\n        options: {\n          new: 'Nuevo', contacted: 'Contactado', qualified: 'Calificado',\n          unqualified: 'No Calificado', converted: 'Convertido',\n        },\n      },\n      lead_source: {\n        label: 'Origen del Prospecto',\n        options: {\n          web: 'Web', referral: 'Referencia', event: 'Evento / Feria',\n          webinar: 'Seminario Web', partner: 'Socio', advertisement: 'Publicidad',\n          paid_search: 'B\u00FAsqueda de Pago', social: 'Redes Sociales', content: 'Contenido / Blog',\n          cold_call: 'Llamada en Fr\u00EDo', email_campaign: 'Campa\u00F1a de Email', other: 'Otro',\n        },\n      },\n      owner_id: { label: 'Propietario' },\n      is_converted: { label: 'Convertido' },\n      description: { label: 'Descripci\u00F3n' },\n      // Mismo juego de valores que `crm_contact.salutation` \u2014 trad\u00FAzcanse igual.\n      salutation: {\n        label: 'Tratamiento',\n        options: { mr: 'Sr.', ms: 'Srta.', mrs: 'Sra.', dr: 'Dr.', prof: 'Prof.' },\n      },\n      full_name: { label: 'Nombre Completo' },\n      // Los 15 valores son los mismos que en `crm_account.industry` \u2014 deben\n      // coincidir literalmente entre ambas pantallas.\n      industry: {\n        label: 'Industria',\n        options: {\n          technology: 'Tecnolog\u00EDa', software: 'Software / SaaS', finance: 'Finanzas',\n          healthcare: 'Salud', retail: 'Comercio', manufacturing: 'Manufactura',\n          education: 'Educaci\u00F3n', real_estate: 'Inmobiliaria', media: 'Medios y Entretenimiento',\n          logistics: 'Log\u00EDstica', hospitality: 'Hosteler\u00EDa', energy: 'Energ\u00EDa y Servicios P\u00FAblicos',\n          government: 'Gobierno', nonprofit: 'Sin \u00C1nimo de Lucro', other: 'Otro',\n        },\n      },\n      mobile: { label: 'M\u00F3vil' },\n      website: { label: 'Sitio Web' },\n      rating: { label: 'Puntuaci\u00F3n de Prospecto', help: 'Puntuaci\u00F3n de calidad del prospecto (1-5 estrellas)' },\n      next_followup_date: { label: 'Pr\u00F3xima Fecha de Seguimiento' },\n      last_contacted_date: { label: '\u00DAltimo Contacto' },\n      need_type: {\n        label: 'Tipo de Necesidad',\n        help: 'Qu\u00E9 est\u00E1 pidiendo este prospecto. La asignaci\u00F3n, la priorizaci\u00F3n y los informes de demanda leen este campo.',\n        options: {\n          new_implementation: 'Nueva Implantaci\u00F3n', expansion: 'Ampliaci\u00F3n',\n          replacement: 'Sustituci\u00F3n', renewal: 'Renovaci\u00F3n', consulting: 'Consultor\u00EDa',\n          support: 'Soporte y Mantenimiento', other: 'Otro',\n        },\n      },\n      estimated_amount: {\n        label: 'Importe Estimado',\n        help: 'Valor estimado de esta necesidad, antes de la cualificaci\u00F3n. Precarga el importe de la oportunidad al convertir.',\n      },\n      conversion_approval_status: {\n        label: 'Aprobaci\u00F3n de Conversi\u00F3n',\n        help: 'Si este prospecto tiene el visto bueno para convertirse. \u00ABNo Requerida\u00BB significa que no se pide aprobaci\u00F3n: es el valor predeterminado de f\u00E1brica.',\n        options: {\n          not_required: 'No Requerida', pending: 'Pendiente',\n          approved: 'Aprobada', rejected: 'Rechazada',\n        },\n      },\n      converted_account: { label: 'Cuenta Convertida' },\n      converted_contact: { label: 'Contacto Convertido' },\n      converted_opportunity: { label: 'Oportunidad Convertida' },\n      converted_date: { label: 'Fecha de Conversi\u00F3n' },\n      address: { label: 'Direcci\u00F3n' },\n      annual_revenue: { label: 'Ingresos Anuales' },\n      number_of_employees: { label: 'N\u00FAmero de Empleados' },\n      notes: { label: 'Notas', help: 'Notas de trabajo sobre este cliente potencial: admite formato.' },\n      do_not_call: { label: 'No Llamar' },\n      email_opt_out: { label: 'Excluir de Correos' },\n      disqualification_reason: {\n        label: 'Motivo de No Calificaci\u00F3n',\n        help: 'Obligatorio cuando el estado es No Calificado',\n        options: {\n          not_a_fit: 'No Encaja', no_budget: 'Sin Presupuesto', wrong_persona: 'Perfil Incorrecto',\n          unreachable: 'Ilocalizable', duplicate: 'Duplicado', competitor: 'Competidor',\n          other: 'Otro',\n        },\n      },\n      duplicate_of_type: {\n        label: 'Duplicado De',\n        help: 'Qu\u00E9 objeto contiene el registro superviviente que este prospecto repite.',\n        // `erased` es una l\u00E1pida, no una opci\u00F3n: el formulario no la ofrece\n        // (ver `src/sales/views/lead.view.ts`), pero un prospecto cuyo superviviente\n        // fue eliminado la lleva, as\u00ED que necesita etiqueta all\u00ED donde el\n        // registro se LEE; sin traducir se mostrar\u00EDa el valor crudo `erased`.\n        options: { crm_lead: 'Prospecto', crm_contact: 'Contacto', erased: 'Registro Eliminado' },\n      },\n      duplicate_of_lead: { label: 'Prospecto Duplicado' },\n      duplicate_of_contact: { label: 'Contacto Duplicado' },\n      duplicate_status: {\n        label: 'Estado del Duplicado',\n        help: 'Sospechoso = marcado autom\u00E1ticamente en la captura. Confirmado = una persona verific\u00F3 la coincidencia.',\n        options: { suspected: 'Sospechoso', confirmed: 'Confirmado' },\n      },\n    },\n    _views: {\n      all_leads: {\n        label: 'Todos los Prospectos',\n        emptyState: { title: 'Todav\u00EDa no hay prospectos', message: 'Empiece creando su primer prospecto' },\n      },\n      kanban_by_status: { label: 'Pipeline de Prospectos' },\n      calendar_by_created: { label: 'Calendario de Prospectos' },\n      gallery_view: { label: 'Galer\u00EDa de Prospectos' },\n      my_leads: { label: 'Mis Prospectos' },\n      high_priority: { label: 'Alta Prioridad' },\n      hot_leads: { label: '\uD83D\uDD25 Prospectos Calientes' },\n      suspected_duplicates: {\n        label: 'Duplicados Sospechosos',\n        emptyState: {\n          title: 'Sin duplicados sospechosos',\n          message: 'Nada que revisar: se han comprobado todos los correos recapturados.',\n        },\n      },\n    },\n    _sections: {\n      // Claves de secci\u00F3n del objeto (lead.object.ts) que usan los\n      // formularios de registro y la p\u00E1gina de detalle, cuyas secciones\n      // hacen referencia a estos grupos (#806).\n      address: { label: 'Direcci\u00F3n' },\n      identity: { label: 'Identidad' },\n      company_info: { label: 'Informaci\u00F3n de la Empresa' },\n      contact_info: { label: 'Informaci\u00F3n de Contacto' },\n      qualification: { label: 'Calificaci\u00F3n' },\n      assignment: { label: 'Asignaci\u00F3n' },\n      conversion: { label: 'Conversi\u00F3n' },\n      additional: { label: 'Informaci\u00F3n Adicional' },\n      preferences: { label: 'Preferencias de Comunicaci\u00F3n' },\n      duplicates: { label: 'Gesti\u00F3n de Duplicados' },\n      // Nombres de secci\u00F3n del formulario en lead.view.ts (#1100) \u2014 aqu\u00ED\n      // viven las secciones del formulario por defecto y las de cada formView\n      // con nombre: si se a\u00F1ade un formulario all\u00ED, se a\u00F1aden aqu\u00ED sus\n      // nombres de secci\u00F3n.\n      contact_information: { label: 'Informaci\u00F3n de Contacto' },\n      lead_classification: { label: 'Clasificaci\u00F3n del Lead' },\n      company_information: { label: 'Informaci\u00F3n de la Empresa' },\n      additional_information: { label: 'Informaci\u00F3n Adicional' },\n      privacy: { label: 'Privacidad' },\n      general: { label: 'General' },\n      details: { label: 'Detalles' },\n      step_1_contact_details: { label: 'Paso 1: Datos de Contacto' },\n      step_2_company_information: { label: 'Paso 2: Informaci\u00F3n de la Empresa' },\n      step_3_qualification: { label: 'Paso 3: Calificaci\u00F3n' },\n      step_4_review_and_convert: { label: 'Paso 4: Revisar y Convertir' },\n      primary_information: { label: 'Informaci\u00F3n Principal' },\n      extended_details: { label: 'Detalles Ampliados' },\n      quick_edit: { label: 'Edici\u00F3n R\u00E1pida' },\n      update_lead_status: { label: 'Actualizar Estado del Lead' },\n      tell_us_about_yourself: { label: 'Cu\u00E9ntanos sobre ti' },\n      about_your_company: { label: 'Sobre tu empresa' },\n      how_can_we_help: { label: '\u00BFC\u00F3mo podemos ayudarte?' },\n      lead_information: { label: 'Informaci\u00F3n del Lead' },\n      address_information: { label: 'Informaci\u00F3n de Direcci\u00F3n' },\n      privacy_preferences: { label: 'Preferencias de Privacidad' },\n    },\n    _actions: {\n      ...activityActions,\n      convert_lead: {\n        label: 'Convertir Prospecto',\n        successMessage: '\u00A1Prospecto convertido con \u00E9xito!',\n      },\n      create_campaign: {\n        label: 'Agregar a Campa\u00F1a',\n        successMessage: '\u00A1Prospecto agregado a la campa\u00F1a!',\n        params: {\n          crm_campaign: { label: 'Campa\u00F1a' },\n        },\n      },\n      schedule_followup: {\n        label: 'Programar Seguimiento',\n        successMessage: 'Seguimiento programado.',\n      },\n    },\n  },\n  crm_opportunity: {\n    _validations: {\n      amount_positive: {\n        message: 'El importe debe ser mayor que cero',\n      },\n      close_date_future: {\n        message: 'La fecha de cierre no deber\u00EDa estar en el pasado salvo que la oportunidad est\u00E9 cerrada',\n      },\n      opportunity_stage_progression: {\n        message: 'Transici\u00F3n de etapa de oportunidad no v\u00E1lida',\n      },\n    },\n    label: 'Oportunidad',\n    pluralLabel: 'Oportunidades',\n    description: 'Oportunidades de venta y negocios en el pipeline',\n    fields: {\n      name: { label: 'Nombre de Oportunidad' },\n      crm_account: { label: 'Cuenta' },\n      primary_contact: { label: 'Contacto Principal' },\n      owner_id: { label: 'Propietario de Oportunidad' },\n      amount: { label: 'Monto' },\n      expected_revenue: { label: 'Ingreso Esperado' },\n      stage: {\n        label: 'Etapa',\n        options: {\n          prospecting: 'Prospecci\u00F3n', qualification: 'Calificaci\u00F3n',\n          needs_analysis: 'An\u00E1lisis de Necesidades', proposal: 'Propuesta',\n          negotiation: 'Negociaci\u00F3n', closed_won: 'Cerrada Ganada', closed_lost: 'Cerrada Perdida',\n        },\n      },\n      probability: { label: 'Probabilidad (%)' },\n      close_date: { label: 'Fecha de Cierre' },\n      type: {\n        label: 'Tipo',\n        options: {\n          new_business: 'Nuevo Negocio',\n          existing_upgrade: 'Cliente Existente - Mejora',\n          existing_renewal: 'Cliente Existente - Renovaci\u00F3n',\n          existing_expansion: 'Cliente Existente - Expansi\u00F3n',\n        },\n      },\n      forecast_category: {\n        label: 'Categor\u00EDa de Pron\u00F3stico',\n        options: {\n          pipeline: 'Pipeline', best_case: 'Mejor Caso',\n          commit: 'Compromiso', omitted: 'Omitida', closed: 'Cerrada',\n        },\n      },\n      description: { label: 'Descripci\u00F3n' },\n      next_step: { label: 'Pr\u00F3ximo Paso' },\n      lead_source: {\n        label: 'Origen del Prospecto',\n        options: {\n          web: 'Web', referral: 'Referencia', event: 'Evento / Feria',\n          webinar: 'Seminario Web', partner: 'Socio', advertisement: 'Publicidad',\n          paid_search: 'B\u00FAsqueda de Pago', social: 'Redes Sociales', content: 'Contenido / Blog',\n          cold_call: 'Llamada en Fr\u00EDo', email_campaign: 'Campa\u00F1a de Email', other: 'Otro',\n        },\n      },\n      crm_campaign: { label: 'Campa\u00F1a', help: 'Campa\u00F1a de marketing que gener\u00F3 esta oportunidad' },\n      days_in_stage: { label: 'D\u00EDas en Etapa Actual' },\n      stage_entry_date: { label: 'Fecha de Entrada a la Etapa', help: 'Fecha en la que esta oportunidad entr\u00F3 en su etapa actual.' },\n      is_private: { label: 'Privado' },\n      approval_status: {\n        label: 'Estado de Aprobaci\u00F3n',\n        options: {\n          not_required: 'No Requerida', pending: 'Pendiente',\n          approved: 'Aprobada', rejected: 'Rechazada',\n        },\n      },\n      approved_date: { label: 'Fecha de Aprobaci\u00F3n' },\n      // #593 \u2014 obligatorias al cerrar la oportunidad, y el desglose de\n      // motivos de p\u00E9rdida las muestra en el panel de ventas, as\u00ED que el\n      // valor almacenado nunca debe llegar crudo al selector.\n      win_reason: {\n        label: 'Motivo de Ganancia',\n        help: 'Por qu\u00E9 se gan\u00F3 este negocio. Obligatorio para cerrar una oportunidad como Ganada.',\n        options: {\n          better_product: 'Mejor Producto', better_price: 'Mejor Precio',\n          relationship: 'Relaci\u00F3n Existente', better_support: 'Mejor Soporte',\n          best_fit: 'Mejor Ajuste / Funcionalidades',\n          quote_accepted: 'Cotizaci\u00F3n Aceptada', other: 'Otro',\n        },\n      },\n      loss_reason: {\n        label: 'Motivo de P\u00E9rdida',\n        help: 'Por qu\u00E9 se perdi\u00F3 este negocio. Obligatorio para cerrar una oportunidad como Perdida.',\n        options: {\n          price: 'Precio Demasiado Alto', competitor: 'Perdida ante Competidor',\n          no_budget: 'Sin Presupuesto', no_decision: 'Sin Decisi\u00F3n',\n          timing: 'Momento Inadecuado', features: 'Funcionalidades Faltantes', other: 'Otro',\n        },\n      },\n      loss_details: {\n        label: 'Detalles de Ganancia/P\u00E9rdida',\n        help: 'Contexto en texto libre detr\u00E1s del motivo de ganancia o p\u00E9rdida.',\n      },\n      // REQ-0006 \u2014 calificaci\u00F3n, calendario de compra del cliente, narrativa\n      // del negocio, l\u00EDnea de negocio y aprobaci\u00F3n del cambio de estado.\n      will_bid: {\n        label: 'Presentaremos Oferta',\n        help: 'Si tenemos intenci\u00F3n de presentar oferta. Sin valor significa que la decisi\u00F3n sigue abierta.',\n      },\n      controllability: { label: 'Controlabilidad', options: { high: 'Alta', medium: 'Media', low: 'Baja' } },\n      priority: { label: 'Prioridad', options: { high: 'Alta', medium: 'Media', low: 'Baja' } },\n      deal_level: { label: 'Nivel del Negocio', options: { strategic: 'Estrat\u00E9gico', key: 'Clave', standard: 'Est\u00E1ndar' } },\n      is_subcontracted: { label: 'Incluye Subcontrataci\u00F3n' },\n      subcontracting_note: { label: 'Nota de Subcontrataci\u00F3n' },\n      customer_initiation_date: { label: 'Fecha de Inicio del Proyecto (Cliente)' },\n      expected_tender_date: { label: 'Fecha Prevista de Licitaci\u00F3n' },\n      expected_signing_date: { label: 'Fecha Prevista de Firma' },\n      expected_tender_amount: { label: 'Importe Previsto de Licitaci\u00F3n' },\n      expected_signing_amount: { label: 'Importe Previsto de Firma' },\n      business_line: {\n        label: 'L\u00EDnea de Negocio',\n        options: {\n          product: 'Producto', services: 'Servicios Profesionales', consulting: 'Consultor\u00EDa',\n          support: 'Soporte y Mantenimiento', other: 'Otro',\n        },\n      },\n      customer_background: { label: 'Antecedentes del Cliente' },\n      project_background: { label: 'Antecedentes del Proyecto' },\n      risk_analysis: { label: 'An\u00E1lisis de Riesgos' },\n      payment_terms: { label: 'Condiciones de Pago' },\n      requested_status: { label: 'Estado Solicitado', options: { closed_won: 'Ganada', closed_lost: 'Perdida' } },\n      status_change_approval_status: {\n        label: 'Aprobaci\u00F3n del Cambio de Estado',\n        options: {\n          not_required: 'No Requerida', pending: 'Pendiente',\n          approved: 'Aprobada', rejected: 'Rechazada',\n        },\n      },\n      // REQ-0006 paso 11 \u2014 la aprobaci\u00F3n de calificaci\u00F3n (\u7ACB\u9879).\n      qualification_requested: {\n        label: 'Solicitar Aprobaci\u00F3n de Calificaci\u00F3n',\n        help: 'M\u00E1rquelo para enviar este negocio a aprobaci\u00F3n de calificaci\u00F3n. Un rechazo lo desmarca; vuelva a marcarlo para solicitarla de nuevo.',\n      },\n      qualification_approval_status: {\n        label: 'Aprobaci\u00F3n de Calificaci\u00F3n',\n        options: {\n          not_required: 'No Requerida', pending: 'Pendiente',\n          approved: 'Aprobada', rejected: 'Rechazada',\n        },\n      },\n    },\n    _views: {\n      tender_this_quarter: {\n        label: 'Licitaciones de Este Trimestre',\n        emptyState: {\n          title: 'No hay licitaciones previstas este trimestre',\n          message: 'Esta pesta\u00F1a muestra los negocios abiertos cuya fecha de licitaci\u00F3n del cliente cae dentro del trimestre actual. Registra la Fecha Prevista de Licitaci\u00F3n en un negocio para verlo aqu\u00ED.',\n        },\n      },\n      open_opportunities: { label: 'Oportunidades Abiertas' },\n      all_opportunities: { label: 'Todas las Oportunidades' },\n      pipeline_kanban: { label: 'Pipeline de Ventas' },\n      close_date_calendar: { label: 'Calendario de Pron\u00F3stico' },\n      deal_timeline: { label: 'L\u00EDnea de Tiempo' },\n      deal_gallery: { label: 'Galer\u00EDa de Negocios' },\n      my_open_deals: { label: 'Mis Negocios Abiertos' },\n      closing_this_quarter: {\n        label: 'Cierres de Este Trimestre',\n        emptyState: {\n          title: 'No hay negocios que cierren este trimestre',\n          message: 'Esta pesta\u00F1a muestra los negocios abiertos en categor\u00EDa Compromiso o Mejor Caso cuya fecha de cierre cae dentro del trimestre actual. Ahora mismo no hay ninguno; los negocios que cierran m\u00E1s adelante est\u00E1n en la pesta\u00F1a Negocios Abiertos.',\n        },\n      },\n      stale_opportunities: { label: '\u26A0\uFE0F Oportunidades Estancadas \u00B7 M\u00E1s Tiempo en Etapa Primero' },\n    },\n    _sections: {\n      // Claves de secci\u00F3n del objeto (opportunity.object.ts) que usan los\n      // formularios de registro y la p\u00E1gina de detalle, cuyas secciones\n      // hacen referencia a estos grupos (#1452).\n      //\n      // `crm_forecast` es la clave del grupo de campos (\u00ABForecast & Metrics\u00BB\n      // en ingl\u00E9s). Esta traducci\u00F3n es anterior a #1452, cuando una secci\u00F3n\n      // de la p\u00E1gina de detalle con el mismo nombre se titulaba \u00ABStage &\n      // Forecast\u00BB; desde entonces solo la lee el grupo.\n      crm_forecast: { label: 'Etapa y Previsi\u00F3n' },\n      basic: { label: 'Informaci\u00F3n B\u00E1sica' },\n      financials: { label: 'Datos Financieros' },\n      sales_process: { label: 'Proceso de Venta' },\n      classification: { label: 'Clasificaci\u00F3n' },\n      campaign: { label: 'Campa\u00F1as' },\n      notes: { label: 'Notas y Pr\u00F3ximos Pasos' },\n      qualification: { label: 'Calificaci\u00F3n' },\n      narrative: { label: 'Narrativa del Negocio' },\n      // Nombres de secci\u00F3n del formulario en opportunity.view.ts (#1100)\n      overview: { label: 'Resumen' },\n      forecast: { label: 'Previsi\u00F3n' },\n      sales_strategy: { label: 'Estrategia de Ventas' },\n      win_loss: { label: 'Ganada / Perdida' },\n    },\n    _actions: {\n      ...activityActions,\n      clone_opportunity: {\n        label: 'Clonar Oportunidad',\n        successMessage: '\u00A1Oportunidad clonada con \u00E9xito!',\n      },\n      mass_update_stage: {\n        label: 'Actualizar Etapa',\n        successMessage: '\u00A1Etapa de oportunidad actualizada!',\n        params: {\n          // Mismos valores que `fields.stage` \u2014 deben coincidir literalmente.\n          stage: {\n            label: 'Nueva Etapa',\n            options: {\n              prospecting: 'Prospecci\u00F3n', qualification: 'Calificaci\u00F3n',\n              needs_analysis: 'An\u00E1lisis de Necesidades', proposal: 'Propuesta',\n              negotiation: 'Negociaci\u00F3n', closed_won: 'Cerrada Ganada', closed_lost: 'Cerrada Perdida',\n            },\n          },\n        },\n      },\n      generate_quote: {\n        label: 'Generar Cotizaci\u00F3n',\n        successMessage: '\u00A1Cotizaci\u00F3n creada desde la oportunidad!',\n      },\n    },\n  },\n  crm_opportunity_line_item: {\n    _validations: {\n      unit_price_positive: {\n        message: 'El precio de venta no puede ser negativo',\n      },\n    },\n    label: 'L\u00EDnea de Oportunidad',\n    pluralLabel: 'L\u00EDneas de Oportunidad',\n    description: 'L\u00EDneas de precio por producto dentro de una oportunidad',\n    fields: {\n      crm_opportunity: { label: 'Oportunidad' },\n      crm_product: { label: 'Producto' },\n      description: { label: 'Descripci\u00F3n' },\n      quantity: { label: 'Cantidad' },\n      list_price: { label: 'Precio de Lista', help: 'Se rellena autom\u00E1ticamente desde el Precio de Lista del producto.' },\n      unit_price: { label: 'Precio de Venta', help: 'Precio unitario negociado (puede diferir del precio de lista)' },\n      discount: { label: 'Descuento (%)' },\n      total_price: { label: 'Total' },\n      line_number: { label: 'N\u00BA de L\u00EDnea' },\n    },\n    _sections: {\n      basic: { label: 'L\u00EDnea' },\n      pricing: { label: 'Precios' },\n    },\n  },\n  crm_forecast: {\n    _validations: {\n      period_end_after_start: {\n        message: 'El fin del periodo debe ser posterior a su inicio.',\n      },\n      period_end_matches_calendar_period: {\n        message: 'El fin del periodo debe ser el \u00FAltimo d\u00EDa del periodo: p. ej. 2026-09-30 para un trimestre que empieza el 2026-07-01, o 2026-08-31 para agosto de 2026.',\n      },\n      period_start_first_of_period: {\n        message: 'El inicio del periodo debe ser el primer d\u00EDa del periodo: p. ej. 2026-08-01 para agosto de 2026.',\n      },\n      quarter_starts_on_quarter_boundary: {\n        message: 'Una previsi\u00F3n trimestral debe comenzar en un l\u00EDmite de trimestre: 1 de enero, 1 de abril, 1 de julio o 1 de octubre.',\n      },\n      snapshot_amounts_non_negative: {\n        message: 'Los importes de la instant\u00E1nea no pueden ser negativos.',\n      },\n    },\n    label: 'Previsi\u00F3n',\n    pluralLabel: 'Previsiones',\n    description: 'Instant\u00E1nea peri\u00F3dica del pipeline por propietario para previsi\u00F3n de ingresos',\n    fields: {\n      owner_id: { label: 'Propietario' },\n      period: { label: 'Periodo', options: { month: 'Mes', quarter: 'Trimestre' } },\n      period_start: {\n        label: 'Inicio del periodo',\n        help: 'Debe ser el primer d\u00EDa del periodo \u2014 p. ej. 2026-08-01 para agosto de 2026. Adem\u00E1s, una previsi\u00F3n trimestral debe comenzar en un l\u00EDmite de trimestre: 1 de enero, 1 de abril, 1 de julio o 1 de octubre.',\n      },\n      period_end: {\n        label: 'Fin del periodo',\n        help: 'Normalmente se calcula autom\u00E1ticamente a partir de Periodo e Inicio del periodo. Si se introduce a mano, debe ser el \u00FAltimo d\u00EDa de ese periodo \u2014 p. ej. 2026-09-30 para un trimestre que empieza el 2026-07-01, o 2026-08-31 para agosto de 2026.',\n      },\n      period_label: { label: 'Periodo', help: 'Etiqueta legible, p. ej. \u00ABT3 2026\u00BB o \u00ABAgo 2026\u00BB.' },\n      display_title: { label: 'T\u00EDtulo Mostrado' },\n      snapshot_date: { label: 'Fecha de instant\u00E1nea', help: 'El d\u00EDa en que se captur\u00F3 esta instant\u00E1nea.' },\n      source: {\n        label: 'Origen',\n        options: { scheduled: 'Instant\u00E1nea programada', ai: 'Skill de IA', manual: 'Entrada manual' },\n      },\n      quota: { label: 'Cuota' },\n      pipeline_amount: { label: 'Pipeline', help: 'Suma de todas las oportunidades abiertas que cierran en este periodo (en cualquier etapa).' },\n      best_case_amount: { label: 'Mejor caso', help: 'Oportunidades abiertas en la categor\u00EDa de pron\u00F3stico Mejor caso o Compromiso.' },\n      commit_amount: { label: 'Compromiso', help: 'Oportunidades abiertas en la categor\u00EDa de pron\u00F3stico Compromiso (comprometidas por el propietario).' },\n      closed_amount: { label: 'Cerrado', help: 'Importe ya cerrado ganado en este periodo.' },\n      expected_amount: { label: 'Esperado', help: 'Cerrado + Compromiso: lo que el propietario espera razonablemente cerrar.' },\n      attainment_pct: { label: 'Cumplimiento %', help: 'Cerrado \u00F7 Cuota \u00D7 100. Muestra 0 % hasta que se fija una cuota positiva.' },\n      coverage_ratio: { label: 'Cobertura', help: 'Pipeline \u00F7 (Cuota \u2212 Cerrado): si queda pipeline suficiente para cubrir la diferencia. Muestra 0 cuando ya se ha alcanzado la cuota.' },\n      notes: { label: 'Notas' },\n      seed_key: {\n        label: 'Clave de semilla',\n        help: 'Identidad del juego de datos de demostraci\u00F3n. Solo la escribe el cargador de semillas; est\u00E1 vac\u00EDa en cualquier instant\u00E1nea real.',\n      },\n    },\n    _views: {\n      all_forecasts: { label: 'Todas las previsiones' },\n      this_quarter_forecasts: {\n        label: 'Este trimestre',\n        emptyState: {\n          title: 'A\u00FAn no hay instant\u00E1neas de este trimestre',\n          message: 'Las instant\u00E1neas trimestrales las escribe el barrido nocturno de previsiones. Hasta que se ejecute una vez para el trimestre actual, esta vista est\u00E1 vac\u00EDa; los trimestres cerrados est\u00E1n en la pesta\u00F1a Todas.',\n        },\n      },\n      my_forecast: { label: 'Mi previsi\u00F3n' },\n    },\n    _sections: {\n      basic: { label: 'Instant\u00E1nea' },\n      amounts: { label: 'Importes' },\n      meta: { label: 'Origen' },\n      // Nombres de secci\u00F3n del formulario en forecast.view.ts (#1100)\n      snapshot: { label: 'Instant\u00E1nea' },\n      notes: { label: 'Notas' },\n    },\n  },\n};\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/sales/translations/es-ES/objects.commerce.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/sales/translations/es-ES\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/sales/translations/es-ES/objects.commerce.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport type { ObjectTranslationData } from '@objectstack/spec/system';\n\n/**\n * Espa\u00F1ol (es-ES) \u2014 `objects` translations for the COMMERCE family:\n * what gets sold and on what paper \u2014 quotes, contracts, products.\n *\n * Roster: `crm_quote`, `crm_quote_line_item`, `crm_contract`, `crm_product`.\n *\n * SPLIT AXIS (#1311): translation NAMESPACE first, then CRM DOMAIN FAMILY.\n * Everything that is not `objects` lives in `./app.ts`; `objects` \u2014 69-78% of\n * every bundle \u2014 is one file per CRM domain family, and a detail object\n * follows its master. A new row goes in the file for ITS family, never in\n * whichever file is already open: that is how one file re-grows past the 70%\n * advisory band `pnpm hygiene` prints. Full rule and rationale:\n * `src/sales/translations/es-ES.ts`.\n */\nexport const commerce: Record<string, ObjectTranslationData> = {\n  crm_quote: {\n    _validations: {\n      discount_within_ceiling: {\n        message: 'El descuento no puede superar el 60 %',\n      },\n      expiration_after_quote: {\n        message: 'La fecha de vencimiento debe ser posterior a la de la cotizaci\u00F3n',\n      },\n      quote_status_progression: {\n        message: 'Transici\u00F3n de estado de cotizaci\u00F3n no v\u00E1lida',\n      },\n    },\n    label: 'Cotizaci\u00F3n',\n    pluralLabel: 'Cotizaciones',\n    description: 'Cotizaciones de precios para clientes',\n    fields: {\n      quote_number: { label: 'N\u00FAmero de Cotizaci\u00F3n' },\n      display_title: { label: 'T\u00EDtulo Mostrado' },\n      name: { label: 'Nombre de Cotizaci\u00F3n' },\n      crm_account: { label: 'Cuenta' },\n      crm_contact: {\n        label: 'Contacto',\n        help: 'Obligatorio en cuanto la cotizaci\u00F3n pasa a Presentada o Aceptada: el contrato generado toma de aqu\u00ED su Contacto principal.',\n      },\n      crm_opportunity: { label: 'Oportunidad' },\n      owner_id: { label: 'Propietario de Cotizaci\u00F3n' },\n      status: {\n        label: 'Estado',\n        options: {\n          draft: 'Borrador', in_review: 'En Revisi\u00F3n', presented: 'Presentada',\n          accepted: 'Aceptada', rejected: 'Rechazada', expired: 'Expirada',\n        },\n      },\n      quote_date: { label: 'Fecha de Cotizaci\u00F3n' },\n      expiration_date: { label: 'Fecha de Expiraci\u00F3n' },\n      subtotal: { label: 'Subtotal' },\n      discount: { label: 'Descuento %' },\n      discount_amount: { label: 'Monto de Descuento' },\n      tax: { label: 'Impuesto' },\n      shipping_handling: { label: 'Env\u00EDo y Manipulaci\u00F3n' },\n      total_price: { label: 'Precio Total' },\n      // Mismo juego de valores que `crm_contract.payment_terms` \u2014 trad\u00FAzcanse igual.\n      payment_terms: {\n        label: 'T\u00E9rminos de Pago',\n        options: {\n          net_15: 'Neto 15', net_30: 'Neto 30', net_60: 'Neto 60', net_90: 'Neto 90',\n          due_on_receipt: 'Pago a la Recepci\u00F3n',\n        },\n      },\n      shipping_terms: { label: 'T\u00E9rminos de Env\u00EDo' },\n      billing_address: { label: 'Direcci\u00F3n de Facturaci\u00F3n' },\n      shipping_address: { label: 'Direcci\u00F3n de Env\u00EDo' },\n      description: { label: 'Descripci\u00F3n' },\n      internal_notes: { label: 'Notas Internas' },\n    },\n    _views: {\n      all_quotes: { label: 'Todas las Cotizaciones' },\n      quote_pipeline: { label: 'Pipeline de Cotizaciones' },\n      quote_calendar: { label: 'Calendario de Cotizaciones' },\n    },\n    _sections: {\n      basic: { label: 'Informaci\u00F3n de la Cotizaci\u00F3n' },\n      pricing: { label: 'Precios' },\n      terms: { label: 'T\u00E9rminos y Vigencia' },\n      address: { label: 'Direcciones' },\n      system: { label: 'Sistema' },\n      // Nombres de secci\u00F3n del formulario en quote.view.ts (#1100)\n      quote: { label: 'Cotizaci\u00F3n' },\n      totals: { label: 'Totales' },\n      quote_terms: { label: 'T\u00E9rminos' },\n      addresses_and_notes: { label: 'Direcciones y Notas' },\n    },\n  },\n  crm_quote_line_item: {\n    _validations: {\n      discount_within_ceiling: {\n        message: 'El descuento de l\u00EDnea no puede superar el 60 %',\n      },\n      unit_price_positive: {\n        message: 'El precio de venta no puede ser negativo',\n      },\n    },\n    label: 'L\u00EDnea de Cotizaci\u00F3n',\n    pluralLabel: 'L\u00EDneas de Cotizaci\u00F3n',\n    description: 'L\u00EDneas de precio por producto dentro de una cotizaci\u00F3n',\n    fields: {\n      crm_quote: { label: 'Cotizaci\u00F3n' },\n      crm_product: { label: 'Producto' },\n      description: { label: 'Descripci\u00F3n' },\n      quantity: { label: 'Cantidad' },\n      list_price: { label: 'Precio de Lista' },\n      unit_price: { label: 'Precio de Venta' },\n      discount: { label: 'Descuento (%)' },\n      subtotal: { label: 'Subtotal' },\n      total_price: { label: 'Total' },\n      line_number: { label: 'N\u00BA de L\u00EDnea' },\n    },\n    _sections: {\n      basic: { label: 'L\u00EDnea' },\n      pricing: { label: 'Precios' },\n    },\n  },\n  crm_contract: {\n    _validations: {\n      end_after_start: {\n        message: 'La fecha de fin debe ser posterior a la de inicio',\n      },\n      contract_status_progression: {\n        message: 'Transici\u00F3n de estado de contrato no v\u00E1lida',\n      },\n    },\n    label: 'Contrato',\n    pluralLabel: 'Contratos',\n    description: 'Contratos y acuerdos legales',\n    fields: {\n      contract_number: { label: 'N\u00FAmero de Contrato' },\n      crm_account: { label: 'Cuenta' },\n      crm_contact: { label: 'Contacto Principal' },\n      crm_opportunity: { label: 'Oportunidad Relacionada' },\n      owner_id: { label: 'Propietario del Contrato' },\n      status: {\n        label: 'Estado',\n        options: {\n          draft: 'Borrador', in_approval: 'En Aprobaci\u00F3n', activated: 'Activado',\n          expired: 'Expirado', terminated: 'Rescindido',\n        },\n      },\n      contract_term_months: { label: 'Plazo del Contrato (Meses)' },\n      start_date: { label: 'Fecha de Inicio' },\n      end_date: { label: 'Fecha de Fin' },\n      contract_value: { label: 'Valor del Contrato' },\n      billing_frequency: {\n        label: 'Frecuencia de Facturaci\u00F3n',\n        options: { monthly: 'Mensual', quarterly: 'Trimestral', annually: 'Anual', one_time: 'Pago \u00DAnico' },\n      },\n      // Mismo juego de valores que `crm_quote.payment_terms` \u2014 trad\u00FAzcanse igual.\n      payment_terms: {\n        label: 'T\u00E9rminos de Pago',\n        options: {\n          net_15: 'Neto 15', net_30: 'Neto 30', net_60: 'Neto 60', net_90: 'Neto 90',\n          due_on_receipt: 'Pago a la Recepci\u00F3n',\n        },\n      },\n      auto_renewal: { label: 'Renovaci\u00F3n Autom\u00E1tica' },\n      renewal_notice_days: { label: 'Aviso de Renovaci\u00F3n (D\u00EDas)' },\n      contract_type: {\n        label: 'Tipo de Contrato',\n        options: {\n          subscription: 'Suscripci\u00F3n', service: 'Acuerdo de Servicio', license: 'Licencia',\n          partnership: 'Asociaci\u00F3n', nda: 'Acuerdo de Confidencialidad (NDA)',\n          msa: 'Acuerdo Marco de Servicios (MSA)',\n        },\n      },\n      signed_date: { label: 'Fecha de Firma' },\n      signed_by: { label: 'Firmado Por' },\n      document_url: { label: 'Documento de Contrato' },\n      special_terms: { label: 'T\u00E9rminos Especiales' },\n      description: { label: 'Descripci\u00F3n' },\n      billing_address: { label: 'Direcci\u00F3n de Facturaci\u00F3n' },\n    },\n    _views: {\n      all_contracts: { label: 'Todos los Contratos' },\n      renewal_calendar: { label: 'Calendario de Renovaci\u00F3n' },\n      contract_gantt: { label: 'Plazos del Contrato' },\n      contract_timeline: { label: 'L\u00EDnea de Tiempo' },\n    },\n    _sections: {\n      basic: { label: 'Informaci\u00F3n del Contrato' },\n      parties: { label: 'Partes' },\n      terms: { label: 'T\u00E9rminos y Fechas' },\n      value: { label: 'Valor del Contrato' },\n      status: { label: 'Estado y Aprobaci\u00F3n' },\n      renewal: { label: 'Renovaci\u00F3n' },\n      // Nombres de secci\u00F3n del formulario en contract.view.ts (#1100)\n      contract_terms: { label: 'T\u00E9rminos' },\n      signing_and_documents: { label: 'Firma y Documentos' },\n      notes: { label: 'Notas' },\n    },\n  },\n  crm_product: {\n    _validations: {\n      cost_less_than_price: {\n        message: 'El coste deber\u00EDa ser inferior al precio de lista',\n      },\n      price_positive: {\n        message: 'El precio de lista debe ser positivo',\n      },\n    },\n    label: 'Producto',\n    pluralLabel: 'Productos',\n    description: 'Productos y servicios que ofrece la empresa',\n    fields: {\n      product_code: { label: 'C\u00F3digo de Producto' },\n      display_title: { label: 'T\u00EDtulo Mostrado' },\n      name: { label: 'Nombre de Producto' },\n      description: { label: 'Descripci\u00F3n' },\n      category: {\n        label: 'Categor\u00EDa',\n        options: {\n          software: 'Software', hardware: 'Hardware', service: 'Servicio',\n          subscription: 'Suscripci\u00F3n', support: 'Soporte',\n        },\n      },\n      family: {\n        label: 'Familia de Producto',\n        options: {\n          enterprise: 'Soluciones para Gran Empresa', smb: 'Soluciones para PYMEs',\n          services: 'Servicios Profesionales', cloud: 'Servicios en la Nube',\n        },\n      },\n      list_price: { label: 'Precio de Lista' },\n      cost: { label: 'Costo' },\n      sku: { label: 'SKU' },\n      is_active: { label: 'Activo' },\n      product_manager: { label: 'Gerente de Producto' },\n      image: { label: 'Imagen de Producto' },\n      datasheet: { label: 'Ficha T\u00E9cnica' },\n    },\n    _views: {\n      all_products: { label: 'Todos los Productos' },\n      product_catalog: { label: 'Cat\u00E1logo de Productos' },\n    },\n    _sections: {\n      basic: { label: 'Informaci\u00F3n del Producto' },\n      pricing: { label: 'Precios' },\n      metadata: { label: 'Recursos' },\n      // Nombres de secci\u00F3n del formulario en product.view.ts (#1100)\n      product_info: { label: 'Informaci\u00F3n del Producto' },\n      pricing_info: { label: 'Precios' },\n      media: { label: 'Multimedia' },\n    },\n  },\n};\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/sales/translations/es-ES/objects.service.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/sales/translations/es-ES\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/sales/translations/es-ES/objects.service.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport type { ObjectTranslationData } from '@objectstack/spec/system';\n\nimport { activityActions } from './_shared';\n\n/**\n * Espa\u00F1ol (es-ES) \u2014 `objects` translations for the SERVICE family:\n * post-sale support \u2014 cases and the knowledge that deflects them.\n *\n * Roster: `crm_case`, `crm_knowledge_article`, `crm_article_feedback`.\n *\n * SPLIT AXIS (#1311): translation NAMESPACE first, then CRM DOMAIN FAMILY.\n * Everything that is not `objects` lives in `./app.ts`; `objects` \u2014 69-78% of\n * every bundle \u2014 is one file per CRM domain family, and a detail object\n * follows its master. A new row goes in the file for ITS family, never in\n * whichever file is already open: that is how one file re-grows past the 70%\n * advisory band `pnpm hygiene` prints. Full rule and rationale:\n * `src/sales/translations/es-ES.ts`.\n */\nexport const service: Record<string, ObjectTranslationData> = {\n  crm_case: {\n    _validations: {\n      resolution_required_for_closed: {\n        message: 'La resoluci\u00F3n es obligatoria al cerrar un caso',\n      },\n      escalation_reason_required: {\n        message: 'El motivo de escalado es obligatorio al escalar un caso',\n      },\n      case_status_progression: {\n        message: 'Transici\u00F3n de estado no v\u00E1lida',\n      },\n    },\n    label: 'Caso',\n    pluralLabel: 'Casos',\n    description: 'Casos de soporte y solicitudes de servicio de clientes',\n    fields: {\n      case_number: { label: 'N\u00FAmero de Caso' },\n      display_title: { label: 'T\u00EDtulo Mostrado' },\n      subject: { label: 'Asunto' },\n      description: { label: 'Descripci\u00F3n' },\n      crm_account: { label: 'Cuenta' },\n      crm_contact: { label: 'Contacto' },\n      status: {\n        label: 'Estado',\n        options: {\n          new: 'Nuevo', in_progress: 'En Curso',\n          waiting_customer: 'Esperando al Cliente', waiting_support: 'Esperando a Soporte',\n          escalated: 'Escalado', resolved: 'Resuelto', closed: 'Cerrado',\n        },\n      },\n      priority: {\n        label: 'Prioridad',\n        options: { low: 'Baja', medium: 'Media', high: 'Alta', critical: 'Cr\u00EDtica' },\n      },\n      priority_rank: { label: 'Rango de Prioridad' },\n      type: {\n        label: 'Tipo de Caso',\n        options: {\n          question: 'Consulta', problem: 'Problema',\n          feature_request: 'Solicitud de Funcionalidad', bug: 'Error',\n        },\n      },\n      // `email` y `chat` se dejan como pr\u00E9stamos: son el t\u00E9rmino habitual en\n      // espa\u00F1ol de negocios y concuerdan con `crm_campaign.channel`.\n      origin: {\n        label: 'Origen del Caso',\n        options: { email: 'Email', phone: 'Tel\u00E9fono', web: 'Web', chat: 'Chat', social_media: 'Redes Sociales' },\n      },\n      owner_id: { label: 'Propietario del Caso' },\n      closed_date: { label: 'Fecha de Cierre' },\n      first_response_date: { label: 'Fecha de Primera Respuesta' },\n      resolution_time_hours: { label: 'Tiempo de Resoluci\u00F3n (Horas)' },\n      sla_due_date: { label: 'Fecha L\u00EDmite SLA', help: 'Se fija seg\u00FAn la prioridad del caso y el Nivel de Cliente de la cuenta, en horas naturales: las noches, los fines de semana y los festivos cuentan.' },\n      is_sla_violated: { label: 'SLA Incumplido' },\n      is_escalated: { label: 'Escalado' },\n      escalated_date: { label: 'Fecha de Escalaci\u00F3n' },\n      escalation_reason: { label: 'Motivo de Escalaci\u00F3n' },\n      resolution: { label: 'Resoluci\u00F3n' },\n      resolved_by_article: { label: 'Resuelto por Art\u00EDculo', help: 'Art\u00EDculo de la base de conocimiento que resolvi\u00F3 este caso \u2014 la se\u00F1al de desv\u00EDo.' },\n      internal_notes: { label: 'Notas Internas', help: 'Notas internas no visibles para el cliente' },\n      is_closed: { label: 'Est\u00E1 Cerrado' },\n    },\n    _views: {\n      all_cases: { label: 'Todos los Casos' },\n      case_workflow: { label: 'Flujo de Servicio' },\n      sla_calendar: { label: 'Calendario SLA' },\n      case_timeline: { label: 'L\u00EDnea de Tiempo de Casos' },\n      unassigned_triage: {\n        label: 'Sin asignar \u2014 triaje',\n        emptyState: {\n          title: 'Nada pendiente de triaje',\n          message: 'Todos los casos tienen propietario. Los casos aparecen aqu\u00ED cuando llegan sin propietario \u2014 normalmente un env\u00EDo web-a-caso recibido mientras nadie ocupaba el puesto de Agente de Servicio.',\n        },\n      },\n      escalated_cases: { label: 'Casos Escalados' },\n      my_open_cases: { label: 'Mis Casos Abiertos' },\n      sla_at_risk: { label: '\u23F0 SLA en Riesgo' },\n    },\n    _sections: {\n      // Nombres de secci\u00F3n del formulario en case.view.ts (#1100).\n      case: { label: 'Caso' },\n      how_can_we_help: { label: '\u00BFC\u00F3mo podemos ayudarte?' },\n      // Claves de secci\u00F3n del objeto (case.object.ts) que usan los\n      // formularios de registro y la p\u00E1gina de detalle, cuyas secciones\n      // hacen referencia a estos grupos (#970).\n      basic: { label: 'Informaci\u00F3n del Caso' },\n      origin: { label: 'Origen y Asignaci\u00F3n' },\n      sla: { label: 'SLA y Prioridad' },\n      resolution: { label: 'Resoluci\u00F3n' },\n      escalation: { label: 'Escalaci\u00F3n' },\n      system: { label: 'Sistema' },\n    },\n    _actions: {\n      ...activityActions,\n      escalate_case: {\n        label: 'Escalar Caso',\n        confirmText: 'Esto enviar\u00E1 el caso al equipo de escalaci\u00F3n. \u00BFContinuar?',\n        successMessage: '\u00A1Caso escalado con \u00E9xito!',\n      },\n      close_case: {\n        label: 'Cerrar Caso',\n        confirmText: '\u00BFEst\u00E1 seguro de querer cerrar este caso?',\n        successMessage: '\u00A1Caso cerrado con \u00E9xito!',\n      },\n      claim_case: {\n        label: 'Tomar Caso',\n        successMessage: 'Caso tomado: ahora es suyo.',\n      },\n    },\n  },\n  crm_knowledge_article: {\n    _validations: {\n      published_requires_body: {\n        message: 'No se pueden publicar art\u00EDculos sin cuerpo.',\n      },\n      published_requires_summary: {\n        message: 'Los art\u00EDculos publicados deben tener un resumen para los resultados de b\u00FAsqueda y las citas de IA.',\n      },\n    },\n    label: 'Art\u00EDculo de Conocimiento',\n    pluralLabel: 'Base de Conocimiento',\n    description: 'Respuestas y gu\u00EDas reutilizables para clientes y agentes',\n    fields: {\n      article_number: { label: 'N.\u00BA Art\u00EDculo' },\n      display_title: { label: 'T\u00EDtulo Mostrado' },\n      title: { label: 'T\u00EDtulo' },\n      summary: { label: 'Resumen', help: 'Resumen de un p\u00E1rrafo que se muestra en los resultados de b\u00FAsqueda y en las citas de la IA.' },\n      body: { label: 'Contenido', help: 'Contenido completo del art\u00EDculo (Markdown).' },\n      category: {\n        label: 'Categor\u00EDa',\n        options: {\n          getting_started: 'Primeros pasos', how_to: 'C\u00F3mo hacerlo',\n          troubleshooting: 'Resoluci\u00F3n de problemas', billing: 'Facturaci\u00F3n', api: 'API e Integraciones',\n          release_notes: 'Notas de versi\u00F3n', policy: 'Pol\u00EDticas',\n        },\n      },\n      tags: {\n        label: 'Etiquetas',\n        options: {\n          auth: 'Autenticaci\u00F3n', sso: 'SSO', mobile: 'M\u00F3vil', email: 'Correo',\n          reports: 'Informes', performance: 'Rendimiento',\n          data_import: 'Importaci\u00F3n de datos', webhooks: 'Webhooks',\n        },\n      },\n      status: {\n        label: 'Estado',\n        options: { draft: 'Borrador', in_review: 'En revisi\u00F3n', published: 'Publicado', archived: 'Archivado' },\n      },\n      audience: {\n        label: 'Audiencia',\n        help: 'Los art\u00EDculos p\u00FAblicos son visibles en el portal de clientes; los internos solo los ven los agentes.',\n        options: { public: 'P\u00FAblico', internal: 'Interno' },\n      },\n      language: {\n        label: 'Idioma',\n        options: { en: 'Ingl\u00E9s', zh_cn: 'Chino simplificado', es_es: 'Espa\u00F1ol', ja_jp: 'Japon\u00E9s' },\n      },\n      owner_id: { label: 'Propietario' },\n      related_to_case: { label: 'Caso de origen', help: 'Caso a partir del cual se redact\u00F3 este art\u00EDculo (opcional).' },\n      published_at: { label: 'Publicado el' },\n      last_reviewed_at: { label: '\u00DAltima revisi\u00F3n' },\n      helpful_count: { label: '\u00DAtil', help: 'Recontado desde crm_article_feedback \u2014 nunca se escribe a mano.' },\n      not_helpful_count: { label: 'No \u00FAtil', help: 'Recontado desde crm_article_feedback \u2014 nunca se escribe a mano.' },\n    },\n    _views: {\n      all_articles: { label: 'Todos los art\u00EDculos' },\n      published_articles: { label: 'Publicados' },\n      my_drafts: { label: 'Mis borradores' },\n    },\n    _sections: {\n      basic: { label: 'Informaci\u00F3n del Art\u00EDculo' },\n      content: { label: 'Contenido' },\n      taxonomy: { label: 'Categorizaci\u00F3n' },\n      metrics: { label: 'Interacci\u00F3n' },\n      engagement: { label: 'Interacci\u00F3n' },\n      // Nombre de secci\u00F3n del formulario en knowledge_article.view.ts (#1100)\n      article: { label: 'Art\u00EDculo' },\n    },\n    _actions: {\n      mark_article_helpful: {\n        label: '\u00DAtil',\n        successMessage: 'Gracias \u2014 registrado como \u00FAtil.',\n      },\n      mark_article_not_helpful: {\n        label: 'No \u00FAtil',\n        successMessage: 'Gracias \u2014 registrado como no \u00FAtil.',\n      },\n    },\n  },\n  crm_article_feedback: {\n    label: 'Opini\u00F3n sobre el Art\u00EDculo',\n    pluralLabel: 'Opiniones sobre Art\u00EDculos',\n    description: 'El veredicto \u00FAtil / no \u00FAtil de un lector sobre un art\u00EDculo de la base de conocimiento',\n    fields: {\n      feedback_number: { label: 'N.\u00BA de Opini\u00F3n' },\n      owner_id: { label: 'Lector' },\n      crm_knowledge_article: { label: 'Art\u00EDculo', help: 'Art\u00EDculo de la base de conocimiento al que se refiere esta opini\u00F3n.' },\n      verdict: {\n        label: 'Veredicto',\n        options: { helpful: '\u00DAtil', not_helpful: 'No \u00FAtil' },\n      },\n      comment: { label: 'Comentario', help: 'Nota opcional que explica el veredicto \u2014 la lee el autor del art\u00EDculo.' },\n    },\n    _sections: {\n      basic: { label: 'Opini\u00F3n' },\n    },\n  },\n};\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/sales/translations/es-ES/objects.activity.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/sales/translations/es-ES\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/sales/translations/es-ES/objects.activity.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport type { ObjectTranslationData } from '@objectstack/spec/system';\n\n/**\n * Espa\u00F1ol (es-ES) \u2014 `objects` translations for the ACTIVITY family:\n * the interaction log \u2014 tasks, events, and who attended.\n *\n * Roster: `crm_task`, `crm_event`, `crm_event_attendee`.\n *\n * SPLIT AXIS (#1311): translation NAMESPACE first, then CRM DOMAIN FAMILY.\n * Everything that is not `objects` lives in `./app.ts`; `objects` \u2014 69-78% of\n * every bundle \u2014 is one file per CRM domain family, and a detail object\n * follows its master. A new row goes in the file for ITS family, never in\n * whichever file is already open: that is how one file re-grows past the 70%\n * advisory band `pnpm hygiene` prints. Full rule and rationale:\n * `src/sales/translations/es-ES.ts`.\n */\nexport const activity: Record<string, ObjectTranslationData> = {\n  crm_task: {\n    _validations: {\n      completed_date_required: {\n        message: 'La fecha de finalizaci\u00F3n es obligatoria cuando el estado es Completada',\n      },\n      recurrence_fields_required: {\n        message: 'El tipo de recurrencia es obligatorio para las tareas recurrentes',\n      },\n      related_to_required: {\n        message: 'Debe seleccionarse al menos un registro relacionado',\n      },\n    },\n    label: 'Tarea',\n    pluralLabel: 'Tareas',\n    description: 'Actividades y tareas pendientes',\n    fields: {\n      subject: { label: 'Asunto' },\n      description: { label: 'Descripci\u00F3n' },\n      status: {\n        label: 'Estado',\n        options: {\n          not_started: 'No Iniciada', in_progress: 'En Curso', waiting: 'En Espera',\n          completed: 'Completada', deferred: 'Aplazada',\n        },\n      },\n      priority: {\n        label: 'Prioridad',\n        options: { low: 'Baja', normal: 'Normal', high: 'Alta', urgent: 'Urgente' },\n      },\n      priority_rank: { label: 'Rango de Prioridad' },\n      type: {\n        label: 'Tipo de Tarea',\n        options: {\n          call: 'Llamada', email: 'Email', meeting: 'Reuni\u00F3n',\n          follow_up: 'Seguimiento', demo: 'Demostraci\u00F3n', other: 'Otro',\n        },\n      },\n      due_date: { label: 'Fecha L\u00EDmite' },\n      reminder_date: { label: 'Fecha/Hora de Recordatorio' },\n      reminder_sent: { label: 'Recordatorio Enviado' },\n      completed_date: { label: 'Fecha de Finalizaci\u00F3n' },\n      owner_id: { label: 'Asignado A' },\n      // Los valores son nombres de objeto: se reutilizan las etiquetas ya\n      // traducidas de cada objeto en este mismo paquete (igual que\n      // `crm_event.related_to_type`).\n      related_to_type: {\n        label: 'Tipo de Objeto Relacionado',\n        options: {\n          crm_account: 'Cuenta', crm_contact: 'Contacto', crm_opportunity: 'Oportunidad',\n          crm_lead: 'Prospecto', crm_case: 'Caso',\n        },\n      },\n      related_to_account: { label: 'Cuenta Relacionada' },\n      related_to_contact: { label: 'Contacto Relacionado' },\n      related_to_opportunity: { label: 'Oportunidad Relacionada' },\n      related_to_lead: { label: 'Prospecto Relacionado' },\n      related_to_case: { label: 'Caso Relacionado' },\n      is_recurring: { label: 'Tarea Recurrente' },\n      recurrence_type: {\n        label: 'Tipo de Recurrencia',\n        options: { daily: 'Diaria', weekly: 'Semanal', monthly: 'Mensual', yearly: 'Anual' },\n      },\n      recurrence_interval: { label: 'Intervalo de Recurrencia' },\n      recurrence_end_date: { label: 'Fecha Fin de Recurrencia' },\n      is_completed: { label: 'Est\u00E1 Completado' },\n      is_overdue: { label: 'Est\u00E1 Vencido' },\n      progress_percent: { label: 'Progreso (%)' },\n    },\n    _views: {\n      all_tasks: { label: 'Todas las Tareas' },\n      task_board: { label: 'Tablero de Tareas' },\n      task_calendar: { label: 'Calendario de Tareas' },\n      task_gantt: { label: 'Plan de Ejecuci\u00F3n' },\n      task_timeline: { label: 'L\u00EDnea de Tiempo' },\n      my_open_tasks: { label: 'Mis Tareas Abiertas' },\n      todays_tasks: { label: '\uD83D\uDCC5 Mis Tareas Prioritarias' },\n      overdue_tasks: { label: '\u23F0 Tareas Abiertas \u00B7 M\u00E1s Vencidas Primero' },\n    },\n    _sections: {\n      basic: { label: 'Informaci\u00F3n de la Tarea' },\n      scheduling: { label: 'Programaci\u00F3n' },\n      related: { label: 'Registros Relacionados' },\n      recurrence: { label: 'Recurrencia' },\n      effort: { label: 'Progreso y Esfuerzo' },\n      system: { label: 'Sistema' },\n      // Nombres de secci\u00F3n del formulario en task.view.ts (#1100)\n      task: { label: 'Tarea' },\n      related_records: { label: 'Registros Relacionados' },\n      recurrence_and_effort: { label: 'Recurrencia y Esfuerzo' },\n    },\n  },\n  crm_event: {\n    _validations: {\n      end_after_start: {\n        message: 'La hora de fin debe ser posterior a la de inicio',\n      },\n      related_to_required: {\n        message: 'Debe seleccionarse al menos un registro relacionado',\n      },\n    },\n    label: 'Evento',\n    pluralLabel: 'Eventos',\n    description: 'Reuniones, llamadas y otras interacciones programadas con clientes',\n    fields: {\n      subject: { label: 'Asunto' },\n      description: { label: 'Descripci\u00F3n' },\n      type: {\n        label: 'Tipo de evento',\n        options: {\n          meeting: 'Reuni\u00F3n', call: 'Llamada', demo: 'Demostraci\u00F3n',\n          webinar: 'Seminario web', onsite_visit: 'Visita presencial', other: 'Otro',\n        },\n      },\n      status: {\n        label: 'Estado',\n        options: {\n          planned: 'Planificado', held: 'Realizado', cancelled: 'Cancelado', no_show: 'No asisti\u00F3',\n        },\n      },\n      owner_id: { label: 'Asignado a' },\n      start_datetime: { label: 'Inicio' },\n      end_datetime: { label: 'Fin' },\n      all_day: { label: 'Evento de todo el d\u00EDa' },\n      duration_minutes: { label: 'Duraci\u00F3n (minutos)' },\n      location: { label: 'Ubicaci\u00F3n', help: 'Sala, direcci\u00F3n o enlace de la reuni\u00F3n' },\n      related_to_type: {\n        label: 'Tipo de registro relacionado',\n        options: {\n          crm_account: 'Cuenta', crm_contact: 'Contacto', crm_opportunity: 'Oportunidad',\n          crm_lead: 'Prospecto', crm_case: 'Caso',\n        },\n      },\n      related_to_account: { label: 'Cuenta relacionada' },\n      related_to_contact: { label: 'Contacto relacionado' },\n      related_to_opportunity: { label: 'Oportunidad relacionada' },\n      related_to_lead: { label: 'Prospecto relacionado' },\n      related_to_case: { label: 'Caso relacionado' },\n      outcome_notes: { label: 'Notas de resultado', help: 'Qu\u00E9 se acord\u00F3 y qu\u00E9 sigue' },\n    },\n    _views: {\n      all_events: { label: 'Todos los eventos' },\n      event_calendar: { label: 'Calendario de eventos' },\n      event_timeline: { label: 'Agenda del equipo' },\n      my_events: { label: 'Mi calendario' },\n      upcoming_events: { label: '\uD83D\uDCC5 Pr\u00F3ximos \u00B7 M\u00E1s cercanos primero' },\n      held_events: { label: '\u2705 Historial de interacciones' },\n    },\n    _sections: {\n      basic: { label: 'Informaci\u00F3n del Evento' },\n      schedule: { label: 'Programaci\u00F3n' },\n      related: { label: 'Registros Relacionados' },\n      outcome: { label: 'Resultado' },\n      // Nombres de secci\u00F3n del formulario en event.view.ts (#1100)\n      event: { label: 'Evento' },\n      related_records: { label: 'Registros Relacionados' },\n    },\n  },\n  crm_event_attendee: {\n    _validations: {\n      attendee_resolves: {\n        message: 'Un asistente debe indicar la parte que nombra su tipo: el tipo Contacto requiere un contacto y el tipo Externo requiere un nombre de asistente externo',\n      },\n      attendee_type_exclusive: {\n        message: 'Un asistente nombra exactamente una parte: borre las columnas que su tipo de asistente no nombra',\n      },\n    },\n    label: 'Asistente al evento',\n    pluralLabel: 'Asistentes al evento',\n    description: 'Persona invitada o presente en un evento',\n    fields: {\n      attendee_number: { label: 'N\u00FAmero de asistente' },\n      crm_event: { label: 'Evento' },\n      attendee_type: {\n        label: 'Tipo de asistente',\n        options: { contact: 'Contacto', lead: 'Prospecto', user: 'Usuario', external: 'Externo' },\n      },\n      crm_contact: { label: 'Contacto', help: 'Se rellena cuando el asistente es un contacto de cliente ya existente' },\n      crm_lead: { label: 'Prospecto', help: 'Se rellena cuando el asistente sigue siendo un prospecto sin convertir' },\n      sys_user: { label: 'Usuario', help: 'Se rellena cuando el asistente es un compa\u00F1ero de la empresa' },\n      external_name: { label: 'Asistente externo', help: 'Nombre de un asistente que no est\u00E1 en ning\u00FAn objeto del CRM: se rellena cuando el tipo de asistente es Externo' },\n      response: {\n        label: 'Respuesta',\n        options: {\n          no_response: 'Sin respuesta', accepted: 'Aceptado',\n          declined: 'Rechazado', tentative: 'Tentativo',\n        },\n      },\n      is_organizer: { label: 'Organizador' },\n      invited_date: { label: 'Invitado el' },\n    },\n    _views: {\n      all_event_attendees: { label: 'Asistentes al evento' },\n    },\n    _sections: {\n      // El ingl\u00E9s es \u00ABAttendee\u00BB / \u00ABInvitation\u00BB, no el par\n      // \u00ABBasic Information\u00BB / \u00ABResponse Tracking\u00BB de crm_campaign_member.\n      basic: { label: 'Asistente' },\n      response: { label: 'Invitaci\u00F3n' },\n      // Nombres de secci\u00F3n del formulario en event_attendee.view.ts (#1100)\n      attendee: { label: 'Asistente' },\n      invitation: { label: 'Invitaci\u00F3n' },\n    },\n  },\n};\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/sales/translations/es-ES/objects.marketing.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/sales/translations/es-ES\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/sales/translations/es-ES/objects.marketing.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport type { ObjectTranslationData } from '@objectstack/spec/system';\n\n/**\n * Espa\u00F1ol (es-ES) \u2014 `objects` translations for the MARKETING family:\n * demand generation \u2014 campaigns and their membership.\n *\n * Roster: `crm_campaign`, `crm_campaign_member`.\n *\n * SPLIT AXIS (#1311): translation NAMESPACE first, then CRM DOMAIN FAMILY.\n * Everything that is not `objects` lives in `./app.ts`; `objects` \u2014 69-78% of\n * every bundle \u2014 is one file per CRM domain family, and a detail object\n * follows its master. A new row goes in the file for ITS family, never in\n * whichever file is already open: that is how one file re-grows past the 70%\n * advisory band `pnpm hygiene` prints. Full rule and rationale:\n * `src/sales/translations/es-ES.ts`.\n */\nexport const marketing: Record<string, ObjectTranslationData> = {\n  crm_campaign: {\n    _validations: {\n      end_after_start: {\n        message: 'La fecha de fin debe ser posterior a la de inicio',\n      },\n      actual_cost_within_budget: {\n        message: 'El coste real supera el coste presupuestado',\n      },\n    },\n    label: 'Campa\u00F1a',\n    pluralLabel: 'Campa\u00F1as',\n    description: 'Campa\u00F1as e iniciativas de marketing',\n    fields: {\n      campaign_code: { label: 'C\u00F3digo de Campa\u00F1a' },\n      display_title: { label: 'T\u00EDtulo Mostrado' },\n      name: { label: 'Nombre de Campa\u00F1a' },\n      description: { label: 'Descripci\u00F3n' },\n      type: {\n        label: 'Tipo de Campa\u00F1a',\n        options: {\n          email: 'Email', webinar: 'Seminario Web', trade_show: 'Feria Comercial',\n          conference: 'Conferencia', direct_mail: 'Correo Postal', social_media: 'Redes Sociales',\n          content: 'Marketing de Contenidos', partner: 'Marketing con Socios',\n        },\n      },\n      channel: {\n        label: 'Canal Principal',\n        options: {\n          digital: 'Digital', social: 'Redes Sociales', email: 'Email',\n          events: 'Eventos', partner: 'Socios',\n        },\n      },\n      status: {\n        label: 'Estado',\n        options: {\n          planning: 'Planificaci\u00F3n', in_progress: 'En Curso',\n          completed: 'Completada', aborted: 'Cancelada',\n        },\n      },\n      start_date: { label: 'Fecha de Inicio' },\n      end_date: { label: 'Fecha de Fin' },\n      budgeted_cost: { label: 'Costo Presupuestado' },\n      actual_cost: { label: 'Costo Real' },\n      expected_revenue: { label: 'Ingresos Previstos' },\n      actual_revenue: { label: 'Ingresos Reales' },\n      target_size: { label: 'Tama\u00F1o Objetivo', help: 'N\u00FAmero objetivo de prospectos/contactos' },\n      num_sent: { label: 'Cantidad Enviada' },\n      num_responses: { label: 'N\u00FAmero de Respuestas' },\n      num_leads: { label: 'N\u00FAmero de Prospectos' },\n      num_converted_leads: { label: 'Prospectos Convertidos' },\n      num_opportunities: { label: 'Oportunidades Creadas' },\n      num_won_opportunities: { label: 'Oportunidades Ganadas' },\n      response_rate: { label: 'Tasa de Respuesta %' },\n      roi: { label: 'ROI %' },\n      owner_id: { label: 'Propietario de Campa\u00F1a' },\n      landing_page_url: { label: 'P\u00E1gina de Aterrizaje' },\n      is_active: { label: 'Activo' },\n    },\n    _views: {\n      all_campaigns: { label: 'Todas las Campa\u00F1as' },\n      campaign_gantt: { label: 'Programaci\u00F3n de Campa\u00F1as' },\n      campaign_calendar: { label: 'Calendario de Campa\u00F1as' },\n      campaign_timeline: { label: 'L\u00EDnea de Tiempo de Marketing' },\n    },\n    _sections: {\n      basic: { label: 'Informaci\u00F3n de Campa\u00F1a' },\n      schedule: { label: 'Programaci\u00F3n' },\n      budget: { label: 'Presupuesto y ROI' },\n      metrics: { label: 'Rendimiento' },\n      // El ingl\u00E9s de este grupo es \u00ABOwnership\u00BB, no \u00ABAssignment\u00BB: agrupa al\n      // propietario de la campa\u00F1a, igual que `crm_account.ownership`.\n      assignment: { label: 'Propiedad' },\n      assets: { label: 'Recursos de Campa\u00F1a' },\n    },\n    _actions: {\n      enroll_leads: {\n        label: 'Inscribir Miembros',\n        successMessage: 'Miembros elegibles inscritos en la campa\u00F1a.',\n      },\n    },\n  },\n  crm_campaign_member: {\n    _validations: {\n      lead_or_contact_required: {\n        message: 'Un miembro de campa\u00F1a debe referenciar un prospecto o un contacto',\n      },\n    },\n    label: 'Miembro de Campa\u00F1a',\n    pluralLabel: 'Miembros de Campa\u00F1a',\n    description: 'Prospectos y contactos alcanzados por una campa\u00F1a, con su estado de respuesta',\n    fields: {\n      member_number: { label: 'N\u00FAmero de Miembro' },\n      crm_campaign: { label: 'Campa\u00F1a' },\n      crm_lead: { label: 'Prospecto', help: 'Se rellena cuando el miembro era un Prospecto en el momento de la inscripci\u00F3n' },\n      crm_contact: { label: 'Contacto', help: 'Se rellena cuando el miembro es un Contacto existente' },\n      status: {\n        label: 'Estado',\n        options: {\n          sent: 'Enviado', responded: 'Respondido',\n          converted: 'Convertido', unsubscribed: 'Dado de Baja',\n        },\n      },\n      added_date: { label: 'Fecha de Alta' },\n      response_date: { label: 'Fecha de Respuesta' },\n      has_responded: { label: 'Ha Respondido' },\n    },\n    _sections: {\n      basic: { label: 'Informaci\u00F3n B\u00E1sica' },\n      response: { label: 'Seguimiento de Respuesta' },\n    },\n    _actions: {\n      mark_responded: {\n        label: 'Marcar como Respondido',\n        successMessage: 'Respuesta registrada en este miembro de campa\u00F1a.',\n      },\n    },\n  },\n};\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/sales/translations/es-ES.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/sales/translations\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/sales/translations/es-ES.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport type { TranslationData } from '@objectstack/spec/system';\n\nimport { appSurface } from './es-ES/app';\nimport { customer } from './es-ES/objects.customer';\nimport { pipeline } from './es-ES/objects.pipeline';\nimport { commerce } from './es-ES/objects.commerce';\nimport { service } from './es-ES/objects.service';\nimport { activity } from './es-ES/objects.activity';\nimport { marketing } from './es-ES/objects.marketing';\n\n/**\n * Espa\u00F1ol (es-ES) \u2014 CRM App Translations\n *\n * Per-locale file: one file per language, following the `per_locale` convention.\n *\n * SPLIT AXIS (#1311): translation NAMESPACE first, then CRM DOMAIN FAMILY.\n *\n * This bundle was one file and it had reached 88.6% of the 100KB source cap\n * `pnpm hygiene` enforces, growing ~1.2KB a day. It is now assembled from\n * `./<locale>/`, on an axis measured rather than guessed:\n *\n *   - every namespace that is NOT `objects` \u2014 `apps`, `messages`,\n *     `dashboards`, `datasets`, `pages`, and any namespace `TranslationData`\n *     gains later \u2014 lives in `app.ts`. Measured: those namespaces together\n *     are under a quarter of the bundle, and the schema bounds how many can\n *     ever arrive, so one file holds them with room left;\n *   - `objects` is 69-78% of every bundle, so it is partitioned again, one\n *     file per CRM domain family \u2014 `customer`, `pipeline`, `commerce`,\n *     `service`, `activity`, `marketing` \u2014 and a DETAIL object follows its\n *     master: line items follow their quote or opportunity,\n *     `crm_event_attendee` follows `crm_event`, `crm_campaign_member`\n *     follows `crm_campaign`, `crm_article_feedback` follows\n *     `crm_knowledge_article`.\n *\n * A namespace axis ALONE was measured and rejected: it leaves `objects` at\n * 65.7KB, 3.9KB under the advisory band, which `objects` growth crosses in\n * about nine days. The family axis puts the largest part at 24.2% of the cap.\n *\n * \u26A0\uFE0F A new object translation belongs in the file for ITS family. Do not add\n * it to whichever file is already open \u2014 that is how one file re-grows past\n * the band, which is what split this bundle in the first place.\n *\n * \u26A0\uFE0F A value used by more than one family lives in `<locale>/_shared.ts`. A\n * value used by exactly one family lives in that family's file.\n *\n * \u26A0\uFE0F The key order below is LOAD-BEARING, not cosmetic. `objectstack build`\n * serialises this object into `dist/objectstack.json` in insertion order and\n * never sorts it, so listing the rows here \u2014 rather than spreading the family\n * files \u2014 is what keeps the built artifact byte-identical across the split.\n * The order is this bundle's own historical accretion order and differs\n * between locales; reordering it rewrites the artifact.\n */\nexport const esES: TranslationData = {\n  objects: {\n    crm_account: customer.crm_account,\n    crm_contact: customer.crm_contact,\n    crm_knowledge_article: service.crm_knowledge_article,\n    crm_forecast: pipeline.crm_forecast,\n    crm_lead: pipeline.crm_lead,\n    crm_opportunity: pipeline.crm_opportunity,\n    crm_case: service.crm_case,\n    crm_contract: commerce.crm_contract,\n    crm_product: commerce.crm_product,\n    crm_quote: commerce.crm_quote,\n    crm_task: activity.crm_task,\n    crm_campaign: marketing.crm_campaign,\n    crm_event: activity.crm_event,\n    crm_event_attendee: activity.crm_event_attendee,\n    crm_article_feedback: service.crm_article_feedback,\n    crm_campaign_member: marketing.crm_campaign_member,\n    crm_opportunity_line_item: pipeline.crm_opportunity_line_item,\n    crm_quote_line_item: commerce.crm_quote_line_item,\n  },\n  ...appSurface,\n};\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/sales/translations/crm.translation.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/sales/translations\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/sales/translations/crm.translation.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport type { TranslationBundle } from '@objectstack/spec/system';\nimport { en } from './en';\nimport { zhCN } from './zh-CN';\nimport { jaJP } from './ja-JP';\nimport { esES } from './es-ES';\n\n/**\n * CRM App \u2014 Internationalization (i18n)\n *\n * Demonstrates **per-locale file splitting** convention:\n * each language is defined in its own file (`en.ts`, `zh-CN.ts`, `ja-JP.ts`, `es-ES.ts`)\n * and assembled into a single `TranslationBundle` here.\n *\n * Enterprise-grade multi-language translations covering:\n * - Core CRM objects: Account, Contact, Lead, Opportunity\n * - Select-field option labels for each object\n * - App & navigation group labels\n * - Common UI messages, validation messages\n *\n * Supported locales: en, zh-CN, ja-JP, es-ES\n */\nexport const CrmTranslations: TranslationBundle = {\n  en,\n  'zh-CN': zhCN,\n  'ja-JP': jaJP,\n  'es-ES': esES,\n};\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/sales/views/index.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/sales/views\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/sales/views/index.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\n/**\n * Sales (the app package) views barrel.\n *\n * The doctrine for this metadata type is written once, in\n * `src/sales/views/index.ts`; this file is the sales package's half of\n * the same file-by-file registration.\n */\n\nexport { LeadViews } from './lead.view';\nexport { AccountViews } from './account.view';\nexport { ContactViews } from './contact.view';\nexport { OpportunityViews } from './opportunity.view';\nexport { TaskViews } from './task.view';\nexport { EventViews } from './event.view';\nexport { EventAttendeeViews } from './event_attendee.view';\nexport { ForecastViews } from './forecast.view';\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/sales/views/lead.view.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/sales/views\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/sales/views/lead.view.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport { P } from '@objectstack/spec';\nimport { defineView } from '@objectstack/spec/ui';\nimport { DUPLICATE_OF_TYPE_AUTHORABLE_OPTIONS } from '../objects/_picklists';\n\n/**\n * \u2550\u2550\u2550 HOUSE RULE: form predicates are `record.`-bound AND TOTAL \u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\n *\n * Every `visibleOn` / `visibleWhen` below is a CEL predicate the *renderer*\n * evaluates, and it must satisfy two properties. `test/view-predicate-dialect.test.ts`\n * enforces both against the compiled stack, so you do not have to remember them.\n *\n * 1. **`record.`-bound.** The evaluation context binds field values under the\n *    `record` namespace (`buildScope` in `@objectstack/formula` binds exactly\n *    `record` / `previous` / `input` / `user` / `current_user` / `ctx` / `os`).\n *    A bare field name is an unbound identifier, so it never evaluates:\n *\n *        evaluate('status == \"unqualified\"',        { record: { status: 'new' } })\n *          \u2192 ok:false  type  \"Unknown variable: status\"       \u2190 for EVERY record\n *        evaluate('record.status == \"unqualified\"', { record: { status: 'new' } })\n *          \u2192 ok:true   false\n *\n * 2. **TOTAL** \u2014 the same `has(record.x)` rule AGENTS.md states for\n *    `validations[].condition` / `requiredWhen` / `readonlyWhen` / `visibleWhen`\n *    (#630). Prefixing alone is not enough: on a *brand-new* record the key is\n *    absent, and strict CEL aborts on the read:\n *\n *        evaluate('record.duplicate_of_type == \"crm_lead\"',                { record: {} })\n *          \u2192 ok:false  \"No such key: duplicate_of_type\"\n *        evaluate('has(record.duplicate_of_type) && record.duplicate_of_type == \"crm_lead\"',\n *                                                                          { record: {} })\n *          \u2192 ok:true   false\n *\n * Why both matter here and not only in theory (#688): the console's predicate\n * evaluation **fails OPEN** \u2014 an unevaluable `visibleWhen` defaults the field to\n * *visible*, with no diagnostic \u2014 and a visible field carries its `required: true`\n * into client-side submit validation. So a predicate that cannot answer does not\n * degrade to \"shown but optional\"; it makes the form unsatisfiable. On `crm_lead`\n * this rendered all five conditional disqualification fields at once and demanded\n * a new lead be a duplicate of *both* a lead and a contact \u2014 mutually exclusive by\n * design \u2014 so no lead could be created through the UI at all. The fail-open half\n * is tracked upstream at objectstack-ai/objectstack#5149; these predicates are the\n * half this repo owns, and they must be able to answer.\n *\n * Numeric comparisons carry `!= null` on top of `has(...)`, matching the object\n * files: `has(record.rating) && record.rating != null && record.rating >= 4`.\n * Strict CEL aborts on `dyn<null> < int`, which `has()` alone does not prevent.\n */\n\n/**\n * The duplicate-link block (#598), spread into every form that offers\n * `disqualification_reason`.\n *\n * `duplicate_disqualification_requires_survivor` on `crm_lead` rejects a lead\n * closed as \"Duplicate\" that does not name the record it duplicates and confirm\n * the match. So the same rule the `disqualification_reason` field itself follows\n * applies one level down: a form that lets a user PICK \"Duplicate\" must also let\n * them satisfy it, or the save fails with an error the form gives no way to\n * clear. Declared once and reused rather than retyped eight times \u2014 the copies\n * would drift, and a form that quietly lost the block is exactly the failure\n * this shape is meant to make impossible.\n *\n * The two lookups mirror the object's `requiredWhen` predicates: each appears\n * only when `duplicate_of_type` names its object \u2014 and now says so in the same\n * words, character for character as the `requiredWhen` on those two fields in\n * `lead.object.ts`, so the form shows a lookup exactly when the server will\n * demand it. `test/view-predicate-dialect.test.ts` pins the two together.\n */\nconst DUPLICATE_LINK_FIELDS = [\n  {\n    field: 'duplicate_of_type',\n    required: true,\n    // The picker offers the AUTHORABLE half of the vocabulary only (#1164).\n    // `crm_lead.duplicate_of_type` also accepts `erased`, a tombstone\n    // `lead_duplicate_check` stamps when the engine's reference cleanup nulls\n    // the pointer \u2014 \"confirmed duplicate of a record that has since been\n    // erased\". Nobody authors that: it is an observation about a deletion that\n    // already happened, and offering it would let a reviewer close a lead as a\n    // duplicate of nothing while satisfying every rule that exists to stop\n    // exactly that. Narrowing here rather than deleting the value is the point\n    // \u2014 the record can still SAY it, and the field keeps its label in all four\n    // locales, so a tombstoned lead reads as \"Erased Record\" on the detail page\n    // instead of as a raw enum nobody can explain.\n    //\n    // Spread from `_picklists.ts` rather than retyped: the authorable set is\n    // the source both lists derive from, so a future object type added there\n    // reaches this picker automatically and the tombstone never can.\n    options: [...DUPLICATE_OF_TYPE_AUTHORABLE_OPTIONS],\n    visibleOn: P`has(record.disqualification_reason) && record.disqualification_reason == \"duplicate\"`,\n  },\n  {\n    field: 'duplicate_of_lead',\n    required: true,\n    visibleOn: P`has(record.duplicate_of_type) && record.duplicate_of_type == \"crm_lead\"`,\n  },\n  {\n    field: 'duplicate_of_contact',\n    required: true,\n    visibleOn: P`has(record.duplicate_of_type) && record.duplicate_of_type == \"crm_contact\"`,\n  },\n  {\n    field: 'duplicate_status',\n    required: true,\n    visibleOn: P`has(record.disqualification_reason) && record.disqualification_reason == \"duplicate\"`,\n    helpText: 'Confirmed means a human checked the two records and they are the same person.',\n  },\n];\n\n/**\n * Lead Views - Comprehensive UI Showcase\n * \n * This file demonstrates:\n * 1. All 6 FormView layout types (simple, tabbed, wizard, split, drawer, modal)\n * 2. Section features (collapsible, 1-4 column layouts)\n * 3. Field-level controls (readonly, required, hidden, span, visibleOn, dependsOn, custom widget)\n * 4. Multiple named formViews for different scenarios\n * 5. Various list view types\n */\nexport const LeadViews = defineView({\n  /**\n   * Default List View - Grid with Advanced Features\n   */\n  list: {\n    type: 'grid',\n    name: 'all_leads',\n    label: 'All Leads',\n    userActions: { editInline: true },\n    data: {\n      provider: 'object',\n      object: 'crm_lead',\n    },\n    \n    // Column Configuration with Enhanced Features\n    columns: [\n      {\n        // One name column, not two. Splitting first/last spent 300px to say\n        // what \"Alice Martinez\" says in one, and hung the record link off the\n        // given name alone \u2014 so opening a person meant aiming at their first\n        // name specifically.\n        field: 'full_name',\n        label: 'Name',\n        width: 200,\n        sortable: true,\n        link: true, // Primary navigation link\n      },\n      {\n        field: 'company',\n        label: 'Company',\n        width: 200,\n        sortable: true,\n      },\n      {\n        field: 'email',\n        label: 'Email',\n        width: 200,\n      },\n      {\n        field: 'status',\n        label: 'Status',\n        width: 120,\n        sortable: true,\n      },\n      {\n        field: 'rating',\n        label: 'Score',\n        width: 100,\n        align: 'center',\n      },\n      {\n        field: 'lead_source',\n        label: 'Source',\n        width: 120,\n      },\n      // REQ-0005 acceptance 1: what the prospect wants and what it is worth,\n      // on the roster a rep opens every morning. Columns are also what the\n      // list's own filter and grouping controls offer, which is what makes the\n      // two FILTERABLE and GROUPABLE here rather than only readable \u2014 the same\n      // reading `contact.view.ts` records for the buying-centre columns.\n      // `need_type` is single-valued for exactly that reason (see\n      // `_picklists.ts`): a grouped list answers with one aggregate per raw\n      // stored value, so a multi-valued column would group by the combination.\n      {\n        field: 'need_type',\n        label: 'Need Type',\n        width: 160,\n        sortable: true,\n      },\n      {\n        field: 'estimated_amount',\n        label: 'Est. Amount',\n        width: 130,\n        align: 'right',\n        sortable: true,\n      },\n      {\n        field: 'owner_id',\n        label: 'Owner',\n        width: 150,\n      },\n    ],\n    \n    sort: [\n      { field: 'created_at', order: 'desc' }\n    ],\n    \n    // A row click opens the record page. There is deliberately no\n    // `navigation.view` here: measured in the browser on console 17.3.0\n    // (#1716), the key is not resolved as a form-view name. The navigation\n    // hook reads it into the SECOND argument of `onNavigate` \u2014 the slot that\n    // otherwise carries the literal mode string, `r(t, d ?? 'view')` \u2014 so it\n    // named nothing and selected nothing. The record page here is rendered by\n    // `lead_detail_page` (`src/sales/pages/lead_detail.page.ts`), not by a named\n    // form view, and clicking a row behaved identically with the key present,\n    // with it absent, and on a list that never declared it. `detail_form`\n    // below stays: it is this file's one TABBED layout example, and it was\n    // already reachable by no path.\n    navigation: {\n      mode: 'page',\n    },\n    \n    // `convert_lead` / `schedule_followup` declare `locations: ['list_item']`\n    // and are auto-injected into the menu. Do not add strings here: the legacy\n    // rowActions surface only dispatches defined stack actions.\n    // Built-in `exportOptions` covers CSV export; no export action needed.\n    bulkActions: ['create_campaign'],\n    \n    // Features\n    pagination: { pageSize: 25, pageSizeOptions: [10, 25, 50, 100] },\n    rowHeight: 'medium',\n    exportOptions: { formats: ['csv', 'xlsx'] },\n    \n    // Empty State\n    emptyState: {\n      title: 'No Leads Yet',\n      message: 'Get started by creating your first lead',\n      icon: 'user-plus',\n    },\n  },\n  \n  /**\n   * Default Form View - SIMPLE Layout\n   * Basic sectioned form with collapsible sections and column layouts\n   */\n  form: {\n    type: 'simple',\n    \n    sections: [\n      {\n        name: 'contact_information',\n        label: 'Contact Information',\n        collapsible: true,\n        collapsed: false,\n        columns: 2, // 2-column layout\n        fields: [\n          {\n            field: 'salutation',\n          },\n          {\n            field: 'first_name',\n            required: true,\n          },\n          {\n            field: 'last_name',\n            required: true,\n            span: 'full',\n          },\n          'company',\n          'title',\n          'email',\n          'phone',\n          'mobile',\n          'website',\n        ],\n      },\n      {\n        name: 'lead_classification',\n        label: 'Lead Classification',\n        collapsible: true,\n        collapsed: false,\n        columns: 3, // 3-column layout\n        fields: [\n          {\n            field: 'status',\n            required: true,\n          },\n          {\n            field: 'rating',\n            widget: 'star_rating', // Custom widget\n          },\n          'lead_source',\n          'industry',\n          // Offered, \u26D4 not `required` (#2097): an insert that leaves it empty is\n          // stamped to the creator by the platform (see `lead.hook.ts`), so a\n          // rep's new lead is theirs without a pick, and a manager can still\n          // choose another owner. `required` blocked that save client-side.\n          'owner_id',\n          // `disqualification_reason` is enforced by the\n          // `disqualification_reason_required` validation on crm_lead, so every\n          // form that lets a user pick \"Unqualified\" must also offer the reason\n          // \u2014 otherwise the save fails with an error the form gives you no way\n          // to clear. Hidden until it applies.\n          {\n            field: 'disqualification_reason',\n            required: true,\n            visibleOn: P`has(record.status) && record.status == \"unqualified\"`,\n          },\n          // REQ-0005 step 6: \u300C\u586B\u5199\u2026\u9700\u6C42\u7C7B\u578B\u2026\u9884\u8BA1\u91D1\u989D\u300D. A rep types these at\n          // intake, so they need an authoring surface \u2014 and this form IS the\n          // create dialog (`RecordFormPage` and `useActionModal` both resolve\n          // `view.form ?? view.formViews?.default`, see `case.view.ts`).\n          //\n          // \u26A0\uFE0F Named rather than reached through a group reference, and the\n          // AGENTS.md ladder's rung 3 asks for the reason in writing. Both\n          // fields declare `group: 'qualification'` on the object, so every\n          // DERIVED surface \u2014 the page synthesizer, an auto-derived form \u2014\n          // already carries them from `fieldGroups` alone with nothing authored.\n          // This form is not one of those: it authors `sections`, and an\n          // authored `sections` array wins outright over the auto-derived path.\n          // The rung-2 fix, a `{ group: 'qualification' }` section, cannot be\n          // used HERE specifically: this section is a CURATED cross-group set,\n          // not a mirror of that group. It already names four of the group's\n          // members with per-field overrides a group reference cannot carry\n          // (`status` required, `rating`'s star widget, and\n          // `disqualification_reason`'s `required` + `visibleOn` directly\n          // above), and it borrows `industry` and `owner_id` from two other\n          // groups. Adding a group reference beside it would render those four\n          // a second time and pull in `next_followup_date` /\n          // `last_contacted_date`, which are machine-written and deliberately\n          // absent from every form. \u21D2 The customer need is real, the group\n          // reference genuinely cannot express it, and the two lines below are\n          // what that leaves.\n          'need_type',\n          'estimated_amount',\n          ...DUPLICATE_LINK_FIELDS,\n        ],\n      },\n      {\n        name: 'company_information',\n        label: 'Company Information',\n        collapsible: true,\n        collapsed: true, // Collapsed by default\n        columns: 2,\n        fields: [\n          'annual_revenue',\n          'number_of_employees',\n        ],\n      },\n      {\n        name: 'address',\n        label: 'Address',\n        collapsible: true,\n        collapsed: true,\n        columns: 2,\n        // `crm_lead` stores the location in one composite `Field.address`;\n        // the discrete street/city/state/postal_code/country columns this\n        // section used to list do not exist on the object, so the whole\n        // section rendered blank.\n        fields: [\n          {\n            field: 'address',\n            span: 'full',\n          },\n        ],\n      },\n      {\n        name: 'additional_information',\n        label: 'Additional Information',\n        collapsible: true,\n        collapsed: true,\n        columns: 1, // Single column for text areas\n        fields: [\n          'description',\n          'notes',\n        ],\n      },\n      {\n        name: 'privacy',\n        label: 'Privacy',\n        collapsible: true,\n        collapsed: true,\n        columns: 2,\n        fields: [\n          'do_not_call',\n          'email_opt_out',\n        ],\n      },\n    ],\n  },\n  \n  /**\n   * Additional Named List Views\n   */\n  listViews: {\n    // Declaration order IS tab order in the console. These three working\n    // queues used to sit AFTER the kanban / calendar / gallery views, which\n    // pushed all of them into the \"3 more\" overflow menu \u2014 so the one screen\n    // a rep opens this list for was the one they had to go hunting for, while\n    // three presentation modes held the front row.\n\n    /**\n     * My Leads \u2014 a rep's own queue, hottest first.\n     */\n    my_leads: {\n      name: 'my_leads',\n      type: 'grid',\n      label: 'My Leads',\n      userActions: { editInline: true },\n      data: {\n        provider: 'object',\n        object: 'crm_lead',\n      },\n      columns: ['full_name', 'company', 'email', 'status', 'rating'],\n      filter: [\n        { field: 'owner_id', operator: 'equals', value: '{current_user_id}' },\n      ],\n      sort: [\n        { field: 'rating', order: 'desc' },\n        { field: 'created_at', order: 'desc' }\n      ],\n    },\n\n    /**\n     * Hot Leads \u2014 the working queue for the leads routing declared HOT.\n     *\n     * \"Hot\" is defined in exactly ONE place: the `lead_assignment` flow's\n     * `check_hot` decision (edge `e2`, `record.rating >= 4`). Crossing that\n     * line is what stamps the 1-day follow-up SLA and fires the \"Hot lead \u2014\n     * assign within 24h\" alert at the owner, so this queue must hold precisely\n     * the leads that alert is about. (An earlier comment here credited a\n     * flagging workflow that has never existed in this repo \u2014 dead name\n     * removed, the routing flow is the producer.)\n     *\n     * The cut was `rating >= 4.5` (#766). `rating` is a WHOLE-star field \u2014\n     * `lead.hook.ts` rounds its computed score (\"round to WHOLE stars\"), the\n     * `star_rating` widget offers nothing finer, and the one seeded 4.5 was\n     * deleted for the same reason (#591) \u2014 so `>= 4.5` meant `== 5` on every\n     * row that can actually exist. A 4-star lead was routed hot, alerted on,\n     * and then missing from the queue its owner was sent to.\n     *\n     * Sharing the population with \"High Priority\" is the deliberate cost of\n     * having one definition of hot, not an oversight: both views now show\n     * rating >= 4, still New or Contacted. What differs is what they are FOR.\n     * Hot Leads is the work order \u2014 sorted by next-follow-up (the SLA that\n     * routing just stamped), with phone, email and owner on the row so it can\n     * be dialled top to bottom. High Priority is the scan list \u2014 score-tinted\n     * rows and lead source, no SLA column, no time ordering. A 5-star-only\n     * queue, if it is ever a real need, gets its own view under its own name\n     * instead of squatting on \"Hot\".\n     *\n     * `test/hot-lead-threshold-parity.test.ts` derives this threshold and the\n     * flow's from the metadata and fails if they drift apart again.\n     */\n    hot_leads: {\n      name: 'hot_leads',\n      type: 'grid',\n      label: '\uD83D\uDD25 Hot Leads',\n      userActions: { editInline: true },\n      data: { provider: 'object', object: 'crm_lead' },\n      columns: ['full_name', 'company', 'phone', 'email', 'rating', 'next_followup_date', 'owner_id'],\n      // Same rating cut as the `lead_assignment` hot branch, scoped to the\n      // statuses still worth working. (Operator-only filters; the view runtime\n      // does not resolve date template strings.)\n      filter: [\n        { field: 'rating', operator: 'greater_than_or_equal', value: 4 },\n        { field: 'status', operator: 'in', value: ['new', 'contacted'] },\n      ],\n      sort: [{ field: 'next_followup_date', order: 'asc' }],\n    },\n\n    /**\n     * High Priority Leads\n     */\n    high_priority: {\n      name: 'high_priority',\n      type: 'grid',\n      label: 'High Priority',\n      userActions: { editInline: true },\n      data: {\n        provider: 'object',\n        object: 'crm_lead',\n      },\n      columns: ['full_name', 'company', 'email', 'status', 'rating', 'lead_source'],\n      filter: [\n        { field: 'rating', operator: 'greater_than_or_equal', value: 4 },\n        { field: 'status', operator: 'in', value: ['new', 'contacted'] },\n      ],\n      rowColor: {\n        field: 'rating',\n        colors: {\n          '5': 'green',\n          '4': 'orange',\n        },\n      },\n    },\n\n    /**\n     * Suspected Duplicates \u2014 the review queue behind the intake flag (#598).\n     *\n     * `lead_duplicate_check` marks a re-captured email `suspected` and links it\n     * to the record it repeats. Without a place to SEE that set, the flag would\n     * be a column nobody reads: the reviewer opens this queue, compares the two\n     * records, and either clears the flag or disqualifies the lead as a\n     * confirmed duplicate. `confirmed` rows drop out of the queue, so it drains.\n     */\n    suspected_duplicates: {\n      name: 'suspected_duplicates',\n      type: 'grid',\n      label: 'Suspected Duplicates',\n      userActions: { editInline: true },\n      data: { provider: 'object', object: 'crm_lead' },\n      columns: [\n        'full_name', 'company', 'email',\n        'duplicate_of_type', 'duplicate_of_lead', 'duplicate_of_contact',\n        'status', 'owner_id',\n      ],\n      filter: [\n        { field: 'duplicate_status', operator: 'equals', value: 'suspected' },\n      ],\n      // Oldest suspicion first: an unreviewed duplicate is a second rep working\n      // the same person, so the queue is worked front to back.\n      sort: [{ field: 'created_at', order: 'asc' }],\n      emptyState: {\n        title: 'No Suspected Duplicates',\n        message: 'Nothing to review \u2014 every re-captured email has been checked.',\n        icon: 'copy',\n      },\n    },\n\n    /**\n     * Kanban Board View\n     */\n    kanban_by_status: {\n      name: 'kanban_by_status',\n      type: 'kanban',\n      label: 'Lead Pipeline',\n      data: {\n        provider: 'object',\n        object: 'crm_lead',\n      },\n      columns: ['first_name', 'last_name', 'company', 'email'],\n      kanban: {\n        groupByField: 'status',\n        summarizeField: 'annual_revenue',\n        columns: ['first_name', 'last_name', 'company', 'rating'],\n      },\n      navigation: {\n        mode: 'drawer', // Open in drawer instead of new page\n        width: '600px',\n      },\n    },\n    \n    /**\n     * Calendar View\n     */\n    calendar_by_created: {\n      name: 'calendar_by_created',\n      type: 'calendar',\n      label: 'Lead Calendar',\n      data: {\n        provider: 'object',\n        object: 'crm_lead',\n      },\n      columns: ['first_name', 'last_name', 'company'],\n      calendar: {\n        startDateField: 'created_at',\n        titleField: 'company',\n        colorField: 'status',\n      },\n    },\n    \n    /**\n     * Gallery/Card View\n     */\n    gallery_view: {\n      name: 'gallery_view',\n      type: 'gallery',\n      label: 'Lead Cards',\n      data: {\n        provider: 'object',\n        object: 'crm_lead',\n      },\n      columns: ['first_name', 'last_name', 'company', 'email', 'status'],\n      gallery: {\n        cardSize: 'medium',\n        titleField: 'company',\n        visibleFields: ['first_name', 'last_name', 'email', 'phone', 'status', 'rating'],\n      },\n    },\n    \n  },\n\n  /**\n   * Additional Named Form Views - Demonstrating All 6 Layout Types\n   *\n   * One example per layout type. The SIMPLE one is the default `form`\n   * above, so this block carries the other five, plus the public and the\n   * conditional-visibility examples. Every layout is demonstrated exactly\n   * once across the file: each entry below is the only example of its own.\n   */\n  formViews: {\n    /**\n     * 2. TABBED Layout\n     * Organize complex forms with tabs\n     */\n    detail_form: {\n      type: 'tabbed',\n      sections: [\n        {\n          name: 'general',\n          label: 'General',\n          columns: 2,\n          fields: [\n            'salutation',\n            'first_name',\n            'last_name',\n            'company',\n            'title',\n            'email',\n            'phone',\n            'mobile',\n          ],\n        },\n        {\n          name: 'qualification',\n          label: 'Qualification',\n          columns: 2,\n          fields: [\n            { field: 'status', required: true },\n            { field: 'rating', widget: 'star_rating' },\n            'lead_source',\n            'industry',\n            'annual_revenue',\n            'number_of_employees',\n            // See the default form: `unqualified` requires a reason.\n            {\n              field: 'disqualification_reason',\n              required: true,\n              visibleOn: P`has(record.status) && record.status == \"unqualified\"`,\n            },\n            ...DUPLICATE_LINK_FIELDS,\n          ],\n        },\n        {\n          name: 'address',\n          label: 'Address',\n          columns: 2,\n          // Single composite `Field.address` \u2014 see the note on the default\n          // form's Address section.\n          fields: [\n            { field: 'address', span: 'full' },\n          ],\n        },\n        {\n          name: 'details',\n          label: 'Details',\n          columns: 1,\n          fields: [\n            'description',\n            'notes',\n            'do_not_call',\n            'email_opt_out',\n          ],\n        },\n      ],\n    },\n    \n    /**\n     * 3. WIZARD Layout\n     * Step-by-step guided process\n     */\n    lead_conversion_wizard: {\n      type: 'wizard',\n      data: {\n        provider: 'object',\n        object: 'crm_lead',\n      },\n      sections: [\n        {\n          name: 'step_1_contact_details',\n          label: 'Step 1: Contact Details',\n          columns: 2,\n          fields: [\n            { field: 'first_name', required: true, readonly: true },\n            { field: 'last_name', required: true, readonly: true },\n            { field: 'email', readonly: true, span: 'full' },\n            'phone',\n            'mobile',\n          ],\n        },\n        {\n          name: 'step_2_company_information',\n          label: 'Step 2: Company Information',\n          columns: 2,\n          fields: [\n            { field: 'company', required: true, readonly: true },\n            'title',\n            'industry',\n            'annual_revenue',\n            'number_of_employees',\n            'website',\n          ],\n        },\n        {\n          name: 'step_3_qualification',\n          label: 'Step 3: Qualification',\n          columns: 2,\n          fields: [\n            { field: 'status', required: true },\n            // See the default form: `unqualified` requires a reason. The status\n            // is editable in this step, so the wizard can land there too.\n            {\n              field: 'disqualification_reason',\n              required: true,\n              visibleOn: P`has(record.status) && record.status == \"unqualified\"`,\n            },\n            ...DUPLICATE_LINK_FIELDS,\n            { field: 'rating', widget: 'star_rating' },\n            'lead_source',\n            {\n              field: 'owner_id',\n              // Conditional visibility. `!= null` on top of `has(...)`: strict\n              // CEL aborts on `dyn<null> < int`, which `has()` alone allows.\n              visibleOn: P`has(record.rating) && record.rating != null && record.rating >= 4`,\n            },\n          ],\n        },\n        {\n          name: 'step_4_review_and_convert',\n          label: 'Step 4: Review & Convert',\n          columns: 1,\n          fields: [\n            {\n              field: 'description',\n              helpText: 'Review all information before converting to Account and Contact',\n            },\n          ],\n        },\n      ],\n    },\n    \n    /**\n     * 4. SPLIT Layout\n     * Master-detail split view\n     */\n    split_edit: {\n      type: 'split',\n      data: {\n        provider: 'object',\n        object: 'crm_lead',\n      },\n      sections: [\n        {\n          name: 'primary_information',\n          label: 'Primary Information',\n          columns: 1,\n          fields: [\n            'first_name',\n            'last_name',\n            'company',\n            'email',\n            { field: 'status', required: true },\n            'owner_id',\n            // See the default form: `unqualified` requires a reason.\n            {\n              field: 'disqualification_reason',\n              required: true,\n              visibleOn: P`has(record.status) && record.status == \"unqualified\"`,\n            },\n            ...DUPLICATE_LINK_FIELDS,\n          ],\n        },\n        {\n          name: 'extended_details',\n          label: 'Extended Details',\n          columns: 2,\n          fields: [\n            'phone',\n            'mobile',\n            'title',\n            'industry',\n            'lead_source',\n            { field: 'rating', widget: 'star_rating' },\n            'annual_revenue',\n            'number_of_employees',\n          ],\n        },\n      ],\n    },\n    \n    /**\n     * 5. DRAWER Layout\n     * Side panel form (typically opened from list view)\n     */\n    quick_edit_drawer: {\n      type: 'drawer',\n      data: {\n        provider: 'object',\n        object: 'crm_lead',\n      },\n      sections: [\n        {\n          name: 'quick_edit',\n          label: 'Quick Edit',\n          columns: 1, // Drawers typically use single column\n          fields: [\n            { field: 'first_name', required: true },\n            { field: 'last_name', required: true },\n            'company',\n            'email',\n            'phone',\n            { field: 'status', required: true },\n            { field: 'rating', widget: 'star_rating' },\n            'lead_source',\n            {\n              field: 'owner_id',\n              // Only show owner after initial contact. A record with no status\n              // yet has not been contacted, so `!isBlank` keeps the blank case\n              // on the \"hidden\" side rather than letting `null != \"new\"` show it.\n              visibleOn: P`has(record.status) && !isBlank(record.status) && record.status != \"new\"`,\n            },\n            // See the default form: `unqualified` requires a reason.\n            {\n              field: 'disqualification_reason',\n              required: true,\n              visibleOn: P`has(record.status) && record.status == \"unqualified\"`,\n            },\n            ...DUPLICATE_LINK_FIELDS,\n          ],\n        },\n      ],\n    },\n    \n    /**\n     * 6. MODAL Layout\n     * Dialog-based form for quick actions\n     */\n    status_update_modal: {\n      type: 'modal',\n      data: {\n        provider: 'object',\n        object: 'crm_lead',\n      },\n      sections: [\n        {\n          name: 'update_lead_status',\n          label: 'Update Lead Status',\n          columns: 1,\n          fields: [\n            { field: 'first_name', readonly: true },\n            { field: 'last_name', readonly: true },\n            { field: 'company', readonly: true },\n            { \n              field: 'status', \n              required: true,\n              helpText: 'Select the new status for this lead',\n            },\n            {\n              field: 'rating',\n              widget: 'star_rating',\n              // Only show rating for qualified leads\n              visibleOn: P`has(record.status) && record.status == \"qualified\"`,\n            },\n            // The reason picklist, not just free-text notes: it is what the\n            // `disqualification_reason_required` validation checks, and this\n            // modal is the main place a rep flips a lead to Unqualified.\n            {\n              field: 'disqualification_reason',\n              required: true,\n              visibleOn: P`has(record.status) && record.status == \"unqualified\"`,\n            },\n            ...DUPLICATE_LINK_FIELDS,\n            {\n              field: 'notes',\n              placeholder: 'Add notes about this status change',\n              // Free-text context alongside the reason\n              visibleOn: P`has(record.status) && record.status == \"unqualified\"`,\n            },\n          ],\n        },\n      ],\n    },\n    \n    /**\n     * 7. PUBLIC / ANONYMOUS \u2014 \"Web-to-Lead\"\n     *\n     * Airtable-style public form hosted at `/forms/contact-us`. Embeddable\n     * via iframe on a marketing site. Guests can ONLY submit (insert) \u2014 the\n     * `guest_portal` profile denies read/edit/delete on `crm_lead`.\n     *\n     * Fields not on the form (status, lead_source, owner_id, rating) are stamped\n     * by the `lead_automation` hook in `lead.hook.ts` after a guest submission.\n     */\n    web_to_lead: {\n      type: 'simple',\n      data: {\n        provider: 'object',\n        object: 'crm_lead',\n      },\n      sections: [\n        {\n          name: 'tell_us_about_yourself',\n          label: 'Tell us about yourself',\n          columns: 2,\n          fields: [\n            { field: 'first_name', required: true },\n            { field: 'last_name',  required: true },\n            { field: 'email',      required: true, span: 'full' },\n            'phone',\n            'title',\n          ],\n        },\n        {\n          name: 'about_your_company',\n          label: 'About your company',\n          columns: 2,\n          fields: [\n            { field: 'company', required: true, span: 'full' },\n            'website',\n            'industry',\n            'number_of_employees',\n            'annual_revenue',\n          ],\n        },\n        {\n          name: 'how_can_we_help',\n          label: 'How can we help?',\n          columns: 1,\n          fields: [\n            {\n              field: 'description',\n              required: true,\n              placeholder: 'Briefly describe what you are looking for...',\n              helpText: 'A sales representative will get back to you within one business day.',\n            },\n          ],\n        },\n      ],\n      sharing: {\n        enabled: true,\n        allowAnonymous: true,\n        publicLink: '/forms/contact-us',\n      },\n    },\n\n    /**\n     * Advanced Example: Conditional Field Visibility & Dependencies\n     */\n    advanced_conditional: {\n      type: 'simple',\n      data: {\n        provider: 'object',\n        object: 'crm_lead',\n      },\n      sections: [\n        {\n          name: 'lead_information',\n          label: 'Lead Information',\n          columns: 2,\n          fields: [\n            'first_name',\n            'last_name',\n            'company',\n            'email',\n            'status',\n            'lead_source',\n            {\n              field: 'rating',\n              widget: 'star_rating',\n              // Only show after first contact \u2014 see the drawer form's note on\n              // why blank stays on the \"hidden\" side.\n              visibleOn: P`has(record.status) && !isBlank(record.status) && record.status != \"new\"`,\n            },\n            {\n              field: 'industry',\n              dependsOn: 'company', // Industry options depend on company\n            },\n            {\n              field: 'annual_revenue',\n              // Only for qualified leads\n              visibleOn: P`has(record.rating) && record.rating != null && record.rating >= 3`,\n            },\n            {\n              field: 'number_of_employees',\n              visibleOn: P`has(record.rating) && record.rating != null && record.rating >= 3`,\n            },\n            {\n              field: 'owner_id',\n              required: true,\n              visibleOn: P`has(record.status) && (record.status == \"contacted\" || record.status == \"qualified\")`,\n            },\n            // See the default form: `unqualified` requires a reason.\n            {\n              field: 'disqualification_reason',\n              required: true,\n              visibleOn: P`has(record.status) && record.status == \"unqualified\"`,\n            },\n            ...DUPLICATE_LINK_FIELDS,\n            {\n              field: 'notes',\n              span: 'full',\n              required: true,\n              // Require explanation for unqualified\n              visibleOn: P`has(record.status) && record.status == \"unqualified\"`,\n            },\n          ],\n        },\n        {\n          name: 'address_information',\n          label: 'Address Information',\n          collapsible: true,\n          collapsed: true,\n          columns: 2,\n          // Single composite `Field.address` \u2014 the discrete street/city/state/\n          // postal_code/country columns do not exist on crm_lead.\n          fields: [\n            { field: 'address', span: 'full' },\n          ],\n        },\n        {\n          name: 'privacy_preferences',\n          label: 'Privacy Preferences',\n          collapsible: true,\n          collapsed: true,\n          columns: 2,\n          fields: [\n            {\n              field: 'do_not_call',\n              helpText: 'Check if this lead has requested not to be called',\n            },\n            {\n              field: 'email_opt_out',\n              helpText: 'Check if this lead has opted out of email communications',\n            },\n          ],\n        },\n      ],\n    },\n  },\n});\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/sales/views/account.view.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/sales/views\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/sales/views/account.view.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport { defineView } from '@objectstack/spec/ui';\n\n/**\n * Account Views\n *\n *   \u2022 grid    \u2014 primary list with revenue / industry summaries\n *   \u2022 gallery \u2014 branded account cards with brand_color highlights\n *   \u2022 map     \u2014 geospatial distribution (uses office_location)\n */\nexport const AccountViews = defineView({\n  list: {\n    type: 'grid',\n    name: 'all_accounts',\n    label: 'All Accounts',\n    userActions: { editInline: true },\n    data: { provider: 'object', object: 'crm_account' },\n    columns: [\n      { field: 'name', width: 240, sortable: true, link: true, pinned: 'left' },\n      { field: 'industry', width: 140, sortable: true },\n      { field: 'type', width: 130 },\n      { field: 'annual_revenue', width: 160, align: 'right', summary: 'sum' },\n      { field: 'number_of_employees', width: 130, align: 'right', summary: 'avg' },\n      { field: 'health_score', width: 140 },\n    ],\n    sort: [{ field: 'annual_revenue', order: 'desc' }],\n    rowColor: { field: 'is_active', colors: { true: 'green', false: 'slate' } },\n    selection: { type: 'multiple' },\n    pagination: { pageSize: 50, pageSizeOptions: [25, 50, 100] },\n    exportOptions: { formats: ['csv', 'xlsx'] },\n    compactToolbar: true,\n    bulkActionDefs: [\n      {\n        name: 'update_tier',\n        label: 'Update Tier',\n        icon: 'tag',\n        operation: 'update',\n        params: [\n          {\n            name: 'tier',\n            label: 'Customer Tier',\n            type: 'select',\n            required: true,\n            options: [\n              { label: 'Strategic',  value: 'strategic'  },\n              { label: 'Enterprise', value: 'enterprise' },\n              { label: 'Mid-Market', value: 'mid_market' },\n              { label: 'SMB',        value: 'smb'        },\n            ],\n          },\n        ],\n        confirmText: 'Update tier on {{count}} account(s) to {{tier}}?',\n      },\n      {\n        name: 'transfer_owner',\n        label: 'Transfer Owner',\n        icon: 'user-check',\n        operation: 'update',\n        params: [\n          {\n            name: 'owner_id',\n            label: 'New Owner',\n            type: 'lookup',\n            // The platform registers `sys_user` \u2014 `user` matches no object and\n            // rendered an empty picker.\n            object: 'sys_user',\n            required: true,\n          },\n        ],\n        confirmText: 'Transfer ownership of {{count}} account(s)?',\n      },\n      {\n        name: 'delete',\n        label: 'Delete',\n        icon: 'trash-2',\n        variant: 'danger',\n        operation: 'delete',\n        confirmText: 'Permanently delete {{count}} account(s)? This cannot be undone.',\n        confirmLabel: 'Delete',\n      },\n    ],\n    appearance: {\n      showDescription: true,\n      allowedVisualizations: ['grid', 'gallery', 'map'],\n    },\n  },\n\n  listViews: {\n    /** Branded account cards */\n    account_gallery: {\n      name: 'account_gallery',\n      type: 'gallery',\n      label: 'Account Cards',\n      data: { provider: 'object', object: 'crm_account' },\n      // `logo` rides in the projection for the same reason the timeline view\n      // carries its date fields: the list data source projects the configured\n      // columns, and `coverField` reads off that projection.\n      columns: ['name', 'industry', 'annual_revenue', 'phone', 'logo'],\n      gallery: {\n        // The card art this view was named for. \"Branded account cards\" had a\n        // brand COLOUR and no brand IMAGE \u2014 `crm_account.logo` is the object's\n        // only image field and nothing displayed it, so every card drew the\n        // same blank cover. `coverFit` is left unstated: the schema's default\n        // is the crop these cards want, and materialising a default rewrites\n        // \"the author said nothing\" into \"the author asked for this\".\n        coverField: 'logo',\n        cardSize: 'medium',\n        titleField: 'name',\n        visibleFields: ['industry', 'annual_revenue', 'number_of_employees', 'phone', 'website', 'owner_id'],\n      },\n    },\n\n    /**\n     * Geospatial distribution.\n     *\n     * The `map` block is what BINDS the view to a coordinate source. Without it\n     * the renderer falls back to literal default field names, which resolve on\n     * `crm_account` only by luck \u2014 the view draws no marker while authoring\n     * reports success (`view/layout-without-binding`). `office_location` is the\n     * object's `Field.location(...)`, which is the one field on `crm_account`\n     * carrying coordinates; `billing_address` is an `address` field and is a\n     * postal shape, not a coordinate one, so it stays a column rather than the\n     * binding. `titleField` names the marker label \u2014 `name`, not the object's\n     * `nameField` (`display_title`), because the map's own `columns` show\n     * `name` and the two should agree.\n     */\n    account_map: {\n      name: 'account_map',\n      type: 'map',\n      label: 'Accounts by Location',\n      data: { provider: 'object', object: 'crm_account' },\n      columns: ['name', 'industry', 'office_location', 'billing_address'],\n      map: { locationField: 'office_location', titleField: 'name' },\n    },\n\n    /** Tier accounts: Enterprise (>= $10M ARR) */\n    enterprise_accounts: {\n      name: 'enterprise_accounts',\n      type: 'grid',\n      label: 'Enterprise Accounts',\n      userActions: { editInline: true },\n      data: { provider: 'object', object: 'crm_account' },\n      columns: ['name', 'industry', 'annual_revenue', 'number_of_employees', 'owner_id'],\n      filter: [{ field: 'annual_revenue', operator: 'greater_than_or_equal', value: 10000000 }],\n      sort: [{ field: 'annual_revenue', order: 'desc' }],\n\n      // ADR-0047 end-user quick filters (Airtable \"User filters\", Elements:\n      // dropdowns). `element: 'dropdown'`, deliberately \u2014 on an object list\n      // the view SWITCHER owns the tab bar (it builds one entry per `list` /\n      // `listViews` descriptor), so a quick-filter block shaped as tabs is\n      // dropped there: the console logs `defines userFilters (element:\n      // \"tabs\"), which are ignored on an object list view (ADR-0047 \"views\"\n      // mode \u2014 the view switcher owns the tab bar here)` and renders nothing.\n      // Dropdowns sit beside the switcher and are unaffected.\n      // `owner_id` is the platform ownership lookup (#548) \u2014 it renders as a\n      // record-picker dropdown.\n      // NOTE: requires @objectstack/spec > 9.2.0 (ADR-0047 UserFiltersSchema);\n      // on older specs defineStack strips this block \u2014 harmless no-op.\n      ...({\n        userFilters: {\n          element: 'dropdown',\n          fields: [\n            { field: 'industry', showCount: true },\n            { field: 'type' },\n            { field: 'owner_id' },\n          ],\n        },\n        // typed via spread-as-any until @objectstack/spec ships ADR-0047\n        // (UserFiltersSchema is in framework main, > 9.2.0)\n      } as any),\n    },\n\n    my_accounts: {\n      name: 'my_accounts',\n      type: 'grid',\n      label: 'My Accounts',\n      userActions: { editInline: true },\n      data: { provider: 'object', object: 'crm_account' },\n      columns: ['name', 'industry', 'annual_revenue', 'phone', 'last_activity_date'],\n      filter: [{ field: 'owner_id', operator: 'equals', value: '{current_user_id}' }],\n      sort: [{ field: 'last_activity_date', order: 'desc' }],\n    },\n\n    // The `renewals_due` view is gone with the fields it was built on (#1181):\n    // both its `is_not_null` filter and its sort key were\n    // `crm_account.next_renewal_date`, so the view could not outlive the field.\n    // Nothing is lost \u2014 `crm_contract` ships the renewals queue that the daily\n    // sweep actually acts on (`renewal_calendar`, over `end_date`).\n\n    /** At-risk customers \u2014 CSM action queue */\n    at_risk_accounts: {\n      name: 'at_risk_accounts',\n      type: 'grid',\n      label: '\u26A0\uFE0F At-Risk Accounts',\n      userActions: { editInline: true },\n      data: { provider: 'object', object: 'crm_account' },\n      columns: ['name', 'tier', 'health_score', 'segment', 'last_activity_date'],\n      filter: [\n        { field: 'type', operator: 'equals', value: 'customer' },\n        { field: 'health_score', operator: 'in', value: ['at_risk', 'churning'] },\n      ],\n      sort: [{ field: 'health_score', order: 'desc' }],\n    },\n  },\n\n  form: {\n    type: 'tabbed',\n    sections: [\n      {\n        name: 'profile',\n        label: 'Profile',\n        columns: 2,\n        fields: [\n          { field: 'name', required: true, span: 'full' },\n          'account_number',\n          // `type` (prospect / customer / partner \u2026) drives the Renewals and\n          // At-Risk views' `type = customer` filter \u2014 with no form field it\n          // could never be set, so those views matched nothing.\n          'type',\n          'industry',\n          'phone',\n          'website',\n          'owner_id',\n          'parent_account',\n          'is_active',\n          'brand_color',\n          // The other half of the `branding` group. Without a form field there\n          // is no upload control anywhere in the app, so the logo the gallery\n          // cards now cover with could never have been set. Full span: an\n          // image drop target in a half-width cell is a thumbnail-sized one.\n          { field: 'logo', span: 'full' },\n        ],\n      },\n      {\n        // `child_account_revenue` is a roll-up the engine maintains, so it is\n        // read-only on the form by construction \u2014 it is here because a hierarchy\n        // nobody can see the effect of is the decoration this field replaced.\n        name: 'financials',\n        label: 'Financials',\n        columns: 2,\n        fields: ['annual_revenue', 'number_of_employees', 'child_account_revenue'],\n      },\n      {\n        // The customer-success fields the at_risk_accounts view lists and\n        // filters on. They existed on the object but no form offered them, so\n        // the CS working queue stayed permanently empty. (`renewal_owner` and\n        // `next_renewal_date` were removed from this section with the fields\n        // themselves \u2014 #1181.)\n        name: 'customer_success',\n        label: 'Customer Success',\n        columns: 2,\n        fields: ['tier', 'segment', 'health_score'],\n      },\n      {\n        name: 'locations',\n        label: 'Locations',\n        columns: 1,\n        // `billing_country` and `territory` are readonly and derived, but both\n        // are on the form on purpose: an admin asking \"why does the NA team not\n        // see this account?\" reads the answer off the record instead of\n        // guessing at the address blob (#621). `territory` is what the rules\n        // actually match (#639) and `billing_country` is the input it was\n        // classified from, so the two together show the whole derivation \u2014\n        // including the case the picklist alone cannot explain, an account\n        // sitting in `Other` because its country was typed in a spelling the\n        // mapping does not know.\n        fields: ['billing_address', 'billing_country', 'territory', 'office_location'],\n      },\n      {\n        name: 'description',\n        label: 'Description',\n        columns: 1,\n        fields: ['description'],\n      },\n    ],\n  },\n});\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/sales/views/contact.view.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/sales/views\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/sales/views/contact.view.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport { defineView } from '@objectstack/spec/ui';\n\n/**\n * Contact Views\n *\n *   \u2022 grid    \u2014 primary roster with avatar\n *   \u2022 gallery \u2014 people directory cards (avatar as cover)\n */\nexport const ContactViews = defineView({\n  list: {\n    type: 'grid',\n    name: 'all_contacts',\n    label: 'All Contacts',\n    userActions: { editInline: true },\n    data: { provider: 'object', object: 'crm_contact' },\n    columns: [\n      { field: 'avatar', width: 64, align: 'center' },\n      { field: 'first_name', width: 140, sortable: true, link: true },\n      { field: 'last_name', width: 140, sortable: true },\n      { field: 'crm_account', width: 200 },\n      { field: 'title', width: 180 },\n      { field: 'department', width: 140 },\n      // REQ-0004 acceptance 2: the three buying-centre attributes are columns\n      // on the landing roster, which is already grouped by account with the\n      // groups collapsed \u2014 so expanding one account reads as a MAP (who\n      // decides, who is on our side) instead of a directory. Columns are also\n      // what the list's own filter and grouping controls offer.\n      { field: 'buying_function', width: 160 },\n      { field: 'attitude', width: 140 },\n      { field: 'relationship_strength', width: 180 },\n      { field: 'email', width: 220 },\n      { field: 'phone', width: 150 },\n      { field: 'owner_id', width: 150 },\n    ],\n    sort: [{ field: 'last_name', order: 'asc' }],\n    grouping: { fields: [{ field: 'crm_account', order: 'asc', collapsed: true }] },\n    selection: { type: 'multiple' },\n    // The selection-bar entry point for campaigning at existing customers\n    // (#597), mirroring `bulkActions: ['create_campaign']` on the lead grid.\n    // The bare-string form fans the action out once per selected row; do not\n    // add strings for `mark_primary` / `send_email`, which declare\n    // `locations: ['list_item']` and are auto-injected into the row menu.\n    bulkActions: ['add_contact_to_campaign'],\n    pagination: { pageSize: 50, pageSizeOptions: [25, 50, 100] },\n    exportOptions: { formats: ['csv', 'xlsx'] },\n    appearance: {\n      showDescription: true,\n      allowedVisualizations: ['grid', 'gallery'],\n    },\n  },\n\n  listViews: {\n    /** People directory */\n    contact_directory: {\n      name: 'contact_directory',\n      type: 'gallery',\n      label: 'People Directory',\n      data: { provider: 'object', object: 'crm_contact' },\n      columns: ['first_name', 'last_name', 'title', 'email'],\n      gallery: {\n        coverField: 'avatar',\n        coverFit: 'cover',\n        cardSize: 'small',\n        titleField: 'last_name',\n        visibleFields: ['first_name', 'title', 'department', 'email', 'phone', 'crm_account'],\n      },\n    },\n\n    primary_contacts: {\n      name: 'primary_contacts',\n      type: 'grid',\n      label: 'Primary Contacts',\n      userActions: { editInline: true },\n      data: { provider: 'object', object: 'crm_contact' },\n      columns: ['first_name', 'last_name', 'crm_account', 'title', 'email', 'phone'],\n      filter: [{ field: 'is_primary', operator: 'equals', value: true }],\n      sort: [{ field: 'crm_account', order: 'asc' }],\n    },\n  },\n\n  form: {\n    type: 'tabbed',\n    sections: [\n      {\n        name: 'identity',\n        label: 'Identity',\n        columns: 2,\n        fields: [\n          'salutation',\n          { field: 'first_name', required: true },\n          { field: 'last_name', required: true, span: 'full' },\n          { field: 'crm_account', required: true },\n          'title',\n          'department',\n          'owner_id',\n        ],\n      },\n      {\n        // REQ-0004 acceptance 1: the buying-centre group is rendered FROM\n        // `fieldGroups`, with no per-field enumeration authored anywhere.\n        //\n        // This form authors `sections`, and an authored `sections` array wins\n        // outright over the renderer's `fieldGroups` auto-derivation (the\n        // mechanism is written up at length in `case.view.ts`), so a group\n        // declared on the object alone would reach the SYNTHESIZED detail\n        // page and never this form \u2014 which is also the create dialog. The\n        // group-reference form is rung 2 of the AGENTS.md ladder, for exactly\n        // this \"partial arrangement is genuinely needed\" case: `group:`\n        // inherits the object's `buying_centre` members (every field pointing\n        // at it, in declaration order) and its presentation, so adding a\n        // fourth attribute to the group later reaches this form by itself.\n        //\n        // \u26D4 `group:` is mutually exclusive with `fields:` and with every key\n        // the group itself declares (`name`, `label`, `description`,\n        // `visibleWhen`, `collapsible`/`collapsed: true`) \u2014 `columns` is not\n        // one of those, because the group declares nothing about layout.\n        group: 'buying_centre',\n        columns: 2,\n      },\n      {\n        // Named `contact_details`, not `contact_info` \u2014 `contact_info` is\n        // already a distinct fieldGroup key on `crm_contact` (\"Contact\n        // Information\"), and reusing it here would make this section's\n        // translated heading follow that group's wording instead of its own\n        // \"Contact Info\".\n        name: 'contact_details',\n        label: 'Contact Info',\n        columns: 2,\n        fields: ['email', 'phone', 'mobile', 'avatar'],\n      },\n      {\n        // Named `mailing_address` \u2014 deliberately the SAME key as the\n        // `mailing_address` fieldGroup on `crm_contact`, which is the opposite\n        // call from the two sections either side of it and for the same\n        // reason. Reusing a group key makes the section's translated heading\n        // follow that group's wording; `contact_details` and\n        // `comm_preferences` wanted their own shorter wording, so they had to\n        // avoid the collision. This section wants exactly the group's wording\n        // (\"Mailing Address\"), which every locale already carries under\n        // `objects.crm_contact._sections.mailing_address`, so the collision is\n        // the feature: one heading, one translation, four locales, no new row.\n        //\n        // Why the section exists at all: an authored `sections` array wins\n        // outright over the renderer's `fieldGroups` auto-derivation (the\n        // mechanism is written up at length in `case.view.ts`), and this form\n        // is also the CREATE dialog. Without this section the address was\n        // readable on the SYNTHESIZED detail page \u2014 which does derive from\n        // `fieldGroups` \u2014 while no form in the app could enter or edit it,\n        // even though `contact_import.mapping.ts` writes it from the shipped\n        // CSV template. This tab is the authoring half of the import path.\n        name: 'mailing_address',\n        label: 'Mailing Address',\n        columns: 2,\n        fields: [\n          // One structured `address` field; full width, so its parts lay out\n          // as a unit rather than in half a grid column.\n          { field: 'mailing_address', span: 'full' },\n        ],\n      },\n      {\n        // Named `comm_preferences`, not `preferences` \u2014 `preferences` is\n        // already a distinct fieldGroup key on `crm_contact` (\"Communication\n        // Preferences\"), and reusing it here would make this section's\n        // translated heading follow that group's wording instead of its own\n        // \"Preferences\".\n        name: 'comm_preferences',\n        label: 'Preferences',\n        columns: 2,\n        fields: ['lead_source', 'is_primary', 'do_not_call', 'email_opt_out'],\n      },\n    ],\n  },\n});\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/sales/views/opportunity.view.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/sales/views\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/sales/views/opportunity.view.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport { defineView } from '@objectstack/spec/ui';\n\n/**\n * Opportunity Views\n *\n * Sales pipeline benefits from multiple visualisations:\n *   \u2022 grid     \u2014 full pipeline browsing & inline edits\n *   \u2022 kanban   \u2014 drag-and-drop pipeline stage management (group by stage)\n *   \u2022 calendar \u2014 close-date forecasting on a monthly view\n *   \u2022 timeline \u2014 chronological deal flow grouped by owner\n *   \u2022 gallery  \u2014 pinboard / executive review cards\n */\nexport const OpportunityViews = defineView({\n  // The landing view is OPEN deals, not every deal ever recorded.\n  //\n  // Sorted by close_date ascending and unfiltered, \"All Opportunities\" opened\n  // on settled history: the first screen was 7 closed-won and 4 closed-lost\n  // records, and a rep had to scroll past months of finished business to reach\n  // anything they could still act on. The full unfiltered list is still one\n  // click away on the \"All Opportunities\" tab.\n  list: {\n    type: 'grid',\n    name: 'open_opportunities',\n    label: 'Open Deals',\n    userActions: { editInline: true },\n    data: { provider: 'object', object: 'crm_opportunity' },\n    filter: [\n      { field: 'stage', operator: 'not_in', value: ['closed_won', 'closed_lost'] },\n    ],\n    columns: [\n      { field: 'name', width: 220, sortable: true, link: true },\n      { field: 'crm_account', label: 'Account', width: 180 },\n      { field: 'stage', width: 140, sortable: true },\n      { field: 'amount', width: 140, align: 'right', sortable: true, summary: 'sum' },\n      { field: 'probability', width: 110, align: 'right' },\n      { field: 'expected_revenue', width: 160, align: 'right', summary: 'sum' },\n      { field: 'close_date', width: 140, sortable: true },\n    ],\n    sort: [{ field: 'close_date', order: 'asc' }],\n    rowColor: {\n      field: 'stage',\n      colors: {\n        prospecting: 'slate',\n        qualification: 'sky',\n        // Teal sits between the cool qualification blue and the warm proposal\n        // amber, keeping the cool\u2192warm funnel ramp readable. NOT the gold\n        // `#FFD700` this option carries in `_picklists.ts`: gold is one hue\n        // step from proposal's amber, so the two adjacent stages would tint\n        // rows the same.\n        //\n        // Values are colour NAMES, not hex: objectui's `useRowColor` resolves\n        // only a name from its own vocabulary (or a full `bg-*` class) and\n        // turns a hex into no colour at all \u2014 so until 17.6.0's lint said so,\n        // this map tinted nothing.\n        needs_analysis: 'teal',\n        proposal: 'amber',\n        negotiation: 'purple',\n        closed_won: 'green',\n        closed_lost: 'red',\n      },\n    },\n    pagination: { pageSize: 25, pageSizeOptions: [25, 50, 100] },\n    selection: { type: 'multiple' },\n    showRecordCount: true,\n    exportOptions: { formats: ['csv', 'xlsx'] },\n    appearance: {\n      showDescription: true,\n      allowedVisualizations: ['grid', 'kanban', 'calendar', 'timeline', 'gallery'],\n    },\n    // Binds the 'calendar' entry above: the same forecast dates the dedicated\n    // `close_date_calendar` view shows, on the field this list sorts by.\n    // `close_date` is required + notNull on crm_opportunity.\n    calendar: {\n      startDateField: 'close_date',\n      titleField: 'name',\n      colorField: 'stage',\n    },\n    // List-level entry points: generate_quote reaches the row menu via its\n    // own `locations: ['list_item']`. Built-in `exportOptions` covers CSV\n    // export.\n    //\n    // `mass_update_stage` is wired as an AGGREGATE bulk def, not as a bare\n    // `bulkActions: ['mass_update_stage']` string (#508). The two forms are\n    // different dispatch contracts, and only this one moves a whole selection:\n    //\n    //   - bare string  \u2192 per-record fan-out: the action is dispatched ONCE PER\n    //     selected row with `recordId` set. N requests, N stage moves.\n    //   - aggregate def \u2192 ONE dispatch for the whole selection, carrying every\n    //     id in the builtin `params._selectedIds` and no `recordId`. One\n    //     request, N stage moves, one audit entry.\n    //\n    // Aggregate is the right shape here because the body already loops over the\n    // selection itself, and because the run is all-or-nothing: a partial result\n    // rejects instead of leaving the bar reporting per-row success it cannot\n    // honour (see the body in `src/sales/actions/opportunity.actions.ts`).\n    //\n    // `execution: 'aggregate'` is REQUIRED on an `operation: 'custom'` def and\n    // is not boilerplate: a custom def without it has no dispatcher, so the\n    // button ticks green once per row and does nothing at all. The spec refuses\n    // that shape at parse time (#4457) \u2014 which is also what makes this\n    // declaration safe to trust rather than merely present.\n    //\n    // History: this list carried the bare-string form until #588 removed it as\n    // a silent no-op, and the removal was read as \"the platform cannot deliver\n    // a selection\" for two release candidates. It could: the channel is\n    // `params._selectedIds`, the underscore is load-bearing, and nothing was\n    // injecting it precisely BECAUSE this declaration was gone\n    // (objectstack-ai/objectstack#5568, closed works-as-declared).\n    //\n    // The def deliberately carries only the three keys that choose the dispatch\n    // contract. Label, icon, params (the New Stage picker) and `visible` are\n    // promoted from the action itself by the renderer, so the dialog and the\n    // toolbar button cannot drift apart \u2014 and the label stays i18n-resolved,\n    // which an inline `label:` here would not be.\n    bulkActionDefs: [\n      { name: 'mass_update_stage', operation: 'custom', execution: 'aggregate' },\n    ],\n  },\n\n  listViews: {\n    /**\n     * All Opportunities \u2014 the unfiltered book, including closed business.\n     *\n     * Demoted from the landing view (see the note on `list` above) but kept\n     * whole: reporting, audits and win/loss reviews all need the closed rows,\n     * and a manager reaches this in one click.\n     */\n    all_opportunities: {\n      name: 'all_opportunities',\n      type: 'grid',\n      label: 'All Opportunities',\n      userActions: { editInline: true },\n      data: { provider: 'object', object: 'crm_opportunity' },\n      columns: [\n        { field: 'name', width: 220, sortable: true, link: true },\n        { field: 'crm_account', label: 'Account', width: 180 },\n        { field: 'stage', width: 140, sortable: true },\n        { field: 'amount', width: 140, align: 'right', sortable: true, summary: 'sum' },\n        { field: 'probability', width: 110, align: 'right' },\n        { field: 'expected_revenue', width: 160, align: 'right', summary: 'sum' },\n        { field: 'close_date', width: 140, sortable: true },\n        { field: 'owner_id', width: 150 },\n      ],\n      sort: [{ field: 'close_date', order: 'desc' }],\n      showRecordCount: true,\n    },\n\n    /** Drag-and-drop sales pipeline */\n    pipeline_kanban: {\n      name: 'pipeline_kanban',\n      type: 'kanban',\n      label: 'Sales Pipeline',\n      data: { provider: 'object', object: 'crm_opportunity' },\n      columns: ['name', 'crm_account', 'amount', 'close_date', 'owner_id'],\n      kanban: {\n        groupByField: 'stage',\n        summarizeField: 'amount',\n        columns: ['name', 'crm_account', 'amount', 'close_date'],\n      },\n      // The board is the active working pipeline. Closed business remains in\n      // the full book and the dashboard, while excluding it here keeps all\n      // five active stages visible at a presentation-friendly width.\n      filter: [{ field: 'stage', operator: 'not_in', value: ['closed_won', 'closed_lost'] }],\n      sort: [{ field: 'close_date', order: 'asc' }],\n      navigation: { mode: 'drawer', width: '640px' },\n    },\n\n    /** Close-date forecasting calendar */\n    close_date_calendar: {\n      name: 'close_date_calendar',\n      type: 'calendar',\n      label: 'Forecast Calendar',\n      data: { provider: 'object', object: 'crm_opportunity' },\n      columns: ['name', 'amount', 'stage', 'owner_id'],\n      calendar: {\n        startDateField: 'close_date',\n        titleField: 'name',\n        colorField: 'stage',\n      },\n    },\n\n    /** Chronological deal flow */\n    deal_timeline: {\n      name: 'deal_timeline',\n      type: 'timeline',\n      label: 'Deal Timeline',\n      data: { provider: 'object', object: 'crm_opportunity' },\n      columns: ['name', 'crm_account', 'amount'],\n      timeline: {\n        // `created_at`, the platform's own creation stamp \u2014 the object's\n        // duplicate `created_date` was removed in #575 B2 because nothing ever\n        // wrote it, so this timeline started every bar at null. Same spelling\n        // as the lead activity calendar.\n        startDateField: 'created_at',\n        endDateField: 'close_date',\n        titleField: 'name',\n        groupByField: 'owner_id',\n        colorField: 'stage',\n        scale: 'month',\n      },\n    },\n\n    /** Executive review cards */\n    deal_gallery: {\n      name: 'deal_gallery',\n      type: 'gallery',\n      label: 'Deal Cards',\n      data: { provider: 'object', object: 'crm_opportunity' },\n      columns: ['name', 'crm_account', 'amount', 'stage', 'close_date'],\n      gallery: {\n        cardSize: 'medium',\n        titleField: 'name',\n        visibleFields: ['crm_account', 'amount', 'stage', 'probability', 'close_date', 'owner_id'],\n      },\n    },\n\n    /** Personal pipeline */\n    my_open_deals: {\n      name: 'my_open_deals',\n      type: 'grid',\n      label: 'My Open Deals',\n      userActions: { editInline: true },\n      data: { provider: 'object', object: 'crm_opportunity' },\n      columns: ['name', 'crm_account', 'stage', 'amount', 'close_date'],\n      // \"Open\" has to exclude BOTH closed stages. Excluding only closed_won\n      // meant a rep's own queue opened on their lost deals, sorted to the top\n      // by close_date \u2014 the least actionable rows in the system.\n      filter: [\n        { field: 'owner_id', operator: 'equals', value: '{current_user_id}' },\n        { field: 'stage', operator: 'not_in', value: ['closed_won', 'closed_lost'] },\n      ],\n      sort: [{ field: 'close_date', order: 'asc' }],\n    },\n\n    /** Stale Opportunities \u2014 still-open deals, longest-parked first */\n    stale_opportunities: {\n      name: 'stale_opportunities',\n      type: 'grid',\n      // Honest label: this view does not apply the 14-day cut its automation\n      // twin (`opportunity_stagnation`, STALE_THRESHOLD_DAYS = 14) uses, and\n      // does not claim to. Two independent reasons were recorded for that; one\n      // still holds and one has expired, so they are separated here.\n      //\n      // STILL TRUE \u2014 `days_in_stage` is a FORMULA (#489), evaluated in JS after\n      // the query, so the data engine can neither filter nor sort on it. Any\n      // filter phrased in terms of `days_in_stage` remains impossible.\n      //\n      // EXPIRED (#744) \u2014 the second reason said the list data path resolves no\n      // date macros, so `stage_entry_date < {14_days_ago}` would ship the token\n      // as a literal and invert the comparison lexicographically ('2026-\u2026' sorts\n      // below '{', so every row matched). That was measured on @objectstack\n      // 16.1.0 and stopped being true at 17.0.0-rc.0, when `resolveFilterTokens()`\n      // was wired into the ObjectQL read path (objectql #3582). `{14_days_ago}`\n      // is a first-class vocabulary member \u2014 it matches the parameterised\n      // grammar `DATE_MACRO_PARAM_RE`, `{N_(minutes|hours|days|weeks|months|\n      // years)_(ago|from_now)}` \u2014 and it reaches the driver already substituted\n      // for an ISO date. Measured on 17.0.0-rc.2, RE-MEASURED 2026-09-03 on\n      // 17.2.0 (#1467), RE-RUN on 17.3.0 (#1676, after the PR #1577 bump) and\n      // RE-RUN again on 17.4.0 (#1883, after the PR #1814 bump; not yet on\n      // 17.5.0), unchanged at every taking: over four rows parked\n      // 30d / 15d / 13d / 1d, `stage_entry_date < {14_days_ago}` returned the\n      // 30d and 15d rows \u2014 the same two the equivalent day-start literal\n      // returns, and not all four, which is what an unsubstituted token would\n      // have matched. It is the same seam\n      // `closing_this_quarter` \u2014 the very next view in this file \u2014 relies on,\n      // pinned against a real engine in\n      // `test/forecast-current-quarter-view.test.ts`.\n      //\n      // Correcting that half of the comment does not decide anything about the\n      // filter, and is deliberately not a licence to change it: expressing the\n      // cut as `stage_entry_date <= {14_days_ago}` would drop `days_in_stage`\n      // from the question entirely and change which rows this view returns \u2014\n      // hiding today's 13-day-old deals from a manager's queue. That is a\n      // BEHAVIOUR change with its own issue (#770), where the open question is\n      // whether this queue should be a cut or a ranking at all \u2014 this label\n      // promises a ranking and honours it. `stale_articles` in\n      // `src/views/knowledge_article.view.ts` carried the same expired premise\n      // and was corrected in the same pass (#769); that tab was then DELETED\n      // outright (#781, the review queue ruled out of the product), so it is no\n      // longer a comparison available in this tree \u2014 the surviving precedent\n      // for \"ranking, not cut\" is this view. Nothing below was touched.\n      //\n      // As shipped: operator-only filter, ordered by the stored\n      // `stage_entry_date` ascending \u2014 longest-parked on top, which is the\n      // queue a manager works. The `days_in_stage` column puts the\n      // `opportunity_stagnation` threshold in plain sight on every row.\n      label: '\u26A0\uFE0F Stale Opportunities \u00B7 Longest in Stage First',\n      userActions: { editInline: true },\n      data: { provider: 'object', object: 'crm_opportunity' },\n      columns: ['name', 'crm_account', 'stage', 'amount', 'stage_entry_date', 'days_in_stage', 'close_date', 'owner_id'],\n      filter: [\n        { field: 'stage', operator: 'not_in', value: ['closed_won', 'closed_lost'] },\n      ],\n      sort: [{ field: 'stage_entry_date', order: 'asc' }, { field: 'close_date', order: 'asc' }],\n    },\n\n    /**\n     * Tender expected this quarter \u2014 REQ-0006 acceptance 2 in one view.\n     *\n     * The point of the view is the predicate: it windows\n     * `expected_tender_date`, the CUSTOMER's procurement calendar, and touches\n     * `close_date` nowhere \u2014 which is what \"reportable independently of\n     * `close_date`\" means and what a single forecast date could never express.\n     *\n     * Same inclusive `{current_quarter_*}` bounds as `closing_this_quarter`\n     * below, exact for the same measured reason: both bounds are date macros\n     * resolved server-side, and `expected_tender_date` is a `Field.date()`\n     * stored as `YYYY-MM-DD` TEXT, so the inclusive upper bound drops no rows.\n     */\n    tender_this_quarter: {\n      name: 'tender_this_quarter',\n      type: 'grid',\n      label: 'Tender This Quarter',\n      userActions: { editInline: true },\n      data: { provider: 'object', object: 'crm_opportunity' },\n      columns: ['name', 'crm_account', 'expected_tender_date', 'expected_tender_amount', 'expected_signing_date', 'stage', 'owner_id'],\n      filter: [\n        { field: 'stage', operator: 'not_in', value: ['closed_won', 'closed_lost'] },\n        { field: 'expected_tender_date', operator: 'greater_than_or_equal', value: '{current_quarter_start}' },\n        { field: 'expected_tender_date', operator: 'less_than_or_equal', value: '{current_quarter_end}' },\n      ],\n      sort: [{ field: 'expected_tender_date', order: 'asc' }],\n      // Empty is the legitimate state on a fresh install: no seed row carries\n      // a customer-side tender date, so this tab opens on nothing until a rep\n      // records one. Unexplained, that reads as broken.\n      emptyState: {\n        title: 'No Tenders Expected This Quarter',\n        message: 'This tab lists open deals whose customer-side tender date falls inside the current quarter. Record Expected Tender Date on a deal to see it here.',\n        icon: 'calendar-clock',\n      },\n    },\n\n    /** Closing this quarter (commit + best_case) \u2014 sales-manager forecast */\n    closing_this_quarter: {\n      name: 'closing_this_quarter',\n      type: 'grid',\n      label: 'Closing This Quarter',\n      userActions: { editInline: true },\n      data: { provider: 'object', object: 'crm_opportunity' },\n      columns: ['name', 'crm_account', 'amount', 'forecast_category', 'probability', 'close_date', 'owner_id'],\n      // The `close_date` window is what makes the label true (#743). Without\n      // it this view returned EVERY open commit/best-case deal whenever it\n      // closed \u2014 a deal slated for next March sat under a heading that said\n      // \"Closing This Quarter\", and summing the Amount column gave a number\n      // that was not this quarter's commit.\n      //\n      // Both bounds are date macros resolved server-side: `resolveFilterTokens()`\n      // was wired into the ObjectQL read path in 17.0.0-rc.0 (objectql #3582,\n      // covering find/findOne/count/aggregate ahead of the middleware chain),\n      // so a saved-view filter value reaches the driver already substituted.\n      // Measured on 17.0.0-rc.2, RE-MEASURED 2026-09-03 on 17.2.0 (#1467),\n      // RE-RUN on 17.3.0 (#1676, after the PR #1577 bump) and RE-RUN again on\n      // 17.4.0 (#1883, after the PR #1814 bump), unchanged at\n      // every taking \u2014 see the runtime block in\n      // `test/forecast-current-quarter-view.test.ts`, which is that\n      // re-measurement (not yet re-run on 17.5.0).\n      //\n      // The upper bound is INCLUSIVE against `{current_quarter_end}` rather\n      // than half-open against `{next_quarter_start}`, and that choice is\n      // deliberate: a `*_end` token resolves to the period's last calendar DAY\n      // (2026-09-30), which on a `datetime` column would stop at midnight and\n      // silently drop that day's rows \u2014 the spec says to use the half-open\n      // form there. `close_date` is `Field.date()`, stored as `YYYY-MM-DD`\n      // TEXT on both sides of the comparison, so the inclusive bound is exact.\n      // That is the same field-type property `metadata-references.test.ts`\n      // relies on for why the CRM/Sales/Executive dashboards may window\n      // `close_date` at all (#460). Both forms were measured to return the\n      // identical row set here; the inclusive one reads as what it means.\n      filter: [\n        { field: 'forecast_category', operator: 'in', value: ['commit', 'best_case'] },\n        { field: 'stage', operator: 'not_in', value: ['closed_won', 'closed_lost'] },\n        { field: 'close_date', operator: 'greater_than_or_equal', value: '{current_quarter_start}' },\n        { field: 'close_date', operator: 'less_than_or_equal', value: '{current_quarter_end}' },\n      ],\n      sort: [{ field: 'close_date', order: 'asc' }],\n      // Scoping the list makes \"empty\" a state a real user meets, so it needs\n      // copy. Unlike the forecast view's (#745, where the sweep owns the\n      // window and a fresh install is ALWAYS empty until it runs), the seeds\n      // here do produce rows for most of a quarter \u2014 six seeded deals qualify\n      // on forecast_category + stage, at `daysFromNow` offsets 11/14/24/30/38/45.\n      // But every one of those offsets is relative to the INSTALL day, so once\n      // fewer than 11 days remain in the quarter all six land in the next one\n      // and a freshly seeded demo opens this tab on nothing. A real org meets\n      // the same state whenever a quarter's commit slips out. Empty is\n      // legitimate here; unexplained, it reads as broken.\n      emptyState: {\n        title: 'No Deals Closing This Quarter',\n        message: 'This tab lists open commit and best-case deals with a close date inside the current quarter. Nothing matches right now \u2014 deals closing later are on the Open Deals tab.',\n        icon: 'calendar-check',\n      },\n    },\n  },\n\n  form: {\n    type: 'tabbed',\n    sections: [\n      {\n        name: 'overview',\n        label: 'Overview',\n        columns: 2,\n        fields: [\n          { field: 'name', required: true, span: 'full' },\n          { field: 'crm_account', required: true },\n          'primary_contact',\n          { field: 'stage', required: true },\n          { field: 'amount', required: true },\n          'probability',\n          'close_date',\n          'owner_id',\n        ],\n      },\n      {\n        name: 'forecast',\n        label: 'Forecast',\n        columns: 2,\n        fields: [\n          'expected_revenue',\n          'forecast_category',\n          'type',\n          'lead_source',\n          'crm_campaign',\n          'stage_entry_date',\n          'days_in_stage',\n          'is_private',\n          // REQ-0006 step 8 \u2014 the customer's own procurement calendar. Named\n          // here (AGENTS.md ladder rung 3), and the reason in writing:\n          // `tender_this_quarter` filters on `expected_tender_date`, and a\n          // filtered field no form offers is a view that can never match a\n          // deal a rep created through the UI (`test/metadata-references\n          // .test.ts`). The fields declare `group: 'sales_process'`, so every\n          // DERIVED surface \u2014 the record page's Details tab \u2014 already carries\n          // them; this form authors `sections`, which win outright over\n          // derivation. A `{ group: 'sales_process' }` reference cannot stand\n          // in: it would render `stage`, `probability` and `close_date`\n          // (curated in Overview, `stage` `required`) and `stage_entry_date`\n          // (above) a second time, and pull the approval verdict columns and\n          // the inert-by-default `requested_status` into the create dialog.\n          'customer_initiation_date',\n          'expected_tender_date',\n          'expected_tender_amount',\n          'expected_signing_date',\n          'expected_signing_amount',\n        ],\n      },\n      // REQ-0006 acceptance 1, FROM `fieldGroups` (AGENTS.md ladder rung 2),\n      // the way `contact.view.ts` references REQ-0004's buying centre: this\n      // form authors `sections`, which win outright over the renderer's\n      // `fieldGroups` derivation, so a group declared on the object alone\n      // never reaches this form \u2014 the Edit and New dialog. A group reference\n      // enumerates nothing; members, label and icon come from the object.\n      //\n      // \u26A0\uFE0F Measured on the 17.6.0 console: the tabbed dialog renders NO tab\n      // for a `{ group }` section \u2014 this one, and the contact form's buying\n      // centre on `main` alike. That is the platform's to fix, and these two\n      // lines are the contract-correct form waiting for it (AGENTS.md: a\n      // platform defect is waited for, never routed around). Until then every\n      // REQ-0006 field is edited through the Details tab's edit mode \u2014 which\n      // offers no markdown editor, the reason the narrative fields are\n      // textareas (see the note above `customer_background`).\n      { group: 'qualification', columns: 2 },\n      { group: 'narrative', columns: 1 },\n      {\n        name: 'sales_strategy',\n        label: 'Sales Strategy',\n        columns: 1,\n        // `competitors` sat here until #1061 retired it \u2014 this form section was\n        // the field's ONLY surface anywhere in the app (nothing read it back).\n        fields: ['next_step'],\n      },\n      {\n        // Win/loss capture at close time. The fields existed on the object for\n        // reporting but no form offered them, so every closed deal lost its\n        // why-we-won / why-we-lost data.\n        name: 'win_loss',\n        label: 'Win / Loss',\n        collapsible: true,\n        collapsed: true,\n        columns: 2,\n        fields: ['win_reason', 'loss_reason', { field: 'loss_details', span: 'full' }],\n      },\n    ],\n  },\n});\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/sales/views/task.view.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/sales/views\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/sales/views/task.view.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport { defineView } from '@objectstack/spec/ui';\n\n/**\n * Task Views\n *\n *   \u2022 grid     \u2014 to-do list with completion controls\n *   \u2022 kanban   \u2014 work board grouped by status\n *   \u2022 calendar \u2014 schedule by due_date\n *   \u2022 gantt    \u2014 execution plan from reminder_date \u2192 due_date\n *   \u2022 timeline \u2014 chronological worklog grouped by owner\n */\nexport const TaskViews = defineView({\n  list: {\n    type: 'grid',\n    name: 'all_tasks',\n    label: 'All Tasks',\n    userActions: { editInline: true },\n    data: { provider: 'object', object: 'crm_task' },\n    // NO `progress_percent` column here (#1214 item 5). The default grid used\n    // to render completion THREE times on one row \u2014 \u662F\u5426\u5B8C\u6210 (tick), \u72B6\u6001, and\n    // \u8FDB\u5EA6(%) \u2014 and the percent was the one that carried nothing.\n    //\n    // \u26A0\uFE0F The card justified the removal as \"every seeded row is 0%\". That is\n    // FALSE as stated and was re-measured before deleting: two of the seven\n    // seeded tasks carry 100. What is TRUE is the claim underneath it \u2014 nobody\n    // maintains a percent per task \u2014 and the seed shows it more sharply than\n    // the card did:\n    //   \u00B7 every value that exists is 100, and every one of those rows is\n    //     `status: 'completed'` (`service.seed.ts` mirrors what the hook would\n    //     stamp, since hooks do not run over seeds);\n    //   \u00B7 `task_completion` stamps 100 on the completed transition and writes\n    //     the field at no other time;\n    //   \u00B7 both `in_progress` rows sit at 0 \u2014 the one status where a percent\n    //     could say something a status cannot, and it says nothing.\n    // \u21D2 On this grid the column is `status` re-rendered at LOWER resolution: it\n    // cannot tell `not_started` from `in_progress` (both 0), while the `status`\n    // column beside it can. Dropping it loses no fact this row does not already\n    // carry twice.\n    //\n    // \u26D4 The FIELD stays, and so does every other reader \u2014 this is one column\n    // on one view, not a retirement: `task_gantt` fills its bars from\n    // `gantt.progressField`, `task_board` and `my_open_tasks` show it (neither\n    // carries `status` AND `is_completed`, so there it is not a third spelling),\n    // `avg_progress` in `task.dataset.ts` aggregates it, and the Effort section\n    // of this file's form still lets a user author one.\n    //\n    // \u26D4 `is_completed` STAYS, and is not the second half of this cleanup: it is\n    // not an independent shadow that can contradict `status` \u2014 `task_completion`\n    // recomputes it from status on every insert and update\n    // (`input.is_completed = effStatus === 'completed'`), which is precisely the\n    // \"render completion from status\" the card asks for, already done at the\n    // data layer. It is also this list's first sort key and its completion\n    // control.\n    columns: [\n      { field: 'is_completed', width: 60, align: 'center' },\n      { field: 'subject', width: 280, sortable: true, link: true },\n      { field: 'status', width: 130, sortable: true },\n      { field: 'priority', width: 110, sortable: true },\n      { field: 'due_date', width: 140, sortable: true },\n      { field: 'owner_id', width: 150 },\n      { field: 'is_overdue', width: 100, align: 'center' },\n    ],\n    sort: [\n      { field: 'is_completed', order: 'asc' },\n      { field: 'due_date', order: 'asc' },\n    ],\n    rowColor: {\n      // Task priority is low/normal/high/urgent \u2014 the previous critical/medium\n      // keys were Case values, so urgent and normal rows got no color at all.\n      // Colors mirror the option colors on crm_task.priority.\n      field: 'priority',\n      colors: { urgent: 'red', high: 'orange', normal: 'green', low: 'slate' },\n    },\n    selection: { type: 'multiple' },\n    pagination: { pageSize: 50 },\n    appearance: {\n      showDescription: true,\n      allowedVisualizations: ['grid', 'kanban', 'calendar', 'gantt', 'timeline'],\n    },\n    // Binds the 'calendar' entry above: the same schedule the dedicated\n    // `task_calendar` view shows, on the field this list sorts by. `due_date`\n    // is optional \u2014 an undated task stays off the calendar instead of being\n    // dropped on today by a guessed field.\n    calendar: {\n      startDateField: 'due_date',\n      titleField: 'subject',\n      colorField: 'priority',\n    },\n  },\n\n  listViews: {\n    /** Work board */\n    task_board: {\n      name: 'task_board',\n      type: 'kanban',\n      label: 'Task Board',\n      data: { provider: 'object', object: 'crm_task' },\n      columns: ['subject', 'priority', 'due_date', 'owner_id'],\n      kanban: {\n        groupByField: 'status',\n        columns: ['subject', 'priority', 'due_date', 'progress_percent'],\n      },\n      filter: [{ field: 'is_completed', operator: 'equals', value: false }],\n      navigation: { mode: 'drawer', width: '520px' },\n    },\n\n    /** Schedule view */\n    task_calendar: {\n      name: 'task_calendar',\n      type: 'calendar',\n      label: 'Task Schedule',\n      data: { provider: 'object', object: 'crm_task' },\n      columns: ['subject', 'priority', 'owner_id'],\n      calendar: {\n        startDateField: 'due_date',\n        titleField: 'subject',\n        colorField: 'priority',\n      },\n    },\n\n    /** Execution plan */\n    task_gantt: {\n      name: 'task_gantt',\n      type: 'gantt',\n      label: 'Execution Plan',\n      data: { provider: 'object', object: 'crm_task' },\n      columns: ['subject', 'owner_id', 'progress_percent'],\n      gantt: {\n        startDateField: 'reminder_date',\n        endDateField: 'due_date',\n        titleField: 'subject',\n        progressField: 'progress_percent',\n      },\n    },\n\n    /** Worklog timeline */\n    task_timeline: {\n      name: 'task_timeline',\n      type: 'timeline',\n      label: 'Worklog Timeline',\n      data: { provider: 'object', object: 'crm_task' },\n      columns: ['subject', 'status'],\n      timeline: {\n        startDateField: 'reminder_date',\n        endDateField: 'due_date',\n        titleField: 'subject',\n        groupByField: 'owner_id',\n        colorField: 'status',\n        scale: 'week',\n      },\n    },\n\n    my_open_tasks: {\n      name: 'my_open_tasks',\n      type: 'grid',\n      label: 'My Open Tasks',\n      userActions: { editInline: true },\n      data: { provider: 'object', object: 'crm_task' },\n      columns: ['subject', 'priority', 'due_date', 'progress_percent'],\n      filter: [\n        { field: 'owner_id', operator: 'equals', value: '{current_user_id}' },\n        { field: 'is_completed', operator: 'equals', value: false },\n      ],\n      sort: [{ field: 'due_date', order: 'asc' }],\n    },\n\n    /** My open priority tasks \u2014 daily morning queue */\n    todays_tasks: {\n      name: 'todays_tasks',\n      type: 'grid',\n      label: '\uD83D\uDCC5 My Priority Tasks',\n      userActions: { editInline: true },\n      data: { provider: 'object', object: 'crm_task' },\n      columns: ['subject', 'priority', 'status', 'due_date', 'related_to_type', 'owner_id'],\n      // Operator-only filter \u2014 priority and status, no tokens \u2014 and the reason\n      // recorded here for that has expired (#782). Two claims stood here; both\n      // were wrong already on 17.0.0-rc.2 \u2014 the version this repo pinned AT\n      // THE TIME they were measured, not the current pin \u2014 in different\n      // ways. \"Wrong\" is about those two\n      // retired claims, not about the engine: nothing in this block reports\n      // broken platform behaviour.\n      //\n      // \u26A0\uFE0F READ THE VERSION ON EACH READING BELOW. They were taken at\n      // several different pins and are labelled individually; a reading\n      // labelled 17.2.0 was taken there and has NOT been re-taken on any later\n      // pin unless it says so.\n      //\n      // `{current_user_id}` DOES interpolate. `resolveFilterTokens()` was wired\n      // into the ObjectQL READ path at 17.0.0-rc.0 (objectql #3582) ahead of\n      // the middleware chain, covering `find` / `findOne` / `count` /\n      // `aggregate` \u2014 saved-view filters included. `my_open_tasks`, the view\n      // directly above, ships that exact token. Measured in #784 with two probes\n      // that separate the three possible outcomes: `owner_id =\n      // {current_org_id}` returned 0 rows (the filter is not being dropped)\n      // while `owner_id = {current_user_id}` returned every seeded task (not a\n      // literal-string compare either \u2014 the literal matches no owner at all).\n      // RE-MEASURED 2026-09-03 on 17.2.0 (#1467), unchanged: both probes\n      // reported exactly those results there. NOT re-run on 17.3.0 (#1676) \u2014\n      // the two-probe result is a 17.2.0 reading, and the seam it rests on\n      // (`resolveFilterTokens()` on the read path) was re-confirmed on 17.4.0\n      // by `test/flow-filter-today-token.test.ts` (not yet re-run on 17.5.0).\n      //\n      // `{TODAY()}` is not a spelling of anything and never was. The vocabulary\n      // is `{today}` / `{yesterday}` / `{tomorrow}` / `{now}`, the period\n      // tokens, and the parameterised `{N_days_ago}` family.\n      //\n      // \u26A0\uFE0F WHAT CHANGED between rc.2 and 17.4.0 \u2014 the one reading in\n      // this block that did NOT survive re-measurement, and the reason the\n      // version qualifiers here are load-bearing rather than bookkeeping. On\n      // rc.2 `{TODAY()}` was not REJECTED either: the placeholder grammar was\n      // `/^\\$?\\{([a-zA-Z0-9_]+)\\}$/`, parentheses fell outside it,\n      // `classifyFilterToken('{TODAY()}')` returned null, and the string\n      // reached the driver verbatim and compared as text. From 17.2.0 on \u2014\n      // re-confirmed on 17.3.0 (#1676) and again on 17.4.0\n      // (#1883) by the PREMISE case in\n      // `test/flow-filter-today-token.test.ts`, which drives a real engine \u2014\n      // that is FALSE: `FILTER_TOKEN_WRAPPED_RE` in `@objectstack/spec/data`\n      // now reads `/^\\$?\\{([^{}]+)\\}$/`, which DOES match `TODAY()`, so it\n      // classifies as `kind: 'unknown'` and `resolveFilterTokens()` throws\n      // `UnknownFilterTokenError` (`FILTER_TOKEN_UNKNOWN`, HTTP 400) \u2014 the same\n      // envelope `{TODAY}` gets. The change landed at 17.0.0-rc.6 and this repo\n      // already pins it elsewhere: `test/flow-filter-today-token.test.ts`\n      // (#1107). That is also why the `src/*/flows` sweeps that still spell\n      // `{TODAY()}` work \u2014 `interpolateFilter()` resolves it before ObjectQL\n      // sees the filter at all.\n      //\n      // Measured on rc.2 over a four-row `crm_task` fixture (due 30d ago / 1d\n      // ago / today / in 7d), and RE-MEASURED 2026-09-03 on 17.2.0 (#1467)\n      // over the same fixture \u2014 three rows unchanged, the fourth not. \u26D4 The\n      // row COUNTS below are a 17.2.0 reading and were NOT re-taken on 17.3.0\n      // (#1676); what WAS re-confirmed there is the throw/resolve verdict in\n      // the right-hand column, by `test/flow-filter-today-token.test.ts`:\n      //\n      //                                  rc.2               17.2.0\n      //     due_date <  '{today}'    ->  2 rows (past-due)  2 rows\n      //     due_date <= '{today}'    ->  3 rows             3 rows\n      //     due_date <  '{TODAY}'    ->  throws             throws\n      //     due_date <  '{TODAY()}'  ->  ALL 4 rows         throws\n      //\n      // (Both throws are `UnknownFilterTokenError`, `FILTER_TOKEN_UNKNOWN`.)\n      //\n      // So the #744 lexicographic inversion ('2026-\u2026' sorts below '{') is NOT\n      // still live on this path, and \u26D4 nothing here should carry a workaround\n      // for it: on rc.2 it reached every spelling the grammar could not see,\n      // and the 17.2.0 grammar sees them all. The author-time guard in\n      // `test/metadata-references.test.ts` \u2014 it scans the broader\n      // `/\\{([^{}]+)\\}/` and rejects any token neither path resolves \u2014 still\n      // earns its keep, by failing at authoring time rather than as a 400 in a\n      // user's face, and by covering the analytics path the engine gate does\n      // not.\n      //\n      // Correcting the comment is not a licence to change the filter. Whether\n      // this view should carry a date bound at all \u2014 and whether a label\n      // reading \"My Priority Tasks\" over a filter with no owner condition is\n      // the right name \u2014 are BEHAVIOUR decisions on #770's line for the task\n      // views, not this one's.\n      //\n      // The sort below is due_date-MAJOR, not priority-major: `priority_rank\n      // desc` only breaks ties inside a single due date, so a high task due\n      // tomorrow outranks an urgent one due next week. Measured on rc.2 with\n      // the shipped sort over four rows \u2014 soon/urgent, soon/high, later/urgent,\n      // later/high, in that order. What stood here said the sort \"puts urgent\n      // at top\", which is what the OTHER key order would do.\n      filter: [\n        { field: 'status', operator: 'in', value: ['not_started', 'in_progress'] },\n        { field: 'priority', operator: 'in', value: ['high', 'urgent'] },\n      ],\n      sort: [{ field: 'due_date', order: 'asc' }, { field: 'priority_rank', order: 'desc' }],\n    },\n\n    /** Overdue / open tasks across the team \u2014 sorted oldest-due first */\n    overdue_tasks: {\n      name: 'overdue_tasks',\n      type: 'grid',\n      // Honest label. Two independent reasons were recorded for it; one still\n      // holds and one has expired (#782), so they are separated here.\n      //\n      // STILL TRUE \u2014 `is_overdue` is a WRITE-TIME snapshot. `task.hook.ts:68`\n      // stamps it in `beforeSave` off that moment's clock (`effDue < todayStr`\n      // and not completed) and nothing re-stamps it afterwards, so a task that\n      // was on time when it was last saved still reads `is_overdue = false` the\n      // day after its due date passes. A filter on that column would hand back\n      // the wrong rows, and it would go wrong silently.\n      //\n      // EXPIRED \u2014 the other reason said the view layer cannot resolve\n      // `due_date < {TODAY()}`, and that only `{current_user_id}` interpolates.\n      // Both halves were wrong already on 17.0.0-rc.2 \u2014 the version this repo\n      // pinned AT THE TIME they were measured, not the current pin \u2014 and the\n      // file said the opposite of\n      // itself: the note on `todays_tasks` above asserted that\n      // `{current_user_id}` does NOT interpolate. It does.\n      // That comment carries the measurements with their versions, INCLUDING\n      // the one that moved: `{TODAY()}` is REJECTED from 17.2.0 on\n      // (`FILTER_TOKEN_UNKNOWN`, re-confirmed on 17.3.0 and again on\n      // 17.4.0 by\n      // `test/flow-filter-today-token.test.ts`) where on rc.2 it shipped to\n      // the driver as text, so \"cannot resolve `{TODAY()}`\" is wrong on the\n      // current pin for a different reason than it was wrong on rc.2. The\n      // canonical `{today}` resolves on the read path either way, so a\n      // strictly past-due filter IS expressible: `due_date < '{today}'`\n      // selected exactly the past-due rows out of four on rc.2, and did again\n      // on 17.2.0 (RE-MEASURED 2026-09-03; that row count was not re-taken on\n      // 17.3.0, where the token's resolution is re-confirmed by the test file\n      // named above).\n      //\n      // So the honest statement is narrower than the one that stood here: this\n      // view CAN be given a strictly past-due cut through `{today}`, and is not\n      // given one. Adding it is a BEHAVIOUR change, not a comment correction \u2014\n      // it would drop today's due-today work out of the queue and turn an\n      // \"Open Tasks\" backlog into a strict overdue list, which is the\n      // cut-versus-ranking question already open on #770 for the task views.\n      // That also retires the follow-up this comment used to end on: an hourly\n      // flow re-stamping `is_overdue` was proposed as the ONLY route to a\n      // truly-overdue gauge, because the filter route was believed closed.\n      // There are two routes now, and choosing between them belongs to #770.\n      //\n      // As shipped: the open-task backlog ordered most-overdue-first (oldest\n      // due date on top), which is the actionable queue a manager works.\n      label: '\u23F0 Open Tasks \u00B7 Most Overdue First',\n      userActions: { editInline: true },\n      data: { provider: 'object', object: 'crm_task' },\n      columns: ['subject', 'priority', 'status', 'due_date', 'owner_id'],\n      filter: [\n        { field: 'is_completed', operator: 'equals', value: false },\n      ],\n      sort: [{ field: 'due_date', order: 'asc' }],\n    },\n  },\n\n  form: {\n    type: 'simple',\n    sections: [\n      {\n        name: 'task',\n        label: 'Task',\n        columns: 2,\n        // `type` (call / email / meeting / demo) is what makes an activity\n        // history readable and is the first thing a rep reaches for after the\n        // subject \u2014 it was missing entirely. `description` captures what was\n        // actually said on the call. `progress_percent` moved to the Effort\n        // section: a task being filed is 0% by definition, so a percentage\n        // slider on the create form is noise.\n        fields: [\n          { field: 'subject', required: true, span: 'full' },\n          { field: 'type', required: false },\n          { field: 'status', required: true },\n          'priority',\n          'due_date',\n          'owner_id',\n          'reminder_date',\n          { field: 'description', span: 'full' },\n        ],\n      },\n      {\n        name: 'related_records',\n        label: 'Related Records',\n        collapsible: true,\n        columns: 2,\n        fields: [\n          'related_to_account',\n          'related_to_contact',\n          'related_to_opportunity',\n          'related_to_lead',\n          'related_to_case',\n        ],\n      },\n      {\n        name: 'recurrence_and_effort',\n        label: 'Recurrence & Effort',\n        collapsible: true,\n        collapsed: true,\n        columns: 2,\n        fields: [\n          'is_recurring',\n          'recurrence_type',\n          'recurrence_interval',\n          'recurrence_end_date',\n          'progress_percent',\n        ],\n      },\n    ],\n  },\n});\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/sales/views/event.view.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/sales/views\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/sales/views/event.view.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport { defineView } from '@objectstack/spec/ui';\n\n/**\n * Event Views (#592)\n *\n *   \u2022 grid     \u2014 every interaction, most recent first\n *   \u2022 calendar \u2014 the schedule, start \u2192 end (the platform view type the issue asks for)\n *   \u2022 timeline \u2014 the same rows laid out per rep\n *   \u2022 mine     \u2014 my calendar\n *   \u2022 upcoming \u2014 what is booked but has not happened yet\n *   \u2022 held     \u2014 what actually happened, the interaction history\n *\n * # Why no \"past events\" filter on a date\n *\n * The list-view data path resolves ONLY the user tokens (`{current_user_id}`);\n * date macros ship to the server as literal strings, and because\n * `'2026-\u2026' < '{\u2026'` is lexicographically true, a `start_datetime < {today}`\n * filter matches the FUTURE rows instead of the past ones \u2014 inverted, not\n * merely empty (the same trap `overdue_tasks` documents). So the past/future\n * split is expressed with `status`, which is authored and does not decay, and\n * the ordering does the rest.\n */\nexport const EventViews = defineView({\n  list: {\n    type: 'grid',\n    name: 'all_events',\n    label: 'All Events',\n    userActions: { editInline: true },\n    data: { provider: 'object', object: 'crm_event' },\n    columns: [\n      { field: 'subject', width: 280, sortable: true, link: true },\n      { field: 'type', width: 120, sortable: true },\n      { field: 'status', width: 120, sortable: true },\n      { field: 'start_datetime', width: 180, sortable: true },\n      { field: 'duration_minutes', width: 120, align: 'right' },\n      { field: 'location', width: 180 },\n      { field: 'owner_id', width: 150 },\n    ],\n    sort: [{ field: 'start_datetime', order: 'desc' }],\n    rowColor: {\n      // Mirrors the option colors on crm_event.status.\n      field: 'status',\n      colors: { planned: 'blue', held: 'green', cancelled: 'slate', no_show: 'orange' },\n    },\n    selection: { type: 'multiple' },\n    pagination: { pageSize: 50 },\n    appearance: {\n      showDescription: true,\n      allowedVisualizations: ['grid', 'calendar', 'timeline', 'kanban'],\n    },\n    // Binds the 'calendar' entry above: the same span the dedicated\n    // `event_calendar` view shows. `start_datetime` is required + notNull;\n    // `end_datetime` is optional, so an event without one stays a single point\n    // in time rather than borrowing a neighbour's end.\n    calendar: {\n      startDateField: 'start_datetime',\n      endDateField: 'end_datetime',\n      titleField: 'subject',\n      colorField: 'type',\n    },\n  },\n\n  listViews: {\n    /** The calendar the issue asks for \u2014 start \u2192 end, coloured by kind. */\n    event_calendar: {\n      name: 'event_calendar',\n      type: 'calendar',\n      label: 'Event Calendar',\n      data: { provider: 'object', object: 'crm_event' },\n      columns: ['subject', 'type', 'owner_id'],\n      calendar: {\n        startDateField: 'start_datetime',\n        endDateField: 'end_datetime',\n        titleField: 'subject',\n        colorField: 'type',\n      },\n    },\n\n    /** Who is booked when \u2014 one lane per rep. */\n    event_timeline: {\n      name: 'event_timeline',\n      type: 'timeline',\n      label: 'Team Schedule',\n      data: { provider: 'object', object: 'crm_event' },\n      columns: ['subject', 'status'],\n      timeline: {\n        startDateField: 'start_datetime',\n        endDateField: 'end_datetime',\n        titleField: 'subject',\n        groupByField: 'owner_id',\n        colorField: 'type',\n        scale: 'day',\n      },\n    },\n\n    my_events: {\n      name: 'my_events',\n      type: 'calendar',\n      label: 'My Calendar',\n      data: { provider: 'object', object: 'crm_event' },\n      columns: ['subject', 'type', 'location'],\n      // `{current_user_id}` is the one token the list-view data path really\n      // interpolates (see crm.app.ts's \"My Work\" note).\n      filter: [{ field: 'owner_id', operator: 'equals', value: '{current_user_id}' }],\n      calendar: {\n        startDateField: 'start_datetime',\n        endDateField: 'end_datetime',\n        titleField: 'subject',\n        colorField: 'type',\n      },\n    },\n\n    /** Booked, not yet held \u2014 soonest first. */\n    upcoming_events: {\n      name: 'upcoming_events',\n      type: 'grid',\n      label: '\uD83D\uDCC5 Upcoming \u00B7 Soonest First',\n      userActions: { editInline: true },\n      data: { provider: 'object', object: 'crm_event' },\n      columns: ['subject', 'type', 'start_datetime', 'location', 'related_to_type', 'owner_id'],\n      filter: [{ field: 'status', operator: 'equals', value: 'planned' }],\n      sort: [{ field: 'start_datetime', order: 'asc' }],\n    },\n\n    /** What actually happened \u2014 the interaction history the CRM could not show. */\n    held_events: {\n      name: 'held_events',\n      type: 'grid',\n      label: '\u2705 Interaction History',\n      userActions: { editInline: true },\n      data: { provider: 'object', object: 'crm_event' },\n      columns: ['subject', 'type', 'start_datetime', 'duration_minutes', 'related_to_type', 'owner_id'],\n      filter: [{ field: 'status', operator: 'equals', value: 'held' }],\n      sort: [{ field: 'start_datetime', order: 'desc' }],\n    },\n  },\n\n  form: {\n    type: 'simple',\n    sections: [\n      {\n        name: 'event',\n        label: 'Event',\n        columns: 2,\n        fields: [\n          { field: 'subject', required: true, span: 'full' },\n          { field: 'type', required: true },\n          { field: 'status', required: true },\n          'owner_id',\n          'location',\n          { field: 'description', span: 'full' },\n        ],\n      },\n      {\n        name: 'schedule',\n        label: 'Schedule',\n        columns: 2,\n        fields: [\n          { field: 'start_datetime', required: true },\n          'end_datetime',\n          'all_day',\n          'duration_minutes',\n        ],\n      },\n      {\n        name: 'related_records',\n        label: 'Related Records',\n        collapsible: true,\n        columns: 2,\n        fields: [\n          'related_to_account',\n          'related_to_contact',\n          'related_to_opportunity',\n          'related_to_lead',\n          'related_to_case',\n        ],\n      },\n      {\n        name: 'outcome',\n        label: 'Outcome',\n        collapsible: true,\n        collapsed: true,\n        columns: 1,\n        fields: ['outcome_notes'],\n      },\n    ],\n  },\n});\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/sales/views/event_attendee.view.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/sales/views\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/sales/views/event_attendee.view.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport { defineView } from '@objectstack/spec/ui';\n\n/**\n * Event Attendee Views (#592)\n *\n * A junction object is normally edited inside its parent's related list, and\n * `crm_event_attendee` is no exception. It carries no navigation entry: an\n * attendee is never something you go looking for on its own, you reach it\n * through the meeting.\n *\n * # What each half of this bundle actually renders \u2014 measured (#944)\n *\n * This header used to justify both halves in one sentence: the related list\n * renders THIS view's columns, the quick-create modal renders THIS form, and\n * without them the panel falls back to every column in declaration order while\n * the modal offers the raw autonumber \u2014 \"for the same reason\n * `crm_campaign_member` has them\". `crm_campaign_member` has no view metadata\n * at all, which is what sent #944 looking; re-measuring the paragraph against\n * the shipped Console (17.0.0-rc.3) left only the form half standing.\n *\n * **`form` \u2014 live.** The Console merges a view bundle's `form` onto the object\n * definition it holds, and the record drawer a related list opens (\"New\" on\n * the panel, edit on a row) renders that form's `sections`. What the authored\n * form buys is the section split and the field order \u2014 not rescue from a raw\n * autonumber, because the no-form fallback is not raw either: in `create` mode\n * the drawer drops `autonumber`, `formula` and `summary` fields (and anything\n * hidden or readonly) and sections whatever is left by the object's own\n * `fieldGroups`. `attendee_number` was never on offer.\n *\n * **`list` \u2014 not what the related list reads.** A detail-page related list\n * takes its columns from the CHILD's lookup field \u2014 `relatedListColumns` on\n * `crm_event`, which this app authors nowhere \u2014 and falls back to the child\n * object's `highlightFields` minus the parent lookup, capped at six, with\n * columns that are empty on every fetched row dropped. Only an object with no\n * `highlightFields` reaches the last resort, and that is a heuristic over the\n * field map (title-ish names first, audit columns last, `rich_text` / `html` /\n * `json` excluded) \u2014 not declaration order, and never this view. So the\n * attendee panel on a meeting shows `attendee_type`, `response` and\n * `is_organizer`, straight off `crm_event_attendee.highlightFields`, whatever\n * the columns below say.\n *\n * The grid is therefore reachable only at this object's own list URL, which no\n * navigation entry links to. It is kept as the curated answer to \"what do you\n * show about an attendee\", and it is what a future `relatedListColumns` would\n * be copied from \u2014 but nothing in this repo may cite it as what makes a\n * related list readable. The load-bearing metadata is `highlightFields`, and\n * `test/view-references.test.ts` pins it for every object reached only through\n * a parent: strip it and the panel really does fall to the heuristic, which\n * leads with the autonumber these objects use as their `nameField`.\n */\nexport const EventAttendeeViews = defineView({\n  list: {\n    type: 'grid',\n    name: 'all_event_attendees',\n    label: 'Event Attendees',\n    userActions: { editInline: true },\n    data: { provider: 'object', object: 'crm_event_attendee' },\n    columns: [\n      { field: 'attendee_type', width: 120, sortable: true },\n      { field: 'crm_contact', width: 200 },\n      { field: 'crm_lead', width: 200 },\n      { field: 'sys_user', width: 200 },\n      { field: 'external_name', width: 200 },\n      { field: 'response', width: 140, sortable: true },\n      { field: 'is_organizer', width: 100, align: 'center' },\n    ],\n    sort: [{ field: 'is_organizer', order: 'desc' }],\n    rowColor: {\n      // Mirrors the option colors on crm_event_attendee.response.\n      field: 'response',\n      colors: { accepted: 'green', declined: 'red', tentative: 'orange', no_response: 'slate' },\n    },\n    pagination: { pageSize: 25 },\n  },\n\n  form: {\n    type: 'simple',\n    sections: [\n      {\n        name: 'attendee',\n        label: 'Attendee',\n        columns: 2,\n        fields: [\n          { field: 'crm_event', required: true },\n          { field: 'attendee_type', required: true },\n          'crm_contact',\n          'crm_lead',\n          'sys_user',\n          'external_name',\n        ],\n      },\n      {\n        name: 'invitation',\n        label: 'Invitation',\n        columns: 2,\n        fields: ['response', 'is_organizer', 'invited_date'],\n      },\n    ],\n  },\n});\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/sales/views/forecast.view.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/sales/views\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/sales/views/forecast.view.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport { defineView } from '@objectstack/spec/ui';\n\n/**\n * Forecast Views\n *\n *   \u2022 grid            \u2014 every snapshot\n *   \u2022 current_quarter \u2014 owners \u00D7 this-quarter row\n *   \u2022 my_forecast     \u2014 current user's snapshots\n */\nexport const ForecastViews = defineView({\n  list: {\n    type: 'grid',\n    name: 'all_forecasts',\n    label: 'All Forecasts',\n    userActions: { editInline: true },\n    data: { provider: 'object', object: 'crm_forecast' },\n    columns: [\n      { field: 'owner_id',            width: 160, pinned: 'left', link: true },\n      { field: 'period_label',     width: 130, sortable: true },\n      { field: 'period_start',     width: 130, sortable: true },\n      { field: 'snapshot_date',    width: 130, sortable: true },\n      { field: 'quota',            width: 130, align: 'right', summary: 'sum' },\n      { field: 'closed_amount',    width: 140, align: 'right', summary: 'sum' },\n      { field: 'commit_amount',    width: 140, align: 'right', summary: 'sum' },\n      { field: 'best_case_amount', width: 140, align: 'right', summary: 'sum' },\n      { field: 'pipeline_amount',  width: 140, align: 'right', summary: 'sum' },\n      // No total here: a formula has no stored column to aggregate, so the spec refuses `sum` on a `formula` field (#1980).\n      { field: 'expected_amount',  width: 140, align: 'right' },\n      { field: 'attainment_pct',   width: 130, align: 'right' },\n      { field: 'coverage_ratio',   width: 130, align: 'right' },\n      { field: 'source',           width: 130 },\n    ],\n    sort: [\n      { field: 'period_start',  order: 'desc' },\n      { field: 'owner_id',         order: 'asc' },\n    ],\n    grouping: { fields: [{ field: 'period_label', order: 'desc' }] },\n    pagination: { pageSize: 50 },\n    appearance: { allowedVisualizations: ['grid'] },\n  },\n\n  listViews: {\n    this_quarter_forecasts: {\n      name: 'this_quarter_forecasts',\n      type: 'grid',\n      // The label promises the CURRENT quarter, and the filter delivers it.\n      //\n      // The restriction was dropped in #515 on the measurement that \"the list\n      // data path resolves no date macro\". That measurement was taken on\n      // @objectstack 16.1.0 and has since expired: `resolveFilterTokens()` was\n      // wired into the ObjectQL READ path in 17.0.0-rc.0 (objectql\n      // `feat(filters): evaluate {filter-token} placeholders server-side`,\n      // #3582) \u2014 `find`/`findOne`/`count`/`aggregate`, ahead of the middleware\n      // chain, which is the one gate every server-side read passes through,\n      // saved-view filters included. Measured rather than inferred;\n      // `test/forecast-current-quarter-view.test.ts` runs THIS filter through a\n      // real engine and pins the three-way outcome (one quarter selected, not\n      // zero and not all of them). First taken on 17.0.0-rc.2, RE-RUN\n      // 2026-09-03 on 17.2.0 (#1467), RE-RUN on 17.3.0 (#1676, after the PR\n      // #1577 bump) and RE-RUN again on 17.4.0 (#1883, after the PR #1814\n      // bump), green all four times. Not yet re-run on 17.5.0; the test is\n      // what re-takes the reading on each new pin.\n      //\n      // Both halves of the key are load-bearing, same as the quota-attainment\n      // widget in `src/sales/dashboards/sales.dashboard.ts`: `period: 'quarter'`\n      // alone returns every quarter ever snapshotted (the #730 defect), and\n      // `period_start` alone merges the quarter row with the MONTH row that\n      // opens the same quarter \u2014 Q3 and July both start on the 1st.\n      //\n      // The old `{this_quarter_start}` spelling is not merely unresolved now,\n      // it is rejected: the resolver throws `Unresolvable filter placeholder`\n      // and names `{current_quarter_start}` as the fix, so the silent-empty\n      // failure mode that removal was reacting to is no longer reachable.\n      label: 'This Quarter',\n      userActions: { editInline: true },\n      data: { provider: 'object', object: 'crm_forecast' },\n      columns: ['owner_id', 'quota', 'closed_amount', 'commit_amount', 'best_case_amount', 'pipeline_amount', 'attainment_pct', 'coverage_ratio'],\n      filter: [\n        { field: 'period', operator: 'equals', value: 'quarter' },\n        { field: 'period_start', operator: 'equals', value: '{current_quarter_start}' },\n      ],\n      // One sort key, because the filter pins `period_start` to a single value\n      // \u2014 the `period_start desc` key that ranked quarters against each other\n      // existed only to float the current quarter to the top of an unscoped\n      // list, and is provably inert now that the list holds one quarter.\n      //\n      // The tiebreaker is NOT `attainment_pct desc`, which is a FORMULA \u2014 the\n      // engine computes it in JS after the query, so the data engine never saw\n      // that sort key and the ordering within a quarter was arbitrary (same\n      // class of defect as #489's `days_in_stage` filter). `closed_amount` is\n      // the stored numerator behind attainment and ranks the same direction.\n      sort: [\n        { field: 'closed_amount', order: 'desc' },\n      ],\n      // Empty is the honest state, and it needs to say so. The seeds ship no\n      // current-quarter row on purpose (#702 \u2014 the sweep owns that window, and\n      // two producers in one window is what left a phantom ownerless\n      // duplicate), so on a fresh install this view is empty until the 03:00\n      // `forecast_snapshot` sweep has run once. That is the same trade the\n      // quota-attainment widget already takes; without this copy the user\n      // cannot tell it apart from a broken view.\n      emptyState: {\n        title: 'This Quarter Has No Snapshots Yet',\n        message: 'Quarterly snapshots are written by the nightly forecast sweep. Until it has run once for the current quarter this view is empty \u2014 settled quarters are on the All tab.',\n        icon: 'calendar',\n      },\n    },\n    my_forecast: {\n      name: 'my_forecast',\n      type: 'grid',\n      label: 'My Forecast',\n      userActions: { editInline: true },\n      data: { provider: 'object', object: 'crm_forecast' },\n      columns: ['period_label', 'snapshot_date', 'quota', 'closed_amount', 'commit_amount', 'pipeline_amount', 'attainment_pct'],\n      // `{current_user_id}` is the only user token the view runtime resolves\n      // (`{current_user}` silently never matches).\n      filter: [{ field: 'owner_id', operator: 'equals', value: '{current_user_id}' }],\n      sort: [{ field: 'period_start', order: 'desc' }],\n    },\n  },\n\n  form: {\n    type: 'simple',\n    sections: [\n      {\n        name: 'snapshot',\n        label: 'Snapshot',\n        columns: 2,\n        fields: ['owner_id', 'period', 'period_start', 'period_end', 'period_label', 'snapshot_date', 'source'],\n      },\n      {\n        name: 'amounts',\n        label: 'Amounts',\n        columns: 2,\n        fields: ['quota', 'closed_amount', 'commit_amount', 'best_case_amount', 'pipeline_amount', 'expected_amount', 'attainment_pct', 'coverage_ratio'],\n      },\n      {\n        name: 'notes',\n        label: 'Notes',\n        columns: 1,\n        fields: ['notes'],\n      },\n    ],\n  },\n});\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/revenue/views/index.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/revenue/views\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/revenue/views/index.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\n/**\n * Revenue views barrel.\n *\n * The doctrine for this metadata type is written once, in\n * `src/sales/views/index.ts`; this file is the revenue package's half of\n * the same file-by-file registration.\n */\n\nexport { ContractViews } from './contract.view';\nexport { ProductViews } from './product.view';\nexport { QuoteViews } from './quote.view';\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/revenue/views/contract.view.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/revenue/views\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/revenue/views/contract.view.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport { defineView } from '@objectstack/spec/ui';\n\n/**\n * Contract Views\n *\n *   \u2022 grid     \u2014 contract register with renewal info\n *   \u2022 calendar \u2014 start/end dates\n *   \u2022 gantt    \u2014 contract terms timeline\n *   \u2022 timeline \u2014 chronological contract stream\n */\nexport const ContractViews = defineView({\n  list: {\n    type: 'grid',\n    name: 'all_contracts',\n    label: 'All Contracts',\n    userActions: { editInline: true },\n    data: { provider: 'object', object: 'crm_contract' },\n    columns: [\n      { field: 'contract_number', width: 150, link: true, pinned: 'left' },\n      { field: 'crm_account', width: 200 },\n      { field: 'crm_opportunity', width: 200 },\n      { field: 'status', width: 130, sortable: true },\n      { field: 'contract_value', width: 140, align: 'right', summary: 'sum' },\n      { field: 'contract_term_months', width: 130, align: 'right' },\n      { field: 'start_date', width: 130, sortable: true },\n      { field: 'end_date', width: 130, sortable: true },\n      { field: 'auto_renewal', width: 110, align: 'center' },\n      { field: 'owner_id', width: 150 },\n    ],\n    sort: [{ field: 'end_date', order: 'asc' }],\n    pagination: { pageSize: 25 },\n    selection: { type: 'multiple' },\n    appearance: {\n      allowedVisualizations: ['grid', 'calendar', 'gantt', 'timeline'],\n    },\n    // Binds the 'calendar' entry above: renewal dates, same as the dedicated\n    // `renewal_calendar` view and the field this list sorts by. A contract\n    // calendar answers \"what renews when\" \u2014 the start -> end term SPAN is\n    // already carried by `contract_gantt` and `contract_timeline`, which is\n    // why `end_date` is the start of the event here rather than an end.\n    calendar: {\n      startDateField: 'end_date',\n      titleField: 'contract_number',\n      colorField: 'status',\n    },\n  },\n\n  listViews: {\n    /** Renewal calendar (highlights upcoming end dates) */\n    renewal_calendar: {\n      name: 'renewal_calendar',\n      type: 'calendar',\n      label: 'Renewal Calendar',\n      data: { provider: 'object', object: 'crm_contract' },\n      columns: ['contract_number', 'crm_account', 'status'],\n      calendar: {\n        startDateField: 'end_date',\n        titleField: 'contract_number',\n        colorField: 'status',\n      },\n    },\n\n    /** Contract terms gantt */\n    contract_gantt: {\n      name: 'contract_gantt',\n      type: 'gantt',\n      label: 'Contract Terms',\n      data: { provider: 'object', object: 'crm_contract' },\n      columns: ['contract_number', 'crm_account', 'contract_value'],\n      gantt: {\n        startDateField: 'start_date',\n        endDateField: 'end_date',\n        titleField: 'contract_number',\n      },\n    },\n\n    /** Chronological timeline */\n    contract_timeline: {\n      name: 'contract_timeline',\n      type: 'timeline',\n      label: 'Contract Timeline',\n      data: { provider: 'object', object: 'crm_contract' },\n      columns: ['contract_number', 'crm_account'],\n      timeline: {\n        startDateField: 'start_date',\n        endDateField: 'end_date',\n        titleField: 'contract_number',\n        groupByField: 'crm_account',\n        colorField: 'status',\n        scale: 'quarter',\n      },\n    },\n  },\n\n  form: {\n    type: 'tabbed',\n    sections: [\n      {\n        name: 'parties',\n        label: 'Parties',\n        columns: 2,\n        fields: ['contract_number', 'crm_account', 'crm_contact', 'crm_opportunity', 'owner_id', 'status'],\n      },\n      {\n        // Named `contract_terms`, not `terms` \u2014 `terms` is already a distinct\n        // fieldGroup key on `crm_contract` (\"Terms & Dates\"), and reusing it\n        // here would make this section's translated heading follow that\n        // group's wording instead of its own \"Terms\".\n        name: 'contract_terms',\n        label: 'Terms',\n        columns: 2,\n        fields: [\n          'contract_term_months',\n          'start_date',\n          'end_date',\n          'contract_value',\n          'billing_frequency',\n          'payment_terms',\n          'auto_renewal',\n          'renewal_notice_days',\n        ],\n      },\n      {\n        name: 'signing_and_documents',\n        label: 'Signing & Documents',\n        columns: 2,\n        fields: ['signed_date', 'signed_by', 'document_url'],\n      },\n      {\n        // The contract's two markdown bodies, together and in the order a\n        // reader needs them \u2014 the question #1826 asked this form to answer.\n        // They are not redundant, and `content/docs/revenue/contracts.mdx`\n        // already rules which is which: **Description** is the plain summary\n        // of what this contract is (declared on the `basic` group, listed\n        // there under \"Contract Information\"), while **Special Terms** is\n        // where every free-text TERM goes \u2014 the doc sends renewal\n        // instructions, an unlisted billing cadence and an unlisted payment\n        // arrangement to Special Terms by name, three separate times.\n        // Description was the one field in that inventory no form offered, so\n        // the summary a reader was told the record carries could not be\n        // written. One column, because both are long-form.\n        name: 'notes',\n        label: 'Notes',\n        columns: 1,\n        fields: ['description', 'special_terms', 'billing_address'],\n      },\n    ],\n  },\n});\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/revenue/views/product.view.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/revenue/views\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/revenue/views/product.view.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport { defineView } from '@objectstack/spec/ui';\n\n/**\n * Product Views\n *\n *   \u2022 grid    \u2014 catalog listing\n *   \u2022 gallery \u2014 visual product catalog (`image` as cover)\n *\n * The `low_stock` view was removed with the inventory fields it was built on:\n * its columns, its filter and its sort key were all `quantity_on_hand` /\n * `reorder_point`, so it could not outlive them. It was never the stock report\n * it looked like either \u2014 the filter compared against a hardcoded 10 rather\n * than each product's own reorder point.\n */\nexport const ProductViews = defineView({\n  list: {\n    type: 'grid',\n    name: 'all_products',\n    label: 'All Products',\n    userActions: { editInline: true },\n    data: { provider: 'object', object: 'crm_product' },\n    columns: [\n      { field: 'product_code', width: 140, link: true, pinned: 'left' },\n      { field: 'name', width: 240, sortable: true },\n      { field: 'category', width: 140 },\n      { field: 'family', width: 140 },\n      { field: 'sku', width: 140 },\n      { field: 'list_price', width: 130, align: 'right', summary: 'avg' },\n      { field: 'cost', width: 130, align: 'right' },\n      { field: 'is_active', width: 100, align: 'center' },\n    ],\n    sort: [{ field: 'name', order: 'asc' }],\n    grouping: { fields: [{ field: 'category', order: 'asc' }] },\n    pagination: { pageSize: 50 },\n    selection: { type: 'multiple' },\n    appearance: {\n      allowedVisualizations: ['grid', 'gallery'],\n    },\n  },\n\n  listViews: {\n    /** Visual catalog */\n    product_catalog: {\n      name: 'product_catalog',\n      type: 'gallery',\n      label: 'Product Catalog',\n      data: { provider: 'object', object: 'crm_product' },\n      columns: ['name', 'category', 'list_price'],\n      gallery: {\n        coverField: 'image',\n        coverFit: 'cover',\n        cardSize: 'medium',\n        titleField: 'name',\n        visibleFields: ['product_code', 'category', 'family', 'list_price', 'sku'],\n      },\n    },\n  },\n\n  form: {\n    type: 'simple',\n    sections: [\n      {\n        name: 'product_info',\n        label: 'Product Info',\n        columns: 2,\n        fields: [\n          'product_code',\n          { field: 'name', required: true, span: 'full' },\n          'category',\n          'family',\n          'sku',\n          'product_manager',\n          'is_active',\n        ],\n      },\n      {\n        name: 'pricing_info',\n        label: 'Pricing',\n        columns: 2,\n        fields: ['list_price', 'cost'],\n      },\n      {\n        name: 'media',\n        label: 'Media',\n        columns: 1,\n        fields: ['image', 'datasheet', 'description'],\n      },\n    ],\n  },\n});\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/revenue/views/quote.view.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/revenue/views\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/revenue/views/quote.view.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport { defineView } from '@objectstack/spec/ui';\n\n/**\n * Quote Views\n *\n *   \u2022 grid     \u2014 quote register with totals\n *   \u2022 kanban   \u2014 quote workflow grouped by status\n *   \u2022 calendar \u2014 quote-date calendar\n */\nexport const QuoteViews = defineView({\n  list: {\n    type: 'grid',\n    name: 'all_quotes',\n    label: 'All Quotes',\n    userActions: { editInline: true },\n    data: { provider: 'object', object: 'crm_quote' },\n    columns: [\n      { field: 'quote_number', width: 140, link: true, pinned: 'left' },\n      { field: 'crm_account', width: 200 },\n      { field: 'crm_opportunity', width: 200 },\n      { field: 'status', width: 130, sortable: true },\n      { field: 'quote_date', width: 130, sortable: true },\n      { field: 'expiration_date', width: 140, sortable: true },\n      { field: 'subtotal', width: 130, align: 'right', summary: 'sum' },\n      { field: 'discount', width: 110, align: 'right' },\n      { field: 'tax', width: 110, align: 'right', summary: 'sum' },\n      { field: 'total_price', width: 140, align: 'right', summary: 'sum' },\n      { field: 'owner_id', width: 150 },\n    ],\n    sort: [{ field: 'quote_date', order: 'desc' }],\n    pagination: { pageSize: 25 },\n    selection: { type: 'multiple' },\n    appearance: {\n      allowedVisualizations: ['grid', 'kanban', 'calendar'],\n    },\n    // Binds the 'calendar' entry above: the same span the dedicated\n    // `quote_calendar` view shows. `quote_date` and `expiration_date` are both\n    // required + notNull on crm_quote, so every quote lands on a real window.\n    calendar: {\n      startDateField: 'quote_date',\n      endDateField: 'expiration_date',\n      titleField: 'quote_number',\n      colorField: 'status',\n    },\n  },\n\n  listViews: {\n    /** Quote workflow board */\n    quote_pipeline: {\n      name: 'quote_pipeline',\n      type: 'kanban',\n      label: 'Quote Pipeline',\n      data: { provider: 'object', object: 'crm_quote' },\n      columns: ['quote_number', 'crm_account', 'total_price', 'expiration_date'],\n      kanban: {\n        groupByField: 'status',\n        summarizeField: 'total_price',\n        columns: ['quote_number', 'crm_account', 'total_price', 'expiration_date'],\n      },\n    },\n\n    /** Quote-date calendar */\n    quote_calendar: {\n      name: 'quote_calendar',\n      type: 'calendar',\n      label: 'Quote Calendar',\n      data: { provider: 'object', object: 'crm_quote' },\n      columns: ['quote_number', 'crm_account', 'total_price'],\n      calendar: {\n        startDateField: 'quote_date',\n        endDateField: 'expiration_date',\n        titleField: 'quote_number',\n        colorField: 'status',\n      },\n    },\n  },\n\n  form: {\n    type: 'tabbed',\n    sections: [\n      {\n        name: 'quote',\n        label: 'Quote',\n        columns: 2,\n        // `name` is required on crm_quote with no default \u2014 omitting it made\n        // quote creation through this form impossible.\n        fields: [{ field: 'name', required: true, span: 'full' }, 'quote_number', 'crm_account', 'crm_contact', 'crm_opportunity', 'owner_id', 'status', 'quote_date', 'expiration_date'],\n      },\n      {\n        name: 'totals',\n        label: 'Totals',\n        columns: 2,\n        fields: ['subtotal', 'discount', 'discount_amount', 'tax', 'shipping_handling', 'total_price'],\n      },\n      {\n        // Named `quote_terms`, not `terms` \u2014 `terms` is already a distinct\n        // fieldGroup key on `crm_quote` (\"Terms & Validity\"), and reusing it\n        // here would make this section's translated heading follow that\n        // group's wording instead of its own \"Terms\".\n        name: 'quote_terms',\n        label: 'Terms',\n        columns: 2,\n        fields: ['payment_terms', 'shipping_terms'],\n      },\n      {\n        name: 'addresses_and_notes',\n        label: 'Addresses & Notes',\n        columns: 1,\n        fields: ['billing_address', 'shipping_address', 'internal_notes'],\n      },\n    ],\n  },\n});\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/marketing/views/index.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/marketing/views\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/marketing/views/index.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\n/**\n * Marketing views barrel.\n *\n * The doctrine for this metadata type is written once, in\n * `src/sales/views/index.ts`; this file is the marketing package's half of\n * the same file-by-file registration.\n */\n\nexport { CampaignViews } from './campaign.view';\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/marketing/views/campaign.view.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/marketing/views\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/marketing/views/campaign.view.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport { defineView } from '@objectstack/spec/ui';\n\n/**\n * Campaign Views\n *\n *   \u2022 grid     \u2014 performance grid with aggregated KPIs\n *   \u2022 gantt    \u2014 campaign schedule (start_date \u2192 end_date)\n *   \u2022 calendar \u2014 launch calendar\n *   \u2022 timeline \u2014 multi-campaign chronological view\n */\nexport const CampaignViews = defineView({\n  list: {\n    type: 'grid',\n    name: 'all_campaigns',\n    label: 'All Campaigns',\n    userActions: { editInline: true },\n    data: { provider: 'object', object: 'crm_campaign' },\n    columns: [\n      { field: 'name', width: 240, sortable: true, link: true, pinned: 'left' },\n      { field: 'channel', width: 130 },\n      { field: 'status', width: 130, sortable: true },\n      { field: 'start_date', width: 130, sortable: true },\n      { field: 'end_date', width: 130, sortable: true },\n      { field: 'budgeted_cost', width: 140, align: 'right', summary: 'sum' },\n      { field: 'expected_revenue', width: 160, align: 'right', summary: 'sum' },\n    ],\n    sort: [{ field: 'start_date', order: 'asc' }],\n    pagination: { pageSize: 25 },\n    selection: { type: 'multiple' },\n    appearance: {\n      showDescription: true,\n      allowedVisualizations: ['grid', 'gantt', 'calendar', 'timeline'],\n    },\n    // Binds the 'calendar' entry above: the switcher opens the same schedule\n    // the dedicated `campaign_calendar` view shows. Both dates are required +\n    // notNull on crm_campaign, so every campaign spans a truthful range.\n    calendar: {\n      startDateField: 'start_date',\n      endDateField: 'end_date',\n      titleField: 'name',\n      colorField: 'channel',\n    },\n  },\n\n  listViews: {\n    /** Campaign schedule */\n    campaign_gantt: {\n      name: 'campaign_gantt',\n      type: 'gantt',\n      label: 'Campaign Schedule',\n      data: { provider: 'object', object: 'crm_campaign' },\n      columns: ['name', 'channel'],\n      gantt: {\n        startDateField: 'start_date',\n        endDateField: 'end_date',\n        titleField: 'name',\n      },\n    },\n\n    /** Launch calendar */\n    campaign_calendar: {\n      name: 'campaign_calendar',\n      type: 'calendar',\n      label: 'Launch Calendar',\n      data: { provider: 'object', object: 'crm_campaign' },\n      columns: ['name', 'channel', 'status'],\n      calendar: {\n        startDateField: 'start_date',\n        endDateField: 'end_date',\n        titleField: 'name',\n        colorField: 'channel',\n      },\n    },\n\n    /** Marketing timeline */\n    campaign_timeline: {\n      name: 'campaign_timeline',\n      type: 'timeline',\n      label: 'Marketing Timeline',\n      data: { provider: 'object', object: 'crm_campaign' },\n      // The list data source projects configured columns. Keep the date\n      // fields in that projection so the timeline renderer can bucket and\n      // order campaigns from the same schedule data as the calendar/Gantt.\n      columns: ['name', 'channel', 'start_date', 'end_date'],\n      timeline: {\n        startDateField: 'start_date',\n        endDateField: 'end_date',\n        titleField: 'name',\n        groupByField: 'channel',\n        colorField: 'status',\n        scale: 'month',\n      },\n    },\n  },\n\n  form: {\n    type: 'tabbed',\n    sections: [\n      {\n        // Every form section here carries a `name` matching the object's\n        // fieldGroup key, so the heading resolves through\n        // `objects.crm_campaign._sections.<name>.label` in all four packs. A\n        // nameless section has no key a bundle can carry and renders its\n        // English label in every locale \u2014 the platform warns about exactly this\n        // during `objectstack validate`, and this form was carrying four of\n        // those warnings before the #597 restructure gave it a reason to move.\n        name: 'basic',\n        label: 'Campaign Information',\n        columns: 2,\n        fields: [\n          { field: 'name', required: true, span: 'full' },\n          'campaign_code',\n          'type',\n          'channel',\n          { field: 'status', required: true },\n          'owner_id',\n          'is_active',\n          'landing_page_url',\n          // The markdown body of the campaign brief. Declared on the `basic`\n          // group and filled by seven of the seed campaigns, but omitted from\n          // this enumeration \u2014 so the only surface that could show it did not,\n          // and a marketer could neither read nor write the brief they wrote.\n          { field: 'description', span: 'full' },\n        ],\n      },\n      {\n        name: 'schedule',\n        label: 'Schedule',\n        columns: 2,\n        fields: ['start_date', 'end_date'],\n      },\n      {\n        /**\n         * Budget & ROI \u2014 a SECTION OF ITS OWN, deliberately (#597).\n         *\n         * `budgeted_cost` and `actual_cost` are the only two campaign numbers\n         * that are manual-entry by design: nothing on the platform knows what a\n         * trade-show booth cost. They used to sit seventh and eighth in a\n         * seven-field \"Schedule & Budget\" row, below the dates and beside two\n         * revenue figures one of which the metric hooks own \u2014 so the two fields\n         * a marketer must type were the least visible things on the form, and\n         * `actual_cost` in particular went untyped.\n         *\n         * That is not a cosmetic complaint: `roi` divides by `actual_cost`, and\n         * its formula answers a flat `0.0` for any campaign where that field is\n         * blank. An empty cost field renders as 0% ROI on every campaign \u2014 the\n         * one number the whole Performance section exists to produce, reading\n         * as a real measurement rather than as missing input.\n         *\n         * So the costs get their own heading, and `roi` is displayed HERE with\n         * them rather than at the bottom of Performance, where its dependency\n         * on two fields three sections away was invisible. The heading matches\n         * the object's `budget` fieldGroup, so the form and the detail page\n         * agree on what this group is called.\n         */\n        name: 'budget',\n        label: 'Budget & ROI',\n        columns: 2,\n        fields: ['budgeted_cost', 'actual_cost', 'expected_revenue', 'actual_revenue', 'roi'],\n      },\n      {\n        name: 'metrics',\n        label: 'Performance',\n        columns: 2,\n        fields: [\n          'target_size',\n          'num_sent',\n          'num_responses',\n          'num_leads',\n          'num_converted_leads',\n          'num_opportunities',\n          'num_won_opportunities',\n          'response_rate',\n        ],\n      },\n    ],\n  },\n});\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/sales/pages/index.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/sales/pages\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/sales/pages/index.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\n/**\n * Sales (the app package) pages barrel.\n *\n * The doctrine for this metadata type is written once, in\n * `src/sales/pages/index.ts`; this file is the sales package's half of\n * the same file-by-file registration.\n */\n\nexport { LeadDetailPage } from './lead_detail.page';\nexport { OpportunityDetailPage } from './opportunity_detail.page';\nexport { AccountDetailPage } from './account_detail.page';\nexport { AccountWorkbenchPage } from './account_workbench.page';\nexport { SalesHomePage } from './home.page';\nexport { AppLauncherPage } from './app_launcher.page';\nexport { UtilityBarPage } from './utility_bar.page';\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/sales/pages/lead_detail.page.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/sales/pages\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/sales/pages/lead_detail.page.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport { Page } from '@objectstack/spec/ui';\nimport { P } from '@objectstack/spec';\n\n/**\n * Lead Detail Record Page\n *\n * Demonstrates a comprehensive record page layout similar to Salesforce Lightning Record Page.\n *\n * Features:\n * - Template-based layout with named regions\n * - Rich component composition (details, highlights, related lists)\n * - Component visibility rules\n * - Profile-based page assignment\n */\nexport const LeadDetailPage: Page = {\n  name: 'lead_detail_page',\n  label: 'Lead Detail',\n  description: 'Comprehensive lead detail page with highlights, details, and related information',\n\n  type: 'record',\n  object: 'crm_lead',\n\n  // Template defines the overall layout structure. We use `full-width`\n  // (single column) because the previous `header-sidebar-main` layout\n  // sandwiched the highlights strip into a cramped sidebar with no other\n  // meaningful sidebar content \u2014 Salesforce Lightning record pages\n  // similarly default to a stacked column for medium-density objects.\n  template: 'full-width',\n  kind: 'full',\n  // Page-level state variables\n  variables: [\n    {\n      name: 'showHistory',\n      type: 'boolean',\n      defaultValue: false,\n    },\n    {\n      name: 'activeTab',\n      type: 'string',\n      defaultValue: 'details',\n    },\n  ],\n\n  // Regions correspond to slots in the template\n  regions: [\n    {\n      name: 'header',\n      width: 'full',\n      components: [\n        // Title + subtitle + icon, with record-level actions rendered\n        // inline in the header's action slot via the first-class\n        // `actions` property (no sibling node, no visual offset hack).\n        {\n          type: 'page:header',\n          id: 'lead_header',\n          label: 'Lead Information',\n          properties: {\n            title: '{first_name} {last_name}',\n            subtitle: '{company}',\n            // `icon` removed from `page:header` in @objectstack/spec 17.0.0\n            // (#6946, ADR-0087 D2) \u2014 deleted, not renamed. See the full note on\n            // `account_detail.page.ts`; nothing ever drew it.\n            // `breadcrumb` retired from `page:header` in @objectstack/spec 17.6.0\n            // (#20785, `page-header-breadcrumb-removed`) \u2014 deleted: no renderer\n            // ever drew a trail for it; the app shell's own trail is unchanged.\n            // Convert is the outcome; scheduling the next touch is the daily\n            // act. Both belong in the header \u2014 the follow-up used to be four\n            // clicks deep in the Related tab.\n            //\n            // The three activity actions are listed EXPLICITLY (#592): a custom\n            // record page replaces the synthesized header, so an object-scoped\n            // action that is not named here is unreachable from the record \u2014\n            // only the list-row \u22EE menu can fire it. Logging the call you just\n            // made is the single most frequent thing a rep does on a lead, and\n            // it was two navigations away.\n            //\n            // Action IDs, not `ActionDef` objects: `PageHeaderProps.actions` is\n            // `z.array(z.string())` (\"Action IDs to show in header\") in\n            // @objectstack/spec 17.3.0, and this repo authors against the\n            // protocol (#1653). Each id is the `name` of a crm_lead-scoped\n            // action \u2014 `convert_lead` / `schedule_followup` in\n            // `src/sales/actions/lead.actions.ts`, the activity trio in\n            // `src/sales/actions/activity-actions.ts`.\n            actions: [\n              'convert_lead',\n              'schedule_followup',\n              'log_call',\n              'log_meeting',\n              'schedule_meeting',\n            ],\n          },\n        },\n        // Duplicate banners \u2014 ONE PER VERDICT (#1207 \u00B7 widened by #1289 \u00B7\n        // split by #1628).\n        //\n        // `lead_duplicate_check` (lead.hook.ts, job 2) already writes\n        // `duplicate_status: 'suspected'` and links the record the lead repeats\n        // \u2014 the flag existed, and this page never read it. A rep opened a\n        // flagged lead, saw a page identical to a clean one, and converted it\n        // into a second account, contact and opportunity. These banners and the\n        // `duplicates` section on the Details tab are the record-page half of\n        // that fix \u2014 the banner is the alarm, the section is the link to\n        // compare against; the conversion screen carries the other half.\n        //\n        // ## Why there are TWO of them (#1628)\n        //\n        // #1207 shipped one banner gated on `== \"suspected\"`, which left the\n        // STRONGER state silent. #1289 widened the predicate to every verdict\n        // and, being one component, had to pick copy that named NEITHER state:\n        // a `record:alert` carries a single `visible` and a single title/body\n        // pair, and `pickLocalized` picks by LANGUAGE, not by row \u2014 so naming\n        // one verdict would have mislabelled every lead in the other.\n        //\n        // That was correct for one banner, and it is why one banner is not\n        // enough. Since #1288 the two verdicts have OPPOSITE next steps:\n        //\n        //   suspected \u2014 the intake hook's guess. Conversion PROCEEDS; the rep\n        //               should compare against the linked record first.\n        //   confirmed \u2014 a reviewer's verdict. Conversion is REFUSED outright\n        //               (`lead-conversion.flow.ts`, `refuse_confirmed_duplicate`).\n        //\n        // One sentence cannot state either without being false for the other,\n        // so it stated neither, and the rep had to scroll to the Duplicate\n        // Status chip to learn which situation they were in. A banner that\n        // announces something is wrong but not what to do is not doing the one\n        // job a banner has. Two components, two predicates, two next steps.\n        //\n        // \u26A0\uFE0F Two sibling `record:alert` nodes really do BOTH render: a region\n        // renders as `components.map((node, i) => <SchemaRenderer key={node?.id\n        // || fallback} \u2026>)` \u2014 read out of the shipped console bundle at the\n        // `.objectui-sha` pin \u2014 so each is mounted separately and evaluates its\n        // own `visible` against the same row. Their `id`s are their React keys,\n        // which is why the two ids differ rather than sharing one.\n        //\n        // \u26A0\uFE0F `visible` is the ONE record component whose PROPS carry a real row\n        // predicate: `record-alert.tsx` evaluates `properties.visible` through\n        // `toPredicateInput` + `useCondition` against the row\n        // (`usePredicateRecordContext`), the same pipeline as an action button.\n        // A node-level `visibleWhen` is a different gate one tier up,\n        // evaluated by `SchemaRenderer`, and the two compose as AND. Measured\n        // on the 17.6.0 pin (#1887), that tier binds the page's row as\n        // `record` too (objectui#5454): this same predicate, moved there,\n        // gated correctly in both directions. `visible` stays because it is\n        // the gate `record:alert` declares in its own props.\n        //\n        // \u26A0\uFE0F `has()` is load-bearing, and this surface is the WORST of the four\n        // this repo measures (cf. `test/view-predicate-dialect.test.ts`): the\n        // renderer's call site is FAIL-SOFT \u2014 an unevaluable predicate answers\n        // SHOWN. So a bare `record.duplicate_status == \"suspected\"` would abort\n        // with `No such key` on every clean lead whose driver omits the column\n        // (`driver-memory` / `driver-mongodb`; `driver-sql` returns it as null)\n        // and put a duplicate warning on leads that are not duplicates. The\n        // guard is what makes the predicate answer `false` instead of faulting.\n        // Pinned on the real engine in `test/lead-duplicate-visibility.test.ts`.\n        //\n        // \u26D4 And the guard is NOT the whole predicate \u2014 `has()` ALONE is wrong\n        // here, in either shape. It is TRUE for a key that is PRESENT AND NULL,\n        // which is precisely what `driver-sql` hands back for a clean lead\n        // (measured: `has(record.duplicate_status)` against\n        // `{ duplicate_status: null }` answers `{ ok: true, value: true }`), so\n        // the guard needs a comparison beside it or the banner cries wolf on\n        // every clean lead. #1289, covering both verdicts at once, spelled that\n        // comparison `&& \u2026 != null`. A per-verdict banner spells it with the\n        // EQUALITY, which is strictly narrower and subsumes it: measured on\n        // this engine, `null == \"suspected\"` is a clean `false`, not a fault,\n        // and the two spellings agree on every record shape a driver can\n        // produce. Both halves of the shape #1289 ruled for are intact \u2014 the\n        // `has()` guard verbatim, and a comparison that makes \"set\" mean set \u2014\n        // and the comparison got STRICTER, which is the point of the split. The\n        // same spelling already ships one file over, on this same field: the\n        // conversion flow's `e21` / `e25` edges (#1288) read\n        // `has(vars.leadRecord.duplicate_status) && \u2026 == \"suspected\"`.\n        //\n        // \u26D4 Neither half may be simplified away. Both are pinned, shape by\n        // shape, including the reverse pin that the unguarded tail really does\n        // fault.\n        //\n        // `P` \u2014 an explicit `{ dialect: 'cel' }` envelope \u2014 is not decoration\n        // either: `ExpressionEvaluator.evaluateCondition` routes ONLY the\n        // envelope to `@objectstack/formula`'s CEL engine, where `has()` is a\n        // real function; a bare string takes the legacy JS path, whose\n        // `FormulaFunctions` has no CEL `has()`, so the guard would itself be\n        // the fault that fails soft to visible.\n        //\n        // `title` / `body` carry inline locale maps rather than plain strings:\n        // this renderer resolves both through `pickLocalized(\u2026, language)`\n        // (the same capability `opportunity_detail.page.ts` records under\n        // #972), and `body` has no other channel \u2014 the i18n extractor's\n        // per-component copy keys (`PAGE_COMPONENT_COPY_KEYS`, read on 17.6.0)\n        // are title/description/label/placeholder/emptyText, so a plain-string\n        // `body` would ship English to all four locales. Keeping both halves of one banner's copy in one\n        // place beats splitting `title` into the locale packs.\n        //\n        // \u2B50 Each banner's copy NAMES ITS OWN VERDICT, in the vocabulary the\n        // `duplicate_status` chip below publishes, and never the other one \u2014\n        // pinned against the option labels read out of the locale packs in\n        // `test/lead-duplicate-visibility.test.ts`, so renaming an option\n        // re-aims the assertion rather than retiring it.\n        {\n          type: 'record:alert',\n          id: 'lead_duplicate_alert_suspected',\n          label: 'Suspected Duplicate Alert',\n          properties: {\n            // `warning`, not `error`: conversion still PROCEEDS on this\n            // verdict, and the renderer maps `error` to `role=\"alert\"` /\n            // `aria-live=\"assertive\"` \u2014 an interruption this state has not\n            // earned.\n            severity: 'warning',\n            visible: P`has(record.duplicate_status) && record.duplicate_status == \"suspected\"`,\n            title: {\n              en: 'Suspected duplicate \u2014 compare before you convert',\n              'zh-CN': '\u7591\u4F3C\u91CD\u590D\u2014\u2014\u8F6C\u6362\u524D\u8BF7\u5148\u6BD4\u5BF9',\n              'ja-JP': '\u91CD\u8907\u306E\u7591\u3044 \u2014 \u5909\u63DB\u3059\u308B\u524D\u306B\u7167\u5408\u3057\u3066\u304F\u3060\u3055\u3044',\n              'es-ES': 'Duplicado Sospechoso: compare antes de convertir',\n            },\n            body: {\n              en:\n                'Intake matched this lead to a record this app already has. Duplicate '\n                + 'Management below links that record \u2014 open it and compare. You can still '\n                + 'convert this lead: this is the match intake guessed at, not a reviewer\\'s '\n                + 'decision. But if it is the same buyer, disqualify it instead, because '\n                + 'converting creates a second account, contact and opportunity for them.',\n              'zh-CN':\n                '\u5F55\u5165\u65F6\u53D1\u73B0\u8BE5\u7EBF\u7D22\u4E0E\u7CFB\u7EDF\u4E2D\u5DF2\u6709\u8BB0\u5F55\u5339\u914D\u3002\u4E0B\u65B9\u300C\u91CD\u590D\u7EBF\u7D22\u7BA1\u7406\u300D\u4E2D\u662F\u5B83\u91CD\u590D\u7684\u90A3\u6761\u8BB0\u5F55\uFF0C'\n                + '\u8BF7\u5148\u6253\u5F00\u6BD4\u5BF9\u3002\u8BE5\u7EBF\u7D22\u4ECD\u7136\u53EF\u4EE5\u8F6C\u6362\uFF1A\u8FD9\u662F\u5F55\u5165\u65F6\u7684\u81EA\u52A8\u5224\u65AD\uFF0C\u4E0D\u662F\u5BA1\u6838\u4EBA\u7684\u7ED3\u8BBA\u3002'\n                + '\u4F46\u82E5\u786E\u5C5E\u540C\u4E00\u5BA2\u6237\uFF0C\u8BF7\u6539\u4E3A\u53D6\u6D88\u8D44\u683C\u2014\u2014\u8F6C\u6362\u4F1A\u4E3A\u540C\u4E00\u5BA2\u6237\u518D\u521B\u5EFA\u4E00\u5957\u5BA2\u6237\u3001\u8054\u7CFB\u4EBA\u548C\u5546\u673A\u3002',\n              'ja-JP':\n                '\u767B\u9332\u6642\u306B\u3001\u3053\u306E\u30EA\u30FC\u30C9\u304C\u65E2\u5B58\u30EC\u30B3\u30FC\u30C9\u3068\u4E00\u81F4\u3057\u307E\u3057\u305F\u3002\u4E0B\u306E\u300C\u91CD\u8907\u7BA1\u7406\u300D\u306B\u91CD\u8907\u5148\u306E'\n                + '\u30EC\u30B3\u30FC\u30C9\u304C\u3042\u308A\u307E\u3059\u3002\u307E\u305A\u958B\u3044\u3066\u7167\u5408\u3057\u3066\u304F\u3060\u3055\u3044\u3002\u3053\u306E\u30EA\u30FC\u30C9\u306F\u307E\u3060\u5909\u63DB\u3067\u304D\u307E\u3059\u3002'\n                + '\u3053\u308C\u306F\u767B\u9332\u6642\u306E\u81EA\u52D5\u5224\u5B9A\u3067\u3042\u308A\u3001\u62C5\u5F53\u8005\u306E\u7D50\u8AD6\u3067\u306F\u3042\u308A\u307E\u305B\u3093\u3002\u305F\u3060\u3057\u540C\u3058\u76F8\u624B\u3067'\n                + '\u3042\u308C\u3070\u3001\u5909\u63DB\u305B\u305A\u4E0D\u9069\u683C\u306B\u3057\u3066\u304F\u3060\u3055\u3044\u3002\u5909\u63DB\u3059\u308B\u3068\u540C\u3058\u76F8\u624B\u306B\u53D6\u5F15\u5148\u30FB\u53D6\u5F15\u5148'\n                + '\u8CAC\u4EFB\u8005\u30FB\u5546\u8AC7\u304C\u3082\u3046\u4E00\u7D44\u4F5C\u6210\u3055\u308C\u307E\u3059\u3002',\n              'es-ES':\n                'La captura encontr\u00F3 que este prospecto coincide con un registro que ya '\n                + 'existe. Gesti\u00F3n de Duplicados, m\u00E1s abajo, enlaza ese registro: \u00E1bralo y '\n                + 'comp\u00E1relo. Todav\u00EDa puede convertir este prospecto, porque se trata de una '\n                + 'coincidencia autom\u00E1tica de la captura y no del veredicto de una persona. '\n                + 'Pero si es el mismo comprador, descalif\u00EDquelo en su lugar: convertirlo '\n                + 'crea una segunda cuenta, contacto y oportunidad para \u00E9l.',\n            },\n          },\n        },\n        {\n          type: 'record:alert',\n          id: 'lead_duplicate_alert_confirmed',\n          label: 'Confirmed Duplicate Alert',\n          properties: {\n            // `error`, and the level is the message: this is the state on which\n            // the app REFUSES the rep's next click, and the renderer gives\n            // `error` `role=\"alert\"` / `aria-live=\"assertive\"` rather than the\n            // polite `role=\"status\"` every other level gets. \u26D4 The severity is\n            // presentation only \u2014 what the app refuses was ruled by #1288 and\n            // shipped by PR #1555, and nothing here changes it.\n            severity: 'error',\n            visible: P`has(record.duplicate_status) && record.duplicate_status == \"confirmed\"`,\n            title: {\n              en: 'Confirmed duplicate \u2014 conversion will be refused',\n              'zh-CN': '\u5DF2\u786E\u8BA4\u91CD\u590D\u2014\u2014\u8F6C\u6362\u5C06\u88AB\u62D2\u7EDD',\n              'ja-JP': '\u91CD\u8907\u78BA\u5B9A \u2014 \u5909\u63DB\u306F\u62D2\u5426\u3055\u308C\u307E\u3059',\n              'es-ES': 'Duplicado Confirmado: la conversi\u00F3n ser\u00E1 rechazada',\n            },\n            body: {\n              // \u2B50 The only place a rep learns the Convert button will refuse\n              // them BEFORE they press it \u2014 until this banner, the refusal\n              // dialog was the first they heard of it.\n              en:\n                'A reviewer checked this lead and recorded that it repeats a record this app '\n                + 'already has, so Convert Lead refuses it \u2014 this banner is the only warning '\n                + 'you get before you press the button. Disqualify this lead instead, naming '\n                + 'the surviving record from Duplicate Management below. If the verdict is '\n                + 'wrong, a reviewer revises Duplicate Status; there is no override here.',\n              'zh-CN':\n                '\u5BA1\u6838\u4EBA\u5DF2\u6838\u5B9E\u8BE5\u7EBF\u7D22\u4E0E\u7CFB\u7EDF\u4E2D\u5DF2\u6709\u8BB0\u5F55\u91CD\u590D\uFF0C\u56E0\u6B64\u300C\u8F6C\u6362\u7EBF\u7D22\u300D\u4F1A\u62D2\u7EDD\u6267\u884C\u2014\u2014'\n                + '\u672C\u63D0\u793A\u662F\u4F60\u6309\u4E0B\u6309\u94AE\u524D\u552F\u4E00\u7684\u9884\u8B66\u3002\u8BF7\u6539\u4E3A\u53D6\u6D88\u8BE5\u7EBF\u7D22\u7684\u8D44\u683C\uFF0C\u5E76\u5728\u4E0B\u65B9'\n                + '\u300C\u91CD\u590D\u7EBF\u7D22\u7BA1\u7406\u300D\u4E2D\u6CE8\u660E\u4FDD\u7559\u7684\u90A3\u6761\u8BB0\u5F55\u3002\u82E5\u5224\u5B9A\u6709\u8BEF\uFF0C\u5E94\u7531\u5BA1\u6838\u4EBA\u4FEE\u6539'\n                + '\u300C\u91CD\u590D\u72B6\u6001\u300D\uFF0C\u6B64\u5904\u4E0D\u63D0\u4F9B\u5F3A\u5236\u8F6C\u6362\u7684\u5165\u53E3\u3002',\n              'ja-JP':\n                '\u62C5\u5F53\u8005\u304C\u78BA\u8A8D\u3057\u3001\u3053\u306E\u30EA\u30FC\u30C9\u306F\u65E2\u5B58\u30EC\u30B3\u30FC\u30C9\u306E\u91CD\u8907\u3067\u3042\u308B\u3068\u8A18\u9332\u3055\u308C\u307E\u3057\u305F\u3002'\n                + '\u305D\u306E\u305F\u3081\u300C\u30EA\u30FC\u30C9\u5909\u63DB\u300D\u306F\u62D2\u5426\u3055\u308C\u307E\u3059\u3002\u3053\u306E\u901A\u77E5\u304C\u3001\u30DC\u30BF\u30F3\u3092\u62BC\u3059\u524D\u306B\u5F97\u3089\u308C\u308B'\n                + '\u552F\u4E00\u306E\u8B66\u544A\u3067\u3059\u3002\u3053\u306E\u30EA\u30FC\u30C9\u306F\u4E0D\u9069\u683C\u306B\u3057\u305F\u3046\u3048\u3067\u3001\u4E0B\u306E\u300C\u91CD\u8907\u7BA1\u7406\u300D\u3067\u6B8B\u3059'\n                + '\u30EC\u30B3\u30FC\u30C9\u3092\u660E\u8A18\u3057\u3066\u304F\u3060\u3055\u3044\u3002\u5224\u5B9A\u304C\u8AA4\u3063\u3066\u3044\u308B\u5834\u5408\u306F\u62C5\u5F53\u8005\u304C\u300C\u91CD\u8907\u30B9\u30C6\u30FC\u30BF\u30B9\u300D'\n                + '\u3092\u4FEE\u6B63\u3057\u307E\u3059\u3002\u3053\u3053\u306B\u5F37\u5236\u5909\u63DB\u306E\u624B\u6BB5\u306F\u3042\u308A\u307E\u305B\u3093\u3002',\n              'es-ES':\n                'Una persona verific\u00F3 que este prospecto repite un registro que ya existe, '\n                + 'por lo que Convertir Prospecto lo rechazar\u00E1: este aviso es la \u00FAnica '\n                + 'advertencia antes de pulsar el bot\u00F3n. Descalifique el prospecto e indique '\n                + 'el registro que sobrevive desde Gesti\u00F3n de Duplicados, m\u00E1s abajo. Si el '\n                + 'veredicto es incorrecto, una persona debe cambiar el Estado del Duplicado; '\n                + 'aqu\u00ED no hay forma de forzar la conversi\u00F3n.',\n            },\n          },\n        },\n        // Salesforce-style Highlights Panel: a horizontal strip of the\n        // most-important key facts directly under the header. Pulled out\n        // of the sidebar so it can use the full page width.\n        {\n          type: 'record:highlights',\n          id: 'lead_highlights',\n          label: 'Key Information',\n          properties: {\n            fields: ['status', 'rating', 'lead_source', 'owner_id', 'email', 'phone'],\n          },\n        },\n        {\n          type: 'record:path',\n          id: 'lead_path',\n          label: 'Lead Status Path',\n          properties: {\n            statusField: 'status',\n            // `converted` is the terminal WIN state and must be on the path \u2014\n            // without it the strip reads as if \"Unqualified\" were the goal, and\n            // a converted lead had no stage to light up at all.\n            stages: [\n              { value: 'new', label: 'New' },\n              { value: 'contacted', label: 'Contacted' },\n              { value: 'qualified', label: 'Qualified' },\n              { value: 'converted', label: 'Converted' },\n              { value: 'unqualified', label: 'Unqualified' },\n            ],\n          },\n        },\n      ],\n    },\n\n    {\n      name: 'main',\n      width: 'large',\n      components: [\n        {\n          type: 'page:tabs',\n          id: 'main_tabs',\n          label: 'Lead Information Tabs',\n          properties: {\n            // `type` \u2192 `tabStyle` (@objectstack/spec 17.0.0, #6776, ADR-0087\n            // D2). Same three values; see the full note on `home.page.ts`.\n            tabStyle: 'line',\n            position: 'top',\n            items: [\n              {\n                label: 'Details',\n                icon: 'info-circle',\n                children: [\n                  {\n                    type: 'record:details',\n                    id: 'lead_details',\n                    label: 'Lead Details',\n                    properties: {\n                      columns: '2',\n                      // `layout` was REMOVED from `record:details` in\n                      // @objectstack/spec 17.0.0 (#6946, ADR-0087 D2) and is\n                      // deleted with no successor: its `auto` | `custom`\n                      // semantics were never implemented.\n                      //\n                      // Every section is a GROUP REFERENCE (#806, maintainer\n                      // ruling C, decision batch #21, 2026-09-03). `{ group }`\n                      // names one of crm_lead's `fieldGroups`, and the renderer\n                      // derives that section's members, label, icon and collapse\n                      // state from the object (`deriveFieldGroupLayout`,\n                      // ADR-0085 \u00A75). Membership has ONE declaration site \u2014 the\n                      // `group:` on each field in lead.object.ts \u2014 and this page\n                      // curates only the ORDER, so a field added to a group shows\n                      // up here with no edit to this file. \u26D4 Do not enumerate\n                      // `fields:` again, and do not restate a key the group owns\n                      // (`name` / `label` / `icon` / `collapsible` /\n                      // `defaultCollapsed`) beside `group`: the spec refuses both.\n                      //\n                      // \u26D4 `sections` stays load-bearing. Omitting it renders an\n                      // EMPTY Details tab, not a `fieldGroups` fallback (#806 R28\n                      // on 17.2.0, #1521); derivation is per section, through\n                      // `group:`, never page-level.\n                      //\n                      // Measured on @objectstack/console 17.6.0 (#806 R70,\n                      // headless Chromium, with a control leg; on 17.4.0 R61\n                      // measured this form crashing the component). What a\n                      // group section does there is the renderer's, not ours:\n                      //   - it lays out its own column count (the page-level\n                      //     `columns` above does not reach it);\n                      //   - a group whose members are all empty renders nothing\n                      //     (`duplicates` on a clean lead), unless the section\n                      //     says `hideEmpty: false`;\n                      //   - members the highlights strip registered are dropped,\n                      //     so `assignment` (only `owner_id`) renders nothing on\n                      //     this page \u2014 the owner is in the strip;\n                      //   - a group declared `collapse: 'collapsed'` starts\n                      //     collapsed; changing that is a `fieldGroups` decision\n                      //     in lead.object.ts, not a key on this page.\n                      //\n                      // `hideEmpty: false` (#2003, the #1211 reasoning) sits on\n                      // the groups whose every member a rep types and the\n                      // create form asks for: `contact_info` (`mobile` and\n                      // `website` once the strip takes `email` and `phone`),\n                      // `address`, and `additional` (revenue, headcount,\n                      // description, notes). Without it all three vanish on a\n                      // fresh lead, so a rep cannot see what is left to fill.\n                      // Not on `assignment`: its derived list is empty, and the\n                      // renderer draws nothing for an empty list whatever\n                      // `hideEmpty` says. Not on `duplicates`: the\n                      // `lead_duplicate_check` hook writes it.\n                      sections: [\n                        { group: 'identity' },\n                        { group: 'company_info' },\n                        { group: 'contact_info', hideEmpty: false },\n                        // Do Not Call / Email Opt Out, right under the numbers\n                        // a rep is about to dial (#806).\n                        { group: 'preferences' },\n                        { group: 'qualification' },\n                        { group: 'assignment' },\n                        { group: 'address', hideEmpty: false },\n                        { group: 'conversion' },\n                        // The LINK half of the duplicate banners (#1207): the\n                        // group carries both survivor lookups, because\n                        // `lead_duplicate_check` matches contacts before leads.\n                        // On a clean lead every member is empty, so the section\n                        // renders nothing. \u26A0\uFE0F Not the highlights strip:\n                        // `record:highlights` caps `fields` at 7 and holds 6.\n                        { group: 'duplicates' },\n                        // Description and Notes \u2014 kept last, where the page's\n                        // Description section always sat.\n                        { group: 'additional', hideEmpty: false },\n                      ],\n                    },\n                  },\n                ],\n              },\n              {\n                label: 'Related',\n                icon: 'link',\n                children: [\n                  {\n                    type: 'page:accordion',\n                    id: 'related_accordion',\n                    label: 'Related Records',\n                    properties: {\n                      allowMultiple: true,\n                      items: [\n                        {\n                          label: 'Tasks',\n                          icon: 'list-checks',\n                          collapsed: false,\n                          children: [\n                            {\n                              type: 'record:related_list',\n                              id: 'related_tasks',\n                              label: 'Tasks',\n                              properties: {\n                                objectName: 'crm_task',\n                                // crm_task links back through the polymorphic\n                                // `related_to_lead` lookup; there is no `lead_id`\n                                // column, so the old binding matched nothing and\n                                // this list read \"0\" no matter how many follow-ups\n                                // the rep had filed.\n                                relationshipField: 'related_to_lead',\n                                columns: ['subject', 'status', 'priority', 'due_date', 'owner_id'],\n                                sort: [\n                                  { field: 'due_date', order: 'asc' }\n                                ],\n                                limit: 10,\n                                title: 'Open Tasks',\n                                filter: [{ field: 'status', operator: 'not_equals', value: 'completed' }],\n                                showViewAll: true,\n                              },\n                            },\n                          ],\n                        },\n                      ],\n                    },\n                  },\n                ],\n              },\n              {\n                label: 'Activity',\n                icon: 'clock',\n                children: [\n                  {\n                    type: 'record:activity',\n                    id: 'lead_activity',\n                    label: 'Activity Timeline',\n                    properties: {\n                      // `types` is keyed on FEED ITEM KIND, never on object name\n                      // (#1209). The old `['crm_task']` was not one of the kinds\n                      // the prop accepts, and nothing anywhere enforced that: the\n                      // page schema's `properties` is an open bag\n                      // (`z.record(z.string(), z.unknown())`) so the value was\n                      // stored verbatim, and the renderer's own sanitiser drops\n                      // members it does not recognise and then reads the EMPTY\n                      // remainder as \"no filter authored\" \u2014 measured on the\n                      // shipped bundle, `types: ['crm_task']`, `types: []` and\n                      // omitting `types` all render the same unfiltered stream.\n                      // That is why the tab showed `Created Lead` / `Updated\n                      // Lead` audit rows, which the History tab already covers.\n                      //\n                      // What this component can actually show is `sys_activity`\n                      // scoped to the record, through the renderer's own\n                      // type map \u2014 measured, not inferred:\n                      //\n                      //   sys_activity.type      feed kind      written by\n                      //   created/updated/\u2026      field_change   platform audit\n                      //   system                 system         platform\n                      //   completed              task           log_call /\n                      //                                         log_meeting /\n                      //                                         send_email\n                      //   scheduled              (dropped)      schedule_meeting\n                      //\n                      // So `task` is the kind that carries a rep's logged\n                      // interactions, and it is the only reachable one worth\n                      // filtering to. `event` is NOT added: it is a legal kind\n                      // the prop accepts but no `sys_activity.type` maps to it,\n                      // so it would be a declared value enforced by nothing.\n                      // `scheduled` rows fall out of the map upstream \u2014 a\n                      // platform gap, not something to work around here.\n                      types: ['task'],\n                      limit: 20,\n                      // Load-bearing, not cosmetic: the renderer strips every\n                      // `task` item BEFORE the `types` filter runs unless this is\n                      // true, and `task` items are exactly the `completed` rows.\n                      // `types: ['task']` with the old `showCompleted: false`\n                      // renders an empty tab.\n                      showCompleted: true,\n                    },\n                  },\n                ],\n              },\n              {\n                label: 'History',\n                icon: 'history',\n                children: [\n                  {\n                    // `record:history` is the platform's own audit feed over the\n                    // fields marked `trackHistory` (status / rating). Ownership\n                    // moved to the platform's `owner_id` in #548, which carries no\n                    // `trackHistory` flag \u2014 transfers land in the compliance audit\n                    // log, not on this feed.\n                    // The hand-rolled version queried an object named\n                    // `field_history`, which this app does not define, so the\n                    // tab could only ever render empty.\n                    type: 'record:history',\n                    id: 'lead_history',\n                    label: 'Field History',\n                    properties: {\n                      limit: 25,\n                    },\n                  },\n                ],\n              },\n            ],\n          },\n        },\n      ],\n    },\n  ],\n\n  // Make this the default page for leads\n  isDefault: true,\n\n  // ARIA accessibility\n  aria: {\n    ariaLabel: 'Lead Detail Page',\n    ariaDescribedBy: 'Detailed view of lead information with related records and activity',\n  },\n};\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/sales/pages/opportunity_detail.page.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/sales/pages\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/sales/pages/opportunity_detail.page.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport { Page } from '@objectstack/spec/ui';\n\n/**\n * Opportunity Detail Record Page\n *\n * Salesforce Lightning-style record page for the `crm_opportunity` object.\n * Mirrors the lead_detail blueprint: single-column full-width layout with\n * a Lightning-style header chip, primary action, key highlights strip and\n * status path, then a tab strip below. No sidebar \u2014 secondary widgets such\n * as the AI assistant live in the floating console chat instead.\n */\nexport const OpportunityDetailPage: Page = {\n  name: 'opportunity_detail_page',\n  label: 'Opportunity Detail',\n  description: 'Comprehensive opportunity detail page with path, highlights, details, and related lists',\n\n  type: 'record',\n  object: 'crm_opportunity',\n\n  template: 'full-width',\n  kind: 'full',\n  variables: [\n    { name: 'activeTab', type: 'string', defaultValue: 'details' },\n  ],\n\n  regions: [\n    {\n      name: 'header',\n      width: 'full',\n      components: [\n        {\n          type: 'page:header',\n          id: 'opp_header',\n          label: 'Opportunity Information',\n          properties: {\n            title: '{name}',\n            // The lookup field is `crm_account` \u2014 `{account}` matched nothing\n            // and the subtitle rendered blank.\n            subtitle: '{crm_account}',\n            // `icon` removed from `page:header` in @objectstack/spec 17.0.0\n            // (#6946, ADR-0087 D2) \u2014 deleted, not renamed. See the full note on\n            // `account_detail.page.ts`; nothing ever drew it.\n            // `breadcrumb` retired from `page:header` in @objectstack/spec 17.6.0\n            // (#20785, `page-header-breadcrumb-removed`) \u2014 deleted: no renderer\n            // ever drew a trail for it; the app shell's own trail is unchanged.\n            // generate_quote is the CPQ entry point (opportunity \u2192 quote); a\n            // custom record page replaces the default header, so the action\n            // must be listed here explicitly or it is unreachable. The same\n            // sentence is why the three activity actions are named here (#592):\n            // without them a rep can log a call on the deal only from the list\n            // row's \u22EE menu, never from the deal itself.\n            //\n            // Action IDs, not `ActionDef` objects: `PageHeaderProps.actions` is\n            // `z.array(z.string())` (\"Action IDs to show in header\") in\n            // @objectstack/spec 17.3.0, and this repo authors against the\n            // protocol (#1653). Each id is the `name` of a\n            // crm_opportunity-scoped action \u2014 `generate_quote` /\n            // `clone_opportunity` in `src/sales/actions/opportunity.actions.ts`, the\n            // activity trio in `src/sales/actions/activity-actions.ts`.\n            actions: [\n              'generate_quote',\n              'clone_opportunity',\n              'log_call',\n              'log_meeting',\n              'schedule_meeting',\n            ],\n          },\n        },\n        {\n          type: 'record:highlights',\n          id: 'opp_highlights',\n          label: 'Key Information',\n          properties: {\n            fields: ['amount', 'close_date', 'probability', 'expected_revenue', 'owner_id', 'crm_account'],\n          },\n        },\n        {\n          type: 'record:path',\n          id: 'opp_stage_path',\n          label: 'Opportunity Stage Path',\n          properties: {\n            statusField: 'stage',\n            // Every canonical value of `stage` must appear here, in funnel\n            // order \u2014 the path is the only place a rep reads \"where is this\n            // deal\". `needs_analysis` was missing, so a deal sitting in that\n            // stage lit up NO step at all and the strip read as if the deal\n            // had skipped from Qualification to Proposal. The two terminal\n            // stages stay last (won before lost), matching lead_detail's\n            // converted/unqualified tail.\n            stages: [\n              { value: 'prospecting', label: 'Prospecting' },\n              { value: 'qualification', label: 'Qualification' },\n              { value: 'needs_analysis', label: 'Needs Analysis' },\n              { value: 'proposal', label: 'Proposal' },\n              { value: 'negotiation', label: 'Negotiation' },\n              { value: 'closed_won', label: 'Closed Won' },\n              { value: 'closed_lost', label: 'Closed Lost' },\n            ],\n          },\n        },\n      ],\n    },\n    {\n      name: 'main',\n      width: 'large',\n      components: [\n        {\n          type: 'page:tabs',\n          id: 'opp_main_tabs',\n          properties: {\n            // `type` \u2192 `tabStyle` (@objectstack/spec 17.0.0, #6776, ADR-0087\n            // D2). Same three values; see the full note on `home.page.ts`.\n            tabStyle: 'line',\n            position: 'top',\n            items: [\n              {\n                // Tab item `key` \u2192 `value` (#1269): `value` is the stable\n                // `?tab=` URL token the renderer reads, `key` is read by\n                // nothing. See the full note on `case_detail.page.ts`.\n                value: 'details',\n                label: 'Details',\n                children: [\n                  {\n                    type: 'record:details',\n                    id: 'opp_details',\n                    label: 'Opportunity Details',\n                    properties: {\n                      // `columns` is a STRING enum ('1'|'2'|'3'|'4') in\n                      // @objectstack/spec 17. `layout` is gone (removed in spec\n                      // 17.0.0, #6946 / ADR-0087 D2).\n                      columns: '2',\n                      // Every section references one of crm_opportunity's\n                      // `fieldGroups` (#1452, the #806 class ruling C): the\n                      // renderer derives members, label, icon and collapse state\n                      // from the object, so this page curates only the order.\n                      // The full note \u2014 what a group section does on 17.6.0 and\n                      // what may not sit beside `group` \u2014 is on\n                      // `lead_detail.page.ts`.\n                      //\n                      // The highlights strip still wins (#1211): the renderer\n                      // drops every field `record:highlights` registered, and the\n                      // record title, from the derived members. So `basic` shows\n                      // `primary_contact` only, and `financials` (`amount`,\n                      // `expected_revenue`, both in the strip) renders nothing\n                      // here \u2014 it stays referenced so that a field added to the\n                      // group reaches this tab without an edit to this file.\n                      //\n                      // `hideEmpty: false` keeps an ALL-empty section on screen\n                      // (#1211). The platform default (objectui#8603 ruling A)\n                      // renders such a section as nothing at all, so on a deal\n                      // with only its required fields the deal's type and\n                      // source (`classification`), its campaign (`campaign`)\n                      // and its description and next step (`notes`) vanished \u2014\n                      // the very fields a seller fills in later. Kept, they\n                      // show as labelled empty rows to fill. Measured on\n                      // 17.6.0 on such a deal: 2 sections render without it, 5\n                      // with it. Not on `basic` (its only member outside the\n                      // title and the strip is `primary_contact`), nor on\n                      // `financials`: both members sit in the strip, the\n                      // derived list is empty, and the renderer draws nothing\n                      // for an empty list whatever `hideEmpty` says.\n                      //\n                      // `qualification` and `narrative` (REQ-0006) sit right\n                      // after `sales_process`, the order the object declares\n                      // them in, and both keep `hideEmpty: false` on the same\n                      // reasoning: every member is a judgement or a piece of\n                      // prose the seller is expected to write (bid / no-bid,\n                      // controllability, priority, deal level, subcontracting;\n                      // the four narrative fields), none sits in the strip, and\n                      // no deal that predates REQ-0006 carries any of them \u2014 so\n                      // without the key both sections vanish on every existing\n                      // deal, which is exactly where a seller would fill them.\n                      sections: [\n                        { group: 'basic' },\n                        { group: 'financials' },\n                        { group: 'classification', hideEmpty: false },\n                        { group: 'campaign', hideEmpty: false },\n                        { group: 'sales_process' },\n                        { group: 'qualification', hideEmpty: false },\n                        { group: 'narrative', hideEmpty: false },\n                        { group: 'crm_forecast' },\n                        { group: 'notes', hideEmpty: false },\n                      ],\n                    },\n                  },\n                ],\n              },\n              {\n                value: 'related',\n                label: 'Related',\n                children: [\n                  {\n                    type: 'page:accordion',\n                    id: 'opp_related_accordion',\n                    properties: {\n                      items: [\n                        {\n                          // Accordion item `key` is DELETED, not renamed to\n                          // `value` \u2014 the opposite verdict to the tab items\n                          // above, because this renderer overwrites `value` with\n                          // `panel-<index>`. See the full note on\n                          // `case_detail.page.ts`.\n                          label: 'Quotes',\n                          // OPEN on arrival (#1214 item 6). All three panels\n                          // used to start shut, so the Related tab opened on\n                          // three closed bars whose headers already carried the\n                          // counts \u2014 the click bought the user nothing the page\n                          // had not already told them.\n                          //\n                          // `collapsed: false` is the whole mechanism, and it is\n                          // needed even though the schema DEFAULTS it to false:\n                          // the renderer opens the panels it finds by strict\n                          // identity \u2014 `items.filter(i => i.collapsed === false)`\n                          // \u2014 so an item that simply omits the key is\n                          // `undefined`, not `false`, and stays shut. Measured\n                          // on the @objectstack/console 17.3.0 bundle \u2014 the pin\n                          // at that taking, \u26D4 NOT re-taken on 17.4.0\n                          // (#1814, #1807) or 17.5.0 \u2014\n                          // and the component's own designer text says the same\n                          // (\"collapsed: false opens a panel by default\").\n                          //\n                          // \u26A0\uFE0F ONLY the first panel, and that is the renderer's\n                          // choice rather than a preference: with `allowMultiple`\n                          // absent (it defaults false) the accordion mounts as\n                          // `type=\"single\"` and takes `defaultValue={open[0]}` \u2014\n                          // one panel, the first in declaration order. Marking\n                          // Products or Open Tasks too would change nothing on\n                          // screen. Opening more than one means declaring\n                          // `allowMultiple: true`, which changes the interaction\n                          // model (panels stop closing each other) and is not\n                          // this card's ask.\n                          //\n                          // \u26D4 NOT \"default-open the sections that have rows\",\n                          // which the card asked for first: that is not\n                          // expressible here. `collapsed` is a static boolean on\n                          // a strict item shape (`label` / `icon` / `collapsed` /\n                          // `children` \u2014 nothing else parses), the page is\n                          // authored metadata evaluated before any row is read,\n                          // and the related lists below fetch their own rows\n                          // after mount. Reported rather than worked around; \u26D4\n                          // the component is not this repo's to change.\n                          collapsed: false,\n                          children: [\n                            {\n                              type: 'record:related_list',\n                              id: 'opp_quotes',\n                              properties: {\n                                objectName: 'crm_quote',\n                                relationshipField: 'crm_opportunity',\n                                columns: ['quote_number', 'name', 'status', 'total_price', 'expiration_date'],\n                                limit: 10,\n                              },\n                            },\n                          ],\n                        },\n                        {\n                          label: 'Products',\n                          children: [\n                            {\n                              type: 'record:related_list',\n                              id: 'opp_products',\n                              properties: {\n                                objectName: 'crm_opportunity_line_item',\n                                relationshipField: 'crm_opportunity',\n                                columns: ['crm_product', 'quantity', 'unit_price', 'total_price'],\n                                limit: 10,\n                                // The entry point that was missing (#1731). Every\n                                // OTHER surface already treated line items as\n                                // live \u2014 three profiles grant `allowCreate`, the\n                                // docs describe the amount rolling up from them,\n                                // and `billing-handoff.flow.ts`'s\n                                // `load_line_items` reads them on every won deal\n                                // \u2014 while nothing in the app could create one:\n                                // no action, no list view, no navigation entry,\n                                // no seed. A rep who wanted to itemise a deal had\n                                // to type the Amount by hand. Declared surface and\n                                // reachable surface now coincide again.\n                                //\n                                // What `add` writes is the whole reason a picker\n                                // is sufficient here. It creates a row carrying\n                                // exactly two authored keys \u2014\n                                // `{ [relationshipField]: <opportunityId>,\n                                //    [linkField]: <pickedProductId> }` \u2014 and\n                                // nothing else. On this object that would leave\n                                // `quantity` and `unit_price` unset, and both are\n                                // `required` + `storage.notNull`, so the insert\n                                // would be refused. It is not, because the two\n                                // gaps are already filled by machinery that\n                                // predates this list:\n                                //\n                                //   quantity   -> the field's own `defaultValue: 1`\n                                //   unit_price -> `_line-item-price-fill.ts`, which\n                                //                 on `beforeInsert` stamps\n                                //                 `list_price` from the chosen\n                                //                 product and defaults the\n                                //                 negotiated `unit_price` to it\n                                //   discount   -> the field's own `defaultValue: 0`\n                                //   total_price-> the formula over the three above\n                                //\n                                // and `crm_product.list_price` is itself `required`\n                                // + `notNull`, so the hook can never fail to find a\n                                // source. Measured end-to-end, not reasoned:\n                                // `test/opportunity-line-item-add-picker.test.ts`\n                                // inserts the picker's exact two-key shape and\n                                // asserts the complete priced row, with an ablation\n                                // that unbinds the hook and shows the same insert\n                                // rejected as \"Sales Price is required\" \u2014 so the\n                                // assertion cannot pass vacuously.\n                                //\n                                // \u26D4 Do not add a `label`. The button falls back to\n                                // the platform's own localized \"Add\"; the\n                                // translation bundles reach a page component through\n                                // `pages.<page>.components.<id>`, which carries\n                                // `label`/`title`/`description` for the COMPONENT\n                                // and has no route to a nested `add.label`. A\n                                // hand-authored string here would ship English into\n                                // the zh-CN / es-ES / ja-JP bundles with no key to\n                                // translate it under.\n                                //\n                                // `valueField` and `labelField` are both omitted on\n                                // purpose rather than restated: `valueField`\n                                // defaults to `id`, which is what the `crm_product`\n                                // lookup stores, and `labelField` defaults to the\n                                // picked object's own title field \u2014 `crm_product`\n                                // declares `nameField: 'display_title'` (ADR-0079),\n                                // so the picker labels rows \"PRD-0001 - Widget\" and\n                                // keeps ONE source of truth for a product's title.\n                                // That formula title is searchable only because the\n                                // object also declares `searchableFields`, which it\n                                // already does for exactly this reason.\n                                add: {\n                                  picker: {\n                                    object: 'crm_product',\n                                    // A retired product must not be sellable onto a\n                                    // new deal. `product.hook.ts`'s `beforeDelete`\n                                    // defines retirement as precisely this flag\n                                    // (\"Set is_active=false to retire instead\"),\n                                    // so the catalog's own retirement mechanism is\n                                    // what scopes the picker. All 13 seeded\n                                    // products carry `is_active: true`, so this\n                                    // narrows without emptying.\n                                    filter: [{ field: 'is_active', operator: 'equals', value: true }],\n                                  },\n                                  linkField: 'crm_product',\n                                },\n                              },\n                            },\n                          ],\n                        },\n                        {\n                          label: 'Open Tasks',\n                          children: [\n                            {\n                              type: 'record:related_list',\n                              id: 'opp_tasks',\n                              properties: {\n                                objectName: 'crm_task',\n                                relationshipField: 'related_to_opportunity',\n                                columns: ['subject', 'status', 'priority', 'due_date', 'owner_id'],\n                                filter: [{ field: 'status', operator: 'not_equals', value: 'completed' }],\n                                limit: 10,\n                              },\n                            },\n                          ],\n                        },\n                      ],\n                    },\n                  },\n                ],\n              },\n              {\n                value: 'activity',\n                label: 'Activity',\n                children: [\n                  {\n                    type: 'record:activity',\n                    id: 'opp_activity',\n                    /**\n                     * `filters` is deleted with nothing put in its place, and\n                     * that is the whole finding (#1269).\n                     *\n                     * It used to read `['all', 'tasks', 'meetings', 'calls',\n                     * 'emails']` \u2014 a vocabulary that exists nowhere in the\n                     * contract. `RecordActivityProps` has exactly two filter\n                     * channels and neither takes that list:\n                     *\n                     *   `types`      \u2014 an array of FEED ITEM KINDS\n                     *                  (`comment` | `field_change` | `task` |\n                     *                  `event` | `email` | `call` | \u2026). Not\n                     *                  these values: `all` is not a kind and\n                     *                  `meetings` is not one either (the kind\n                     *                  is `event`), and all five are plural\n                     *                  where the enum is singular.\n                     *   `filterMode` \u2014 ONE default for the panel's dropdown,\n                     *                  from `all` | `comments_only` |\n                     *                  `changes_only` | `tasks_only`. The\n                     *                  dropdown's option list is the renderer's,\n                     *                  not authorable.\n                     *\n                     * So the list was reaching for a third thing \u2014 \"offer these\n                     * filter chips\" \u2014 that the component does not expose. What\n                     * it wanted is already delivered: `showFilterToggle`\n                     * defaults on, so the panel renders its filter dropdown, and\n                     * `filterMode` defaults to `all`, so it opens unfiltered.\n                     * Neither is restated here, because materializing a default\n                     * turns \"the author said nothing\" into \"the author asked for\n                     * the default\" \u2014 a different fact, and the one a later\n                     * liveness audit reads.\n                     *\n                     * Mapping it onto `types` instead was considered and\n                     * rejected: #1209 corrected exactly that mistake one page\n                     * over (the lead timeline's `types: ['crm_task']`), and the\n                     * renderer sanitises out-of-enum members then reads the\n                     * EMPTY remainder as \"no filter authored\" \u2014 so a bad `types`\n                     * is indistinguishable from no `types` on screen while\n                     * claiming otherwise in source. A `types` here would also\n                     * be a NEW restriction nobody asked for: it would drop\n                     * comments and field changes from a timeline that shows them\n                     * today.\n                     */\n                    properties: {\n                      limit: 25,\n                      // Load-bearing (#2071): a call or meeting logged on the\n                      // deal is a `sys_activity` row of type `completed` (the\n                      // `task` feed kind), and the renderer drops every such\n                      // row unless this is true \u2014 so a rep's logged call never\n                      // reached this tab. The deal's other `completed` writers\n                      // are its own won / lost milestones\n                      // (`opportunity.object.ts`), which belong here too.\n                      // Completed crm_task rows do NOT arrive: their audit rows\n                      // are keyed to the task, and this feed reads only rows\n                      // keyed to the deal. Nor is this the `types` restriction\n                      // the note above refuses: it adds rows and filters none.\n                      showCompleted: true,\n                    },\n                  },\n                ],\n              },\n            ],\n          },\n        },\n      ],\n    },\n    {\n      name: 'aside',\n      width: 'small',\n      components: [\n        {\n          type: 'record:reference_rail',\n          id: 'opp_reference_rail',\n          properties: {\n            /**\n             * No entry declares a `title` \u2014 deliberately (#972).\n             *\n             * The rail resolves a card's heading as\n             * `entry.title || i18n.objectLabel({ name: objectName, \u2026 })`, so a\n             * literal `title` does not merely provide a default: it WINS, and\n             * the locale bundle is never consulted. The three literals that\n             * used to sit here (`Quotes` / `Products` / `Open Tasks`) therefore\n             * printed English into every one of the four locales this app\n             * ships, on top of `objects.<name>.label` already being translated\n             * in all of them. Dropping them hands the heading back to the\n             * translation bundle \u2014 the single source of truth for what an\n             * object is called \u2014 so a locale added later is covered for free.\n             *\n             * A translated literal is not available as an alternative: unlike\n             * `record:alert`, whose `title` is run through the inline\n             * translation-map resolver, the rail renders `entry.title` as a\n             * raw React child. An `{ en, 'zh-CN' }` map here would not be\n             * resolved \u2014 it would be handed to React as an object.\n             *\n             * The third card losing the word \"Open\" is a correction, not a\n             * casualty. A rail entry has no filter at all \u2014 the rail queries\n             * `{ $filter: { [relationshipField]: parentId }, $top: limit }` and\n             * reads nothing else \u2014 so that card always counted and listed this\n             * deal's tasks whatever their status. The heading claimed a filter\n             * the component cannot apply. The genuinely filtered view is the\n             * `opp_tasks` related list on the *Related* tab above, which does\n             * carry `status neq completed`.\n             *\n             * Pinned by `test/metadata-references.test.ts` (entries resolve,\n             * no literal titles) and `test/i18n-references.test.ts` (every\n             * rail object has a `label` in every locale, so the fallback\n             * lands on a translation rather than on a humanized object name).\n             */\n            entries: [\n              {\n                objectName: 'crm_quote',\n                relationshipField: 'crm_opportunity',\n                limit: 3,\n              },\n              {\n                objectName: 'crm_opportunity_line_item',\n                relationshipField: 'crm_opportunity',\n                limit: 3,\n              },\n              {\n                objectName: 'crm_task',\n                relationshipField: 'related_to_opportunity',\n                limit: 3,\n              },\n            ],\n          },\n        },\n      ],\n    },\n  ],\n\n  isDefault: true,\n\n  aria: {\n    ariaLabel: 'Opportunity Detail Page',\n    ariaDescribedBy: 'Detailed view of opportunity information with related records and activity',\n  },\n};\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/sales/pages/account_detail.page.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/sales/pages\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/sales/pages/account_detail.page.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport type { Page } from '@objectstack/spec/ui';\n\n/**\n * Account Detail \u2014 slotted record page.\n *\n * We use ObjectUI's **slotted page** pattern: the default-page\n * synthesizer owns layout (header, highlights, path, tabs with\n * Details/Related/Activity/History, reference rail). We override\n * two slots:\n *\n *   header   \u00B7 Custom `page:header` with title and subtitle. It used to\n *              claim an ACCOUNT eyebrow, a building icon and a breadcrumb\n *              back to the list; none of them ever drew anything (#1269 and\n *              the props notes below \u2014 `breadcrumb` retired in 17.6.0).\n *\n *   discussion \u00B7 `record:chatter` is already auto-emitted, but we\n *              re-state it so it ALWAYS appears \u2014 even on accounts\n *              with no related lists (the auto-emitter sometimes\n *              skips chatter for lean objects). Discussion is core\n *              to the chat-first vibe, and it is the account's\n *              activity timeline: its one `feed` turns on the\n *              completed rows a logged call or meeting writes\n *              (see the slot's note).\n *\n * Why not embed an inline chat panel? `ai:chat_window` was dropped\n * from objectui (see @object-ui/layout CHANGELOG 5.x). The supported\n * surface is the global floating chatbot mounted by app-shell, which\n * picks up `defaultAgent: 'ask'` from this app and is launched from\n * the FAB at the bottom-right.\n */\nexport const AccountDetailPage = {\n  name: 'account_detail_page',\n  label: 'Account Detail',\n  description:\n    'Slotted account record page \u2014 custom header + persistent discussion feed.',\n\n  type: 'record',\n  object: 'crm_account',\n\n  kind: 'slotted',\n  regions: [],\n\n  slots: {\n    header: {\n      type: 'page:header',\n      id: 'account_header_slotted',\n      label: 'Account Header (slotted)',\n      properties: {\n        title: '{name}',\n        subtitle: '{industry} \u00B7 {type}',\n        // `icon` and `eyebrow` are GONE, and for two different reasons \u2014 both\n        // measured against the contract rather than inferred from the warning\n        // text (#1269).\n        //\n        // `icon` was REMOVED from `page:header` in @objectstack/spec 17.0.0\n        // (#6946, ADR-0087 D2). It is deleted rather than renamed because no\n        // renderer ever read it: objectui resolves `icon` per header ACTION\n        // (`action.icon`) and never off the header's own props bag, and the\n        // component registry never published it as an input \u2014 which is what put\n        // the key in objectui's `UNPUBLISHED_EXEMPTIONS` as a \"spec declares it,\n        // NO renderer read point\" entry. The header's own identity comes from\n        // the record chrome (`recordChrome`, on by default).\n        //\n        // `eyebrow` was never declared by anything. It is not in\n        // `PageHeaderProps`, it has no alias or tombstone there, and the string\n        // \"eyebrow\" does not occur anywhere in objectui \u2014 no schema, no\n        // registry input, no renderer. So the ACCOUNT kicker this page's\n        // docblock used to promise has never reached a screen: the props bag is\n        // `z.record(z.string(), z.unknown())`, so the key was carried into the\n        // artifact and dropped at render. Deleting it changes nothing a user\n        // sees; it only stops the source claiming a kicker exists.\n        // `breadcrumb` retired from `page:header` in @objectstack/spec 17.6.0\n        // (#20785, `page-header-breadcrumb-removed`) \u2014 deleted: no renderer\n        // ever drew a trail for it; the app shell's own trail is unchanged.\n        // Overriding the `header` slot REPLACES the synthesized header, actions\n        // and all \u2014 so this slot has to re-state every action it wants to keep.\n        // Before #592 it named none, which is why an account record showed no\n        // activity buttons at all while the list row's \u22EE menu showed three.\n        //\n        // Action IDs, not `ActionDef` objects: `PageHeaderProps.actions` is\n        // `z.array(z.string())` (\"Action IDs to show in header\") in\n        // @objectstack/spec 17.3.0, and this repo authors against the protocol\n        // (#1653). Each id is the `name` of a crm_account-scoped action in\n        // `src/sales/actions/activity-actions.ts`.\n        actions: ['log_call', 'log_meeting', 'schedule_meeting'],\n      },\n    },\n\n    discussion: {\n      type: 'record:chatter',\n      id: 'account_chatter',\n      label: 'Discussion',\n      /**\n       * One `feed`, for one reason: `showCompleted` (#2071).\n       *\n       * This feed IS the account's activity timeline \u2014 the slotted page\n       * synthesizes no Activity tab, so the panel's \"All Activity\" stream is\n       * where an account's `sys_activity` rows surface. A call or meeting\n       * logged on the account is a row of type `completed` (the `task` feed\n       * kind), and the timeline drops every such row unless\n       * `feed.showCompleted` is true \u2014 so Log a Call / Log a Meeting on an\n       * account wrote a row that appeared nowhere on the account.\n       *\n       * Authoring a `feed` costs two more keys, and they are stated rather\n       * than left out. `RecordChatterRenderer` builds `{ position: 'bottom',\n       * collapsible: false, feed: { enableReactions: true, enableThreading:\n       * true, showCommentInput: true }, ...schema }` \u2014 one shallow spread \u2014 so\n       * a `feed` of our own REPLACES that default object wholesale, and\n       * `RecordActivityTimeline` reads `enableReactions ?? false` and\n       * `enableThreading ?? false` off what is left. Without the two keys\n       * below, reactions and threading would silently switch off.\n       * `showCommentInput` needs no restating: the timeline reads it as\n       * `!== false`.\n       *\n       * `feed.enableMentions` needs none either: the renderer reads it as\n       * `!== false` too. And the older note still holds (#1269):\n       * `enableComments` and a top-level `enableReactions` / `enableMentions`\n       * are not `record:chatter` keys \u2014 `RecordChatterProps` declares\n       * `position`, `width`, `collapsible`, `defaultCollapsed`, `feed` and\n       * `aria`, nothing else.\n       */\n      properties: {\n        feed: {\n          showCompleted: true,\n          enableReactions: true,\n          enableThreading: true,\n        },\n      },\n    },\n  },\n} as unknown as Page;\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/sales/pages/account_workbench.page.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/sales/pages\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/sales/pages/account_workbench.page.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport { Page } from '@objectstack/spec/ui';\n\n/**\n * Account Workbench \u2014 ADR-0047 interface page (Airtable Interfaces parity).\n *\n * The author-curated counterpart to the Accounts object nav entry. Where\n * the object entry (data mode) shows every list view as switcher tabs and\n * offers the full toolbar, this page is deliberately closed:\n *\n *   \u2022 it REFERENCES the account default view (`sourceView`) \u2014 columns,\n *     base filter and sort are inherited, never restated (the iron rule);\n *   \u2022 end users get exactly three quick filters: industry (with record\n *     counts), customer type, and owner_id (the platform ownership lookup \u2014\n *     renders as a\n *     record-picker dropdown);\n *   \u2022 the visualization is locked to grid (single-entry whitelist);\n *   \u2022 advanced filtering / view management are not offered.\n *\n * Filter selections persist as `uf_*` URL params \u2014 reload-safe, shareable.\n *\n * NOTE: `interfaceConfig.userFilters` requires @objectstack/spec > 9.2.0\n * (ADR-0047). On older specs defineStack strips the unknown keys and the\n * page renders without the filter bar \u2014 a harmless no-op until the\n * dependency bump activates it.\n */\nexport const AccountWorkbenchPage: Page = {\n  name: 'account_workbench',\n  label: 'Account Workbench',\n  description: 'Curated account list for the sales team: quick filters only, no view management.',\n  type: 'list',\n  object: 'crm_account',\n  kind: 'full',\n  template: 'default',\n  isDefault: false,\n  // Interface pages carry no regions \u2014 the list surface is generated from\n  // `interfaceConfig` (ADR-0047), not composed from components.\n  regions: [],\n  interfaceConfig: {\n    source: 'crm_account',\n    sourceView: 'all_accounts',\n\n    ...({\n      userFilters: {\n        element: 'dropdown',\n        fields: [\n          { field: 'industry', showCount: true },\n          { field: 'type' },\n          { field: 'owner_id' },\n        ],\n      },\n      // typed via spread-as-any until @objectstack/spec ships ADR-0047\n      // (UserFiltersSchema is in framework main, > 9.2.0)\n    } as any),\n\n    appearance: {\n      showDescription: true,\n      allowedVisualizations: ['grid'],\n    },\n\n    userActions: {\n      sort: true,\n      search: true,\n      filter: false,\n      rowHeight: false,\n      addRecordForm: false,\n    },\n\n    showRecordCount: true,\n  },\n};\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/sales/pages/home.page.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/sales/pages\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/sales/pages/home.page.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport { Page, PageComponent, View } from '@objectstack/spec/ui';\nimport { EventViews } from '../views/event.view';\nimport { LeadViews } from '../views/lead.view';\nimport { OpportunityViews } from '../views/opportunity.view';\nimport { TaskViews } from '../views/task.view';\n\n/**\n * Embed one of an object's OWN saved list views in a page region.\n *\n * The home tabs used to hold a bare `{ type: 'page:section', properties: {} }`\n * each, which renders an empty `<section>` \u2014 three tab names promising content\n * over three blank panels. Same lesson as the `record:highlights` card below:\n * a component with no binding renders nothing, silently.\n *\n * `list-view` is the block that renders an object list inside a page (it is in\n * the platform's public block contract, ADR-0080), and it takes its columns /\n * filter / sort inline \u2014 there is no way for a page component to name a saved\n * view, so those three keys are READ OFF the saved view here rather than\n * retyped. That is the same iron rule `account_workbench.page.ts` states for\n * interface pages: columns, base filter and sort are inherited, never restated.\n * Retyping them would have created a second definition of \"my leads\" that\n * drifts from `src/sales/views/lead.view.ts` the first time either side is edited.\n *\n * `{current_user_id}` in a saved view's filter resolves on this path (the\n * ObjectQL read path runs `resolveFilterTokens()` since 17.0.0-rc.0), so\n * \"mine\" really does mean mine here \u2014 measured tab by tab in the browser, see\n * the PR. The nav's My Work group reaches the SAME views by name\n * (`src/sales/apps/crm.app.ts`); these tabs are the landing-page shortcut to them.\n */\nconst embeddedListView = (id: string, objectName: string, views: View, viewKey: string): PageComponent => {\n  const view = views.listViews?.[viewKey];\n  // Loud, at build time: a renamed or deleted view must not degrade back into\n  // a blank tab \u2014 that is the defect this whole component replaces.\n  if (!view) throw new Error(`home.page.ts: no saved view \"${viewKey}\" on ${objectName}`);\n  return {\n    type: 'list-view',\n    id,\n    label: view.label,\n    properties: {\n      objectName,\n      viewType: 'grid',\n      columns: view.columns,\n      filter: view.filter,\n      sort: view.sort,\n    },\n  };\n};\n\n/**\n * Sales Home Page\n *\n * Demonstrates a home page layout with dashboards and quick access widgets.\n * Similar to Salesforce Lightning Home Page.\n *\n * Features:\n * - Dashboard-style layout\n * - Multiple component regions\n * - Global search and notifications\n * - Quick action cards\n */\nexport const SalesHomePage: Page = {\n  name: 'sales_home_page',\n  label: 'Sales Home',\n  description: 'Sales team home page with key metrics and quick actions',\n  \n  type: 'home',\n  \n  template: 'three-column',\n  kind: 'full',  \n  variables: [\n    {\n      name: 'selectedPeriod',\n      type: 'string',\n      defaultValue: 'this_month',\n    },\n  ],\n  \n  regions: [\n    {\n      name: 'header',\n      width: 'full',\n      components: [\n        {\n          type: 'page:header',\n          id: 'home_header',\n          label: 'Sales Home Header',\n          properties: {\n            title: 'Sales Dashboard',\n            // Was `Welcome back, {current_user.first_name}`, which rendered as\n            // \"Welcome back, \" \u2014 the name was never going to arrive, because\n            // that one string mixes three vocabularies that do not compose:\n            //\n            //  1. `subtitle` is an `I18nLabel` (`ComponentPropsMap`,\n            //     `@objectstack/spec/ui`) \u2014 a display string or an inline\n            //     locale map, resolved by `resolveI18nLabel`. The field has no\n            //     token pass and no expression pass of its own.\n            //  2. Braces DO resolve in a page header, but the vocabulary is the\n            //     BOUND RECORD's own fields \u2014 `case_detail.page.ts` records the\n            //     measurement, where `{account}` matched no field and the\n            //     subtitle rendered blank until it was spelled `{crm_account}`.\n            //     A `type: 'home'` page has no record, so no brace token can\n            //     ever resolve here.\n            //  3. `current_user.first_name` is a CEL path, and CEL is written\n            //     bare, never inside `{\u2026}`. The one resolvable brace token in\n            //     the filter vocabulary is `{current_user_id}` on its own.\n            //\n            // A greeting that names the user is not expressible on a\n            // translatable label, so the label now says the part that is true\n            // in every locale and the four bundles carry the translations\n            // (`pages.sales_home_page.subtitle`). Personalising it would need a\n            // component that takes user data \u2014 no shipped component does\n            // (`user:profile` and its neighbours are `emptyProps` rows), so\n            // this is a static greeting rather than a widened accept surface.\n            subtitle: 'Welcome back',\n            // `icon` removed from `page:header` in @objectstack/spec 17.0.0\n            // (#6946, ADR-0087 D2) \u2014 deleted, not renamed. See the full note on\n            // `account_detail.page.ts`; nothing ever drew it.\n            // `breadcrumb` retired from `page:header` in @objectstack/spec 17.6.0\n            // (#20785, `page-header-breadcrumb-removed`) \u2014 deleted: no renderer\n            // ever drew a trail for it; the app shell's own trail is unchanged.\n          },\n        },\n      ],\n    },\n    \n    {\n      name: 'left_sidebar',\n      width: 'small',\n      components: [\n        {\n          type: 'page:card',\n          id: 'quick_create',\n          label: 'Quick Create',\n          properties: {\n            title: 'Quick Create',\n            bordered: true,\n            children: [\n              {\n                type: 'nav:menu',\n                id: 'create_menu',\n                properties: {},\n              },\n            ],\n          },\n        },\n        // There is no `Recent Items` card here any more, and re-adding one\n        // needs a data source that does not exist yet.\n        //\n        // It shipped as a `page:card` with a title and no body: a bordered box\n        // with the words \"Recent Items\" and nothing under them, on the landing\n        // page of every `sales_rep` / `sales_manager`. \"Recent\" is per-user\n        // access history across objects, and the platform publishes no source\n        // for it on 17.1.0 \u2014 `ComponentPropsMap` has no recent-records\n        // component, and the two that sound like one (`record:activity`,\n        // `record:history`) both read the page's BOUND RECORD, which a home\n        // page does not have. Binding it to one object's list view instead\n        // would have made the title lie, which is the defect #771 exists to\n        // prevent, so the card is removed rather than filled with something\n        // that is not recency. Recorded as #1217; when the platform ships a\n        // recent-records source, this is where the card goes back.\n      ],\n    },\n    \n    {\n      name: 'main',\n      width: 'large',\n      components: [\n        {\n          type: 'page:card',\n          id: 'key_metrics',\n          label: 'Key Metrics',\n          properties: {\n            title: 'Key Performance Indicators',\n            bordered: false,\n            // `record:highlights` needs a bound record and real fields; a home\n            // page has neither, and the four names it listed (total_revenue,\n            // deals_won, \u2026) exist on no object \u2014 the card rendered blank.\n            // `object-metric` widgets aggregate live data instead.\n            children: [\n              {\n                type: 'object-metric',\n                id: 'kpi_revenue_won',\n                properties: {\n                  objectName: 'crm_opportunity',\n                  label: 'Revenue (Won)',\n                  icon: 'dollar-sign',\n                  aggregate: { field: 'amount', function: 'sum' },\n                  filter: [{ field: 'stage', operator: 'equals', value: 'closed_won' }],\n                },\n              },\n              {\n                type: 'object-metric',\n                id: 'kpi_deals_won',\n                properties: {\n                  objectName: 'crm_opportunity',\n                  label: 'Deals Won',\n                  icon: 'trophy',\n                  aggregate: { field: 'id', function: 'count' },\n                  filter: [{ field: 'stage', operator: 'equals', value: 'closed_won' }],\n                },\n              },\n              {\n                type: 'object-metric',\n                id: 'kpi_pipeline_value',\n                properties: {\n                  objectName: 'crm_opportunity',\n                  label: 'Pipeline Value',\n                  icon: 'briefcase',\n                  aggregate: { field: 'amount', function: 'sum' },\n                  filter: [{ field: 'stage', operator: 'not_in', value: ['closed_won', 'closed_lost'] }],\n                },\n              },\n              {\n                type: 'object-metric',\n                id: 'kpi_open_leads',\n                properties: {\n                  objectName: 'crm_lead',\n                  label: 'Open Leads',\n                  icon: 'user-plus',\n                  aggregate: { field: 'id', function: 'count' },\n                  filter: [{ field: 'is_converted', operator: 'equals', value: false }],\n                },\n              },\n            ],\n          },\n        },\n        {\n          type: 'page:tabs',\n          id: 'home_tabs',\n          label: 'Home Tabs',\n          properties: {\n            /**\n             * `type` \u2192 `tabStyle` (@objectstack/spec 17.0.0, #6776, ADR-0087\n             * D2). The concept and the value vocabulary (`line` | `card` |\n             * `pill`) are unchanged; only the spelling moved, because a props\n             * key named `type` collides with the page component's own dispatch\n             * key: objectui's `SchemaRenderer` hoists `properties` onto the node\n             * but deliberately skips `type` and `id` (or the inner value would\n             * shadow which renderer to dispatch to), and `sdui-parser` lists\n             * `type` in `BASE_PROPS`, so a manifest input by that name is never\n             * validated at all.\n             *\n             * Renaming is behaviour-preserving on this page and on the three\n             * record pages: the renderer resolves\n             * `schema?.properties?.type || schema?.tabStyle || 'line'`, so it\n             * has been honouring the retired spelling as a back-compat read all\n             * along and picks up the canonical one through the same hoist.\n             */\n            tabStyle: 'card',\n            position: 'top',\n            items: [\n              {\n                label: 'My Leads',\n                icon: 'user-plus',\n                children: [embeddedListView('home_my_leads', 'crm_lead', LeadViews, 'my_leads')],\n              },\n              {\n                // Was \"My Opportunities\", which promises every deal I own; the\n                // view behind it is the open-pipeline one (the nav's My Work >\n                // My Deals opens the same `my_open_deals`). The tab name now\n                // says what the panel shows.\n                label: 'My Open Deals',\n                icon: 'dollar-sign',\n                children: [embeddedListView('home_my_deals', 'crm_opportunity', OpportunityViews, 'my_open_deals')],\n              },\n              {\n                // Same correction: `my_open_tasks` excludes completed tasks.\n                label: 'My Open Tasks',\n                icon: 'list-checks',\n                children: [embeddedListView('home_my_tasks', 'crm_task', TaskViews, 'my_open_tasks')],\n              },\n            ],\n          },\n        },\n      ],\n    },\n    \n    {\n      name: 'right_sidebar',\n      width: 'medium',\n      components: [\n        {\n          type: 'page:card',\n          id: 'ai_briefing',\n          // The assistant is the PLATFORM's (`ask`), not an app-owned persona:\n          // HotCRM contributes skills, the agent lives in the cloud side\n          // (maintainer ruling on #612, 2026-08-04). The retired `sales_copilot`\n          // agent (#512, ADR-0063 \u00A72) must not be named in live UI copy \u2014 and\n          // the entry point is the assistant panel the platform opens from the\n          // right edge of every page, which is the wording\n          // `content/docs/ai-copilot/index.mdx` landed in #611/PR #1001.\n          label: 'Today with the AI Assistant',\n          properties: {\n            title: 'Ask the AI Assistant',\n            bordered: true,\n            // The paragraph is an `element:text` child (#1581). It used to be\n            // `properties.description`, which `page:card` does not declare, so\n            // the card rendered as a title over nothing. `content` is not on\n            // the locale pack's page-component face, so the four languages\n            // live here as an inline locale map, the spec's route for page\n            // prose. The #1002 persona guard in\n            // `test/metadata-references.test.ts` reads this child.\n            children: [\n              {\n                type: 'element:text',\n                id: 'ai_briefing_text',\n                properties: {\n                  content: {\n                    en: 'Open the assistant panel from the right edge of the page and ask \"what should I focus on today?\" \u2014 it sees your live pipeline, schema, and accounts.',\n                    'zh-CN':\n                      '\u4ECE\u9875\u9762\u53F3\u4FA7\u6253\u5F00\u52A9\u624B\u9762\u677F\uFF0C\u8BE2\u95EE\"\u6211\u4ECA\u5929\u5E94\u8BE5\u5173\u6CE8\u4EC0\u4E48\uFF1F\"\u2014\u2014\u5B83\u53EF\u4EE5\u5B9E\u65F6\u67E5\u770B\u60A8\u7684\u9500\u552E\u7BA1\u9053\u3001\u67B6\u6784\u4E0E\u5BA2\u6237\u4FE1\u606F\u3002',\n                    'es-ES':\n                      'Abra el panel del asistente desde el borde derecho de la p\u00E1gina y pregunte \"\u00BFen qu\u00E9 deber\u00EDa concentrarme hoy?\" \u2014 ve su flujo de ventas, esquema y cuentas en tiempo real.',\n                    'ja-JP':\n                      '\u30DA\u30FC\u30B8\u53F3\u7AEF\u304B\u3089\u30A2\u30B7\u30B9\u30BF\u30F3\u30C8\u30D1\u30CD\u30EB\u3092\u958B\u304D\u3001\u300C\u4ECA\u65E5\u306F\u4F55\u306B\u96C6\u4E2D\u3059\u3079\u304D\u304B\uFF1F\u300D\u3068\u5C0B\u306D\u3066\u304F\u3060\u3055\u3044 \u2014 \u30EA\u30A2\u30EB\u30BF\u30A4\u30E0\u306E\u30D1\u30A4\u30D7\u30E9\u30A4\u30F3\u3001\u30B9\u30AD\u30FC\u30DE\u3001\u53D6\u5F15\u5148\u60C5\u5831\u3092\u628A\u63E1\u3057\u3066\u3044\u307E\u3059\u3002',\n                  },\n                },\n              },\n            ],\n          },\n        },\n        {\n          type: 'page:card',\n          id: 'upcoming_events',\n          // Was `Calendar` / \"Today's Schedule\" over an empty bordered box \u2014\n          // the card declared no body, so the renderer had nothing to draw.\n          //\n          // It is bound to `crm_event`'s saved `upcoming_events` view, read off\n          // the view exactly like the tabs above, and the name now matches what\n          // the panel shows. \"Today's Schedule\" is NOT what any existing view\n          // says: `my_events` is scoped to the current user but carries no date\n          // filter, no sort and no date column (27 seeded rows, mostly `held`\n          // interactions from the past), while `upcoming_events` is\n          // `status: 'planned'` sorted by `start_datetime` ascending with the\n          // date on the row. Narrowing either one to today would mean retyping\n          // a filter in this page \u2014 the second definition the helper above\n          // exists to prevent \u2014 so the title says \"upcoming\" instead of\n          // promising a day this page cannot compute.\n          label: 'Upcoming Events',\n          properties: {\n            title: 'Upcoming Events',\n            bordered: true,\n            children: [embeddedListView('home_upcoming_events', 'crm_event', EventViews, 'upcoming_events')],\n          },\n        },\n      ],\n    },\n  ],\n  \n  isDefault: true,\n  \n  aria: {\n    ariaLabel: 'Sales Home Page',\n    ariaDescribedBy: 'Sales team home page with metrics, leads, and quick actions',\n  },\n};\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/sales/pages/app_launcher.page.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/sales/pages\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/sales/pages/app_launcher.page.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport { Page } from '@objectstack/spec/ui';\n\n/**\n * App Launcher Page\n * \n * Demonstrates an application launcher page similar to Salesforce App Launcher.\n * \n * Features:\n * - Grid-based app icon layout\n * - Global search\n * - Quick access to all apps\n */\nexport const AppLauncherPage: Page = {\n  name: 'app_launcher_page',\n  label: 'App Launcher',\n  description: 'Central hub for accessing all applications',\n  \n  type: 'app',\n  \n  template: 'centered',\n  kind: 'full',  \n  regions: [\n    {\n      name: 'header',\n      width: 'full',\n      components: [\n        {\n          type: 'global:search',\n          id: 'app_search',\n          label: 'Search Apps',\n          properties: {},\n        },\n      ],\n    },\n    \n    {\n      name: 'main',\n      width: 'large',\n      components: [\n        {\n          type: 'page:header',\n          id: 'launcher_header',\n          label: 'App Launcher Header',\n          properties: {\n            title: 'App Launcher',\n            subtitle: 'Select an app to get started',\n            // `icon` removed from `page:header` in @objectstack/spec 17.0.0\n            // (#6946, ADR-0087 D2) \u2014 deleted, not renamed. See the full note on\n            // `account_detail.page.ts`; nothing ever drew it.\n            // `breadcrumb` retired from `page:header` in @objectstack/spec 17.6.0\n            // (#20785, `page-header-breadcrumb-removed`) \u2014 deleted: no renderer\n            // ever drew a trail for it; the app shell's own trail is unchanged.\n          },\n        },\n        {\n          type: 'app:launcher',\n          id: 'app_grid',\n          label: 'Application Grid',\n          properties: {},\n        },\n      ],\n    },\n  ],\n  \n  isDefault: false,\n  \n  aria: {\n    ariaLabel: 'App Launcher Page',\n    ariaDescribedBy: 'Central application launcher for accessing all apps',\n  },\n};\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/sales/pages/utility_bar.page.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/sales/pages\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/sales/pages/utility_bar.page.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport { Page } from '@objectstack/spec/ui';\n\n/**\n * Utility Bar Page\n * \n * Demonstrates a utility bar page for floating panels and quick access tools.\n * Similar to Salesforce Lightning Utility Bar.\n * \n * Features:\n * - Floating utility panels\n * - Quick notes\n * - Chat/messaging\n * - Notifications\n */\nexport const UtilityBarPage: Page = {\n  name: 'utility_bar_page',\n  label: 'Utility Bar',\n  description: 'Quick access utility bar with floating tools',\n  \n  type: 'utility',\n  \n  template: 'utility-bar',\n  kind: 'full',\n  regions: [\n    {\n      name: 'utilities',\n      width: 'full',\n      components: [\n        {\n          type: 'global:notifications',\n          id: 'notifications_panel',\n          label: 'Notifications',\n          properties: {},\n        },\n        {\n          type: 'page:card',\n          id: 'quick_notes',\n          label: 'Quick Notes',\n          properties: {\n            title: 'Quick Notes',\n            bordered: true,\n          },\n        },\n        {\n          type: 'global:search',\n          id: 'quick_search',\n          label: 'Quick Search',\n          properties: {},\n        },\n      ],\n    },\n  ],\n  \n  isDefault: false,\n  \n  aria: {\n    ariaLabel: 'Utility Bar',\n    ariaDescribedBy: 'Quick access utility bar with floating tools and notifications',\n  },\n};\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/sales/email-templates/index.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/sales/email-templates\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/sales/email-templates/index.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\n/**\n * Sales email-template barrel.\n *\n * An email template lives with the object its `notify` node is authored\n * against (AGENTS.md layout rule 3), so the packages that own notifying flows\n * each carry their own directory. `_bundle.ts` is the shared source the other\n * two read along their edge into sales.\n */\nexport { SalesEmailTemplates } from './crm.email-template';\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/sales/email-templates/en.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/sales/email-templates\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/sales/email-templates/en.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport type { EmailTemplatePack } from './_bundle';\n\n/**\n * English (en-US) \u2014 the sales package's notification templates.\n *\n * Per-locale file, one language each, assembled in `crm.email-template.ts` \u2014\n * the same convention `src/sales/translations/` already follows for the UI\n * locale packs.\n *\n * Every string here is the text its `notify` node already sent, with the\n * flow's `{var.path}` interpolations re-expressed as the `{{key}}` holes the\n * renderer fills from that node's `templateData`. A conversion, not a rewrite:\n * no notification says anything new.\n *\n * \u26A0\uFE0F Registered under `en-US`, not `en` \u2014 see the ladder note on `bundle()`.\n */\nexport const en: EmailTemplatePack = {\n  'crm.account_approved': {\n    label: 'Account Approved',\n    subject: 'Account approved: {{name}}',\n    bodyHtml: '<p>This account has been signed off and is now established data.</p>',\n  },\n  'crm.account_rejected': {\n    label: 'Account Not Approved',\n    subject: 'Account not approved: {{name}}',\n    bodyHtml: '<p>This account was not signed off. Correct its details and ask for another review.</p>',\n  },\n  'crm.contact_welcome': {\n    label: 'New Contact',\n    subject: 'New contact: {{first_name}} {{last_name}}',\n    bodyHtml: '<p>{{first_name}} {{last_name}} was added as a contact. Reach out to welcome them.</p>',\n  },\n  'crm.deal_stalled': {\n    label: 'Stalled Deal',\n    subject: 'Stalled deal: {{name}}',\n    bodyHtml: '<p>Opportunity {{name}} has sat in {{stage}} for {{days_in_stage}} days. Time to advance or re-qualify it.</p>',\n  },\n  'crm.large_deal_won': {\n    label: 'Large Deal Won',\n    subject: 'Large deal won: {{name}}',\n    bodyHtml: '<p>{{name}} closed at {{amount}}. Congratulations to the team.</p>',\n  },\n  'crm.lead_conversion_approved': {\n    label: 'Lead Approved for Conversion',\n    subject: 'Lead approved for conversion: {{first_name}} {{last_name}}',\n    bodyHtml: '<p>This lead has been signed off. You can convert it into an account, contact and opportunity.</p>',\n  },\n  'crm.lead_conversion_rejected': {\n    label: 'Lead Not Approved',\n    subject: 'Lead not approved: {{first_name}} {{last_name}}',\n    bodyHtml: '<p>Conversion of this lead was not approved. Keep working it, or disqualify it with a reason.</p>',\n  },\n  'crm.lead_converted': {\n    label: 'Lead Converted',\n    subject: 'Lead converted: {{first_name}} {{last_name}}',\n    bodyHtml: '<p>Lead {{first_name}} {{last_name}} was converted into an account and contact.</p>',\n  },\n  'crm.lead_routing_hot': {\n    label: 'Hot Lead Routing',\n    subject: 'Hot lead \u2014 assign within 24h: {{first_name}} {{last_name}}',\n    bodyHtml: '<p>{{first_name}} {{last_name}} from {{company}} (rating {{rating}}) needs an owner today.</p>',\n  },\n  'crm.lead_routing_new': {\n    label: 'New Lead Routing',\n    subject: 'New lead to assign: {{first_name}} {{last_name}}',\n    bodyHtml: '<p>{{first_name}} {{last_name}} from {{company}} is awaiting assignment.</p>',\n  },\n  'crm.opportunity_approved': {\n    label: 'Deal Approved',\n    subject: 'Deal approved: {{name}}',\n    bodyHtml: '<p>Your opportunity {{name}} has been approved.</p>',\n  },\n  'crm.opportunity_rejected': {\n    label: 'Deal Rejected',\n    subject: 'Deal rejected: {{name}}',\n    bodyHtml: '<p>Your opportunity {{name}} was not approved. Review and revise before resubmitting.</p>',\n  },\n  'crm.task_reminder': {\n    label: 'Task Reminder',\n    subject: 'Task reminder: {{subject}}',\n    bodyHtml: '<p>Your task \"{{subject}}\" is due (reminder set for {{reminder_date}}).</p>',\n  },\n  'crm.urgent_task': {\n    label: 'Urgent Task',\n    subject: 'Urgent task: {{subject}}',\n    bodyHtml: '<p>An urgent task \"{{subject}}\" was assigned to you and needs attention.</p>',\n  },\n};\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/sales/email-templates/zh-CN.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/sales/email-templates\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/sales/email-templates/zh-CN.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport type { EmailTemplatePack } from './_bundle';\n\n/** \u7B80\u4F53\u4E2D\u6587 (zh-CN) \u2014 the sales package's notification templates. See `en.ts`. */\nexport const zhCN: EmailTemplatePack = {\n  'crm.account_approved': {\n    label: '\u5BA2\u6237\u5BA1\u6279\u901A\u8FC7',\n    subject: '\u5BA2\u6237\u5DF2\u5BA1\u6279\u901A\u8FC7\uFF1A{{name}}',\n    bodyHtml: '<p>\u8BE5\u5BA2\u6237\u5DF2\u5BA1\u6279\u901A\u8FC7\uFF0C\u73B0\u4E3A\u6B63\u5F0F\u6570\u636E\u3002</p>',\n  },\n  'crm.account_rejected': {\n    label: '\u5BA2\u6237\u5BA1\u6279\u672A\u901A\u8FC7',\n    subject: '\u5BA2\u6237\u672A\u901A\u8FC7\u5BA1\u6279\uFF1A{{name}}',\n    bodyHtml: '<p>\u8BE5\u5BA2\u6237\u672A\u901A\u8FC7\u5BA1\u6279\u3002\u8BF7\u4FEE\u6B63\u5176\u4FE1\u606F\u540E\u518D\u6B21\u63D0\u4EA4\u5BA1\u6838\u3002</p>',\n  },\n  'crm.contact_welcome': {\n    label: '\u65B0\u8054\u7CFB\u4EBA',\n    subject: '\u65B0\u8054\u7CFB\u4EBA\uFF1A{{first_name}} {{last_name}}',\n    bodyHtml: '<p>{{first_name}} {{last_name}} \u5DF2\u6DFB\u52A0\u4E3A\u8054\u7CFB\u4EBA\u3002\u8BF7\u4E3B\u52A8\u8054\u7CFB\u5E76\u8868\u793A\u6B22\u8FCE\u3002</p>',\n  },\n  'crm.deal_stalled': {\n    label: '\u5546\u673A\u505C\u6EDE',\n    subject: '\u505C\u6EDE\u5546\u673A\uFF1A{{name}}',\n    bodyHtml: '<p>\u5546\u673A {{name}} \u5DF2\u5728\u201C{{stage}}\u201D\u9636\u6BB5\u505C\u7559 {{days_in_stage}} \u5929\u3002\u8BF7\u63A8\u8FDB\u6216\u91CD\u65B0\u8BC4\u4F30\u3002</p>',\n  },\n  'crm.large_deal_won': {\n    label: '\u5927\u989D\u5546\u673A\u8D62\u5355',\n    subject: '\u5927\u989D\u5546\u673A\u8D62\u5355\uFF1A{{name}}',\n    bodyHtml: '<p>{{name}} \u4EE5 {{amount}} \u6210\u4EA4\u3002\u606D\u559C\u56E2\u961F\u3002</p>',\n  },\n  'crm.lead_conversion_approved': {\n    label: '\u7EBF\u7D22\u8F6C\u6362\u5DF2\u6279\u51C6',\n    subject: '\u7EBF\u7D22\u8F6C\u6362\u5DF2\u6279\u51C6\uFF1A{{first_name}} {{last_name}}',\n    bodyHtml: '<p>\u8BE5\u7EBF\u7D22\u5DF2\u5BA1\u6279\u901A\u8FC7\u3002\u60A8\u53EF\u4EE5\u5C06\u5176\u8F6C\u6362\u4E3A\u5BA2\u6237\u3001\u8054\u7CFB\u4EBA\u548C\u5546\u673A\u3002</p>',\n  },\n  'crm.lead_conversion_rejected': {\n    label: '\u7EBF\u7D22\u8F6C\u6362\u672A\u6279\u51C6',\n    subject: '\u7EBF\u7D22\u672A\u901A\u8FC7\u5BA1\u6279\uFF1A{{first_name}} {{last_name}}',\n    bodyHtml: '<p>\u8BE5\u7EBF\u7D22\u7684\u8F6C\u6362\u672A\u83B7\u6279\u51C6\u3002\u8BF7\u7EE7\u7EED\u8DDF\u8FDB\uFF0C\u6216\u6CE8\u660E\u539F\u56E0\u5C06\u5176\u53D6\u6D88\u8D44\u683C\u3002</p>',\n  },\n  'crm.lead_converted': {\n    label: '\u7EBF\u7D22\u5DF2\u8F6C\u6362',\n    subject: '\u7EBF\u7D22\u5DF2\u8F6C\u6362\uFF1A{{first_name}} {{last_name}}',\n    bodyHtml: '<p>\u7EBF\u7D22 {{first_name}} {{last_name}} \u5DF2\u8F6C\u6362\u4E3A\u5BA2\u6237\u548C\u8054\u7CFB\u4EBA\u3002</p>',\n  },\n  'crm.lead_routing_hot': {\n    label: '\u70ED\u95E8\u7EBF\u7D22\u5206\u914D',\n    subject: '\u70ED\u95E8\u7EBF\u7D22 \u2014 24 \u5C0F\u65F6\u5185\u5206\u914D\uFF1A{{first_name}} {{last_name}}',\n    bodyHtml: '<p>\u6765\u81EA {{company}} \u7684 {{first_name}} {{last_name}}\uFF08\u8BC4\u5206 {{rating}}\uFF09\u9700\u8981\u4ECA\u5929\u5C31\u6307\u5B9A\u8D1F\u8D23\u4EBA\u3002</p>',\n  },\n  'crm.lead_routing_new': {\n    label: '\u65B0\u7EBF\u7D22\u5206\u914D',\n    subject: '\u5F85\u5206\u914D\u65B0\u7EBF\u7D22\uFF1A{{first_name}} {{last_name}}',\n    bodyHtml: '<p>\u6765\u81EA {{company}} \u7684 {{first_name}} {{last_name}} \u6B63\u5728\u7B49\u5F85\u5206\u914D\u3002</p>',\n  },\n  'crm.opportunity_approved': {\n    label: '\u5546\u673A\u5BA1\u6279\u901A\u8FC7',\n    subject: '\u5546\u673A\u5DF2\u6279\u51C6\uFF1A{{name}}',\n    bodyHtml: '<p>\u60A8\u7684\u5546\u673A {{name}} \u5DF2\u83B7\u6279\u51C6\u3002</p>',\n  },\n  'crm.opportunity_rejected': {\n    label: '\u5546\u673A\u5BA1\u6279\u672A\u901A\u8FC7',\n    subject: '\u5546\u673A\u672A\u6279\u51C6\uFF1A{{name}}',\n    bodyHtml: '<p>\u60A8\u7684\u5546\u673A {{name}} \u672A\u83B7\u6279\u51C6\u3002\u8BF7\u68C0\u67E5\u5E76\u4FEE\u6539\u540E\u91CD\u65B0\u63D0\u4EA4\u3002</p>',\n  },\n  'crm.task_reminder': {\n    label: '\u4EFB\u52A1\u63D0\u9192',\n    subject: '\u4EFB\u52A1\u63D0\u9192\uFF1A{{subject}}',\n    bodyHtml: '<p>\u60A8\u7684\u4EFB\u52A1\u201C{{subject}}\u201D\u5DF2\u5230\u671F\uFF08\u63D0\u9192\u65F6\u95F4 {{reminder_date}}\uFF09\u3002</p>',\n  },\n  'crm.urgent_task': {\n    label: '\u7D27\u6025\u4EFB\u52A1',\n    subject: '\u7D27\u6025\u4EFB\u52A1\uFF1A{{subject}}',\n    bodyHtml: '<p>\u4E00\u9879\u7D27\u6025\u4EFB\u52A1\u201C{{subject}}\u201D\u5DF2\u5206\u914D\u7ED9\u60A8\uFF0C\u9700\u8981\u5C3D\u5FEB\u5904\u7406\u3002</p>',\n  },\n};\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/sales/email-templates/ja-JP.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/sales/email-templates\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/sales/email-templates/ja-JP.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport type { EmailTemplatePack } from './_bundle';\n\n/** \u65E5\u672C\u8A9E (ja-JP) \u2014 the sales package's notification templates. See `en.ts`. */\nexport const jaJP: EmailTemplatePack = {\n  'crm.account_approved': {\n    label: '\u30A2\u30AB\u30A6\u30F3\u30C8\u627F\u8A8D\u6E08\u307F',\n    subject: '\u30A2\u30AB\u30A6\u30F3\u30C8\u304C\u627F\u8A8D\u3055\u308C\u307E\u3057\u305F: {{name}}',\n    bodyHtml: '<p>\u3053\u306E\u30A2\u30AB\u30A6\u30F3\u30C8\u306F\u627F\u8A8D\u3055\u308C\u3001\u6B63\u5F0F\u306A\u30C7\u30FC\u30BF\u306B\u306A\u308A\u307E\u3057\u305F\u3002</p>',\n  },\n  'crm.account_rejected': {\n    label: '\u30A2\u30AB\u30A6\u30F3\u30C8\u672A\u627F\u8A8D',\n    subject: '\u30A2\u30AB\u30A6\u30F3\u30C8\u304C\u627F\u8A8D\u3055\u308C\u307E\u305B\u3093\u3067\u3057\u305F: {{name}}',\n    bodyHtml: '<p>\u3053\u306E\u30A2\u30AB\u30A6\u30F3\u30C8\u306F\u627F\u8A8D\u3055\u308C\u307E\u305B\u3093\u3067\u3057\u305F\u3002\u5185\u5BB9\u3092\u4FEE\u6B63\u306E\u3046\u3048\u3001\u518D\u5EA6\u627F\u8A8D\u3092\u4F9D\u983C\u3057\u3066\u304F\u3060\u3055\u3044\u3002</p>',\n  },\n  'crm.contact_welcome': {\n    label: '\u65B0\u898F\u53D6\u5F15\u5148\u8CAC\u4EFB\u8005',\n    subject: '\u65B0\u3057\u3044\u53D6\u5F15\u5148\u8CAC\u4EFB\u8005: {{first_name}} {{last_name}}',\n    bodyHtml: '<p>{{first_name}} {{last_name}} \u304C\u53D6\u5F15\u5148\u8CAC\u4EFB\u8005\u3068\u3057\u3066\u8FFD\u52A0\u3055\u308C\u307E\u3057\u305F\u3002\u3054\u6328\u62F6\u306E\u9023\u7D61\u3092\u3057\u3066\u304F\u3060\u3055\u3044\u3002</p>',\n  },\n  'crm.deal_stalled': {\n    label: '\u505C\u6EDE\u4E2D\u306E\u5546\u8AC7',\n    subject: '\u505C\u6EDE\u4E2D\u306E\u5546\u8AC7: {{name}}',\n    bodyHtml: '<p>\u5546\u8AC7 {{name}} \u306F\u300C{{stage}}\u300D\u306B {{days_in_stage}} \u65E5\u9593\u7559\u307E\u3063\u3066\u3044\u307E\u3059\u3002\u6B21\u306E\u6BB5\u968E\u306B\u9032\u3081\u308B\u304B\u3001\u518D\u8A55\u4FA1\u3057\u3066\u304F\u3060\u3055\u3044\u3002</p>',\n  },\n  'crm.large_deal_won': {\n    label: '\u5927\u578B\u5546\u8AC7\u306E\u53D7\u6CE8',\n    subject: '\u5927\u578B\u5546\u8AC7\u3092\u53D7\u6CE8: {{name}}',\n    bodyHtml: '<p>{{name}} \u304C {{amount}} \u3067\u6210\u7D04\u3057\u307E\u3057\u305F\u3002\u30C1\u30FC\u30E0\u306E\u7686\u3055\u3093\u3001\u304A\u3081\u3067\u3068\u3046\u3054\u3056\u3044\u307E\u3059\u3002</p>',\n  },\n  'crm.lead_conversion_approved': {\n    label: '\u30EA\u30FC\u30C9\u5909\u63DB\u306E\u627F\u8A8D',\n    subject: '\u30EA\u30FC\u30C9\u306E\u5909\u63DB\u304C\u627F\u8A8D\u3055\u308C\u307E\u3057\u305F: {{first_name}} {{last_name}}',\n    bodyHtml: '<p>\u3053\u306E\u30EA\u30FC\u30C9\u306F\u627F\u8A8D\u3055\u308C\u307E\u3057\u305F\u3002\u53D6\u5F15\u5148\u3001\u53D6\u5F15\u5148\u8CAC\u4EFB\u8005\u3001\u5546\u8AC7\u306B\u5909\u63DB\u3067\u304D\u307E\u3059\u3002</p>',\n  },\n  'crm.lead_conversion_rejected': {\n    label: '\u30EA\u30FC\u30C9\u672A\u627F\u8A8D',\n    subject: '\u30EA\u30FC\u30C9\u304C\u627F\u8A8D\u3055\u308C\u307E\u305B\u3093\u3067\u3057\u305F: {{first_name}} {{last_name}}',\n    bodyHtml: '<p>\u3053\u306E\u30EA\u30FC\u30C9\u306E\u5909\u63DB\u306F\u627F\u8A8D\u3055\u308C\u307E\u305B\u3093\u3067\u3057\u305F\u3002\u5F15\u304D\u7D9A\u304D\u5BFE\u5FDC\u3059\u308B\u304B\u3001\u7406\u7531\u3092\u4ED8\u3051\u3066\u5BFE\u8C61\u5916\u306B\u3057\u3066\u304F\u3060\u3055\u3044\u3002</p>',\n  },\n  'crm.lead_converted': {\n    label: '\u30EA\u30FC\u30C9\u5909\u63DB\u6E08\u307F',\n    subject: '\u30EA\u30FC\u30C9\u3092\u5909\u63DB\u3057\u307E\u3057\u305F: {{first_name}} {{last_name}}',\n    bodyHtml: '<p>\u30EA\u30FC\u30C9 {{first_name}} {{last_name}} \u3092\u53D6\u5F15\u5148\u3068\u53D6\u5F15\u5148\u8CAC\u4EFB\u8005\u306B\u5909\u63DB\u3057\u307E\u3057\u305F\u3002</p>',\n  },\n  'crm.lead_routing_hot': {\n    label: '\u30DB\u30C3\u30C8\u30EA\u30FC\u30C9\u306E\u5272\u308A\u5F53\u3066',\n    subject: '\u30DB\u30C3\u30C8\u30EA\u30FC\u30C9 \u2014 24 \u6642\u9593\u4EE5\u5185\u306B\u5272\u308A\u5F53\u3066: {{first_name}} {{last_name}}',\n    bodyHtml: '<p>{{company}} \u306E {{first_name}} {{last_name}}\uFF08\u8A55\u4FA1 {{rating}}\uFF09\u306B\u672C\u65E5\u4E2D\u306B\u62C5\u5F53\u8005\u3092\u5272\u308A\u5F53\u3066\u3066\u304F\u3060\u3055\u3044\u3002</p>',\n  },\n  'crm.lead_routing_new': {\n    label: '\u65B0\u898F\u30EA\u30FC\u30C9\u306E\u5272\u308A\u5F53\u3066',\n    subject: '\u5272\u308A\u5F53\u3066\u5F85\u3061\u306E\u65B0\u898F\u30EA\u30FC\u30C9: {{first_name}} {{last_name}}',\n    bodyHtml: '<p>{{company}} \u306E {{first_name}} {{last_name}} \u304C\u5272\u308A\u5F53\u3066\u3092\u5F85\u3063\u3066\u3044\u307E\u3059\u3002</p>',\n  },\n  'crm.opportunity_approved': {\n    label: '\u5546\u8AC7\u627F\u8A8D\u6E08\u307F',\n    subject: '\u5546\u8AC7\u304C\u627F\u8A8D\u3055\u308C\u307E\u3057\u305F: {{name}}',\n    bodyHtml: '<p>\u5546\u8AC7 {{name}} \u304C\u627F\u8A8D\u3055\u308C\u307E\u3057\u305F\u3002</p>',\n  },\n  'crm.opportunity_rejected': {\n    label: '\u5546\u8AC7\u672A\u627F\u8A8D',\n    subject: '\u5546\u8AC7\u304C\u627F\u8A8D\u3055\u308C\u307E\u305B\u3093\u3067\u3057\u305F: {{name}}',\n    bodyHtml: '<p>\u5546\u8AC7 {{name}} \u306F\u627F\u8A8D\u3055\u308C\u307E\u305B\u3093\u3067\u3057\u305F\u3002\u5185\u5BB9\u3092\u78BA\u8A8D\u30FB\u4FEE\u6B63\u306E\u3046\u3048\u3001\u518D\u7533\u8ACB\u3057\u3066\u304F\u3060\u3055\u3044\u3002</p>',\n  },\n  'crm.task_reminder': {\n    label: 'ToDo \u30EA\u30DE\u30A4\u30F3\u30C0\u30FC',\n    subject: 'ToDo \u306E\u30EA\u30DE\u30A4\u30F3\u30C0\u30FC: {{subject}}',\n    bodyHtml: '<p>ToDo\u300C{{subject}}\u300D\u304C\u671F\u9650\u3092\u8FCE\u3048\u307E\u3057\u305F\uFF08\u30EA\u30DE\u30A4\u30F3\u30C0\u30FC\u8A2D\u5B9A: {{reminder_date}}\uFF09\u3002</p>',\n  },\n  'crm.urgent_task': {\n    label: '\u7DCA\u6025 ToDo',\n    subject: '\u7DCA\u6025\u306E ToDo: {{subject}}',\n    bodyHtml: '<p>\u7DCA\u6025\u306E ToDo\u300C{{subject}}\u300D\u304C\u5272\u308A\u5F53\u3066\u3089\u308C\u307E\u3057\u305F\u3002\u5BFE\u5FDC\u3092\u304A\u9858\u3044\u3057\u307E\u3059\u3002</p>',\n  },\n};\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/sales/email-templates/es-ES.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/sales/email-templates\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/sales/email-templates/es-ES.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport type { EmailTemplatePack } from './_bundle';\n\n/** Espa\u00F1ol (es-ES) \u2014 the sales package's notification templates. See `en.ts`. */\nexport const esES: EmailTemplatePack = {\n  'crm.account_approved': {\n    label: 'Cuenta aprobada',\n    subject: 'Cuenta aprobada: {{name}}',\n    bodyHtml: '<p>Esta cuenta ha sido aprobada y ya es un dato consolidado.</p>',\n  },\n  'crm.account_rejected': {\n    label: 'Cuenta no aprobada',\n    subject: 'Cuenta no aprobada: {{name}}',\n    bodyHtml: '<p>Esta cuenta no fue aprobada. Corrige sus datos y solicita otra revisi\u00F3n.</p>',\n  },\n  'crm.contact_welcome': {\n    label: 'Nuevo contacto',\n    subject: 'Nuevo contacto: {{first_name}} {{last_name}}',\n    bodyHtml: '<p>{{first_name}} {{last_name}} se ha a\u00F1adido como contacto. Ponte en contacto para darle la bienvenida.</p>',\n  },\n  'crm.deal_stalled': {\n    label: 'Oportunidad estancada',\n    subject: 'Oportunidad estancada: {{name}}',\n    bodyHtml: '<p>La oportunidad {{name}} lleva {{days_in_stage}} d\u00EDas en {{stage}}. Es hora de avanzarla o volver a cualificarla.</p>',\n  },\n  'crm.large_deal_won': {\n    label: 'Gran operaci\u00F3n ganada',\n    subject: 'Gran operaci\u00F3n ganada: {{name}}',\n    bodyHtml: '<p>{{name}} se cerr\u00F3 por {{amount}}. Enhorabuena al equipo.</p>',\n  },\n  'crm.lead_conversion_approved': {\n    label: 'Cliente potencial aprobado para conversi\u00F3n',\n    subject: 'Cliente potencial aprobado para conversi\u00F3n: {{first_name}} {{last_name}}',\n    bodyHtml: '<p>Este cliente potencial ha sido aprobado. Puedes convertirlo en cuenta, contacto y oportunidad.</p>',\n  },\n  'crm.lead_conversion_rejected': {\n    label: 'Cliente potencial no aprobado',\n    subject: 'Cliente potencial no aprobado: {{first_name}} {{last_name}}',\n    bodyHtml: '<p>La conversi\u00F3n de este cliente potencial no fue aprobada. Sigue trabaj\u00E1ndolo o descalif\u00EDcalo indicando un motivo.</p>',\n  },\n  'crm.lead_converted': {\n    label: 'Cliente potencial convertido',\n    subject: 'Cliente potencial convertido: {{first_name}} {{last_name}}',\n    bodyHtml: '<p>El cliente potencial {{first_name}} {{last_name}} se convirti\u00F3 en cuenta y contacto.</p>',\n  },\n  'crm.lead_routing_hot': {\n    label: 'Asignaci\u00F3n de cliente potencial caliente',\n    subject: 'Cliente potencial caliente \u2014 asignar en 24 h: {{first_name}} {{last_name}}',\n    bodyHtml: '<p>{{first_name}} {{last_name}} de {{company}} (puntuaci\u00F3n {{rating}}) necesita propietario hoy.</p>',\n  },\n  'crm.lead_routing_new': {\n    label: 'Asignaci\u00F3n de cliente potencial',\n    subject: 'Nuevo cliente potencial por asignar: {{first_name}} {{last_name}}',\n    bodyHtml: '<p>{{first_name}} {{last_name}} de {{company}} est\u00E1 pendiente de asignaci\u00F3n.</p>',\n  },\n  'crm.opportunity_approved': {\n    label: 'Oportunidad aprobada',\n    subject: 'Oportunidad aprobada: {{name}}',\n    bodyHtml: '<p>Tu oportunidad {{name}} ha sido aprobada.</p>',\n  },\n  'crm.opportunity_rejected': {\n    label: 'Oportunidad rechazada',\n    subject: 'Oportunidad rechazada: {{name}}',\n    bodyHtml: '<p>Tu oportunidad {{name}} no fue aprobada. Rev\u00EDsala y corr\u00EDgela antes de volver a enviarla.</p>',\n  },\n  'crm.task_reminder': {\n    label: 'Recordatorio de tarea',\n    subject: 'Recordatorio de tarea: {{subject}}',\n    bodyHtml: '<p>Tu tarea \"{{subject}}\" vence (recordatorio fijado para {{reminder_date}}).</p>',\n  },\n  'crm.urgent_task': {\n    label: 'Tarea urgente',\n    subject: 'Tarea urgente: {{subject}}',\n    bodyHtml: '<p>Se te ha asignado una tarea urgente \"{{subject}}\" que requiere atenci\u00F3n.</p>',\n  },\n};\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/sales/email-templates/crm.email-template.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/sales/email-templates\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/sales/email-templates/crm.email-template.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport type { EmailTemplateDefinition } from '@objectstack/spec/system';\nimport { bundle } from './_bundle';\nimport { en } from './en';\nimport { zhCN } from './zh-CN';\nimport { jaJP } from './ja-JP';\nimport { esES } from './es-ES';\n\n/**\n * Sales \u2014 every `sys_email_template` row this package's `notify` nodes name.\n *\n * Four locale packs crossed with fourteen template names: the rows a\n * recipient's own `sys_user.locale` is resolved against, per recipient, after\n * fan-out. Assembled here the way `translations/crm.translation.ts` assembles\n * the UI locale packs \u2014 one file per language, one file that collects them.\n */\nexport const SalesEmailTemplates: EmailTemplateDefinition[] = bundle({\n  'en-US': en,\n  'zh-CN': zhCN,\n  'ja-JP': jaJP,\n  'es-ES': esES,\n});\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/revenue/email-templates/index.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/revenue/email-templates\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/revenue/email-templates/index.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\n/** Revenue email-template barrel. */\nexport { RevenueEmailTemplates } from './crm.email-template';\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/revenue/email-templates/en.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/revenue/email-templates\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/revenue/email-templates/en.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport type { EmailTemplatePack } from '../../sales/email-templates/_bundle';\n\n/**\n * English (en-US) \u2014 the revenue package's notification templates.\n *\n * Every string is the text its `notify` node already sent, with the flow's\n * `{var.path}` interpolations re-expressed as the `{{key}}` holes the renderer\n * fills from that node's `templateData`. \u26A0\uFE0F Tagged `en-US`, not `en` \u2014 see the\n * resolution-ladder note on `bundle()`.\n */\nexport const en: EmailTemplatePack = {\n  'crm.contract_expired': {\n    label: 'Contract Expired',\n    subject: 'Contract expired: {{contract_number}}',\n    bodyHtml: '<p>Contract {{contract_number}} reached its end date and has been marked expired.</p>',\n  },\n  'crm.contract_renewal': {\n    label: 'Contract Renewal Due',\n    subject: 'Contract renewal due: {{contract_number}}',\n    bodyHtml: '<p>Contract {{contract_number}} ends on {{end_date}}. Start the renewal conversation now.</p>',\n  },\n  'crm.quote_created': {\n    label: 'Quote Created',\n    subject: 'Quote created: {{quote_name}}',\n    bodyHtml: '<p>Your quote {{quote_name}} has been created from this opportunity.</p>',\n  },\n};\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/revenue/email-templates/zh-CN.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/revenue/email-templates\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/revenue/email-templates/zh-CN.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport type { EmailTemplatePack } from '../../sales/email-templates/_bundle';\n\n/** \u7B80\u4F53\u4E2D\u6587 (zh-CN) \u2014 the revenue package's notification templates. See `en.ts`. */\nexport const zhCN: EmailTemplatePack = {\n  'crm.contract_expired': {\n    label: '\u5408\u540C\u5DF2\u5230\u671F',\n    subject: '\u5408\u540C\u5DF2\u5230\u671F\uFF1A{{contract_number}}',\n    bodyHtml: '<p>\u5408\u540C {{contract_number}} \u5DF2\u5230\u8FBE\u7ED3\u675F\u65E5\u671F\uFF0C\u5E76\u5DF2\u6807\u8BB0\u4E3A\u5230\u671F\u3002</p>',\n  },\n  'crm.contract_renewal': {\n    label: '\u5408\u540C\u7EED\u7EA6\u63D0\u9192',\n    subject: '\u5408\u540C\u5F85\u7EED\u7EA6\uFF1A{{contract_number}}',\n    bodyHtml: '<p>\u5408\u540C {{contract_number}} \u5C06\u4E8E {{end_date}} \u7ED3\u675F\u3002\u8BF7\u7ACB\u5373\u542F\u52A8\u7EED\u7EA6\u6C9F\u901A\u3002</p>',\n  },\n  'crm.quote_created': {\n    label: '\u62A5\u4EF7\u5355\u5DF2\u521B\u5EFA',\n    subject: '\u62A5\u4EF7\u5355\u5DF2\u521B\u5EFA\uFF1A{{quote_name}}',\n    bodyHtml: '<p>\u60A8\u7684\u62A5\u4EF7\u5355 {{quote_name}} \u5DF2\u4ECE\u8BE5\u5546\u673A\u521B\u5EFA\u3002</p>',\n  },\n};\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/revenue/email-templates/ja-JP.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/revenue/email-templates\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/revenue/email-templates/ja-JP.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport type { EmailTemplatePack } from '../../sales/email-templates/_bundle';\n\n/** \u65E5\u672C\u8A9E (ja-JP) \u2014 the revenue package's notification templates. See `en.ts`. */\nexport const jaJP: EmailTemplatePack = {\n  'crm.contract_expired': {\n    label: '\u5951\u7D04\u306E\u6E80\u4E86',\n    subject: '\u5951\u7D04\u304C\u6E80\u4E86\u3057\u307E\u3057\u305F: {{contract_number}}',\n    bodyHtml: '<p>\u5951\u7D04 {{contract_number}} \u306F\u7D42\u4E86\u65E5\u306B\u9054\u3057\u3001\u6E80\u4E86\u3068\u3057\u3066\u8A18\u9332\u3055\u308C\u307E\u3057\u305F\u3002</p>',\n  },\n  'crm.contract_renewal': {\n    label: '\u5951\u7D04\u66F4\u65B0\u306E\u6642\u671F',\n    subject: '\u5951\u7D04\u306E\u66F4\u65B0\u6642\u671F\u3067\u3059: {{contract_number}}',\n    bodyHtml: '<p>\u5951\u7D04 {{contract_number}} \u306F {{end_date}} \u306B\u7D42\u4E86\u3057\u307E\u3059\u3002\u66F4\u65B0\u306E\u76F8\u8AC7\u3092\u59CB\u3081\u3066\u304F\u3060\u3055\u3044\u3002</p>',\n  },\n  'crm.quote_created': {\n    label: '\u898B\u7A4D\u306E\u4F5C\u6210',\n    subject: '\u898B\u7A4D\u3092\u4F5C\u6210\u3057\u307E\u3057\u305F: {{quote_name}}',\n    bodyHtml: '<p>\u3053\u306E\u5546\u8AC7\u304B\u3089\u898B\u7A4D {{quote_name}} \u304C\u4F5C\u6210\u3055\u308C\u307E\u3057\u305F\u3002</p>',\n  },\n};\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/revenue/email-templates/es-ES.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/revenue/email-templates\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/revenue/email-templates/es-ES.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport type { EmailTemplatePack } from '../../sales/email-templates/_bundle';\n\n/** Espa\u00F1ol (es-ES) \u2014 the revenue package's notification templates. See `en.ts`. */\nexport const esES: EmailTemplatePack = {\n  'crm.contract_expired': {\n    label: 'Contrato vencido',\n    subject: 'Contrato vencido: {{contract_number}}',\n    bodyHtml: '<p>El contrato {{contract_number}} alcanz\u00F3 su fecha de fin y se ha marcado como vencido.</p>',\n  },\n  'crm.contract_renewal': {\n    label: 'Renovaci\u00F3n de contrato pendiente',\n    subject: 'Renovaci\u00F3n de contrato pendiente: {{contract_number}}',\n    bodyHtml: '<p>El contrato {{contract_number}} finaliza el {{end_date}}. Inicia ya la conversaci\u00F3n de renovaci\u00F3n.</p>',\n  },\n  'crm.quote_created': {\n    label: 'Presupuesto creado',\n    subject: 'Presupuesto creado: {{quote_name}}',\n    bodyHtml: '<p>Tu presupuesto {{quote_name}} se ha creado a partir de esta oportunidad.</p>',\n  },\n};\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/revenue/email-templates/crm.email-template.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/revenue/email-templates\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/revenue/email-templates/crm.email-template.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport type { EmailTemplateDefinition } from '@objectstack/spec/system';\nimport { bundle } from '../../sales/email-templates/_bundle';\nimport { en } from './en';\nimport { zhCN } from './zh-CN';\nimport { jaJP } from './ja-JP';\nimport { esES } from './es-ES';\n\n/**\n * Revenue \u2014 every `sys_email_template` row this package's `notify` nodes name.\n *\n * Four locale packs crossed with three template names. `bundle()` is imported\n * along this module's edge into sales, the one deterministic home for a source\n * more than one package needs.\n */\nexport const RevenueEmailTemplates: EmailTemplateDefinition[] = bundle({\n  'en-US': en,\n  'zh-CN': zhCN,\n  'ja-JP': jaJP,\n  'es-ES': esES,\n});\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/sales/profiles/tenant-admin.profile.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/sales/profiles\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/sales/profiles/tenant-admin.profile.ts\";// Copyright (c) 2026 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport { SystemAdminProfile } from './system-admin.profile';\n\n/**\n * Tenant Administrator \u2014 the admin persona of the SaaS / multi-org composition\n * (#1361). Registered ONLY by that composition; the community app ships\n * `system_admin` exactly as it always has and this file is not in its artifact.\n *\n * ### Why a second admin set instead of narrowing the first\n *\n * The two admins are different people. `system_admin` is the operator of a\n * single-org install: the one who owns the deployment. A tenant admin owns an\n * ORGANIZATION inside somebody else's deployment, and under an `isolated`\n * posture every other organization in that database is none of their business.\n * A profile is a description of a persona, so where the persona differs the\n * profile does \u2014 narrowing `system_admin` in place would have changed the\n * community app's meaning to describe a customer it does not have.\n *\n * ### The OBJECT grants are shared, on purpose and by reference\n *\n * A tenant admin administers their own org's records with exactly the authority\n * `system_admin` has over a single-org install's records \u2014 same objects, same\n * CRUD, same all-records depth, same transfer and export bits. So the map is\n * DERIVED from `SystemAdminProfile.objects` rather than transcribed.\n *\n * That is the load-bearing half. Permission sets are explicit-allow only, so an\n * object missing from the map is permission-denied for tenant admins too, and a\n * transcribed copy would drift the first time an object shipped \u2014 the exact\n * defect `test/authorization-coverage.test.ts` exists to catch on the community\n * set (#488: objects that shipped with navigation, views, hooks and seeds but a\n * grant in no set at all). Deriving means a new object lands in both admins the\n * day it lands in one, with nothing to remember.\n *\n * ### What changes: `manage_users` \u2192 `manage_org_users`\n *\n * `manage_users` is `scope: 'platform'` in the platform's own capability\n * registry \u2014 \"Create, edit, and deactivate users across the platform\". Handing\n * that to a tenant is handing them every other tenant's people. Its org-scoped\n * sibling, `manage_org_users` (\"Manage members within the caller's\n * organization\"), is the member-management authority a tenant admin should hold,\n * and it is declared in the released `@objectstack/spec` 17.1.0 this app depends\n * on (verified against the installed `PLATFORM_CAPABILITIES`, not against a\n * newer platform checkout \u2014 an app on a released line cannot grant a capability\n * that line has not shipped).\n *\n * Both are DECLARATIONS here, not enforcement: measured against the installed\n * 17.1.0 packages, `manage_users` appears in a single comment and nothing reads\n * either name \u2014 the member-management door is the enterprise organizations\n * runtime's, and it is the edition that supplies the gate. That is the shape the\n * maintainer's 2026-08-11 ruling asks for and the app package's `requires`\n * (`src/sales/index.ts`) already follows for `hierarchy-security`: \u300C\u672C\u9879\u76EE\u662F\u5143\u6570\u636Eapp\uFF0C\u5728\u4F01\u4E1A\u7248\u8FD0\u884C\u5C31\u5177\u5907\u4F01\u4E1A\u7248\n * \u76F8\u5173\u7684\u80FD\u529B\uFF0C\u4E0D\u91CD\u590D\u5F00\u53D1\u3002\u300D The app states what it MEANS; the edition enforces.\n *\n * ### What `view_all_data` / `modify_all_data` mean under the wall \u2014 the audit\n *\n * They are KEPT, and they are bounded by the organization, not by them.\n *\n * Two measurements, both against the 17.1.0 line \u2014 the version\n * installed AT THE TIME they were taken, not the current pin (neither was\n * re-taken on 17.3.0, 17.4.0 or 17.5.0).\n *\n * \u26A0\uFE0F The zero-occurrence result in 1 \u2014 the load-bearing half \u2014 reproduced on\n * 17.2.0 and has not been re-run since (#1676). The three CONTROL counts in\n * it do NOT reproduce: they are\n * as-measured-then figures and have since moved. They are kept at their\n * measured values on purpose rather than refreshed, because what they are\n * evidence FOR is that the sweep can find a name it looks for \u2014 never a\n * current total. \u26D4 Do not cite them as one, and \u26D4 do not \"fix\" them by\n * pasting today's numbers over a 17.1.0 measurement.\n *\n *  1. **Neither string is read by anything.** `view_all_data` and\n *     `modify_all_data` occur in ZERO installed `@objectstack/*` JavaScript\n *     files (control probes in the same sweep: `manage_sharing` 15 files,\n *     `manage_metadata` 25, `setup.access` 32 \u2014 so the sweep can find a name it\n *     is looking for). They are app-declared vocabulary. The authority that is\n *     really enforced is the PER-OBJECT `viewAllRecords` / `modifyAllRecords`\n *     bits in the map above, which the sharing layer reads on every request.\n *  2. **The organization predicate is not part of that layer.** A tenant-scoped\n *     read is compiled by the DRIVER from the execution context's tenant id,\n *     underneath permissions and sharing entirely. Measured on a real engine: a\n *     caller in `org_a` reading `crm_account` sees 1 of the 2 rows in the table\n *     \u2014 and still sees 1 of 2 with the tenancy posture flipped to `single`,\n *     which is what shows the boundary belongs to the driver and the context\n *     rather than to a deployment knob a profile might hope to out-rank.\n *\n * So \"all data\" answers a question about DEPTH inside one organization \u2014 all\n * rows regardless of owner \u2014 and no permission-set bit can widen it past the\n * wall, because the wall is not applied by the permission set. The one context\n * that does cross it is a system context (`isSystem`), which no profile grants\n * and no session produces. Keeping the two grants therefore says the true\n * thing about a tenant admin: inside their org, they see and edit everything.\n *\n * ### What a tenant admin may AUTHOR: nothing, since 18.0.0-next.0\n *\n * Through 17.7.0 this set held `manage_org_presentation`, the platform's\n * `scope: 'org'` capability (objectstack-ai/objectstack#12702) that admitted\n * `/meta` writes of the `allowOrgOverride: true` types \u2014 view, dashboard,\n * report, translation, email_template \u2014 as overlays in the caller's own\n * organization. 18.0.0-next.0 RETIRES it with the per-organization overlay\n * axis (ADR-0131 D6, the spec's `manage-org-presentation-retired` entry): it is\n * no longer in `PLATFORM_CAPABILITIES`, nothing consults it, and the entry's\n * remedy is to delete it from every set. There is no organization-bounded\n * authoring capability left; the only key that admits those writes is\n * `manage_metadata`, whose writes land environment-wide, so it stays\n * ungranted for the reason below.\n *\n * `customize_application`, `manage_profiles` and `manage_roles` stay\n * ungranted. They describe authoring the app's structure and security model \u2014\n * objects, apps, pages, permission sets, positions \u2014 and the registry declares\n * every one of those types `allowOrgOverride: false`, so the only key that\n * admits those writes is still `manage_metadata`: `scope: 'platform'`, reach\n * across every organization in the deployment. Granting the three would\n * describe an authority the deployment cannot safely give.\n *\n * `manage_sharing` IS granted: the platform declares it `scope: 'org'`\n * (\"Administer record sharing \u2026 beyond one's own records\"), which is precisely\n * a tenant admin's job over their own org's records.\n *\n * `view_setup` is kept for parity with the community admin \u2014 it is this app's\n * own Setup-entry vocabulary and, like the two above, has no platform consumer\n * on this line. (The platform's own `setup.access` is `scope: 'platform'` and\n * is not granted here for the same reason `manage_users` is not.)\n */\nexport const TenantAdminProfile = {\n  name: 'tenant_admin',\n  label: 'Tenant Administrator',\n  // Derived, never transcribed \u2014 see the note above. Spread rather than\n  // aliased so the two sets are independent values in the built artifact.\n  objects: { ...SystemAdminProfile.objects },\n  systemPermissions: [\n    'view_setup',\n    // The one substitution this profile exists for: org-scoped member\n    // management instead of platform-wide user management.\n    'manage_org_users',\n    // Org-bounded by the driver's tenant predicate \u2014 see the audit above.\n    'view_all_data', 'modify_all_data',\n    'manage_sharing',\n  ],\n};\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/sales/objects/account.hook.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/sales/objects\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/sales/objects/account.hook.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport type { Hook, HookContext } from '@objectstack/spec/data';\nimport type { HookApi } from './_hook-api';\n\n/**\n * Account protection hook.\n *\n * - Validates `website` format and `annual_revenue` non-negative.\n * - Projects `billing_address.country` onto the flat `billing_country` column\n *   (#621) and classifies it into the `territory` select the territory sharing\n *   rules filter on (#639).\n * - Folds `name` into the `name_normalized` column lead conversion matches\n *   accounts on (#626).\n * - Refuses to delete a `customer` account that still has opportunities \u2014\n *   open or closed, the account's sales history (#2019) \u2014 or activated\n *   contracts \u2014 contracts cascade with the account since #549.\n */\nconst accountHook: Hook = {\n  name: 'account_protection',\n  object: 'crm_account',\n  events: ['beforeInsert', 'beforeUpdate', 'beforeDelete'],\n  priority: 200,\n  description:\n    'Validate account fields and protect customer accounts with opportunities or activated contracts from deletion.',\n  handler: async (ctx: HookContext) => {\n    // The refusal envelope (#1075). Mirrored from `./_refusal.ts` because a\n    // lowered body has no module scope and `extractHookBody` THROWS on an\n    // import; `test/refusal-envelope.test.ts` pins every copy against it.\n    function refuse(\n      message: string,\n      code: string,\n      status: number,\n      userMessage: string = message,\n    ): Error {\n      const err = new Error(message) as Error & {\n        code: string;\n        status: number;\n        userMessage: string;\n      };\n      err.code = code;\n      err.status = status;\n      err.userMessage = userMessage;\n      return err;\n    }\n    const { event, input } = ctx;\n\n    if (event === 'beforeInsert' || event === 'beforeUpdate') {\n      if (typeof input.website === 'string' && input.website.length > 0) {\n        if (!/^https?:\\/\\//i.test(input.website)) {\n          throw refuse('Website must start with http:// or https://', 'VALIDATION_FAILED', 400);\n        }\n      }\n      if (typeof input.annual_revenue === 'number' && input.annual_revenue < 0) {\n        throw refuse('Annual Revenue must be greater than or equal to 0', 'VALIDATION_FAILED', 400);\n      }\n\n      // \u2500\u2500\u2500 Territory (#621 storage location, #639 classification) \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n      //\n      // Two derived columns, one input. `billing_country` is the flat\n      // projection of `billing_address.country`; `territory` is the CLASSIFIED\n      // value the two territory sharing rules now filter on. This block is the\n      // only writer of both.\n      //\n      // `billing_country` became a flat column because a sharing rule's CEL\n      // condition is compiled into a pushdown-able query filter, and that\n      // compiler rejects any path reaching INSIDE a composite `address` value\n      // \u2014 `record.billing_address.country in [...]` is not translatable, so\n      // plugin-sharing dropped both rules on every boot and `na_sales_team` /\n      // `eu_sales_team` got nothing at all (#621).\n      //\n      // That fixed WHERE the country is read from and left WHAT the rules\n      // match on unfixed: a free-text country. `United States` matched no\n      // territory, silently, and the same country lists were restated in two\n      // CEL strings and six documentation files. #639 replaced the matching\n      // with `territory`, a declared select \u2014 see `./_territory.ts` for the\n      // whole argument and for the authored tables this table is derived from.\n      //\n      // \u2500\u2500 Two different recompute rules, on purpose \u2500\u2500\n      //\n      // `billing_country` MIRRORS the address, so it is rewritten only when\n      // the write carries one: a partial update that never mentions\n      // `billing_address` must leave it alone, or every unrelated edit would\n      // blank the column. A write that CLEARS the address\n      // (`billing_address: null`) does clear it \u2014 the key is present, the\n      // value is empty.\n      //\n      // `territory` is a CLASSIFICATION, and #639 decided it is always a\n      // stated fact rather than a blank (\"belongs to no territory\" and \"nobody\n      // filled it in\" must not look alike). So it is also stated on an insert\n      // that carries no address at all, where it is `other`. On an update that\n      // does not mention the address it is left alone, exactly like the\n      // projection \u2014 an unrelated edit must not re-derive it.\n      //\n      // Only `country` is read. `countryCode` is the ISO 3166-1 alpha-2 slot\n      // and would be the better input, but it is optional and mostly empty in\n      // this app's data; reading it in preference would move which slot decides\n      // an account's territory, which #639 did not ask for. `UK` vs `GB` is\n      // handled in the mapping instead (both are `emea`), which is why nothing\n      // had to migrate.\n      //\n      // \u2500\u2500 Why the map is INLINE rather than imported \u2500\u2500\n      //\n      // A hook handler is lowered to a metadata-only `body.source` and\n      // evaluated inside QuickJS with no module scope, so an import is a\n      // `ReferenceError` at runtime, not a closure; `extractHookBody` rejects\n      // such a handler and `test/action-sandbox.test.ts` runs that same\n      // lowering pass over every registered hook. The table therefore cannot be\n      // read from `./_territory.ts` here. It is not trusted to stay in step\n      // either: `test/territory-single-source.test.ts` parses this literal out\n      // of the LOWERED body and asserts deep equality with the module's derived\n      // map, so a country added to either side alone fails.\n      if ('billing_address' in input || event === 'beforeInsert') {\n        const address = input.billing_address;\n        const country =\n          address !== null && typeof address === 'object' && !Array.isArray(address)\n            ? (address as { country?: unknown }).country\n            : undefined;\n        // The one normalisation rule, mirrored from `normalizeCountry`: trim,\n        // collapse internal whitespace, upper-case. Every key below is written\n        // in that form, so the lookup is a plain property read rather than a\n        // pile of tolerant comparisons.\n        const normalized =\n          typeof country === 'string' ? country.trim().replace(/\\s+/g, ' ').toUpperCase() : '';\n\n        if ('billing_address' in input) {\n          input.billing_country = normalized === '' ? null : normalized;\n        }\n\n        // A COPY of the map derived in `./_territory.ts`, kept here because a\n        // sandboxed body cannot import it (see above). Edit `_territory.ts`\n        // and mirror the result here \u2014 `test/territory-single-source.test.ts`\n        // reads this literal back out of the lowered body and fails if the two\n        // disagree, so the mirroring is enforced rather than remembered.\n        const TERRITORY_BY_COUNTRY: Record<string, string> = {\n          \"US\": \"na\", \"CA\": \"na\", \"MX\": \"na\",\n          \"GB\": \"emea\", \"DE\": \"emea\", \"FR\": \"emea\", \"IT\": \"emea\", \"ES\": \"emea\",\n          \"UNITED STATES\": \"na\", \"UNITED STATES OF AMERICA\": \"na\", \"USA\": \"na\",\n          \"CANADA\": \"na\", \"MEXICO\": \"na\",\n          \"UK\": \"emea\", \"UNITED KINGDOM\": \"emea\", \"GREAT BRITAIN\": \"emea\",\n          \"GERMANY\": \"emea\", \"FRANCE\": \"emea\", \"ITALY\": \"emea\", \"SPAIN\": \"emea\"\n        };\n        input.territory = TERRITORY_BY_COUNTRY[normalized] || 'other';\n      }\n\n      // \u2500\u2500\u2500 Account-name match key (#626) \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n      //\n      // `name_normalized` is the column `lead_conversion` matches accounts on,\n      // and this block is its only writer. It exists because the flow that\n      // reads it cannot compute it: `service-automation`'s template resolver\n      // knows one function form (`NOW()` / `TODAY()`), so `{LOWER(x)}`,\n      // `{TRIM(x)}` and `{x.toLowerCase()}` all resolve to `undefined` \u2014 and a\n      // formula field has no physical column to filter on\n      // (`fieldHasColumn(formula) === false`). The canonical form therefore has\n      // to be established HERE, by the producer, exactly as `crm_lead.email`\n      // and `crm_contact.email` are.\n      //\n      // lower + trim + collapse internal whitespace, so \"Acme Corp\",\n      // \"ACME  Corp\" and \" acme corp \" all land on `acme corp`. That is the\n      // whole transform: normalize-then-EXACT. Fuzzy matching is out of scope\n      // (see the field's doc comment on `crm_account`).\n      //\n      // Recompute ONLY when the write carries the name \u2014 a partial update that\n      // never mentions `name` must leave the key alone, or every unrelated edit\n      // would blank it and make the account invisible to conversion. `name` is\n      // required + notNull, so on insert it is always present; the null branch\n      // is for a whitespace-only value the validator would reject anyway.\n      //\n      // Written inline, not as a module-scope helper, for the same reason as\n      // the block above: hook bodies lower to metadata-only (no free\n      // identifiers), which `test/action-sandbox.test.ts` enforces.\n      if ('name' in input) {\n        const rawName = input.name;\n        const normalizedName =\n          typeof rawName === 'string'\n            ? rawName.trim().toLowerCase().replace(/\\s+/g, ' ')\n            : '';\n        input.name_normalized = normalizedName === '' ? null : normalizedName;\n      }\n    }\n\n    // Stamp last_activity_date when ownership or type changes.\n    // USER writes only (`ctx.user?.id` \u2014 this repo's system-write signal, cf.\n    // opportunity/quote hooks): the platform's seed-ownership claim re-owns\n    // ownerless seeded accounts as a system write (the retired `demo_bootstrap`\n    // sweep did the same every 10 minutes), and stamping those flattened every\n    // seeded activity date to \"today\", emptying the churn report buckets.\n    // D3 stand-down on the predicate path (`forecast.hook.ts`): `ownerChanged`\n    // / `typeChanged` are decided against THIS row's `previous`, so the stamp\n    // would spread to every matched row. The `billing_country` / `territory` /\n    // `name_normalized` normalisation above reads only the payload and stays.\n    if (event === 'beforeUpdate' && ctx.user?.id && ctx.dispatch?.mode !== 'per-row') {\n      const prev = ctx.previous ?? {};\n      const ownerChanged = typeof input.owner_id !== 'undefined' && input.owner_id !== prev.owner_id;\n      const typeChanged = typeof input.type !== 'undefined' && input.type !== prev.type;\n      if (ownerChanged || typeChanged) {\n        input.last_activity_date = new Date().toISOString().slice(0, 10);\n      }\n    }\n\n    if (event === 'beforeDelete') {\n      const previous = ctx.previous;\n      if (!previous || previous.type !== 'customer') return;\n      const api = ctx.api as HookApi | undefined;\n      if (!api) return;\n      // EVERY opportunity, closed ones included (#2019). A closed deal is the\n      // account's sales history \u2014 the won and lost amounts its rollups,\n      // forecasts and win rates are read from \u2014 and the app keeps it: the\n      // `crm_opportunity.crm_account` lookup is required and does not cascade,\n      // so the engine refuses the delete while ANY deal names the account, and\n      // `opportunity_lifecycle` freezes a closed deal against being moved to\n      // another account. This guard used to count open deals only and tell the\n      // user to \"Close or reassign it first\"; closing it was answered by the\n      // engine's own refusal all the same. So the count is the engine's, and\n      // the sentence names what frees the account for every deal it counts \u2014\n      // deleting it (an open deal could also be moved; a closed one cannot) \u2014\n      // and the way to retire a customer that keeps its history: the account\n      // goes inactive, as `product_catalog` retires a product with a history.\n      const opportunities = await api.object('crm_opportunity').count({\n        where: { crm_account: previous.id },\n      });\n      if (opportunities > 0) {\n        // Whole sentence per branch, not a stitched-together noun (#721). The\n        // count switched the NOUN only (`opportunit{y,ies}`) while the verb and\n        // the closing pronoun stayed plural, so the singular case read\n        // \"1 open opportunity still reference it. Close or reassign them\n        // first.\" Agreement runs across three words here \u2014 noun, verb and\n        // pronoun \u2014 and the two readable sentences are cheaper to keep correct\n        // (and to grep for) than three interlocking conditionals.\n        throw refuse(\n          opportunities === 1\n            ? 'Cannot delete customer account: 1 opportunity, open or closed, still references it. Delete the opportunity first, or mark the account inactive to retire it instead.'\n            : `Cannot delete customer account: ${opportunities} opportunities, open or closed, still reference it. Delete the opportunities first, or mark the account inactive to retire it instead.`,\n          'DELETE_RESTRICTED',\n          409,\n        );\n      }\n      // `crm_contract` is master-detail under the account (#549), so a delete\n      // would cascade the signed agreements away. Activated = live (the same\n      // definition `contact_integrity` uses); drafts and ended contracts go.\n      const activeContracts = await api.object('crm_contract').count({\n        where: { crm_account: previous.id, status: 'activated' },\n      });\n      if (activeContracts > 0) {\n        throw refuse(\n          activeContracts === 1\n            ? 'Cannot delete customer account: 1 activated contract still references it. Terminate or reassign it first.'\n            : `Cannot delete customer account: ${activeContracts} activated contracts still reference it. Terminate or reassign them first.`,\n          'DELETE_RESTRICTED',\n          409,\n        );\n      }\n    }\n  },\n};\n\nexport default accountHook;\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/sales/objects/contact.hook.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/sales/objects\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/sales/objects/contact.hook.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport type { Hook, HookContext } from '@objectstack/spec/data';\nimport type { HookApi } from './_hook-api';\n\n/**\n * Contact integrity hook.\n *\n * - On insert/update, dedupes by `email` WITHIN THE ORGANIZATION \u2014 matching\n *   the constraint the schema actually declares. `crm_contact.email` carries\n *   field-level `unique: true`, which materializes as the tenant composite\n *   `(organization_id, email)` (framework#3696), so the address is unique\n *   across every account of one organization and two organizations may each\n *   know the same person. The lookup is deliberately NOT account-scoped (the\n *   old per-account lookup let a cross-account duplicate sail past the\n *   friendly check and explode on the DB index instead, mid-conversion) \u2014 but\n *   it must not reach ACROSS organizations either.\n *\n *   ## What an unscoped lookup cost, as measured\n *\n *   `ctx.api` reads are not organization-scoped for every caller: the seed\n *   loader replays a dataset per organization as a SYSTEM write, and an\n *   unscoped `findOne({ where: { email } })` from inside that replay meets the\n *   FIRST organization's contacts. On the deployment shape where many\n *   organizations share one database, the second organization's replay was\n *   refused row by row \u2014 `Another contact (\u2026) with email\n *   john.smith@acme.example.com already exists.` \u2014 landing 0 of 9 contacts\n *   and, because `crm_contract` requires one, 0 of 4 contracts, plus\n *   half-populated quotes, quote line items, campaign members and event\n *   attendees. Nothing leaked; the tenant wall held. The data never arrived.\n *\n *   The organization is therefore resolved before the lookup, in the blessed\n *   order: the acting user's active organization first (`user.organizationId`\n *   === `session.organizationId` === the `organization_id` column === RLS's\n *   `current_user.organizationId`), then the row's own stamp, which is what a\n *   system write carries when no session does. Resolved: scope the lookup.\n *   Unresolvable on a system write: skip the friendly guard and let the\n *   `(organization_id, email)` index enforce. Unresolvable for a USER write:\n *   an untenanted (community) install, where the old global lookup is right.\n * - On delete, refuses if the contact is referenced by an active opportunity,\n *   open quote or active contract.\n *\n * \u26D4 No email/phone propagation to opportunities: `crm_opportunity` has no\n * `contact_email` / `contact_phone` columns, and a rollup writing nonexistent\n * fields is silently swallowed. Opportunities reach the live values through\n * their `primary_contact` lookup.\n */\n\nconst contactHook: Hook = {\n  name: 'contact_integrity',\n  object: 'crm_contact',\n  events: ['beforeInsert', 'beforeUpdate', 'beforeDelete'],\n  priority: 200,\n  description:\n    'Dedupe contacts by email and protect referenced contacts from deletion.',\n  handler: async (ctx: HookContext) => {\n    // The refusal envelope (#1075). Mirrored from `./_refusal.ts` because a\n    // lowered body has no module scope and `extractHookBody` THROWS on an\n    // import; `test/refusal-envelope.test.ts` pins every copy against it.\n    function refuse(\n      message: string,\n      code: string,\n      status: number,\n      userMessage: string = message,\n    ): Error {\n      const err = new Error(message) as Error & {\n        code: string;\n        status: number;\n        userMessage: string;\n      };\n      err.code = code;\n      err.status = status;\n      err.userMessage = userMessage;\n      return err;\n    }\n    const { event, input } = ctx;\n    const api = ctx.api as HookApi | undefined;\n\n    if ((event === 'beforeInsert' || event === 'beforeUpdate') && api) {\n      const email = typeof input.email === 'string' ? input.email.toLowerCase() : '';\n      if (email) {\n        input.email = email;\n        // Scope the guard to the organization the write belongs to, so it is\n        // exactly as strict as the `(organization_id, email)` index it fires\n        // ahead of \u2014 no stricter. An unresolvable organization on a SYSTEM\n        // write (no `ctx.user`) means the caller is the seed loader or a\n        // backfill: skip the friendly guard rather than run it unscoped, and\n        // let the database constraint be the enforcement. Running it unscoped\n        // there is what starved every organization after the first of its\n        // contacts.\n        const organizationId = [\n          ctx.user?.organizationId,\n          ctx.session?.organizationId,\n          input.organization_id,\n          ctx.previous?.organization_id,\n        ].find((candidate): candidate is string => typeof candidate === 'string' && candidate !== '');\n        if (organizationId || ctx.user?.id) {\n          const dup = await api.object('crm_contact').findOne({\n            where: organizationId ? { organization_id: organizationId, email } : { email },\n          });\n          const dupRow = dup as\n            | { id?: string; first_name?: unknown; last_name?: unknown }\n            | null;\n          const dupId = dupRow?.id;\n          const selfId = ctx.previous?.id ?? input.id;\n          if (dup && dupId !== selfId) {\n            // Name the colliding contact, not its primary key (#1243, the same\n            // class #1208 closed on the escalation task). This refusal is read\n            // by a rep in a dialog at the moment their save is blocked, and the\n            // one actionable thing it can say is WHOSE record already holds the\n            // address. The id was the opposite of that: a 16-character string\n            // that appears on no screen in this app and cannot be pasted into\n            // search. `full_name` is `crm_contact.nameField`, and it is composed\n            // from the same two stored columns here \u2014 a lowered hook body cannot\n            // read a formula field. No second read pays for it: the `findOne`\n            // above carries no projection, so the whole row is already in hand.\n            const dupName = [dupRow?.first_name, dupRow?.last_name]\n              .filter((part) => typeof part === 'string' && part.trim() !== '')\n              .join(' ');\n            throw refuse(\n              dupName\n                ? `Another contact (${dupName}) with email ${email} already exists.`\n                : `Another contact with email ${email} already exists.`,\n              'DUPLICATE_VALUE',\n              409,\n            );\n          }\n        }\n      }\n    }\n\n    if (event === 'beforeDelete' && api) {\n      const id = ctx.previous?.id;\n      if (!id) return;\n      const [openOpps, openQuotes, activeContracts] = await Promise.all([\n        api.object('crm_opportunity').count({\n          where: { primary_contact: id, stage: { $nin: ['closed_won', 'closed_lost'] } },\n        }),\n        api.object('crm_quote').count({\n          where: { crm_contact: id, status: { $nin: ['rejected', 'expired'] } },\n        }),\n        api.object('crm_contract').count({\n          where: { crm_contact: id, status: 'activated' },\n        }),\n      ]);\n      const total = openOpps + openQuotes + activeContracts;\n      if (total > 0) {\n        // Phrase the refusal as the BLOCKING RELATIONSHIP, not as the caller's\n        // operation (#693). This hook fires on a direct\n        // `DELETE /crm_contact/<id>` AND as a cascade child of\n        // `DELETE /crm_account/<id>` (`crm_contact.crm_account` is a\n        // master-detail with `deleteBehavior: 'cascade'`), and the hook context\n        // carries nothing that distinguishes the two \u2014 measured on 17.0.0-rc.2,\n        // a cascaded `beforeDelete` ctx holds exactly\n        // {api,event,input,object,previous,provenance,ql,session,transaction,user}\n        // with no cascade marker. So \"Cannot delete contact\" told an account\n        // deleter that they had asked to delete a contact, and sent them\n        // looking for the wrong record. Naming the contact and both\n        // consequences is true in either context.\n        const name = [ctx.previous?.first_name, ctx.previous?.last_name]\n          .filter((part) => typeof part === 'string' && part.trim() !== '')\n          .join(' ');\n        // Named, never keyed (#1243). `id` still does the work it is good at \u2014\n        // it is what the three counts above were queried by \u2014 but the sentence\n        // the user reads names the contact the way `nameField` does. A contact\n        // with no name at all is referred to, not identified: a bare id told\n        // the reader nothing they could look up either.\n        const subject = name ? `Contact ${name}` : 'This contact';\n        // What frees the contact is not the same for the three (#2019). An\n        // opportunity's `primary_contact` and a quote's `crm_contact` are\n        // optional, so once the deal or quote is settled the engine clears the\n        // link and the delete lands. A contract's `crm_contact` is REQUIRED: a\n        // contract keeps its primary contact for its whole life, ended or not\n        // \u2014 it is the account's signed record and is kept, so the engine\n        // refuses the delete while ANY contract names the contact. The old\n        // closing \"Close or reassign those records first\" sent the user to\n        // terminate the contract, after which the engine refused all the same.\n        // So the sentence says what frees the contact from a contract: another\n        // primary contact on it.\n        //\n        // \u26D4 The COUNT stays `activated`, and that is deliberate. This guard also\n        // runs inside an account delete (the cascade above) and cannot tell the\n        // two apart, and an account delete takes its draft and ended contracts\n        // with it (#549, `account_protection`). Counting those here would make\n        // this guard refuse that account delete itself \u2014 today the engine\n        // already refuses it on the cascade's order (objectstack#22305, pinned\n        // in `test/hooks-runtime-sales.test.ts`), and that is the platform's to\n        // fix. An ended contract on a DIRECT contact delete is refused by the\n        // engine, in its own words naming the contract.\n        throw refuse(\n          `${subject} is still referenced by ${openOpps} open opportunity(ies), ${openQuotes} active quote(s), ${activeContracts} active contract(s), so it cannot be deleted \u2014 and neither can its account, because deleting an account deletes its contacts. Close or reassign the opportunities and quotes first, and give each contract another primary contact: a contract keeps its primary contact even after it ends.`,\n          'DELETE_RESTRICTED',\n          409,\n        );\n      }\n    }\n  },\n};\n\nexport default contactHook;\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/sales/objects/event.hook.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/sales/objects\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/sales/objects/event.hook.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport type { Hook, HookContext } from '@objectstack/spec/data';\nimport type { HookApi } from './_hook-api';\n\n/**\n * Event lifecycle hooks (#592).\n *\n * - `event_schedule_derive` keeps `start_datetime` / `end_datetime` /\n *   `duration_minutes` mutually consistent, so a calendar view and a duration\n *   report cannot disagree about the same row.\n * - `event_activity_bubble` is the app's PRIMARY writer of interaction\n *   recency: a `held` event stamps `crm_account.last_activity_date`,\n *   `crm_lead.last_contacted_date` and `crm_contact.last_contacted_date`,\n *   walking UP from an opportunity / case / contact to the account it hangs\n *   off. Since #595 it is also the SINGLE writer of\n *   `crm_case.first_response_date` (see the block at the end of the handler).\n *\n * # Why the walk-up matters\n *\n * `at_risk_accounts` and `customer_churn_signals` are built on\n * `crm_account.last_activity_date`, but a rep logs a call on the OPPORTUNITY or\n * the CONTACT \u2014 almost never on the account row itself. \u26D4 Bubbling only to the\n * directly-named record leaves the account clock untouched through an entire\n * sales cycle, and the churn report then counts a busy customer as silent. The\n * walk-up is the whole reason the signal becomes real.\n */\n\nconst eventScheduleDerive: Hook = {\n  name: 'event_schedule_derive',\n  object: 'crm_event',\n  events: ['beforeInsert', 'beforeUpdate'],\n  priority: 200,\n  description:\n    'Keep start/end/duration coherent: derive whichever of end_datetime or duration_minutes was not supplied.',\n  handler: async (ctx: HookContext) => {\n    // D3 stand-down: a predicate update has ONE payload for every matched row,\n    // so the `ctx.previous`-conditioned writes below would land on rows that\n    // did not earn them \u2014 refused as a diverging key set, or stored silently\n    // from the last row. Full account and the measurement: `forecast.hook.ts`.\n    if (ctx.event === 'beforeUpdate' && ctx.dispatch?.mode === 'per-row') return;\n\n    const { input } = ctx;\n    const previous = ctx.previous;\n\n    const effective = (key: string): unknown =>\n      input[key] !== undefined && input[key] !== null ? input[key] : previous?.[key];\n\n    const start = effective('start_datetime');\n    const end = effective('end_datetime');\n    const durationRaw = effective('duration_minutes');\n\n    const startMs = typeof start === 'string' || start instanceof Date ? new Date(start as string).getTime() : NaN;\n    const endMs = typeof end === 'string' || end instanceof Date ? new Date(end as string).getTime() : NaN;\n    const duration = typeof durationRaw === 'number' && isFinite(durationRaw) ? durationRaw : NaN;\n\n    // An all-day event has no meaningful minute count; leave duration alone so\n    // a report can tell \"all day\" apart from \"we forgot to fill it in\".\n    const allDay = effective('all_day') === true;\n\n    if (!isNaN(startMs) && !isNaN(endMs)) {\n      // Both ends known \u2014 the duration is a MEASUREMENT, so it is recomputed\n      // even when the caller supplied one. A stored duration that disagrees\n      // with its own timestamps is the kind of metadata a report quietly\n      // averages into nonsense.\n      if (!allDay) input.duration_minutes = Math.max(0, Math.round((endMs - startMs) / 60000));\n    } else if (!isNaN(startMs) && isNaN(endMs) && !isNaN(duration) && duration > 0) {\n      // Duration-only, the shape `log_call` submits (\"a 20-minute call, now\").\n      // Materialising the end timestamp is what puts the row on a calendar.\n      input.end_datetime = new Date(startMs + duration * 60000).toISOString();\n    }\n\n    // A cancelled or no-show meeting occupies no one's time. Zeroing it keeps\n    // \"meeting minutes this week\" honest without deleting the row, which is\n    // still evidence that the interaction was attempted.\n    const status = effective('status');\n    if (status === 'cancelled' || status === 'no_show') input.duration_minutes = 0;\n  },\n};\n\n/**\n * The activity bubble \u2014 the canonical copy (`task_activity_bubble` carries a\n * verbatim twin).\n *\n * ## `runAs: 'system'` (#2014, AGENTS.md rule 9)\n *\n * The clocks it stamps belong to the records the interaction was WITH \u2014 the\n * account, contact and lead \u2014 and to the case it answered, not to the person\n * who logged it. As the caller, every one of those writes (and the walk-up\n * reads) met the caller's grants: a service agent holds no edit right on\n * accounts, and a rep need not own the account or contact their own deal hangs\n * off. Each refusal was swallowed best-effort, so the clocks never moved\n * (measured on 17.7.0: a service agent's held call on their own case left the\n * case account's `last_activity_date` empty while an admin's identical call\n * stamped it; the task twin the same, and a rep's completed task on their own\n * deal reached neither the account nor the contact a manager owns). So the\n * hook elevates. It writes nothing the caller chose beyond the links already on\n * the event, and only the recency dates and the case's first-response stamp;\n * elevation is not anonymity \u2014 `updated_by` still names the person.\n *\n * ## Organization (AGENTS.md rule 10)\n *\n * Every read and every write is pinned to the triggering event's own\n * `organization_id` when it carries one: the walk-up reads carry the predicate,\n * and because a by-id update cannot (the engine refuses an extra `where` key on\n * the by-id path), each write target is first confirmed inside the\n * organization by one pinned read per object. A person's elevated context\n * already keeps their tenant; the pin is what holds the wall for a trigger\n * that carries none (a system write, which runs unscoped). An event with no\n * organization (a single-organization install) has no wall, and is not pinned.\n */\nconst eventActivityBubble: Hook = {\n  name: 'event_activity_bubble',\n  object: 'crm_event',\n  events: ['afterInsert', 'afterUpdate'],\n  priority: 800,\n  async: true,\n  onError: 'log',\n  runAs: 'system',\n  description:\n    'A held event stamps interaction recency on the related account (walking up from contact/opportunity/case), lead and contact, and the first-response time on a related case.',\n  handler: async (ctx: HookContext) => {\n    const { input } = ctx;\n    const previous = ctx.previous;\n    const api = ctx.api as HookApi | undefined;\n    if (!api) return;\n\n    const r: Record<string, any> = { ...(previous ?? {}), ...input };\n\n    // Only an interaction that HAPPENED resets the recency clock. A meeting\n    // booked for next quarter is not contact; letting `planned` bubble would\n    // make an account look freshly-touched the moment someone put a placeholder\n    // on the calendar, which is the exact failure mode the churn report exists\n    // to avoid.\n    if (r.status !== 'held') return;\n    // Fire once, on the transition into `held` (afterInsert has no `previous`).\n    if (previous && previous.status === 'held') return;\n\n    const nowIso = new Date().toISOString();\n    // `crm_account.last_activity_date` is a DATE column; the two contact\n    // timestamps are datetimes. Passing an ISO instant to a date column is what\n    // stores '2026-08-04T\u2026' in a field every filter compares as 'YYYY-MM-DD'.\n    const today = nowIso.slice(0, 10);\n\n    const idOf = (key: string): string | undefined =>\n      typeof r[key] === 'string' && r[key].length > 0 ? (r[key] as string) : undefined;\n    // The rule-10 pin \u2014 see the hook's note.\n    const org = idOf('organization_id');\n    const inOrg: Record<string, string> = org ? { organization_id: org } : {};\n\n    const accountIds = new Set<string>();\n    const contactIds = new Set<string>();\n    const leadIds = new Set<string>();\n\n    const direct = idOf('related_to_account');\n    if (direct) accountIds.add(direct);\n    const contactId = idOf('related_to_contact');\n    if (contactId) contactIds.add(contactId);\n    const leadId = idOf('related_to_lead');\n    if (leadId) leadIds.add(leadId);\n\n    // Walk UP to the account. Every one of these objects names its parent\n    // `crm_account`, so one loop covers all three. `find(... top: 1)` rather\n    // than `findOne`: the two agree here, and `find` is the shape the rest of\n    // the app's hooks read with.\n    const parentLookups: Array<[string, string]> = [\n      ['related_to_contact', 'crm_contact'],\n      ['related_to_opportunity', 'crm_opportunity'],\n      ['related_to_case', 'crm_case'],\n    ];\n    for (const [field, object] of parentLookups) {\n      const id = idOf(field);\n      if (!id) continue;\n      try {\n        const raw: any = await api.object(object).find({\n          where: { id, ...inOrg },\n          fields: ['crm_account'],\n          top: 1,\n        });\n        const rows = Array.isArray(raw) ? raw : (raw?.records ?? []);\n        const parent = rows.length ? rows[0].crm_account : undefined;\n        if (typeof parent === 'string' && parent.length > 0) accountIds.add(parent);\n      } catch {\n        // Best-effort: a parent that cannot be read is not bubbled through.\n        // No `console` in the L2 hook sandbox \u2014 logging here would throw its\n        // own ReferenceError (cf. #471).\n      }\n    }\n\n    const targets: Array<[string, Set<string>, Record<string, any>]> = [\n      ['crm_account', accountIds, { last_activity_date: today }],\n      ['crm_contact', contactIds, { last_contacted_date: nowIso }],\n      ['crm_lead', leadIds, { last_contacted_date: nowIso }],\n    ];\n    for (const [object, ids, doc] of targets) {\n      let inside = [...ids];\n      if (org && inside.length > 0) {\n        try {\n          const raw: any = await api.object(object).find({ where: { id: { $in: inside }, ...inOrg }, fields: ['id'], top: inside.length });\n          inside = (Array.isArray(raw) ? raw : (raw?.records ?? [])).map((row: any) => String(row.id));\n        } catch {\n          inside = [];\n        }\n      }\n      for (const id of inside) {\n        try {\n          // `update(document, options)` \u2014 `ctx.api` is the engine repo facade,\n          // whose update takes a DOCUMENT, not an id (#616; pinned by\n          // test/hook-write-shape.test.ts against a real kernel).\n          await api.object(object).update({ ...doc, id }, { where: { id } });\n        } catch {\n          // Best-effort activity bubble; never break the parent write.\n        }\n      }\n    }\n\n    // \u2500\u2500 First response on a case (#595) \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n    //\n    // \u26D4 The SINGLE writer of `crm_case.first_response_date`, and it belongs\n    // here rather than in the `log_call` / `log_meeting` action bodies: stamping\n    // it per-button covers only interactions recorded through those two\n    // buttons, and an event created any other way (the Activity tab, an import,\n    // an integration, a future action) leaves the most standard SLA metric a\n    // service desk reports permanently null. The rule those actions express is\n    // the one this hook already computes for recency \u2014 an interaction that\n    // HAPPENED \u2014 so it lives once, where every writer of a held event passes\n    // through it. Same argument that makes this hook the single writer of\n    // recency, and `case_status_side_effects` the single owner of escalation\n    // follow-up tasks.\n    //\n    // A status change is deliberately NOT a first response: an agent can move a\n    // case to \"in progress\" and investigate\n    // for an hour while the customer hears nothing, so a status-derived number\n    // would report a response that never happened. Neither is a meeting merely\n    // BOOKED \u2014 that is the `held` gate above, which this block sits under.\n    const responseCaseId = idOf('related_to_case');\n    if (responseCaseId) {\n      try {\n        // Read the STORED value rather than trusting the event's own payload:\n        // \"first response\" is a property of the case, so the second held event\n        // on a case must find the first one's stamp and leave it alone. A\n        // re-stamp would silently turn the metric into \"last response\".\n        // Pinned like the bubble, and written only when the read FOUND the\n        // case: under elevation an empty read means \"not this organization's\"\n        // (or gone), never \"not stamped yet\".\n        const raw: any = await api.object('crm_case').find({\n          where: { id: responseCaseId, ...inOrg },\n          fields: ['first_response_date'],\n          top: 1,\n        });\n        const rows = Array.isArray(raw) ? raw : (raw?.records ?? []);\n        if (rows.length > 0 && !rows[0].first_response_date) {\n          await api.object('crm_case').update(\n            { id: responseCaseId, first_response_date: nowIso },\n            { where: { id: responseCaseId } },\n          );\n        }\n      } catch {\n        // Best-effort, like the bubble above: never break the event write.\n      }\n    }\n  },\n};\n\n/**\n * `do_not_call` \u2014 the calendar half of the same promise.\n *\n * `crm_task` carries the follow-up a rep OWES; `crm_event` carries the slot a\n * rep BOOKS. A `planned` event of type `call` is a booked outbound phone call,\n * so it is refused against a person flagged `do_not_call` for exactly the\n * reasons stated on `task_do_not_call_guard` in `src/sales/objects/task.hook.ts`\n * (read that block first \u2014 it carries the full rationale for enforcing on the\n * write rather than on a button, and for scoping to the phone).\n *\n * The status split is what makes this guard honest, and it is the whole reason\n * `log_call` needs no gate of its own:\n *\n *   - `status: 'held'`   \u2014 the call HAPPENED. Allowed, always. This is what\n *     `log_call` writes, and refusing it would hide evidence of a call rather\n *     than prevent one.\n *   - `status: 'planned'` \u2014 the call is BOOKED. Refused.\n *\n * `schedule_meeting` is deliberately NOT caught here: it hardcodes\n * `type: 'meeting'`, and a person who does not want phone calls may still be\n * met in person or over video. Gating it would widen `do_not_call` into\n * `do_not_contact`.\n */\nconst eventDoNotCallGuard: Hook = {\n  name: 'event_do_not_call_guard',\n  object: 'crm_event',\n  events: ['beforeInsert', 'beforeUpdate'],\n  priority: 150,\n  description: 'Refuse to book a planned Call event against a lead/contact flagged Do Not Call.',\n  handler: async (ctx: HookContext) => {\n    // The refusal envelope (#1075). Mirrored from `./_refusal.ts` because a\n    // lowered body has no module scope and `extractHookBody` THROWS on an\n    // import; `test/refusal-envelope.test.ts` pins every copy against it.\n    function refuse(\n      message: string,\n      code: string,\n      status: number,\n      userMessage: string = message,\n    ): Error {\n      const err = new Error(message) as Error & {\n        code: string;\n        status: number;\n        userMessage: string;\n      };\n      err.code = code;\n      err.status = status;\n      err.userMessage = userMessage;\n      return err;\n    }\n    const { input } = ctx;\n    const previous = ctx.previous;\n    const api = ctx.api as HookApi | undefined;\n    if (!api) return;\n\n    const effective = (key: string): unknown =>\n      input[key] !== undefined && input[key] !== null ? input[key] : previous?.[key];\n\n    if (effective('type') !== 'call') return;\n    // Only a booking. `held` (what `log_call` writes) and every other status\n    // describe a call that is no longer preventable.\n    if (effective('status') !== 'planned') return;\n\n    const leadId = effective('related_to_lead');\n    const contactId = effective('related_to_contact');\n\n    const targets: Array<{ object: string; id: string; label: string }> = [];\n    if (typeof leadId === 'string' && leadId) {\n      targets.push({ object: 'crm_lead', id: leadId, label: 'lead' });\n    }\n    if (typeof contactId === 'string' && contactId) {\n      targets.push({ object: 'crm_contact', id: contactId, label: 'contact' });\n    }\n\n    for (const t of targets) {\n      // `find(... top: 1)`, normalised for both driver shapes \u2014 same reasoning\n      // as `event_activity_bubble` below.\n      const raw: any = await api.object(t.object).find({\n        where: { id: t.id },\n        fields: ['id', 'do_not_call'],\n        top: 1,\n      });\n      const rows = Array.isArray(raw) ? raw : (raw?.records ?? []);\n      const person = rows[0];\n      // `=== true`: absent / null / false are all \"not flagged\".\n      if (person?.do_not_call === true) {\n        throw refuse(\n          `This ${t.label} is flagged Do Not Call, so a call cannot be scheduled against them. ` +\n            'Log the call as held if it already happened, book a meeting instead, ' +\n            'or clear Do Not Call on the record first.',\n          'FORBIDDEN',\n          403,\n        );\n      }\n    }\n  },\n};\n\nexport default [eventScheduleDerive, eventDoNotCallGuard, eventActivityBubble];\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/sales/objects/forecast.hook.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/sales/objects\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/sales/objects/forecast.hook.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport type { Hook, HookContext } from '@objectstack/spec/data';\n\n/**\n * Forecast lifecycle hook.\n *\n * Auto-derives the whole period family \u2014 `period_start`, `period_end` and\n * `period_label` \u2014 from `period` (+ `period_start`, when the caller supplies\n * one) so callers (UI, AI skill, the `forecast_snapshot` scheduled flow) don't\n * have to compute them. Also stamps `snapshot_date` to today on insert if\n * unset.\n *\n * Why `period_start` is derived here and nowhere else: a flow template can\n * express `{TODAY()}` and day offsets, but it has no way to say \"the first day\n * of the calendar quarter containing today\". If each writer computed its own\n * boundary we would get exactly the drift #530 pinned in the seeds \u2014 snapshots\n * labelled 'Q3 2026' whose `period_start` is some mid-quarter date, so every\n * \"this quarter\" equals-filter misses. One derivation, one definition: give\n * the object a `period` and it lands on a calendar-true boundary or not at all.\n *\n * NOTE: all helpers are inlined into `handler` because the build pipeline\n * lowers inline handlers \u2014 module-scope helpers would not survive lowering.\n */\nconst forecastDerive: Hook = {\n  name: 'forecast_derive_period',\n  object: 'crm_forecast',\n  events: ['beforeInsert', 'beforeUpdate'],\n  priority: 200,\n  description: 'Derive period_start, period_end and period_label from period (+ snapshot_date).',\n  handler: async (ctx: HookContext) => {\n    // \u26D4 A PREDICATE UPDATE DERIVES NOTHING HERE \u2014 ADR-0058 Addendum II D3.\n    //\n    // `update(obj, payload, { multi: true, where })` sends ONE `SET` clause for\n    // all N matched rows, and the engine hands every row's `beforeUpdate` THAT\n    // payload rather than a per-row copy. A payload write whose value \u2014 or\n    // whose if-guard \u2014 reads `ctx.previous` therefore does not scope itself to\n    // the row it was decided on. Both outcomes are measured on\n    // 17.4.0, in this app, on a fresh `pnpm dev`:\n    //\n    //  - keys written for SOME rows only \u21D2 the engine refuses the whole batch\n    //    (`MULTI_UPDATE_HOOK_KEY_DIVERGENCE`) and writes nothing. This hook's\n    //    own `if (!input.period_end)` did exactly that under the platform's\n    //    seed-ownership claim: row 0 stamped `period_end` / `period_label`\n    //    into the shared payload, rows 1-6 then saw them already set and\n    //    stamped nothing, so all 7 seeded forecasts stayed ownerless (#1804).\n    //  - the SAME key on EVERY row \u21D2 nothing diverges, the batch resolves, and\n    //    the LAST row's value is stored for all of them, in silence. That is\n    //    what left `probability: 80` on closed-lost opportunities (#1275).\n    //\n    // `ctx.previous` on this path is supplied so a guard can REFUSE a write,\n    // never so a rewrite can be aimed. Deriving is per-record work, so it\n    // stands down here and still happens on the per-record path \u2014 which is\n    // every writer this app has: all 19 `update_record` flow nodes and every\n    // action and hook write through `ctx.api`, all of them by id. The platform's\n    // seed-ownership claim is a predicate write, and it writes only `owner_id`,\n    // which derives nothing.\n    //\n    // \u26A0\uFE0F The `ctx.event` half is load-bearing, not ceremony: a BATCH INSERT\n    // also reports `dispatch.mode === 'per-row'`, and there each row carries\n    // its OWN payload \u2014 dropping that half would stop the seeds deriving their\n    // periods at all.\n    if (ctx.event === 'beforeUpdate' && ctx.dispatch?.mode === 'per-row') return;\n\n    const pad = (n: number) => String(n).padStart(2, '0');\n    const isoDate = (d: Date) =>\n      `${d.getUTCFullYear()}-${pad(d.getUTCMonth() + 1)}-${pad(d.getUTCDate())}`;\n    const MONTHS = ['Jan','Feb','Mar','Apr','May','Jun','Jul','Aug','Sep','Oct','Nov','Dec'];\n    const endOfMonth = (start: Date) =>\n      new Date(Date.UTC(start.getUTCFullYear(), start.getUTCMonth() + 1, 0));\n    // \"start + one period\", a ROLLING window \u2014 calendar-true only because a\n    // hand-filled `period_start` off a calendar boundary is now REFUSED by\n    // `period_start_first_of_period` / `quarter_starts_on_quarter_boundary` in\n    // `forecast.object.ts` (#1008). Before that rule, `2026-08-15` + `quarter`\n    // derived `2026-10-31` under the label `Q3 2026`.\n    const endOfQuarter = (start: Date) =>\n      new Date(Date.UTC(start.getUTCFullYear(), start.getUTCMonth() + 3, 0));\n    // First day of the calendar period CONTAINING `d` \u2014 the inverse of the\n    // two helpers above, and the piece a flow template cannot express.\n    const startOfPeriod = (period: string, d: Date) =>\n      new Date(Date.UTC(\n        d.getUTCFullYear(),\n        period === 'quarter' ? Math.floor(d.getUTCMonth() / 3) * 3 : d.getUTCMonth(),\n        1,\n      ));\n    const labelFor = (period: string, start: Date) => {\n      if (period === 'quarter') {\n        const q = Math.floor(start.getUTCMonth() / 3) + 1;\n        return `Q${q} ${start.getUTCFullYear()}`;\n      }\n      return `${MONTHS[start.getUTCMonth()]} ${start.getUTCFullYear()}`;\n    };\n\n    const { input } = ctx;\n    const previous = ctx.previous;\n    const period =\n      (typeof input.period === 'string' && input.period) ||\n      (typeof previous?.period === 'string' && (previous.period as string)) ||\n      'month';\n    let startStr =\n      (typeof input.period_start === 'string' && input.period_start) ||\n      (typeof previous?.period_start === 'string' && (previous.period_start as string)) ||\n      undefined;\n\n    // No period_start anywhere \u21D2 snapshot the period that contains the\n    // snapshot day (falling back to today). `period_start` is required +\n    // notNull, so before this the write simply failed; deriving it is what\n    // makes `{ period: 'quarter' }` a complete, calendar-true snapshot\n    // request \u2014 the only shape an automated writer can express.\n    if (!startStr) {\n      const anchorStr =\n        (typeof input.snapshot_date === 'string' && input.snapshot_date) ||\n        (typeof previous?.snapshot_date === 'string' && (previous.snapshot_date as string)) ||\n        isoDate(new Date());\n      const anchor = new Date(`${anchorStr.slice(0, 10)}T00:00:00Z`);\n      if (!Number.isNaN(anchor.getTime())) {\n        startStr = isoDate(startOfPeriod(period, anchor));\n        input.period_start = startStr;\n      }\n    }\n\n    if (startStr) {\n      const start = new Date(`${startStr}T00:00:00Z`);\n      if (!Number.isNaN(start.getTime())) {\n        const end = period === 'quarter' ? endOfQuarter(start) : endOfMonth(start);\n        if (!input.period_end) input.period_end = isoDate(end);\n        if (!input.period_label) input.period_label = labelFor(period, start);\n      }\n    }\n\n    if (!input.snapshot_date && !previous?.snapshot_date) {\n      input.snapshot_date = isoDate(new Date());\n    }\n  },\n};\n\nexport default forecastDerive;\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/sales/objects/lead.hook.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/sales/objects\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/sales/objects/lead.hook.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport type { Hook, HookContext } from '@objectstack/spec/data';\nimport type { HookApi } from './_hook-api';\n\n/**\n * Lead automation hook.\n *\n * - Auto-scores incoming leads into `rating` (1-5) using industry/title/email/phone weights.\n * - Refuses edits to a converted lead \u2014 but not the engine's reference cleanup,\n *   so a converted lead never makes its conversion products undeletable.\n * - When status flips to `qualified`, schedules a follow-up `crm_task` for the current user.\n * - Normalizes `email` and flags a re-captured address as a suspected duplicate.\n */\n\n// \u26A0\uFE0F The scoring constants and `computeRating` live INSIDE `lead_automation`'s\n// handler: L2 hook bodies run body-only in the QuickJS sandbox, so module scope\n// is not reachable at runtime. Tune the weights in the handler \u2014 a module-level\n// copy is dead code that silently diverges from the copy that actually runs.\n\n/**\n * Lead auto-assignment (load-balanced round-robin).\n *\n * A lead created without an owner (CSV import, web-to-lead, API capture) is\n * assigned to the sales rep with the FEWEST open leads \u2014 a self-balancing\n * round-robin that needs no rotation counter. It writes `owner_id`, the platform\n * ownership anchor that OWD, sharing and the \"My Leads\" view all read, so the\n * assigned rep really owns the lead rather than merely being named on it.\n *\n * \u26A0\uFE0F Writing a FOREIGN owner is normally an ownership transfer, denied without\n * `allowTransfer` (#3004). It passes here because of WHERE this runs, not what\n * it is granted: a `beforeInsert` hook mutates `opCtx.data` INSIDE the operation\n * the security middleware already wrapped, so the guard read (and stamped) the\n * payload before this line changed it. `test/ownership-model.test.ts` pins that\n * ordering against a real ObjectQL \u2014 an assumption here would be the difference\n * between round-robin working and every web-to-lead submission 403-ing.\n *\n * The rep pool is whoever holds the `sales_rep` position (`sys_user_position`).\n * When that pool is empty (a fresh org before positions are assigned) the hook\n * is a NO-OP and the lead keeps whatever owner it had \u2014 it never blocks lead\n * creation. UI-created leads already carry `owner_id` = creator (the\n * middleware's insert-time stamp), so this only fires on genuinely ownerless\n * intake.\n *\n * Runs beforeInsert so the downstream `lead_assignment` flow (afterInsert) sees\n * the assigned owner and routes its SLA alert to that rep.\n *\n * \u26A0\uFE0F Priority 250 \u2014 hooks run in ASCENDING priority order, so this must run\n * AFTER `lead_automation` (200), whose guest branch strips a client-spoofed\n * `owner_id` from anonymous Web-to-Lead submissions. Assigning first and being\n * stripped afterwards lands every web-to-lead ownerless \u2014 the exact case this\n * hook exists for.\n */\nconst leadAutoAssignHook: Hook = {\n  name: 'lead_auto_assign',\n  object: 'crm_lead',\n  events: ['beforeInsert'],\n  priority: 250,\n  description: 'Assign ownerless new leads to the least-loaded sales rep.',\n  handler: async (ctx: HookContext) => {\n    const { input } = ctx;\n    // Respect an explicit / creator-assigned owner. On a write that carries a\n    // user the security middleware has ALREADY stamped `owner_id` to that user\n    // by the time this runs, so this is also what makes the hook a no-op for\n    // ordinary UI creation \u2014 only genuinely ownerless intake falls through.\n    if (typeof input.owner_id === 'string' && input.owner_id) return;\n    const api = ctx.api as HookApi | undefined;\n    if (!api) return;\n\n    // Auto-assignment is a best-effort ENHANCEMENT \u2014 it must NEVER block lead\n    // creation. In particular an anonymous Web-to-Lead submission runs under the\n    // public-form grant, which permits only create/read-back on crm_lead and\n    // DENIES `find` on sys_user_position; letting that denial propagate would\n    // reject the whole insert and break the public form. So the pool lookup +\n    // load balancing are wrapped: on ANY error (permission, etc.) we log and\n    // leave the lead ownerless (a manager / the lead_assignment flow routes it).\n    try {\n      // Rep pool = holders of the sales_rep position.\n      const holders = await api.object('sys_user_position').find({\n        where: { position: 'sales_rep' }, fields: ['user_id'], top: 1000,\n      });\n      const repIds = Array.from(\n        new Set(\n          (holders ?? [])\n            .map((r) => (typeof r.user_id === 'string' ? r.user_id : ''))\n            .filter(Boolean),\n        ),\n      );\n      if (repIds.length === 0) return; // no pool \u2192 leave ownerless (no-op)\n\n      // Pick the rep with the fewest OPEN (non-converted) leads.\n      let best: string | undefined;\n      let bestCount = Infinity;\n      for (const repId of repIds) {\n        const openCount = await api.object('crm_lead').count({\n          where: { owner_id: repId, is_converted: false },\n        });\n        if (openCount < bestCount) {\n          bestCount = openCount;\n          best = repId;\n        }\n      }\n      if (best) input.owner_id = best;\n    } catch {\n      // Swallow: auto-assignment must never block the insert. Common case is the\n      // anonymous public-form context, which can't read sys_user_position \u2014 the\n      // lead is still captured, ownerless, for downstream routing. (No `console`\n      // here \u2014 the L2 hook sandbox doesn't define it.)\n    }\n  },\n};\n\nconst leadHook: Hook = {\n  name: 'lead_automation',\n  object: 'crm_lead',\n  events: ['beforeInsert', 'beforeUpdate', 'afterUpdate'],\n  priority: 200,\n  description:\n    'Score new leads, lock converted leads, and create follow-up task on qualification.',\n  handler: async (ctx: HookContext) => {\n    // The refusal envelope (#1075). Mirrored from `./_refusal.ts` because a\n    // lowered body has no module scope and `extractHookBody` THROWS on an\n    // import; `test/refusal-envelope.test.ts` pins every copy against it.\n    function refuse(\n      message: string,\n      code: string,\n      status: number,\n      userMessage: string = message,\n    ): Error {\n      const err = new Error(message) as Error & {\n        code: string;\n        status: number;\n        userMessage: string;\n      };\n      err.code = code;\n      err.status = status;\n      err.userMessage = userMessage;\n      return err;\n    }\n    const { event, input } = ctx;\n\n    const HIGH_VALUE_INDUSTRIES = new Set(['technology', 'finance', 'healthcare']);\n    const SENIOR_TITLE_PATTERN = /\\b(ceo|cto|cfo|cio|coo|founder|vp|vice president|director|head of)\\b/i;\n    function computeRating(input: Record<string, unknown>): number {\n      let score = 0;\n      const email = typeof input.email === 'string' ? input.email : '';\n      const phone = typeof input.phone === 'string' ? input.phone : '';\n      const title = typeof input.title === 'string' ? input.title : '';\n      const industry = typeof input.industry === 'string' ? input.industry : '';\n      const employees = typeof input.number_of_employees === 'number' ? input.number_of_employees : 0;\n      const revenue = typeof input.annual_revenue === 'number' ? input.annual_revenue : 0;\n      if (email && !/(gmail|yahoo|hotmail|outlook|qq|163)\\.com$/i.test(email)) score += 1;\n      if (phone.length > 0) score += 0.5;\n      if (SENIOR_TITLE_PATTERN.test(title)) score += 1.5;\n      if (HIGH_VALUE_INDUSTRIES.has(industry)) score += 1;\n      if (employees >= 200) score += 0.5;\n      if (revenue >= 10_000_000) score += 0.5;\n      // Cap at 5, floor at 1, round to WHOLE stars \u2014 `rating` is a 1-5 star\n      // field; half values rendered inconsistently in the star widget.\n      const clamped = Math.max(1, Math.min(5, score));\n      return Math.round(clamped);\n    }\n\n    if (event === 'beforeInsert') {\n      // Web-to-Lead: anonymous submissions from the public form get sensible\n      // defaults stamped server-side so they cannot be spoofed by the client.\n      // Guests are unauthenticated, so we identify them by the absence of\n      // `ctx.user?.id`. (The `guest_portal` profile already restricts them to\n      // INSERT-only on `crm_lead`.)\n      //\n      // \u26A0\uFE0F `!ctx.session?.isSystem` is required, not decoration: a SYSTEM write\n      // (seed load, backfill, seed-ownership claim) also arrives with no user id, and\n      // the strip below would otherwise blank the owner and conversion state of\n      // every system-written lead. The converted-lead lock further down reads\n      // that same absence as the system-write signal, so the two readings have\n      // to agree. `case.hook.ts`'s guest branch carries the same correction.\n      const isGuestSubmission = !ctx.user?.id && !ctx.session?.isSystem;\n      if (isGuestSubmission) {\n        if (!input.lead_source) input.lead_source = 'web';\n        if (!input.status)      input.status      = 'new';\n        // Never trust client-supplied conversion / ownership fields on a public\n        // form \u2014 OVERWRITE them with a safe value.\n        //\n        // \u2705 HISTORY, RESOLVED \u2014 and the conclusion is unchanged. Through\n        // 17.2.0, `delete input.x` in a hook was a SILENT NO-OP: ObjectQL's\n        // flat-record input Proxy had no `deleteProperty` trap, so the key\n        // survived the delete and reached storage, while an ASSIGNMENT to the\n        // same key on the same `input` landed normally. This block was ten\n        // `delete` statements and every one of them did nothing; the symptom was\n        // a guest insert storing `is_converted: true` and an `owner_id` it\n        // supplied itself. Assignment is what this block uses.\n        //\n        // Upstream objectstack#12277 shipped in **17.3.0**, so every later\n        // pin carries the fix and `delete` is effective on both execution paths.\n        // \u26D4 That is still not a licence to spell this block with `delete`: the\n        // assignments are load-bearing as WRITES \u2014 `lead_duplicate_check` stands\n        // down only on a NON-BLANK verdict, so these columns must arrive `null`\n        // rather than ABSENT. `case.hook.ts`'s copy carries the full note and\n        // the measurement; `test/hook-input-shape.test.ts` pins the new contract.\n        //\n        // `null` is the no-value spelling throughout, and it is load-bearing\n        // twice over: `lead_auto_assign` stands down only on a non-empty STRING\n        // `owner_id`, and `lead_duplicate_check` stands down only on a NON-BLANK\n        // `duplicate_status` / `duplicate_of_type` \u2014 where its own `isBlank`\n        // counts `null` as blank. Both therefore still run on a sanitised guest\n        // submission, which is exactly what the removed deletes were for.\n        input.is_converted           = false;\n        input.converted_account      = null;\n        input.converted_contact      = null;\n        input.converted_opportunity  = null;\n        input.converted_date         = null;\n        input.owner_id               = null;\n        // Same reasoning for the duplicate link: a submitter who can post\n        // `duplicate_status: 'confirmed'` can switch OFF the intake dedupe for\n        // their own submission (`lead_duplicate_check` stands down on a record\n        // that already carries a verdict) and park a link to any record id they\n        // care to guess. Guests state facts about themselves, never about the\n        // pipeline.\n        input.duplicate_of_type      = null;\n        input.duplicate_of_lead      = null;\n        input.duplicate_of_contact   = null;\n        input.duplicate_status       = null;\n      }\n\n      if (typeof input.rating !== 'number') {\n        input.rating = computeRating(input);\n      }\n    }\n\n    // \u2500\u2500 The conversion approval gate (REQ-0005 step 7) \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n    //\n    // \u300C\u7EBF\u7D22\u5BF9\u5E94\u5BA1\u6279\u6D41\u7A0B\uFF0C\u5BA1\u6279\u901A\u8FC7\u540E\u65B9\u53EF\u8F6C\u5316\u4E3A\u6B63\u5F0F\u5546\u673A\u300D. This is the WRITE-PATH\n    // half of the gate; `convert_lead`'s `visible` predicate is the other, and\n    // it only hides a button. Hiding a button is not a control: the conversion\n    // screen flow is reachable over REST (`POST /automation/lead_conversion/\n    // trigger`), and so is a bare `PATCH` that sets `is_converted` itself. Both\n    // land HERE, because both are an update to `crm_lead`.\n    //\n    // \u26A0\uFE0F A TRANSITION GATE, not an invariant (AGENTS.md metadata semantics rule\n    // 7), and the difference is the `!wasConverted` term rather than a comment\n    // claiming it. The refusal is conditioned on the record CROSSING into\n    // converted on THIS write; a lead that was already converted before the\n    // gate existed is untouched by it forever, whatever its approval column\n    // says (REQ-0005 acceptance 4). \u26D4 Never restate this as a `validations[]`\n    // script: a validation is evaluated against `{...previous, ...data}`, where\n    // \"already converted\" and \"converting now\" are the same state, so it would\n    // brick every later write to every historical converted lead.\n    //\n    // \u26A0\uFE0F The verdict is read off `previous`, never off `input`. The approval\n    // column is `readonly: true`, so a caller-supplied value is stripped before\n    // storage on the non-system path \u2014 but `stripReadonlyFields` is not a thing\n    // this guard may lean on (it does not run on inserts, nor for a system\n    // write), and reading the STORED verdict is the correct semantics anyway:\n    // what may convert a lead is what an approver decided, not what the writer\n    // attached to the request.\n    //\n    // \u26A0\uFE0F Fail OPEN on an absent or unrecognised verdict, and that is the gate's\n    // off switch, not an oversight. With the gate off \u2014 the shipped default \u2014\n    // every lead carries `not_required`, and a lead that predates the column\n    // carries nothing at all; both must convert exactly as they did before this\n    // field existed. So only the two verdicts a live approval actually writes\n    // refuse. (`convert_lead`'s predicate carries the same polarity and the\n    // same reason, against its own fail-CLOSED neighbours.)\n    if (event === 'beforeUpdate') {\n      const previous = ctx.previous;\n      const wasConverted = previous?.is_converted === true || previous?.status === 'converted';\n      const isConverting =\n        !wasConverted && (input.is_converted === true || input.status === 'converted');\n      const verdict = previous?.conversion_approval_status;\n      if (isConverting && (verdict === 'pending' || verdict === 'rejected')) {\n        // Name the lead the way `display_title` does \u2014 see the converted-lead\n        // lock below for why an id never appears in a sentence a user reads.\n        const person = [previous?.first_name, previous?.last_name]\n          .filter((part) => typeof part === 'string' && part.trim() !== '')\n          .join(' ');\n        const company =\n          typeof previous?.company === 'string' ? previous.company.trim() : '';\n        const label = [person, company].filter(Boolean).join(' - ');\n        const state = verdict === 'rejected' ? 'was rejected' : 'is still awaiting approval';\n        throw refuse(\n          `Cannot convert ${label ? `lead ${label}` : 'this lead'}: its conversion ${state}. Conversion opens once an approver signs it off \u2014 the Conversion Approval field on the lead shows where it stands.`,\n          'RECORD_LOCKED',\n          409,\n        );\n      }\n    }\n\n    // Converted-lead lock \u2014 USER edits only (`ctx.user?.id` is this repo's\n    // system-write signal, cf. opportunity/quote/account hooks): a blanket\n    // throw also rejected system writes (seed-ownership claims, flow\n    // backfills). Narrative notes and framework-managed columns stay editable;\n    // identity and conversion fields stay locked.\n    //\n    // This is the ONLY converted-lead guard \u2014 there is deliberately no second,\n    // friendlier script validation over the same four identity fields, because\n    // this throw always won the race and a second layer could only drift. The\n    // message below therefore has to carry the whole story, hence the\n    // attempted-field list.\n    if (event === 'beforeUpdate' && ctx.user?.id) {\n      const previous = ctx.previous;\n      const wasConverted = previous?.is_converted === true || previous?.status === 'converted';\n      if (wasConverted) {\n        const ALLOWED = new Set([\n          'description', 'notes',\n          // Framework-managed / system columns (cf. opportunity.hook.ts).\n          'id', 'owner_id', 'created_at', 'updated_at',\n          'created_by', 'updated_by', 'space_id', 'organization_id', 'org_id', 'version',\n        ]);\n        const violating = Object.keys(input).filter(\n          (k) => !ALLOWED.has(k) && input[k] !== previous?.[k],\n        );\n        if (violating.length > 0) {\n          // Every lookup on `crm_lead` a referential clear can attack.\n          const REFERENCE_FIELDS = new Set([\n            'converted_account', 'converted_contact', 'converted_opportunity',\n            'duplicate_of_lead', 'duplicate_of_contact',\n          ]);\n          // \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500 the reference-cleanup yield \u2500\u2500\n          // #720. The engine implements `deleteBehavior: 'set_null'` by UPDATING\n          // the row that HOLDS the lookup, so deleting the account / contact /\n          // opportunity a converted lead points at (or the lead / contact it was\n          // flagged as a duplicate of) arrives here as an ordinary user\n          // `beforeUpdate` \u2014 and this lock refused it, which made a converted\n          // lead able to keep all three of its conversion products undeletable\n          // forever (a GDPR erasure that cannot be carried out).\n          //\n          // Measured on 17.1.0 \u2014 the version this repo pinned AT THE TIME of\n          // the measurement, not the current pin (the cascade shape below has\n          // NOT been re-measured on any later pin \u2014 not 17.3.0, #1676, not\n          // 17.4.0, PR #1814, and not 17.5.0) \u2014 with a probe hook at priority 199 immediately\n          // ahead of each guard, not assumed.\n          // The engine builds its cleanup write on the CALLER's own context\n          // plus two engine keys, so on the path a REST `DELETE` takes, the\n          // cascade and a user's hand-clear of the same lookup are identical\n          // everywhere a guard can look: payload\n          // `{ id, <link>: null, updated_at, updated_by }`, `ctx.user` the\n          // CALLER, `ctx.session` the caller's own `{ userId, isSystem }`.\n          // (Both `updated_by` and the identity drop out together when the\n          // DELETE itself carried no `userId` \u2014 a rig artefact, not this app's\n          // path.) So the WRITE SHAPE is not a discriminator, and the yield\n          // below is not one either: it lets ANY caller clear a declared link\n          // on a settled record. That is the trade #720 accepted, not a side\n          // effect of it.\n          //\n          // \u26A0\uFE0F A marker DOES reach a hook \u2014 and is deliberately not read. An\n          // earlier version of this note concluded \"no marker reaches a hook,\n          // and the WRITE SHAPE is the only evidence there is\"; it reasoned\n          // only about `ctx.session`, whose allow-list really does omit\n          // `__`-prefixed operation-private keys, and missed the other route\n          // into the context. `ObjectQL.cascadeDeleteRelations` builds\n          // `{ ...context, __referentialFieldClear: true }`, readable at\n          // `ctx.api.executionContext.__referentialFieldClear`: measured `true`\n          // on every cascade into `crm_opportunity`, `crm_quote` and\n          // `crm_lead`, `undefined` on every hand-clear (#1165, #1412).\n          //\n          // \u26D4 The #1165 ruling (2026-08-25) reviewed that and upheld NOT\n          // reading it, on two grounds. It is an operation-private key \u2014 an\n          // undeclared dependency that can vanish in a patch release. And\n          // reachability through the SHIPPED path is unproven: a hook body runs\n          // body-only in QuickJS, where `buildSandboxApi` passes `engineCtx.api`\n          // only when that exposes `object()`, and otherwise a shim with no\n          // `executionContext` at all. Green in a kernel rig and silently false\n          // in production is the worst outcome a guard can have. The declared\n          // replacement `ctx.referentialFieldClear` is asked for upstream as\n          // objectstack-ai/objectstack#13644.\n          //\n          // \u26D4 Keep this narrow (maintainer's ruling on #720, Option A): a write\n          // yields ONLY when every one of its non-system changes is a DECLARED\n          // link going from a value to `null`. One business field alongside it,\n          // or a link repointed to a NEW value, and the refusal below still\n          // fires. The three freeze guards share this block verbatim \u2014 sharing\n          // it as an imported helper is not possible (hook bodies run body-only\n          // in the sandbox and cannot reach module scope), so\n          // `test/freeze-guard-reference-cleanup.test.ts` pins the three copies\n          // as identical text and pins both directions of the narrowness.\n          const isReferenceCleanup = violating.every(\n            (k) => REFERENCE_FIELDS.has(k) && input[k] === null && previous?.[k] != null,\n          );\n          if (isReferenceCleanup) return;\n\n          // Name the lead the way `crm_lead.display_title` does \u2014 the person\n          // and the company, joined \u2014 rather than appending the record id,\n          // which is unmatchable against every lead surface in this app (record\n          // page, list view, breadcrumb, lookup picker), all of which title a\n          // lead `Ada Lovelace - Acme`. Composed from the two stored columns\n          // because a lowered hook body cannot read the `display_title` formula.\n          const person = [previous?.first_name, previous?.last_name]\n            .filter((part) => typeof part === 'string' && part.trim() !== '')\n            .join(' ');\n          const company =\n            typeof previous?.company === 'string' ? previous.company.trim() : '';\n          const label = [person, company].filter(Boolean).join(' - ');\n\n          throw refuse(\n            `Cannot edit ${label ? `converted lead ${label}` : 'a converted lead'} (attempted: ${violating.join(', ')}). Make changes on the converted records instead.`,\n            'RECORD_LOCKED',\n            409,\n          );\n        }\n      }\n    }\n\n    if (event === 'afterUpdate') {\n      const previous = ctx.previous;\n      const becameQualified =\n        input.status === 'qualified' && previous?.status !== 'qualified';\n      if (!becameQualified) return;\n\n      const api = ctx.api as HookApi | undefined;\n      if (!api) return;\n\n      const leadId =\n        (typeof input.id === 'string' && input.id) ||\n        (typeof previous?.id === 'string' && previous.id) ||\n        undefined;\n      const ownerId =\n        (typeof input.owner_id === 'string' && input.owner_id) ||\n        (typeof previous?.owner_id === 'string' && previous.owner_id) ||\n        ctx.user?.id;\n\n      // ONE calendar, and it is UTC \u2014 the day step is taken with `setUTCDate`\n      // because the result is rendered with `toISOString()` below. `setDate`\n      // reads and writes the LOCAL calendar and preserves wall-clock time, so\n      // in a DST-observing deployment a two-day step across a spring-forward\n      // advances 47 h, not 48, and the rendered UTC day is one short. It is\n      // invisible at `TZ=UTC`, where the two calendars coincide.\n      const dueDate = new Date();\n      dueDate.setUTCDate(dueDate.getUTCDate() + 2);\n\n      // Title the task with the lead's name, not its record id. **All Tasks**\n      // is where a rep starts the day; a queue of rows reading `Follow up with\n      // qualified lead (EMtmaScoa3I-uYFG)` is a queue nobody can triage, and\n      // the key matches nothing on any lead page or in search. Both halves\n      // prefer the value THIS write is setting, since a qualifying write may be\n      // renaming the lead in the same payload.\n      //\n      // \u26A0\uFE0F The 255 cap is load-bearing, exactly as in `case.hook.ts`:\n      // `crm_task.subject` declares `maxLength: 255` and the engine enforces\n      // it, while `crm_lead.company` alone allows 255 \u2014 so an uncapped title is\n      // rejected, and the `catch` below swallows that rejection, leaving no\n      // follow-up task and no trace. Truncating the TAIL keeps the\n      // discriminating head intact.\n      const person = [\n        (typeof input.first_name === 'string' && input.first_name) || previous?.first_name,\n        (typeof input.last_name === 'string' && input.last_name) || previous?.last_name,\n      ]\n        .filter((part) => typeof part === 'string' && part.trim() !== '')\n        .join(' ');\n      const company =\n        (typeof input.company === 'string' && input.company.trim()) ||\n        (typeof previous?.company === 'string' && previous.company.trim()) ||\n        '';\n      const label = [person, company].filter(Boolean).join(' - ');\n      const titled = label\n        ? `Follow up with qualified lead: ${label}`\n        : 'Follow up with qualified lead';\n\n      try {\n        await api.object('crm_task').insert({\n          subject: titled.length > 255 ? `${titled.slice(0, 254)}\u2026` : titled,\n          status: 'not_started',\n          priority: 'high',\n          type: 'follow_up',\n          due_date: dueDate.toISOString().slice(0, 10),\n          // Unlike `lead_auto_assign` above, this is a SEPARATE insert on\n          // `ctx.api` \u2014 a new operation carrying the caller's context, so the\n          // #3004 transfer guard does apply to it. When the qualifier is the\n          // lead's own rep (`owner_id` == caller) it is not a transfer at all;\n          // a manager qualifying a rep's lead holds `allowTransfer`. Any other\n          // caller is denied and the catch below drops the task rather than\n          // landing it on the wrong desk.\n          owner_id: ownerId,\n          related_to_type: 'crm_lead',\n          related_to_lead: leadId,\n        });\n      } catch {\n        // Side-effect failure must not break the parent transaction. No\n        // `console` in the L2 hook sandbox \u2014 logging would throw its own\n        // ReferenceError and mask the real failure (cf. #471).\n      }\n    }\n  },\n};\n\n/**\n * Soft lead dedupe.\n *\n * A prospect who enquires twice must not be REJECTED \u2014 a re-captured address is\n * recorded as a fact instead of refused, so the public Web-to-Lead form never\n * answers a returning visitor with a save error.\n *\n * Four jobs, all `before`-phase so the values land in the same write:\n *\n * 1. **Normalize `email`** (trim + lowercase), exactly as `contact_integrity`\n *    does on `crm_contact`. \u26A0\uFE0F This is what makes the dedupe lookup below a\n *    plain equality match: there is no case-insensitive predicate to lean on \u2014\n *    ObjectQL's `$regex` compiles to a LIKE *substring* on SQL, which would\n *    match `a@b.com` inside `xa@b.com` \u2014 so the canonical form has to be\n *    established by the PRODUCER at write time rather than worked around by\n *    every reader. Also on update: an edit reintroducing mixed case would\n *    silently make the record invisible to every later dedupe.\n *\n * 1b. **Fold `company` into `company_normalized`** \u2014 a SEPARATE column, not an\n *    in-place rewrite, because `company` is the display value the conversion\n *    flow copies onto the account it creates. It is the lead half of the pair\n *    `crm_account.name_normalized` completes, and it exists for the same reason\n *    as the email fold: the reader (a flow template) can compare two stored\n *    columns but cannot compute either one.\n *\n * 2. **Link a repeated address to the record it repeats** \u2014 on insert only.\n *    An existing `crm_contact` wins over an open lead: the prospect who already\n *    became a contact is the further-along record, and the one the conversion\n *    flow would reuse anyway. Within a kind the OLDEST record wins, so a cluster\n *    of five re-submissions all point at the same origin instead of chaining.\n *\n * 3. **Retire the whole claim when the record it named is gone** \u2014 on update\n *    only, and the exact mirror of job 2: the hook that stamps a duplicate link\n *    is the one that takes it back down. See the note at the block itself.\n *\n * The write is `duplicate_status: 'suspected'` \u2014 a machine's guess, explicitly\n * distinguished from the `confirmed` verdict a human records when disqualifying\n * as a duplicate. The hook stands down on any record that already carries a\n * verdict, so `confirmed` can never be reverted to `suspected` by a later\n * write, and on any record that already names a survivor.\n *\n * Detection is INSERT-only by design: a later edit re-scanning would re-open a\n * question a human may have already closed, and the review queue\n * (`suspected_duplicates`) is the affordance for anything intake missed.\n *\n * \u26A0\uFE0F Priority 300 \u2014 after `lead_automation` (200), whose guest branch strips\n * client-supplied `duplicate_*` from anonymous submissions. Running earlier\n * would let a spoofed `duplicate_status` switch this hook off.\n */\nconst leadDuplicateCheckHook: Hook = {\n  name: 'lead_duplicate_check',\n  object: 'crm_lead',\n  events: ['beforeInsert', 'beforeUpdate'],\n  priority: 300,\n  description:\n    'Normalize lead email and company match key; flag a re-captured address as a suspected duplicate of the record it repeats.',\n  handler: async (ctx: HookContext) => {\n    const { event, input } = ctx;\n\n    // A duplicate cluster larger than this is pathological; every member points\n    // at the same origin either way, so the scan is bounded rather than paged.\n    const SCAN_LIMIT = 50;\n\n    /** Absent, null or whitespace \u2014 the shape `isBlank` tests in CEL. */\n    const isBlank = (value: unknown): boolean =>\n      value === undefined || value === null || (typeof value === 'string' && value.trim() === '');\n\n    // 1. Canonical email. `input.email` is absent on a partial update; leave it\n    //    alone then rather than writing an empty string over a real address.\n    if (typeof input.email === 'string') {\n      input.email = input.email.trim().toLowerCase();\n    }\n    const email = typeof input.email === 'string' ? input.email : '';\n\n    // 1b. Canonical COMPANY, into its own column (#626). Same doctrine as the\n    //     email above \u2014 the canonical form is established by the producer at\n    //     write time \u2014 but it cannot be done in place: `company` is the display\n    //     value and is copied verbatim onto the account `lead_conversion`\n    //     creates, so folding it would ship \"acme corp\" as the account name.\n    //     `crm_account.name_normalized` is the other half of the pair; the flow\n    //     compares the two columns because it can compute neither\n    //     (`resolveToken` knows only `NOW()` / `TODAY()`).\n    //\n    //     Runs before the insert-only early return below, so an edit that\n    //     rewrites `company` re-folds the key instead of leaving a stale one.\n    //     Absent key \u21D2 untouched: a partial update that never mentions\n    //     `company` must not blank the match key.\n    if ('company' in input) {\n      const rawCompany = input.company;\n      const normalizedCompany =\n        typeof rawCompany === 'string'\n          ? rawCompany.trim().toLowerCase().replace(/\\s+/g, ' ')\n          : '';\n      input.company_normalized = normalizedCompany === '' ? null : normalizedCompany;\n    }\n\n    // 1c. Retire a duplicate claim once the record it named is gone.\n    //\n    //     \u26A0\uFE0F Platform constraint. `duplicate_of_type` is a DISCRIMINATOR, and\n    //     `lead.object.ts` pairs it with the lookup it names through\n    //     `requiredWhen` \u2014 so \"the type is set\" and \"that lookup is populated\"\n    //     are ONE fact stated in two columns. Neither lookup declares a\n    //     `deleteBehavior`, so both take the spec default `set_null`, and the\n    //     engine implements `set_null` by UPDATING the row that HOLDS the\n    //     lookup. Deleting the contact (or lead) a lead was flagged against\n    //     therefore arrives here as `{ id, duplicate_of_<x>: null, \u2026 }`, nulls\n    //     one half of the pair, and the row instantly breaks its own rule \u2014 so\n    //     the whole delete rolls back with `Duplicate Of Contact is required`,\n    //     an error naming a field on an object the caller never addressed.\n    //\n    //     The blast radius is why this matters: the flag is stamped\n    //     automatically at intake on any OPEN lead that merely re-uses a\n    //     contact's email, so an ordinary duplicate makes that CONTACT\n    //     undeletable \u2014 and because `crm_contact.crm_account` is a\n    //     master-detail with `deleteBehavior: 'cascade'`, the ACCOUNT above it\n    //     too. A GDPR \"delete this person\" request with no way to carry it out.\n    //\n    //     The rule restored here is one line: **the discriminator may not\n    //     outlive the lookup it names.** When a write leaves that lookup blank,\n    //     the claim is retired WHOLE \u2014 type and status go with the link \u2014 and\n    //     the lead simply stops saying it duplicates something.\n    //\n    //     \u26A0\uFE0F This is deliberately NOT a second spelling of #720's \"is this write\n    //     the engine's reference cleanup?\" predicate in `lead_automation` above.\n    //     Re-measured on 17.1.0 with a probe hook at priority 199: the engine's\n    //     cleanup write and a user's hand-clear of the same lookup are identical\n    //     in everything this block could read \u2014 identical `input`\n    //     (`{ id, <link>: null, updated_at, updated_by }`), identical\n    //     `ctx.user`, identical `ctx.session` \u2014 because the engine builds the\n    //     cleanup on the CALLER's own context. They are not indistinguishable\n    //     outright, though: a marker is reachable at\n    //     `ctx.api.executionContext.__referentialFieldClear`, `true` on the\n    //     cascade and `undefined` on the hand-clear. The #1165 ruling of\n    //     2026-08-25 upheld NOT reading it \u2014 an operation-private key is an\n    //     undeclared dependency, and a hook body in QuickJS can be handed an\n    //     api shim with no `executionContext` at all (#1412; the declared\n    //     replacement is asked for as objectstack-ai/objectstack#13644).\n    //     None of which changes this block, and that is the point: asking \"is\n    //     the pair still whole?\" needs no provenance at all, and answers both\n    //     callers the same correct way \u2014 a lead whose link you removed no\n    //     longer duplicates anything, however the removal was spelled.\n    //\n    //     It does NOT loosen the pairing, which is the thing to check when\n    //     reading this: a write that STATES a type without naming a record is\n    //     still refused by `requiredWhen`, on insert and on update. That is what\n    //     the `restated` guard below protects \u2014 a payload carrying its own\n    //     non-blank `duplicate_of_type` is an author's claim, so it is left for\n    //     the rule to judge instead of being quietly deleted.\n    //\n    //     \u26A0\uFE0F Priority 300 is load-bearing here, not just for job 2:\n    //     `lead_automation` (200) must see the CALLER's payload before these two\n    //     nulls are added to it. Its reference-cleanup yield passes a write only\n    //     when every non-system change is a declared LOOKUP going value\u2192null,\n    //     and `duplicate_of_type` / `duplicate_status` are neither \u2014 so at a\n    //     lower priority this block would make the converted-lead lock refuse\n    //     the very cleanup that yield exists to allow.\n    // D3 stand-down on the predicate path \u2014 the `email` / `company_normalized`\n    // normalisation above reads only the payload, so it is batch-scoped by\n    // construction and keeps running. This block is not: see `forecast.hook.ts`.\n    if (event === 'beforeUpdate' && ctx.dispatch?.mode !== 'per-row') {\n      const previous = ctx.previous;\n      const LINK_OF_TYPE: Record<string, string> = {\n        crm_lead: 'duplicate_of_lead',\n        crm_contact: 'duplicate_of_contact',\n      };\n      const restated = 'duplicate_of_type' in input && !isBlank(input.duplicate_of_type);\n      const declared = previous?.duplicate_of_type;\n      const link = typeof declared === 'string' ? LINK_OF_TYPE[declared] : undefined;\n      if (!restated && link && link in input && isBlank(input[link])) {\n        // Two outcomes, and which applies turns on ONE question: did a human\n        // ever look at these two records and agree? `duplicate_status` already\n        // records exactly that, so the question is answered from the record's\n        // own vocabulary rather than from a second rule restated here.\n        //\n        //   `confirmed` \u2014 a person compared the two records and said yes. The\n        //     record it named is gone, but the VERDICT is about what the\n        //     reviewer found, not about the pointer. So the claim is\n        //     TOMBSTONED: the discriminator moves to `erased` and the status\n        //     stands, and the lead goes on saying \"confirmed duplicate of a\n        //     record that has since been erased\".\n        //\n        //   anything else \u2014 the machine's `suspected` guess, or no opinion at\n        //     all. Retired WHOLE; there is no human verdict to preserve.\n        //\n        // \u26A0\uFE0F `'erased'` is spelled INLINE on purpose. L2 hook bodies run\n        // body-only in the QuickJS sandbox, so `DUPLICATE_OF_TYPE_ERASED` from\n        // `_picklists.ts` would resolve at authoring time and arrive as\n        // `undefined`. The canonical constant is the one in `_picklists.ts`;\n        // `test/lead-duplicate-management.test.ts` pins this literal to it and\n        // pins this block as its only writer, so the two cannot drift.\n        //\n        // The verdict is read from `previous`, and the write must be SILENT\n        // about it \u2014 `'duplicate_status' in input` disqualifies the tombstone.\n        // That keeps the tombstone on the erasure path and off every other one:\n        // the engine's `set_null` cleanup never mentions the status, while a\n        // caller that DOES mention it is managing the claim by hand, and a\n        // hand-blanked pointer is not an erasure. It also means no payload can\n        // manufacture a tombstone by supplying its own `confirmed`.\n        if (!('duplicate_status' in input) && previous?.duplicate_status === 'confirmed') {\n          input.duplicate_of_type = 'erased';\n          // `duplicate_status` deliberately UNTOUCHED \u2014 it stays `confirmed`,\n          // which is what keeps the surviving state readable as a verdict.\n        } else {\n          input.duplicate_of_type = null;\n          // `duplicate_status` goes with it. Its readers in this app are the\n          // `suspected_duplicates` review queue (`src/sales/views/lead.view.ts`),\n          // whose whole workflow is \"open the two records and compare them\";\n          // the `duplicate_disqualification_requires_survivor` validation,\n          // which demands a NAMED survivor; the duplicate form block; and this\n          // hook's own insert-time stand-down, which reads the payload and\n          // never the stored row. With no link left, none of them can act on\n          // `suspected`, and leaving it would park a permanently unworkable row\n          // in that queue. The verdict is not lost: `duplicate_status` declares\n          // `trackHistory: true`, so who decided what, and when, stays on the\n          // record's field history.\n          input.duplicate_status = null;\n        }\n      }\n    }\n\n    if (event !== 'beforeInsert' || !email) return;\n\n    // 2. Never overwrite an opinion the record already carries. The\n    //    `duplicate_status` half is the load-bearing one: it is what keeps a\n    //    human's `confirmed` verdict safe from any later automatic write.\n    if (!isBlank(input.duplicate_status) || !isBlank(input.duplicate_of_type)) return;\n\n    const api = ctx.api as HookApi | undefined;\n    if (!api) return;\n\n    /** Oldest row wins; an undated row only wins if nothing dated is present. */\n    const original = (rows: Array<Record<string, unknown>>): string | undefined => {\n      let best: string | undefined;\n      let bestKey = Infinity;\n      for (const row of rows) {\n        const id = typeof row.id === 'string' ? row.id : '';\n        if (!id) continue;\n        const raw = row.created_at;\n        const parsed =\n          typeof raw === 'string' || typeof raw === 'number' || raw instanceof Date\n            ? new Date(raw as string).getTime()\n            : Number.NaN;\n        const key = Number.isFinite(parsed) ? parsed : Infinity;\n        if (best === undefined || key < bestKey) {\n          best = id;\n          bestKey = key;\n        }\n      }\n      return best;\n    };\n\n    // Best-effort ENHANCEMENT, never a gate on the write \u2014 identical to\n    // `lead_auto_assign` above. An anonymous Web-to-Lead submission runs under\n    // the `guest_portal` grant, which is INSERT-only on `crm_lead` and denies\n    // reads outright; letting that denial propagate would reject the very\n    // submission this feature exists to accept. A guest's duplicate therefore\n    // lands unflagged rather than not landing at all.\n    try {\n      const contacts = await api.object('crm_contact').find({\n        where: { email },\n        fields: ['id', 'created_at'],\n        top: SCAN_LIMIT,\n      });\n      const contactId = original(contacts ?? []);\n      if (contactId) {\n        input.duplicate_of_type = 'crm_contact';\n        input.duplicate_of_contact = contactId;\n        input.duplicate_status = 'suspected';\n        return;\n      }\n\n      // Open leads only. A predecessor that already converted is represented by\n      // the contact it created, which the branch above matches on the same\n      // address \u2014 pointing at the locked lead instead would name a record\n      // nobody can work.\n      const leads = await api.object('crm_lead').find({\n        where: { email, is_converted: false },\n        fields: ['id', 'created_at'],\n        top: SCAN_LIMIT,\n      });\n      const leadId = original(leads ?? []);\n      if (leadId) {\n        input.duplicate_of_type = 'crm_lead';\n        input.duplicate_of_lead = leadId;\n        input.duplicate_status = 'suspected';\n      }\n    } catch {\n      // Swallow: see above. (No `console` in the L2 hook sandbox.)\n    }\n  },\n};\n\nexport default [leadAutoAssignHook, leadHook, leadDuplicateCheckHook];\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/sales/objects/lead.campaign-metrics.hook.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/sales/objects\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/sales/objects/lead.campaign-metrics.hook.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport type { Hook, HookContext } from '@objectstack/spec/data';\nimport type { HookApi } from './_hook-api';\n\n/**\n * Campaign metric refresh, triggered by a LEAD conversion.\n *\n * Attached to `crm_lead`, which the sales package owns, so it lives here\n * beside that object rather than with the campaign metadata it maintains\n * (plan item 6: a hook sits beside its object, which is what enforces R4).\n * Its three siblings: `campaign_validation` and `campaign_metrics_refresh` on\n * `crm_campaign` in `src/marketing/objects/campaign.hook.ts`, and\n * `campaign_attribution_refresh` on `crm_opportunity` next door in\n * `opportunity.campaign-metrics.hook.ts`.\n *\n * \u26A0\uFE0F WHY THE RECOMPUTE IS WRITTEN OUT FOUR TIMES.\n *\n * L2 hook bodies are lowered to metadata and evaluated BODY-ONLY in the QuickJS\n * sandbox: a handler cannot reach module scope at runtime, so a shared\n * `refreshCampaignMetrics()` import would be a free identifier \u2014 the CLI build\n * silently declines to lower the handler, keeps it in a bundled runtime file,\n * and the hook stops being deployable as pure metadata (the build says so in\n * one line nobody reads). `test/action-sandbox.test.ts` is what catches it.\n *\n * So the arithmetic is inlined per handler. The duplication is NOT trusted:\n * `test/campaign-member-lifecycle.test.ts` lowers all four bodies and asserts\n * the recompute block is character-identical across them, so a fix landing on\n * one copy and skipping three fails a test instead of shipping four definitions\n * of `num_sent`. Splitting the four across three files by owning object changed\n * none of that \u2014 the suite reads them by hook name, not by file.\n */\n\n/**\n * Promote the member rows of a converting lead, then recompute.\n *\n * This hook is `converted`'s ONLY writer, and without it that status option\n * would be exactly the kind of inert vocabulary #597 removed the tracker states\n * for \u2014 a value the picklist offers, the ROI surfaces segment by, and nothing\n * produces. Conversion is the one campaign outcome the app can observe by\n * itself: `crm_lead.is_converted` flips (the `lead_conversion` flow, or the\n * convert action), and every campaign that lead was enrolled in has just\n * recorded a conversion.\n *\n * Only members still `sent` or `responded` are promoted. An `unsubscribed`\n * member is NOT: that person asked to be left alone, and overwriting their\n * opt-out state with a marketing outcome is precisely the kind of quiet rewrite\n * `campaign_member_optout_sync` exists to prevent.\n *\n * `num_converted_leads` also counts `crm_lead.is_converted` across the\n * membership, so this same event is the metric's trigger \u2014 a lead can sit in\n * several campaigns and every one of them is refreshed.\n *\n * `runAs: 'system'` (#2014, AGENTS.md rule 9). Conversions are a rep's act,\n * and a rep may edit neither campaign members nor campaigns, so the promotion\n * was refused, logged and swallowed: the lead converted and its memberships\n * stayed where they were. The promotion and the recompute are marketing's\n * record of the outcome, not the rep's write, so the hook elevates; the lead\n * write stays the caller's. Organization (rule 10): every read is keyed to the\n * triggering lead's own memberships and their campaigns, and the elevated\n * `ctx.api` keeps the trigger's tenant.\n */\nconst campaignLeadConversionRefresh: Hook = {\n  name: 'campaign_lead_conversion_refresh',\n  object: 'crm_lead',\n  events: ['afterUpdate'],\n  priority: 810,\n  async: true,\n  onError: 'log',\n  runAs: 'system',\n  description: 'Promote campaign members of a converting lead and recompute campaign metrics.',\n  handler: async (ctx: HookContext) => {\n    const api = ctx.api as HookApi | undefined;\n    if (!api) return;\n    const { input } = ctx;\n    const previous = ctx.previous;\n    if (input?.is_converted !== true) return;\n    if (previous?.is_converted === true) return;\n    const leadId =\n      (typeof input?.id === 'string' && input.id) ||\n      (typeof previous?.id === 'string' ? (previous.id as string) : '');\n    if (!leadId) return;\n    // `id` is projected because the promotion below updates each row by it:\n    // the SQL datasource returns exactly the columns a read names (#2018).\n    const memberships = await api.object('crm_campaign_member').find({\n      where: { crm_lead: leadId }, fields: ['id', 'crm_campaign', 'status'], top: 500,\n    });\n    for (const m of memberships) {\n      const memberId = typeof m.id === 'string' ? m.id : '';\n      if (!memberId) continue;\n      if (m.status !== 'sent' && m.status !== 'responded') continue;\n      await api.object('crm_campaign_member').update(\n        { id: memberId, status: 'converted' },\n        { where: { id: memberId } },\n      );\n    }\n    const campaignIds = Array.from(new Set(\n      memberships.map((m) => (typeof m.crm_campaign === 'string' ? m.crm_campaign : '')).filter(Boolean),\n    ));\n    for (const id of campaignIds) {\n      // \u2500\u2500 recompute \u2500\u2500 identical in all four refresh hooks; see the header.\n      const memberRows = await api.object('crm_campaign_member').find({\n        where: { crm_campaign: id }, fields: ['crm_lead', 'status'], top: 5000,\n      });\n      const leadIds = Array.from(new Set(\n        memberRows.map((r) => (typeof r.crm_lead === 'string' ? r.crm_lead : '')).filter(Boolean),\n      ));\n      const convertedLeads = leadIds.length > 0\n        ? await api.object('crm_lead').count({ where: { id: { $in: leadIds }, is_converted: true } })\n        : 0;\n      const numOpportunities = await api.object('crm_opportunity').count({ where: { crm_campaign: id } });\n      const numWon = await api.object('crm_opportunity').count({ where: { crm_campaign: id, stage: 'closed_won' } });\n      const wonRows = await api.object('crm_opportunity').find({\n        where: { crm_campaign: id, stage: 'closed_won' }, fields: ['amount'], top: 5000,\n      });\n      const actualRevenue = wonRows.reduce(\n        (sum, row) => sum + (typeof row.amount === 'number' ? row.amount : Number(row.amount) || 0), 0,\n      );\n      await api.object('crm_campaign').update({\n        id,\n        num_sent: memberRows.length,\n        num_responses: memberRows.filter((r) => r.status === 'responded' || r.status === 'converted').length,\n        num_leads: leadIds.length,\n        num_converted_leads: convertedLeads,\n        num_opportunities: numOpportunities,\n        num_won_opportunities: numWon,\n        actual_revenue: actualRevenue,\n      }, { where: { id } });\n      // \u2500\u2500 /recompute \u2500\u2500\n    }\n  },\n};\n\nexport default [campaignLeadConversionRefresh];\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/sales/objects/opportunity.hook.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/sales/objects\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/sales/objects/opportunity.hook.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport type { Hook, HookContext } from '@objectstack/spec/data';\nimport type { HookApi } from './_hook-api';\n\n/**\n * Opportunity lifecycle hook.\n *\n * - Re-derives `expected_revenue` from `amount * stageProbability` when either changes.\n * - Stamps `stage_entry_date` on insert and on every stage change \u2014 the stored\n *   clock behind the `days_in_stage` formula and the stagnation sweep (#489).\n * - Freezes most fields after stage is closed (won/lost) \u2014 only narrative fields\n *   editable. The freeze yields to the engine's reference cleanup, so a closed\n *   deal never makes the records it points at undeletable (#720).\n * - On `closed_won`: stamps `close_date=today`, promotes the parent account to `customer`,\n *   and asynchronously schedules an \"Activate customer\" task.\n */\n\nconst opportunityValidationHook: Hook = {\n  name: 'opportunity_lifecycle',\n  object: 'crm_opportunity',\n  events: ['beforeInsert', 'beforeUpdate'],\n  priority: 200,\n  description:\n    'Recompute expected_revenue, freeze closed opportunities except narrative fields.',\n  handler: async (ctx: HookContext) => {\n    // The refusal envelope (#1075). Mirrored from `./_refusal.ts` because a\n    // lowered body has no module scope and `extractHookBody` THROWS on an\n    // import; `test/refusal-envelope.test.ts` pins every copy against it.\n    function refuse(\n      message: string,\n      code: string,\n      status: number,\n      userMessage: string = message,\n    ): Error {\n      const err = new Error(message) as Error & {\n        code: string;\n        status: number;\n        userMessage: string;\n      };\n      err.code = code;\n      err.status = status;\n      err.userMessage = userMessage;\n      return err;\n    }\n    // NOTE: L2 hook bodies run *body-only* in a sandbox (QuickJS) \u2014 module-level\n    // constants are NOT in scope at runtime. These MUST be declared inside the\n    // handler or the body throws `ReferenceError` on every write. (See ADR on\n    // sandboxed hooks; same pattern as lead.hook.ts.)\n    const STAGE_PROBABILITY: Record<string, number> = {\n      prospecting: 10,\n      qualification: 25,\n      needs_analysis: 40,\n      proposal: 60,\n      negotiation: 80,\n      closed_won: 100,\n      closed_lost: 0,\n    };\n    const NARRATIVE_FIELDS = new Set(['description', 'next_step', 'notes']);\n    // Framework-managed columns are re-stamped by the runtime itself (ownership\n    // reassignment, audit timestamps) \u2014 including during post-seed ownership\n    // assignment introduced in ObjectStack 9.x. The \"freeze closed record\" guard\n    // must never reject these system writes, only user edits to business fields.\n    // (Declared in-handler: sandboxed bodies have no module scope.)\n    const SYSTEM_FIELDS = new Set([\n      'id', 'owner_id', 'created_at', 'updated_at',\n      'created_by', 'updated_by', 'space_id', 'organization_id', 'org_id', 'version',\n    ]);\n    // Approval verdicts must be allowed to land even if the deal closes while\n    // the request is in flight \u2014 rejecting them left the record locked with a\n    // permanently pending approval.\n    //\n    // \u26A0\uFE0F Why this exemption is still needed even though `opportunity_approval`\n    // declares `runAs: 'system'`, and why that is not a contradiction:\n    // ELEVATION IS NOT ANONYMITY (objectstack#5494). `resolveRunDataContext`\n    // returns `{ isSystem: true, actor, ...userId }` for a `runAs: 'system'`\n    // run \u2014 it carries the triggering user through rather than erasing them.\n    // So ONE approval write is seen by TWO guards keyed on DIFFERENT halves of\n    // that context, and both fire as designed:\n    //   \u2022 this freeze guard keys on `ctx.user?.id`, which is PRESENT \u21D2 the\n    //     write is judged as a user edit and would be rejected on a closed\n    //     deal \u2014 hence this allow-list.\n    //   \u2022 the engine's readonly strip keys on `isSystem`, which is TRUE \u21D2 the\n    //     strip branch (`if (!opCtx.context?.isSystem)`) is skipped, so the\n    //     stamps land even though both columns are declared `readonly: true`\n    //     (#1666).\n    // \u26D4 Neither mechanism needs changing, and neither is a substitute for the\n    // other: dropping this allow-list re-locks in-flight approvals, and the\n    // readonly declaration is what keeps a hand-edit out. Measured in\n    // `test/readonly-write-semantics.test.ts` and pinned for these two columns\n    // in `test/audit-stamp-readonly.test.ts`.\n    // `status_change_approval_status` and `requested_status` join the\n    // allow-list for the same reason and by the same mechanism: the REQ-0006\n    // gate's flow stamps its verdict and clears the request AFTER the deal has\n    // reached a closed stage, and elevation is not anonymity \u2014 the freeze\n    // guard below would judge those writes as user edits on a closed record\n    // and re-lock an in-flight approval.\n    // `qualification_approval_status` and `qualification_requested` (the\n    // REQ-0006 step-11 \u7ACB\u9879 gate) join for the same reason and by the same\n    // mechanism. Their flow stamps the verdict, and on a rejection clears the\n    // request, under the triggering user; a deal a write this hook does not\n    // judge (a system write, no user) closed while the \u7ACB\u9879 request was open\n    // would otherwise refuse that stamp and leave the approval decided but\n    // never recorded.\n    const APPROVAL_FIELDS = new Set([\n      'approval_status', 'approved_date',\n      'status_change_approval_status', 'requested_status',\n      'qualification_approval_status', 'qualification_requested',\n    ]);\n    // Stage \u2192 forecast category.\n    const STAGE_FORECAST: Record<string, string> = {\n      prospecting: 'pipeline',\n      qualification: 'pipeline',\n      needs_analysis: 'best_case',\n      proposal: 'commit',\n      negotiation: 'commit',\n      closed_won: 'closed',\n      closed_lost: 'omitted',\n    };\n\n    const { event, input } = ctx;\n    const previous = ctx.previous;\n\n    // \u2500\u2500\u2500 \u7ACB\u9879 (qualification) gate (REQ-0006 step 11) \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n    //\n    // \u300C\u65B0\u589E\u5546\u673A\u53EF\u8DDF\u8FDB\uFF0C\u7ACB\u9879\u901A\u8FC7\u540E\u65B9\u53EF\u66F4\u65B0\u9636\u6BB5\u3001\u6295\u6807\u3001\u8D62\u4E22\u5355\u64CD\u4F5C\u3002\u300D Until \u7ACB\u9879 is\n    // approved, two acts are refused and every other edit stays open:\n    //   \u2022 any change of `stage` \u2014 \u66F4\u65B0\u9636\u6BB5, which includes a direct close\n    //     (\u8D62\u4E22\u5355);\n    //   \u2022 a NEW `requested_status` \u2014 the won/lost request (\u8D62\u4E22\u5355) the step-14\n    //     gate opens. So with both gates armed \u7ACB\u9879 comes FIRST: an unqualified\n    //     deal cannot even ask for a status change.\n    // `will_bid` (\u662F\u5426\u6295\u6807) is deliberately NOT held (#2004, ruled): step 8 has\n    // the rep fill it as INPUT to \u7ACB\u9879, for the approver to read, so holding it\n    // until approval would have the approver decide without it. Step 11's \u6295\u6807\n    // is the act of bidding, which HotCRM does not model.\n    // Built on the step-14 gate below and deliberately the same in every\n    // load-bearing term:\n    //   \u2022 a TRANSITION GATE, not an invariant (AGENTS.md metadata semantics\n    //     rule 7) \u2014 inert unless the install arms it, since\n    //     `qualification_approval_status` ships `not_required`;\n    //   \u2022 the verdict is read INPUT-FIRST, so a write that carries the\n    //     approved verdict is judged as approved. This gate's own flow writes\n    //     only the verdict (and on a rejection the request), so it never needs\n    //     that; it keeps the sibling's reading, and a hand-supplied verdict is\n    //     stripped before this hook runs (see the field);\n    //   \u2022 `rejected` refuses as `pending` does \u2014 an approver's \"no\" is not a\n    //     release; the way on is a new request;\n    //   \u2022 USER writes only (`ctx.user?.id`), the boundary both other guards in\n    //     this hook draw;\n    //   \u2022 RECORD_LOCKED / 409 (`REFUSAL_CODES.locked`).\n    // It sits ABOVE the step-14 block so an unqualified deal's direct close\n    // names the gate that comes first.\n    //\n    // \u26A0\uFE0F BOUNDARY, recorded rather than hidden: `beforeInsert` is not judged.\n    // Creating a deal is \u65B0\u589E\u5546\u673A, which step 11 leaves open (step 8 has the rep\n    // fill \u662F\u5426\u6295\u6807 on the new-deal form) \u2014 the line the step-14 gate draws too.\n    if (event === 'beforeUpdate' && previous && ctx.user?.id) {\n      const qualification = (input.qualification_approval_status ?? previous.qualification_approval_status) as string | undefined;\n      if (qualification === 'pending' || qualification === 'rejected') {\n        const held: string[] = [];\n        if (typeof input.stage === 'string' && input.stage !== previous.stage) held.push('Stage');\n        if (typeof input.requested_status === 'string' && input.requested_status !== '' && input.requested_status !== previous.requested_status) {\n          held.push('Requested Status');\n        }\n        if (held.length > 0) {\n          throw refuse(\n            `This deal needs qualification approval first: tick Request Qualification Approval. ${held.join(' and ')} can change once it is approved.`,\n            'RECORD_LOCKED',\n            409,\n          );\n        }\n      }\n    }\n\n    // \u2500\u2500\u2500 Status-change gate (REQ-0006 steps 13-14) \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n    //\n    // A TRANSITION GATE, not an invariant (AGENTS.md metadata semantics rule\n    // 7): it refuses the next move, and every deal already sitting in a closed\n    // stage keeps it. Inert unless the install arms the gate \u2014 shipped,\n    // `status_change_approval_status` defaults to `not_required` and this\n    // condition is false for every record that has ever existed, which is what\n    // keeps REQ-0006 acceptance 3's \"bit-for-bit what it is today\" true.\n    //\n    // \u26A0\uFE0F The gate value is read INPUT-FIRST, and that is load-bearing. The\n    // approving flow writes `stage` and `status_change_approval_status:\n    // 'approved'` in ONE payload; reading `previous` first would see `pending`\n    // and refuse the flow's own write. `runAs: 'system'` does not help \u2014\n    // elevation is not anonymity, so `ctx.user?.id` is present in that run\n    // exactly as the APPROVAL_FIELDS note above records.\n    //\n    // \u26A0\uFE0F `rejected` refuses too, exactly as `lead_automation` refuses a\n    // conversion in both `pending` and `rejected`. An approver's \"no\" is not a\n    // release: if only `pending` refused, a single rejection would disarm the\n    // gate on that deal for good, and the rep could then close it directly with\n    // no approval at all. From `rejected` the way forward is a NEW request \u2014 the\n    // flow's start condition re-opens on it \u2014 never a direct stage write.\n    //\n    // RECORD_LOCKED / 409 (`REFUSAL_CODES.locked`): while the gate holds, the\n    // deal's own state freezes `stage` against a move into a closed stage \u2014 the\n    // same class the lead sibling answers with.\n    if (event === 'beforeUpdate' && previous && ctx.user?.id) {\n      const gate = (input.status_change_approval_status ?? previous.status_change_approval_status) as string | undefined;\n      const next = input.stage as string | undefined;\n      const closing = (next === 'closed_won' || next === 'closed_lost') && next !== previous.stage;\n      if (closing && (gate === 'pending' || gate === 'rejected')) {\n        throw refuse(\n          'This deal\\'s status change needs approval: set Requested Status (and the win/loss reason) instead. The stage takes effect when the request is approved.',\n          'RECORD_LOCKED',\n          409,\n        );\n      }\n    }\n\n    // Freeze closed opportunities \u2014 but guard ONLY genuine USER edits. A write\n    // with no authenticated user (`ctx.user?.id` absent) is a system / seed /\n    // backfill write and must pass: the seed's `close_date: daysAgo(15)`\n    // re-evaluates to a new date on every reboot, so a re-seed legitimately\n    // changes close_date on already-closed opps. Guarding those threw 23\n    // boot-time BodyRunner errors AND blocked the seed from correcting\n    // closed-won `probability` to 100 (#459). `ctx.user?.id` is this repo's\n    // system-write signal (cf. case/lead/quote hooks) and matches the\n    // SYSTEM_FIELDS intent above (\"only user edits to business fields\").\n    // Still runs before the derived-field recompute below so a genuine user\n    // edit is judged on the caller's own fields, not injected ones.\n    if (event === 'beforeUpdate' && previous && ctx.user?.id) {\n      const prevStage = previous.stage as string | undefined;\n      const isClosed = prevStage === 'closed_won' || prevStage === 'closed_lost';\n      if (isClosed) {\n        const violating = Object.keys(input).filter(\n          (k) => !NARRATIVE_FIELDS.has(k) && !SYSTEM_FIELDS.has(k) && !APPROVAL_FIELDS.has(k) && input[k] !== previous[k],\n        );\n        if (violating.length > 0) {\n          // Every lookup on `crm_opportunity` a referential clear can attack.\n          const REFERENCE_FIELDS = new Set(['crm_account', 'primary_contact', 'crm_campaign']);\n          // \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500 the reference-cleanup yield \u2500\u2500\n          // #720. The engine implements `deleteBehavior: 'set_null'` by UPDATING\n          // the row that HOLDS the lookup, so deleting a contact or a campaign a\n          // CLOSED opportunity references arrives here as an ordinary user\n          // `beforeUpdate` \u2014 and this freeze refused it, which made the frozen\n          // opportunity able to keep a person undeletable forever (and, through\n          // the master-detail cascade, that person's account too \u2014 a GDPR\n          // erasure that cannot be carried out).\n          //\n          // Measured on 17.1.0 \u2014 the version this repo pinned AT THE TIME of\n          // the measurement, not the current pin (the cascade shape below has\n          // NOT been re-measured on any later pin \u2014 not 17.3.0, #1676, not\n          // 17.4.0, PR #1814, and not 17.5.0) \u2014 with a probe hook at priority 199 immediately\n          // ahead of each guard, not assumed.\n          // The engine builds its cleanup write on the CALLER's own context\n          // plus two engine keys, so on the path a REST `DELETE` takes, the\n          // cascade and a user's hand-clear of the same lookup are identical\n          // everywhere a guard can look: payload\n          // `{ id, <link>: null, updated_at, updated_by }`, `ctx.user` the\n          // CALLER, `ctx.session` the caller's own `{ userId, isSystem }`.\n          // (Both `updated_by` and the identity drop out together when the\n          // DELETE itself carried no `userId` \u2014 a rig artefact, not this app's\n          // path.) So the WRITE SHAPE is not a discriminator, and the yield\n          // below is not one either: it lets ANY caller clear a declared link\n          // on a settled record. That is the trade #720 accepted, not a side\n          // effect of it.\n          //\n          // \u26A0\uFE0F A marker DOES reach a hook \u2014 and is deliberately not read. An\n          // earlier version of this note concluded \"no marker reaches a hook,\n          // and the WRITE SHAPE is the only evidence there is\"; it reasoned\n          // only about `ctx.session`, whose allow-list really does omit\n          // `__`-prefixed operation-private keys, and missed the other route\n          // into the context. `ObjectQL.cascadeDeleteRelations` builds\n          // `{ ...context, __referentialFieldClear: true }`, readable at\n          // `ctx.api.executionContext.__referentialFieldClear`: measured `true`\n          // on every cascade into `crm_opportunity`, `crm_quote` and\n          // `crm_lead`, `undefined` on every hand-clear (#1165, #1412).\n          //\n          // \u26D4 The #1165 ruling (2026-08-25) reviewed that and upheld NOT\n          // reading it, on two grounds. It is an operation-private key \u2014 an\n          // undeclared dependency that can vanish in a patch release. And\n          // reachability through the SHIPPED path is unproven: a hook body runs\n          // body-only in QuickJS, where `buildSandboxApi` passes `engineCtx.api`\n          // only when that exposes `object()`, and otherwise a shim with no\n          // `executionContext` at all. Green in a kernel rig and silently false\n          // in production is the worst outcome a guard can have. The declared\n          // replacement `ctx.referentialFieldClear` is asked for upstream as\n          // objectstack-ai/objectstack#13644.\n          //\n          // \u26D4 Keep this narrow (maintainer's ruling on #720, Option A): a write\n          // yields ONLY when every one of its non-system changes is a DECLARED\n          // link going from a value to `null`. One business field alongside it,\n          // or a link repointed to a NEW value, and the refusal below still\n          // fires. The three freeze guards share this block verbatim \u2014 sharing\n          // it as an imported helper is not possible (hook bodies run body-only\n          // in the sandbox and cannot reach module scope), so\n          // `test/freeze-guard-reference-cleanup.test.ts` pins the three copies\n          // as identical text and pins both directions of the narrowness.\n          const isReferenceCleanup = violating.every(\n            (k) => REFERENCE_FIELDS.has(k) && input[k] === null && previous?.[k] != null,\n          );\n          if (isReferenceCleanup) return;\n\n          // `crm_opportunity.nameField` IS `name`, so the name on its own is\n          // exactly how every other surface titles this record. \u26D4 Never append\n          // the record id \u2014 it matches none of them.\n          const name = typeof previous.name === 'string' ? previous.name.trim() : '';\n          const subject = name ? `Opportunity ${name}` : 'Opportunity';\n          throw refuse(\n            `${subject} is closed (${prevStage}); only ${[...NARRATIVE_FIELDS].join(', ')} may be edited. Attempted: ${violating.join(', ')}.`,\n            'RECORD_LOCKED',\n            409,\n          );\n        }\n      }\n    }\n\n    // D3 stand-down: a predicate update has ONE payload for every matched row,\n    // so the `ctx.previous`-conditioned recomputes below would land on rows that\n    // did not earn them \u2014 refused as a diverging key set, or stored silently\n    // from the last row. Full account and the measurement: `forecast.hook.ts`.\n    // The closed-record REFUSAL above deliberately sits before this line:\n    // reading `previous` to throw is what D3 supplies it for, and a batch that\n    // touches a closed deal must still be refused.\n    if (ctx.event === 'beforeUpdate' && ctx.dispatch?.mode === 'per-row') return;\n\n    // Recompute expected_revenue\n    const amount =\n      typeof input.amount === 'number'\n        ? input.amount\n        : typeof previous?.amount === 'number'\n          ? (previous.amount as number)\n          : undefined;\n    const stage =\n      typeof input.stage === 'string'\n        ? input.stage\n        : typeof previous?.stage === 'string'\n          ? (previous.stage as string)\n          : undefined;\n    if (typeof amount === 'number' && stage && STAGE_PROBABILITY[stage] !== undefined) {\n      input.expected_revenue = Math.round(amount * STAGE_PROBABILITY[stage]) / 100;\n    }\n    if (stage && STAGE_PROBABILITY[stage] !== undefined) {\n      // Always sync probability with stage (single source of truth = stage).\n      input.probability = STAGE_PROBABILITY[stage];\n    }\n    // Sync forecast_category with stage on insert and whenever stage changes.\n    if (stage && STAGE_FORECAST[stage] !== undefined) {\n      const stageChanged = event === 'beforeInsert' || (typeof input.stage === 'string' && input.stage !== previous?.stage);\n      if (stageChanged) input.forecast_category = STAGE_FORECAST[stage];\n    }\n\n    // Start the stage-age clock at creation. Without this the row lands with a\n    // null `stage_entry_date`, `days_in_stage` reads null instead of 0, and the\n    // deal is invisible to the stagnation sweep until its first stage change \u2014\n    // exactly backwards, since a deal that never moves is the stalled one.\n    if (event === 'beforeInsert' && !input.stage_entry_date) {\n      input.stage_entry_date = new Date().toISOString().slice(0, 10);\n    }\n\n    if (event === 'beforeUpdate' && previous) {\n      // Stamp close_date when transitioning into closed_won\n      if (input.stage === 'closed_won' && previous.stage !== 'closed_won' && !input.close_date) {\n        input.close_date = new Date().toISOString().slice(0, 10);\n      }\n      // Restart the stage-age clock on any stage change so a deal that\n      // advances stops matching the stagnation sweep. `days_in_stage` is a\n      // formula over this column, so this one write IS the reset \u2014 it used to\n      // set `days_in_stage = 0` against a counter nothing ever incremented.\n      // (Readonly fields are writable from before-hooks via input mutation:\n      // readonly stripping only drops keys the CALLER supplied.)\n      if (typeof input.stage === 'string' && input.stage !== previous.stage) {\n        input.stage_entry_date = new Date().toISOString().slice(0, 10);\n      }\n    }\n  },\n};\n\n/**\n * On close-won: promote the account to `customer` and schedule the activation\n * task for the deal's owner.\n *\n * `runAs: 'system'` (#2014, AGENTS.md rule 9). The trigger is a rep winning\n * their own deal, and the account need not be theirs: as the caller, a read of\n * an account the rep cannot see came back empty and the promotion was skipped\n * without a word (measured: a rep's win on an account another user owns left\n * it a `prospect`). That an account has a won deal is the account's fact, not\n * the rep's edit, so the hook elevates; the deal write stays the caller's.\n * Elevation is not anonymity: `ctx.user` and the audit stamps still name the\n * rep. Organization (rule 10): it reads and writes only the account the\n * triggering deal names, and the elevated `ctx.api` keeps the trigger's tenant.\n */\nconst opportunityWonHook: Hook = {\n  name: 'opportunity_promote_account',\n  object: 'crm_opportunity',\n  events: ['afterUpdate'],\n  priority: 800,\n  async: true,\n  onError: 'log',\n  runAs: 'system',\n  description:\n    'On closed_won: promote linked account to customer and create activation task.',\n  handler: async (ctx: HookContext) => {\n    const { input } = ctx;\n    const previous = ctx.previous;\n    const becameWon = input.stage === 'closed_won' && previous?.stage !== 'closed_won';\n    if (!becameWon) return;\n    const api = ctx.api as HookApi | undefined;\n    if (!api) return;\n\n    const accountId =\n      (typeof input.crm_account === 'string' && input.crm_account) ||\n      (typeof previous?.crm_account === 'string' && previous.crm_account) ||\n      undefined;\n    if (!accountId) return;\n\n    const account = await api.object('crm_account').findOne({ where: { id: accountId } });\n    if (account && account.type !== 'customer') {\n      await api.object('crm_account').update(\n        { id: accountId, type: 'customer' },\n        { where: { id: accountId } },\n      );\n    }\n\n    const oppId = (typeof input.id === 'string' && input.id) || previous?.id;\n    const ownerId =\n      (typeof input.owner_id === 'string' && input.owner_id) ||\n      (typeof previous?.owner_id === 'string' && previous.owner_id) ||\n      ctx.user?.id;\n    // UTC calendar for the step, matching the `toISOString()` render below \u2014\n    // see the note on the same shape in `lead.hook.ts`. A local `setDate` step\n    // preserves wall-clock time, so across a spring-forward the activation task\n    // is filed a day early in every non-UTC deployment.\n    const due = new Date();\n    due.setUTCDate(due.getUTCDate() + 3);\n\n    // Title the task with the opportunity's NAME (#1243). This is one of the\n    // two rows a walkthrough of current main still writes with a raw key in it,\n    // and it lands in **All Tasks** next to the escalation rows #1208 already\n    // fixed. `crm_opportunity.name` is required + notNull, so the bare fallback\n    // is a shape the schema does not permit rather than an expected case \u2014 it\n    // exists so a pre-image that arrived without the column still produces a\n    // sentence instead of a dangling one. The 255 cap is the same one\n    // `case.hook.ts` documents: `crm_task.subject` enforces it, and this hook is\n    // `async: true` + `onError: 'log'`, so a rejected insert would surface\n    // nowhere at all.\n    const oppName =\n      (typeof input.name === 'string' && input.name.trim()) ||\n      (typeof previous?.name === 'string' && previous.name.trim()) ||\n      '';\n    const titled = oppName\n      ? `Activate new customer for opportunity ${oppName}`\n      : 'Activate new customer';\n    await api.object('crm_task').insert({\n      subject: titled.length > 255 ? `${titled.slice(0, 254)}\u2026` : titled,\n      status: 'not_started',\n      priority: 'high',\n      type: 'follow_up',\n      due_date: due.toISOString().slice(0, 10),\n      owner_id: ownerId,\n      related_to_type: 'crm_opportunity',\n      related_to_opportunity: oppId,\n      related_to_account: accountId,\n    });\n  },\n};\n\n\n/**\n * The capability gate \u2014 an account whose `commercial_capability` is\n * `settlement_only` may not have a NEW opportunity opened against it.\n *\n * REQ-0003's most valuable primitive: *some counterparties are payable but not\n * sellable* \u2014 \u300C\u62DB\u6807\u4EE3\u7406\u53CA\u5176\u4ED6\u7C7B\u5BA2\u6237\u4EC5\u53EF\u7528\u4E8E\u4ED8\u6B3E\u56DE\u6B3E\uFF0C\u65E0\u6CD5\u53D1\u8D77\u5546\u673A\u300D. The category lives on\n * `crm_account`; this is the rule that reads it, and without a reader the\n * category would be prose (REQ-0003 *Disposition & rationale*).\n *\n * ## \u26A0\uFE0F `beforeInsert` ONLY \u2014 a transition gate, not an invariant\n *\n * Maintainer ruling, 2026-09-16 (verbatim, kept untranslated):\n *\n *   \u300C\u95F8\u95E8\u8D70 `opportunity.hook.ts` \u7684 `beforeInsert`\uFF0C\u7528 hook \u7684 `ctx.api` \u8BFB\u5BA2\u6237\u7C7B\u522B\u3002\n *    REQ-0003 \u7B2C 128 \u884C\u7684 `validations[]` \u4E0E\u8BE5\u8BB0\u5F55\u81EA\u5DF1\u7684\u9A8C\u6536\u7B2C 2 \u6761\u51B2\u7A81\uFF0C\u4EE5\u9A8C\u6536\u4E3A\u51C6\u3002\u300D\n *\n * The event list IS the transition gate (AGENTS.md metadata semantics rule 7),\n * and it is the construct rather than a comment claiming the property. An\n * opportunity that already points at an account restricted later is never\n * re-evaluated: it keeps working and keeps being editable, which REQ-0003\n * acceptance 2 demands in as many words. \u26D4 Never restate this as a\n * `validations[]` script \u2014 a validation is evaluated against\n * `{...previous, ...data}` on every write, where \"already linked\" and \"linking\n * now\" are the same state, so it would refuse every later edit to every\n * historical opportunity. The whole measurement, including why a predicate\n * cannot read the account at all, is on `crm_account.commercial_capability`.\n *\n * \u26A0\uFE0F BOUNDARY, recorded rather than hidden: an UPDATE that re-points an\n * EXISTING opportunity onto a restricted account is not refused. That is the\n * ruling's construct and it is also what acceptance 2 asks for \u2014 the refusal is\n * scoped to \"linked to a NEW opportunity\". Widening to `beforeUpdate` is not a\n * free win either: the update payload would have to be judged against\n * `previous` to tell a re-point from an ordinary edit, which is the state\n * confusion this event list exists to avoid. A gate on re-pointing is a\n * separate decision, not a tidy-up.\n *\n * ## Fails OPEN, on purpose\n *\n * Only the one verdict a person wrote down refuses (AGENTS.md metadata\n * semantics rule 8). An account that predates the column, an account that\n * cannot be found, an absent `ctx.api` and an unrecognised value all let the\n * write through: the shipped default is `full`, and an account created before\n * this field existed carries nothing at all \u2014 both must open deals exactly as\n * they did before the gate existed.\n *\n * \u26A0\uFE0F A read that THROWS is not in that list and is deliberately not caught. A\n * broken read is not evidence that the account is sellable; swallowing it\n * would make the gate silently absent exactly when the platform cannot answer.\n *\n * ## `runAs: 'system'`, and a refusal that names no account (#2014)\n *\n * As the caller, the verdict was read under the caller's record access \u2014 and a\n * rep who cannot read the account is not refused that read: record-level\n * access FILTERS it, `findOne` answers `null`, the gate took that for \"cannot\n * be found\" and stood down, and the engine's reference check accepted the link\n * (measured on 17.7.0: an outsider opened a deal on a Settlement Only account\n * they cannot read). Whether an account is sellable is the account's\n * commercial fact, not a privilege of whoever names it, so the gate reads it\n * elevated (AGENTS.md rule 9 \u2014 the read is the one thing elevated; the deal\n * write stays the caller's).\n *\n * What elevation reads must not leak back through the refusal. Maintainer\n * ruling on #2014 (option B): the refusal says \"this account\" and names none \u2014\n * no number, no name, no id \u2014 and states nothing it read beyond the one fact\n * that blocks the deal, the Settlement Only verdict. It supersedes #1243's\n * \"name the account the way the UI does\" on this one path: the caller chose\n * the account on the very form the refusal answers, so the dialog stays clear\n * without echoing an account the caller may not be allowed to read. So the read\n * asks for `commercial_capability` and nothing else.\n *\n * Organization (AGENTS.md rule 10): the read is pinned to the new deal's own\n * `organization_id` when it carries one, so an elevated verdict is never read\n * from another organization's account; a deal with no organization (a\n * single-organization install) has no wall to stay inside, and is not pinned.\n * An account outside the deal's organization then reads as \"cannot be found\"\n * and the gate stands down \u2014 the same answer a person's tenant-scoped read\n * already gives.\n *\n * \u26D4 No system-write exemption, deliberately, and it is the same reading the\n * two approval flows record: a control that engages only for writers carrying a\n * session is not a control, since a `runAs: 'system'` importer would simply\n * bypass it.\n *\n * Priority 150 runs it AHEAD of `opportunity_lifecycle` (200): a refused write\n * should not first pay for the derived-field recompute.\n */\nconst opportunityAccountCapabilityHook: Hook = {\n  name: 'opportunity_account_capability',\n  object: 'crm_opportunity',\n  events: ['beforeInsert'],\n  priority: 150,\n  runAs: 'system',\n  description:\n    'Refuse a NEW opportunity linked to an account whose commercial capability is settlement only.',\n  handler: async (ctx: HookContext) => {\n    // The refusal envelope (#1075). Mirrored from `./_refusal.ts` because a\n    // lowered body has no module scope and `extractHookBody` THROWS on an\n    // import; `test/refusal-envelope.test.ts` pins every copy against it.\n    function refuse(\n      message: string,\n      code: string,\n      status: number,\n      userMessage: string = message,\n    ): Error {\n      const err = new Error(message) as Error & {\n        code: string;\n        status: number;\n        userMessage: string;\n      };\n      err.code = code;\n      err.status = status;\n      err.userMessage = userMessage;\n      return err;\n    }\n    const api = ctx.api as HookApi | undefined;\n    if (!api) return;\n    const accountId = ctx.input.crm_account;\n    if (typeof accountId !== 'string' || accountId === '') return;\n\n    const org = ctx.input.organization_id;\n    const account = await api.object('crm_account').findOne({\n      where: { id: accountId, ...(typeof org === 'string' && org ? { organization_id: org } : {}) },\n      fields: ['commercial_capability'],\n    });\n    if (!account || account.commercial_capability !== 'settlement_only') return;\n\n    // \u26D4 \"this account\", never a number, a name or an id \u2014 see the note above.\n    throw refuse(\n      'Cannot open an opportunity against this account: its Commercial Capability is Settlement Only, so it is available for billing and payment but no new business may be booked against it. Pick a different account, or have the account reclassified to Full first.',\n      'VALIDATION_FAILED',\n      400,\n    );\n  },\n};\n\nexport default [\n  opportunityAccountCapabilityHook,\n  opportunityValidationHook,\n  opportunityWonHook,\n];\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/sales/objects/opportunity.campaign-metrics.hook.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/sales/objects\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/sales/objects/opportunity.campaign-metrics.hook.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport type { Hook, HookContext } from '@objectstack/spec/data';\nimport type { HookApi } from './_hook-api';\n\n/**\n * Campaign metric refresh, triggered by an OPPORTUNITY write.\n *\n * The hook is campaign arithmetic, but it is attached to `crm_opportunity`,\n * which the sales package owns \u2014 and since the ADR-0130 layout a hook lives\n * beside the object it names (plan item 6: R4 is enforced by co-location\n * rather than by reading). Its three siblings: `campaign_validation` and\n * `campaign_metrics_refresh` on `crm_campaign` in\n * `src/marketing/objects/campaign.hook.ts`, and\n * `campaign_lead_conversion_refresh` on `crm_lead` next door in\n * `lead.campaign-metrics.hook.ts`. The membership side of the same recompute\n * is `src/marketing/objects/campaign_member.hook.ts`.\n *\n * \u26A0\uFE0F WHY THE RECOMPUTE IS WRITTEN OUT FOUR TIMES.\n *\n * L2 hook bodies are lowered to metadata and evaluated BODY-ONLY in the QuickJS\n * sandbox: a handler cannot reach module scope at runtime, so a shared\n * `refreshCampaignMetrics()` import would be a free identifier \u2014 the CLI build\n * silently declines to lower the handler, keeps it in a bundled runtime file,\n * and the hook stops being deployable as pure metadata (the build says so in\n * one line nobody reads). `test/action-sandbox.test.ts` is what catches it.\n *\n * So the arithmetic is inlined per handler. The duplication is NOT trusted:\n * `test/campaign-member-lifecycle.test.ts` lowers all four bodies and asserts\n * the recompute block is character-identical across them, so a fix landing on\n * one copy and skipping three fails a test instead of shipping four definitions\n * of `num_sent`. Splitting the four across three files by owning object changed\n * none of that \u2014 the suite reads them by hook name, not by file.\n */\n\n/**\n * Recompute when an opportunity's campaign attribution changes.\n *\n * `num_opportunities`, `num_won_opportunities` and `actual_revenue` derive from\n * opportunities, not from members \u2014 so the membership trigger alone would leave\n * exactly the three metrics `roi` is built on stale. Insert / update / delete,\n * and both sides of a re-attribution (old and new campaign), the same way the\n * line-item rollup handles re-parenting.\n *\n * Declared here rather than in `opportunity.hook.ts` on purpose: it is campaign\n * arithmetic that happens to be triggered by an opportunity write, and the\n * hooks barrel flattens each `*.hook.ts` default export regardless of which\n * object each entry names.\n *\n * `runAs: 'system'` (#2014, AGENTS.md rule 9). The trigger is a sales write \u2014\n * a rep winning their own deal, a manager winning one on a marketing-owned\n * campaign \u2014 and neither may edit the campaign, so the metric write was\n * refused, logged and swallowed: the deal was won and the campaign's revenue\n * stayed 0. The recompute is the campaign's writer, not the rep's, so the\n * hook elevates; the opportunity write stays the caller's. Organization\n * (rule 10): every read is keyed to the triggering deal's campaign (and the\n * leads its members name), and the elevated `ctx.api` keeps the trigger's\n * tenant.\n */\nconst campaignAttributionRefresh: Hook = {\n  name: 'campaign_attribution_refresh',\n  object: 'crm_opportunity',\n  events: ['afterInsert', 'afterUpdate', 'afterDelete'],\n  priority: 810,\n  async: true,\n  onError: 'log',\n  runAs: 'system',\n  description: 'Recompute campaign metrics when an opportunity\u2019s campaign attribution changes.',\n  handler: async (ctx: HookContext) => {\n    const api = ctx.api as HookApi | undefined;\n    if (!api) return;\n    const { input } = ctx;\n    const previous = ctx.previous;\n    const campaignIds = Array.from(new Set([\n      typeof input?.crm_campaign === 'string' ? input.crm_campaign : '',\n      typeof previous?.crm_campaign === 'string' ? (previous.crm_campaign as string) : '',\n    ].filter(Boolean)));\n    for (const id of campaignIds) {\n      // \u2500\u2500 recompute \u2500\u2500 identical in all four refresh hooks; see the header.\n      const memberRows = await api.object('crm_campaign_member').find({\n        where: { crm_campaign: id }, fields: ['crm_lead', 'status'], top: 5000,\n      });\n      const leadIds = Array.from(new Set(\n        memberRows.map((r) => (typeof r.crm_lead === 'string' ? r.crm_lead : '')).filter(Boolean),\n      ));\n      const convertedLeads = leadIds.length > 0\n        ? await api.object('crm_lead').count({ where: { id: { $in: leadIds }, is_converted: true } })\n        : 0;\n      const numOpportunities = await api.object('crm_opportunity').count({ where: { crm_campaign: id } });\n      const numWon = await api.object('crm_opportunity').count({ where: { crm_campaign: id, stage: 'closed_won' } });\n      const wonRows = await api.object('crm_opportunity').find({\n        where: { crm_campaign: id, stage: 'closed_won' }, fields: ['amount'], top: 5000,\n      });\n      const actualRevenue = wonRows.reduce(\n        (sum, row) => sum + (typeof row.amount === 'number' ? row.amount : Number(row.amount) || 0), 0,\n      );\n      await api.object('crm_campaign').update({\n        id,\n        num_sent: memberRows.length,\n        num_responses: memberRows.filter((r) => r.status === 'responded' || r.status === 'converted').length,\n        num_leads: leadIds.length,\n        num_converted_leads: convertedLeads,\n        num_opportunities: numOpportunities,\n        num_won_opportunities: numWon,\n        actual_revenue: actualRevenue,\n      }, { where: { id } });\n      // \u2500\u2500 /recompute \u2500\u2500\n    }\n  },\n};\n\nexport default [campaignAttributionRefresh];\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/sales/objects/task.hook.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/sales/objects\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/sales/objects/task.hook.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport type { Hook, HookContext } from '@objectstack/spec/data';\nimport type { HookApi } from './_hook-api';\n\n/**\n * Task lifecycle hook.\n *\n * - On `completed` transition, stamps `completed_date` and `progress_percent=100`.\n * - Warns when `reminder_date` is after `due_date`.\n * - Bubbles activity to the polymorphic parent (account `last_activity_date`,\n *   lead `last_contacted_date`).\n * - Refuses to SCHEDULE a phone touch against a person flagged `do_not_call`\n *   (see {@link taskDoNotCallGuard}).\n */\n\nconst taskValidation: Hook = {\n  name: 'task_completion',\n  object: 'crm_task',\n  events: ['beforeInsert', 'beforeUpdate'],\n  priority: 200,\n  description: 'Stamp completed/overdue flags + dates on completion and validate reminder timing.',\n  handler: async (ctx: HookContext) => {\n    // D3 stand-down: a predicate update has ONE payload for every matched row,\n    // so the `ctx.previous`-conditioned writes below would land on rows that\n    // did not earn them \u2014 refused as a diverging key set, or stored silently\n    // from the last row. Full account and the measurement: `forecast.hook.ts`.\n    if (ctx.event === 'beforeUpdate' && ctx.dispatch?.mode === 'per-row') return;\n\n    // The refusal envelope (#1075). Mirrored from `./_refusal.ts` because a\n    // lowered body has no module scope and `extractHookBody` THROWS on an\n    // import; `test/refusal-envelope.test.ts` pins every copy against it.\n    function refuse(\n      message: string,\n      code: string,\n      status: number,\n      userMessage: string = message,\n    ): Error {\n      const err = new Error(message) as Error & {\n        code: string;\n        status: number;\n        userMessage: string;\n      };\n      err.code = code;\n      err.status = status;\n      err.userMessage = userMessage;\n      return err;\n    }\n    const { input } = ctx;\n    const previous = ctx.previous;\n\n    // Land `reminder_sent` as a real boolean on insert, never NULL. The\n    // task_due_reminder sweep de-dups on `reminder_date` (cleared after each\n    // send), not on this flag \u2014 but keep it a real boolean so the audit trail\n    // and any future `!= true` filter behave under SQL three-valued logic.\n    if (!previous && input.reminder_sent == null) {\n      input.reminder_sent = false;\n    }\n\n    // Materialise the urgency ordinal so the to-do queue can sort by it \u2014\n    // sorting on `priority` itself compares raw strings and inverts urgency.\n    const effPriority =\n      (typeof input.priority === 'string' && input.priority) ||\n      (typeof previous?.priority === 'string' && (previous.priority as string)) ||\n      undefined;\n    //\n    // Inline and duplicated in case.hook.ts on purpose \u2014 L2 hook bodies run\n    // body-only in the QuickJS sandbox, so a shared module constant resolves at\n    // authoring time and arrives as `undefined` (see _line-item-price-fill.ts).\n    // The vocabularies differ (normal vs medium), but the UNKNOWN fallback must\n    // match crm_case: `0`, the unranked sentinel that sorts below every real\n    // rank. `test/priority-rank-parity.test.ts` pins that agreement.\n    if (effPriority) {\n      const rank: Record<string, number> = { low: 1, normal: 2, high: 3, urgent: 4 };\n      input.priority_rank = rank[effPriority] ?? 0;\n    }\n\n    if (input.status === 'completed' && previous?.status !== 'completed') {\n      // \u26A0\uFE0F `!input.completed_date` ALONE was the defect, and `|| !ctx.session?.isSystem`\n      // is the fix \u2014 \u26D4 do not tidy the second half away. `completed_date` is\n      // `readonly: true`, and since `@objectstack/objectql@17.4.0` the engine strips a\n      // static readonly field from a NON-SYSTEM caller's INSERT too, not just their\n      // UPDATE (the retired-pin note in `test/readonly-write-semantics.test.ts` carries\n      // that migration). Measured against a running server on the 17.4.0 pin: this\n      // handler still SEES the caller's value \u2014 the strip runs after `beforeInsert`\n      // returns \u2014 and the value THIS line writes survives it, because a hook-written\n      // key is not caller-supplied.\n      //\n      // So deferring to a supplied value inverted the rule below it: a caller who sent\n      // `completed_date` suppressed the only stamp there was, the engine then deleted\n      // what they sent, and `completed_date_required` rejected the one call that had\n      // actually supplied the field \u2014 while omitting it succeeded. The error named the\n      // field whose PRESENCE caused it, so an agent retried by sending it again.\n      //\n      // The `isSystem` half is not decoration: nothing strips a system write, and\n      // `src/sales/data/activity.seed.ts` back-dates completions with `daysAgo(3)` /\n      // `daysAgo(2)`. Stamping over those would replay the demo book with every\n      // completion dated today.\n      if (!input.completed_date || !ctx.session?.isSystem) {\n        input.completed_date = new Date().toISOString();\n      }\n      if (typeof input.progress_percent !== 'number') input.progress_percent = 100;\n    }\n\n    // Derived flags.\n    const effStatus =\n      (typeof input.status === 'string' && input.status) ||\n      (typeof previous?.status === 'string' && (previous.status as string)) ||\n      undefined;\n    if (typeof effStatus === 'string') input.is_completed = effStatus === 'completed';\n    const effDue =\n      (typeof input.due_date === 'string' && input.due_date) ||\n      (typeof previous?.due_date === 'string' && (previous.due_date as string)) ||\n      undefined;\n    const todayStr = new Date().toISOString().slice(0, 10);\n    input.is_overdue = !!effDue && effDue.slice(0, 10) < todayStr && input.is_completed !== true;\n\n    const reminder =\n      (typeof input.reminder_date === 'string' && input.reminder_date) ||\n      (typeof previous?.reminder_date === 'string' && (previous.reminder_date as string)) ||\n      undefined;\n    const due =\n      (typeof input.due_date === 'string' && input.due_date) ||\n      (typeof previous?.due_date === 'string' && (previous.due_date as string)) ||\n      undefined;\n    if (reminder && due && reminder.slice(0, 10) > due.slice(0, 10)) {\n      throw refuse(\n        `Reminder (${reminder}) is after the due date (${due}); reminders should fire before the deadline.`,\n        'VALIDATION_FAILED',\n        400,\n      );\n    }\n  },\n};\n\n/**\n * Recurring-task generator.\n *\n * The schema carries `is_recurring` / `recurrence_type` / `recurrence_interval`\n * / `recurrence_end_date`, but nothing ever spawned the next occurrence \u2014 so a\n * \"recurring\" task was recurring in name only. On the completing transition of a\n * recurring task, this clones it with `due_date` (and `reminder_date`) advanced\n * by `recurrence_type \u00D7 interval`, until `recurrence_end_date` is passed.\n *\n * Done in a hook (not a flow) because the next due date needs real calendar math\n * (month/year rollover); the flow runtime's `{NOW()+n}` only does day offsets and\n * has no `DATEADD`. The spawned task is `not_started`, so it never re-triggers\n * this completion hook (no recursion).\n */\nconst taskRecurrence: Hook = {\n  name: 'task_recurrence',\n  object: 'crm_task',\n  events: ['afterUpdate'],\n  priority: 700,\n  async: true,\n  onError: 'log',\n  description: 'On completion of a recurring task, spawn the next occurrence (dates advanced by recurrence_type \u00D7 interval).',\n  handler: async (ctx: HookContext) => {\n    /**\n     * Advance a date by `interval` units of the given recurrence type.\n     *\n     * Declared INSIDE the handler, matching every other hook in this directory:\n     * L2 hook bodies run body-only in the QuickJS sandbox, where module scope\n     * is not available (cf. opportunity.hook.ts / lead.hook.ts). This was the\n     * one module-level helper left in the tree.\n     *\n     * Month and year steps CLAMP to the last valid day of the target month\n     * instead of overflowing. `Date.setMonth` rolls a day that does not exist\n     * forward into the next month \u2014 Jan 31 + 1 month landed on Mar 3, so a\n     * month-end recurring task walked further into the following month on every\n     * occurrence and, for the 31st, skipped February entirely.\n     *\n     * \u26A0\uFE0F Every read and write below is on the UTC calendar, and that is the\n     * whole point of the spelling rather than a style choice. The base is the\n     * stored `due_date` \u2014 a bare `YYYY-MM-DD`, which the spec's date-only form\n     * anchors at UTC midnight \u2014 and the result is rendered with\n     * `toISOString()`. A local `getDate`/`setDate`/`setMonth` step in between\n     * reads that UTC anchor on a different calendar (west of Greenwich it is\n     * the previous evening, so `getDate()` on `2026-01-15` answers 14) and\n     * preserves wall-clock time across a DST transition, which is a 23 h or\n     * 25 h day. Both errors render as a day the series never recovers from:\n     * each occurrence is computed from the previous one.\n     *\n     * The clamp probe is built with `Date.UTC` for the same reason \u2014 a\n     * `new Date(y, m, d)` constructor reads its arguments as LOCAL fields, so\n     * it would answer the length of the wrong month at either end of the year.\n     */\n    function advanceDate(d: Date, type: string, interval: number): Date {\n      const next = new Date(d);\n      if (type === 'daily') {\n        next.setUTCDate(next.getUTCDate() + interval);\n        return next;\n      }\n      if (type === 'weekly') {\n        next.setUTCDate(next.getUTCDate() + 7 * interval);\n        return next;\n      }\n      const months = type === 'monthly' ? interval : type === 'yearly' ? 12 * interval : 0;\n      if (months === 0) return next;\n\n      const day = next.getUTCDate();\n      // Move to the 1st first so the month arithmetic can never overflow, then\n      // clamp the day to the target month's length.\n      next.setUTCDate(1);\n      next.setUTCMonth(next.getUTCMonth() + months);\n      const lastDayOfTargetMonth = new Date(Date.UTC(\n        next.getUTCFullYear(), next.getUTCMonth() + 1, 0,\n      )).getUTCDate();\n      next.setUTCDate(Math.min(day, lastDayOfTargetMonth));\n      return next;\n    }\n\n    const { input } = ctx;\n    const previous = ctx.previous;\n    const api = ctx.api as HookApi | undefined;\n    if (!api) return;\n\n    // Fire only on the transition INTO completed (not on later edits of an\n    // already-completed task).\n    const nowDone = input.status === 'completed' || input.is_completed === true;\n    const wasDone = previous?.status === 'completed' || previous?.is_completed === true;\n    if (!nowDone || wasDone) return;\n\n    const r: Record<string, any> = { ...(previous ?? {}), ...input };\n    if (r.is_recurring !== true) return;\n\n    const type = typeof r.recurrence_type === 'string' ? r.recurrence_type : undefined;\n    if (!type || !['daily', 'weekly', 'monthly', 'yearly'].includes(type)) return;\n    const interval = Number(r.recurrence_interval) > 0 ? Number(r.recurrence_interval) : 1;\n\n    const baseDue = r.due_date ? new Date(r.due_date) : new Date();\n    if (isNaN(baseDue.getTime())) return;\n    const nextDue = advanceDate(baseDue, type, interval);\n\n    // Stop the series once the next occurrence would fall past the end date.\n    if (r.recurrence_end_date) {\n      const end = new Date(r.recurrence_end_date);\n      if (!isNaN(end.getTime()) && nextDue > end) return;\n    }\n\n    const doc: Record<string, any> = {\n      subject: r.subject,\n      description: r.description ?? null,\n      priority: r.priority,\n      type: r.type ?? null,\n      owner_id: r.owner_id ?? null,\n      status: 'not_started',\n      is_completed: false,\n      reminder_sent: false,\n      due_date: nextDue.toISOString().slice(0, 10),\n      is_recurring: true,\n      recurrence_type: type,\n      recurrence_interval: interval,\n      recurrence_end_date: r.recurrence_end_date ?? null,\n      related_to_type: r.related_to_type ?? null,\n      related_to_account: r.related_to_account ?? null,\n      related_to_contact: r.related_to_contact ?? null,\n      related_to_opportunity: r.related_to_opportunity ?? null,\n      related_to_lead: r.related_to_lead ?? null,\n      related_to_case: r.related_to_case ?? null,\n    };\n    if (r.reminder_date) {\n      const baseRem = new Date(r.reminder_date);\n      if (!isNaN(baseRem.getTime())) doc.reminder_date = advanceDate(baseRem, type, interval).toISOString();\n    }\n\n    try {\n      await api.object('crm_task').insert(doc);\n    } catch {\n      // Best-effort; never break the parent write. No `console` in the L2 hook\n      // sandbox \u2014 logging here would throw its own ReferenceError (cf. #471).\n    }\n  },\n};\n\n/**\n * The activity bubble's task twin.\n *\n * `runAs: 'system'` (#2014, AGENTS.md rule 9) and the organization pin (rule\n * 10) for the reasons `event_activity_bubble` records \u2014 read that note. The\n * measurement that put this copy on the card: a service agent completing a\n * task on their own case left the case account's `last_activity_date` empty,\n * while an admin's identical completion stamped it (17.7.0); a rep's\n * completed task on their own deal reached neither the account nor the\n * contact a manager owns.\n */\nconst taskBubble: Hook = {\n  name: 'task_activity_bubble',\n  object: 'crm_task',\n  events: ['afterUpdate'],\n  priority: 800,\n  async: true,\n  onError: 'log',\n  runAs: 'system',\n  description:\n    'A completed task stamps interaction recency on the related account (walking up from contact/opportunity/case), lead and contact.',\n  handler: async (ctx: HookContext) => {\n    /*\n     * The activity bubble, second copy. `src/sales/objects/event.hook.ts` carries the\n     * canonical one and the rationale; this is a deliberate verbatim duplicate,\n     * not drift \u2014 an L2 hook body ships body-only into the QuickJS sandbox, so a\n     * shared module helper resolves at authoring time and arrives `undefined` at\n     * runtime (same constraint as `_line-item-price-fill.ts` and the\n     * `priority_rank` table above). `test/activity-recency.test.ts` runs BOTH\n     * copies through the same cases so they cannot diverge silently.\n     *\n     * \u26D4 Two properties this must keep:\n     *\n     *   1. It does NOT key off `related_to_type`. That discriminator is a\n     *      display hint a rep can leave blank, and a task with a perfectly good\n     *      `related_to_account` then bubbles to nothing at all.\n     *   2. It WALKS UP to the account. A rep completes a task on the\n     *      opportunity, not on the account row, so bubbling only to the named\n     *      record leaves `crm_account.last_activity_date` untouched through an\n     *      entire deal \u2014 and `at_risk_accounts` then lists active customers.\n     */\n    const { input } = ctx;\n    const previous = ctx.previous;\n    const api = ctx.api as HookApi | undefined;\n    if (!api) return;\n\n    // Recency means the interaction HAPPENED. An open task is a promise, not\n    // contact; only the completing transition bubbles.\n    const nowDone = input.status === 'completed' || input.is_completed === true;\n    const wasDone = previous?.status === 'completed' || previous?.is_completed === true;\n    if (!nowDone || wasDone) return;\n\n    const r: Record<string, any> = { ...(previous ?? {}), ...input };\n\n    const nowIso = new Date().toISOString();\n    // `crm_account.last_activity_date` is a DATE column; the two contact\n    // timestamps are datetimes.\n    const today = nowIso.slice(0, 10);\n\n    const idOf = (key: string): string | undefined =>\n      typeof r[key] === 'string' && r[key].length > 0 ? (r[key] as string) : undefined;\n    // The rule-10 pin \u2014 see `event_activity_bubble`'s note.\n    const org = idOf('organization_id');\n    const inOrg: Record<string, string> = org ? { organization_id: org } : {};\n\n    const accountIds = new Set<string>();\n    const contactIds = new Set<string>();\n    const leadIds = new Set<string>();\n\n    const direct = idOf('related_to_account');\n    if (direct) accountIds.add(direct);\n    const contactId = idOf('related_to_contact');\n    if (contactId) contactIds.add(contactId);\n    const leadId = idOf('related_to_lead');\n    if (leadId) leadIds.add(leadId);\n\n    const parentLookups: Array<[string, string]> = [\n      ['related_to_contact', 'crm_contact'],\n      ['related_to_opportunity', 'crm_opportunity'],\n      ['related_to_case', 'crm_case'],\n    ];\n    for (const [field, object] of parentLookups) {\n      const id = idOf(field);\n      if (!id) continue;\n      try {\n        const raw: any = await api.object(object).find({\n          where: { id, ...inOrg },\n          fields: ['crm_account'],\n          top: 1,\n        });\n        const rows = Array.isArray(raw) ? raw : (raw?.records ?? []);\n        const parent = rows.length ? rows[0].crm_account : undefined;\n        if (typeof parent === 'string' && parent.length > 0) accountIds.add(parent);\n      } catch {\n        // Best-effort: a parent that cannot be read is not bubbled through.\n        // No `console` in the L2 hook sandbox (cf. #471).\n      }\n    }\n\n    const targets: Array<[string, Set<string>, Record<string, any>]> = [\n      ['crm_account', accountIds, { last_activity_date: today }],\n      ['crm_contact', contactIds, { last_contacted_date: nowIso }],\n      ['crm_lead', leadIds, { last_contacted_date: nowIso }],\n    ];\n    for (const [object, ids, doc] of targets) {\n      let inside = [...ids];\n      if (org && inside.length > 0) {\n        try {\n          const raw: any = await api.object(object).find({ where: { id: { $in: inside }, ...inOrg }, fields: ['id'], top: inside.length });\n          inside = (Array.isArray(raw) ? raw : (raw?.records ?? [])).map((row: any) => String(row.id));\n        } catch {\n          inside = [];\n        }\n      }\n      for (const id of inside) {\n        try {\n          await api.object(object).update({ ...doc, id }, { where: { id } });\n        } catch {\n          // Best-effort activity bubble; never break the parent write.\n        }\n      }\n    }\n  },\n};\n\n/**\n * `do_not_call` \u2014 refuse to SCHEDULE a phone touch, never to record one.\n *\n * # Why this is a hook and not an action predicate\n *\n * The obvious mirror of the `email_opt_out` treatment is\n * `visible: P\\`record.do_not_call == false\\`` on a button, the way\n * `send_email` and `add_contact_to_campaign` are gated in\n * `src/sales/actions/contact.actions.ts`. That is a RENDERING hint, and it is the\n * whole of what those two do: it hides a button in the Console and leaves the\n * action reachable over REST, from an AI tool call, from a flow, and from an\n * import. For email that is only half a promise too \u2014 but the email half is\n * backed by real enforcement elsewhere (`campaign-enrollment.flow.ts` filters\n * on the flag, `campaign_member.hook.ts` writes it). `do_not_call` had no such\n * backing, so a predicate alone would have moved the field from \"declared and\n * unenforced\" to \"declared and unenforced unless you use the mouse\".\n *\n * Enforcing on the WRITE instead covers every entry point at once \u2014 the\n * `schedule_followup` screen flow, a hand-created task, an import, an AI agent\n * calling the data API \u2014 which is the same \"one writer, not one per entry\n * point\" reasoning `src/sales/actions/activity-actions.ts` gives for keeping the\n * recency bubble on `crm_event`'s hook rather than in each button's body.\n *\n * # Why `type: 'call'` and not \"any forward-looking outreach\"\n *\n * `do_not_call` is a promise about the PHONE. It is not `do_not_contact`:\n * this person may still be emailed (that is `email_opt_out`'s separate flag),\n * met, or demoed to. Refusing a `meeting` task here would silently widen a\n * declared field into a promise the app never made \u2014 the mirror image of the\n * defect this guard closes.\n *\n * # Why a completed task is allowed through\n *\n * A `completed` Call task is a RECORD of a call that already happened, not a\n * plan to place one. Refusing it would delete the evidence rather than prevent\n * the call \u2014 and would make the flag actively harmful, because the honest rep\n * who logs the call they should not have made is the one who gets blocked. The\n * same reasoning keeps the `log_call` action reachable and ungated.\n */\nconst taskDoNotCallGuard: Hook = {\n  name: 'task_do_not_call_guard',\n  object: 'crm_task',\n  events: ['beforeInsert', 'beforeUpdate'],\n  priority: 150,\n  description: 'Refuse to schedule an open Call task against a lead/contact flagged Do Not Call.',\n  handler: async (ctx: HookContext) => {\n    // The refusal envelope (#1075). Mirrored from `./_refusal.ts` because a\n    // lowered body has no module scope and `extractHookBody` THROWS on an\n    // import; `test/refusal-envelope.test.ts` pins every copy against it.\n    function refuse(\n      message: string,\n      code: string,\n      status: number,\n      userMessage: string = message,\n    ): Error {\n      const err = new Error(message) as Error & {\n        code: string;\n        status: number;\n        userMessage: string;\n      };\n      err.code = code;\n      err.status = status;\n      err.userMessage = userMessage;\n      return err;\n    }\n    const { input } = ctx;\n    const previous = ctx.previous;\n    const api = ctx.api as HookApi | undefined;\n    if (!api) return;\n\n    // The value the row will HAVE after this write, not the value the write\n    // happens to mention: flipping `type` to `call` on an existing task and\n    // re-parenting an existing Call task are both ways in, and each only\n    // supplies one of the two keys.\n    const effective = (key: string): unknown =>\n      input[key] !== undefined && input[key] !== null ? input[key] : previous?.[key];\n\n    if (effective('type') !== 'call') return;\n    if (effective('status') === 'completed') return;\n\n    const leadId = effective('related_to_lead');\n    const contactId = effective('related_to_contact');\n\n    // Both branches run rather than an if/else: `related_to_required` on the\n    // object guarantees at least one parent, and a row that somehow carries\n    // both must be checked against both people, not against whichever the\n    // author listed first.\n    const targets: Array<{ object: string; id: string; label: string }> = [];\n    if (typeof leadId === 'string' && leadId) {\n      targets.push({ object: 'crm_lead', id: leadId, label: 'lead' });\n    }\n    if (typeof contactId === 'string' && contactId) {\n      targets.push({ object: 'crm_contact', id: contactId, label: 'contact' });\n    }\n\n    for (const t of targets) {\n      // `find(... top: 1)` rather than `findOne`, matching\n      // `event_activity_bubble` in `src/sales/objects/event.hook.ts` and the shape\n      // the rest of the app's hooks read with. The result is normalised for\n      // both driver shapes (bare array / `{ records }`).\n      const raw: any = await api.object(t.object).find({\n        where: { id: t.id },\n        fields: ['id', 'do_not_call'],\n        top: 1,\n      });\n      const rows = Array.isArray(raw) ? raw : (raw?.records ?? []);\n      const person = rows[0];\n      // `=== true` on purpose: an absent key, `null`, and `false` are all \"not\n      // flagged\". A driver that stores only written columns hands back the key\n      // ABSENT (see AGENTS.md on predicate totality), and treating that as\n      // truthy would block every ordinary call task in the app.\n      if (person?.do_not_call === true) {\n        throw refuse(\n          `This ${t.label} is flagged Do Not Call, so a Call task cannot be scheduled against them. ` +\n            'Log a completed call if one already happened, choose a non-phone activity type, ' +\n            'or clear Do Not Call on the record first.',\n          'FORBIDDEN',\n          403,\n        );\n      }\n    }\n  },\n};\n\nexport default [taskValidation, taskDoNotCallGuard, taskRecurrence, taskBubble];\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/revenue/objects/contract.hook.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/revenue/objects\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/revenue/objects/contract.hook.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport type { Hook, HookContext } from '@objectstack/spec/data';\nimport type { HookApi } from '../../sales/objects/_hook-api';\n\n/**\n * Contract lifecycle hook.\n *\n * - Validates `end_date` \u2248 `start_date + contract_term_months`.\n * - Rejects shrinking `end_date` after activation.\n * - On `activated`: stamps `signed_date` (if missing) and promotes the account\n *   to `customer`. Renewal reminders are owned by the `contract_renewal` flow.\n */\n\n// NB: helpers used by handlers are declared INSIDE each handler \u2014 L2 hook\n// bodies run body-only in the QuickJS sandbox, so module scope is not\n// available at runtime (cf. opportunity.hook.ts). Module-level copies were\n// dead code that invited silent divergence.\n\nconst contractValidation: Hook = {\n  name: 'contract_validation',\n  object: 'crm_contract',\n  events: ['beforeInsert', 'beforeUpdate'],\n  priority: 200,\n  description: 'Enforce contract term math and prevent shrinking end_date once activated.',\n  handler: async (ctx: HookContext) => {\n    // The refusal envelope (#1075). Mirrored from `src/sales/objects/_refusal.ts` because a\n    // lowered body has no module scope and `extractHookBody` THROWS on an\n    // import; `test/refusal-envelope.test.ts` pins every copy against it.\n    function refuse(\n      message: string,\n      code: string,\n      status: number,\n      userMessage: string = message,\n    ): Error {\n      const err = new Error(message) as Error & {\n        code: string;\n        status: number;\n        userMessage: string;\n      };\n      err.code = code;\n      err.status = status;\n      err.userMessage = userMessage;\n      return err;\n    }\n    const { event, input, previous } = ctx;\n\n    // Both operands are stored `YYYY-MM-DD` values, which the date-only parse\n    // anchors at UTC MIDNIGHT \u2014 so they are read here on the calendar they were\n    // written on. The local accessors are one day earlier west of Greenwich\n    // (`new Date('2026-01-01').getDate()` answers 31 in `America/New_York`, 1 in\n    // `Europe/Berlin`), and this count feeds a hard refusal that the +/-1 month\n    // tolerance does not absorb at the boundary: a legal contract spanning\n    // `term + 1` months measured `term + 2` and the save was rejected, quoting a\n    // month count its own dates do not have.\n    function monthsBetween(startISO: string, endISO: string): number {\n      const s = new Date(startISO);\n      const e = new Date(endISO);\n      return (\n        (e.getUTCFullYear() - s.getUTCFullYear()) * 12 +\n        (e.getUTCMonth() - s.getUTCMonth()) +\n        // Unchanged intent: has the end day-of-month reached the start's yet?\n        // If not, the last month is not complete and does not count.\n        (e.getUTCDate() >= s.getUTCDate() ? 0 : -1)\n      );\n    }\n\n    // The patch's value, else the stored one; an empty string or a 0 / NaN\n    // term counts as absent, so the check below stands down.\n    const startDate = [input.start_date, previous?.start_date].find((v): v is string => typeof v === 'string' && v !== '');\n    const endDate = [input.end_date, previous?.end_date].find((v): v is string => typeof v === 'string' && v !== '');\n    const term = [input.contract_term_months, previous?.contract_term_months].find((v): v is number => typeof v === 'number' && !!v);\n\n    if (startDate && endDate && term) {\n      const calc = monthsBetween(startDate, endDate);\n      if (Math.abs(calc - term) > 1) {\n        throw refuse(\n          `Contract term (${term} months) does not match date range (${calc} months from ${startDate} to ${endDate}).`,\n          'VALIDATION_FAILED',\n          400,\n        );\n      }\n    }\n\n    if (event === 'beforeUpdate' && previous?.status === 'activated') {\n      if (\n        typeof input.end_date === 'string' &&\n        typeof previous.end_date === 'string' &&\n        input.end_date < previous.end_date\n      ) {\n        throw refuse(\n          `Cannot shrink end_date (${previous.end_date as string} \u2192 ${input.end_date}) after activation. Use a termination/amendment workflow instead.`,\n          'RECORD_LOCKED',\n          409,\n        );\n      }\n    }\n  },\n};\n\nconst contractActivation: Hook = {\n  name: 'contract_on_activation',\n  object: 'crm_contract',\n  events: ['afterUpdate'],\n  priority: 800,\n  async: true,\n  onError: 'log',\n  description: 'On activation: stamp signed_date, promote account.',\n  handler: async (ctx: HookContext) => {\n    const { input, previous } = ctx;\n    if (input.status !== 'activated' || previous?.status === 'activated') return;\n    const api = ctx.api as HookApi | undefined;\n    if (!api) return;\n\n    const id = [input.id, previous?.id].find((v): v is string => typeof v === 'string' && v !== '');\n    const accountId = [input.crm_account, previous?.crm_account].find((v): v is string => typeof v === 'string' && v !== '');\n\n    if (id && !input.signed_date && !previous?.signed_date) {\n      await api.object('crm_contract').update(\n        { id, signed_date: new Date().toISOString().slice(0, 10) },\n        { where: { id } },\n      );\n    }\n\n    if (accountId) {\n      const account = await api.object('crm_account').findOne({ where: { id: accountId } });\n      if (account && account.type !== 'customer') {\n        await api.object('crm_account').update(\n          { id: accountId, type: 'customer' },\n          { where: { id: accountId } },\n        );\n      }\n    }\n\n    // No renewal task here: renewal reminders are owned by the\n    // `contract_renewal` scheduled flow, which honours the per-contract\n    // `renewal_notice_days`. The activation-time task this hook used to\n    // create hardcoded a 60-day notice and duplicated the flow's task.\n  },\n};\n\nexport default [contractValidation, contractActivation];\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/revenue/objects/_line-item-price-fill.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/revenue/objects\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/revenue/objects/_line-item-price-fill.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport type { Hook, HookContext } from '@objectstack/spec/data';\nimport type { HookApi } from '../../sales/objects/_hook-api';\n\n/**\n * Shared line-item price fill.\n *\n * `list_price` on both line-item objects is documented as \"auto-populated from\n * product.list_price\", and nothing implemented it until this hook. On write,\n * when a product is part of THIS change, it stamps the catalog `list_price`;\n * on INSERT it also defaults the negotiated `unit_price` to the list price when\n * the rep left it blank (they can still override). On update the negotiated\n * `unit_price` is left alone, so a re-synced catalog price never clobbers a\n * price someone actually negotiated.\n *\n * Why it lives here rather than twice: `crm_opportunity_line_item` and\n * `crm_quote_line_item` carried near-verbatim copies of this handler that\n * differed only in comments \u2014 the shape that lets a fix land on one object and\n * silently skip the other. Only the price fill is shared; the two ROLLUP hooks\n * next door look alike but compute genuinely different totals, so they stay\n * separate.\n *\n * Sandbox note: L2 hook bodies run BODY-ONLY in the QuickJS sandbox, so a\n * handler cannot reach module scope at runtime. This factory is still safe\n * because the sharing happens at authoring time \u2014 `objectName`/`hookName` are\n * plain metadata on the returned Hook, and the handler body below closes over\n * NOTHING but its own `ctx`. Never move a value the body reads into this\n * factory's parameters; it would resolve here and be undefined in the sandbox.\n *\n * That rule is enforced, not just documented: `test/action-sandbox.test.ts`\n * lowers this handler with the CLI build's own extraction pass (which rejects a\n * body referencing anything out of scope) and runs the result under the real\n * QuickJS runner, with a negative control that shows the guard still bites.\n * Worth knowing why a test has to: when extraction fails the build does not,\n * it silently keeps the handler in its bundled form and the hook stops being\n * deployable as pure metadata.\n */\nexport function createLineItemPriceFill(objectName: string, hookName: string): Hook {\n  return {\n    name: hookName,\n    object: objectName,\n    events: ['beforeInsert', 'beforeUpdate'],\n    priority: 100,\n    description: 'Default list_price / unit_price from the chosen product.',\n    handler: async (ctx: HookContext) => {\n      const { event, input } = ctx;\n      const api = ctx.api as HookApi | undefined;\n      if (!api) return;\n      // Only act when a product reference is part of THIS write.\n      const productId = typeof input.crm_product === 'string' ? input.crm_product : undefined;\n      if (!productId) return;\n      const product = await api.object('crm_product').findOne({\n        where: { id: productId }, fields: ['id', 'list_price'],\n      });\n      const listPrice = product && typeof product.list_price === 'number' ? product.list_price : undefined;\n      if (listPrice === undefined) return;\n      // Catalog reference always tracks the product.\n      input.list_price = listPrice;\n      // Negotiated price defaults to list on create when left blank; never\n      // overwritten on update (respect a rep's negotiated figure).\n      if (event === 'beforeInsert' && input.unit_price == null) {\n        input.unit_price = listPrice;\n      }\n    },\n  };\n}\n\n/**\n * Shared line-number assigner (#1828) \u2014 `line_number` is `readonly`, so this is\n * its one writer. Insert: `max under the parent + 1`. Update of a row that still\n * has none (created before this hook \u2014 `scripts/backfill-line-number.ts` touches\n * each once): same stamp. An existing ordinal is never renumbered. The engine\n * keeps a payload key a hook wrote through its readonly strip, so a user write\n * lands the stamp and a user-supplied value is overwritten; only a no-user\n * system write that supplies one (the seed, and its replay) keeps its own. `runAs: 'system'`\n * elevates the sibling read and nothing else. Body-only rule as above: the\n * parent key comes from `ctx.object`, never a factory parameter.\n */\nexport function createLineItemNumbering(objectName: string, hookName: string): Hook {\n  return {\n    name: hookName,\n    object: objectName,\n    events: ['beforeInsert', 'beforeUpdate'],\n    priority: 110,\n    runAs: 'system',\n    description: 'Assign line_number = (max under the parent) + 1.',\n    handler: async (ctx: HookContext) => {\n      const { event, input } = ctx;\n      const prev = ctx.previous;\n      const api = ctx.api as HookApi | undefined;\n      if (!api) return;\n      if (!ctx.user?.id && typeof input.line_number === 'number') return;\n      // D3: a predicate update has ONE payload for every row (forecast.hook.ts).\n      if (event === 'beforeUpdate' && (ctx.dispatch?.mode === 'per-row' || typeof prev?.line_number === 'number')) return;\n      const parentKey = ctx.object === 'crm_quote_line_item' ? 'crm_quote' : 'crm_opportunity';\n      const parentId = input[parentKey] ?? prev?.[parentKey];\n      if (typeof parentId !== 'string' || !parentId) return;\n      const siblings = await api.object(ctx.object).find({\n        where: { [parentKey]: parentId }, fields: ['line_number'], top: 5000,\n      });\n      let max = 0;\n      for (const s of siblings) {\n        if (typeof s.line_number === 'number' && s.line_number > max) max = s.line_number;\n      }\n      // A batch insert runs every row's beforeInsert before storing any row.\n      const offset = event === 'beforeInsert' && ctx.dispatch?.mode === 'per-row' ? ctx.dispatch.index : 0;\n      input.line_number = max + 1 + offset;\n    },\n  };\n}\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/revenue/objects/opportunity_line_item.hook.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/revenue/objects\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/revenue/objects/opportunity_line_item.hook.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport type { Hook, HookContext } from '@objectstack/spec/data';\nimport type { HookApi } from '../../sales/objects/_hook-api';\nimport { createLineItemNumbering, createLineItemPriceFill } from './_line-item-price-fill';\n\n/**\n * Opportunity amount rollup.\n *\n * Keeps `crm_opportunity.amount` in sync with the sum of its line items'\n * extended price. Fires after a line item is inserted / updated / deleted (the\n * console surfaces these as the opportunity's \"Products\" related list) and\n * recomputes the parent opportunity's amount from the current line set.\n *\n * Why this exists: `amount` was a free-typed currency field with no link to\n * `crm_opportunity_line_item`, so itemising a deal and its headline number\n * could drift apart. Once a deal is itemised, the line sum is authoritative.\n *\n * Design decisions:\n * - Recomputes from raw `quantity * unit_price * (1 - discount/100)` rather than\n *   reading the `total_price` FORMULA field, so it doesn't depend on formula\n *   hydration inside the sandboxed hook body.\n * - If the opportunity has NO line items (e.g. the last one was just deleted),\n *   `amount` is left untouched \u2014 zeroing it would trip the `amount > 0`\n *   validation and wipe the manually-entered figure on opportunities that never\n *   used line items at all.\n * - `async: true` + `onError: 'log'` \u2014 the rollup is a derived convenience; a\n *   failure must never block the line-item write. Updating the parent does not\n *   re-trigger this hook (different object), so there's no loop.\n * - On re-parenting (update that moves a line to another opportunity), BOTH the\n *   old and new parents are recomputed.\n */\n/**\n * Line-item price fill \u2014 one implementation shared with the quote line item;\n * see `_line-item-price-fill.ts` for the behaviour and the sandbox caveat.\n */\nconst opportunityLineItemPriceFill: Hook = createLineItemPriceFill(\n  'crm_opportunity_line_item',\n  'opportunity_line_item_price_fill',\n);\n\n/** `line_number` assigner \u2014 see `_line-item-price-fill.ts` (#1828). */\nconst opportunityLineItemNumbering: Hook = createLineItemNumbering(\n  'crm_opportunity_line_item',\n  'opportunity_line_item_line_number',\n);\n\nconst opportunityAmountRollup: Hook = {\n  name: 'opportunity_amount_rollup',\n  object: 'crm_opportunity_line_item',\n  events: ['afterInsert', 'afterUpdate', 'afterDelete'],\n  priority: 300,\n  async: true,\n  onError: 'log',\n  description: 'Recompute parent opportunity.amount from the sum of its line items.',\n  handler: async (ctx: HookContext) => {\n    const api = ctx.api as HookApi | undefined;\n    if (!api) return;\n    const { input, previous } = ctx;\n    const num = (v: unknown): number => (typeof v === 'number' ? v : 0);\n\n    // Every parent opportunity touched by this change (old + new handles the\n    // re-parenting case on update).\n    const oppIds = new Set<string>();\n    for (const v of [input?.crm_opportunity, previous?.crm_opportunity]) {\n      if (typeof v === 'string' && v) oppIds.add(v);\n    }\n    if (oppIds.size === 0) return;\n\n    for (const oppId of oppIds) {\n      // Skip closed deals. The rollup runs in a system context (no ctx.user),\n      // which BYPASSES the opportunity freeze guard \u2014 so without this check,\n      // editing a line item would silently rewrite a closed-won deal's recorded\n      // amount. A closed deal's value is settled; leave it.\n      const opp = await api.object('crm_opportunity').findOne({\n        where: { id: oppId }, fields: ['id', 'stage'],\n      });\n      const stage = opp && typeof opp.stage === 'string' ? opp.stage : undefined;\n      if (stage === 'closed_won' || stage === 'closed_lost') continue;\n\n      const lines = await api.object('crm_opportunity_line_item').find({\n        where: { crm_opportunity: oppId },\n        fields: ['quantity', 'unit_price', 'discount'],\n        top: 5000,\n      });\n      // No lines left \u2192 leave the existing amount as-is (see design note).\n      if (!lines || lines.length === 0) continue;\n\n      let sum = 0;\n      for (const l of lines) sum += num(l.quantity) * num(l.unit_price) * (1 - num(l.discount) / 100);\n      sum = Math.round(sum * 100) / 100;\n      if (sum > 0) {\n        await api.object('crm_opportunity').update(\n          { id: oppId, amount: sum },\n          { where: { id: oppId } },\n        );\n      }\n    }\n  },\n};\n\nexport default [opportunityLineItemPriceFill, opportunityLineItemNumbering, opportunityAmountRollup];\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/revenue/objects/product.hook.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/revenue/objects\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/revenue/objects/product.hook.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport type { Hook, HookContext } from '@objectstack/spec/data';\nimport type { HookApi } from '../../sales/objects/_hook-api';\n\n/**\n * Product catalog hook.\n *\n * - Enforces `list_price >= cost`.\n * - Normalizes `sku` to uppercase.\n * - Refuses delete when the product is referenced by ANY opportunity or quote\n *   line item (historical included \u2014 deals keep their line history); suggests\n *   deactivating (`is_active=false`) instead.\n */\n\nconst productHook: Hook = {\n  name: 'product_catalog',\n  object: 'crm_product',\n  events: ['beforeInsert', 'beforeUpdate', 'beforeDelete'],\n  priority: 200,\n  description: 'Pricing sanity, SKU normalization, and protect referenced products from deletion.',\n  handler: async (ctx: HookContext) => {\n    // The refusal envelope (#1075). Mirrored from `src/sales/objects/_refusal.ts` because a\n    // lowered body has no module scope and `extractHookBody` THROWS on an\n    // import; `test/refusal-envelope.test.ts` pins every copy against it.\n    function refuse(\n      message: string,\n      code: string,\n      status: number,\n      userMessage: string = message,\n    ): Error {\n      const err = new Error(message) as Error & {\n        code: string;\n        status: number;\n        userMessage: string;\n      };\n      err.code = code;\n      err.status = status;\n      err.userMessage = userMessage;\n      return err;\n    }\n    const { event, input, previous } = ctx;\n\n    if (event === 'beforeInsert' || event === 'beforeUpdate') {\n      // The patch's value, else the stored one \u2014 the first that is a number.\n      const listPrice = [input.list_price, previous?.list_price].find((v): v is number => typeof v === 'number');\n      const cost = [input.cost, previous?.cost].find((v): v is number => typeof v === 'number');\n      if (typeof listPrice === 'number' && typeof cost === 'number' && listPrice < cost) {\n        throw refuse(\n          `List Price (${listPrice}) must be greater than or equal to Cost (${cost}).`,\n          'VALIDATION_FAILED',\n          400,\n        );\n      }\n      if (typeof input.sku === 'string') {\n        input.sku = input.sku.toUpperCase();\n      }\n    }\n\n    if (event === 'beforeDelete') {\n      const api = ctx.api as HookApi | undefined;\n      const id = previous?.id;\n      if (!api || !id) return;\n      const [oppRefs, quoteRefs] = await Promise.all([\n        api.object('crm_opportunity_line_item').count({ where: { crm_product: id } }).catch(() => 0),\n        api.object('crm_quote_line_item').count({ where: { crm_product: id } }).catch(() => 0),\n      ]);\n      if (oppRefs + quoteRefs > 0) {\n        throw refuse(\n          `Cannot delete product: referenced by ${oppRefs} opportunity(ies) and ${quoteRefs} quote(s). Set is_active=false to retire instead.`,\n          'DELETE_RESTRICTED',\n          409,\n        );\n      }\n    }\n  },\n};\n\nexport default productHook;\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/revenue/objects/quote.hook.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/revenue/objects\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/revenue/objects/quote.hook.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport type { Hook, HookContext } from '@objectstack/spec/data';\nimport type { HookApi } from '../../sales/objects/_hook-api';\n\n/**\n * Quote workflow hook.\n *\n * - Defaults `expiration_date` to `quote_date + 30 days` when missing.\n * - Freezes quotes once `accepted` or `expired` \u2014 against USER edits only: a\n *   write that is purely the engine clearing a link is let through. The\n *   freeze covers the quote's LINE ITEMS too (#2060): a user may neither add\n *   a line to a settled quote nor change one of its lines.\n * - Refuses a user's acceptance while the linked opportunity is held by an\n *   approval, because acceptance closes that deal as won (#2014).\n * - On `accepted`, drafts a contract \u2014 carrying the quote's negotiated\n *   `payment_terms` onto it, and filling what the quote cannot express from\n *   `DRAFT_CONTRACT_DEFAULTS`, declared placeholders rather than decisions\n *   (#1129) \u2014 and pushes the linked opportunity to `closed_won`. Two hooks,\n *   `quote_accepted_contract_draft` and `quote_on_accepted`, because only the\n *   draft is elevated (#2014; see its note).\n */\n\n// \u26A0\uFE0F Helpers used by handlers are declared INSIDE each handler \u2014 L2 hook bodies\n// run body-only in the QuickJS sandbox, so module scope is not available at\n// runtime (cf. opportunity.hook.ts).\n\nconst quoteValidation: Hook = {\n  name: 'quote_workflow',\n  // \u26A0\uFE0F Two objects, deliberately (#2060): the freeze below is ONE freeze \u2014 the\n  // quote's and its lines' \u2014 so it lives in one place, judged by one user/system\n  // boundary and carried by one envelope, rather than a second copy of both on\n  // the line. `test/package-ownership.test.ts` reads every name in the list.\n  object: ['crm_quote', 'crm_quote_line_item'],\n  events: ['beforeInsert', 'beforeUpdate'],\n  priority: 200,\n  description: 'Default expiration date; freeze accepted/expired quotes and their lines.',\n  handler: async (ctx: HookContext) => {\n    // The refusal envelope. \u26A0\uFE0F Mirrored from `src/sales/objects/_refusal.ts` because a lowered\n    // body has no module scope and `extractHookBody` THROWS on an import;\n    // `test/refusal-envelope.test.ts` pins every copy against it.\n    function refuse(\n      message: string,\n      code: string,\n      status: number,\n      userMessage: string = message,\n    ): Error {\n      const err = new Error(message) as Error & {\n        code: string;\n        status: number;\n        userMessage: string;\n      };\n      err.code = code;\n      err.status = status;\n      err.userMessage = userMessage;\n      return err;\n    }\n    const { event, input, previous } = ctx;\n\n    // \u2500\u2500\u2500 A settled quote's LINES are frozen with it (#2060 item 1, B-09) \u2500\u2500\n    //\n    // Measured on 17.7.0 before this branch: a rep added a line to an accepted\n    // quote (200), `quote_total_rollup` rightly left the settled totals alone,\n    // and the quote's lines stopped summing to them. The doc promises the\n    // opposite (`content/docs/sales/quotes.mdx`, \"the quote is frozen\").\n    //\n    // The freeze's own boundary, not a second one: USER writes only (a seed or\n    // import carries no user and is let through, as below), and an update is\n    // judged by what it CHANGES, like `violating` below \u2014 `id` addresses the\n    // row, `updated_at` / `updated_by` are the engine's stamps (measured on every\n    // user update), and `line_number` is the read-only platform ordinal, which\n    // the 4.0.0 one-time back-fill touches with `{ line_number: null }` on every\n    // unnumbered line, settled quotes included. Both parents are judged, so a\n    // line moves neither onto a settled quote nor off one.\n    //\n    // \u26A0\uFE0F DELETE is not guarded, pending a decision on #2060: deleting a quote,\n    // or the account it cascades from, deletes its lines AS THE DELETING USER\n    // (measured: each line's `beforeDelete` sees that user), and no declared\n    // hook-context key tells that cascade from a hand delete of one line \u2014 so a\n    // delete guard would make every settled quote with lines undeletable.\n    if (ctx.object === 'crm_quote_line_item') {\n      const changed = Object.keys(input).some((k) => !['id', 'updated_at', 'updated_by', 'line_number'].includes(k) && input[k] !== previous?.[k]);\n      for (const id of new Set([input.crm_quote, previous?.crm_quote])) {\n        const q = changed && ctx.user?.id && typeof id === 'string' && id\n          ? await (ctx.api as HookApi | undefined)?.object('crm_quote').findOne({ where: { id }, fields: ['quote_number', 'name', 'status'] })\n          : null;\n        if (q?.status === 'accepted' || q?.status === 'expired') {\n          throw refuse(`Quote ${String(q.quote_number)} - ${String(q.name)} is ${q.status}, so its line items can no longer be added or changed.`, 'RECORD_LOCKED', 409);\n        }\n      }\n      return;\n    }\n\n    // The quote as every quote surface titles it. `crm_quote.display_title` is\n    // `quote_number - name`; compose the same pair from the two stored columns\n    // rather than appending the record id. A lowered hook body cannot read the\n    // formula field itself, and both of its sources are already on the\n    // pre-image \u2014 the number is an engine-issued autonumber, so it is read from\n    // `previous` only. Both refusals below name the quote with it.\n    function subject(): string {\n      const label = [previous?.quote_number, previous?.name].map((v) => (typeof v === 'string' ? v.trim() : '')).filter(Boolean).join(' - ');\n      return label ? `Quote ${label}` : 'Quote';\n    }\n\n    /**\n     * `iso` + `days`, on ONE calendar \u2014 UTC, end to end.\n     *\n     * The base is not an instant here, it is a stored DATE: a bare\n     * `YYYY-MM-DD` is parsed by the date-only form of the spec, which anchors\n     * it at UTC midnight (measured: `new Date('2026-01-01')` is\n     * `2026-01-01T00:00:00.000Z` in every zone). So the anchor was already\n     * UTC and only the arithmetic was not \u2014 and reading a UTC-midnight anchor\n     * on the LOCAL calendar is off by a whole day west of Greenwich, where\n     * that instant is the previous evening (`getDate()` on the value above\n     * answers 31, not 1).\n     *\n     * That is why this site's exposure is not the one-hour window the\n     * \"advance now by N days\" hooks have: the anchor does not move with the\n     * clock, so every quote whose [quote_date, quote_date + days] span crosses\n     * a DST transition took a 23 h day and rendered a day short \u2014 measured at\n     * 60 of 730 consecutive base dates in `America/New_York`, `Europe/Berlin`,\n     * `America/Santiago`, `Australia/Sydney` and `Pacific/Auckland` alike.\n     */\n    function addDays(iso: string, days: number): string {\n      const d = new Date(iso);\n      d.setUTCDate(d.getUTCDate() + days);\n      return d.toISOString().slice(0, 10);\n    }\n\n    if (event === 'beforeInsert' && !input.expiration_date) {\n      const base = typeof input.quote_date === 'string' ? input.quote_date : new Date().toISOString().slice(0, 10);\n      input.expiration_date = addDays(base, 30);\n    }\n\n    // \u26A0\uFE0F Guard ONLY genuine USER edits (`ctx.user?.id` present). System / seed /\n    // backfill writes carry no user and legitimately re-apply business fields\n    // (the seed's quote_date/expiration_date re-evaluate on every reboot), so\n    // guarding them throws boot-time BodyRunner errors. Matches the system-write\n    // convention used across the case/lead/opportunity hooks.\n    if (event === 'beforeUpdate' && previous && ctx.user?.id) {\n      const frozen = previous.status === 'accepted' || previous.status === 'expired';\n      if (frozen) {\n        const allowed = new Set(['internal_notes']);\n        // Framework-managed columns (ownership, audit timestamps) are re-stamped\n        // by the 9.x runtime \u2014 never treat those system writes as edits to a\n        // frozen quote, only user changes to business fields.\n        const SYSTEM_FIELDS = new Set([\n          'id', 'owner_id', 'created_at', 'updated_at', 'created_by', 'updated_by', 'space_id', 'organization_id', 'org_id', 'version',\n        ]);\n        // \u26A0\uFE0F `violating` rather than `changed`: the three freeze guards share\n        // one reference-cleanup predicate verbatim, and a shared block can only\n        // be shared if it reads the same variable in all three.\n        const violating = Object.keys(input).filter(\n          (k) => !allowed.has(k) && !SYSTEM_FIELDS.has(k) && input[k] !== previous[k],\n        );\n        if (violating.length > 0) {\n          // Every lookup on `crm_quote` a referential clear can attack.\n          const REFERENCE_FIELDS = new Set(['crm_account', 'crm_contact', 'crm_opportunity']);\n          // \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500 the reference-cleanup yield \u2500\u2500\n          // #720. The engine implements `deleteBehavior: 'set_null'` by UPDATING\n          // the row that HOLDS the lookup, so deleting the opportunity (or the\n          // contact) an ACCEPTED quote references arrives here as an ordinary\n          // user `beforeUpdate` \u2014 and this freeze refused it, which made a\n          // settled quote able to keep a deal, a person and (through the\n          // master-detail cascade) that person's account undeletable forever.\n          //\n          // Measured on 17.1.0 \u2014 the version this repo pinned AT THE TIME of\n          // the measurement, not the current pin (the cascade shape below has\n          // NOT been re-measured on any later pin \u2014 not 17.3.0, #1676, not\n          // 17.4.0, PR #1814, and not 17.5.0) \u2014 with a probe hook at priority 199 immediately\n          // ahead of each guard, not assumed.\n          // The engine builds its cleanup write on the CALLER's own context\n          // plus two engine keys, so on the path a REST `DELETE` takes, the\n          // cascade and a user's hand-clear of the same lookup are identical\n          // everywhere a guard can look: payload\n          // `{ id, <link>: null, updated_at, updated_by }`, `ctx.user` the\n          // CALLER, `ctx.session` the caller's own `{ userId, isSystem }`.\n          // (Both `updated_by` and the identity drop out together when the\n          // DELETE itself carried no `userId` \u2014 a rig artefact, not this app's\n          // path.) So the WRITE SHAPE is not a discriminator, and the yield\n          // below is not one either: it lets ANY caller clear a declared link\n          // on a settled record. That is the trade #720 accepted, not a side\n          // effect of it.\n          //\n          // \u26A0\uFE0F A marker DOES reach a hook \u2014 and is deliberately not read. An\n          // earlier version of this note concluded \"no marker reaches a hook,\n          // and the WRITE SHAPE is the only evidence there is\"; it reasoned\n          // only about `ctx.session`, whose allow-list really does omit\n          // `__`-prefixed operation-private keys, and missed the other route\n          // into the context. `ObjectQL.cascadeDeleteRelations` builds\n          // `{ ...context, __referentialFieldClear: true }`, readable at\n          // `ctx.api.executionContext.__referentialFieldClear`: measured `true`\n          // on every cascade into `crm_opportunity`, `crm_quote` and\n          // `crm_lead`, `undefined` on every hand-clear (#1165, #1412).\n          //\n          // \u26D4 The #1165 ruling (2026-08-25) reviewed that and upheld NOT\n          // reading it, on two grounds. It is an operation-private key \u2014 an\n          // undeclared dependency that can vanish in a patch release. And\n          // reachability through the SHIPPED path is unproven: a hook body runs\n          // body-only in QuickJS, where `buildSandboxApi` passes `engineCtx.api`\n          // only when that exposes `object()`, and otherwise a shim with no\n          // `executionContext` at all. Green in a kernel rig and silently false\n          // in production is the worst outcome a guard can have. The declared\n          // replacement `ctx.referentialFieldClear` is asked for upstream as\n          // objectstack-ai/objectstack#13644.\n          //\n          // \u26D4 Keep this narrow (maintainer's ruling on #720, Option A): a write\n          // yields ONLY when every one of its non-system changes is a DECLARED\n          // link going from a value to `null`. One business field alongside it,\n          // or a link repointed to a NEW value, and the refusal below still\n          // fires. The three freeze guards share this block verbatim \u2014 sharing\n          // it as an imported helper is not possible (hook bodies run body-only\n          // in the sandbox and cannot reach module scope), so\n          // `test/freeze-guard-reference-cleanup.test.ts` pins the three copies\n          // as identical text and pins both directions of the narrowness.\n          const isReferenceCleanup = violating.every(\n            (k) => REFERENCE_FIELDS.has(k) && input[k] === null && previous?.[k] != null,\n          );\n          if (isReferenceCleanup) return;\n\n          const what = `${subject()} is ${previous.status as string}`;\n          throw refuse(`${what}; only internal_notes may be edited. Attempted: ${violating.join(', ')}.`, 'RECORD_LOCKED', 409);\n        }\n      }\n\n      // \u2500\u2500\u2500 An acceptance the linked deal's approval holds (#2014) \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n      //\n      // Accepting a quote closes its opportunity as won (`quote_on_accepted`,\n      // as the CALLER). While an approval holds that deal, that close is\n      // refused \u2014 and it used to be refused one write too late: the acceptance\n      // was admitted, the close-won met the refusal inside an `async` hook,\n      // `onError: 'log'` swallowed it, and an accepted (therefore frozen) quote\n      // sat on an open deal it could never close again (measured on 17.7.0: a\n      // sales rep, a deal pending its Large Deal Approval). Maintainer ruling\n      // on #2014 (option C): refuse the ACCEPTANCE, at the moment it is made,\n      // so an approval stays an approval and the rep learns why.\n      //\n      // \"Held\" is exactly what makes that close-won fail, measured per state\n      // on 17.7.0 with a rep's direct close \u2014 no wider:\n      //   \u2022 `approval_status` `pending`: the Large Deal Approval's request is\n      //     open, and its approval node locks the record (`lockRecord: true`)\n      //     \u2192 the platform's RECORD_LOCKED. The column is the node's own\n      //     mirror of the live request (`approvalStatusField`); a recalled or\n      //     decided request leaves it `rejected` / `approved`, and neither\n      //     holds the deal (the close goes through on both);\n      //   \u2022 `status_change_approval_status` `pending` or `rejected` (REQ-0006,\n      //     once an install arms it) \u2192 `opportunity_lifecycle`'s refusal of a\n      //     direct close; with a request open the platform lock holds too;\n      //   \u2022 `qualification_approval_status` `pending` or `rejected` (the \u7ACB\u9879\n      //     gate, once armed) \u2192 `opportunity_lifecycle`'s refusal of any stage\n      //     move. Its approval node does NOT lock the record (`lockRecord:\n      //     false`); the refusal is the app's gate, and it is mirrored for that.\n      // A closed deal is never close-won again, so it holds nothing here.\n      //\n      // \u26A0\uFE0F BOUNDARIES, recorded rather than hidden. Read as the CALLER: a deal\n      // the caller cannot read cannot be closed by them either, for a reason\n      // that is not an approval, and that is not this gate's to name \u2014 so an\n      // unreadable deal, or a read that fails, stands down. USER writes only,\n      // the boundary the freeze above draws: a system write's close-won is not\n      // held by the lock or by either app gate (both judge users), so refusing\n      // its acceptance would be wider than the condition it mirrors.\n      if (input.status === 'accepted' && previous.status !== 'accepted') {\n        const dealId = [input.crm_opportunity, previous.crm_opportunity].find((v) => typeof v === 'string' && v);\n        const deal = dealId\n          ? await (ctx.api as HookApi | undefined)?.object('crm_opportunity').findOne({\n            where: { id: dealId },\n            fields: ['stage', 'approval_status', 'status_change_approval_status', 'qualification_approval_status'],\n          }).catch(() => null)\n          : null;\n        // Each hold is named by the field label and value the rep sees on the\n        // deal itself, so the sentence points at where to look. A `rejected`\n        // Large Deal Approval holds nothing (measured: the close goes through).\n        const held = deal && !String(deal.stage).startsWith('closed_')\n          ? [['approval_status', 'Approval Status'], ['status_change_approval_status', 'Status Change Approval'], ['qualification_approval_status', 'Qualification Approval']]\n            .filter(([f]) => deal[f] === 'pending' || (deal[f] === 'rejected' && f !== 'approval_status'))\n            .map(([f, label]) => `${label} is ${deal[f] === 'pending' ? 'Pending' : 'Rejected'}`)\n          : [];\n        // The quote has exactly one opportunity, so \"its opportunity\" names the\n        // deal unambiguously \u2014 and \u26D4 never by its record id.\n        if (held.length > 0) {\n          const what = `${subject()} cannot be accepted while its opportunity is held by an approval`;\n          throw refuse(`${what} (${held.join('; ')}): accepting it would close that deal as won. Accept it once the approval is granted.`, 'RECORD_LOCKED', 409);\n        }\n      }\n    }\n  },\n};\n\n/**\n * On acceptance: draft the contract.\n *\n * ## `runAs: 'system'`, and why the close-won is a separate hook (#2014)\n *\n * A sales rep holds `crm_contract.allowCreate: false`, and a rep accepting the\n * quote on their own deal is the ordinary CPQ path \u2014 so as the caller the\n * draft was refused (\"You do not have permission\"), `onError: 'log'` swallowed\n * it, and the deal went `closed_won` with no contract (measured on 17.7.0).\n * The draft is the business's paperwork for a sale the rep is entitled to\n * record, not the rep authoring a contract, so this hook elevates (AGENTS.md\n * rule 9); the rep still cannot create a contract by hand. Elevation is not\n * anonymity: the contract's `created_by` names the person who accepted.\n *\n * Elevating as little as possible is why the close-won is NOT here. `runAs` is\n * per hook, and a system write is not held by an approval's record lock:\n * elevated, an accepted quote would close a deal its manager has not approved.\n * `quote_on_accepted` keeps that write the caller's. The two were already\n * independent legs (#714) \u2014 a contract that will not draft must not decide\n * whether the deal is won \u2014 and two hooks make that structural.\n *\n * Organization (AGENTS.md rule 10): it issues no read, so there is no scan to\n * pin; its one write is an insert built from the triggering quote's own links,\n * and the engine stamps its `organization_id` from the trigger's context, which\n * elevation carries through unchanged (`withRunAs('system')` is the triggering\n * context plus `isSystem`) \u2014 pinned on a walled deployment by\n * `test/hook-org-inheritance.test.ts`.\n */\nconst quoteAcceptedContractDraft: Hook = {\n  name: 'quote_accepted_contract_draft',\n  object: 'crm_quote',\n  events: ['afterUpdate'],\n  priority: 800,\n  async: true,\n  onError: 'log',\n  runAs: 'system',\n  description: 'Draft the accepted quote\u2019s contract.',\n  handler: async (ctx: HookContext) => {\n    const { input, previous } = ctx;\n    if (input.status !== 'accepted' || previous?.status === 'accepted') return;\n    const api = ctx.api as HookApi | undefined;\n    if (!api) return;\n\n    // Real calendar months \u2014 `days * 30` shorted a 12-month term by ~5 days\n    // and only slipped past contract_validation's \u00B11-month tolerance by luck.\n    //\n    // On the UTC calendar throughout, for the reason `addDays` documents in\n    // the sibling hook above: the base is a UTC-midnight-anchored date string,\n    // so a local `getMonth`/`setMonth` step reads that anchor as the previous\n    // evening and renders a day short whenever the offset at the end of the\n    // term differs from the offset at its start. A 12-month term makes that\n    // rare but not absent \u2014 measured on 9 of 730 consecutive start dates in\n    // `America/New_York` (e.g. `2026-11-02` + 12 months answered\n    // `2027-11-01`), and it is `crm_contract.end_date`, a date the customer is\n    // invoiced against.\n    function addMonths(iso: string, months: number): string {\n      const d = new Date(iso);\n      d.setUTCMonth(d.getUTCMonth() + months);\n      return d.toISOString().slice(0, 10);\n    }\n\n    /**\n     * First candidate that is a non-empty record id, or `undefined` (#714).\n     *\n     * The id chains here used to be written `(typeof a === 'string' && a) || (typeof\n     * b === 'string' && b)`, whose value when NEITHER operand holds is boolean\n     * `false` \u2014 not `undefined`. `false` is a VALUE: it went into the contract\n     * document as the content of a lookup, and a lookup column takes a record id\n     * or nothing at all. What the engine did with it depends on the deployment's\n     * ADR-0104 value-shape posture, and both outcomes are wrong:\n     *\n     *   - warn-first (a deployment that has not run `os migrate value-shapes\n     *     --apply`): the write is ADMITTED with a `[value-shape] \u2026 accepted for\n     *     now` warning, and `crm_contact = false` is persisted into a reference\n     *     column \u2014 a row the value-shape scan will later refuse to convert;\n     *   - strict (after that gate, or `OS_DATA_VALUE_SHAPE_STRICT_ENABLED=1`):\n     *     `ValidationError: Primary Contact has an invalid lookup value: Invalid\n     *     input: expected string, received boolean`, which aborted this whole\n     *     handler \u2014 so no contract, and the close-won leg below never ran.\n     *\n     * `undefined` is the only correct \"there is no id here\": it does not survive\n     * the JSON hop into the engine, and the writes below drop the key outright,\n     * so an absent optional link is an ABSENT COLUMN rather than a junk value.\n     */\n    const pickId = (...candidates: unknown[]): string | undefined =>\n      candidates.find((c): c is string => typeof c === 'string' && c !== '');\n\n    const accountId = pickId(input.crm_account, previous?.crm_account);\n    const contactId = pickId(input.crm_contact, previous?.crm_contact);\n    const opportunityId = pickId(input.crm_opportunity, previous?.crm_opportunity);\n    const ownerId = pickId(input.owner_id, previous?.owner_id, ctx.user?.id);\n    const totalPrice = [input.total_price, previous?.total_price].find((v) => typeof v === 'number') ?? 0;\n\n    /**\n     * The payment terms the customer actually negotiated.\n     *\n     * Quote and Contract share one `payment_terms` vocabulary because an\n     * accepted quote's terms carry over to the contract \u2014 but only if something\n     * carries them. Without this the drafted contract takes\n     * `crm_contract.payment_terms`'s own option default `net_30` on every\n     * accepted quote, including one negotiated at `due_on_receipt`; and the\n     * contract's `payment_terms` is one of the fields\n     * `src/revenue/flows/billing-handoff-contract-activated.flow.ts` POSTs to\n     * billing when the contract activates, so a defaulted term becomes an\n     * invoicing term.\n     *\n     * Read like `totalPrice` above: the patch's value when the accepting write\n     * carried one, else the value already on the quote \u2014 `pickId`'s rule\n     * exactly (the first non-empty string), so it is read with `pickId`. A\n     * quote that never chose a term yields `undefined`, which drops the key and\n     * lets the contract's own default apply.\n     */\n    const paymentTerms = pickId(input.payment_terms, previous?.payment_terms);\n\n    const today = new Date().toISOString().slice(0, 10);\n\n    /**\n     * PLACEHOLDER DEFAULTS \u2014 declared as defaults, NOT decided as business\n     * facts (#1129 ruling, 2026-08-31). An auto-drafted contract is a STARTING\n     * DRAFT an admin completes, not a faithful transcription of what was sold.\n     * `crm_contract` requires all three, a quote can express none of them, so\n     * the hook has to supply something; none of it is evidence about the deal:\n     *\n     *   - `contract_term_months` \u2014 `required + notNull + min: 1` on the\n     *     contract, and the quote has nowhere to record a term. 12 is a guess\n     *     with nothing behind it;\n     *   - `contract_type` \u2014 the contract declares six values (subscription /\n     *     service / license / partnership / nda / msa) and NO option default,\n     *     so this line is the only thing that ever picks one: every\n     *     auto-drafted contract in the app is a subscription and the other\n     *     five types are unreachable on this path. It does not stay here\n     *     either \u2014\n     *     `src/revenue/flows/billing-handoff-contract-activated.flow.ts`\n     *     POSTs `contract_type` to billing when the contract activates;\n     *   - `start_date` \u2014 the one member that is not a literal: the date the\n     *     quote happened to be ACCEPTED, which is not necessarily the date the\n     *     customer's term begins. A placeholder RULE rather than a placeholder\n     *     value. It sits in the block because the block is itself per-draft:\n     *     an L2 body has no module scope at runtime (see the file header), so\n     *     these are handler-local by construction, not module constants.\n     *\n     * `end_date` is not a fourth default \u2014 it is DERIVED from the two above\n     * (`addMonths`, real calendar months), so it inherits their guesses rather\n     * than adding one of its own.\n     *\n     * \u26D4 Do not read these as decisions and do not quietly re-tune them. The\n     * alternative \u2014 the quote carrying a real term and type so the draft\n     * transcribes what was sold \u2014 is option A of #1129: recorded, not\n     * undertaken, unfrozen only by measured evidence that real sales processes\n     * fix the term and type at acceptance time. This block is then the list of\n     * values that move onto `crm_quote`. Leaving them unmarked was excluded by\n     * the same ruling: an unmarked hardcode is exactly how the `payment_terms`\n     * drift of #873 happened.\n     */\n    const DRAFT_CONTRACT_DEFAULTS = {\n      contract_term_months: 12,\n      contract_type: 'subscription',\n      start_date: today,\n    } as const;\n\n    // The contract's ONE field explaining where it came from. \u26D4 Never a record\n    // id: `Auto-drafted from accepted quote MvNopWgEDZwm2T5L` names a string no\n    // surface in this app ever shows, on a quote every screen calls `QTE-0006`.\n    // Name it the way `crm_quote.display_title` does. Unlike the task sites in\n    // this class there is no relationship field to hold the id afterwards \u2014\n    // `crm_contract` links account, contact and opportunity but not the quote \u2014\n    // so this sentence is the whole provenance record and had better be\n    // readable. `quote_number` is an engine-issued autonumber and never appears\n    // on an update payload, so it is read from the pre-image alone; `name` can\n    // be changing in this very write.\n    const trimmed = (v: unknown): string => (typeof v === 'string' ? v.trim() : '');\n    const quoteLabel = [trimmed(previous?.quote_number), [input.name, previous?.name].map(trimmed).find(Boolean)].filter(Boolean).join(' - ');\n\n    // Only lookups we actually HAVE are written. A missing optional link is an\n    // absent key \u2014 never `false` (see `pickId`), and never `null` either: `null`\n    // is a legal shape for the optional `crm_opportunity` but not for the\n    // required `crm_contact`, and one idiom for both is what keeps this honest.\n    const contract: Record<string, unknown> = {\n      ...DRAFT_CONTRACT_DEFAULTS,\n      status: 'draft',\n      end_date: addMonths(DRAFT_CONTRACT_DEFAULTS.start_date, DRAFT_CONTRACT_DEFAULTS.contract_term_months),\n      contract_value: totalPrice,\n      description: quoteLabel ? `Auto-drafted from accepted quote ${quoteLabel}` : 'Auto-drafted from an accepted quote',\n    };\n    if (accountId) contract.crm_account = accountId;\n    if (contactId) contract.crm_contact = contactId;\n    if (opportunityId) contract.crm_opportunity = opportunityId;\n    if (ownerId) contract.owner_id = ownerId;\n    // Same idiom for the same reason: written only when the quote HAS a term,\n    // so \"the quote chose nothing\" stays an absent key rather than becoming a\n    // value the contract's default would otherwise have supplied.\n    if (paymentTerms) contract.payment_terms = paymentTerms;\n\n    // What the draft deliberately does NOT carry (#1129 ruling, 2026-08-31) \u2014\n    // DECIDED, not overlooked. `crm_quote.shipping_terms` and\n    // `crm_quote.shipping_address` have no counterpart column on\n    // `crm_contract` at all; `crm_quote.billing_address` has one and is left\n    // for the admin completing the draft; and the quote's `description` would\n    // displace the provenance sentence written above, which is this contract's\n    // only record of where it came from. Copying any of them is part of option\n    // A (faithful transcription) and unfreezes with it, not before.\n\n    try {\n      await api.object('crm_contract').insert(contract);\n    } catch (err) {\n      // `crm_quote.crm_contact` is deliberately optional while\n      // `crm_contract.crm_contact` is `required + notNull`, so a quote accepted\n      // without a recipient legitimately lands here with \"Primary Contact is\n      // required\". That refusal is the documented behaviour, not a defect \u2014\n      // `content/docs/sales/quotes.mdx` already tells reps to put the contact on\n      // the quote first, because \"what the quote does not carry, acceptance\n      // cannot pass on\". The refusal is truthful (a named missing field, not\n      // \"received boolean\"), and since the close-won lives in its own hook it\n      // can no longer take that leg with it.\n      //\n      // DELIBERATELY BARE, like the close-won one in `quote_on_accepted`: a\n      // cascade fault the accepting user neither caused nor can act on, so a\n      // 500, never a 4xx refusal envelope (#1075). It names the quote the way\n      // every screen does \u2014 the label composed above \u2014 never by its id (#1243).\n      throw new Error(`could not draft the contract for quote ${quoteLabel}: ${(err as Error).message}`);\n    }\n  },\n};\n\n/**\n * On acceptance: push the linked opportunity to `closed_won`.\n *\n * Deliberately NOT elevated \u2014 the reason is on `quote_accepted_contract_draft`\n * above: this write stays the accepting caller's, so the opportunity's own\n * guards and an approval's record lock judge it as they always have. A deal an\n * approval holds is refused at the acceptance itself (`quote_workflow`), so this\n * write no longer meets that lock on a user's acceptance.\n */\nconst quoteAccepted: Hook = {\n  name: 'quote_on_accepted',\n  object: 'crm_quote',\n  events: ['afterUpdate'],\n  priority: 800,\n  async: true,\n  onError: 'log',\n  description: 'Close-win the accepted quote\u2019s opportunity.',\n  handler: async (ctx: HookContext) => {\n    const { input, previous } = ctx;\n    if (input.status !== 'accepted' || previous?.status === 'accepted') return;\n    const api = ctx.api as HookApi | undefined;\n    // A record id or nothing \u2014 never boolean `false` (#714; the full note is on\n    // `pickId` in `quote_accepted_contract_draft`).\n    const id = [input.crm_opportunity, previous?.crm_opportunity].find((v): v is string => typeof v === 'string' && v !== '');\n    if (!api || !id) return;\n\n    try {\n      const opp = await api.object('crm_opportunity').findOne({ where: { id } });\n      // A deal already closed, won or lost, is left where it is.\n      if (opp && !String(opp.stage).startsWith('closed_')) {\n        // `crm_opportunity.win_reason` is `requiredWhen` stage is closed_won\n        // (#593), and this write is the ONE close path with no human in it to\n        // attribute the win \u2014 so without a value here the CPQ leg would be\n        // rejected by the engine on every accepted quote. `quote_accepted`\n        // names the automated path rather than guessing a rep's answer; keep\n        // the reason the rep already recorded if there is one.\n        const won = { id, stage: 'closed_won', close_date: new Date().toISOString().slice(0, 10) };\n        await api.object('crm_opportunity').update({ ...won, ...(opp.win_reason ? {} : { win_reason: 'quote_accepted' }) }, { where: { id } });\n      }\n    } catch (err) {\n      // DELIBERATELY BARE \u2014 one of the two throws in this file the #1075 sweep\n      // left alone (the other is the contract draft's, above). Every other\n      // throw here is a business refusal: the user asked for something the\n      // rules forbid, and an envelope tells their client which rule. This one\n      // is the opposite. It fires from an `afterUpdate` cascade when close-won\n      // bookkeeping FAILED for reasons the user did not cause and cannot act\n      // on, so it is a server fault and belongs in the 5xx band. A bare Error is\n      // already mapped to `500 / INTERNAL_ERROR` by `resolveThrownHttpError`,\n      // which is the correct answer \u2014 dressing it in a 4xx refusal code would\n      // file a broken cascade as user error. It names the quote by its number,\n      // the engine's autonumber every screen shows \u2014 never a record id (#1243).\n      throw new Error(`could not close-won the opportunity of quote ${String(previous?.quote_number)}: ${(err as Error).message}`);\n    }\n  },\n};\n\nexport default [quoteValidation, quoteAcceptedContractDraft, quoteAccepted];\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/revenue/objects/quote_line_item.hook.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/revenue/objects\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/revenue/objects/quote_line_item.hook.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport type { Hook, HookContext } from '@objectstack/spec/data';\nimport type { HookApi } from '../../sales/objects/_hook-api';\nimport { createLineItemNumbering, createLineItemPriceFill } from './_line-item-price-fill';\n\n/**\n * Quote total rollup.\n *\n * Keeps a quote's pricing (`subtotal` / `discount_amount` / `total_price`) in\n * sync with the sum of its line items. Fires after a quote line item is\n * inserted / updated / deleted (the console surfaces these as the quote's\n * \"Line Items\" related list).\n *\n * Why this exists: `quote_generation` seeds the quote totals from the source\n * opportunity's amount at create time, but nothing kept them in step once a\n * rep edited the line items \u2014 the quote total and its itemization could drift.\n *\n * Total model (mirrors the quote_generation flow):\n *   subtotal        = \u03A3 line (quantity \u00D7 unit_price \u00D7 (1 \u2212 line_discount/100))\n *   discount_amount = subtotal \u00D7 quote.discount%              (quote-level)\n *   total_price     = subtotal \u2212 discount_amount + tax + shipping_handling\n * Quote-level `tax` and `shipping_handling` stay manual; only the line-derived\n * figures are rolled up.\n *\n * Design decisions mirror opportunity_line_item.hook:\n * - recompute from raw `quantity/unit_price/discount` (not the `subtotal`\n *   FORMULA field) so it doesn't depend on formula hydration in the sandbox;\n * - leave totals untouched when there are NO lines (never zero a quote whose\n *   totals came from the opportunity);\n * - skip accepted / expired quotes \u2014 the rollup runs system-context and would\n *   otherwise bypass the quote freeze guard and rewrite a settled quote;\n * - async + onError:'log' \u2014 a derived convenience, never blocks the line write;\n * - handles re-parenting (old + new quote).\n */\n/**\n * Line-item price fill \u2014 one implementation shared with the opportunity line\n * item; see `_line-item-price-fill.ts` for the behaviour and the sandbox caveat.\n */\nconst quoteLineItemPriceFill: Hook = createLineItemPriceFill(\n  'crm_quote_line_item',\n  'quote_line_item_price_fill',\n);\n\n/** `line_number` assigner \u2014 see `_line-item-price-fill.ts` (#1828). */\nconst quoteLineItemNumbering: Hook = createLineItemNumbering(\n  'crm_quote_line_item',\n  'quote_line_item_line_number',\n);\n\nconst quoteTotalRollup: Hook = {\n  name: 'quote_total_rollup',\n  object: 'crm_quote_line_item',\n  events: ['afterInsert', 'afterUpdate', 'afterDelete'],\n  priority: 300,\n  async: true,\n  onError: 'log',\n  description: 'Recompute parent quote subtotal/discount/total from its line items.',\n  handler: async (ctx: HookContext) => {\n    const api = ctx.api as HookApi | undefined;\n    if (!api) return;\n    const { input, previous } = ctx;\n    const num = (v: unknown): number => (typeof v === 'number' ? v : 0);\n\n    const quoteIds = new Set<string>();\n    for (const v of [input?.crm_quote, previous?.crm_quote]) {\n      if (typeof v === 'string' && v) quoteIds.add(v);\n    }\n    if (quoteIds.size === 0) return;\n\n    for (const quoteId of quoteIds) {\n      const quote = await api.object('crm_quote').findOne({\n        where: { id: quoteId },\n        fields: ['id', 'status', 'discount', 'tax', 'shipping_handling'],\n      });\n      if (!quote) continue;\n      const status = typeof quote.status === 'string' ? quote.status : undefined;\n      if (status === 'accepted' || status === 'expired') continue;\n\n      const lines = await api.object('crm_quote_line_item').find({\n        where: { crm_quote: quoteId },\n        fields: ['quantity', 'unit_price', 'discount'],\n        top: 5000,\n      });\n      // No lines left \u2192 leave the flow-seeded totals as-is (see design note).\n      if (!lines || lines.length === 0) continue;\n\n      let subtotal = 0;\n      for (const l of lines) subtotal += num(l.quantity) * num(l.unit_price) * (1 - num(l.discount) / 100);\n      subtotal = Math.round(subtotal * 100) / 100;\n\n      const discountAmount = Math.round(subtotal * (num(quote.discount) / 100) * 100) / 100;\n      const total = Math.round((subtotal - discountAmount + num(quote.tax) + num(quote.shipping_handling)) * 100) / 100;\n\n      await api.object('crm_quote').update(\n        { id: quoteId, subtotal, discount_amount: discountAmount, total_price: total },\n        { where: { id: quoteId } },\n      );\n    }\n  },\n};\n\nexport default [quoteLineItemPriceFill, quoteLineItemNumbering, quoteTotalRollup];\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/marketing/objects/campaign.hook.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/marketing/objects\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/marketing/objects/campaign.hook.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport type { Hook, HookContext } from '@objectstack/spec/data';\nimport type { HookApi } from '../../sales/objects/_hook-api';\n\n/**\n * Campaign lifecycle hooks.\n *\n * - `campaign_validation` \u2014 start/end date ordering, and no `in_progress`\n *   without both dates.\n * - `campaign_metrics_refresh` \u2014 recompute the metric block when the campaign's\n *   own status moves.\n * The other two hooks of this family are attached to objects the SALES package\n * owns, so since the ADR-0130 layout they sit beside those objects instead\n * (plan item 6 \u2014 co-location is what enforces R4):\n *\n * - `campaign_attribution_refresh` (`crm_opportunity`) \u2014\n *   `src/sales/objects/opportunity.campaign-metrics.hook.ts`\n * - `campaign_lead_conversion_refresh` (`crm_lead`) \u2014\n *   `src/sales/objects/lead.campaign-metrics.hook.ts`\n *\n * The membership side of the same recompute lives in `campaign_member.hook.ts`.\n * Together these are what replaced the single completion-time snapshot (#597):\n * every input a campaign metric derives from now has a trigger that refreshes\n * the metric when it changes, so a LIVE campaign reports live numbers instead\n * of zeros until the day it ends.\n *\n * \u26A0\uFE0F WHY THE RECOMPUTE IS WRITTEN OUT FOUR TIMES.\n *\n * L2 hook bodies are lowered to metadata and evaluated BODY-ONLY in the QuickJS\n * sandbox: a handler cannot reach module scope at runtime, so a shared\n * `refreshCampaignMetrics()` import would be a free identifier \u2014 the CLI build\n * silently declines to lower the handler, keeps it in a bundled runtime file,\n * and the hook stops being deployable as pure metadata (the build says so in\n * one line nobody reads). `test/action-sandbox.test.ts` is what catches it.\n *\n * So the arithmetic is inlined per handler, the same way `account_protection`\n * inlines the territory table rather than importing `_territory.ts`. The\n * duplication is NOT trusted: `test/campaign-member-lifecycle.test.ts` lowers\n * all four bodies and asserts the recompute block is character-identical across\n * them, so a fix landing on one copy and skipping three fails a test instead of\n * shipping four definitions of `num_sent`. Splitting the four across three\n * files by owning object changed none of that \u2014 the suite reads them by hook\n * name, not by file.\n */\n\nconst campaignValidation: Hook = {\n  name: 'campaign_validation',\n  object: 'crm_campaign',\n  events: ['beforeInsert', 'beforeUpdate'],\n  priority: 200,\n  description: 'Validate campaign date range and required fields per status.',\n  handler: async (ctx: HookContext) => {\n    // The refusal envelope (#1075). Mirrored from `src/sales/objects/_refusal.ts` because a\n    // lowered body has no module scope and `extractHookBody` THROWS on an\n    // import; `test/refusal-envelope.test.ts` pins every copy against it.\n    function refuse(\n      message: string,\n      code: string,\n      status: number,\n      userMessage: string = message,\n    ): Error {\n      const err = new Error(message) as Error & {\n        code: string;\n        status: number;\n        userMessage: string;\n      };\n      err.code = code;\n      err.status = status;\n      err.userMessage = userMessage;\n      return err;\n    }\n    const { input } = ctx;\n    const previous = ctx.previous;\n    const start =\n      (typeof input.start_date === 'string' && input.start_date) ||\n      (typeof previous?.start_date === 'string' && (previous.start_date as string)) ||\n      undefined;\n    const end =\n      (typeof input.end_date === 'string' && input.end_date) ||\n      (typeof previous?.end_date === 'string' && (previous.end_date as string)) ||\n      undefined;\n    if (start && end && start > end) {\n      throw refuse(`Campaign start_date (${start}) must not be after end_date (${end}).`, 'VALIDATION_FAILED', 400);\n    }\n    const status =\n      (typeof input.status === 'string' && input.status) ||\n      (typeof previous?.status === 'string' && (previous.status as string)) ||\n      undefined;\n    if (status === 'in_progress' && (!start || !end)) {\n      throw refuse('Campaign cannot move to in_progress without both start_date and end_date.', 'VALIDATION_FAILED', 400);\n    }\n  },\n};\n\n/**\n * Recompute this campaign's metrics when its own status moves.\n *\n * \u26A0\uFE0F RECURSION. This hook writes to the object it listens on, so its trigger\n * has to be a condition its own write cannot satisfy. It is: the write carries\n * the metric block and nothing else, and this fires only on a `status`\n * TRANSITION \u2014 `input.status` present AND different from `previous.status`. A\n * metric-only write has no `status` key at all, so the re-entry ends at the\n * first guard. `CAMPAIGN_METRIC_WRITE_KEYS` at the bottom of this file states\n * the other half of that contract as data the runtime test checks the recorded\n * write against, so a future writer that adds a non-metric key to the refresh\n * write fails a test instead of looping in production.\n *\n * The old `campaign_snapshot_metrics` fired on `\u2192 completed` and nothing else,\n * which meant a campaign reported zeros for its entire useful life and became\n * accurate on the day everybody stopped looking at it. Completion is now simply\n * one of the transitions this catches.\n */\nconst campaignMetricsRefresh: Hook = {\n  name: 'campaign_metrics_refresh',\n  object: 'crm_campaign',\n  events: ['afterUpdate'],\n  priority: 800,\n  async: true,\n  onError: 'log',\n  description: 'Recompute the campaign metric block whenever the campaign status moves.',\n  handler: async (ctx: HookContext) => {\n    const { input } = ctx;\n    const previous = ctx.previous;\n    // The recursion guard, stated positively: only a status TRANSITION runs.\n    if (typeof input.status !== 'string') return;\n    if (previous && input.status === previous.status) return;\n    const api = ctx.api as HookApi | undefined;\n    if (!api) return;\n    const campaignId =\n      (typeof input.id === 'string' && input.id) ||\n      (typeof previous?.id === 'string' ? (previous.id as string) : '');\n    if (!campaignId) return;\n    for (const id of [campaignId]) {\n      // \u2500\u2500 recompute \u2500\u2500 identical in all four refresh hooks; see the header.\n      const memberRows = await api.object('crm_campaign_member').find({\n        where: { crm_campaign: id }, fields: ['crm_lead', 'status'], top: 5000,\n      });\n      const leadIds = Array.from(new Set(\n        memberRows.map((r) => (typeof r.crm_lead === 'string' ? r.crm_lead : '')).filter(Boolean),\n      ));\n      const convertedLeads = leadIds.length > 0\n        ? await api.object('crm_lead').count({ where: { id: { $in: leadIds }, is_converted: true } })\n        : 0;\n      const numOpportunities = await api.object('crm_opportunity').count({ where: { crm_campaign: id } });\n      const numWon = await api.object('crm_opportunity').count({ where: { crm_campaign: id, stage: 'closed_won' } });\n      const wonRows = await api.object('crm_opportunity').find({\n        where: { crm_campaign: id, stage: 'closed_won' }, fields: ['amount'], top: 5000,\n      });\n      const actualRevenue = wonRows.reduce(\n        (sum, row) => sum + (typeof row.amount === 'number' ? row.amount : Number(row.amount) || 0), 0,\n      );\n      await api.object('crm_campaign').update({\n        id,\n        num_sent: memberRows.length,\n        num_responses: memberRows.filter((r) => r.status === 'responded' || r.status === 'converted').length,\n        num_leads: leadIds.length,\n        num_converted_leads: convertedLeads,\n        num_opportunities: numOpportunities,\n        num_won_opportunities: numWon,\n        actual_revenue: actualRevenue,\n      }, { where: { id } });\n      // \u2500\u2500 /recompute \u2500\u2500\n    }\n  },\n};\n\n/**\n * The metric block these hooks own. Nothing else may write these columns.\n *\n * Module scope, deliberately OUTSIDE every handler: this is read by the tests,\n * never by a sandboxed body \u2014 a body that referenced it would stop lowering\n * (see the header).\n */\nexport const CAMPAIGN_METRIC_FIELDS: readonly string[] = [\n  'num_sent',\n  'num_responses',\n  'num_leads',\n  'num_converted_leads',\n  'num_opportunities',\n  'num_won_opportunities',\n  'actual_revenue',\n];\n\n/**\n * The recursion contract of `campaign_metrics_refresh`, asserted rather than\n * described: the refresh write may carry the metric block and `id`, nothing\n * else. A comment cannot fail; this is checked against the recorded write.\n */\nexport const CAMPAIGN_METRIC_WRITE_KEYS: readonly string[] = ['id', ...CAMPAIGN_METRIC_FIELDS];\n\nexport default [campaignValidation, campaignMetricsRefresh];\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/marketing/objects/campaign_member.hook.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/marketing/objects\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/marketing/objects/campaign_member.hook.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport type { Hook, HookContext } from '@objectstack/spec/data';\nimport type { HookApi } from '../../sales/objects/_hook-api';\n\n/**\n * Campaign member hooks \u2014 the writers that make the trimmed lifecycle honest\n * (#597).\n *\n * `crm_campaign_member` was the app's clearest case of declared-but-inert\n * metadata: a seven-value engagement lifecycle and two tracker stamps, with the\n * enrollment flow writing `sent` and nothing writing anything else, ever. The\n * object trim removed the values no writer could reach; these three hooks are\n * the other half of that trade \u2014 they give every value that SURVIVED a writer\n * that actually runs.\n *\n * - `campaign_member_lifecycle` (before) \u2014 keeps `has_responded` /\n *   `response_date` in lockstep with `status`, whichever end a caller writes.\n * - `campaign_member_optout_sync` (after) \u2014 round-trips `unsubscribed` to the\n *   member's lead/contact `email_opt_out`.\n * - `campaign_member_metrics_refresh` (after) \u2014 recomputes the campaign's\n *   metric block on every membership change, which is what makes a live\n *   campaign show live numbers.\n *\n * \u26A0\uFE0F The recompute block below is written out here and three more times in\n * `campaign.hook.ts`, deliberately: a sandboxed hook body cannot reach module\n * scope, so a shared import would stop the handler lowering to metadata (see\n * that file's header for the full reasoning). All four copies are asserted\n * character-identical by `test/campaign-member-lifecycle.test.ts`.\n */\n\n/**\n * Keep the response summary fields honest, on every write path.\n *\n * There are two ways a member becomes \"responded\" and they must not disagree:\n * the `mark_responded` action (which stamps all three fields itself) and a rep\n * flipping `status` on the record detail page (which stamps only `status`). The\n * second path is why this hook exists \u2014 without it, a hand-flipped member reads\n * `Responded` on the status badge and `Has Responded: false` two rows below it,\n * and `test/seed-consistency.test.ts`'s \"track the responded status exactly\"\n * contract holds for seeded rows while runtime rows drift out of it.\n *\n * `converted` counts as responded too: a member cannot convert without having\n * responded first, and `has_responded` is the \"did this person ever engage\"\n * flag the response surfaces filter on.\n */\nconst campaignMemberLifecycle: Hook = {\n  name: 'campaign_member_lifecycle',\n  object: 'crm_campaign_member',\n  events: ['beforeInsert', 'beforeUpdate'],\n  priority: 200,\n  description: 'Keep has_responded / response_date in lockstep with the member status.',\n  handler: async (ctx: HookContext) => {\n    // D3 stand-down: a predicate update has ONE payload for every matched row,\n    // so the `ctx.previous`-conditioned writes below would land on rows that\n    // did not earn them \u2014 refused as a diverging key set, or stored silently\n    // from the last row. Full account and the measurement: `forecast.hook.ts`.\n    if (ctx.event === 'beforeUpdate' && ctx.dispatch?.mode === 'per-row') return;\n\n    const { input } = ctx;\n    const previous = ctx.previous;\n    const status =\n      (typeof input.status === 'string' && input.status) ||\n      (typeof previous?.status === 'string' ? (previous.status as string) : undefined);\n    if (!status) return;\n\n    // The responded set is spelled INLINE, not lifted to a module constant: a\n    // sandboxed body cannot reach module scope, and a handler that reads one\n    // stops lowering to metadata (see `campaign.hook.ts`'s header).\n    const responded = status === 'responded' || status === 'converted';\n    const priorStatus = typeof previous?.status === 'string' ? (previous.status as string) : '';\n    const wasResponded = priorStatus === 'responded' || priorStatus === 'converted';\n\n    if (responded) {\n      input.has_responded = true;\n      // Stamp a response date only when the member is CROSSING into a responded\n      // state and does not already carry one. Re-stamping on every later edit\n      // would quietly move the response date forward each time somebody touched\n      // the row, and response-time reporting reads this column.\n      const existing = input.response_date ?? previous?.response_date;\n      if (!wasResponded && (existing === undefined || existing === null || existing === '')) {\n        input.response_date = new Date().toISOString();\n      }\n      return;\n    }\n\n    // Moving BACK out of a responded state (a mis-click corrected, or a member\n    // reset to `sent` for a re-send) clears the summary with it. Leaving\n    // `has_responded: true` behind on a `sent` member is the same disagreement\n    // in the other direction, and it inflates nothing visible \u2014 which is\n    // exactly why it would survive review.\n    if (wasResponded && typeof input.status === 'string') {\n      input.has_responded = false;\n      input.response_date = null;\n      return;\n    }\n    if (ctx.event === 'beforeInsert' && input.has_responded === undefined) {\n      input.has_responded = false;\n    }\n  },\n};\n\n/**\n * Round-trip `unsubscribed` to the person's `email_opt_out`.\n *\n * This closes a loop the app already had one half of: `campaign_enrollment`\n * filters on `email_opt_out: false`, and the `send_email` action hides itself\n * on an opted-out contact \u2014 but NOTHING ever set the flag, so honouring it was\n * a promise about a column no user action could reach. Unsubscribing a member\n * marked the junction row and left the person enrollable by the very next\n * campaign, which is the failure mode an opt-out exists to prevent.\n *\n * Deliberately one-directional: member `unsubscribed` \u21D2 person opted out.\n * The reverse (person opts out \u21D2 close their open memberships) is NOT done\n * here \u2014 a past campaign's membership is a historical record, and rewriting it\n * would falsify what happened at the time.\n *\n * `async` + `onError: 'log'`: the member write is the user's action and must\n * not fail because the lead row is locked or gone. A missed sync is recovered\n * by the next unsubscribe; a rejected write loses the unsubscribe itself.\n *\n * `runAs: 'system'` (#2014, AGENTS.md rule 9). Members are worked by\n * marketing, and a contact is a master-detail child of its account, which a\n * marketing user may not edit \u2014 so the contact write was refused (\"requires\n * edit access to its master record\"), logged and swallowed, and the person\n * stayed enrollable by the next campaign. An unsubscribe has to reach the\n * person whoever recorded it, so the hook elevates; the member write stays the\n * caller's, and `updated_by` on the person still names them. Organization\n * (rule 10): it writes only the lead / contact the triggering member row\n * names, and the elevated `ctx.api` keeps the trigger's tenant.\n */\nconst campaignMemberOptOutSync: Hook = {\n  name: 'campaign_member_optout_sync',\n  object: 'crm_campaign_member',\n  events: ['afterInsert', 'afterUpdate'],\n  priority: 300,\n  async: true,\n  onError: 'log',\n  runAs: 'system',\n  description: 'Sync an unsubscribed member back to the lead/contact email_opt_out flag.',\n  handler: async (ctx: HookContext) => {\n    const api = ctx.api as HookApi | undefined;\n    if (!api) return;\n    const { input } = ctx;\n    const previous = ctx.previous;\n    if (input?.status !== 'unsubscribed') return;\n    // Already unsubscribed \u21D2 already synced. Re-running would be harmless\n    // (the write is idempotent) but it would also re-open a row on every\n    // unrelated edit of an unsubscribed member.\n    if (previous?.status === 'unsubscribed') return;\n\n    const leadId =\n      (typeof input?.crm_lead === 'string' && input.crm_lead) ||\n      (typeof previous?.crm_lead === 'string' ? (previous.crm_lead as string) : undefined);\n    const contactId =\n      (typeof input?.crm_contact === 'string' && input.crm_contact) ||\n      (typeof previous?.crm_contact === 'string' ? (previous.crm_contact as string) : undefined);\n\n    // Exactly one of the two is set \u2014 `lead_or_contact_required` on the object\n    // guarantees at least one, and the enrollment writers never set both. Both\n    // branches run anyway rather than an if/else, so a row that somehow carries\n    // both still opts out both people instead of half of them.\n    if (leadId) {\n      await api.object('crm_lead').update(\n        { id: leadId, email_opt_out: true },\n        { where: { id: leadId } },\n      );\n    }\n    if (contactId) {\n      await api.object('crm_contact').update(\n        { id: contactId, email_opt_out: true },\n        { where: { id: contactId } },\n      );\n    }\n  },\n};\n\n/**\n * Recompute the campaign's metric block on every membership change.\n *\n * THIS is the hook the \"metrics are live\" acceptance criterion rests on:\n * enrolling a member, marking one responded, or removing one moves\n * `num_sent` / `num_responses` / `num_leads` / `num_converted_leads`\n * immediately \u2014 no waiting for the campaign to reach `completed`, which is\n * what the removed `campaign_snapshot_metrics` made everyone wait for.\n *\n * Both sides on update: moving a member between campaigns has to decrement the\n * old campaign as well as increment the new one.\n *\n * No loop: this writes `crm_campaign`, and the campaign-side refresh only fires\n * on a `status` transition, which a metric-only write does not carry.\n *\n * `runAs: 'system'` (#2014, AGENTS.md rule 9). A rollup must not depend on who\n * fired it. Run as a marketing user, the recompute counted only the deals that\n * user may see \u2014 a Private won deal is its owner's alone \u2014 and wrote the\n * smaller numbers over the right ones: measured, `num_won_opportunities` 2 \u2192 1\n * and `actual_revenue` 1,100 \u2192 100 the moment a marketer enrolled a member.\n * Elevated, every member write recomputes the same campaign the same way; the\n * member write itself stays the caller's. Organization (rule 10): every read\n * is keyed to the triggering member's campaign (and the leads that campaign's\n * members name), and the elevated `ctx.api` keeps the trigger's tenant.\n */\nconst campaignMemberMetricsRefresh: Hook = {\n  name: 'campaign_member_metrics_refresh',\n  object: 'crm_campaign_member',\n  events: ['afterInsert', 'afterUpdate', 'afterDelete'],\n  priority: 800,\n  async: true,\n  onError: 'log',\n  runAs: 'system',\n  description: 'Recompute the campaign metric block live whenever its membership changes.',\n  handler: async (ctx: HookContext) => {\n    const api = ctx.api as HookApi | undefined;\n    if (!api) return;\n    const { input } = ctx;\n    const previous = ctx.previous;\n    const campaignIds = Array.from(new Set([\n      typeof input?.crm_campaign === 'string' ? input.crm_campaign : '',\n      typeof previous?.crm_campaign === 'string' ? (previous.crm_campaign as string) : '',\n    ].filter(Boolean)));\n    for (const id of campaignIds) {\n      // \u2500\u2500 recompute \u2500\u2500 identical in all four refresh hooks; see the header.\n      const memberRows = await api.object('crm_campaign_member').find({\n        where: { crm_campaign: id }, fields: ['crm_lead', 'status'], top: 5000,\n      });\n      const leadIds = Array.from(new Set(\n        memberRows.map((r) => (typeof r.crm_lead === 'string' ? r.crm_lead : '')).filter(Boolean),\n      ));\n      const convertedLeads = leadIds.length > 0\n        ? await api.object('crm_lead').count({ where: { id: { $in: leadIds }, is_converted: true } })\n        : 0;\n      const numOpportunities = await api.object('crm_opportunity').count({ where: { crm_campaign: id } });\n      const numWon = await api.object('crm_opportunity').count({ where: { crm_campaign: id, stage: 'closed_won' } });\n      const wonRows = await api.object('crm_opportunity').find({\n        where: { crm_campaign: id, stage: 'closed_won' }, fields: ['amount'], top: 5000,\n      });\n      const actualRevenue = wonRows.reduce(\n        (sum, row) => sum + (typeof row.amount === 'number' ? row.amount : Number(row.amount) || 0), 0,\n      );\n      await api.object('crm_campaign').update({\n        id,\n        num_sent: memberRows.length,\n        num_responses: memberRows.filter((r) => r.status === 'responded' || r.status === 'converted').length,\n        num_leads: leadIds.length,\n        num_converted_leads: convertedLeads,\n        num_opportunities: numOpportunities,\n        num_won_opportunities: numWon,\n        actual_revenue: actualRevenue,\n      }, { where: { id } });\n      // \u2500\u2500 /recompute \u2500\u2500\n    }\n  },\n};\n\nexport default [\n  campaignMemberLifecycle,\n  campaignMemberOptOutSync,\n  campaignMemberMetricsRefresh,\n];\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/sales/flows/lead-conversion.flow.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/sales/flows\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/sales/flows/lead-conversion.flow.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport { P, cel } from '@objectstack/spec';\nimport type * as Automation from '@objectstack/spec/automation';\ntype Flow = Automation.Flow;\n\n/** Lead Conversion \u2014 multi-step screen flow to convert qualified leads */\nexport const LeadConversionFlow: Flow = {\n  name: 'lead_conversion',\n  label: 'Lead Conversion Process',\n  description: 'Automated flow to convert qualified leads to accounts, contacts, and opportunities',\n  type: 'screen',\n  status: 'active',\n\n  variables: [\n    // Named `recordId` to match the console's flow-action invocation contract:\n    // POST /automation/:name/trigger sends { recordId, objectName } and the\n    // dispatcher exposes them as params.recordId / params.crmLeadId. A custom\n    // name like `leadId` never gets seeded (16.x runtime).\n    { name: 'recordId', type: 'text', isInput: true, isOutput: false },\n    // THE authority for the conversion default. `defaultValue` is what makes\n    // declared mean BOUND: the engine seeds every declared variable that\n    // carries one before the run starts, so `createOpportunity` is bound on\n    // every path \u2014 including the one where the screen runner posts back only\n    // the fields the user touched. The screen field below derives its prefill\n    // from this line rather than restating `false`.\n    //\n    // Measured on 17.0.0 GA, by running flows (not by reading the engine):\n    //   \u00B7 declared + nothing supplied  \u2192 bound to `false`; ablating this key\n    //     from the declaration re-fails the read with `No such key:\n    //     createOpportunity`, so the default is what binds it;\n    //   \u00B7 seeded BEFORE the start condition is evaluated, so a start condition\n    //     could read it too;\n    //   \u00B7 a caller-supplied `context.params.createOpportunity` WINS \u2014 the\n    //     boundary is `!== undefined`, so an explicit `false`/`null` is a\n    //     supplied answer, and only absence falls through to this default.\n    // \u26D4 Never seed this with an assignment node instead: an assignment is\n    // unconditional and clobbers a caller-supplied value. All of the above is\n    // pinned in `test/flow-variable-conditions.test.ts`.\n    { name: 'createOpportunity', type: 'boolean', isInput: true, isOutput: false, defaultValue: false },\n    { name: 'opportunityName', type: 'text', isInput: true, isOutput: false },\n    { name: 'opportunityAmount', type: 'text', isInput: true, isOutput: false },\n    // The conversion's close date, collected on the screen below\n    // instead of stamped inside `create_opportunity`. Declared with NO\n    // `defaultValue`, and that is measured rather than chosen: the engine\n    // binds a DECLARATION's default raw \u2014 `seedDeclaredVariables` does a plain\n    // `variables.set(name, defaultValue)` with no `interpolate` call \u2014 so\n    // `{TODAY() + 90}` written here would bind that string verbatim and\n    // `create_opportunity` would post the braces into a date column. Measured\n    // on 17.3.0 by running a probe flow, not by reading the engine. The screen\n    // field is therefore the only layer that can carry the expression, which\n    // is where the +90 lives and why this line is deliberately bare.\n    { name: 'closeDate', type: 'date', isInput: true, isOutput: false },\n  ],\n\n  nodes: [\n    { id: 'start', type: 'start', label: 'Start', config: { objectName: 'crm_lead' } },\n    {\n      id: 'screen_1', type: 'screen', label: 'Conversion Details',\n      config: {\n        // The suspected-duplicate warning. `lead_duplicate_check` flags a\n        // re-captured email at intake and links the record the lead repeats;\n        // the rep about to CONVERT is the last moment that flag is worth\n        // anything, and without it the duplicate becomes a second account,\n        // contact and opportunity.\n        //\n        // \u26D4 Not on `convert_lead`'s `confirmText`: that string is static and\n        // unconditional, so it would warn identically on every clean lead \u2014 the\n        // cry-wolf that makes a confirm dialog furniture. This screen is where\n        // the conversion decision is actually taken, and the one surface that\n        // can say something TRUE about THIS lead.\n        //\n        // Mechanism: the executor renders `config.description` \u2014 a text slot,\n        // written as a `{{ }}` hole since 18.0.0-next.0 \u2014 into the `ScreenSpec`\n        // it puts on the wire, and `FlowRunner.tsx` renders it \u2014\n        // `{screen.description && <DialogDescription>\u2026}`. A hole over `null`\n        // renders the empty string, which the executor's `renderTextSlot`\n        // turns into no description at all (read in the installed\n        // 18.0.0-next.0 `service-automation`; on the 17.1.0 bundles it was\n        // measured as `interp` mapping null to `undefined`), so the clean-lead\n        // branch below (which assigns `null`) renders NO description rather\n        // than an empty paragraph. That is why the conditionality lives in an\n        // assignment and not in the copy: a screen `description` has no\n        // `visibleWhen`.\n        description: '{{duplicateWarning}}',\n        // `visibleWhen` on a screen field is BARE CEL over the screen's own\n        // field names \u2014 not the CEL value envelopes the rest of this flow uses\n        // for filters and `update_record` fields, evaluated on the server. The\n        // client re-evaluates the predicate against the values collected so far,\n        // which is why it cannot be a server-evaluated envelope.\n        fields: [\n          // \u26D4 NEVER `required` on a boolean screen field. A checkbox has no\n          // unanswered state \u2014 clear IS an answer, and \"convert this lead\n          // WITHOUT an opportunity\" is the commonest path. `required: true`\n          // blocks on both sides of the wire: the client counts the untouched\n          // box as an unanswered field and disables Submit, and from\n          // 17.0.0-rc.2 the SERVER enforces the screen's declared contract too,\n          // refusing the resume with `INVALID_SCREEN_INPUT: Screen field\n          // \"createOpportunity\" is required` \u2014 so a runner that posts only what\n          // the user touched cannot convert a lead at all. The variable's\n          // declared `defaultValue` is what supplies the answer.\n          //\n          // DERIVED, not restated. The envelope reads the flow variable\n          // `createOpportunity`, so the literal `false` is written exactly once in this\n          // file \u2014 on the declaration \u2014 and the widget prefill cannot drift from\n          // the value the engine binds.\n          //\n          // A screen field's `defaultValue` is a CEL value envelope evaluated\n          // before the descriptor goes on the wire, so the client receives the\n          // value, never the envelope: boolean `false`, which is what the\n          // 17.0.0 GA template was measured to send. (`visibleWhen` below is the\n          // opposite case: forwarded raw, never evaluated on the server. Same\n          // node, two different dialects.)\n          { name: 'createOpportunity', label: 'Create Opportunity?', type: 'boolean', defaultValue: cel`createOpportunity` },\n          // PREFILLED FROM THE LEAD (REQ-0005 acceptance 2). Both defaults are\n          // CEL envelopes over `leadRecord`, which `get_lead` bound before this\n          // screen was reached \u2014 the fetch sits AHEAD of the screen for the\n          // duplicate warning, and these two ride the same ordering.\n          //\n          // \u26A0\uFE0F Each envelope is evaluated before the descriptor goes on the\n          // wire, so `estimated_amount` arrives as a NUMBER. `company` is\n          // required on a lead; `estimated_amount` is not, so its read is\n          // guarded: a lead with no estimate is served `null` where 17.x served\n          // nothing (the migration entry: a field's `defaultValue` seeds the\n          // field with null), and an ABSENT column on a sparse datasource no\n          // longer fails the run at this screen.\n          //\n          // \u26D4 The amount is prefilled, never copied silently. `estimated_amount`\n          // is a pre-qualification guess and `crm_opportunity.amount` is a\n          // number a rep defends in a forecast; conversion is the moment a human\n          // turns one into the other, so the figure is shown in an editable box\n          // and the rep confirms it. Writing it straight into\n          // `create_opportunity` would put an unreviewed estimate into the\n          // forecast and leave the two fields looking like copies of each other.\n          //\n          // `required` on the amount mirrors the column, for the reason given\n          // at `closeDate` below: `crm_opportunity.amount` is `required` +\n          // `notNull`, and without this a ticked box with no amount reached\n          // `create_opportunity` after the account and contact were written,\n          // leaving the lead half-converted (#2060 item 2). Visible-only, so\n          // an unticked box still converts with no amount.\n          { name: 'opportunityName', label: 'Opportunity Name', type: 'text', required: true, defaultValue: cel`leadRecord.company`, visibleWhen: 'createOpportunity == true' },\n          { name: 'opportunityAmount', label: 'Opportunity Amount', type: 'currency', required: true, defaultValue: cel`has(leadRecord.estimated_amount) ? leadRecord.estimated_amount : null`, visibleWhen: 'createOpportunity == true' },\n          // The close date, DEFAULTED AND VISIBLE. `close_date` is what files\n          // an opportunity into a forecast PERIOD, so \u26D4 never stamp it silently\n          // inside `create_opportunity`: a hidden +90 days files every converted\n          // deal a quarter out and moves the forecast where nobody can see it.\n          //\n          // The +90 is written HERE and nowhere else, and here the layer is\n          // FORCED rather than preferred. A screen field's `defaultValue` is\n          // evaluated before the descriptor goes on the wire and a flow\n          // variable's default is bound raw (see the declaration above), so this\n          // is the only place the expression can be written at all.\n          // `isoDate(daysFromNow(90))` writes the `YYYY-MM-DD` string 90 days out\n          // on the UTC calendar \u2014 what 17.3.0's `{TODAY() + 90}` was measured to\n          // send \u2014 and the value the rep sees is the value\n          // `create_opportunity` writes.\n          //\n          // `required` mirrors the column \u2014 `crm_opportunity.close_date` is\n          // `required` + `notNull` \u2014 and it is what keeps the refusal at the\n          // SCREEN boundary. Measured both ways against a real ObjectQL engine:\n          // WITHOUT it, a submission carrying no date reaches\n          // `create_opportunity` and fails there with `Close Date is required`,\n          // by which point the account and the contact have already been\n          // written and the lead is left half-converted; WITH it the resume is\n          // refused before any node runs, nothing is written, and the message\n          // names the field. That path is not hypothetical \u2014 a rep who CLEARS\n          // the prefilled date posts the key empty, and `isPresent('')` is\n          // false. A hidden `required` never fires: the server contract skips it\n          // when `visibleWhen` evaluates false, and so does the console, which\n          // is the untouched-checkbox path this screen has always had to keep\n          // working.\n          { name: 'closeDate', label: 'Close Date', type: 'date', required: true, defaultValue: cel`isoDate(daysFromNow(90))`, visibleWhen: 'createOpportunity == true' },\n        ],\n      },\n    },\n    {\n      // \u26D4 This fetch must stay AHEAD of the screen: the duplicate warning\n      // reads `leadRecord`, and a screen that suspends before the fetch has\n      // nothing to read. The fetch itself never depended on the screen \u2014\n      // `recordId` is an input variable, seeded before the run starts.\n      id: 'get_lead', type: 'get_record', label: 'Get Lead Record',\n      config: { objectName: 'crm_lead', filter: { id: cel`recordId` }, outputVariable: 'leadRecord' },\n    },\n    {\n      // Branching is on edges `e21` / `e22` / `e25` \u2014 see `decision_account`.\n      // Three ways out, because `duplicate_status` carries two different KINDS\n      // of fact and they get different answers: the machine's `suspected` guess\n      // warns and lets the rep decide (`e21`), a person's `confirmed` verdict\n      // refuses outright (`e25`), and everything else converts silently (`e22`).\n      id: 'decision_duplicate', type: 'decision', label: 'Duplicate Verdict?',\n    },\n    {\n      // The warning names the record the way the UI names a person \u2014 by the\n      // email address the two records share \u2014 and NOT by\n      // `duplicate_of_lead` / `duplicate_of_contact`, which hold ids. That is\n      // the house rule `test/record-id-not-in-prose.test.ts` states for every\n      // sentence a user reads: \"the id goes in the relationship field that\n      // exists to carry it, or nowhere\". The link itself is on the lead's\n      // record page (`lead_detail.page.ts`), where it can be clicked.\n      //\n      // \"flagged at intake\" is the app's own published definition of this\n      // value, not a guess about provenance: `duplicate_status`'s help text\n      // reads \"Suspected = flagged automatically at intake\" in all four\n      // locales, and `lead_duplicate_check` is insert-only by design.\n      //\n      // This warning's TEXT is English-only: it is the value of a variable,\n      // and no locale pack reaches a variable \u2014 the screen's translated\n      // `description` can only carry the `{{duplicateWarning}}` hole that\n      // shows it. The screens' own headings and bodies are keyed in the packs\n      // (`flows.lead_conversion` in `src/sales/translations/<locale>/app.ts`),\n      // and the banner on the record page carries the warning in all four.\n      id: 'warn_duplicate', type: 'assignment', label: 'Compose Duplicate Warning',\n      config: {\n        assignments: {\n          duplicateWarning:\n            cel`'Suspected duplicate \u2014 intake flagged this lead as repeating an existing record with this email address (' + leadRecord.email + '). Converting creates a second account, contact and opportunity for the same buyer; compare the linked record on the lead page before you continue.'`,\n        },\n      },\n    },\n    {\n      // The other branch assigns `null`, which is what makes the warning\n      // CONDITIONAL: the description hole renders it as no description at\n      // all (see `screen_1`). Same shape as `no_opportunity` below \u2014 both branches\n      // write the variable so no downstream read ever meets an unset one.\n      id: 'no_duplicate_warning', type: 'assignment', label: 'No Duplicate Warning',\n      config: { assignments: { duplicateWarning: null } },\n    },\n    {\n      // The REFUSAL. A `confirmed` duplicate is a person's verdict, and the app\n      // stops converting on it \u2014 the rule AGENTS.md states as \"interception\n      // stands on a person's judgement\". `suspected` keeps the warn-and-allow\n      // above: a machine's guess stays advisory, because `lead_duplicate_check`\n      // matches on email EQUALITY and a shared inbox (`info@`, a switchboard\n      // address) false-positives by construction. \u26D4 Do not block on the guess \u2014\n      // it would need an override flag to stay usable, and an override flag is\n      // the one shape this exhibit must not demonstrate.\n      //\n      // ## Why the refusal is HERE and not on `convert_lead`'s predicate\n      //\n      // A refusal must NAME the verdict and the surviving record, and measured\n      // against `@objectstack/spec` 17.2.0 the action predicates cannot:\n      // `visible` and `disabled` are each a bare boolean/CEL envelope with\n      // nowhere to put a sentence, so `visible` hides a button that cannot then\n      // explain itself and `disabled` greys one out with no reason attached.\n      // `errorMessage` on the Action is a single static string \u2014 what the\n      // console toasts on a FAILED run \u2014 and cannot say anything about THIS\n      // lead. A screen node's `description` is a text slot rendered per run\n      // and shown by `FlowRunner` as the dialog body.\n      //\n      // The flow is also the only choke point covering every door: the\n      // record-header button, the list-row button and the `action_convert_lead`\n      // AI tool all dispatch `POST /automation/lead_conversion/trigger`, while\n      // `visible` / `disabled` are console-side and say nothing to the other\n      // two.\n      //\n      // ## What the rep sees, measured on the shipped console bundle\n      //\n      // A run that PAUSES returns `{ success: true, silent: true }` to the\n      // action framework (`RecordDetailView`'s flow handler), and `silent`\n      // suppresses the success toast \u2014 so `convert_lead`'s\n      // `successMessage: 'Lead converted successfully!'` does NOT fire behind\n      // this dialog. Submitting it resumes into `end`; nothing is created and\n      // the lead is untouched on either path, because every write in this flow\n      // is downstream of `screen_1`.\n      //\n      // ## What the copy may claim\n      //\n      // \u26D4 NOT the shared email address, which is what `warn_duplicate` above\n      // uses. That claim is safe for `suspected` because only\n      // `lead_duplicate_check` writes it and it matches on email; `confirmed`\n      // is written by a PERSON, and the lead form lets a reviewer point\n      // `duplicate_of_type` + its lookup at any record they like. So the\n      // refusal names the survivor through the relationship fields that exist\n      // to carry it (`test/record-id-not-in-prose.test.ts`: \"the id goes in the\n      // relationship field that exists to carry it, or nowhere\"), naming the\n      // `duplicates` field group by its shipped label, \"Duplicate Management\".\n      // That sentence also stays true on the `erased` tombstone, where the\n      // verdict survives its pointer (`lead.hook.ts`, job 1c).\n      //\n      // \u26D4 Never transcribe the vocabulary of `duplicate_of_type` into this\n      // sentence (\"an existing Lead\" / \"an existing Contact\"). Those labels are\n      // locale-pack facts with one source of truth, the rep can see them on the\n      // section this line points at, and a hand-copied machine list in prose is\n      // the drift AGENTS.md documentation rule 5 forbids.\n      //\n      // The title and the body are translated in the packs\n      // (`flows.lead_conversion.screens.refuse_confirmed_duplicate`).\n      id: 'refuse_confirmed_duplicate', type: 'screen', label: 'Conversion Refused',\n      config: {\n        title: 'Conversion refused',\n        description:\n          \"This lead's Duplicate Status is Confirmed: a reviewer compared it against an existing record and recorded that it repeats one. Converting would create a second account, contact and opportunity for the same buyer. The Duplicate Management section on this lead names the surviving record; disqualify this lead as a duplicate instead. Only a reviewer revising that verdict reopens conversion.\",\n        // A message-only screen: no fields, so the pause has to be asked for.\n        // `waitForInput` is what turns a field-less screen from a server-side\n        // pass-through into the dialog the rep reads (the executor's\n        // `shouldPause`), and without it this node would fall through to `end`\n        // in silence \u2014 a refusal nobody is told about.\n        waitForInput: true,\n      },\n    },\n    {\n      // Branching is on edges `e28` / `e29` \u2014 see `decision_account`.\n      id: 'decision_approval', type: 'decision', label: 'Approved for Conversion?',\n    },\n    {\n      // The approval gate, on the surface a REST caller reaches (REQ-0005\n      // acceptance 3). `convert_lead`'s `visible` predicate hides the button and\n      // `lead.hook.ts` refuses the write, but this flow has its own door \u2014\n      // `POST /automation/lead_conversion/trigger` \u2014 and without this branch a\n      // caller through that door would run the whole conversion and only be\n      // refused at `mark_converted`, by which point the account, the contact and\n      // the opportunity have already been written and the lead is left\n      // half-converted. Refusing HERE, ahead of `screen_1`, is what makes the\n      // gate whole: every create and update in this flow sits behind that\n      // screen, and this path never reaches it.\n      id: 'refuse_unapproved', type: 'screen', label: 'Conversion Refused',\n      config: {\n        title: 'Conversion refused',\n        description:\n          \"This lead has not been approved for conversion. An approver has to sign it off before it can become an account, contact and opportunity; the Conversion Approval field on the lead shows whether the decision is still pending or was refused. Keep working the lead in the meantime \u2014 nothing about it is frozen.\",\n        // Field-less screen: `waitForInput` is what turns it from a server-side\n        // pass-through into the dialog the rep reads. See\n        // `refuse_confirmed_duplicate` for the mechanism.\n        waitForInput: true,\n      },\n    },\n    {\n      // Branching is on edges `e31` / `e32` \u2014 see `decision_account`. The\n      // match-key guard sits between the duplicate verdict and `screen_1`, so\n      // it dominates `find_account` and a key-less lead is refused before the\n      // rep fills in the form and before any write. It is the LAST of the\n      // three refusals on purpose: an unapproved lead or a confirmed duplicate\n      // is told that verdict first, and a missing key is a repairable data\n      // gap rather than a verdict.\n      id: 'decision_match_key', type: 'decision', label: 'Company Match Key?',\n    },\n    {\n      // The KEY-LESS refusal (#2017). Why `find_account` must not run without\n      // a key is recorded on that node; this is what the rep reads instead.\n      //\n      // A refusal, not a new account, and that is the flow's own stated intent\n      // rather than a fresh choice: a conversion that stops is far cheaper to\n      // diagnose than one that quietly attaches to the wrong account or\n      // creates a duplicate one, and `screen_1` offers the rep no account\n      // choice that could confirm a match by hand.\n      //\n      // The copy claims only what holds on every path into it: the key is\n      // derived from `company` on every write that carries it\n      // (`lead_duplicate_check`), and nothing has been written, because every\n      // create and update in this flow sits behind `screen_1`. Its title and\n      // body are translated in the packs, like the other two refusals.\n      //\n      // Field-less screen: `waitForInput` is what turns it from a server-side\n      // pass-through into the dialog the rep reads. See\n      // `refuse_confirmed_duplicate` for the mechanism.\n      id: 'refuse_no_match_key', type: 'screen', label: 'Conversion Refused',\n      config: {\n        title: 'Conversion refused',\n        description:\n          \"This lead's company has no match key, so conversion cannot tell which account it belongs to, and it will not guess: a guess could file the contact and opportunity under another customer. Saving the lead's Company rebuilds the key, so save it again, then convert. Nothing has been created.\",\n        waitForInput: true,\n      },\n    },\n    {\n      // Account dedupe: match on the NORMALIZED company name, never on the raw\n      // one \u2014 \"Acme Corp\" and \"ACME  Corp\" are the same account.\n      //\n      // Both sides of this comparison are stored, hook-maintained columns, and\n      // on 17.x that was forced rather than chosen: a flow template could not\n      // normalize ANYTHING. `service-automation`'s `resolveToken` recognises exactly one\n      // function form \u2014 `NOW()` / `TODAY()` \u2014 and every bare identifier in the\n      // expression fallback is substituted before evaluation, so no string\n      // method is reachable either: `{LOWER(x)}`, `{TRIM(x)}` and\n      // `{x.toLowerCase()}` all resolve to `undefined`, and an unwrapped\n      // `LOWER({x})` interpolates literally to \"LOWER(Acme Corp)\". A formula\n      // field is no help either \u2014 it has no physical column to filter on. So\n      // the producer canonicalizes (`account_protection`,\n      // `lead_duplicate_check`) and this node does a plain, indexed equality\n      // match. `test/account-name-normalized-match.test.ts` re-measures all of\n      // that rather than trusting this paragraph.\n      //\n      // Normalize-then-EXACT only: lower + trim + collapse internal\n      // whitespace. Fuzzy matching stays out of scope.\n      //\n      // A lead with NO `company_normalized` never reaches this node:\n      // `decision_match_key`, ahead of `screen_1`, refuses it first. The node\n      // cannot be left to refuse on its own, because \"no key\" arrives in two\n      // shapes that behave differently (both measured on 17.7.0):\n      //\n      //   \u00B7 ABSENT \u2014 a sparse datasource (`driver-memory` / `driver-mongodb`)\n      //     on a row never written with the column. The token resolves to\n      //     nothing and `get_record` refuses to run, so the run FAILS\n      //     (`FLOW_FAILED`, \"refusing to run \u2014 1 filter condition(s) resolved\n      //     to nothing and were dropped from the query \u2026\").\n      //   \u00B7 NULL \u2014 SQL, or any datasource once the column is written empty,\n      //     which `lead_duplicate_check` does on purpose for a company that\n      //     folds to nothing. The token resolves to `null`, and a bare `null`\n      //     in a filter is the platform's documented HAS-NO-VALUE predicate\n      //     (`$eq: null`, `@objectstack/spec` `data/filter.zod.ts`). This\n      //     lookup then MATCHES every account whose own key is null, and the\n      //     lead converts onto an unrelated customer's account (#2017).\n      //\n      // A key-less lead is not only a row written before the producer existed\n      // (the backfill in docs/MAINTENANCE.md \u00A73.3): a non-string company\n      // written through the record API folds to `null` too. A conversion that\n      // stops is far cheaper to diagnose than one that quietly attaches to the\n      // wrong account or creates a duplicate one, so the answer is the\n      // refusal the rep reads in `refuse_no_match_key`.\n      //\n      // Since 18.0.0-next.0 the operand is a CEL envelope: an absent key fails\n      // the run before the query, and a null one refuses the node instead of\n      // matching (the platform's `flow-value-slot-template-dialect-refused`\n      // entry; not re-measured here). Neither shape converts onto another\n      // account any more, and `decision_match_key` still refuses first, with\n      // copy the rep can read.\n      //\n      // \u26D4 Never paper this over with a second, case-sensitive lookup on the\n      // raw `name`: a missing key means the producer could not derive one, and\n      // a tolerant consumer path would hide that while restoring the exact bug\n      // this node exists to fix.\n      id: 'find_account', type: 'get_record', label: 'Find Existing Account',\n      config: { objectName: 'crm_account', filter: { name_normalized: cel`leadRecord.company_normalized` }, outputVariable: 'matchedAccount' },\n    },\n    {\n      // Branching is on edges `e5` / `e6`. No `config.condition` here: a\n      // `decision` node's singular one is never evaluated.\n      id: 'decision_account', type: 'decision', label: 'Account Already Exists?',\n    },\n    {\n      // NEW-account branch. outputVariable is `createdAccount`; the assignment\n      // below normalizes both branches onto a single `accountId` id string so\n      // downstream nodes don't need to know which path ran.\n      //\n      // `name` carries the lead's company VERBATIM \u2014 the display value. The\n      // match key `name_normalized` is deliberately absent: it is readonly and\n      // hook-owned, and `account_protection` derives it from the `name` written\n      // here, so an account created by this node is immediately findable by the\n      // next conversion.\n      id: 'create_account', type: 'create_record', label: 'Create Account',\n      config: {\n        objectName: 'crm_account',\n        fields: {\n          // `company` is required on a lead; every other copied fact is\n          // optional, so its read is guarded to null (an insert treats null as\n          // it treated the key the template left out).\n          name: cel`leadRecord.company`, phone: cel`has(leadRecord.phone) ? leadRecord.phone : null`,\n          website: cel`has(leadRecord.website) ? leadRecord.website : null`,\n          industry: cel`has(leadRecord.industry) ? leadRecord.industry : null`,\n          annual_revenue: cel`has(leadRecord.annual_revenue) ? leadRecord.annual_revenue : null`,\n          number_of_employees: cel`has(leadRecord.number_of_employees) ? leadRecord.number_of_employees : null`,\n          billing_address: cel`has(leadRecord.address) ? leadRecord.address : null`,\n          owner_id: cel`current_user.id`, is_active: true,\n        },\n        outputVariable: 'createdAccount',\n      },\n    },\n    {\n      id: 'use_new_account', type: 'assignment', label: 'Use New Account',\n      config: { assignments: { accountId: cel`createdAccount.id` } },\n    },\n    {\n      id: 'use_existing_account', type: 'assignment', label: 'Reuse Existing Account',\n      config: { assignments: { accountId: cel`matchedAccount.id` } },\n    },\n    {\n      // Contact dedupe by email \u2014 GLOBAL, not per-account. \u26D4 Never scope this\n      // lookup to the account: `crm_contact` carries a global unique index on\n      // `email`, so an account-scoped lookup misses a same-email contact under\n      // another account and `create_contact` then explodes on the DB index\n      // AFTER the account has been created, orphaning it. Leads require an\n      // email, so the match key is reliable.\n      id: 'find_contact', type: 'get_record', label: 'Find Existing Contact',\n      config: {\n        objectName: 'crm_contact',\n        filter: { email: cel`leadRecord.email` },\n        outputVariable: 'matchedContact',\n      },\n    },\n    {\n      // Branching is on edges `e11` / `e12` \u2014 see `decision_account`.\n      id: 'decision_contact', type: 'decision', label: 'Contact Already Exists?',\n    },\n    {\n      // `accountId` is a bare id string from whichever account branch ran.\n      id: 'create_contact', type: 'create_record', label: 'Create Contact',\n      config: {\n        objectName: 'crm_contact',\n        fields: {\n          // The person's own facts travel with them (#2068). `crm_contact`\n          // declares each of these on the lead's vocabulary (`_picklists.ts`\n          // for the two selects, pinned by `test/actions-flows-integrity`), so\n          // a straight copy is always legal. The two opt-outs are copied,\n          // never defaulted: a lead that opted out must not become a contact\n          // that has not \u2014 `email_opt_out` hides Send Email and silences\n          // `contact_welcome`, `do_not_call` refuses a scheduled call. A\n          // REUSED contact does not come through here: see\n          // `decision_contact_do_not_call`.\n          //\n          // Names and email are required on a lead and read bare; the rest\n          // are optional and guarded to null, which an insert reads as the\n          // omitted key the template wrote (each opt-out then takes its\n          // `false` default, as before).\n          salutation: cel`has(leadRecord.salutation) ? leadRecord.salutation : null`,\n          mobile: cel`has(leadRecord.mobile) ? leadRecord.mobile : null`,\n          lead_source: cel`has(leadRecord.lead_source) ? leadRecord.lead_source : null`,\n          do_not_call: cel`has(leadRecord.do_not_call) ? leadRecord.do_not_call : null`,\n          email_opt_out: cel`has(leadRecord.email_opt_out) ? leadRecord.email_opt_out : null`,\n          first_name: cel`leadRecord.first_name`, last_name: cel`leadRecord.last_name`,\n          email: cel`leadRecord.email`, phone: cel`has(leadRecord.phone) ? leadRecord.phone : null`,\n          title: cel`has(leadRecord.title) ? leadRecord.title : null`, crm_account: cel`accountId`,\n          is_primary: true, owner_id: cel`current_user.id`,\n        },\n        outputVariable: 'createdContact',\n      },\n    },\n    {\n      id: 'use_new_contact', type: 'assignment', label: 'Use New Contact',\n      config: { assignments: { contactId: cel`createdContact.id` } },\n    },\n    {\n      id: 'use_existing_contact', type: 'assignment', label: 'Reuse Existing Contact',\n      config: { assignments: { contactId: cel`matchedContact.id` } },\n    },\n    {\n      // \u2500\u2500 A REUSED contact keeps the stricter consent (#2068) \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n      //\n      // `create_contact` copies the lead's opt-outs onto a NEW contact. A\n      // reused contact already holds its own answer, and an opt-out is a\n      // promise to a person that a conversion never takes back \u2014 so this path\n      // only ever RAISES a flag, one node per flag, and only when the lead\n      // carries it. The `raise_*` nodes write the literal `true`, \u26D4 never a\n      // copy of `leadRecord.x`: a copy would write the lead's `false` over a contact\n      // who had opted out. `crm_account` carries neither flag, so the account\n      // half of \"the stricter value wins\" has nothing to write.\n      //\n      // The edges read the LEAD's flag only, not whether the contact already\n      // holds it. Reading `vars.matchedContact.x` needs a\n      // `has(vars.matchedContact)` guard, which\n      // `test/flow-variable-conditions.test.ts` forbids on this flow (a\n      // `get_record` binds it on every path) \u2014 and writing `true` over `true`\n      // changes nothing.\n      //\n      // Branching on `e35` / `e36`, then `e38` / `e39`: each pair is TOTAL and\n      // partitions by De Morgan, so exactly one edge holds on every shape\n      // `get_lead` can bind \u2014 pinned in `test/flow-conversion.test.ts`.\n      id: 'decision_contact_do_not_call', type: 'decision', label: 'Lead Is Do-Not-Call?',\n    },\n    {\n      id: 'raise_contact_do_not_call', type: 'update_record', label: 'Carry Do-Not-Call to Contact',\n      config: { objectName: 'crm_contact', filter: { id: cel`contactId` }, fields: { do_not_call: true } },\n    },\n    {\n      id: 'decision_contact_email_opt_out', type: 'decision', label: 'Lead Opted Out of Email?',\n    },\n    {\n      id: 'raise_contact_email_opt_out', type: 'update_record', label: 'Carry Email Opt-Out to Contact',\n      config: { objectName: 'crm_contact', filter: { id: cel`contactId` }, fields: { email_opt_out: true } },\n    },\n    {\n      // Branching is on edges `e16` / `e17` \u2014 see `decision_account`.\n      id: 'decision_opportunity', type: 'decision', label: 'Create Opportunity?',\n    },\n    {\n      // `close_date` comes from the screen field, which is the only layer that\n      // can carry the `isoDate(daysFromNow(90))` expression \u2014 see the\n      // `closeDate` declaration. An unbound `closeDate` fails the run at this\n      // node rather than inventing a quarter, which is the failure this node\n      // is allowed to have.\n      id: 'create_opportunity', type: 'create_record', label: 'Create Opportunity',\n      config: {\n        objectName: 'crm_opportunity',\n        fields: {\n          name: cel`opportunityName`, crm_account: cel`accountId`, primary_contact: cel`contactId`,\n          amount: cel`opportunityAmount`, stage: 'prospecting', probability: 10,\n          lead_source: cel`has(leadRecord.lead_source) ? leadRecord.lead_source : null`,\n          close_date: cel`closeDate`, owner_id: cel`current_user.id`,\n        },\n        outputVariable: 'createdOpportunity',\n      },\n    },\n    {\n      // Normalize both opportunity branches onto a single `opportunityId`, the\n      // same pattern as accountId/contactId. \u26D4 Never reference\n      // `createdOpportunity.id` downstream instead: on the \"No\" branch the\n      // create node never ran, and the unbound read fails the run (on 17.x the\n      // unresolved token interpolated into the `converted_opportunity` lookup\n      // as a placeholder).\n      id: 'use_new_opportunity', type: 'assignment', label: 'Use New Opportunity',\n      config: { assignments: { opportunityId: cel`createdOpportunity.id` } },\n    },\n    {\n      id: 'no_opportunity', type: 'assignment', label: 'No Opportunity',\n      config: { assignments: { opportunityId: null } },\n    },\n    {\n      id: 'mark_converted', type: 'update_record', label: 'Mark Lead as Converted',\n      config: {\n        objectName: 'crm_lead', filter: { id: cel`recordId` },\n        fields: {\n          // `status: 'converted'` rides along so list views agree with the\n          // conversion flags (the qualified \u2192 converted transition is legal\n          // per the lead_status_progression state machine).\n          is_converted: true, status: 'converted', converted_date: cel`isoDatetime(now())`,\n          converted_account: cel`accountId`, converted_contact: cel`contactId`,\n          converted_opportunity: cel`opportunityId`,\n        },\n      },\n    },\n    {\n      // ADR-0012: deliver via the `notify` node (inbox + email). The legacy\n      // `script` + `actionType:'email'` shape is a no-op stub in 7.4.\n      id: 'send_notification', type: 'notify', label: 'Send Confirmation',\n      config: {\n        recipients: [cel`current_user.id`],\n        channels: ['inbox', 'email'],\n        topic: 'lead_converted',\n        template: 'crm.lead_converted',\n        templateData: { first_name: cel`leadRecord.first_name`, last_name: cel`leadRecord.last_name` },\n        actionUrl: '/crm_account/{{accountId}}',\n      },\n    },\n    { id: 'end', type: 'end', label: 'End' },\n  ],\n\n  edges: [\n    // \u26D4 A retired edge's id stays VACANT and every surviving edge keeps the id\n    // it has always had \u2014 `e1`, `e3` and `e15` are gaps on purpose.\n    // Renumbering to close a gap rewrites ids that other notes, tests and run\n    // logs refer to.\n    { id: 'e0', source: 'start', target: 'get_lead', type: 'default' },\n    // \u26D4 When you add an edge, take the next id AFTER THE HIGHEST IN USE \u2014 do\n    // not reuse a vacant one, and do not assume an unused-looking id is free.\n    // A duplicate id is INERT (traversal filters out-edges by `source`, never\n    // by `id`), so nothing fails and the collision survives to trap the next\n    // editor picking out of the sequence. `e1`, `e3` and `e15` are vacant\n    // retired ids and stay that way; `e27` is above the highest live id, not\n    // a gap-fill.\n    { id: 'e27', source: 'get_lead', target: 'decision_approval', type: 'default' },\n    // \u2500\u2500 The approval gate (REQ-0005 step 7) \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n    //\n    // The same TOTAL, PARTITIONING pair the duplicate verdict below is written\n    // as, and for the same measured reason: a decision node declaring no\n    // `config.conditions` takes EVERY out-edge whose condition holds, in\n    // parallel, so two overlapping guards would refuse the conversion and\n    // continue it in one run. `e29` is `e28` negated by De Morgan.\n    //\n    // \u26A0\uFE0F The polarity is fail-OPEN, unlike the duplicate branch, and that is the\n    // gate's off switch rather than a slip. Only the two verdicts a live\n    // approval writes refuse; `not_required` \u2014 the shipped default \u2014 and an\n    // absent column (a lead from before the field existed) both continue, so\n    // with the gate off this pair is invisible and conversion behaves exactly as\n    // it did before. `lead.hook.ts` and `convert_lead.visible` carry the same\n    // polarity, because the three have to agree about what \"off\" means.\n    { id: 'e28', source: 'decision_approval', target: 'refuse_unapproved', type: 'default', condition: P`has(vars.leadRecord) && has(vars.leadRecord.conversion_approval_status)\n      && (vars.leadRecord.conversion_approval_status == \"pending\" || vars.leadRecord.conversion_approval_status == \"rejected\")`, label: 'Not approved' },\n    { id: 'e29', source: 'decision_approval', target: 'decision_duplicate', type: 'default', condition: P`!has(vars.leadRecord) || !has(vars.leadRecord.conversion_approval_status)\n      || (vars.leadRecord.conversion_approval_status != \"pending\" && vars.leadRecord.conversion_approval_status != \"rejected\")`, label: 'Clear' },\n    // Rejoins nothing, exactly like `e26`: the refusal IS not reaching a writer.\n    { id: 'e30', source: 'refuse_unapproved', target: 'end', type: 'default' },\n    // \u26A0\uFE0F Both conditions are TOTAL, and on this surface that is not a style\n    // preference: a flow condition is interpreted strict CEL on every run, and\n    // an unguarded field read against a driver that omits absent columns\n    // (`driver-memory` / `driver-mongodb`) aborts \u2014 which FAILS THE RUN, so an\n    // unguarded read here would make ordinary leads unconvertible. Measured, in\n    // exactly that shape: `condition failed to evaluate as CEL: No such key:\n    // duplicate_status`. The full table is in\n    // `test/flow-condition-totality.test.ts`.\n    //\n    // TWO guards, in the spelling `test/flow-variable-conditions.test.ts`\n    // requires, and the outer one is not decoration: `vars.leadRecord` is a\n    // KEY, so a plain `vars.leadRecord != null` would itself abort with\n    // `Unknown variable` on the run where `get_lead` bound nothing \u2014 the guard\n    // would be the fault it was written to prevent. `has(vars.leadRecord)`\n    // answers instead of reading.\n    //\n    // The THREE edges PARTITION by De Morgan (`!(a && b && c)` written out as\n    // `!a || !b || !c`, with the two verdict tests conjoined under the last\n    // term), so exactly one is true for every record shape, including the\n    // shapes where the column, the row or both are missing.\n    //\n    // \u26D4 `e22`'s third term must carry BOTH inequalities. A decision node that\n    // declares no `config.conditions` reports no branch, so traversal takes\n    // EVERY out-edge whose condition holds, IN PARALLEL \u2014 with `e22` left at\n    // `!= \"suspected\"` a confirmed lead satisfies `e22` AND `e25`, showing the\n    // refusal and converting the lead in the same run. Measured on\n    // `AutomationEngine.evaluateCondition` across all seven record shapes; the\n    // pin is in `test/lead-duplicate-visibility.test.ts`.\n    { id: 'e21', source: 'decision_duplicate', target: 'warn_duplicate', type: 'default', condition: P`has(vars.leadRecord) && has(vars.leadRecord.duplicate_status) && vars.leadRecord.duplicate_status == \"suspected\"`, label: 'Suspected' },\n    { id: 'e25', source: 'decision_duplicate', target: 'refuse_confirmed_duplicate', type: 'default', condition: P`has(vars.leadRecord) && has(vars.leadRecord.duplicate_status) && vars.leadRecord.duplicate_status == \"confirmed\"`, label: 'Confirmed' },\n    { id: 'e22', source: 'decision_duplicate', target: 'no_duplicate_warning', type: 'default', condition: P`!has(vars.leadRecord) || !has(vars.leadRecord.duplicate_status) || (vars.leadRecord.duplicate_status != \"suspected\" && vars.leadRecord.duplicate_status != \"confirmed\")`, label: 'Clean' },\n    // Both clear duplicate branches pass the match-key guard before the form.\n    { id: 'e23', source: 'warn_duplicate', target: 'decision_match_key', type: 'default' },\n    { id: 'e24', source: 'no_duplicate_warning', target: 'decision_match_key', type: 'default' },\n    // \u2500\u2500 The match-key guard (#2017) \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n    //\n    // TOTAL and PARTITIONING, for the reason recorded at `e28` / `e29`: `e32`\n    // is `e31` negated by De Morgan, so exactly one holds for every shape\n    // `get_lead` can bind \u2014 unbound, a null row, the column absent, null,\n    // empty, or keyed. `has()` alone is not the test: on a row that carries\n    // the column as null it answers true, so the value needs `isBlank` too.\n    // Fail-CLOSED, unlike the approval gate: without a key there is nothing to\n    // match on, and a guess is the defect.\n    { id: 'e31', source: 'decision_match_key', target: 'screen_1', type: 'default', condition: P`has(vars.leadRecord) && has(vars.leadRecord.company_normalized) && !isBlank(vars.leadRecord.company_normalized)`, label: 'Has match key' },\n    { id: 'e32', source: 'decision_match_key', target: 'refuse_no_match_key', type: 'default', condition: P`!has(vars.leadRecord) || !has(vars.leadRecord.company_normalized) || isBlank(vars.leadRecord.company_normalized)`, label: 'No match key' },\n    // Rejoins nothing, exactly like `e26` / `e30`.\n    { id: 'e33', source: 'refuse_no_match_key', target: 'end', type: 'default' },\n    // The refusal branch rejoins nothing: it goes straight to `end`, so no\n    // node that writes is downstream of it. That is the refusal \u2014 the flow's\n    // every create/update sits behind `screen_1`, which this path never\n    // reaches.\n    { id: 'e26', source: 'refuse_confirmed_duplicate', target: 'end', type: 'default' },\n    { id: 'e2', source: 'screen_1', target: 'find_account', type: 'default' },\n    { id: 'e4', source: 'find_account', target: 'decision_account', type: 'default' },\n    // Existing account \u2192 reuse; no account \u2192 create. Both converge on create_contact.\n    // `find_account` is reached only with a match key (`e31`), so a match\n    // here is an equality on a real key, never the has-no-value predicate.\n    // \u26D4 No second copy of the key test on these two edges: it could never\n    // be false here, and an inert restatement of a live predicate is the\n    // shape #650 retired from this repo's decision nodes.\n    { id: 'e5', source: 'decision_account', target: 'use_existing_account', type: 'default', condition: P`vars.matchedAccount != null`, label: 'Existing' },\n    { id: 'e6', source: 'decision_account', target: 'create_account', type: 'default', condition: P`vars.matchedAccount == null`, label: 'New' },\n    { id: 'e7', source: 'create_account', target: 'use_new_account', type: 'default' },\n    // Both account branches converge on the contact-dedupe lookup.\n    { id: 'e8', source: 'use_new_account', target: 'find_contact', type: 'default' },\n    { id: 'e9', source: 'use_existing_account', target: 'find_contact', type: 'default' },\n    { id: 'e10', source: 'find_contact', target: 'decision_contact', type: 'default' },\n    // Existing contact \u2192 reuse; none \u2192 create. Both converge on\n    // decision_opportunity, the reuse path through the consent raise below.\n    { id: 'e11', source: 'decision_contact', target: 'use_existing_contact', type: 'default', condition: P`vars.matchedContact != null`, label: 'Existing' },\n    { id: 'e12', source: 'decision_contact', target: 'create_contact', type: 'default', condition: P`vars.matchedContact == null`, label: 'New' },\n    { id: 'e13', source: 'create_contact', target: 'use_new_contact', type: 'default' },\n    { id: 'e14', source: 'use_new_contact', target: 'decision_opportunity', type: 'default' },\n    // \u2500\u2500 The reused contact's consent raise (#2068) \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n    //\n    // `e15` (use_existing_contact \u2192 decision_opportunity) is RETIRED and stays\n    // vacant; `e34` replaces it. Each pair below is TOTAL and PARTITIONING, and\n    // only a flag the lead carries as `true` takes the raise.\n    { id: 'e34', source: 'use_existing_contact', target: 'decision_contact_do_not_call', type: 'default' },\n    { id: 'e35', source: 'decision_contact_do_not_call', target: 'raise_contact_do_not_call', type: 'default', condition: P`has(vars.leadRecord) && has(vars.leadRecord.do_not_call) && vars.leadRecord.do_not_call == true`, label: 'Do not call' },\n    { id: 'e36', source: 'decision_contact_do_not_call', target: 'decision_contact_email_opt_out', type: 'default', condition: P`!has(vars.leadRecord) || !has(vars.leadRecord.do_not_call) || vars.leadRecord.do_not_call != true`, label: 'Callable' },\n    { id: 'e37', source: 'raise_contact_do_not_call', target: 'decision_contact_email_opt_out', type: 'default' },\n    { id: 'e38', source: 'decision_contact_email_opt_out', target: 'raise_contact_email_opt_out', type: 'default', condition: P`has(vars.leadRecord) && has(vars.leadRecord.email_opt_out) && vars.leadRecord.email_opt_out == true`, label: 'Opted out' },\n    { id: 'e39', source: 'decision_contact_email_opt_out', target: 'decision_opportunity', type: 'default', condition: P`!has(vars.leadRecord) || !has(vars.leadRecord.email_opt_out) || vars.leadRecord.email_opt_out != true`, label: 'Emailable' },\n    { id: 'e40', source: 'raise_contact_email_opt_out', target: 'decision_opportunity', type: 'default' },\n    { id: 'e16', source: 'decision_opportunity', target: 'create_opportunity', type: 'default', condition: P`vars.createOpportunity == true`, label: 'Yes' },\n    { id: 'e17', source: 'decision_opportunity', target: 'no_opportunity', type: 'default', condition: P`vars.createOpportunity != true`, label: 'No' },\n    { id: 'e18', source: 'create_opportunity', target: 'use_new_opportunity', type: 'default' },\n    { id: 'e18a', source: 'use_new_opportunity', target: 'mark_converted', type: 'default' },\n    { id: 'e18b', source: 'no_opportunity', target: 'mark_converted', type: 'default' },\n    { id: 'e19', source: 'mark_converted', target: 'send_notification', type: 'default' },\n    { id: 'e20', source: 'send_notification', target: 'end', type: 'default' },\n  ],\n};\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/sales/flows/lead-conversion-approval.flow.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/sales/flows\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/sales/flows/lead-conversion-approval.flow.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport { P, cel } from '@objectstack/spec';\nimport type * as Automation from '@objectstack/spec/automation';\ntype Flow = Automation.Flow;\n\n/**\n * Lead Conversion Approval \u2014 sign-off before a lead may become a deal.\n *\n * REQ-0005 step 7: \u300C\u7EBF\u7D22\u5BF9\u5E94\u5BA1\u6279\u6D41\u7A0B\uFF0C\u5BA1\u6279\u901A\u8FC7\u540E\u65B9\u53EF\u8F6C\u5316\u4E3A\u6B63\u5F0F\u5546\u673A\u300D. Expressed as an\n * **approval node** (`type: 'approval'`, ADR-0019), the construct\n * `opportunity-approval.flow.ts` already uses \u2014 \u26D4 there is no `workflow`\n * metadata type and no standalone `ApprovalProcess` to author.\n *\n * ## \u26A0\uFE0F This flow is INERT until an install arms the gate, and that is by design\n *\n * REQ-0005: \"The gate must be configurable \u2014 off by default. A single-seller\n * install must not be forced through an approval to convert a lead.\"\n *\n * The switch is `crm_lead.conversion_approval_status`'s `defaultValue`, not this\n * flow's `status`. Shipped, that default is `not_required`, so NO lead is ever\n * born `pending` and the start condition below is false for every record that\n * has ever existed \u2014 the flow registers, binds its trigger, opens nothing, and\n * costs a predicate evaluation per insert. An install arms the gate by changing\n * that one value to `'pending'`; from then on every NEW lead enters here, and\n * `lead.hook.ts` refuses its conversion until this flow writes a verdict.\n *\n * \u26D4 Do NOT reach for `status: 'draft'` as the off switch instead. Measured on\n * `@objectstack/service-automation` 17.4.0, whose own registration\n * diagnostic says it in as many words \u2014 \"draft flows still fire their triggers;\n * set status: 'active' to make intent explicit, or 'obsolete' to disable\". And\n * \u26D4 not `'obsolete'` either: `isFlowEnabled` composes the authoring status with\n * the installation's activation ledger so that \"either one disarms; neither can\n * override the other\", which makes `obsolete` a gate no install can ever turn\n * ON \u2014 the opposite of configurable. A condition no record satisfies is off AND\n * switchable; a disabled flow is only off.\n *\n * ## Why the trigger is insert-only\n *\n * `pending` appears at exactly one moment \u2014 the field default, stamped as the\n * row is written \u2014 so the request is opened where it appears. \u26D4 An afterUpdate\n * twin (the shape `opportunity_approval` needs, because a deal can GROW across\n * its threshold) would re-enter on every edit made while the lead sat pending\n * and open a second request for the same decision.\n *\n * \u21D2 A lead that predates the arming keeps `not_required` and never enters, which\n * is REQ-0005 acceptance 4 holding by construction: arming the gate invalidates\n * no existing record.\n */\nexport const LeadConversionApprovalFlow: Flow = {\n  name: 'lead_conversion_approval',\n  label: 'Lead Conversion Approval',\n  description:\n    'Sign-off a lead needs before it may be converted. Inert unless the install arms the gate on crm_lead.conversion_approval_status.',\n  type: 'record_change',\n  status: 'active',\n  // Same reading `opportunity_approval` records, and for the same two reasons.\n  // A gate exists to CONSTRAIN the submitter, so the submitter's own scope is\n  // the wrong identity to evaluate it under \u2014 and an approval control that\n  // engages only for writers carrying a session is not a control, since a\n  // `runAs: 'system'` importer creating leads would simply bypass it. The\n  // verdict writes below also land on `conversion_approval_status`, which is\n  // `readonly: true` on the object, so only a platform write reaches it.\n  runAs: 'system',\n\n  variables: [\n    { name: 'leadId', type: 'text', isInput: true, isOutput: false },\n  ],\n\n  nodes: [\n    {\n      id: 'start',\n      type: 'start',\n      label: 'Start',\n      config: {\n        objectName: 'crm_lead',\n        triggerType: 'record-after-create',\n        // TOTALITY (AGENTS.md \u2014 validation predicates must be TOTAL): `has()`\n        // on every read. A flow condition is strict CEL on every run, and an\n        // unguarded read against a driver that omits absent columns aborts \u2014\n        // which from 17.0.0-rc.2 FAILS THE RUN rather than skipping it. The\n        // absent case must read as \"not gated\": a lead with no approval column\n        // at all is a lead from before the field existed, and it converts the\n        // way it always did.\n        condition: P`has(record.conversion_approval_status) && record.conversion_approval_status == \"pending\"`,\n      },\n    },\n    {\n      id: 'get_lead',\n      type: 'get_record',\n      label: 'Get Lead',\n      config: { objectName: 'crm_lead', filter: { id: cel`record.id` }, outputVariable: 'leadRecord' },\n    },\n    {\n      id: 'conversion_review',\n      type: 'approval',\n      label: 'Lead Conversion Review',\n      config: {\n        // The customer's chain is \u9500\u552E\u8D1F\u8D23\u4EBA \u2192 \u9500\u552E\u603B\u76D1; the generic shape core\n        // ships is the manager bench this app already declares approvers\n        // against. A second tier, or a different position, is overlay\n        // configuration \u2014 the same status as the need-type vocabulary.\n        approvers: [{ type: 'position', value: 'sales_manager' }],\n        // Explicit though it is the schema default, exactly as\n        // `opportunity_approval` authors it: approvers snapshot at request\n        // creation, so an empty bench would otherwise leave the request\n        // undecidable \u2014 and here that means a lead nobody can ever convert.\n        onEmptyApprovers: 'admin_rescue',\n        behavior: 'first_response',\n        // \u26A0\uFE0F `false`, and NOT the schema default `true` \u2014 the one place this\n        // node deliberately differs from its opportunity sibling. A deal under\n        // review is a document being negotiated; a LEAD under review is a person\n        // a rep is still calling. Locking the record would freeze\n        // `last_contacted_date`, `next_followup_date`, the notes and every\n        // activity bubble for as long as the approver takes, so the gate would\n        // stop the work it exists to authorise. Nothing is at risk in leaving it\n        // open: the verdict column is `readonly: true`, so the only field this\n        // node's decision touches is one no user may write anyway.\n        lockRecord: false,\n        approvalStatusField: 'conversion_approval_status',\n      },\n    },\n    {\n      id: 'mark_approved',\n      type: 'update_record',\n      label: 'Mark Approved',\n      config: {\n        objectName: 'crm_lead',\n        filter: { id: cel`record.id` },\n        fields: { conversion_approval_status: 'approved' },\n      },\n    },\n    {\n      id: 'notify_approved',\n      type: 'notify',\n      label: 'Notify Owner \u2014 Approved',\n      config: {\n        recipients: [cel`has(leadRecord.owner_id) ? leadRecord.owner_id : null`],\n        channels: ['inbox'],\n        topic: 'lead_conversion_approved',\n        template: 'crm.lead_conversion_approved',\n        templateData: { first_name: cel`leadRecord.first_name`, last_name: cel`leadRecord.last_name` },\n        actionUrl: '/crm_lead/{{record.id}}',\n      },\n    },\n    {\n      id: 'mark_rejected',\n      type: 'update_record',\n      label: 'Mark Rejected',\n      config: {\n        objectName: 'crm_lead',\n        filter: { id: cel`record.id` },\n        fields: { conversion_approval_status: 'rejected' },\n      },\n    },\n    {\n      id: 'notify_rejected',\n      type: 'notify',\n      label: 'Notify Owner \u2014 Rejected',\n      config: {\n        recipients: [cel`has(leadRecord.owner_id) ? leadRecord.owner_id : null`],\n        channels: ['inbox'],\n        severity: 'warning',\n        topic: 'lead_conversion_rejected',\n        template: 'crm.lead_conversion_rejected',\n        templateData: { first_name: cel`leadRecord.first_name`, last_name: cel`leadRecord.last_name` },\n        actionUrl: '/crm_lead/{{record.id}}',\n      },\n    },\n    { id: 'end', type: 'end', label: 'End' },\n  ],\n\n  edges: [\n    { id: 'e1', source: 'start', target: 'get_lead', type: 'default' },\n    { id: 'e2', source: 'get_lead', target: 'conversion_review', type: 'default' },\n    // Approval-node branch labels \u2014 the engine resumes down the out-edge whose\n    // `label` matches the recorded decision.\n    { id: 'e3', source: 'conversion_review', target: 'mark_approved', type: 'default', label: 'approve' },\n    { id: 'e4', source: 'conversion_review', target: 'mark_rejected', type: 'default', label: 'reject' },\n    { id: 'e5', source: 'mark_approved', target: 'notify_approved', type: 'default' },\n    { id: 'e6', source: 'notify_approved', target: 'end', type: 'default' },\n    { id: 'e7', source: 'mark_rejected', target: 'notify_rejected', type: 'default' },\n    { id: 'e8', source: 'notify_rejected', target: 'end', type: 'default' },\n  ],\n};\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/sales/flows/account-approval.flow.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/sales/flows\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/sales/flows/account-approval.flow.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport { P, cel } from '@objectstack/spec';\nimport type * as Automation from '@objectstack/spec/automation';\ntype Flow = Automation.Flow;\n\n/**\n * Account Approval \u2014 the sign-off a new account record needs before it counts\n * as established data.\n *\n * REQ-0003 step 5: \u300C\u5BA2\u6237\u4FE1\u606F\u63D0\u4EA4\u540E\u8FDB\u5165\u5BA1\u6279\u6D41\uFF0C\u5BA1\u6279\u901A\u8FC7\u540E\u5BA2\u6237\u6B63\u5F0F\u751F\u6548\u300D. Expressed as an\n * **approval node** (`type: 'approval'`, ADR-0019), the construct\n * `opportunity-approval.flow.ts` and `lead-conversion-approval.flow.ts` already\n * use \u2014 \u26D4 there is no `workflow` metadata type and no standalone\n * `ApprovalProcess` to author.\n *\n * ## \u26A0\uFE0F This flow ships ARMED, and that is the one place it differs from its\n * ## lead sibling\n *\n * `lead-conversion-approval` is inert until an install opts in, because\n * REQ-0005 asked for a gate that is off by default. REQ-0003 asks for the\n * opposite in as many words \u2014 acceptance 4: \"A newly created account sits in a\n * pending state, appears in the platform approval inbox HotCRM already mounts,\n * and only reaches the approved state through a decision on that request.\" So\n * every new account enters here: `crm_account.approval_status` ships with NO\n * default, a new account is born blank, and the start condition below fires on\n * the blank.\n *\n * ## `pending` is written by the request, not by the field default (#2067)\n *\n * The approval node's `approvalStatusField` mirror writes `pending` onto the\n * account the moment it opens the request (plugin-approvals `openNodeRequest`,\n * measured on 17.7.0), inside the create, so with approvals in the\n * composition acceptance 4 holds exactly as before and `pending` always has a\n * request behind it. Without approvals no executor exists for the node, the\n * run fails at it (`No executor registered for node type 'approval'`), and\n * nothing writes `pending`: the account stays blank and editable. A shipped\n * `pending` default had stamped every such account `pending` with no request\n * behind it, and the console derives its lock from that value, so each one\n * read \"locked for approval\" forever with nothing able to decide it.\n *\n * The off switch is still the field default, not this flow's `status`: an\n * install that wants no account sign-off gives the column a default of\n * `approved`, the start condition below is then false for every record that\n * will ever exist, and the gate is off AND still switchable. \u26D4 Do NOT reach\n * for `status: 'draft'` or `'obsolete'` instead \u2014 both were measured on\n * `@objectstack/service-automation` 17.4.0 and neither is an off switch: draft\n * flows still fire their triggers, and `isFlowEnabled` composes authoring\n * status with the installation's activation ledger so that `obsolete` is a gate\n * no install can ever turn back ON. That measurement is recorded in\n * `lead-conversion-approval.flow.ts`; it is quoted here, \u26D4 not re-derived.\n *\n * ## Why the trigger is insert-only\n *\n * Submission happens at exactly one moment, the account's creation, so that is\n * where the request is opened. \u26D4 An afterUpdate twin would re-enter on every\n * edit made while the account sat blank or pending and open a second request\n * for the same decision. The trigger, not the condition, is also what keeps an\n * account that predates this field out: it carries no `approval_status`, which\n * the condition below would read as blank, but it is never inserted again, so\n * it is never dragged into an approval it was not created under.\n */\nexport const AccountApprovalFlow: Flow = {\n  name: 'account_approval',\n  label: 'Account Approval',\n  description:\n    'Sign-off a newly created account needs before it counts as established data. Switchable from crm_account.approval_status.',\n  type: 'record_change',\n  status: 'active',\n  // Same reading the two sibling approval flows record. A gate exists to\n  // CONSTRAIN the submitter, so the submitter's own scope is the wrong identity\n  // to evaluate it under; and the verdict writes below land on\n  // `approval_status`, which is `readonly: true` on the object, so only a\n  // platform write reaches it at all.\n  runAs: 'system',\n\n  variables: [{ name: 'accountId', type: 'text', isInput: true, isOutput: false }],\n\n  nodes: [\n    {\n      id: 'start',\n      type: 'start',\n      label: 'Start',\n      config: {\n        objectName: 'crm_account',\n        triggerType: 'record-after-create',\n        // Fires on the BLANK a new account is born with (see the header):\n        // absent on a sparse driver, null on SQL. A user cannot pre-fill the\n        // column (it is `readonly`), so only a system writer or an install's\n        // `approved` default can make it non-blank at insert, and both mean\n        // \"nothing to submit\".\n        // TOTALITY (AGENTS.md \u2014 validation predicates must be TOTAL): the\n        // `(!has(x) || isBlank(x))` form is the \"x holds no value\" row of that\n        // table. A flow condition is strict CEL on every run, and an unguarded\n        // read against a driver that omits absent columns aborts \u2014 which from\n        // 17.0.0-rc.2 FAILS THE RUN rather than skipping it.\n        condition: P`!has(record.approval_status) || isBlank(record.approval_status)`,\n      },\n    },\n    {\n      id: 'get_account',\n      type: 'get_record',\n      label: 'Get Account',\n      config: {\n        objectName: 'crm_account',\n        filter: { id: cel`record.id` },\n        outputVariable: 'accountRecord',\n      },\n    },\n    {\n      id: 'account_review',\n      type: 'approval',\n      label: 'Account Review',\n      config: {\n        // The customer's chain is \u9500\u552E\u8D1F\u8D23\u4EBA \u2192 \u9500\u552E\u603B\u76D1; REQ-0003 rules that named\n        // chain **C** (overlay \u2014 one company's org chart), so core ships the\n        // one generic tier against the manager bench this app already declares.\n        approvers: [{ type: 'position', value: 'sales_manager' }],\n        // Explicit though it is the schema default, exactly as both sibling\n        // flows author it: approvers snapshot at request creation, so an empty\n        // bench would otherwise leave the request undecidable \u2014 and here that\n        // means an account nobody can ever approve.\n        onEmptyApprovers: 'admin_rescue',\n        behavior: 'first_response',\n        // \u26A0\uFE0F `false`, matching the lead sibling rather than the opportunity one.\n        // An account under review is a record a rep is still working \u2014 contacts\n        // are being attached, the address is being corrected, activity is\n        // landing on it. Locking it would freeze exactly the data-entry the\n        // approval exists to review. Nothing is at risk: the verdict column is\n        // `readonly: true`, so the only field this decision touches is one no\n        // user may write anyway.\n        lockRecord: false,\n        approvalStatusField: 'approval_status',\n      },\n    },\n    {\n      id: 'mark_approved',\n      type: 'update_record',\n      label: 'Mark Approved',\n      config: {\n        objectName: 'crm_account',\n        filter: { id: cel`record.id` },\n        fields: { approval_status: 'approved' },\n      },\n    },\n    {\n      id: 'notify_approved',\n      type: 'notify',\n      label: 'Notify Owner \u2014 Approved',\n      config: {\n        recipients: [cel`has(accountRecord.owner_id) ? accountRecord.owner_id : null`],\n        channels: ['inbox'],\n        topic: 'account_approved',\n        template: 'crm.account_approved',\n        templateData: { name: cel`accountRecord.name` },\n        actionUrl: '/crm_account/{{record.id}}',\n      },\n    },\n    {\n      id: 'mark_rejected',\n      type: 'update_record',\n      label: 'Mark Rejected',\n      config: {\n        objectName: 'crm_account',\n        filter: { id: cel`record.id` },\n        fields: { approval_status: 'rejected' },\n      },\n    },\n    {\n      id: 'notify_rejected',\n      type: 'notify',\n      label: 'Notify Owner \u2014 Rejected',\n      config: {\n        recipients: [cel`has(accountRecord.owner_id) ? accountRecord.owner_id : null`],\n        channels: ['inbox'],\n        severity: 'warning',\n        topic: 'account_rejected',\n        template: 'crm.account_rejected',\n        templateData: { name: cel`accountRecord.name` },\n        actionUrl: '/crm_account/{{record.id}}',\n      },\n    },\n    { id: 'end', type: 'end', label: 'End' },\n  ],\n\n  edges: [\n    { id: 'e1', source: 'start', target: 'get_account', type: 'default' },\n    { id: 'e2', source: 'get_account', target: 'account_review', type: 'default' },\n    // Approval-node branch labels \u2014 the engine resumes down the out-edge whose\n    // `label` matches the recorded decision.\n    { id: 'e3', source: 'account_review', target: 'mark_approved', type: 'default', label: 'approve' },\n    { id: 'e4', source: 'account_review', target: 'mark_rejected', type: 'default', label: 'reject' },\n    { id: 'e5', source: 'mark_approved', target: 'notify_approved', type: 'default' },\n    { id: 'e6', source: 'notify_approved', target: 'end', type: 'default' },\n    { id: 'e7', source: 'mark_rejected', target: 'notify_rejected', type: 'default' },\n    { id: 'e8', source: 'notify_rejected', target: 'end', type: 'default' },\n  ],\n};\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/sales/flows/schedule-followup.flow.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/sales/flows\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/sales/flows/schedule-followup.flow.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport { cel } from '@objectstack/spec';\nimport type * as Automation from '@objectstack/spec/automation';\nimport { TASK_TYPE_OPTIONS, plainOptions } from '../objects/_picklists';\ntype Flow = Automation.Flow;\n\n/**\n * Schedule Follow-up \u2014 one screen, one task, straight off the lead header.\n *\n * `log_call` / `log_meeting` record what already happened; this flow puts the\n * NEXT touch on the rep's list without leaving the lead \u2014 the single most\n * common thing a rep does after a call.\n *\n * \u26D4 Implemented as a SCREEN FLOW, never a `type: 'modal'` action: modal actions\n * are non-functional in 16.1.0 \u2014 the console resolves the action's `target` as\n * an object name and the submit dies on `GET /api/v1/meta/object/<target>` \u2192\n * 400, even though the spec defines `target` for modals as \"the modal/page name\n * to open\". Flow-typed actions are the mechanism that demonstrably works today;\n * `convert_lead` uses it.\n */\nexport const ScheduleFollowUpFlow: Flow = {\n  name: 'schedule_followup',\n  label: 'Schedule Follow-up',\n  description: 'Create the next follow-up task on a lead, already linked and owned.',\n  type: 'screen',\n  status: 'active',\n\n  variables: [\n    // MUST be `recordId` \u2014 the console's flow-action contract seeds only that\n    // name (and its camelCase object alias); a custom name arrives undefined.\n    { name: 'recordId', type: 'text', isInput: true, isOutput: false },\n    { name: 'subject', type: 'text', isInput: true, isOutput: false },\n    { name: 'dueDate', type: 'date', isInput: true, isOutput: false },\n    { name: 'activityType', type: 'text', isInput: true, isOutput: false },\n    { name: 'priority', type: 'text', isInput: true, isOutput: false },\n    { name: 'notes', type: 'text', isInput: true, isOutput: false },\n  ],\n\n  nodes: [\n    { id: 'start', type: 'start', label: 'Start', config: { objectName: 'crm_lead' } },\n    {\n      id: 'screen_1', type: 'screen', label: 'Schedule Follow-up',\n      config: {\n        fields: [\n          { name: 'subject', label: 'What is the next step?', type: 'text', required: true },\n          { name: 'dueDate', label: 'Due Date', type: 'date', required: true },\n          {\n            name: 'activityType', label: 'Activity Type', type: 'select',\n            // Mirrors crm_task.type exactly. \u26D4 Never hand-copy the subset \u2014 it\n            // silently drops an option (`other`) from the picker.\n            options: plainOptions(TASK_TYPE_OPTIONS),\n          },\n          {\n            name: 'priority', label: 'Priority', type: 'select',\n            options: [\n              { label: 'Low', value: 'low' },\n              { label: 'Normal', value: 'normal' },\n              { label: 'High', value: 'high' },\n              { label: 'Urgent', value: 'urgent' },\n            ],\n          },\n          { name: 'notes', label: 'Notes', type: 'textarea' },\n        ],\n      },\n    },\n    {\n      id: 'get_lead', type: 'get_record', label: 'Get Lead Record',\n      config: { objectName: 'crm_lead', filter: { id: cel`recordId` }, outputVariable: 'leadRecord' },\n    },\n    {\n      id: 'create_task', type: 'create_record', label: 'Create Follow-up Task',\n      config: {\n        objectName: 'crm_task',\n        fields: {\n          subject: cel`subject`,\n          due_date: cel`dueDate`,\n          // The three optional answers: a resume may leave one unbound, which\n          // the template wrote as nothing and the guard writes as null. On an\n          // insert the two are the same \u2014 the engine applies a field's default\n          // to an explicit null exactly as to an omitted key, so an unanswered\n          // priority still lands as `normal`.\n          type: cel`has(vars.activityType) ? activityType : null`,\n          priority: cel`has(vars.priority) ? priority : null`,\n          description: cel`has(vars.notes) ? notes : null`,\n          status: 'not_started',\n          owner_id: cel`current_user.id`,\n          // Polymorphic parent: both halves are required for the lead's\n          // Related tab to pick the task up.\n          related_to_type: 'crm_lead',\n          related_to_lead: cel`recordId`,\n        },\n        outputVariable: 'createdTask',\n      },\n    },\n    {\n      // Keep the lead's own follow-up date in step with the task that was just\n      // filed, so the Hot Leads view (sorted by next_followup_date) reflects\n      // the commitment the rep actually made.\n      id: 'stamp_lead', type: 'update_record', label: 'Stamp Next Follow-up Date',\n      config: {\n        objectName: 'crm_lead',\n        filter: { id: cel`recordId` },\n        fields: { next_followup_date: cel`dueDate` },\n      },\n    },\n    { id: 'end', type: 'end', label: 'End' },\n  ],\n\n  edges: [\n    { id: 'e1', source: 'start', target: 'screen_1', type: 'default' },\n    { id: 'e2', source: 'screen_1', target: 'get_lead', type: 'default' },\n    { id: 'e3', source: 'get_lead', target: 'create_task', type: 'default' },\n    { id: 'e4', source: 'create_task', target: 'stamp_lead', type: 'default' },\n    { id: 'e5', source: 'stamp_lead', target: 'end', type: 'default' },\n  ],\n};\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/sales/flows/opportunity-approval.flow.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/sales/flows\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/sales/flows/opportunity-approval.flow.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport { P, cel } from '@objectstack/spec';\nimport type * as Automation from '@objectstack/spec/automation';\nimport { HIGH_VALUE_DEAL_AMOUNT, LARGE_DEAL_AMOUNT } from '../objects/_thresholds';\ntype Flow = Automation.Flow;\n\n/**\n * Opportunity Approval \u2014 tiered sign-off for large deals.\n *\n * Expressed as **Approval nodes** (`type: 'approval'`, ADR-0019): the engine\n * opens an approval request on entry, suspends the run, and resumes down the\n * out-edge whose `label` matches the decision (`approve` / `reject`).\n * Notifications use the **`notify` node** (ADR-0012). \u26D4 Neither a\n * `connector_action` nor a standalone `ApprovalProcess` is available \u2014 both\n * authoring surfaces were removed in ObjectStack 7.4.\n *\n * Tiered policy (single source of truth \u2014 no double-firing):\n *   - amount >= $100K         \u2192 Sales Manager review\n *   - amount > $500K          \u2192 additionally Sales Director sign-off\n *\n * The entry gate is INCLUSIVE at the line (`>=`) and the director tier is\n * exclusive (`>`): those are not the same kind of number. `LARGE_DEAL_AMOUNT` is\n * the one line this app draws around \"large deal\", and every consumer of it \u2014\n * this gate, its insert twin, the won-deal alert and both sharing rules \u2014 must\n * cut the same way, so a deal at exactly $100,000 is large everywhere or\n * nowhere. `HIGH_VALUE_DEAL_AMOUNT` below is a matched PAIR (`> 500000` /\n * `<= 500000`) whose two halves must partition, which is a different property\n * and is left alone.\n *\n * On full approval the deal is stamped `approval_status = approved` (+ date);\n * any rejection stamps `approval_status = rejected`. The record is locked while\n * a step is pending and `approval_status` mirrors the live request status.\n */\nexport const OpportunityApprovalFlow: Flow = {\n  name: 'opportunity_approval',\n  label: 'Large Deal Approval',\n  description: 'Tiered approval for opportunities: manager review at $100K or more, director sign-off > $500K.',\n  type: 'record_change',\n  status: 'active',\n  // Same user-less exposure as every record-change flow (ADR-0049) \u2014 and the\n  // one with teeth. Measured on 17.0.0-rc.2: a $150K renewal\n  // created by the `runAs: 'system'` contract_renewal sweep fired this flow\n  // with no trigger user, and the run died at `get_opportunity`. The deal sat\n  // at `approval_status: 'not_required'`, unlocked, with no approval request\n  // ever opened \u2014 the gate was bypassed by the writer simply not carrying a\n  // session. An approval control that only engages for logged-in writers is\n  // not a control.\n  //\n  // Elevating the USER-driven runs too is not merely acceptable here, it is\n  // required. This gate exists to CONSTRAIN the submitter, so the submitter's\n  // own scope is the wrong identity to evaluate it under; and\n  // `mark_approved` / `mark_rejected` stamp `approval_status` on a record the\n  // approval node holds locked (`lockRecord: true`), which only a platform\n  // write may land. The approval node itself already opens its request under\n  // the platform identity while re-attaching the deciding user for\n  // attribution, so this declaration aligns the flow with the node it drives.\n  runAs: 'system',\n\n  variables: [\n    { name: 'opportunityId', type: 'text', isInput: true, isOutput: false },\n  ],\n\n  nodes: [\n    {\n      id: 'start',\n      type: 'start',\n      label: 'Start',\n      // Trigger wiring (7.4): bind to afterUpdate; gate on crossing the entry\n      // threshold while not already in an approval state. The `not_required`\n      // guard stops the flow's own approval_status writes from re-triggering it.\n      config: {\n        objectName: 'crm_opportunity',\n        triggerType: 'record-after-update',\n        // Null-tolerant: rows inserted before approval_status had a field-level\n        // defaultValue (e.g. flow-created opportunities) carry null, which must\n        // still enter approval.\n        // Stage guard: a settled deal must never (re-)enter approval \u2014 the\n        // freeze hook rejects approval-status writes on closed records, so\n        // without this guard the flow opened a locked approval request it\n        // could never resolve (lockRecord held the closed record hostage).\n        // TOTALITY: `has(...)` on every read, plus `!= null` on the\n        // ordering comparison \u2014 `has()` passes an explicit null and\n        // `record.amount >= 100000` then aborts with\n        // `no such overload: dyn<null> >= int`. Measured total as authored\n        // today (amount/stage are required, approval_status is defaulted), but\n        // that is `crm_opportunity`'s schema doing the work, not the\n        // predicate. An absent `approval_status` reads the same as the null\n        // this condition already tolerates; an absent `stage` is not a settled\n        // stage, so it must not block approval.\n        condition: P`has(record.amount) && record.amount != null && record.amount >= ${LARGE_DEAL_AMOUNT}\n          && (!has(record.approval_status) || record.approval_status == \"not_required\" || record.approval_status == null)\n          && (!has(record.stage) || (record.stage != \"closed_won\" && record.stage != \"closed_lost\"))`,\n      },\n    },\n    {\n      id: 'get_opportunity',\n      type: 'get_record',\n      label: 'Get Opportunity',\n      config: { objectName: 'crm_opportunity', filter: { id: cel`record.id` }, outputVariable: 'oppRecord' },\n    },\n\n    // \u2500\u2500 Tier 1: Sales Manager review (all deals at $100K or more) \u2500\u2500\u2500\n    {\n      id: 'manager_review',\n      type: 'approval',\n      label: 'Sales Manager Review',\n      config: {\n        // \u26D4 Never add an org-owner approver as an empty-bench workaround.\n        // `onEmptyApprovers: 'admin_rescue'` is the node policy for an empty\n        // position on @objectstack 17 (approvers snapshot at request creation,\n        // so a position with no holders would otherwise leave the request\n        // undecidable while `lockRecord` held the record hostage). An\n        // `{ type: 'org_membership_level', value: 'owner' }` entry overshoots:\n        // with `behavior: 'first_response'` it makes an org owner a routine\n        // approver for every deal, not a rescue when the bench is empty.\n        approvers: [{ type: 'position', value: 'sales_manager' }],\n        // Explicit even though `admin_rescue` is the schema default \u2014 this is\n        // the mechanism the node depends on, so it is authored, not inherited.\n        onEmptyApprovers: 'admin_rescue',\n        behavior: 'first_response',\n        lockRecord: true,\n        approvalStatusField: 'approval_status',\n      },\n    },\n\n    // \u2500\u2500 Tier gate: does this deal also need director sign-off? \u2500\u2500\u2500\u2500\u2500\u2500\n    {\n      // No `config.condition` here: the branch is on edges `e5` / `e6`, which\n      // is where the engine actually reads it. A copy on the node would be\n      // inert and indistinguishable from the live one (17.0.0-rc.2's\n      // `flow-inert-node-condition`).\n      id: 'check_high_value',\n      type: 'decision',\n      label: 'High Value (> $500K)?',\n    },\n\n    // \u2500\u2500 Tier 2: Sales Director sign-off (deals > $500K only) \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n    {\n      id: 'director_signoff',\n      type: 'approval',\n      label: 'Sales Director Sign-off',\n      config: {\n        // Same node policy as manager_review \u2014 see the note there.\n        approvers: [{ type: 'position', value: 'sales_director' }],\n        onEmptyApprovers: 'admin_rescue',\n        behavior: 'first_response',\n        lockRecord: true,\n        approvalStatusField: 'approval_status',\n      },\n    },\n\n    // \u2500\u2500 Final approve: stamp status + notify owner \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n    {\n      id: 'mark_approved',\n      type: 'update_record',\n      label: 'Mark Approved',\n      config: {\n        objectName: 'crm_opportunity',\n        filter: { id: cel`record.id` },\n        fields: { approval_status: 'approved', approved_date: cel`isoDatetime(now())` },\n      },\n    },\n    {\n      id: 'notify_approved',\n      type: 'notify',\n      label: 'Notify Owner \u2014 Approved',\n      config: {\n        recipients: [cel`has(oppRecord.owner_id) ? oppRecord.owner_id : null`],\n        channels: ['inbox', 'email'],\n        topic: 'opportunity_approved',\n        template: 'crm.opportunity_approved',\n        templateData: { name: cel`oppRecord.name` },\n        actionUrl: '/crm_opportunity/{{record.id}}',\n      },\n    },\n\n    // \u2500\u2500 Rejection: stamp status + notify owner \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n    {\n      id: 'mark_rejected',\n      type: 'update_record',\n      label: 'Mark Rejected',\n      config: {\n        objectName: 'crm_opportunity',\n        filter: { id: cel`record.id` },\n        fields: { approval_status: 'rejected' },\n      },\n    },\n    {\n      id: 'notify_rejected',\n      type: 'notify',\n      label: 'Notify Owner \u2014 Rejected',\n      config: {\n        recipients: [cel`has(oppRecord.owner_id) ? oppRecord.owner_id : null`],\n        channels: ['inbox', 'email'],\n        severity: 'warning',\n        topic: 'opportunity_rejected',\n        template: 'crm.opportunity_rejected',\n        templateData: { name: cel`oppRecord.name` },\n        actionUrl: '/crm_opportunity/{{record.id}}',\n      },\n    },\n\n    { id: 'end', type: 'end', label: 'End' },\n  ],\n\n  edges: [\n    { id: 'e1', source: 'start', target: 'get_opportunity', type: 'default' },\n    { id: 'e2', source: 'get_opportunity', target: 'manager_review', type: 'default' },\n\n    // Manager decision (approval-node branch labels)\n    { id: 'e3', source: 'manager_review', target: 'check_high_value', type: 'default', label: 'approve' },\n    { id: 'e4', source: 'manager_review', target: 'mark_rejected', type: 'default', label: 'reject' },\n\n    // Tier gate (decision-node conditional branches). These EDGES are the live\n    // sites \u2014 the engine never evaluates a `decision` node's singular\n    // `config.condition` \u2014 and they must PARTITION, so the guards are written\n    // in opposite polarity. A deal whose amount cannot be read lands on\n    // `mark_approved`: the manager has already approved it, and an unreadable\n    // amount must not strand an approved deal in a locked, undecidable\n    // director step.\n    //\n    // TOTALITY: `oppRecord` is a `get_record` OUTPUT, so the read needs\n    // `has(vars.oppRecord)` (the variable), `has(vars.oppRecord.amount)` (the\n    // column \u2014 `findOne` answers a miss with `null`, and a sparse driver row\n    // omits an unwritten column outright) and `!= null` (an explicit null\n    // passes `has()` and the ordering comparison then aborts with `no such\n    // overload: dyn<null> > int`). Measured total as authored today \u2014 `amount`\n    // is `required` on `crm_opportunity` and the `get_record` is keyed on the\n    // row that just fired the trigger \u2014 but that is the neighbouring schema\n    // doing the work, exactly as in the start condition above. `vars.`-scoped\n    // rather than bare: `has(oppRecord.amount)` still aborts with `Unknown\n    // variable: oppRecord` on an unbound variable, `has(vars.oppRecord)`\n    // answers `false` (measured). From 17.0.0-rc.2 an unevaluable condition\n    // ABORTS the step rather than skipping it, so a guard that was\n    // belt-and-braces is now what keeps the run alive.\n    { id: 'e5', source: 'check_high_value', target: 'director_signoff', type: 'conditional', condition: P`has(vars.oppRecord) && has(vars.oppRecord.amount)\n      && vars.oppRecord.amount != null && vars.oppRecord.amount > ${HIGH_VALUE_DEAL_AMOUNT}`, label: 'High value (> $500K)' },\n    { id: 'e6', source: 'check_high_value', target: 'mark_approved', type: 'conditional', condition: P`!has(vars.oppRecord) || !has(vars.oppRecord.amount)\n      || vars.oppRecord.amount == null || vars.oppRecord.amount <= ${HIGH_VALUE_DEAL_AMOUNT}`, label: 'Standard (\u2264 $500K)' },\n\n    // Director decision (approval-node branch labels)\n    { id: 'e7', source: 'director_signoff', target: 'mark_approved', type: 'default', label: 'approve' },\n    { id: 'e8', source: 'director_signoff', target: 'mark_rejected', type: 'default', label: 'reject' },\n\n    // Terminal branches\n    { id: 'e9', source: 'mark_approved', target: 'notify_approved', type: 'default' },\n    { id: 'e10', source: 'notify_approved', target: 'end', type: 'default' },\n    { id: 'e11', source: 'mark_rejected', target: 'notify_rejected', type: 'default' },\n    { id: 'e12', source: 'notify_rejected', target: 'end', type: 'default' },\n  ],\n};\n\n/**\n * Insert-time twin of `opportunity_approval`. A record-change flow binds\n * exactly one hook event, so the afterUpdate flow above never sees\n * opportunities BORN over the threshold \u2014 flow-created deals (contract\n * renewals, lead conversion) and API inserts. \u26D4 Do not delete this twin\n * expecting the afterUpdate flow to cover them; that population is exactly what\n * the start condition's null-tolerance is written for. Same nodes/edges, only\n * the start node is rebound to afterInsert (mirrors `CaseEscalationOnCreateFlow`).\n * The stage guard carries over, keeping seeded/imported closed deals out.\n */\nexport const OpportunityApprovalOnCreateFlow: Flow = {\n  ...OpportunityApprovalFlow,\n  name: 'opportunity_approval_on_create',\n  label: 'Large Deal Approval (on create)',\n  description: 'Approval intake for opportunities created above the threshold (insert-time twin of opportunity_approval).',\n  nodes: OpportunityApprovalFlow.nodes.map((n) =>\n    n.id === 'start'\n      ? { ...n, config: { ...n.config, triggerType: 'record-after-create' } }\n      : n,\n  ),\n};\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/sales/flows/opportunity-status-change-approval.flow.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/sales/flows\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/sales/flows/opportunity-status-change-approval.flow.ts\";// Copyright (c) 2026 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport { P, cel } from '@objectstack/spec';\nimport type * as Automation from '@objectstack/spec/automation';\ntype Flow = Automation.Flow;\n\n/**\n * Opportunity Status Change Approval \u2014 sign-off before a deal is declared won\n * or abandoned.\n *\n * REQ-0006 steps 13 + 14: \u300C\u53D1\u8D77\u8D62\u5355\u3001\u5F03\u5355\u2026\u72B6\u6001\u53D8\u66F4\u64CD\u4F5C\uFF0C\u586B\u5199\u53D8\u66F4\u539F\u56E0\u4E0E\u8BF4\u660E\u300D then\n * \u300C\u91CD\u8981\u72B6\u6001\u53D8\u66F4\u9700\u5BA1\u6279\uFF0C**\u901A\u8FC7\u540E\u5546\u673A\u72B6\u6001\u6B63\u5F0F\u751F\u6548**\u300D. Expressed as an **approval node**\n * (`type: 'approval'`, ADR-0019), the construct `opportunity-approval.flow.ts`\n * already uses \u2014 \u26D4 there is no `workflow` metadata type and no standalone\n * `ApprovalProcess` to author.\n *\n * ## Why the STAGE is not what the rep writes\n *\n * REQ-0006 acceptance 3: the request opens \"and the stage does not change\n * until it is decided\". A `record_change` flow binds an AFTER hook, so by the\n * time it runs the stage has already moved \u2014 an after-flow can lock the record\n * but it cannot un-move it. So the rep writes the REQUEST\n * (`requested_status`) and the approved decision writes the STAGE, which is\n * also literally what the customer's own step 14 says (\"\u901A\u8FC7\u540E\u2026\u6B63\u5F0F\u751F\u6548\").\n * `opportunity.hook.ts` refuses a direct user move into a closed stage while\n * the gate is armed, and names this field in the refusal.\n *\n * ## \u26A0\uFE0F This flow is INERT until an install arms the gate, and that is by design\n *\n * REQ-0006 acceptance 3 again: \"with it off (the default), the existing\n * amount-tiered behaviour of `opportunity-approval.flow.ts` is bit-for-bit\n * what it is today.\"\n *\n * The switch is `crm_opportunity.status_change_approval_status`'s\n * `defaultValue`, \u26D4 not this flow's `status`. Shipped, that default is\n * `not_required`, so no deal is ever born `pending`, the start condition below\n * is false for every record that has ever existed, and this flow opens nothing\n * \u2014 it costs one predicate evaluation per update. An install arms the gate by\n * changing that one value to `'pending'`.\n *\n * \u26D4 Do NOT reach for `status: 'draft'` as the off switch instead, and \u26D4 not\n * `'obsolete'` either. Both readings are measured and recorded in\n * `lead-conversion-approval.flow.ts`'s docstring on\n * `@objectstack/service-automation` 17.4.0, the pin at that taking: draft flows still fire their\n * triggers, and `isFlowEnabled` composes `obsolete` with the installation's\n * activation ledger into a gate no install can ever turn ON. \u26D4 Do not\n * re-derive it here.\n *\n * \u21D2 A deal that predates the arming keeps `not_required` and never enters,\n * so arming the gate invalidates no existing record.\n *\n * ## \u26A0\uFE0F Its own verdict column, NOT `approval_status`\n *\n * `approval_status` belongs to the amount-tiered flow. Sharing it would make\n * either gate's verdict erase the other's \u2014 and worse, re-arm the amount flow,\n * whose entry condition fires on `approval_status == \"not_required\"`.\n */\nexport const OpportunityStatusChangeApprovalFlow: Flow = {\n  name: 'opportunity_status_change_approval',\n  label: 'Opportunity Status Change Approval',\n  description:\n    'Sign-off a deal needs before it is declared won or lost. Inert unless the install arms the gate on crm_opportunity.status_change_approval_status.',\n  type: 'record_change',\n  status: 'active',\n  // REQ-0006 acceptance 4, and the same reading `opportunity_approval` records\n  // from its own measured failure: a gate that engages only for writers\n  // carrying a session is not a control \u2014 a `runAs: 'system'` sweep or import\n  // would simply bypass it. The verdict and the stage write below also land on\n  // columns the readonly strip protects, which only a platform write reaches.\n  runAs: 'system',\n\n  variables: [\n    { name: 'opportunityId', type: 'text', isInput: true, isOutput: false },\n  ],\n\n  nodes: [\n    {\n      id: 'start',\n      type: 'start',\n      label: 'Start',\n      config: {\n        objectName: 'crm_opportunity',\n        triggerType: 'record-after-update',\n        // TOTALITY (AGENTS.md \u2014 validation predicates must be TOTAL): `has()`\n        // on every read. A flow condition is strict CEL on every run and an\n        // unguarded read against a driver that omits absent columns aborts,\n        // which from 17.0.0-rc.2 FAILS THE RUN rather than skipping it. The\n        // absent case must read as \"not gated\": a deal with no gate column at\n        // all predates the field and closes the way it always did.\n        //\n        // Three halves:\n        //\n        // - the gate is ARMED: `pending` (born armed, no request decided yet)\n        //   or `rejected` (the last request was refused). `rejected` re-opens\n        //   on a new request because `opportunity.hook.ts` refuses a direct\n        //   close in both states \u2014 if only `pending` entered here, a rejected\n        //   deal could be neither requested nor closed, ever.\n        // - a request is present;\n        // - the request is NEW on this write. TRANSITION, not current value \u2014\n        //   the idiom `billing_handoff_closed_won` records for this object.\n        //   Without it the flow re-fires on its own write-back while the\n        //   request is still open (the approval node's `pending` stamp through\n        //   `approvalStatusField` is an update of this record). Measured on\n        //   17.6.0 with this term deleted: one re-entry per request, each\n        //   caught only by the engine's self-trigger guard (\"the guard as\n        //   authored does not exclude the flow's own write-back\"); with it,\n        //   none. `previous.*` is guarded FAIL-CLOSED: no visible prior\n        //   value, no visible new request.\n        //\n        // `apply_status` leaves the gate `approved` (out of reach) and\n        // `clear_request` empties the request, so neither re-enters.\n        condition: P`has(record.status_change_approval_status)\n          && (record.status_change_approval_status == \"pending\" || record.status_change_approval_status == \"rejected\")\n          && has(record.requested_status) && record.requested_status != null && record.requested_status != \"\"\n          && has(previous.requested_status) && previous.requested_status != record.requested_status`,\n      },\n    },\n    {\n      id: 'get_opportunity',\n      type: 'get_record',\n      label: 'Get Opportunity',\n      config: { objectName: 'crm_opportunity', filter: { id: cel`record.id` }, outputVariable: 'oppRecord' },\n    },\n    {\n      id: 'status_review',\n      type: 'approval',\n      label: 'Status Change Review',\n      config: {\n        // The customer's chain is \u9500\u552E\u8D1F\u8D23\u4EBA \u2192 \u4E8B\u4E1A\u90E8\u8D1F\u8D23\u4EBA; the generic shape core\n        // ships is the manager bench this app already declares approvers\n        // against. A second tier, or a different position, is overlay\n        // configuration (REQ-0006 acceptance 5).\n        approvers: [{ type: 'position', value: 'sales_manager' }],\n        // Explicit though it is the schema default, exactly as both sibling\n        // approvals author it: approvers snapshot at request creation, so an\n        // empty bench would leave the request undecidable \u2014 and here that\n        // means a deal nobody can ever close.\n        onEmptyApprovers: 'admin_rescue',\n        behavior: 'first_response',\n        // `true`, matching `opportunity_approval` and NOT the lead gate: a deal\n        // awaiting a won/lost verdict must not keep moving underneath the\n        // approver. Its narrative fields are what the freeze hook leaves open\n        // anyway.\n        lockRecord: true,\n        approvalStatusField: 'status_change_approval_status',\n      },\n    },\n    {\n      // The approved decision is what moves the stage \u2014 \"\u901A\u8FC7\u540E\u6B63\u5F0F\u751F\u6548\".\n      //\n      // \u26A0\uFE0F Both fields in ONE write, and that is load-bearing: the\n      // status-change guard in `opportunity.hook.ts` reads the gate column\n      // INPUT-FIRST, so this write presents itself as already-approved and the\n      // guard lets the stage through. Splitting it into two writes would have\n      // the guard refuse the flow's own write (ELEVATION IS NOT ANONYMITY \u2014\n      // `runAs: 'system'` carries the triggering user, so `ctx.user?.id` is\n      // present in this run).\n      //\n      // `win_reason` / `loss_reason` are `requiredWhen` the stage is closed and\n      // are evaluated against the merged record, so the values the rep captured\n      // when requesting satisfy them here.\n      id: 'apply_status',\n      type: 'update_record',\n      label: 'Apply Requested Status',\n      config: {\n        objectName: 'crm_opportunity',\n        filter: { id: cel`record.id` },\n        fields: {\n          stage: cel`oppRecord.requested_status`,\n          status_change_approval_status: 'approved',\n          approved_date: cel`isoDatetime(now())`,\n        },\n      },\n    },\n    {\n      // A rejected request is cleared, not left standing, and the verdict stays\n      // `rejected` so the hook keeps refusing a direct close: the way on is a\n      // new request, which the start condition opens as a fresh approval.\n      id: 'clear_request',\n      type: 'update_record',\n      label: 'Clear Rejected Request',\n      config: {\n        objectName: 'crm_opportunity',\n        filter: { id: cel`record.id` },\n        fields: { status_change_approval_status: 'rejected', requested_status: null },\n      },\n    },\n    { id: 'end', type: 'end', label: 'End' },\n  ],\n\n  edges: [\n    { id: 'e1', source: 'start', target: 'get_opportunity', type: 'default' },\n    { id: 'e2', source: 'get_opportunity', target: 'status_review', type: 'default' },\n    // Approval-node branch labels.\n    { id: 'e3', source: 'status_review', target: 'apply_status', type: 'default', label: 'approve' },\n    { id: 'e4', source: 'status_review', target: 'clear_request', type: 'default', label: 'reject' },\n    { id: 'e5', source: 'apply_status', target: 'end', type: 'default' },\n    { id: 'e6', source: 'clear_request', target: 'end', type: 'default' },\n  ],\n};\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/sales/flows/opportunity-qualification-approval.flow.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/sales/flows\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/sales/flows/opportunity-qualification-approval.flow.ts\";// Copyright (c) 2026 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport { P, cel } from '@objectstack/spec';\nimport type * as Automation from '@objectstack/spec/automation';\ntype Flow = Automation.Flow;\n\n/**\n * Opportunity Qualification Approval \u2014 the \u7ACB\u9879 sign-off a new deal needs\n * before its stage or its won/lost call may change. Will Bid (\u662F\u5426\u6295\u6807) is\n * not held: step 8 makes it input to \u7ACB\u9879, for the approver to read (#2004).\n *\n * REQ-0006 step 11: \u300C\u9500\u552E\u7ACB\u9879\u9700\u8D70\u5BA1\u6279\u6D41\u7A0B\uFF1B\u65B0\u589E\u5546\u673A\u53EF\u8DDF\u8FDB\uFF0C\u7ACB\u9879\u901A\u8FC7\u540E\u65B9\u53EF\u66F4\u65B0\u9636\u6BB5\u3001\u6295\u6807\u3001\n * \u8D62\u4E22\u5355\u64CD\u4F5C\u3002\u300D Expressed as an **approval node** (`type: 'approval'`, ADR-0019),\n * the construct `opportunity-approval.flow.ts` already uses \u2014 \u26D4 there is no\n * `workflow` metadata type and no standalone `ApprovalProcess` to author.\n *\n * Built on `opportunity-status-change-approval.flow.ts` (REQ-0006 step 14) and\n * deliberately the same in every load-bearing term: the switch is a verdict\n * field's `defaultValue`, the rep writes a REQUEST and the flow opens one\n * approval when the request is NEW, `rejected` re-opens on a new request,\n * `runAs: 'system'`, `onEmptyApprovers: 'admin_rescue'`. The refusal of the\n * two gated acts lives beside the step-14 refusal in `opportunity.hook.ts`'s\n * `opportunity_lifecycle`. Where it differs, the reason is written beside it\n * (`lockRecord`).\n *\n * ## \u26A0\uFE0F This flow is INERT until an install arms the gate, and that is by design\n *\n * REQ-0006 *Disposition*: \"**Both gates must be configurable \u2014 off by\n * default**, so existing installs keep today's amount-only behaviour.\"\n *\n * The switch is `crm_opportunity.qualification_approval_status`'s\n * `defaultValue`, \u26D4 not this flow's `status` (`draft` still fires triggers and\n * `obsolete` is a gate no install can turn ON \u2014 measured and recorded in\n * `lead-conversion-approval.flow.ts`; \u26D4 do not re-derive it here). Shipped,\n * that default is `not_required`, so no deal is ever born `pending`, the start\n * condition below is false for every record that has ever existed, and this\n * flow opens nothing \u2014 it costs one predicate evaluation per update. An\n * install arms the gate by changing that one value to `'pending'`.\n *\n * ## With the status-change gate armed too\n *\n * \u7ACB\u9879 comes first: while this verdict is `pending` or `rejected`,\n * `opportunity_lifecycle` refuses a new `requested_status`, so no status-change\n * approval can be asked for. Once \u7ACB\u9879 is `approved` this flow is out of reach\n * for good, and the status-change gate behaves exactly as it does alone. This\n * flow's own writes carry neither `stage` nor `requested_status`, so they can\n * trip neither gate; both columns sit in the hook's APPROVAL_FIELDS so the\n * closed-deal freeze cannot refuse them either.\n *\n * \u26A0\uFE0F The platform holds ONE pending approval per record (`openNodeRequest`\n * throws `DUPLICATE_REQUEST` otherwise, `@objectstack/plugin-approvals`\n * 17.6.0), so the opportunity gates never stack on one deal: a request a\n * second gate would open while another is pending is refused, not queued.\n * Measured on a 17.6.0 boot with this gate armed: a deal raised past\n * `LARGE_DEAL_AMOUNT` while its \u7ACB\u9879 request waited failed\n * `opportunity_approval`'s run with that error (logged, nothing opened); the\n * amount approval opened on the next write, which was this flow's own verdict\n * stamp, because the amount flow's entry tests the current value.\n */\nexport const OpportunityQualificationApprovalFlow: Flow = {\n  name: 'opportunity_qualification_approval',\n  label: 'Opportunity Qualification Approval',\n  description:\n    'The \u7ACB\u9879 sign-off a deal needs before its stage or won/lost call may change. Inert unless the install arms the gate on crm_opportunity.qualification_approval_status.',\n  type: 'record_change',\n  status: 'active',\n  // The reading both sibling gates record from `opportunity_approval`'s\n  // measured failure: a gate that engages only for writers carrying a session\n  // is not a control. The verdict writes below also land on a column the\n  // readonly strip protects, which only a platform write reaches.\n  runAs: 'system',\n\n  variables: [\n    { name: 'opportunityId', type: 'text', isInput: true, isOutput: false },\n  ],\n\n  nodes: [\n    {\n      id: 'start',\n      type: 'start',\n      label: 'Start',\n      config: {\n        objectName: 'crm_opportunity',\n        triggerType: 'record-after-update',\n        // TOTALITY (AGENTS.md \u2014 validation predicates must be TOTAL): `has()`\n        // on every read; the absent case reads as \"not gated\".\n        //\n        // Three halves, the status-change gate's own:\n        //\n        // - the gate is ARMED: `pending` or `rejected`. `rejected` re-opens on a\n        //   new request because the hook refuses the gated acts in both states \u2014\n        //   if only `pending` entered here, a rejected deal could never qualify.\n        // - the request is ticked;\n        // - the request is NEW on this write. TRANSITION, not current value:\n        //   the approval node's `pending` stamp through `approvalStatusField` is\n        //   an update of this record while the request is still ticked, and a\n        //   current-value test re-fires on it. Measured on a 17.6.0 boot with\n        //   this term deleted: one re-entry per request, caught only by the\n        //   engine's self-trigger guard (\"the guard as authored does not\n        //   exclude the flow's own write-back\"); with it, none. `previous.*` is\n        //   guarded FAIL-CLOSED: no visible prior value, no visible new request.\n        //\n        // `mark_qualified` leaves the gate `approved` (out of reach) and\n        // `clear_request` unticks the request, so neither re-enters.\n        condition: P`has(record.qualification_approval_status)\n          && (record.qualification_approval_status == \"pending\" || record.qualification_approval_status == \"rejected\")\n          && has(record.qualification_requested) && record.qualification_requested == true\n          && has(previous.qualification_requested) && previous.qualification_requested != true`,\n      },\n    },\n    {\n      id: 'get_opportunity',\n      type: 'get_record',\n      label: 'Get Opportunity',\n      config: { objectName: 'crm_opportunity', filter: { id: cel`record.id` }, outputVariable: 'oppRecord' },\n    },\n    {\n      id: 'qualification_review',\n      type: 'approval',\n      label: 'Qualification Review',\n      config: {\n        // The customer's chain is \u9500\u552E\u8D1F\u8D23\u4EBA / \u4E8B\u4E1A\u90E8\u5BA1\u6279\u5C97 \u2192 \u4E8B\u4E1A\u90E8\u8D1F\u8D23\u4EBA; the generic\n        // shape core ships is the manager bench both sibling gates route to. A\n        // second tier, or a different position, is overlay configuration\n        // (REQ-0006: the named approval chains are C).\n        approvers: [{ type: 'position', value: 'sales_manager' }],\n        // Explicit though it is the schema default, as every sibling authors\n        // it: an empty bench would leave the request undecidable \u2014 here, a\n        // deal that can never move its stage.\n        onEmptyApprovers: 'admin_rescue',\n        behavior: 'first_response',\n        // \u26A0\uFE0F `false`, NOT the status-change gate's `true` \u2014 the one term this\n        // node deliberately takes from the LEAD gate instead. Step 11 says it\n        // in as many words: \u300C\u65B0\u589E\u5546\u673A\u53EF\u8DDF\u8FDB\u300D. A deal awaiting \u7ACB\u9879 is still being\n        // worked \u2014 the narrative, the customer calendar, the amount and Will\n        // Bid are what the approver reads \u2014 and locking it would stop that work\n        // for as long as the approver takes. The two acts the gate exists to hold\n        // are refused by `opportunity_lifecycle` whether or not a request is\n        // open, so the lock would add nothing but the freeze.\n        lockRecord: false,\n        approvalStatusField: 'qualification_approval_status',\n      },\n    },\n    {\n      id: 'mark_qualified',\n      type: 'update_record',\n      label: 'Mark Qualified',\n      config: {\n        objectName: 'crm_opportunity',\n        filter: { id: cel`record.id` },\n        fields: { qualification_approval_status: 'approved' },\n      },\n    },\n    {\n      // A rejected request is cleared, not left standing, and the verdict stays\n      // `rejected` so the hook keeps refusing the gated acts: the way on is a\n      // new request, which the start condition opens as a fresh approval.\n      id: 'clear_request',\n      type: 'update_record',\n      label: 'Clear Rejected Request',\n      config: {\n        objectName: 'crm_opportunity',\n        filter: { id: cel`record.id` },\n        fields: { qualification_approval_status: 'rejected', qualification_requested: false },\n      },\n    },\n    { id: 'end', type: 'end', label: 'End' },\n  ],\n\n  edges: [\n    { id: 'e1', source: 'start', target: 'get_opportunity', type: 'default' },\n    { id: 'e2', source: 'get_opportunity', target: 'qualification_review', type: 'default' },\n    // Approval-node branch labels.\n    { id: 'e3', source: 'qualification_review', target: 'mark_qualified', type: 'default', label: 'approve' },\n    { id: 'e4', source: 'qualification_review', target: 'clear_request', type: 'default', label: 'reject' },\n    { id: 'e5', source: 'mark_qualified', target: 'end', type: 'default' },\n    { id: 'e6', source: 'clear_request', target: 'end', type: 'default' },\n  ],\n};\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/sales/flows/opportunity-stagnation.flow.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/sales/flows\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/sales/flows/opportunity-stagnation.flow.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport { P, cel } from '@objectstack/spec';\nimport type * as Automation from '@objectstack/spec/automation';\nimport { guarded } from './_guarded-iteration';\ntype Flow = Automation.Flow;\n\n/**\n * Opportunity Stagnation \u2014 scheduled \"deal-rot\" detector.\n *\n * This daily sweep is what acts on `stage_entry_date` (stamped by the lifecycle\n * hook on insert and on every stage change): it finds open opportunities\n * stalled longer than the threshold, nudges the owner and books a follow-up\n * task so the deal re-enters the working set. A deal with an\n * open stall task is skipped (idempotency), so each stall episode produces\n * exactly one nudge; completing the task re-arms it.\n *\n * Capabilities exercised: scheduled trigger + `loop` + `notify` + task\n * creation. Pipeline-hygiene automation is one of the highest-ROI uses of\n * Flows in a sales org.\n */\nconst STALE_THRESHOLD_DAYS = 14;\n\nexport const OpportunityStagnationFlow: Flow = {\n  name: 'opportunity_stagnation',\n  label: 'Stalled Deal Alert',\n  description: 'Daily sweep: nudge owners about open opportunities stuck in-stage beyond the threshold.',\n  type: 'schedule',\n  status: 'active',\n  // Scheduled runs have no trigger user, so under the default runAs:'user' the\n  // data nodes execute UNSCOPED anyway. Declare runAs:'system' to make that\n  // RLS-bypassing elevation explicit and intended (ADR-0049).\n  runAs: 'system',\n\n  variables: [],\n\n  nodes: [\n    { id: 'start', type: 'start', label: 'Start (daily 07:30)', config: { schedule: '30 7 * * *' } },\n    {\n      id: 'query_stalled', type: 'get_record', label: 'Find Stalled Deals',\n      config: {\n        objectName: 'crm_opportunity',\n        // \u26D4 Predicate on the STORED `stage_entry_date`, never on\n        // `days_in_stage`: the latter is a formula, computed after the query, so\n        // as a filter key it addresses a column that does not exist.\n        // `entry < today \u2212 N`\n        // is the same test as `days_in_stage > N`, computed by a CEL value\n        // envelope (the `isoDate(daysAgo(n))` spelling; contract-renewal uses\n        // its `daysFromNow` twin).\n        // A row with a null `stage_entry_date` does not satisfy `$lt` and is\n        // skipped, preserving \"nothing has stagnated yet\" for unstamped rows.\n        filter: {\n          stage: { $nin: ['closed_won', 'closed_lost'] },\n          stage_entry_date: { $lt: cel`isoDate(daysAgo(${STALE_THRESHOLD_DAYS}))` },\n        },\n        limit: 500,\n        outputVariable: 'oppList',\n      },\n    },\n    {\n      id: 'loop_opps', type: 'loop', label: 'For Each Stalled Deal',\n      config: {\n        collection: cel`oppList`,\n        iteratorVariable: 'currentOpp',\n        body: guarded('opp', {\n          nodes: [\n            {\n              // Idempotency gate: a still-open stall task means this deal was\n              // already nudged. \u26D4 Without it the daily sweep re-notifies and\n              // re-creates an identical task every morning for as long as the\n              // deal stays stalled \u2014 an unbounded duplicate pile-up.\n              id: 'find_existing_task', type: 'get_record', label: 'Already Nudged?',\n              config: {\n                objectName: 'crm_task',\n                filter: {\n                  related_to_opportunity: cel`currentOpp.id`,\n                  subject: cel`'Advance stalled deal: ' + currentOpp.name`,\n                  status: { $nin: ['completed'] },\n                },\n                outputVariable: 'existingStallTask',\n              },\n            },\n            {\n              // Gateway only \u2014 the predicate lives on the out-edge.\n              id: 'check_not_nudged', type: 'decision', label: 'First Nudge?',\n            },\n            {\n              // Owner only: `{currentOpp.owner_id.manager}` cannot traverse a\n              // lookup in flow templates \u2014 it interpolates to the literal\n              // \"undefined\" (cf. opportunity_won_alert).\n              id: 'notify_owner', type: 'notify', label: 'Nudge Owner',\n              config: {\n                recipients: [cel`has(currentOpp.owner_id) ? currentOpp.owner_id : null`],\n                channels: ['inbox', 'email'],\n                topic: 'deal_stalled',\n                template: 'crm.deal_stalled',\n                templateData: {\n                  name: cel`currentOpp.name`, stage: cel`currentOpp.stage`,\n                  days_in_stage: cel`currentOpp.days_in_stage`,\n                },\n                actionUrl: '/crm_opportunity/{{currentOpp.id}}',\n              },\n            },\n            {\n              id: 'create_followup_task', type: 'create_record', label: 'Create Follow-up Task',\n              config: {\n                objectName: 'crm_task',\n                fields: {\n                  subject: cel`'Advance stalled deal: ' + currentOpp.name`,\n                  type: 'follow_up', priority: 'high', status: 'not_started',\n                  due_date: cel`isoDate(daysFromNow(2))`,\n                  owner_id: cel`has(currentOpp.owner_id) ? currentOpp.owner_id : null`,\n                  // ORG PARTITION. A schedule trigger carries no\n                  // organization, so without this the nudge task is born\n                  // `organization_id` NULL \u2014 outside every org partition.\n                  // Upstream ruling objectstack#6155 Q2=A assigns the answer to\n                  // the flow author; the task belongs to the org of the deal it\n                  // nudges. `crm_opportunity` carries the column, so the read\n                  // resolves. It is deliberately UNGUARDED: on 17.x a source\n                  // lacking it interpolated to `undefined` and landed as NULL\n                  // while looking declared; CEL fails the iteration instead, and\n                  // a `has()` guard would write that NULL back.\n                  organization_id: cel`currentOpp.organization_id`,\n                  related_to_type: 'crm_opportunity',\n                  related_to_opportunity: cel`currentOpp.id`,\n                },\n              },\n            },\n          ],\n          edges: [\n            { id: 'b1', source: 'find_existing_task', target: 'check_not_nudged', type: 'default' },\n            // \"Already nudged\" has no edge, so the loop moves to the next item.\n            // This edge is the ONLY site for the predicate: a `decision`\n            // node's singular `config.condition` is never read, so a node copy\n            // would be inert metadata free to drift away from what runs.\n            { id: 'b2', source: 'check_not_nudged', target: 'notify_owner', type: 'conditional', condition: P`existingStallTask == null`, label: 'First nudge' },\n            { id: 'b3', source: 'notify_owner', target: 'create_followup_task', type: 'default' },\n          ],\n        }),\n      },\n    },\n    { id: 'end', type: 'end', label: 'End' },\n  ],\n\n  edges: [\n    { id: 'e1', source: 'start', target: 'query_stalled', type: 'default' },\n    { id: 'e2', source: 'query_stalled', target: 'loop_opps', type: 'default' },\n    { id: 'e3', source: 'loop_opps', target: 'end', type: 'default' },\n  ],\n};\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/sales/flows/forecast-snapshot.flow.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/sales/flows\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/sales/flows/forecast-snapshot.flow.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport { P, expression, cel } from '@objectstack/spec';\nimport type * as Automation from '@objectstack/spec/automation';\nimport { guarded } from './_guarded-iteration';\ntype Flow = Automation.Flow;\n\n/**\n * Forecast Snapshot \u2014 nightly per-owner pipeline snapshot into `crm_forecast`.\n *\n * `forecast.hook.ts` only DERIVES fields on a row someone else creates, so this\n * sweep is what creates them. Without it the forecast object, its\n * `attainment_pct` / `coverage_ratio` formulas, the `forecast_metrics` dataset\n * and the dashboard's quota-attainment table all run on hand-seeded demo rows.\n *\n * ## Buckets\n *\n * Amounts are aggregated from `crm_opportunity` by `forecast_category` \u2014 the\n * stored, indexed column the opportunity lifecycle hook derives from `stage`,\n * and the same column the \"Commit & Best Case\" list view and the\n * `pipeline_by_forecast_category` dashboard widget already group on. \u26D4 Never\n * read the snapshot off `probability` instead: that creates a SECOND definition\n * of \"commit\" that silently disagrees with those surfaces.\n *\n * The buckets are CUMULATIVE, the standard forecast ladder \u2014 and the shape the\n * object's own fields already assume (`pipeline` is \"all open opportunities\",\n * so it necessarily contains the other two), the seeded magnitudes show\n * (pipeline > best case > commit), and the opportunity `closing_this_quarter`\n * view spells out by treating `['commit', 'best_case']` as one bucket:\n *\n *   pipeline_amount  \u2192 every OPEN opportunity closing in the period\n *   best_case_amount \u2192 open, forecast_category \u2208 { best_case, commit }\n *   commit_amount    \u2192 open, forecast_category = commit\n *   closed_amount    \u2192 stage = closed_won, closing in the period\n *\n * `quota` is deliberately never written: it is maintained by hand until a\n * quota model exists, and a sweep that reset it every night would erase the\n * denominator of `attainment_pct`.\n *\n * ## Shape\n *\n * Per owner: ensure the current-period row exists, re-read it, then sum four\n * scoped queries into it. Two things force that ordering.\n *\n * 1. The period window is DATA, not arithmetic. The 17.x flow template\n *    resolved `{TODAY()}` and day offsets only \u2014 it could not say \"the first\n *    day of this calendar quarter\". So the flow selects the row whose window\n *    CONTAINS today (`period_start <= today <= period_end`), lets `forecast.hook.ts`\n *    derive a calendar-true window on create, and then reads the boundaries\n *    back off the row to scope the opportunity queries. One definition of \"the\n *    current period\", owned by the object.\n * 2. Sums come from four separate `get_record` + `loop` pairs rather than one\n *    query with in-loop branching. A filter is plain metadata, so the bucket\n *    definitions stay declarative and greppable; the accumulators stay pure\n *    CEL arithmetic (see `sumBucket`).\n *\n * Idempotency: the row is keyed by (owner, period, containing window), so a\n * re-run finds it and OVERWRITES the amounts instead of inserting a second\n * row \u2014 the same upsert discipline as `contract_renewal` /\n * `opportunity_stagnation`. Re-running is how a snapshot stays current, and it\n * is the only way an amount ever decreases.\n *\n * ## Two questions, two scopes \u2014 a manual forecast SUPPRESSES the sweep\n *\n * \u26D4 Never answer both questions with one filter. The window answers \"has this\n * period been handled?\" and does NOT answer \"which row do I own?\". Used for\n * both, it destroys a manager's typed numbers: `source: 'manual'` is one of\n * three documented origins, and a hand-entered current-quarter row satisfies the\n * window filter exactly as the sweep's own row does, since both ends of the\n * window are pinned to the calendar quarter. The sweep then adopts it,\n * overwrites the four amounts, restamps `snapshot_date` and flips `source` to\n * `scheduled`. `quota` survives (it is never written), so attainment silently\n * re-bases onto swept numbers and the row still looks plausible.\n *\n * So the two jobs read through two filters:\n *\n *   gate  (`find_forecast`)   \u2192 CURRENT_PERIOD_FILTER \u2014 ANY row in the window,\n *                               manual included. \"Handled\" is about the period,\n *                               not about who handled it.\n *   write (`reload_forecast`) \u2192 OWNED_PERIOD_FILTER  \u2014 only rows the sweep\n *                               wrote (`source: 'scheduled'`).\n *\n * and `check_owned` turns \"the window is handled, but not by a row I own\" into\n * a stand-down: no write, and \u2014 equally load-bearing \u2014 no second row.\n *\n * \u26D4 Never reach that by excluding non-`scheduled` rows from ONE shared filter.\n * The sweep would stop finding the manual row, decide the period was unhandled\n * and OPEN a duplicate in the same window \u2014 and `this_quarter_forecasts` and the\n * quota-attainment widget pin `period_start` by equality, so both would match\n * two rows.\n *\n * The way out stays open: delete the manual row and the next sweep opens its\n * own again. Automation an override cannot silence is not an override.\n *\n * Note the scope is `source == 'scheduled'`, not `source != 'manual'`: an `ai`\n * row is equally not the sweep's to overwrite, and gets the same deference.\n *\n * Scope: an \"active opportunity owner\" is a user owning at least one\n * opportunity that is not `closed_lost`. Users with none are skipped entirely,\n * so a fresh install does not litter a zero row per employee.\n */\n\n/**\n * The period this sweep snapshots. `quarter` because that is what every\n * consumer reads: the `this_quarter_forecasts` view filters `period: 'quarter'`\n * and the quota-attainment table is a quarterly scoreboard. A monthly cadence\n * would be a second flow, not a flag \u2014 the upsert key is (owner, period).\n */\nconst SNAPSHOT_PERIOD = 'quarter';\n\n/** Open = not yet resolved either way. Both closed stages leave the pipeline. */\nconst OPEN_STAGES = { $nin: ['closed_won', 'closed_lost'] };\n\n/**\n * Window the current-period row: `period_start <= today <= period_end`.\n *\n * The IDEMPOTENCY scope \u2014 deliberately source-blind. \"Has this period been\n * handled?\" is a question about the window, so a manual row answers it just as\n * a scheduled one does, and the sweep opens nothing beside it.\n */\nconst CURRENT_PERIOD_FILTER = {\n  owner_id: cel`currentOwner.id`,\n  period: SNAPSHOT_PERIOD,\n  period_start: { $lte: cel`isoDate(today())` },\n  period_end: { $gte: cel`isoDate(today())` },\n};\n\n/**\n * The same window narrowed to the rows this sweep OWNS \u2014 its WRITE scope.\n *\n * `source` is what separates the two jobs. Anything else in the window\n * belongs to a human (`manual`) or an agent (`ai`) and is theirs to keep; a\n * miss here is the stand-down signal `check_owned` reads, not a reason to\n * create a second row. Narrowing the write scope also makes the target\n * DETERMINISTIC when a manager adds a manual row beside an existing scheduled\n * one: `findOne` over the shared window would hand back whichever row the\n * driver happened to order first.\n */\nconst OWNED_PERIOD_FILTER = { ...CURRENT_PERIOD_FILTER, source: 'scheduled' };\n\n/**\n * Opportunities of the owner in flight during the snapshot window.\n *\n * ## The organization pin\n *\n * `owner_id` and the period window are both organization-NEUTRAL predicates,\n * and this sweep runs `runAs: 'system'` \u2014 the one context the driver's\n * organization predicate does not constrain. Without the pin below, an owner\n * holding opportunities in more than one organization has every one of them\n * summed into the single row `CURRENT_PERIOD_FILTER` selects: one tenant's\n * forecast row reporting another tenant's pipeline. Nothing is NULL-partitioned\n * and no index is violated \u2014 the numbers are simply wrong, and wrong in the\n * direction that looks plausible. `sys_user` is what makes it reachable:\n * identity is GLOBAL and declares no `organization_id`, so the per-owner loop\n * item cannot narrow anything.\n *\n * The pin is the target row's own organization, read back off\n * `currentForecast`. That is the SAME \"prove the source carries the right\n * organization\" mechanism `ownerAnyDeal.organization_id` establishes on\n * `create_forecast`, inverted \u2014 not a second one. It is in scope by\n * construction: `currentForecast` already supplies the window boundaries in\n * this very filter, and `reload_forecast` binds it before any bucket runs.\n *\n * What this does NOT do: give a cross-organization owner one row per\n * organization. `crm_forecast` is still keyed by (owner, period), so such an\n * owner's snapshot now reports THIS organization's numbers only \u2014 true but\n * incomplete, and strictly better than the cross-tenant total it replaces.\n * Whether that key should widen is a product decision, recorded on #1372 and\n * deliberately not undertaken here.\n */\nconst inPeriod = (extra: Record<string, unknown>) => ({\n  owner_id: cel`currentOwner.id`,\n  organization_id: cel`currentForecast.organization_id`,\n  close_date: {\n    $gte: cel`currentForecast.period_start`,\n    $lte: cel`currentForecast.period_end`,\n  },\n  ...extra,\n});\n\n/**\n * One `get_record` + `loop` pair that sums `amount` into `total`.\n *\n * The accumulator is a CEL value envelope, so its operands are TYPED:\n * `double()` turns a currency some drivers return as a string (`\"90000\"`) into\n * a number, and a decimal amount keeps its cents. \u26D4 Never a bare\n * `double(amount)`: it ERRORS on null \u2014 `found no matching overload for\n * 'double(null)'` \u2014 and one opportunity without an amount would fail the\n * owner's whole sweep. The `has()` / `isBlank()` guard sums a null or absent\n * amount as 0. `expression()` rather than `P`: the source splices the node's\n * variable names, which the tag would JSON-quote.\n */\nconst sumBucket = (key: string, label: string, filter: Record<string, unknown>, total: string, item = `current_${key}`) => ({\n  find: {\n    id: `find_${key}`,\n    type: 'get_record' as const,\n    label: `Find ${label}`,\n    config: {\n      objectName: 'crm_opportunity',\n      filter,\n      limit: 500,\n      outputVariable: `${key}Opps`,\n    },\n  },\n  sum: {\n    id: `sum_${key}`,\n    type: 'loop' as const,\n    label: `Sum ${label}`,\n    config: {\n      collection: expression(`${key}Opps`, 'cel'),\n      iteratorVariable: item,\n      body: {\n        nodes: [\n          {\n            id: `add_${key}`,\n            type: 'assignment' as const,\n            label: `Add to ${label}`,\n            config: {\n              assignments: {\n                [total]: expression(`${total} + (!has(${item}.amount) || isBlank(${item}.amount) ? 0.0 : double(${item}.amount))`, 'cel'),\n              },\n            },\n          },\n        ],\n        edges: [],\n      },\n    },\n  },\n});\n\nconst BUCKETS = [\n  sumBucket('pipeline', 'Open Pipeline', inPeriod({ stage: OPEN_STAGES }), 'pipelineTotal'),\n  sumBucket(\n    'best_case',\n    'Best Case',\n    inPeriod({ stage: OPEN_STAGES, forecast_category: { $in: ['best_case', 'commit'] } }),\n    'bestCaseTotal',\n  ),\n  sumBucket(\n    'commit',\n    'Commit',\n    inPeriod({ stage: OPEN_STAGES, forecast_category: 'commit' }),\n    'commitTotal',\n  ),\n  sumBucket('won', 'Closed Won', inPeriod({ stage: 'closed_won' }), 'closedTotal'),\n];\n\n/**\n * The per-owner body runs as one straight line once the THREE gates pass:\n * reset \u2192 (find/sum) \u00D7 4 \u2192 write.\n *\n * \u26D4 The chain must start AFTER the `check_owned` gateway: every edge derived\n * from this list is unconditional, and `check_owned`'s out-edge is not.\n */\nconst OWNER_CHAIN = [\n  'reset_totals',\n  ...BUCKETS.flatMap((b) => [b.find.id, b.sum.id]),\n  'write_snapshot',\n];\n\nexport const ForecastSnapshotFlow: Flow = {\n  name: 'forecast_snapshot',\n  label: 'Forecast Snapshot',\n  description:\n    'Nightly sweep: upsert a current-quarter crm_forecast row per active opportunity owner with pipeline, best-case, commit and closed-won totals.',\n  type: 'schedule',\n  status: 'active',\n  // Scheduled runs have no trigger user, so under the default runAs:'user' the\n  // data nodes execute UNSCOPED anyway. Declare runAs:'system' to make that\n  // RLS-bypassing elevation explicit and intended (ADR-0049) \u2014 and it\n  // is load-bearing here: `crm_forecast` is `sharingModel: 'private'`, so a\n  // user-scoped sweep could only ever see its own rows.\n  runAs: 'system',\n\n  variables: [],\n\n  nodes: [\n    { id: 'start', type: 'start', label: 'Start (daily 03:00)', config: { schedule: '0 3 * * *' } },\n    {\n      // Every user is a candidate; the `has_deals` gate below decides who is\n      // actually an opportunity owner. Filtering `sys_user` here instead would\n      // hard-code an activity flag this app does not own.\n      // No `filter` key: an EMPTY filter node (`{}`) reduces to TRUE and\n      // matches every row, so it is indistinguishable from an absent key \u2014\n      // ObjectStack 17.0.0-rc.6 promotes the pair to an author-time error\n      // (`filter-empty-node`) precisely because only the absent key SAYS\n      // \"every user is a candidate\" to the next reader. The `has_deals` gate\n      // below is what actually narrows the set.\n      id: 'query_owners', type: 'get_record', label: 'Find Users',\n      config: { objectName: 'sys_user', limit: 500, outputVariable: 'ownerList' },\n    },\n    {\n      id: 'loop_owners', type: 'loop', label: 'For Each Owner',\n      config: {\n        collection: cel`ownerList`,\n        iteratorVariable: 'currentOwner',\n        body: guarded('owner', {\n          nodes: [\n            {\n              // Cheap findOne gate: a user with no live opportunity is not a\n              // forecast owner, and must not get a row (a fresh install would\n              // otherwise gain one empty snapshot per employee).\n              id: 'find_any_deal', type: 'get_record', label: 'Owns Any Live Deal?',\n              config: {\n                objectName: 'crm_opportunity',\n                filter: { owner_id: cel`currentOwner.id`, stage: { $nin: ['closed_lost'] } },\n                outputVariable: 'ownerAnyDeal',\n              },\n            },\n            {\n              // Gateway only \u2014 the predicate lives on the out-edge.\n              id: 'has_deals', type: 'decision', label: 'Active Owner?',\n            },\n            {\n              // Idempotency gate AND period lookup in one read: the row whose\n              // window contains today IS this owner's current-period snapshot.\n              id: 'find_forecast', type: 'get_record', label: 'Current-Period Snapshot?',\n              config: {\n                objectName: 'crm_forecast',\n                filter: CURRENT_PERIOD_FILTER,\n                outputVariable: 'existingForecast',\n              },\n            },\n            {\n              // Gateway only \u2014 the predicate lives on the out-edges.\n              id: 'check_missing', type: 'decision', label: 'First Snapshot This Period?',\n            },\n            {\n              // Only `period` is supplied: `forecast.hook.ts` derives\n              // period_start/period_end/period_label so the boundaries are\n              // calendar-true without the flow doing date arithmetic it\n              // cannot do. `quota` is omitted on purpose \u2014 see the header.\n              // A leaf node: the two mutually-exclusive edges out of\n              // `check_missing` both converge on `reload_forecast`, so the\n              // chain below runs exactly once on either path.\n              id: 'create_forecast', type: 'create_record', label: 'Open Snapshot Row',\n              config: {\n                objectName: 'crm_forecast',\n                fields: {\n                  owner_id: cel`currentOwner.id`,\n                  // ORG PARTITION. A schedule trigger carries no\n                  // organization, so without this the snapshot row is born\n                  // `organization_id` NULL \u2014 outside every org partition, where\n                  // an `(organization_id, \u2026)` unique index does not constrain\n                  // and org-scoped reads never see it. Upstream ruling\n                  // objectstack#6155 Q2=A assigns the answer to the flow author.\n                  //\n                  // The source is `ownerAnyDeal`, NOT `currentOwner`. The loop\n                  // item here is a `sys_user` row, and `sys_user` declares NO\n                  // `organization_id` \u2014 identity is global, org-partitioned it\n                  // is not (it carries `primary_business_unit_id` instead).\n                  // On 17.x `{currentOwner.organization_id}` interpolated to\n                  // `undefined` and landed as NULL: the publish guard, which only\n                  // checks that the key is declared, went green over a row still\n                  // born outside every partition (measured, not assumed). Under\n                  // CEL that read fails the iteration instead.\n                  //\n                  // `ownerAnyDeal` is the `crm_opportunity` from `find_any_deal`\n                  // \u2014 it carries the column, and edge `b2` (`ownerAnyDeal !=\n                  // null`) is the only route to this node, so it is never null\n                  // here. Semantically right too: an owner's forecast belongs to\n                  // the org their pipeline is in.\n                  organization_id: cel`ownerAnyDeal.organization_id`,\n                  period: SNAPSHOT_PERIOD,\n                  snapshot_date: cel`isoDate(today())`,\n                  source: 'scheduled',\n                  pipeline_amount: 0,\n                  best_case_amount: 0,\n                  commit_amount: 0,\n                  closed_amount: 0,\n                },\n              },\n            },\n            {\n              // Re-read rather than reuse the create output, so both paths\n              // (row already existed / row just created) hand the rest of the\n              // body ONE variable carrying the hook-derived period window.\n              //\n              // \u26D4 Scope this to OWNED_PERIOD_FILTER, never to the gate's\n              // window: this read chooses the row that gets WRITTEN, and the\n              // sweep only ever owns its own. A miss binds `currentForecast` to\n              // null \u2014 `get_record` always binds \u2014 which is exactly what\n              // `check_owned` below is there to read.\n              id: 'reload_forecast', type: 'get_record', label: 'Load Snapshot Row',\n              config: {\n                objectName: 'crm_forecast',\n                filter: OWNED_PERIOD_FILTER,\n                outputVariable: 'currentForecast',\n              },\n            },\n            {\n              // Gateway only \u2014 the predicate lives on the out-edge.\n              //\n              // The stand-down gate. The window is handled either way by the\n              // time we get here; this asks whether the row handling it is the\n              // sweep's. Same single-out-edge skip shape as `has_deals`: when\n              // the only conditional edge does not match, the iteration ends and\n              // the engine records the unreached nodes as `skipped` with this\n              // node as `skippedBy` \u2014 so a stand-down is visible in the run log\n              // rather than silent.\n              id: 'check_owned', type: 'decision', label: 'Sweep Owns This Row?',\n            },\n            {\n              // Accumulators live in the flow-wide variable map (a loop body\n              // shares the enclosing scope), so they MUST be zeroed per owner\n              // or every rep inherits the previous rep's totals.\n              id: 'reset_totals', type: 'assignment', label: 'Reset Totals',\n              config: {\n                assignments: {\n                  pipelineTotal: 0,\n                  bestCaseTotal: 0,\n                  commitTotal: 0,\n                  closedTotal: 0,\n                },\n              },\n            },\n            ...BUCKETS.flatMap((b) => [b.find, b.sum]),\n            {\n              // Filter by id: `update_record` calls `data.update` without\n              // `options.multi`, so a filter matching more than one row fails\n              // (same constraint as demo_bootstrap / case_sla_monitor).\n              id: 'write_snapshot', type: 'update_record', label: 'Write Snapshot',\n              config: {\n                objectName: 'crm_forecast',\n                filter: { id: cel`currentForecast.id` },\n                fields: {\n                  pipeline_amount: cel`pipelineTotal`,\n                  best_case_amount: cel`bestCaseTotal`,\n                  commit_amount: cel`commitTotal`,\n                  closed_amount: cel`closedTotal`,\n                  snapshot_date: cel`isoDate(today())`,\n                  source: 'scheduled',\n                },\n              },\n            },\n          ],\n          edges: [\n            // Loop-nested conditions are explicit CEL envelopes (`P`): the\n            // conversion pass that wraps bare strings only walks a flow's\n            // TOP-LEVEL edges, so a bare string in here would fall through to\n            // the legacy template path and compare as text \u2014 a gate that never\n            // opens, silently.\n            //\n            // These edges are the ONLY site for their predicates: a\n            // `decision` node's singular `config.condition` is never read, so a\n            // node-level copy would be inert metadata free to drift.\n            { id: 'b1', source: 'find_any_deal', target: 'has_deals', type: 'default' },\n            // No matching edge simply ends this iteration, so a user with no\n            // live deal is skipped without a snapshot row.\n            { id: 'b2', source: 'has_deals', target: 'find_forecast', type: 'conditional', condition: P`ownerAnyDeal != null`, label: 'Active owner' },\n            { id: 'b3', source: 'find_forecast', target: 'check_missing', type: 'default' },\n            // Mutually exclusive, and both reach `reload_forecast` \u2014 never a\n            // default edge alongside a conditional one, which would traverse\n            // BOTH and double-count the whole chain.\n            { id: 'b4', source: 'check_missing', target: 'create_forecast', type: 'conditional', condition: P`existingForecast == null`, label: 'Open new row' },\n            { id: 'b5', source: 'check_missing', target: 'reload_forecast', type: 'conditional', condition: P`existingForecast != null`, label: 'Refresh existing row' },\n            { id: 'b6', source: 'create_forecast', target: 'reload_forecast', type: 'default' },\n            { id: 'b7', source: 'reload_forecast', target: 'check_owned', type: 'default' },\n            // The stand-down. No complementary edge, on purpose: the\n            // false branch is \"this window belongs to a manual/ai row\", and the\n            // whole point is that the sweep then does NOTHING \u2014 no write, and\n            // no second row. A variable-root null test, so no `has()` guard is\n            // needed: `reload_forecast` is a `get_record` and binds\n            // `currentForecast` unconditionally, to `null` on a miss.\n            { id: 'b8', source: 'check_owned', target: 'reset_totals', type: 'conditional', condition: P`currentForecast != null`, label: 'Sweep owns the row' },\n            ...OWNER_CHAIN.slice(0, -1).map((source, i) => ({\n              id: `c${i}`,\n              source,\n              target: OWNER_CHAIN[i + 1],\n              type: 'default' as const,\n            })),\n          ],\n        }),\n      },\n    },\n    { id: 'end', type: 'end', label: 'End' },\n  ],\n\n  edges: [\n    { id: 'e1', source: 'start', target: 'query_owners', type: 'default' },\n    { id: 'e2', source: 'query_owners', target: 'loop_owners', type: 'default' },\n    { id: 'e3', source: 'loop_owners', target: 'end', type: 'default' },\n  ],\n};\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/sales/flows/lead-assignment.flow.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/sales/flows\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/sales/flows/lead-assignment.flow.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport { P, cel } from '@objectstack/spec';\nimport type * as Automation from '@objectstack/spec/automation';\ntype Flow = Automation.Flow;\n\n/**\n * Lead Assignment & Routing \u2014 react the instant a new lead lands.\n *\n * Fires on lead *insert*, sets a rating-based `next_followup_date` SLA, and\n * alerts the lead's OWNER \u2014 the accountable party \u2014 to follow up.\n *\n * \u26D4 Never address a CRM position (`sales_manager` and friends) as a recipient.\n * Positions are not a messaging audience: the messaging service resolves\n * `user:` / `role:` (sys_member) / `team:` / `owner_of:`, and a bare position\n * name is stored verbatim as `sys_inbox_message.user_id`, matching no real user,\n * so the alert reaches nobody. With no territory / round-robin table modelled,\n * the owner is the correct recipient. (Swap to a `team:`/`role:` audience once a\n * manager group is seeded.)\n *\n * Trigger wiring: the `start` node declares `triggerType: 'record-after-create'`\n * so the record-change trigger provider binds it to the ObjectQL `afterInsert`\n * lifecycle hook. Firing on insert only means the SLA write does not re-trigger\n * the flow. The full record is seeded into the run, so fields are read via\n * `record.*` (no get_record round-trip needed).\n */\nexport const LeadAssignmentFlow: Flow = {\n  name: 'lead_assignment',\n  label: 'New Lead Routing & SLA',\n  description: 'On new lead: set a rating-based follow-up SLA and alert the lead owner.',\n  type: 'record_change',\n  status: 'active',\n  // A record-change flow fired by a SYSTEM write carries no trigger user\n  // either (ADR-0049). This is the population the flow is FOR:\n  // leads arrive from web-to-lead, a CSV import, a partner integration or a\n  // seed load, none of which carry a user session. Measured on 17.0.0-rc.2, a\n  // user-less run refuses `sla_hot` / `sla_std` outright, so the lead lands\n  // with no follow-up SLA and no alert at all \u2014 silently, since the refusal\n  // surfaces only in the server log.\n  //\n  // Elevating the USER-driven runs too is correct: the SLA stamp is the\n  // platform's routing decision about the row that just fired the trigger\n  // (keyed to `{record.id}`), not the submitting rep's own edit, and a rep who\n  // may create a lead is not thereby guaranteed edit rights on it.\n  runAs: 'system',\n\n  variables: [],\n\n  nodes: [\n    {\n      id: 'start', type: 'start', label: 'Start (lead created)',\n      config: { objectName: 'crm_lead', triggerType: 'record-after-create' },\n    },\n    {\n      // Branching lives on edges `e2` / `e3` \u2014 see the totality note there.\n      // This node carries no `config.condition`: the engine never evaluates a\n      // `decision` node's singular one, so a copy here would restate the gate\n      // without being the gate (17.0.0-rc.2's `flow-inert-node-condition`).\n      id: 'check_hot', type: 'decision', label: 'Hot Lead (rating \u2265 4)?',\n    },\n\n    // \u2500\u2500 Hot path: 1-day SLA, high-severity alert \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n    {\n      id: 'sla_hot', type: 'update_record', label: 'Set 1-Day SLA',\n      config: { objectName: 'crm_lead', filter: { id: cel`record.id` }, fields: { next_followup_date: cel`isoDate(daysFromNow(1))` } },\n    },\n    {\n      id: 'notify_hot', type: 'notify', label: 'Alert \u2014 Hot Lead',\n      config: {\n        // Route to the lead's OWNER (a real user id). A CRM position like\n        // 'sales_manager' is NOT a messaging audience \u2014 the messaging service\n        // resolves user:/role:(sys_member)/team:/owner_of:, and a bare\n        // 'sales_manager' was stored verbatim as sys_inbox_message.user_id,\n        // matching no real user, so these alerts reached nobody. owner is set\n        // on insert (defaultValue os.user.id) and is the accountable party.\n        recipients: [cel`record.owner_id`],\n        channels: ['inbox', 'email'],\n        severity: 'warning',\n        topic: 'lead_routing',\n        template: 'crm.lead_routing_hot',\n        templateData: {\n          first_name: cel`record.first_name`, last_name: cel`record.last_name`,\n          company: cel`record.company`, rating: cel`record.rating`,\n        },\n        actionUrl: '/crm_lead/{{record.id}}',\n      },\n    },\n\n    // \u2500\u2500 Standard path: 3-day SLA, normal alert \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n    {\n      id: 'sla_std', type: 'update_record', label: 'Set 3-Day SLA',\n      config: { objectName: 'crm_lead', filter: { id: cel`record.id` }, fields: { next_followup_date: cel`isoDate(daysFromNow(3))` } },\n    },\n    {\n      id: 'notify_std', type: 'notify', label: 'Alert \u2014 New Lead',\n      config: {\n        // Route to the lead's owner \u2014 see notify_hot for why a bare\n        // 'sales_manager' position never reached anyone.\n        recipients: [cel`record.owner_id`],\n        channels: ['inbox'],\n        topic: 'lead_routing',\n        template: 'crm.lead_routing_new',\n        templateData: {\n          first_name: cel`record.first_name`, last_name: cel`record.last_name`, company: cel`record.company`,\n        },\n        actionUrl: '/crm_lead/{{record.id}}',\n      },\n    },\n\n    { id: 'end', type: 'end', label: 'End' },\n  ],\n\n  edges: [\n    { id: 'e1', source: 'start', target: 'check_hot', type: 'default' },\n    // TOTALITY: these two edges must PARTITION every lead \u2014 a rating\n    // the predicate cannot read has to fall down one branch, never neither.\n    // Guarding both with `has(...) &&` would have traded a loud abort for a\n    // silent no-op (unrated lead \u2192 no SLA, no alert, no error), which is the\n    // \"declared \u2260 enforced\" shape this repo keeps deleting rules over. So the\n    // hot branch demands a readable rating and the standard branch absorbs\n    // everything else: an unrated lead is, correctly, not a hot lead.\n    //\n    // `rating` is neither required nor defaulted, so a lead written without one\n    // is stored with NO `rating` column on driver-memory / driver-mongodb.\n    // Measured end-to-end: the unguarded `record.rating >= 4` aborted with `No\n    // such key: rating` and an unrated lead got no SLA stamp and no alert at\n    // all. `has()` alone is not enough on an ORDERING comparison \u2014 an explicit\n    // `rating: null` passes `has()` and then aborts with `no such overload:\n    // dyn<null> >= int` \u2014 so both guards are required, in this order.\n    { id: 'e2', source: 'check_hot', target: 'sla_hot', type: 'conditional', condition: P`has(record.rating) && record.rating != null && record.rating >= 4`, label: 'Hot' },\n    { id: 'e3', source: 'check_hot', target: 'sla_std', type: 'conditional', condition: P`!has(record.rating) || record.rating == null || record.rating < 4`, label: 'Standard' },\n    { id: 'e4', source: 'sla_hot', target: 'notify_hot', type: 'default' },\n    { id: 'e5', source: 'notify_hot', target: 'end', type: 'default' },\n    { id: 'e6', source: 'sla_std', target: 'notify_std', type: 'default' },\n    { id: 'e7', source: 'notify_std', target: 'end', type: 'default' },\n  ],\n};\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/sales/flows/contact-welcome.flow.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/sales/flows\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/sales/flows/contact-welcome.flow.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport { P, cel } from '@objectstack/spec';\nimport type * as Automation from '@objectstack/spec/automation';\ntype Flow = Automation.Flow;\n\n/**\n * New-contact alert \u2014 record-change flow on contact insert.\n *\n * \u26D4 Notifies the OWNER, never the contact. `notify` addresses platform users \u2014\n * a raw email address is stored verbatim as an inbox `user_id` and reaches\n * nobody. A true outbound welcome email to the contact needs an email connector\n * action, not an inbox notification.\n *\n * Gated on `email_opt_out != true` so an opted-out contact triggers no outreach\n * prompt, and skipped entirely when there is no owner to notify.\n */\nexport const ContactWelcomeFlow: Flow = {\n  name: 'contact_welcome',\n  label: 'Contact Welcome',\n  description: 'On new contact: prompt the owner to welcome them.',\n  type: 'record_change',\n  status: 'active',\n  // A record-change flow fired by a SYSTEM write carries no trigger user\n  // either (ADR-0049) \u2014 and this flow exists FOR that\n  // population: the start condition below already documents the seeded /\n  // integration-written contacts whose `owner_id` the security middleware\n  // never stamped because the write carried no session.\n  //\n  // Measured honestly on 17.0.0-rc.2: this flow has NO data node today (start\n  // \u2192 notify \u2192 end), the runAs refusal covers get/create/update/delete only,\n  // and `notify` dispatches through the messaging service without a run data\n  // context \u2014 so a user-less run completes and delivers today, and this\n  // declaration changes nothing observable right now. It is declared anyway\n  // because the decision being recorded is \"record-change automation runs as\n  // the platform\", not \"this flow currently happens to have no data node\".\n  // The day a data node is added \u2014 or a start-node `config.expand`, which is\n  // the remedy the notify node's own error message recommends and which reads\n  // through the same guarded path \u2014 the elevation has already been reasoned\n  // about here rather than discovered as a refusal in production. Elevation is\n  // harmless for the user-driven runs: there is no data operation to scope.\n  runAs: 'system',\n  variables: [],\n  nodes: [\n    {\n      id: 'start', type: 'start', label: 'Start (contact created)',\n      config: {\n        objectName: 'crm_contact',\n        triggerType: 'record-after-create',\n        // TOTALITY: every `record.x` read carries a `has(record.x)`\n        // guard \u2014 see the house-rule block in\n        // `test/flow-condition-totality.test.ts`. The absent-key case is real\n        // here, not hypothetical: `owner_id` is auto-stamped by the security\n        // middleware only on writes that CARRY a user, and a system write \u2014\n        // seed data, an integration, a `runAs: 'system'` flow \u2014 short-circuits\n        // that middleware entirely. Such a row reaches driver-memory\n        // with NO `owner_id` column at all, so `record.owner_id != null` alone\n        // aborts with `No such key` and no seeded contact ever gets a welcome\n        // prompt. `!= null` is not a substitute for `has()`: on an absent key\n        // it aborts exactly like `== \"v\"` does. An absent `email_opt_out`\n        // means the contact has not opted out.\n        condition: P`has(record.owner_id) && record.owner_id != null\n          && (!has(record.email_opt_out) || record.email_opt_out != true)`,\n      },\n    },\n    {\n      id: 'send_welcome', type: 'notify', label: 'Prompt Owner to Welcome',\n      config: {\n        recipients: [cel`record.owner_id`],\n        channels: ['inbox', 'email'],\n        topic: 'contact_welcome',\n        template: 'crm.contact_welcome',\n        templateData: { first_name: cel`record.first_name`, last_name: cel`record.last_name` },\n        actionUrl: '/crm_contact/{{record.id}}',\n      },\n    },\n    { id: 'end', type: 'end', label: 'End' },\n  ],\n  edges: [\n    { id: 'e1', source: 'start', target: 'send_welcome', type: 'default' },\n    { id: 'e2', source: 'send_welcome', target: 'end', type: 'default' },\n  ],\n};\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/sales/flows/opportunity-won-alert.flow.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/sales/flows\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/sales/flows/opportunity-won-alert.flow.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport { P, cel } from '@objectstack/spec';\nimport type * as Automation from '@objectstack/spec/automation';\nimport { LARGE_DEAL_AMOUNT } from '../objects/_thresholds';\ntype Flow = Automation.Flow;\n\n/**\n * Large-deal-won alert \u2014 record-change flow on opportunity update.\n *\n * When a deal of $100K or more is marked closed_won, notify the owner \u2014 the\n * owner alone, not their manager (see the notify node for why the manager\n * cannot be reached).\n *\n * The cut is INCLUSIVE (`>=`): `LARGE_DEAL_AMOUNT` must mean one thing across\n * this alert, the approval entry gate and both sharing rules, so a deal at\n * exactly $100,000 is announced on win for the same reason it is shared with\n * leadership. \u26D4 Never let this site and the sharing rules cut differently \u2014 a\n * deal on the line then becomes visible to leadership and invisible to\n * governance.\n *\n * NB: `record.amount >= 100000` is authored as bare CEL against the\n * (string-serialized) currency field, which relies on the 7.7 numeric-hydration\n * fix; pre-7.7 it would have needed `double(record.amount)`.\n */\nexport const OpportunityWonAlertFlow: Flow = {\n  name: 'opportunity_won_alert',\n  label: 'Large Deal Won Alert',\n  description: 'On closed_won opportunities of $100K or more: notify the owner \u2014 the owner alone, not their manager.',\n  type: 'record_change',\n  status: 'active',\n  // A record-change flow fired by a SYSTEM write carries no trigger user\n  // either (ADR-0049). Deals reach `closed_won` through\n  // machinery as well as through a rep's own save \u2014 `lead_conversion` and the\n  // `contract_renewal` sweep both write opportunities, and the latter is\n  // itself `runAs: 'system'`.\n  //\n  // Measured honestly on 17.0.0-rc.2: this flow has NO data node (start \u2192\n  // notify \u2192 end), so the refusal does not reach it today and declaring\n  // `system` changes nothing observable. Declared for the same reason as\n  // `contact_welcome` \u2014 see the fuller note there. Nothing to scope, so\n  // elevating the user-driven runs costs nothing.\n  runAs: 'system',\n  variables: [],\n  nodes: [\n    {\n      id: 'start', type: 'start', label: 'Start (opp updated)',\n      config: {\n        objectName: 'crm_opportunity',\n        triggerType: 'record-after-update',\n        // `previous.stage` guard: fire on the TRANSITION into closed_won only.\n        // Without it every later edit of a won deal (seed-ownership\n        // claims, approval-status stamps, description tweaks) re-sent the\n        // congratulations blast. The trigger forwards `previous` into the\n        // condition scope (cf. the engine's record-change context).\n        // TOTALITY: `has(...)` on every read, plus `!= null` on the\n        // ordering comparison (`has()` passes an explicit null and\n        // `record.amount >= 100000` then aborts with\n        // `no such overload: dyn<null> >= int`).\n        //\n        // `previous.stage` is guarded FAIL-CLOSED \u2014 `has(previous.stage) &&`,\n        // not `!has(previous.stage) ||` \u2014 which is the opposite of how\n        // `record.stage` is guarded, deliberately. This term exists solely to\n        // suppress a re-fire, and the failure it was written for (a\n        // congratulations blast to management re-sent on every later edit of a\n        // won deal) is worse than a missed one. When the engine cannot see\n        // what the prior stage was it cannot see a TRANSITION either, so it\n        // must not claim one. In practice `previous` is a full prior row on\n        // every record-after-update; the shape this covers is a bulk\n        // `updateMany`, where ObjectQL never reads a prior row and `previous`\n        // arrives null \u2014 and firing one blast per row of a bulk update is\n        // exactly what nobody wants.\n        condition: P`has(record.stage) && record.stage == \"closed_won\"\n          && has(previous.stage) && previous.stage != \"closed_won\"\n          && has(record.amount) && record.amount != null && record.amount >= ${LARGE_DEAL_AMOUNT}`,\n      },\n    },\n    {\n      // The `label` names what this node actually does: it notifies the owner\n      // and nobody else. The `id` keeps its original `notify_management`\n      // spelling on purpose \u2014 `edges[]` reference nodes by id, so renaming one\n      // is a behaviour change, not a wording fix.\n      id: 'notify_management', type: 'notify', label: 'Notify Owner',\n      config: {\n        // Owner only: `{record.owner_id.manager}` cannot traverse a lookup on the\n        // raw trigger snapshot \u2014 it interpolates to the literal \"undefined\"\n        // and the message is delivered to a phantom user.\n        recipients: [cel`record.owner_id`],\n        channels: ['inbox', 'email'],\n        severity: 'info',\n        topic: 'large_deal_won',\n        template: 'crm.large_deal_won',\n        templateData: { name: cel`record.name`, amount: cel`record.amount` },\n        actionUrl: '/crm_opportunity/{{record.id}}',\n      },\n    },\n    { id: 'end', type: 'end', label: 'End' },\n  ],\n  edges: [\n    { id: 'e1', source: 'start', target: 'notify_management', type: 'default' },\n    { id: 'e2', source: 'notify_management', target: 'end', type: 'default' },\n  ],\n};\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/sales/flows/task-urgent-alert.flow.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/sales/flows\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/sales/flows/task-urgent-alert.flow.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport { P, cel } from '@objectstack/spec';\nimport type * as Automation from '@objectstack/spec/automation';\ntype Flow = Automation.Flow;\n\n/**\n * Urgent task alert \u2014 record-change flow on task insert.\n *\n * When an urgent, not-yet-completed task is created, notify its owner.\n */\nexport const TaskUrgentAlertFlow: Flow = {\n  name: 'task_urgent_alert',\n  label: 'Urgent Task Alert',\n  description: 'On new urgent task: notify the owner.',\n  type: 'record_change',\n  status: 'active',\n  // A record-change flow fired by a SYSTEM write carries no trigger user\n  // either (ADR-0049), and most urgent tasks in this app are\n  // machine-written: `case_status_side_effects` opens the escalation follow-up\n  // task, and the scheduled sweeps create their own \u2014 none of those writes\n  // carries a session.\n  //\n  // Measured honestly on 17.0.0-rc.2: this flow has NO data node (start \u2192\n  // notify \u2192 end), so the refusal does not reach it today and declaring\n  // `system` changes nothing observable. Declared for the same reason as\n  // `contact_welcome` \u2014 see the fuller note there: the recorded decision is\n  // that record-change automation runs as the platform, so a data node added\n  // later inherits an elevation that was reasoned about rather than one\n  // discovered as a production refusal. No data operation exists to scope, so\n  // elevating the user-driven runs costs nothing.\n  runAs: 'system',\n  variables: [],\n  nodes: [\n    {\n      id: 'start', type: 'start', label: 'Start (task created)',\n      config: {\n        objectName: 'crm_task',\n        triggerType: 'record-after-create',\n        // Gate on the `status` enum, not the `is_completed` boolean: on\n        // SQLite/libsql booleans persist as integer 1, so `is_completed != true`\n        // is `1 != true` = always true and the guard never trips (cf. the same\n        // hazard documented in case_escalation).\n        // TOTALITY: `has(...)` on every read. Both fields are `required`\n        // AND defaulted today, so this predicate measured total as authored \u2014\n        // but that is a property of `crm_task`'s schema, not of the predicate.\n        // Drop either default and the flow goes silently inert on\n        // driver-memory / driver-mongodb, with nothing to catch it. An absent\n        // `status` is not `completed`, so it must not suppress the alert.\n        condition: P`has(record.priority) && record.priority == \"urgent\"\n          && (!has(record.status) || record.status != \"completed\")`,\n      },\n    },\n    {\n      id: 'notify_owner', type: 'notify', label: 'Notify Owner',\n      config: {\n        recipients: [cel`record.owner_id`],\n        channels: ['inbox', 'email'],\n        severity: 'warning',\n        topic: 'urgent_task',\n        template: 'crm.urgent_task',\n        templateData: { subject: cel`record.subject` },\n        actionUrl: '/crm_task/{{record.id}}',\n      },\n    },\n    { id: 'end', type: 'end', label: 'End' },\n  ],\n  edges: [\n    { id: 'e1', source: 'start', target: 'notify_owner', type: 'default' },\n    { id: 'e2', source: 'notify_owner', target: 'end', type: 'default' },\n  ],\n};\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/sales/flows/task-due-reminder.flow.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/sales/flows\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/sales/flows/task-due-reminder.flow.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport { cel } from '@objectstack/spec';\nimport type * as Automation from '@objectstack/spec/automation';\nimport { guarded } from './_guarded-iteration';\ntype Flow = Automation.Flow;\n\n/**\n * Task Due Reminder \u2014 scheduled time-based reminders.\n *\n * The task schema carries `reminder_date` (and `due_date`), and the calendar /\n * gantt views *display* them; this flow is what watches the clock. It sweeps\n * tasks whose `reminder_date` has arrived (and that are still open and not yet\n * reminded), notifies the owner on the inbox + email channels, and stamps\n * `reminder_sent` so the same task is never alerted twice.\n *\n * Mirrors `case_sla_monitor` (scheduled trigger + get_record + loop + notify +\n * update_record), which is the established pattern for time-based sweeps here.\n *\n */\nexport const TaskDueReminderFlow: Flow = {\n  name: 'task_due_reminder',\n  label: 'Task Due Reminder',\n  description: 'Hourly sweep: notify owners of tasks whose reminder time has arrived.',\n  type: 'schedule',\n  status: 'active',\n  // Scheduled runs have no trigger user, so under the default runAs:'user' the\n  // data nodes execute UNSCOPED anyway. Declare runAs:'system' to make that\n  // RLS-bypassing elevation explicit and intended (ADR-0049).\n  runAs: 'system',\n\n  variables: [],\n\n  nodes: [\n    {\n      id: 'start', type: 'start', label: 'Start (hourly)',\n      config: { schedule: '0 * * * *' },\n    },\n    {\n      id: 'query_due', type: 'get_record', label: 'Find Tasks Due for Reminder',\n      config: {\n        objectName: 'crm_task',\n        // De-dup via `reminder_date` itself: the sweep notifies tasks whose\n        // reminder time has arrived, then CLEARS reminder_date (see mark_sent),\n        // so the row no longer matches `$lte` next tick. We do NOT filter on the\n        // `reminder_sent` boolean here \u2014 empirically, a where-clause on that\n        // (newly added) boolean column returns zero rows at runtime in this\n        // engine build, while the long-standing `is_completed` boolean works.\n        // Reusing the verified `$lte` + `is_completed` predicates keeps the\n        // sweep reliable; `reminder_sent` is still stamped for the audit trail.\n        filter: {\n          is_completed: false,\n          reminder_date: { $lte: cel`isoDatetime(now())` },\n        },\n        limit: 500,\n        outputVariable: 'reminderList',\n      },\n    },\n    {\n      // The loop body MUST be nested in `config.body` \u2014 a flat-graph loop\n      // (body omitted, iterator wired via outer edges) does NOT iterate or bind\n      // the iterator variable in the runtime (legacy no-op path), so\n      // `{currentTask.*}` resolves empty. Verified empirically.\n      id: 'loop_tasks', type: 'loop', label: 'For Each Due Task',\n      config: {\n        collection: cel`reminderList`,\n        iteratorVariable: 'currentTask',\n        body: guarded('task', {\n          nodes: [\n            {\n              id: 'notify_owner', type: 'notify', label: 'Notify Owner',\n              config: {\n                recipients: [cel`has(currentTask.owner_id) ? currentTask.owner_id : null`],\n                channels: ['inbox', 'email'],\n                severity: 'warning',\n                topic: 'task_reminder',\n                template: 'crm.task_reminder',\n                templateData: {\n                  subject: cel`currentTask.subject`, reminder_date: cel`currentTask.reminder_date`,\n                },\n                actionUrl: '/crm_task/{{currentTask.id}}',\n              },\n            },\n            {\n              id: 'mark_sent', type: 'update_record', label: 'Mark Reminder Sent',\n              config: {\n                objectName: 'crm_task',\n                filter: { id: cel`currentTask.id` },\n                // Clearing reminder_date is what de-dups (the row stops matching\n                // the sweep's `$lte` next tick); reminder_sent is the audit flag.\n                fields: { reminder_sent: true, reminder_date: null },\n              },\n            },\n          ],\n          edges: [\n            { id: 'b1', source: 'notify_owner', target: 'mark_sent', type: 'default' },\n          ],\n        }),\n      },\n    },\n    { id: 'end', type: 'end', label: 'End' },\n  ],\n\n  edges: [\n    { id: 'e1', source: 'start', target: 'query_due', type: 'default' },\n    { id: 'e2', source: 'query_due', target: 'loop_tasks', type: 'default' },\n    { id: 'e3', source: 'loop_tasks', target: 'end', type: 'default' },\n  ],\n};\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/sales/flows/billing-handoff-closed-won.flow.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/sales/flows\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/sales/flows/billing-handoff-closed-won.flow.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport { P, cel } from '@objectstack/spec';\nimport type * as Automation from '@objectstack/spec/automation';\ntype Flow = Automation.Flow;\n\nimport {\n  BILLING_HANDOFF_ENDPOINT,\n  BILLING_HANDOFF_EVENT,\n  BILLING_HANDOFF_LINE_ITEM_LIMIT,\n  BILLING_HANDOFF_SIGNING_SECRET,\n  BILLING_HANDOFF_TIMEOUT_MS,\n  LINE_ITEM_FIELDS,\n  billingBody,\n  loadAccountNode,\n} from './_billing-endpoint';\n\n/**\n * \u2550\u2550\u2550 Billing hand-off \u2014 where HotCRM's revenue scope ends \u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\n *\n * HotCRM owns lead \u2192 contract. It does **not** model Orders, Invoices or\n * Payments (maintainer decision, 2026-08-02): billing is an external system's\n * job. What the CRM owes that system is a reliable hand-off, and these two\n * flows are it:\n *\n *   - `billing_handoff_closed_won`          \u2014 an opportunity ENTERS `closed_won`\n *     (this file; `crm_opportunity` is the sales package's object)\n *   - `billing_handoff_contract_activated`  \u2014 a contract ENTERS `activated`\n *     (`src/revenue/flows/billing-handoff-contract-activated.flow.ts`)\n *\n * Each POSTs one JSON document \u2014 the record, its account, and its line items \u2014\n * to {@link BILLING_HANDOFF_ENDPOINT}, through the platform's **durable HTTP\n * outbox**: the `http` node with `durable: true` calls\n * `messaging.enqueueHttp({ source: 'flow', \u2026 })`, which persists a\n * `sys_http_delivery` row that the HTTP dispatcher drains with retry, backoff\n * and dead-lettering, signing the body with HMAC-SHA256 when a secret is set.\n * Nothing here is custom plumbing; it is the platform's own outbound-callout\n * verb, on the same outbox the declarative `webhooks` surface uses.\n *\n * ## \u26D4 Do not re-express these as declared `webhooks`\n *\n * Measured on 17.0.0-rc.6, that surface cannot express either event:\n * `WebhookSchema` is `.strict` and rejects `condition` / `filter` / `body` /\n * `payloadFields` / `retryPolicy`; its `triggers` vocabulary is\n * `create / update / delete / bulk_*` with no transition form; and the\n * auto-enqueuer matches on object + trigger alone and delivers a fixed\n * `DataEvent` envelope carrying neither the account nor the line items. A\n * `sys_webhook` row named for closed-won would fire on *every* opportunity edit\n * \u2014 a declaration that lies about itself, in the app other people copy.\n * Dispatch there is additionally gated on the `realtime` capability, which this\n * app does not require, so such a row would be visible in Setup and never fire\n * at all.\n *\n * The cost of this route is stated in `_billing-endpoint.ts` and in\n * `content/docs/revenue/billing-handoff.mdx`: the endpoint and secret live in\n * flow metadata, so repointing them is a rebuild, not a Setup edit.\n *\n * ## Exactly once per transition, not once per edit\n *\n * \u26D4 Both start conditions must test the TRANSITION\n * (`record.x == v && previous.x != v`), never the current value. This is the\n * idiom `opportunity_won_alert` uses on this very object: without the\n * `previous.*` term, every later edit of a won deal \u2014 a seed-ownership\n * claim, an approval stamp, a description tweak \u2014 re-fires the flow. For a\n * congratulations notification that is noise; for a billing hand-off it is a\n * duplicate order. `previous.*` is guarded FAIL-CLOSED (`has(previous.x) &&`)\n * for the same reason it is there: when the engine cannot see the prior value\n * it cannot see a transition either, and must not claim one. The shape that\n * covers is a bulk `updateMany`, where ObjectQL reads no prior row and\n * `previous` arrives null \u2014 one hand-off per row of a bulk update is exactly\n * what nobody wants.\n *\n * Delivery itself is **at-least-once**: the outbox retries a failed attempt,\n * and every attempt of one enqueued row carries the same `X-Objectstack-Delivery`\n * id. Receivers dedupe on that header.\n *\n * ## Totality\n *\n * Every `record.*` / `previous.*` read below carries a `has(...)` guard \u2014 the\n * house rule `test/flow-condition-totality.test.ts` enforces, because a flow\n * condition that aborts fails the whole run rather than yielding `false`.\n */\n\n/**\n * \u2500\u2500 Event 1: opportunity enters `closed_won` \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n */\nexport const BillingHandoffClosedWonFlow: Flow = {\n  name: 'billing_handoff_closed_won',\n  label: 'Billing Hand-off: Closed Won',\n  description:\n    'On the transition into closed_won: POST the deal, its account and its line items to the billing endpoint via the durable HTTP outbox.',\n  type: 'record_change',\n  status: 'active',\n  // A record-change flow fired by a SYSTEM write carries no trigger user\n  // (ADR-0049), and opportunities reach `closed_won` through\n  // machinery as well as a rep's own save \u2014 `lead_conversion` writes them, and\n  // the `contract_renewal` sweep is itself `runAs: 'system'`. This flow has two\n  // data nodes, so under the default `runAs: 'user'` those reads would be\n  // REFUSED on exactly those runs and the hand-off would vanish silently. The\n  // hand-off must also see the WHOLE deal, not the slice the closing rep may\n  // read: an RLS-scoped line-item query that returns three of five rows would\n  // under-bill the customer without failing anything.\n  runAs: 'system',\n  variables: [\n    // Bound with a default so the payload key always exists. Not strictly\n    // needed here (this flow always runs the read) \u2014 declared for symmetry with\n    // the contract flow, where the read is conditional, so the two payloads\n    // cannot drift into different shapes for an empty item list.\n    { name: 'billingLineItems', type: 'collection', isInput: false, isOutput: false, defaultValue: [] },\n  ],\n  nodes: [\n    {\n      id: 'start',\n      type: 'start',\n      label: 'Start (opportunity updated)',\n      config: {\n        objectName: 'crm_opportunity',\n        triggerType: 'record-after-update',\n        // TRANSITION, not current value \u2014 see the file header. `previous.stage`\n        // is guarded fail-closed: no visible prior stage means no visible\n        // transition, so no hand-off.\n        condition: P`has(record.stage) && record.stage == \"closed_won\"\n          && has(previous.stage) && previous.stage != \"closed_won\"`,\n      },\n    },\n    loadAccountNode(),\n    {\n      id: 'load_line_items',\n      type: 'get_record',\n      label: 'Load Line Items',\n      config: {\n        objectName: 'crm_opportunity_line_item',\n        filter: { crm_opportunity: cel`record.id` },\n        fields: LINE_ITEM_FIELDS,\n        // > 1 is what makes `get_record` issue a `find` and bind an ARRAY;\n        // omit it and the node calls `findOne` and binds a single row.\n        limit: BILLING_HANDOFF_LINE_ITEM_LIMIT,\n        outputVariable: 'billingLineItems',\n      },\n    },\n    {\n      // The node id becomes the delivery's `X-Objectstack-Event` header\n      // (`flow:<nodeId>`), so it is named for the event and not for the verb.\n      id: 'send_closed_won_handoff',\n      type: 'http',\n      label: 'Enqueue Billing Hand-off',\n      config: {\n        url: BILLING_HANDOFF_ENDPOINT,\n        method: 'POST',\n        // The whole point of this route: enqueue on `sys_http_delivery` rather\n        // than call inline, so a receiver that is down gets the delivery when\n        // it comes back instead of losing it.\n        durable: true,\n        timeoutMs: BILLING_HANDOFF_TIMEOUT_MS,\n        signingSecret: BILLING_HANDOFF_SIGNING_SECRET,\n        // One envelope building the whole payload (see `billingBody`). Each\n        // read is the value itself, never its stringification, so the amount\n        // stays a number and the line items an array.\n        body: billingBody(BILLING_HANDOFF_EVENT.opportunityClosedWon, 'opportunity', [\n          'id', 'name', 'amount', 'close_date', 'stage', 'type', ['account_id', 'crm_account'], 'owner_id',\n        ]),\n      },\n    },\n    { id: 'end', type: 'end', label: 'End' },\n  ],\n  edges: [\n    { id: 'e1', source: 'start', target: 'load_account', type: 'default' },\n    { id: 'e2', source: 'load_account', target: 'load_line_items', type: 'default' },\n    { id: 'e3', source: 'load_line_items', target: 'send_closed_won_handoff', type: 'default' },\n    { id: 'e4', source: 'send_closed_won_handoff', target: 'end', type: 'default' },\n  ],\n};\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/sales/flows/_billing-endpoint.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/sales/flows\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/sales/flows/_billing-endpoint.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport { cel, expression } from '@objectstack/spec';\nimport type * as Automation from '@objectstack/spec/automation';\n\n/**\n * Billing hand-off contract \u2014 the ONE place the outbound target and the shape\n * of what is sent to it live.\n *\n * HotCRM's revenue scope ends at the signed contract (maintainer decision,\n * 2026-08-02): no Order / Invoice / Payment objects are modelled here. What the\n * CRM owes the billing system is a **reliable hand-off** \u2014 two outbound events,\n * delivered on the platform's durable HTTP outbox.\n *\n * ## Where the endpoint lives, and why that is a code change\n *\n * These constants are read at **build time** by the two `http` nodes in\n * `billing-handoff.flow.ts`, and `objectstack build` bakes their values into the\n * compiled artifact's flow metadata. There is no Setup screen for them.\n *\n * That is a real cost of the mechanism, stated rather than buried: the\n * admin-editable `webhooks` surface cannot express either of these events, so\n * the trade is exact events with a shaped payload at the price of repointing\n * being a rebuild. The measurements behind that are in\n * `billing-handoff.flow.ts`; `content/docs/revenue/billing-handoff.mdx`\n * documents the cost plainly instead of teaching a Setup screen that does not\n * apply.\n *\n * ## Overriding without editing this file\n *\n * Both values are read from the environment first, so a deployment can set them\n * in the build environment rather than patching source:\n *\n *   HOTCRM_BILLING_ENDPOINT=https://billing.acme.internal/hotcrm/events \\\n *   HOTCRM_BILLING_SIGNING_SECRET=\u2026 \\\n *   pnpm build\n *\n * The secret is deliberately NOT defaulted to a literal: a committed HMAC key\n * in a public reference app is worse than an unsigned delivery, and an unsigned\n * delivery is at least visible (no `X-Objectstack-Signature` header on the\n * request) rather than silently trusted.\n */\n\n/**\n * Where both hand-off events are POSTed.\n *\n * The default is the RFC 2606 example host, i.e. deliberately not a real\n * receiver: an untouched install enqueues the delivery, retries it on the\n * platform's backoff schedule, and lands it in `sys_http_delivery` as `dead`.\n * That is the honest default \u2014 the hand-off is wired and visibly waiting for an\n * endpoint, rather than quietly doing nothing.\n */\nexport const BILLING_HANDOFF_ENDPOINT =\n  process.env.HOTCRM_BILLING_ENDPOINT?.trim() || 'https://billing.example.com/hotcrm/events';\n\n/**\n * HMAC-SHA256 secret for the `X-Objectstack-Signature` header.\n *\n * `undefined` when unset \u2014 the messaging sender only signs when a secret is\n * present, and an empty string would read as \"signed\" to an author while\n * producing no header at all.\n */\nexport const BILLING_HANDOFF_SIGNING_SECRET: string | undefined =\n  process.env.HOTCRM_BILLING_SIGNING_SECRET?.trim() || undefined;\n\n/** Per-request timeout handed to the outbox sender (ms). */\nexport const BILLING_HANDOFF_TIMEOUT_MS = 30_000;\n\n/**\n * Event names carried in the payload's `event` field.\n *\n * The receiver routes on this, so the strings are part of the contract with the\n * billing system \u2014 changing one is a breaking change for the consumer, not a\n * rename.\n */\nexport const BILLING_HANDOFF_EVENT = {\n  opportunityClosedWon: 'crm.opportunity.closed_won',\n  contractActivated: 'crm.contract.activated',\n} as const;\n\n/** Payload contract version \u2014 bumped when the body shape changes shape. */\nexport const BILLING_HANDOFF_PAYLOAD_VERSION = 1;\n\n/** Line items read per hand-off. Deals in this app top out well below it. */\nexport const BILLING_HANDOFF_LINE_ITEM_LIMIT = 200;\n\n/*\n * \u2500\u2500\u2500 The payload halves both hand-off events share \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n *\n * These sat in `billing-handoff.flow.ts` while both flows lived in one file.\n * The ADR-0130 layout puts a flow with its trigger object, and the two events\n * trigger on objects in different packages \u2014 `crm_opportunity` is sales',\n * `crm_contract` is revenue's \u2014 so the flows are now\n * `src/sales/flows/billing-handoff-closed-won.flow.ts` and\n * `src/revenue/flows/billing-handoff-contract-activated.flow.ts`. The shared\n * half moved HERE rather than being copied into each: it is the same contract\n * with the same receiver, and two copies of a contract is how a receiver ends\n * up with two shapes. Revenue reads it along the revenue -> sales edge, the\n * one direction ADR-0130 allows.\n */\n\n/** Account fields the billing system needs to open a customer. */\nexport const ACCOUNT_FIELDS = [\n  'id',\n  'name',\n  'account_number',\n  'billing_address',\n  'billing_country',\n  'phone',\n  'website',\n];\n\n/** Line-item fields that price a hand-off. `total_price` is the formula total. */\nexport const LINE_ITEM_FIELDS = [\n  'id',\n  'line_number',\n  'crm_product',\n  'description',\n  'quantity',\n  'list_price',\n  'unit_price',\n  'discount',\n  'total_price',\n];\n\n/** An optional column of the account row, read as `null` where the row lacks it. */\nconst accountField = (field: string) => `has(billingAccount.${field}) ? billingAccount.${field} : null`;\n\n/**\n * The account block, shared by both payloads: a CEL map literal over the\n * `billingAccount` row {@link loadAccountNode} binds, spliced into each body by\n * {@link billingBody}.\n *\n * Authored field-by-field rather than passing the row whole: this object IS the\n * contract with the billing system, so it must not silently grow a column the\n * day someone adds a field to `crm_account`.\n *\n * `name` is required and `account_number` an autonumber, so both are read\n * bare. The other four are optional, and a sparse driver (memory, mongodb)\n * hands back a column the row was never written with ABSENT, which CEL refuses,\n * so each is guarded to `null`. The 17.x template dropped such a key from the\n * JSON instead; on the SQL drivers the column is always present and the two\n * agree.\n */\nexport const ACCOUNT_BLOCK =\n  `{'id': billingAccount.id, 'name': billingAccount.name, 'account_number': billingAccount.account_number, ` +\n  `'billing_address': ${accountField('billing_address')}, 'billing_country': ${accountField('billing_country')}, ` +\n  `'phone': ${accountField('phone')}, 'website': ${accountField('website')}}`;\n\n/**\n * The http `body` of both hand-offs: ONE CEL value envelope building the whole\n * payload. `key` names the record's own block, and `fields` lists what it\n * carries, read straight off the triggering `record`: a field under its own\n * name, or `[key, field]` where the payload names it differently. `record` is\n * the record-change trigger's, which hands the run every declared field (null\n * where unset), so these reads take no guard.\n *\n * Since 18.0.0-next.0 an http body is one value, evaluated once before the\n * call, so the durable outbox enqueues exactly what an inline call would send.\n * A `{\u2026}` token in a nested string is refused there, and an envelope nested in\n * a literal object would be sent as the object it spells \u2014 so the payload is\n * built by one envelope, not by a literal with envelopes inside it. CEL holds a\n * map's values to one type, so each literal and each nested map is wrapped in\n * `dyn()`. `billingLineItems` is a variable read and already dynamic.\n */\nexport const billingBody = (event: string, key: string, fields: (string | [string, string])[]) =>\n  expression(\n    `{'event': dyn('${event}'), 'version': dyn(${BILLING_HANDOFF_PAYLOAD_VERSION}), ` +\n      `'occurred_at': dyn(isoDatetime(now())), ` +\n      `'${key}': dyn({${fields.map((f) => (typeof f === 'string' ? [f, f] : f)).map(([k, f]) => `'${k}': record.${f}`).join(', ')}}), ` +\n      `'account': dyn(${ACCOUNT_BLOCK}), 'line_items': billingLineItems}`,\n  );\n\n/**\n * Read the account named by the triggering record.\n *\n * `crm_account` is `required` + `storage.notNull` on both `crm_opportunity` and\n * `crm_contract`, so the value is always there on a real row. Left UNGUARDED on\n * purpose: if it were ever absent, the envelope fails the run loudly in Studio's\n * Flow Runs page. For a required field that is the right failure \u2014 a silent skip\n * would drop a hand-off with no trace.\n */\nexport const loadAccountNode = (): Automation.FlowNode => ({\n  id: 'load_account',\n  type: 'get_record',\n  label: 'Load Account',\n  config: {\n    objectName: 'crm_account',\n    filter: { id: cel`record.crm_account` },\n    fields: ACCOUNT_FIELDS,\n    // No `limit`: `get_record` calls `findOne` below 2 and binds the single row\n    // itself, which is what the account block's `billingAccount.FIELD` reads need.\n    outputVariable: 'billingAccount',\n  },\n});\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/revenue/flows/quote-generation.flow.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/revenue/flows\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/revenue/flows/quote-generation.flow.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport { P, expression, cel } from '@objectstack/spec';\nimport type * as Automation from '@objectstack/spec/automation';\nimport { QUOTE_DISCOUNT_CEILING } from '../../sales/objects/_thresholds';\ntype Flow = Automation.Flow;\n\n/**\n * The screen's discount as a CEL double, 0 when the rep cleared the box. A\n * source FRAGMENT, spliced into both pricing envelopes with `expression()`:\n * the `P` tag JSON-quotes an interpolated string, so it cannot splice one.\n */\nconst DISCOUNT = '(!has(vars.discount) || isBlank(vars.discount) ? 0.0 : double(vars.discount))';\n\n/**\n * Edge `e4a`'s predicate \u2014 advance the deal to `proposal`. A source FRAGMENT\n * for the same reason as `DISCOUNT`: edge `e4b` is its exact negation,\n * spliced as `!(\u2026)`, so the two branches partition by construction rather\n * than by a hand-kept De Morgan copy (the rationale is on the edges).\n */\nconst ADVANCE = `has(vars.oppRecord) && has(vars.oppRecord.stage)\n  && (vars.oppRecord.stage == \"prospecting\" || vars.oppRecord.stage == \"qualification\" || vars.oppRecord.stage == \"needs_analysis\")\n  && (!has(vars.oppRecord.approval_status) || vars.oppRecord.approval_status != \"pending\")`;\n\n/** Quote Generation \u2014 screen flow to create a quote from an opportunity */\nexport const QuoteGenerationFlow: Flow = {\n  name: 'quote_generation',\n  label: 'Generate Quote from Opportunity',\n  description: 'Create a quote based on opportunity details',\n  type: 'screen',\n  status: 'active',\n\n  variables: [\n    // MUST be `recordId` \u2014 the console's flow-action trigger contract seeds\n    // only that name ({ recordId, objectName }); a custom name like\n    // `opportunityId` arrives undefined.\n    { name: 'recordId', type: 'text', isInput: true, isOutput: false },\n    { name: 'quoteName', type: 'text', isInput: true, isOutput: false },\n    { name: 'expirationDays', type: 'number', isInput: true, isOutput: false },\n    { name: 'discount', type: 'number', isInput: true, isOutput: false },\n  ],\n\n  nodes: [\n    { id: 'start', type: 'start', label: 'Start', config: { objectName: 'crm_opportunity' } },\n    // \u2500\u2500\u2500 The \u7ACB\u9879 (qualification) gate, REQ-0006 step 11 (#2032) \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n    //\n    // \u300C\u65B0\u589E\u5546\u673A\u53EF\u8DDF\u8FDB\uFF0C\u7ACB\u9879\u901A\u8FC7\u540E\u65B9\u53EF\u66F4\u65B0\u9636\u6BB5\u3001\u6295\u6807\u3001\u8D62\u4E22\u5355\u64CD\u4F5C\u3002\u300D Ruled (hotcrm-R74b\n    // item 2, B): before \u7ACB\u9879 is approved, Generate Quote REFUSES and creates\n    // nothing. Steps 15 and 18 put quoting after the deal's approval too.\n    //\n    // Why the refusal is HERE, ahead of the form and of every writer: this\n    // flow writes the quote BEFORE the stage, and a flow carries no\n    // transaction (ADR-0077). With the gate armed, `opportunity_lifecycle`\n    // refuses the `update_opportunity` stage write \u2014 so the run used to fail\n    // AFTER `create_quote` had landed: measured on 17.7.0 as a sales_rep,\n    // `FLOW_FAILED` 400 at `update_opportunity` (\"This deal needs\n    // qualification approval first \u2026\"), one draft quote left behind, the\n    // stage unchanged. \u26D4 Not #2015's keep-stage-and-quote: that lock does\n    // not hold quoting, this gate does.\n    //\n    // The flow is the one choke point every door reaches \u2014 the record-header\n    // and list-row buttons and `POST /automation/quote_generation/trigger` \u2014\n    // so the refusal lives here and `generate_quote` stays visible: hiding\n    // it would leave the rep a missing button with no reason, because an\n    // action's `visible` / `disabled` are bare predicates with nowhere to\n    // put a sentence.\n    //\n    // The FILTER is the gate's reading, the one `opportunity_lifecycle`\n    // applies: `pending` or `rejected` holds the deal (an approver's \"no\" is\n    // not a release), every other value \u2014 the shipped `not_required`,\n    // `approved`, none at all \u2014 does not. So `held` binds the deal only while\n    // it is held, and `null` otherwise; `test/flow-quote.test.ts` pins that\n    // the two answer alike, verdict by verdict.\n    //\n    // A read of its own, at click time. \u26D4 Do not fold it into\n    // `get_opportunity`: that read stays AFTER the screen so the pricing and\n    // the #2015 approval branch (`e4a` / `e4b`) see the deal as it is at\n    // submit. The verdict cannot drift toward held while the form is open:\n    // `not_required` and `approved` are never written back to `pending`.\n    { id: 'get_held', type: 'get_record', label: 'Get Held Deal', config: { objectName: 'crm_opportunity', filter: { id: cel`recordId`, qualification_approval_status: { $in: ['pending', 'rejected'] } }, outputVariable: 'held' } },\n    // A first-class refusal (`EndConfigSchema` `outcome: 'refused'`): the run\n    // ends `refused`, never `failed` and never parked, nothing is written,\n    // and the console shows the message with Close only \u2014 no Submit and no\n    // \"completed\" toast, which is what a message-only screen would give. It\n    // names the next step the `opportunity_lifecycle` refusal of this gate\n    // names.\n    //\n    // Translated: since 18.0.0-next.0 the `flows` translation group keys an\n    // `end` node's refusal as `refusals.refuse_held.message`, which the\n    // engine renders in the run's locale (at 17.7.0 it had no such key, the\n    // gap raised from #2032). The console titles the dialog with the action's\n    // translated label. \u26D4 Do not re-route the refusal through a screen to\n    // borrow a translatable title.\n    { id: 'refuse_held', type: 'end', label: 'Quote Refused', config: { outcome: 'refused', message: 'Qualification approval comes first: tick Request Qualification Approval. Nothing was created.' } },\n    {\n      id: 'screen_1', type: 'screen', label: 'Quote Details',\n      config: {\n        fields: [\n          { name: 'quoteName', label: 'Quote Name', type: 'text', required: true },\n          { name: 'expirationDays', label: 'Valid For (Days)', type: 'number', required: true, defaultValue: 30 },\n          // The ceiling is a HARD block with no override\n          // (`crm_quote.discount_within_ceiling`), so until it is written here\n          // a rep meets the number only by having the quote refused. Both\n          // strings below interpolate `QUOTE_DISCOUNT_CEILING` \u2014 imported,\n          // never retyped, the same rule the two object rules follow \u2014 so the\n          // hint cannot drift from the rule it describes.\n          //\n          // \u26D4 There is deliberately NO `max`, and adding one does not work:\n          // `ScreenFieldConfigSchema` is STRICT at 17.3.0 and its entire key\n          // set is `name` / `label` / `type` / `required` / `options` /\n          // `defaultValue` / `placeholder` / `visibleWhen`. `max` is rejected\n          // BY NAME (`Unrecognized key(s) on this screen field: max`), so\n          // it fails `pnpm validate` rather than quietly doing nothing, and\n          // the executor forwards no such key into the `ScreenSpec` the client\n          // renders. `helpText` is rejected the same way \u2014 the console's\n          // dialog would render one, but no flow screen can carry it there.\n          //\n          // That leaves two carriers, and the label is the load-bearing one:\n          // `placeholder` renders only while the input is empty and\n          // `defaultValue: 0` seeds it, so it surfaces for the moment the rep\n          // clears the box to type \u2014 real, but not enough on its own.\n          {\n            name: 'discount',\n            label: `Discount % (\u2264 ${QUOTE_DISCOUNT_CEILING})`,\n            type: 'percent',\n            defaultValue: 0,\n            placeholder: `0-${QUOTE_DISCOUNT_CEILING}`,\n          },\n        ],\n      },\n    },\n    {\n      id: 'get_opportunity', type: 'get_record', label: 'Get Opportunity',\n      config: { objectName: 'crm_opportunity', filter: { id: cel`recordId` }, outputVariable: 'oppRecord' },\n    },\n    {\n      id: 'create_quote', type: 'create_record', label: 'Create Quote',\n      config: {\n        objectName: 'crm_quote',\n        fields: {\n          name: cel`quoteName`, crm_opportunity: cel`recordId`,\n          crm_account: cel`oppRecord.crm_account`, crm_contact: cel`has(oppRecord.primary_contact) ? oppRecord.primary_contact : null`,\n          owner_id: cel`current_user.id`, status: 'draft',\n          quote_date: cel`isoDate(today())`, expiration_date: cel`isoDate(addDays(today(), expirationDays))`,\n          // `subtotal` is a bare path pass-through and needs no rounding: it\n          // copies `crm_opportunity.amount` as stored and does no arithmetic,\n          // so it adds no floating-point tail of its own.\n          // `discount` is an optional screen answer: a resume may leave it\n          // unbound, which the template wrote as nothing and the guard writes\n          // as null (the quote field has no default, so the two agree).\n          subtotal: cel`oppRecord.amount`, discount: cel`has(vars.discount) ? discount : null`,\n          // \u26D4 A currency \u00D7 percentage MUST be rounded to whole cents inside the\n          // expression \u2014 the flow hands the engine a money amount, never an\n          // unrounded double. `discount / 100` is inexact for every percentage\n          // whose hundredth is not a dyadic rational, so a BARE product carries\n          // a tail: 180,000 at 30% is 125999.99999999999. While these fields\n          // declared `scale: 2` the insert was rejected for it (`Total Price\n          // must have at most 2 decimal places (got 11)`, #1206). Currency\n          // fields no longer declare `scale` \u2014 the platform refuses it, a\n          // currency's decimals are its ISO 4217 minor unit (#1965) \u2014 so the\n          // write is now ACCEPTED and the tail would be stored silently. The\n          // rounding keeps `discount_amount` / `total_price` whole-cent amounts.\n          //\n          // Both are CEL value envelopes. CEL's `round()` is INTEGER-ONLY and\n          // single-argument, and it returns an INT \u2014 so the divisor MUST be\n          // the decimal `100.0`. \u26D4 Never `/ 100`: in CEL int / int is integer\n          // division, which silently drops the cents (1,234.56 at 10% would\n          // store 123, not 123.46; `test/flow-quote.test.ts` pins it). \u26D4 Not\n          // `round(x, 2)` either: there is no precision form, and it fails\n          // loudly. `double()` types the amount, which some drivers return as\n          // a string. A cleared discount (null / absent / \"\") prices as 0%, as\n          // it did before; the `has()` guard is what keeps that TOTAL.\n          //\n          // \u2B50 This shape applies ANYWHERE a flow multiplies a currency by a\n          // percentage. Write the rounding, not the bare product.\n          discount_amount: expression(`round(double(oppRecord.amount) * (${DISCOUNT} / 100.0) * 100.0) / 100.0`, 'cel'),\n          total_price: expression(`round(double(oppRecord.amount) * (1.0 - ${DISCOUNT} / 100.0) * 100.0) / 100.0`, 'cel'),\n          payment_terms: 'net_30',\n        },\n        outputVariable: 'quoteId',\n      },\n    },\n    {\n      // Advance to `proposal` only from a PRE-proposal stage (the state machine\n      // allows `\u2192 proposal` from all three). \u26D4 Never re-write `proposal` on a\n      // deal already at proposal/negotiation: that is an illegal self/backward\n      // transition. Those deals keep their stage; the quote is still created.\n      //\n      // \u26D4 Nor on a deal AWAITING APPROVAL (`approval_status == \"pending\"`). A\n      // deal of `LARGE_DEAL_AMOUNT` or more is held by `opportunity_approval`'s\n      // approval node (`lockRecord: true`) until a manager decides, and the\n      // lock refuses this run's stage write \u2014 the run is the rep's\n      // (`runAs: 'user'`), and the lock is the approval working as intended.\n      // `create_quote` has already landed by then and a flow carries no\n      // transaction (ADR-0077), so the refusal used to fail the run AFTER the\n      // quote existed: measured on 17.7.0, `FLOW_FAILED` 400 `RECORD_LOCKED`\n      // at `update_opportunity`, the rep told the quote failed, and the draft\n      // quote left standing (#2015). A deal under review keeps its stage\n      // exactly like a deal already at proposal; the quote is still created \u2014\n      // the button is offered at every open stage, and a draft quote commits\n      // nothing the approval is there to hold. `approval_status` is the lock's\n      // own mirror (`approvalStatusField`): the approvals plugin stamps\n      // `pending` when it opens the locking request and a terminal verdict\n      // when it releases it.\n      //\n      // The predicate itself lives on edges `e4a` / `e4b` \u2014 a `decision` node's\n      // singular `config.condition` is never evaluated, so a copy here would be\n      // inert (17.0.0-rc.2's `flow-inert-node-condition`). The totality\n      // rationale is on those edges, where the guards are.\n      id: 'check_stage', type: 'decision', label: 'Can Advance to Proposal?',\n    },\n    {\n      id: 'update_opportunity', type: 'update_record', label: 'Update Opportunity',\n      config: {\n        // \u26D4 No `last_activity_date` write: `crm_opportunity` has no such field\n        // (it lives on `crm_account`), and an unknown column fails this node.\n        objectName: 'crm_opportunity', filter: { id: cel`recordId` },\n        fields: { stage: 'proposal' },\n      },\n    },\n    {\n      // ADR-0012: deliver via the `notify` node (inbox + email). The legacy\n      // `script` + `actionType:'email'` shape is a no-op stub in 7.4.\n      id: 'notify_owner', type: 'notify', label: 'Send Notification',\n      config: {\n        recipients: [cel`current_user.id`],\n        channels: ['inbox', 'email'],\n        topic: 'quote_created',\n        template: 'crm.quote_created',\n        templateData: { quote_name: cel`quoteName` },\n        actionUrl: '/crm_quote/{{quoteId.id}}',\n      },\n    },\n    { id: 'end', type: 'end', label: 'End' },\n  ],\n\n  edges: [\n    // \u26D4 A retired edge's id stays VACANT: `e1` (start \u2192 screen_1) is one.\n    // Every surviving edge keeps its id, and a new one takes the next id after\n    // the highest in use \u2014 a duplicate id is inert, so nothing would flag it.\n    { id: 'e7', source: 'start', target: 'get_held', type: 'default' },\n    // \u2500\u2500 The \u7ACB\u9879 gate (#2032) \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n    //\n    // COMPLEMENTARY CONDITIONALS off a plain data node, not a `decision` \u2014 the\n    // shape `billing-handoff-contract-activated.flow.ts` records: they are\n    // evaluated one by one, and `!= null` / `== null` partition exactly.\n    // `get_held` dominates both and binds `held` on every path \u2014 the row, or\n    // `null` on a miss \u2014 so neither read takes a `has()` guard: the\n    // get_record-dominated case `test/flow-variable-conditions.test.ts`\n    // records as needing none, written like `lead_conversion`'s `e5` / `e6`.\n    // Fail-OPEN like the hook: a deal the read cannot see goes on to the form\n    // and fails at `create_quote` exactly as it always did.\n    { id: 'e9', source: 'get_held', target: 'refuse_held', type: 'default', condition: P`vars.held != null`, label: 'Held' },\n    { id: 'e10', source: 'get_held', target: 'screen_1', type: 'default', condition: P`vars.held == null`, label: 'Not held' },\n    { id: 'e2', source: 'screen_1', target: 'get_opportunity', type: 'default' },\n    { id: 'e3', source: 'get_opportunity', target: 'create_quote', type: 'default' },\n    { id: 'e4', source: 'create_quote', target: 'check_stage', type: 'default' },\n    // The two branches must PARTITION, so the keep side is the advance side\n    // negated whole (`ADVANCE` above): `has(\u2026) && \u2026` advances and everything\n    // else keeps. An unknown stage therefore lands on \"keep stage\" \u2014 the quote\n    // is still created and nothing illegal is written to the state machine.\n    // These EDGES are the live sites; `check_stage` carries no\n    // `config.condition` at all, because the engine never evaluates one.\n    //\n    // TOTALITY: `oppRecord` is a `get_record` OUTPUT \u2014 `findOne` answers\n    // a miss with `null`, and reading a field off it then aborts with `No such\n    // key: stage`. Measured unreachable TODAY only because two neighbouring\n    // schemas happen to close it: `crm_opportunity.stage` is `required` (never\n    // a sparse column) and `crm_quote.crm_account` is `required`, so a null\n    // `oppRecord` makes `create_quote` fail one node earlier. Both are one\n    // `required: false` away from re-opening it, so the predicate carries its\n    // own guard \u2014 and from 17.0.0-rc.2 an unevaluable condition aborts the step\n    // instead of skipping it, so the guard is load-bearing, not\n    // decorative. Note the scope is `vars.oppRecord`, not bare `oppRecord`:\n    // measured, `has(oppRecord.stage)` still aborts with `Unknown variable:\n    // oppRecord` when the variable is unbound, while `has(vars.oppRecord)`\n    // answers `false` \u2014 only the `vars.`-scoped form is total against both\n    // hazards.\n    //\n    // The approval term (see `check_stage`) is guarded the same way: an absent\n    // or null `approval_status` is \"not under approval\" and advances, as it\n    // did before the term existed.\n    { id: 'e4a', source: 'check_stage', target: 'update_opportunity', type: 'conditional', condition: expression(ADVANCE, 'cel'), label: 'Advance' },\n    { id: 'e4b', source: 'check_stage', target: 'notify_owner', type: 'conditional', condition: expression(`!(${ADVANCE})`, 'cel'), label: 'Keep stage' },\n    { id: 'e5', source: 'update_opportunity', target: 'notify_owner', type: 'default' },\n    { id: 'e6', source: 'notify_owner', target: 'end', type: 'default' },\n  ],\n};\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/revenue/flows/contract-renewal.flow.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/revenue/flows\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/revenue/flows/contract-renewal.flow.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport { P, cel } from '@objectstack/spec';\nimport type * as Automation from '@objectstack/spec/automation';\nimport { guarded } from '../../sales/flows/_guarded-iteration';\ntype Flow = Automation.Flow;\n\n/**\n * Contract Renewal \u2014 scheduled daily sweep for contracts entering their\n * renewal-notice window.\n *\n * This flow is what consumes `end_date`, `auto_renewal` and\n * `renewal_notice_days`: each morning it finds `activated` contracts whose\n * `end_date` falls inside their per-contract notice window, books a renewal task\n * for the owner, notifies them, and \u2014 when `auto_renewal` is on \u2014 opens an\n * `existing_renewal` opportunity pre-filled from the contract value so the deal\n * is already in the pipeline.\n *\n * Capabilities exercised: scheduled trigger + `loop` over a query result +\n * per-record `decision` gates + `notify` (ADR-0012).\n */\nexport const ContractRenewalFlow: Flow = {\n  name: 'contract_renewal',\n  label: 'Contract Renewal Reminder',\n  description: 'Daily sweep: open renewal tasks/opportunities for contracts nearing end_date.',\n  type: 'schedule',\n  status: 'active',\n  // Scheduled runs have no trigger user, so under the default runAs:'user' the\n  // data nodes execute UNSCOPED anyway. Declare runAs:'system' to make that\n  // RLS-bypassing elevation explicit and intended (ADR-0049).\n  runAs: 'system',\n\n  variables: [],\n\n  nodes: [\n    { id: 'start', type: 'start', label: 'Start (daily 08:00)', config: { schedule: '0 8 * * *' } },\n    {\n      // Broad pre-filter (next 120 days \u2014 \u26D4 must cover the LARGEST\n      // renewal_notice_days in use; seeds go up to 90). The per-record notice\n      // window is applied in the decision node below so each contract honours\n      // its own renewal_notice_days. A pre-filter narrower than the largest\n      // notice period silently truncates it: a 90-day contract stays invisible\n      // until 60 days out.\n      id: 'query_contracts', type: 'get_record', label: 'Find Expiring Contracts',\n      config: {\n        objectName: 'crm_contract',\n        filter: { status: 'activated', end_date: { $gte: cel`isoDate(today())`, $lte: cel`isoDate(daysFromNow(120))` } },\n        limit: 500,\n        outputVariable: 'contractList',\n      },\n    },\n    {\n      id: 'loop_contracts', type: 'loop', label: 'For Each Contract',\n      config: {\n        collection: cel`contractList`,\n        iteratorVariable: 'currentContract',\n        body: guarded('contract', {\n          nodes: [\n            {\n              // Gateway only \u2014 the predicate lives on the out-edge.\n              id: 'check_notice_window', type: 'decision', label: 'Within Notice Window?',\n            },\n            {\n              // Idempotency gate: the sweep matches the same contract every day\n              // of its notice window, so \u26D4 without it every day produces a\n              // duplicate task + notification (and, below, a duplicate\n              // pipeline-inflating renewal opportunity). An open renewal task\n              // for this contract means this window was already handled.\n              id: 'find_existing_task', type: 'get_record', label: 'Already Reminded?',\n              config: {\n                objectName: 'crm_task',\n                filter: {\n                  related_to_account: cel`currentContract.crm_account`,\n                  subject: cel`'Renewal due: contract ' + currentContract.contract_number`,\n                  status: { $nin: ['completed'] },\n                },\n                outputVariable: 'existingRenewalTask',\n              },\n            },\n            {\n              // Gateway only \u2014 the predicate lives on the out-edge.\n              id: 'check_not_reminded', type: 'decision', label: 'First Reminder?',\n            },\n            {\n              id: 'create_renewal_task', type: 'create_record', label: 'Create Renewal Task',\n              config: {\n                objectName: 'crm_task',\n                fields: {\n                  subject: cel`'Renewal due: contract ' + currentContract.contract_number`,\n                  type: 'follow_up', priority: 'high', status: 'not_started',\n                  due_date: cel`currentContract.end_date`,\n                  owner_id: cel`has(currentContract.owner_id) ? currentContract.owner_id : null`,\n                  // ORG PARTITION. A schedule trigger carries no\n                  // organization, so the engine has nothing to fill this from\n                  // and the row would be born `organization_id` NULL \u2014 outside\n                  // every org partition, where an `(organization_id, \u2026)` unique\n                  // index does not constrain and org-scoped reads never see it.\n                  // Upstream ruling objectstack#6155 Q2=A puts the answer here,\n                  // with the flow author: a renewal task belongs to the org of\n                  // the contract that spawned it. Fill-only precedence means an\n                  // author-set value wins over the engine (objectstack#6153).\n                  // The source MUST be a row that actually carries the column.\n                  // On 17.x an absent key interpolated to `undefined` and landed\n                  // as NULL, which satisfied the publish guard while reproducing\n                  // the bug; the CEL read below fails the iteration instead, and\n                  // it is deliberately left UNGUARDED \u2014 a `has()` guard would\n                  // write that NULL back. `crm_contract` carries it; `sys_user`\n                  // does not.\n                  organization_id: cel`currentContract.organization_id`,\n                  related_to_type: 'crm_account',\n                  related_to_account: cel`currentContract.crm_account`,\n                },\n              },\n            },\n            {\n              id: 'notify_owner', type: 'notify', label: 'Notify Owner',\n              config: {\n                recipients: [cel`has(currentContract.owner_id) ? currentContract.owner_id : null`],\n                channels: ['inbox', 'email'],\n                topic: 'contract_renewal',\n                template: 'crm.contract_renewal',\n                templateData: {\n                  contract_number: cel`currentContract.contract_number`, end_date: cel`currentContract.end_date`,\n                },\n                actionUrl: '/crm_contract/{{currentContract.id}}',\n              },\n            },\n            {\n              // Gateway only \u2014 the predicate lives on the out-edge.\n              id: 'check_auto_renewal', type: 'decision', label: 'Auto-Renewal On?',\n            },\n            {\n              // Second gate: never open a second renewal opportunity while one\n              // is still in flight for this account (belt-and-braces for the\n              // case where the task was completed but the deal is still open).\n              id: 'find_existing_renewal_opp', type: 'get_record', label: 'Open Renewal Deal Exists?',\n              config: {\n                objectName: 'crm_opportunity',\n                filter: {\n                  crm_account: cel`currentContract.crm_account`,\n                  type: 'existing_renewal',\n                  stage: { $nin: ['closed_won', 'closed_lost'] },\n                },\n                outputVariable: 'existingRenewalOpp',\n              },\n            },\n            {\n              // Gateway only \u2014 the predicate lives on the out-edge.\n              id: 'check_no_open_renewal', type: 'decision', label: 'No Open Renewal Deal?',\n            },\n            {\n              id: 'create_renewal_opp', type: 'create_record', label: 'Open Renewal Opportunity',\n              config: {\n                objectName: 'crm_opportunity',\n                fields: {\n                  name: cel`'Renewal \u2014 ' + currentContract.contract_number`,\n                  crm_account: cel`currentContract.crm_account`,\n                  amount: cel`currentContract.contract_value`,\n                  stage: 'proposal',\n                  type: 'existing_renewal',\n                  close_date: cel`currentContract.end_date`,\n                  owner_id: cel`has(currentContract.owner_id) ? currentContract.owner_id : null`,\n                  // ORG PARTITION \u2014 see `create_renewal_task` above.\n                  // The renewal deal belongs to the same org as the contract.\n                  organization_id: cel`currentContract.organization_id`,\n                  next_step: 'Confirm renewal terms with customer',\n                },\n              },\n            },\n          ],\n          edges: [\n            // Only act when inside the per-contract notice window; gates with\n            // no matching edge simply end the iteration, so the loop moves on.\n            //\n            // The EDGE is the ONLY site: a `decision` node's singular\n            // `config.condition` is never read \u2014 the executor reads the plural\n            // `config.conditions[]` and nothing else \u2014 so a copy on the node\n            // would be inert metadata that drifts silently. `check_notice_window`\n            // is therefore a bare gateway and this predicate is authored once.\n            //\n            // `end_date` is a DATE field and arrives as `YYYY-MM-DD`, but CEL's\n            // `timestamp()` only accepts a full ISO 8601 datetime and throws\n            // otherwise (\"timestamp() requires a string in ISO 8601 format\").\n            // Appending the time part is what makes this evaluate instead of\n            // blowing up mid-sweep.\n            //\n            // TOTALITY: `currentContract` is a LOOP ITEM over\n            // `contractList`, which `get_record` filled from `data.find` \u2014\n            // every element is a raw driver row, sparse in exactly the way\n            // a raw driver row is. `end_date` is `required` on `crm_contract` so\n            // that column is always written, but `renewal_notice_days`\n            // (`defaultValue: 30`) and `auto_renewal` (`defaultValue: false`)\n            // are only DEFAULTED, and a row written before the default existed\n            // carries neither the column nor a value. Both operands\n            // additionally need `!= null`, because the abort here is not the\n            // usual overload error: `null + \"T00:00:00Z\"` and `int(null)` each\n            // blow up inside the function call, one contract into a 500-row\n            // sweep, taking the whole scheduled run with them.\n            { id: 'b1', source: 'check_notice_window', target: 'find_existing_task', type: 'conditional', condition: P`has(vars.currentContract) && has(vars.currentContract.end_date) && has(vars.currentContract.renewal_notice_days)\n              && vars.currentContract.end_date != null && vars.currentContract.renewal_notice_days != null\n              && timestamp(vars.currentContract.end_date + \"T00:00:00Z\") <= daysFromNow(int(vars.currentContract.renewal_notice_days))`, label: 'In window' },\n            { id: 'b2', source: 'find_existing_task', target: 'check_not_reminded', type: 'default' },\n            { id: 'b3', source: 'check_not_reminded', target: 'create_renewal_task', type: 'conditional', condition: P`existingRenewalTask == null`, label: 'First reminder' },\n            { id: 'b4', source: 'create_renewal_task', target: 'notify_owner', type: 'default' },\n            { id: 'b5', source: 'notify_owner', target: 'check_auto_renewal', type: 'default' },\n            // TOTALITY: same loop item, same sparse driver row. Only an\n            // explicit `true` opens a renewal deal, so an absent column reads\n            // as \"auto-renewal off\" \u2014 the conservative branch.\n            { id: 'b6', source: 'check_auto_renewal', target: 'find_existing_renewal_opp', type: 'conditional', condition: P`has(vars.currentContract) && has(vars.currentContract.auto_renewal)\n              && vars.currentContract.auto_renewal == true`, label: 'Auto-renew' },\n            { id: 'b7', source: 'find_existing_renewal_opp', target: 'check_no_open_renewal', type: 'default' },\n            { id: 'b8', source: 'check_no_open_renewal', target: 'create_renewal_opp', type: 'conditional', condition: P`existingRenewalOpp == null`, label: 'Open renewal deal' },\n          ],\n        }),\n      },\n    },\n    { id: 'end', type: 'end', label: 'End' },\n  ],\n\n  edges: [\n    { id: 'e1', source: 'start', target: 'query_contracts', type: 'default' },\n    { id: 'e2', source: 'query_contracts', target: 'loop_contracts', type: 'default' },\n    { id: 'e3', source: 'loop_contracts', target: 'end', type: 'default' },\n  ],\n};\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/revenue/flows/quote-expiration.flow.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/revenue/flows\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/revenue/flows/quote-expiration.flow.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport { cel } from '@objectstack/spec';\nimport type * as Automation from '@objectstack/spec/automation';\nimport { guarded } from '../../sales/flows/_guarded-iteration';\ntype Flow = Automation.Flow;\n\n/**\n * Quote auto-expiration \u2014 scheduled daily sweep.\n *\n * Flips quotes past their `expiration_date` to `expired` unless already\n * accepted/rejected/expired.\n */\nexport const QuoteExpirationFlow: Flow = {\n  name: 'quote_expiration',\n  label: 'Quote Auto-Expiration',\n  description: 'Daily: expire quotes past their expiration_date that are still open.',\n  type: 'schedule',\n  status: 'active',\n  // Scheduled runs have no trigger user, so under the default runAs:'user' the\n  // data nodes execute UNSCOPED anyway. Declare runAs:'system' to make that\n  // RLS-bypassing elevation explicit and intended (ADR-0049).\n  runAs: 'system',\n  variables: [],\n  nodes: [\n    { id: 'start', type: 'start', label: 'Start (daily 01:00)', config: { schedule: '0 1 * * *' } },\n    {\n      id: 'query_quotes', type: 'get_record', label: 'Find Expired Quotes',\n      config: {\n        objectName: 'crm_quote',\n        filter: { status: { $nin: ['accepted', 'rejected', 'expired'] }, expiration_date: { $lt: cel`isoDate(today())` } },\n        limit: 500,\n        outputVariable: 'quoteList',\n      },\n    },\n    {\n      id: 'loop_quotes', type: 'loop', label: 'For Each Quote',\n      config: {\n        collection: cel`quoteList`,\n        iteratorVariable: 'currentQuote',\n        body: guarded('quote', {\n          nodes: [\n            {\n              id: 'mark_expired', type: 'update_record', label: 'Mark Expired',\n              config: { objectName: 'crm_quote', filter: { id: cel`currentQuote.id` }, fields: { status: 'expired' } },\n            },\n          ],\n          edges: [],\n        }),\n      },\n    },\n    { id: 'end', type: 'end', label: 'End' },\n  ],\n  edges: [\n    { id: 'e1', source: 'start', target: 'query_quotes', type: 'default' },\n    { id: 'e2', source: 'query_quotes', target: 'loop_quotes', type: 'default' },\n    { id: 'e3', source: 'loop_quotes', target: 'end', type: 'default' },\n  ],\n};\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/revenue/flows/contract-expiration.flow.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/revenue/flows\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/revenue/flows/contract-expiration.flow.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport { cel } from '@objectstack/spec';\nimport type * as Automation from '@objectstack/spec/automation';\nimport { guarded } from '../../sales/flows/_guarded-iteration';\ntype Flow = Automation.Flow;\n\n/**\n * Contract auto-expiration \u2014 scheduled daily sweep.\n *\n * Flips `activated` contracts past their `end_date` to `expired` and notifies\n * the owner. (Renewal *reminders* are a separate concern, handled by the\n * `contract_renewal` flow.)\n */\nexport const ContractExpirationFlow: Flow = {\n  name: 'contract_expiration',\n  label: 'Contract Auto-Expiration',\n  description: 'Daily: expire activated contracts past their end_date and notify the owner.',\n  type: 'schedule',\n  status: 'active',\n  // Scheduled runs have no trigger user, so under the default runAs:'user' the\n  // data nodes execute UNSCOPED anyway. Declare runAs:'system' to make that\n  // RLS-bypassing elevation explicit and intended (ADR-0049).\n  runAs: 'system',\n  variables: [],\n  nodes: [\n    { id: 'start', type: 'start', label: 'Start (daily 00:00)', config: { schedule: '0 0 * * *' } },\n    {\n      id: 'query_contracts', type: 'get_record', label: 'Find Expired Contracts',\n      config: {\n        objectName: 'crm_contract',\n        filter: { status: 'activated', end_date: { $lt: cel`isoDate(today())` } },\n        limit: 500,\n        outputVariable: 'contractList',\n      },\n    },\n    {\n      id: 'loop_contracts', type: 'loop', label: 'For Each Contract',\n      config: {\n        collection: cel`contractList`,\n        iteratorVariable: 'currentContract',\n        body: guarded('contract', {\n          nodes: [\n            {\n              id: 'mark_expired', type: 'update_record', label: 'Mark Expired',\n              config: { objectName: 'crm_contract', filter: { id: cel`currentContract.id` }, fields: { status: 'expired' } },\n            },\n            {\n              id: 'notify_owner', type: 'notify', label: 'Notify Owner',\n              config: {\n                recipients: [cel`has(currentContract.owner_id) ? currentContract.owner_id : null`],\n                channels: ['inbox', 'email'],\n                topic: 'contract_expired',\n                template: 'crm.contract_expired',\n                templateData: { contract_number: cel`currentContract.contract_number` },\n                actionUrl: '/crm_contract/{{currentContract.id}}',\n              },\n            },\n          ],\n          edges: [\n            { id: 'b1', source: 'mark_expired', target: 'notify_owner', type: 'default' },\n          ],\n        }),\n      },\n    },\n    { id: 'end', type: 'end', label: 'End' },\n  ],\n  edges: [\n    { id: 'e1', source: 'start', target: 'query_contracts', type: 'default' },\n    { id: 'e2', source: 'query_contracts', target: 'loop_contracts', type: 'default' },\n    { id: 'e3', source: 'loop_contracts', target: 'end', type: 'default' },\n  ],\n};\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/revenue/flows/billing-handoff-contract-activated.flow.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/revenue/flows\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/revenue/flows/billing-handoff-contract-activated.flow.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport { P, cel } from '@objectstack/spec';\nimport type * as Automation from '@objectstack/spec/automation';\ntype Flow = Automation.Flow;\n\nimport {\n  BILLING_HANDOFF_ENDPOINT,\n  BILLING_HANDOFF_EVENT,\n  BILLING_HANDOFF_LINE_ITEM_LIMIT,\n  BILLING_HANDOFF_SIGNING_SECRET,\n  BILLING_HANDOFF_TIMEOUT_MS,\n  LINE_ITEM_FIELDS,\n  billingBody,\n  loadAccountNode,\n} from '../../sales/flows/_billing-endpoint';\n\n/**\n * \u2550\u2550\u2550 Billing hand-off \u2014 where HotCRM's revenue scope ends \u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\n *\n * HotCRM owns lead \u2192 contract. It does **not** model Orders, Invoices or\n * Payments (maintainer decision, 2026-08-02): billing is an external system's\n * job. What the CRM owes that system is a reliable hand-off, and these two\n * flows are it:\n *\n *   - `billing_handoff_closed_won`          \u2014 an opportunity ENTERS `closed_won`\n *     (`src/sales/flows/billing-handoff-closed-won.flow.ts`)\n *   - `billing_handoff_contract_activated`  \u2014 a contract ENTERS `activated`\n *     (this file; `crm_contract` is the revenue package's object)\n *\n * Each POSTs one JSON document \u2014 the record, its account, and its line items \u2014\n * to {@link BILLING_HANDOFF_ENDPOINT}, through the platform's **durable HTTP\n * outbox**: the `http` node with `durable: true` calls\n * `messaging.enqueueHttp({ source: 'flow', \u2026 })`, which persists a\n * `sys_http_delivery` row that the HTTP dispatcher drains with retry, backoff\n * and dead-lettering, signing the body with HMAC-SHA256 when a secret is set.\n * Nothing here is custom plumbing; it is the platform's own outbound-callout\n * verb, on the same outbox the declarative `webhooks` surface uses.\n *\n * ## \u26D4 Do not re-express these as declared `webhooks`\n *\n * Measured on 17.0.0-rc.6, that surface cannot express either event:\n * `WebhookSchema` is `.strict` and rejects `condition` / `filter` / `body` /\n * `payloadFields` / `retryPolicy`; its `triggers` vocabulary is\n * `create / update / delete / bulk_*` with no transition form; and the\n * auto-enqueuer matches on object + trigger alone and delivers a fixed\n * `DataEvent` envelope carrying neither the account nor the line items. A\n * `sys_webhook` row named for closed-won would fire on *every* opportunity edit\n * \u2014 a declaration that lies about itself, in the app other people copy.\n * Dispatch there is additionally gated on the `realtime` capability, which this\n * app does not require, so such a row would be visible in Setup and never fire\n * at all.\n *\n * The cost of this route is stated in `_billing-endpoint.ts` and in\n * `content/docs/revenue/billing-handoff.mdx`: the endpoint and secret live in\n * flow metadata, so repointing them is a rebuild, not a Setup edit.\n *\n * ## Exactly once per transition, not once per edit\n *\n * \u26D4 Both start conditions must test the TRANSITION\n * (`record.x == v && previous.x != v`), never the current value. This is the\n * idiom `opportunity_won_alert` uses on this very object: without the\n * `previous.*` term, every later edit of a won deal \u2014 a seed-ownership\n * claim, an approval stamp, a description tweak \u2014 re-fires the flow. For a\n * congratulations notification that is noise; for a billing hand-off it is a\n * duplicate order. `previous.*` is guarded FAIL-CLOSED (`has(previous.x) &&`)\n * for the same reason it is there: when the engine cannot see the prior value\n * it cannot see a transition either, and must not claim one. The shape that\n * covers is a bulk `updateMany`, where ObjectQL reads no prior row and\n * `previous` arrives null \u2014 one hand-off per row of a bulk update is exactly\n * what nobody wants.\n *\n * Delivery itself is **at-least-once**: the outbox retries a failed attempt,\n * and every attempt of one enqueued row carries the same `X-Objectstack-Delivery`\n * id. Receivers dedupe on that header.\n *\n * ## Totality\n *\n * Every `record.*` / `previous.*` read below carries a `has(...)` guard \u2014 the\n * house rule `test/flow-condition-totality.test.ts` enforces, because a flow\n * condition that aborts fails the whole run rather than yielding `false`.\n */\n\n/**\n * \u2500\u2500 Event 2: contract enters `activated` \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n *\n * NB the value is `activated`. `crm_contract.status` has no `active` member \u2014\n * the options are `draft / in_approval / activated / expired / terminated`,\n * governed by the `contract_status_progression` state machine.\n */\nexport const BillingHandoffContractActivatedFlow: Flow = {\n  name: 'billing_handoff_contract_activated',\n  label: 'Billing Hand-off: Contract Activated',\n  description:\n    'On the transition into activated: POST the contract, its account and the originating deal\u2019s line items to the billing endpoint via the durable HTTP outbox.',\n  type: 'record_change',\n  status: 'active',\n  // Contracts are activated by machinery as well as by hand \u2014 `contract.hook.ts`\n  // stamps the account promotion and signed date on that same transition, and\n  // the renewal sweep runs `runAs: 'system'`. A system write carries no trigger\n  // user, so under the default `runAs: 'user'` this flow's two reads would be\n  // refused on exactly those runs and the hand-off would disappear without a\n  // failed step. Elevation also guarantees the payload is the whole contract,\n  // not an RLS-narrowed view of it.\n  runAs: 'system',\n  variables: [\n    // Bound with a default because the line-item read below is CONDITIONAL: a\n    // contract need not have an originating opportunity. Without the default,\n    // the skipped path leaves `billingLineItems` unbound and the payload key\n    // vanishes \u2014 so a receiver could not tell \"no items\" from \"not sent\".\n    { name: 'billingLineItems', type: 'collection', isInput: false, isOutput: false, defaultValue: [] },\n  ],\n  nodes: [\n    {\n      id: 'start',\n      type: 'start',\n      label: 'Start (contract updated)',\n      config: {\n        objectName: 'crm_contract',\n        triggerType: 'record-after-update',\n        condition: P`has(record.status) && record.status == \"activated\"\n          && has(previous.status) && previous.status != \"activated\"`,\n      },\n    },\n    loadAccountNode(),\n    {\n      id: 'load_line_items',\n      type: 'get_record',\n      label: 'Load Originating Deal\u2019s Line Items',\n      config: {\n        objectName: 'crm_opportunity_line_item',\n        // Contracts carry no line items of their own; what was sold sits on the\n        // opportunity the contract came from. Reached only via the guarded edge\n        // below, because `crm_opportunity` is OPTIONAL on a contract and a\n        // filter operand that evaluates to null makes `get_record` refuse the\n        // step (an absent condition widens a query rather than narrowing it).\n        filter: { crm_opportunity: cel`record.crm_opportunity` },\n        fields: LINE_ITEM_FIELDS,\n        limit: BILLING_HANDOFF_LINE_ITEM_LIMIT,\n        outputVariable: 'billingLineItems',\n      },\n    },\n    {\n      id: 'send_contract_activated_handoff',\n      type: 'http',\n      label: 'Enqueue Billing Hand-off',\n      config: {\n        url: BILLING_HANDOFF_ENDPOINT,\n        method: 'POST',\n        durable: true,\n        timeoutMs: BILLING_HANDOFF_TIMEOUT_MS,\n        signingSecret: BILLING_HANDOFF_SIGNING_SECRET,\n        // One envelope building the whole payload (see `billingBody`). This\n        // flow is the consumer of `billing_frequency` and `payment_terms`: they\n        // are what the billing system needs to raise the schedule HotCRM\n        // deliberately does not model.\n        body: billingBody(BILLING_HANDOFF_EVENT.contractActivated, 'contract', [\n          'id', 'contract_number', 'status', 'contract_type', 'start_date', 'end_date', 'contract_term_months',\n          'contract_value', 'billing_frequency', 'payment_terms', 'auto_renewal', 'signed_date',\n          ['account_id', 'crm_account'], ['opportunity_id', 'crm_opportunity'], 'owner_id',\n        ]),\n      },\n    },\n    { id: 'end', type: 'end', label: 'End' },\n  ],\n  edges: [\n    { id: 'e1', source: 'start', target: 'load_account', type: 'default' },\n    // The two edges below are COMPLEMENTARY CONDITIONALS on a plain data node,\n    // deliberately not a `decision` gateway. A decision with no declared\n    // `config.conditions` reports the engine's `default` branch label, and\n    // traversal then narrows the edge set to out-edges claiming that label \u2014\n    // an `isDefault: true` sibling would swallow the whole branch and the\n    // conditional edge would never be evaluated. Complementary conditions off a\n    // non-branching node are evaluated one by one, which is the behaviour this\n    // needs.\n    {\n      id: 'e2',\n      source: 'load_account',\n      target: 'load_line_items',\n      type: 'conditional',\n      label: 'Has originating deal',\n      condition: P`has(record.crm_opportunity) && record.crm_opportunity != null`,\n    },\n    {\n      id: 'e3',\n      source: 'load_account',\n      target: 'send_contract_activated_handoff',\n      type: 'conditional',\n      label: 'No originating deal',\n      condition: P`!has(record.crm_opportunity) || record.crm_opportunity == null`,\n    },\n    { id: 'e4', source: 'load_line_items', target: 'send_contract_activated_handoff', type: 'default' },\n    { id: 'e5', source: 'send_contract_activated_handoff', target: 'end', type: 'default' },\n  ],\n};\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/marketing/flows/campaign-enrollment.flow.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/marketing/flows\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/marketing/flows/campaign-enrollment.flow.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport { P, cel } from '@objectstack/spec';\nimport type * as Automation from '@objectstack/spec/automation';\nimport { guarded } from '../../sales/flows/_guarded-iteration';\ntype Flow = Automation.Flow;\n\n/**\n * Campaign Enrollment \u2014 screen flow to bulk-enroll leads OR contacts into a\n * campaign.\n *\n * Launched from the \"Enroll Members\" action on a campaign record. \u26D4 Never turn\n * this into a `schedule` flow: a cron firing seeds NO input variables \u2014 only the\n * console's flow-action trigger does (cf. lead_conversion) \u2014 so `recordId` and\n * the segment fields arrive undefined, and the run either matches no campaign or\n * mass-enrolls every open lead into a null campaign.\n *\n * The contact branch mirrors the lead branch rather than being a second dialect:\n * same open-campaign gate, same eligibility shape, same per-member dedupe, same\n * `sent` + `added_date` stamp. Segmentation mirrors too \u2014 leads are segmented by\n * `status` (where they are in qualification); contacts have no such column, so\n * they are segmented by `department`, the field that answers \"who is this person\n * at the account\", which is what a campaign targeting an existing customer base\n * selects on.\n *\n * Eligibility, both sides: has an email, and is not opted out of email; leads\n * additionally must not already be converted (a converted lead is now a contact,\n * and would otherwise be enrollable through both branches as two people).\n * Already-enrolled people are skipped, so re-running the action tops up rather\n * than duplicating.\n *\n * \u26D4 This flow does NOT write the campaign metric rollups (`num_sent` etc.) \u2014\n * the campaign metric hooks own them and refresh on every membership change. A\n * per-run `num_sent = {leadList.length}` overwrite here clobbers prior batches.\n */\nexport const CampaignEnrollmentFlow: Flow = {\n  name: 'campaign_enrollment',\n  label: 'Enroll Members in Campaign',\n  description: 'Bulk enroll eligible leads or contacts into this campaign (skips already-enrolled and opted-out people).',\n  type: 'screen',\n  status: 'active',\n\n  variables: [\n    // `recordId` matches the console's flow-action trigger contract\n    // ({ recordId, objectName }) \u2014 cf. lead_conversion / quote_generation.\n    { name: 'recordId', type: 'text', isInput: true, isOutput: false },\n    /**\n     * `memberSource` is BOUND BY THIS DECLARATION \u2014 not by a seeding node.\n     *\n     * Both branch edges (`e4` / `e7`) read `vars.memberSource`, so it must be\n     * bound on every path reaching them. `FlowVariableSchema` carries\n     * `defaultValue` and the engine seeds it before the start node runs, so this\n     * key alone binds the name \u2014 while a caller-supplied\n     * `context.params.memberSource` still WINS over it.\n     *\n     * \u26A0\uFE0F Measured on the 17.1.0 spec, with the schema key re-checked on 17.2.0.\n     * Neither that key nor the seeding behaviour was re-checked on 17.3.0 or\n     * 17.4.0 (PR #1814, #1807), nor on 17.5.0, 17.6.0, 17.7.0 or 18.0.0-next.0 (the pin since #2031).\n     *\n     * \u26D4 Never seed this with an assignment node instead. An assignment is\n     * unconditional, so it CLOBBERS a supplied param \u2014 measured: launching with\n     * `params.memberSource = 'contacts'` ran the LEAD branch. It also restates a\n     * default the screen field carries, with nothing keeping the two in step.\n     *\n     * A second, independent reason no seeding node is needed here: the\n     * `memberSource` screen field below is `required: true`, and since\n     * 17.0.0-rc.2 the SERVER holds a screen resume to the declared field\n     * contract. A resume signal omitting `memberSource` is refused with\n     * `INVALID_SCREEN_INPUT` and the run stays paused, so the ordinary resume\n     * path cannot reach an unbound read at all \u2014 unlike `lead_conversion`'s\n     * checkbox, which is deliberately not `required` and therefore has an\n     * unanswered state. The one path that skips that check is a resume carrying\n     * NO signal object; measured on 17.x, it fails one node later at\n     * `query_leads` regardless of this binding, because `leadStatus` is unbound\n     * and the query never runs widened. Since 18.0.0-next.0 the filter operand\n     * is a CEL envelope, and an unbound variable fails the run before the query\n     * (the platform's `flow-value-slot-template-dialect-refused` contract; not\n     * re-measured here).\n     *\n     * The literal lives HERE and nowhere else: the screen field derives its\n     * prefill from this variable (its `defaultValue` envelope reads `memberSource`).\n     */\n    { name: 'memberSource', type: 'text', isInput: true, isOutput: false, defaultValue: 'leads' },\n    /**\n     * `leadStatus` / `contactDepartment` deliberately carry NO `defaultValue`,\n     * and the asymmetry with `memberSource` is the point. No condition in this\n     * flow reads either one \u2014 each is a `get_record` `filter` operand \u2014 so the\n     * binding analysis in `test/flow-variable-conditions.test.ts` does not\n     * cover them. An unbound one fails the run before the query is made (the\n     * 18.0.0-next.0 filter-operand contract), because an absent condition\n     * widens a query instead of narrowing it. Seeding these two would turn that\n     * loud failure into a silent enrolment of a segment nobody chose; their\n     * `required: true` screen fields are what supply them.\n     */\n    { name: 'leadStatus', type: 'text', isInput: true, isOutput: false },\n    { name: 'contactDepartment', type: 'text', isInput: true, isOutput: false },\n  ],\n\n  nodes: [\n    { id: 'start', type: 'start', label: 'Start', config: { objectName: 'crm_campaign' } },\n    {\n      id: 'screen_1', type: 'screen', label: 'Enrollment Criteria',\n      config: {\n        fields: [\n          {\n            // Prefill DERIVED from the variable, so the default is written\n            // once (on the declaration) rather than restated here \u2014 the\n            // single-authority form. The envelope is evaluated before the\n            // screen goes on the wire, so the client receives the raw value,\n            // the string `leads`, which is what a literal\n            // `defaultValue: 'leads'` used to send.\n            name: 'memberSource', label: 'Enroll', type: 'select', required: true,\n            defaultValue: cel`memberSource`,\n            options: [\n              { label: 'Leads', value: 'leads' },\n              { label: 'Contacts', value: 'contacts' },\n            ],\n          },\n          {\n            name: 'leadStatus', label: 'Enroll leads in status', type: 'select', required: true,\n            defaultValue: 'new',\n            options: [\n              { label: 'New', value: 'new' },\n              { label: 'Contacted', value: 'contacted' },\n              { label: 'Qualified', value: 'qualified' },\n            ],\n          },\n          {\n            // Required, like `leadStatus`, and for the same reason: a blank\n            // segment would reach the filter as an empty string and\n            // silently match the contacts with NO department rather than all of\n            // them. Both branches make the caller name a segment.\n            name: 'contactDepartment', label: 'Enroll contacts in department',\n            type: 'select', required: true, defaultValue: 'executive',\n            options: [\n              { label: 'Executive', value: 'executive' },\n              { label: 'Sales', value: 'sales' },\n              { label: 'Marketing', value: 'marketing' },\n              { label: 'Engineering', value: 'engineering' },\n              { label: 'Support', value: 'support' },\n              { label: 'Finance', value: 'finance' },\n              { label: 'Human Resources', value: 'hr' },\n              { label: 'Operations', value: 'operations' },\n            ],\n          },\n        ],\n      },\n    },\n    {\n      id: 'get_campaign', type: 'get_record', label: 'Get Campaign',\n      config: { objectName: 'crm_campaign', filter: { id: cel`recordId` }, outputVariable: 'campaignRecord' },\n    },\n    {\n      // The gate itself is on edges `e4` / `e7` \u2014 see the notes there. This node\n      // carries NO `config.condition`: the key is the trigger gate on a `start`\n      // node and is read nowhere else, so a copy here would be a second, inert\n      // statement of the predicate that no reader can tell apart from the live\n      // one (flagged by `flow-inert-node-condition` from 17.0.0-rc.2).\n      id: 'check_campaign_open', type: 'decision', label: 'Campaign Open?',\n    },\n    {\n      id: 'query_leads', type: 'get_record', label: 'Find Eligible Leads',\n      config: {\n        objectName: 'crm_lead',\n        filter: {\n          status: cel`leadStatus`,\n          is_converted: false,\n          email: { $ne: null },\n          // This is email-campaign enrollment \u2014 honour the opt-out flag.\n          // `campaign_member_optout_sync` populates it: an unsubscribed member\n          // round-trips to the person's `email_opt_out`.\n          email_opt_out: false,\n        },\n        limit: 1000,\n        outputVariable: 'leadList',\n      },\n    },\n    {\n      id: 'loop_leads', type: 'loop', label: 'Process Each Lead',\n      config: {\n        collection: cel`leadList`,\n        iteratorVariable: 'currentLead',\n        body: guarded('lead', {\n          nodes: [\n            {\n              // Dedupe: skip leads already enrolled in THIS campaign, so a\n              // re-run tops up instead of double-enrolling (double rows\n              // inflated num_sent / response_rate).\n              id: 'find_existing_member', type: 'get_record', label: 'Already Enrolled?',\n              config: {\n                objectName: 'crm_campaign_member',\n                filter: { crm_campaign: cel`recordId`, crm_lead: cel`currentLead.id` },\n                outputVariable: 'existingMember',\n              },\n            },\n            {\n              // Gateway only \u2014 the predicate lives on the out-edge.\n              id: 'check_not_enrolled', type: 'decision', label: 'New Member?',\n            },\n            {\n              // \u2B50 The INSERT is elevated, this flow is NOT. `added_date` is\n              // `readonly: true`, and from @objectstack/objectql 17.4.0 the\n              // readonly strip runs inside `engine.insert` for a non-system\n              // caller as well as on update \u2014 so a write from this screen\n              // flow's user context now loses the stamp. The remedy the\n              // platform names is a system context; the remedy AGENTS.md house\n              // rule 9 names is a dedicated `system` sub-flow rather than\n              // elevating the screen flow. Both are satisfied here. \u26D4 Do not\n              // fold this back by giving THIS flow `runAs: 'system'`: it would\n              // also lift RLS off `query_leads` / `query_contacts`, and\n              // `crm_lead` is `sharingModel: 'private'`.\n              // See `src/marketing/flows/campaign-member-enroll.flow.ts`.\n              id: 'create_campaign_member', type: 'subflow', label: 'Add to Campaign',\n              config: {\n                flowName: 'campaign_lead_member_enroll',\n                input: { campaignId: cel`recordId`, leadId: cel`currentLead.id` },\n              },\n            },\n          ],\n          edges: [\n            { id: 'b1', source: 'find_existing_member', target: 'check_not_enrolled', type: 'default' },\n            // Already enrolled \u2192 no edge \u2192 next lead. This edge is the ONLY\n            // site for the predicate: a `decision` node's singular\n            // `config.condition` is never read, so a node copy would be inert.\n            { id: 'b2', source: 'check_not_enrolled', target: 'create_campaign_member', type: 'conditional', condition: P`existingMember == null`, label: 'Enroll' },\n          ],\n        }),\n      },\n    },\n    {\n      id: 'query_contacts', type: 'get_record', label: 'Find Eligible Contacts',\n      config: {\n        objectName: 'crm_contact',\n        filter: {\n          department: cel`contactDepartment`,\n          email: { $ne: null },\n          // Same opt-out honour as the lead branch. There is no `is_converted`\n          // twin here: a contact IS the converted end state.\n          email_opt_out: false,\n        },\n        limit: 1000,\n        outputVariable: 'contactList',\n      },\n    },\n    {\n      id: 'loop_contacts', type: 'loop', label: 'Process Each Contact',\n      config: {\n        collection: cel`contactList`,\n        iteratorVariable: 'currentContact',\n        body: guarded('contact', {\n          nodes: [\n            {\n              // Dedupe scoped on `crm_contact`, so a person enrolled as a LEAD\n              // and again as a CONTACT is not treated as a duplicate: those are\n              // two records of two different relationships, and the seed\n              // datasets key them separately for the same reason.\n              id: 'find_existing_contact_member', type: 'get_record', label: 'Already Enrolled?',\n              config: {\n                objectName: 'crm_campaign_member',\n                filter: { crm_campaign: cel`recordId`, crm_contact: cel`currentContact.id` },\n                outputVariable: 'existingContactMember',\n              },\n            },\n            {\n              // Gateway only \u2014 the predicate lives on the out-edge.\n              id: 'check_contact_not_enrolled', type: 'decision', label: 'New Member?',\n            },\n            {\n              // The contact mirror of `create_campaign_member` above \u2014 same\n              // elevation, same reason. See that node's note.\n              id: 'create_contact_member', type: 'subflow', label: 'Add Contact to Campaign',\n              config: {\n                flowName: 'campaign_contact_member_enroll',\n                input: { campaignId: cel`recordId`, contactId: cel`currentContact.id` },\n              },\n            },\n          ],\n          edges: [\n            { id: 'c1', source: 'find_existing_contact_member', target: 'check_contact_not_enrolled', type: 'default' },\n            { id: 'c2', source: 'check_contact_not_enrolled', target: 'create_contact_member', type: 'conditional', condition: P`existingContactMember == null`, label: 'Enroll' },\n          ],\n        }),\n      },\n    },\n    { id: 'end', type: 'end', label: 'End' },\n  ],\n\n  edges: [\n    { id: 'e1', source: 'start', target: 'screen_1', type: 'default' },\n    { id: 'e2', source: 'screen_1', target: 'get_campaign', type: 'default' },\n    { id: 'e3', source: 'get_campaign', target: 'check_campaign_open', type: 'default' },\n    // Closed campaign \u2192 no edge \u2192 flow ends without enrolling.\n    //\n    // THE live gate, on the EDGES and only here. A `decision` node's singular\n    // `config.condition` is never read by the engine.\n    //\n    // Only enroll into campaigns that are actually running (or planned):\n    // topping up a completed/aborted campaign would corrupt its recorded\n    // metrics. (Status values: planning / in_progress / completed / aborted.)\n    //\n    // TOTALITY: `has(vars.campaignRecord)` first, then\n    // `has(vars.campaignRecord.status)`. `campaignRecord` is a `get_record`\n    // OUTPUT, and `findOne` answers a miss with `null` \u2014 so a campaign that was\n    // deleted (or hidden by sharing) between the action click and this node\n    // leaves the variable bound to null, and an unguarded read aborts with\n    // `No such key: status`, recording the run `failed` with not one lead\n    // enrolled. `status` is `required` on `crm_campaign` today so the column is\n    // never sparse \u2014 but that is the neighbouring schema doing the work, not\n    // this predicate, so it is guarded too.\n    //\n    // TWO conditional out-edges, one per member side. The open-campaign clause\n    // is repeated on both rather than hoisted to a second decision node: the\n    // gate IS the edge predicate here, so a separate \"which side\" node would\n    // need its own out-edges carrying the same clause anyway, and a node\n    // stating it once in `config.condition` is inert.\n    { id: 'e4', source: 'check_campaign_open', target: 'query_leads', type: 'conditional', condition: P`has(vars.campaignRecord) && has(vars.campaignRecord.status)\n      && (vars.campaignRecord.status == \"planning\" || vars.campaignRecord.status == \"in_progress\")\n      && vars.memberSource != \"contacts\"`, label: 'Open \u00B7 Leads' },\n    { id: 'e5', source: 'query_leads', target: 'loop_leads', type: 'default' },\n    { id: 'e6', source: 'loop_leads', target: 'end', type: 'default' },\n    // The contact branch. `memberSource` carries no `has()` guard on either\n    // edge, deliberately: its `flow.variables` declaration carries\n    // `defaultValue: 'leads'`, which the engine seeds before the start node, so\n    // it is bound on every path that reaches here \u2014 and on the ordinary resume\n    // path the server has already refused any signal that omitted the\n    // `required` screen field. A guard would have buried the policy (\"no answer\n    // means leads\") inside a predicate and left the graph defect in place \u2014 see\n    // test/flow-variable-conditions.test.ts.\n    { id: 'e7', source: 'check_campaign_open', target: 'query_contacts', type: 'conditional', condition: P`has(vars.campaignRecord) && has(vars.campaignRecord.status)\n      && (vars.campaignRecord.status == \"planning\" || vars.campaignRecord.status == \"in_progress\")\n      && vars.memberSource == \"contacts\"`, label: 'Open \u00B7 Contacts' },\n    { id: 'e8', source: 'query_contacts', target: 'loop_contacts', type: 'default' },\n    { id: 'e9', source: 'loop_contacts', target: 'end', type: 'default' },\n  ],\n};\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/marketing/flows/campaign-member-enroll.flow.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/marketing/flows\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/marketing/flows/campaign-member-enroll.flow.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport { cel } from '@objectstack/spec';\nimport type * as Automation from '@objectstack/spec/automation';\ntype Flow = Automation.Flow;\n\n/**\n * The campaign-membership INSERT \u2014 the one elevated step behind Enroll Members.\n *\n * ## Why these two flows exist\n *\n * `crm_campaign_member.added_date` is `readonly: true`: nobody is meant to\n * hand-edit when a membership was created.\n *\n * \u2B50 From `@objectstack/objectql` 17.4.0 the readonly strip covers INSERT as\n * well as UPDATE, which is the reason this file exists. Its changelog states\n * the BREAKING behaviour change: *\"a static `readonly` field is now stripped\n * from a **non-system caller's INSERT payload inside `engine.insert`**, exactly\n * as it already was on `engine.update`\"*, and it names the remedy in the same\n * sentence \u2014\n * *\"Seeding a read-only column at create time is a **system** act \u2014 use\n * `context.isSystem`, a flow's `runAs: 'system'`, a system hook or a seed.\"*\n * `objectstack validate` says the same thing at author time through\n * `flow-update-readonly-field`.\n *\n * \u26D4 The remedy is NOT to elevate `campaign_enrollment`. That flow is a screen\n * flow a marketer launches from a campaign record, and `AGENTS.md` house rule 9\n * (\"Elevate as little as possible\") is explicit: *\"A screen\n * flow stays `runAs: 'user'`. A write that genuinely needs elevation is split\n * into a dedicated `system` sub-flow and called through a `subflow` node. \u26D4 Do\n * not elevate a whole flow to make `readonly` take effect.\"* Elevating the\n * parent would also lift row-level security off its two bulk reads \u2014 and\n * `crm_lead` is `sharingModel: 'private'`, so a rep clicking Enroll Members\n * would silently enroll the whole organisation's lead pool instead of the leads\n * they can see. That is a product change, not a migration.\n *\n * So the shape is the one `case_escalation_stamp` already uses for\n * `escalate_case`: the parent keeps the marketer's identity for the campaign\n * read, the eligibility queries and the per-member dedupe, and hands ONLY the\n * insert to a dedicated `runAs: 'system'` callee.\n *\n * ELEVATION IS NOT ANONYMITY: `resolveRunDataContext`\n * returns `{ isSystem: true, actor, ...userId }` for a `runAs: 'system'` run, so\n * the membership row is still attributed to the marketer who enrolled it \u2014 only\n * the readonly strip's `if (!opCtx.context?.isSystem)` branch is skipped.\n *\n * ## Two flows, not one branching flow\n *\n * `create_record`'s `fields` map is static, and the lead branch and the contact\n * branch write DIFFERENT lookup columns (`crm_lead` vs `crm_contact`) \u2014 the\n * dedupe in the parent is scoped that way on purpose, because a person enrolled\n * as a lead and again as a contact is two memberships, not a duplicate. A\n * single callee would need a decision node routing on which id happened to be\n * supplied, which is a second place to get that distinction wrong. Two callees\n * with no branching at all say it once each.\n *\n * ## \u26D4 What these flows deliberately do NOT do\n *\n * They insert one membership row and nothing else. The open-campaign gate, the\n * eligibility filters, the opt-out honour and the already-enrolled dedupe all\n * stay in `campaign_enrollment` under the marketer's context \u2014 moving any of\n * them here would elevate a read that has no business being elevated.\n */\n\n/** Fields both callees write, minus the branch's own person lookup. */\nconst MEMBERSHIP_FIELDS = {\n  status: 'sent',\n  // The readonly stamp this elevation exists for.\n  added_date: cel`isoDatetime(now())`,\n} as const;\n\nexport const CampaignLeadMemberEnrollFlow: Flow = {\n  name: 'campaign_lead_member_enroll',\n  label: 'Enroll Lead in Campaign',\n  description:\n    'Insert one lead campaign-membership row with its readonly added_date stamp, using the system context. Called by campaign_enrollment through a subflow node.',\n  type: 'autolaunched',\n  status: 'active',\n\n  // \u2B50 THE ENTIRE POINT OF THIS FILE \u2014 see the header. One `create_record`.\n  runAs: 'system',\n\n  variables: [\n    // Supplied by the caller's `subflow` node.\n    { name: 'campaignId', type: 'text', isInput: true, isOutput: false },\n    { name: 'leadId', type: 'text', isInput: true, isOutput: false },\n  ],\n\n  nodes: [\n    // `config: {}` \u2014 an autolaunched callee is handed its params by the\n    // `subflow` executor and resolves no trigger record of its own, so there is\n    // no `objectName` for the start node to load. Same shape as\n    // `case_escalation_stamp`, measured in `test/readonly-write-semantics.test.ts`.\n    { id: 'start', type: 'start', label: 'Start', config: {} },\n    {\n      id: 'create_campaign_member', type: 'create_record', label: 'Add to Campaign',\n      config: {\n        objectName: 'crm_campaign_member',\n        // \u26D4 Do not add fields here. Every column in this node is written with\n        // the elevated context; anything a marketer may legitimately type\n        // belongs in `campaign_enrollment` instead.\n        fields: { crm_campaign: cel`campaignId`, crm_lead: cel`leadId`, ...MEMBERSHIP_FIELDS },\n      },\n    },\n    { id: 'end', type: 'end', label: 'End' },\n  ],\n\n  edges: [\n    { id: 'e1', source: 'start', target: 'create_campaign_member', type: 'default' },\n    { id: 'e2', source: 'create_campaign_member', target: 'end', type: 'default' },\n  ],\n};\n\nexport const CampaignContactMemberEnrollFlow: Flow = {\n  name: 'campaign_contact_member_enroll',\n  label: 'Enroll Contact in Campaign',\n  description:\n    'Insert one contact campaign-membership row with its readonly added_date stamp, using the system context. Called by campaign_enrollment through a subflow node.',\n  type: 'autolaunched',\n  status: 'active',\n\n  runAs: 'system',\n\n  variables: [\n    { name: 'campaignId', type: 'text', isInput: true, isOutput: false },\n    { name: 'contactId', type: 'text', isInput: true, isOutput: false },\n  ],\n\n  nodes: [\n    { id: 'start', type: 'start', label: 'Start', config: {} },\n    {\n      id: 'create_contact_member', type: 'create_record', label: 'Add Contact to Campaign',\n      config: {\n        objectName: 'crm_campaign_member',\n        fields: { crm_campaign: cel`campaignId`, crm_contact: cel`contactId`, ...MEMBERSHIP_FIELDS },\n      },\n    },\n    { id: 'end', type: 'end', label: 'End' },\n  ],\n\n  edges: [\n    { id: 'e1', source: 'start', target: 'create_contact_member', type: 'default' },\n    { id: 'e2', source: 'create_contact_member', target: 'end', type: 'default' },\n  ],\n};\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/marketing/flows/campaign-completion.flow.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/marketing/flows\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/marketing/flows/campaign-completion.flow.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport { cel } from '@objectstack/spec';\nimport type * as Automation from '@objectstack/spec/automation';\nimport { guarded } from '../../sales/flows/_guarded-iteration';\ntype Flow = Automation.Flow;\n\n/**\n * Campaign auto-completion \u2014 scheduled daily sweep.\n *\n * Each night it flips `in_progress` campaigns whose `end_date` has passed to\n * `completed` \u2014 a `status` transition, which is one of the triggers\n * `campaign_metrics_refresh` (`campaign.hook.ts`) recomputes the metric block\n * on.\n *\n * \u26A0\uFE0F That is a REFRESH, not a snapshot. The block is kept live by four refresh\n * hooks \u2014 `campaign_metrics_refresh`, `campaign_attribution_refresh`,\n * `campaign_lead_conversion_refresh` and `campaign_member_metrics_refresh` \u2014 so\n * this sweep is not the moment the numbers arrive, just one more transition\n * over numbers that were already current.\n */\nexport const CampaignCompletionFlow: Flow = {\n  name: 'campaign_completion',\n  label: 'Campaign Auto-Completion',\n  description: 'Daily: mark in_progress campaigns whose end_date has passed as completed.',\n  type: 'schedule',\n  status: 'active',\n  // Scheduled runs have no trigger user, so under the default runAs:'user' the\n  // data nodes execute UNSCOPED anyway. Declare runAs:'system' to make that\n  // RLS-bypassing elevation explicit and intended (ADR-0049).\n  runAs: 'system',\n  variables: [],\n  nodes: [\n    { id: 'start', type: 'start', label: 'Start (daily 02:00)', config: { schedule: '0 2 * * *' } },\n    {\n      id: 'query_campaigns', type: 'get_record', label: 'Find Ended Campaigns',\n      config: {\n        objectName: 'crm_campaign',\n        filter: { status: 'in_progress', end_date: { $lt: cel`isoDate(today())` } },\n        limit: 500,\n        outputVariable: 'campaignList',\n      },\n    },\n    {\n      id: 'loop_campaigns', type: 'loop', label: 'For Each Campaign',\n      config: {\n        collection: cel`campaignList`,\n        iteratorVariable: 'currentCampaign',\n        body: guarded('campaign', {\n          nodes: [\n            {\n              id: 'mark_completed', type: 'update_record', label: 'Mark Completed',\n              config: { objectName: 'crm_campaign', filter: { id: cel`currentCampaign.id` }, fields: { status: 'completed' } },\n            },\n          ],\n          edges: [],\n        }),\n      },\n    },\n    { id: 'end', type: 'end', label: 'End' },\n  ],\n  edges: [\n    { id: 'e1', source: 'start', target: 'query_campaigns', type: 'default' },\n    { id: 'e2', source: 'query_campaigns', target: 'loop_campaigns', type: 'default' },\n    { id: 'e3', source: 'loop_campaigns', target: 'end', type: 'default' },\n  ],\n};\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/sales/skills/lead-qualification.skill.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/sales/skills\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/sales/skills/lead-qualification.skill.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport { defineSkill } from '@objectstack/spec';\n\n/**\n * Lead Qualification \u2014 score an inbound lead with BANT, then act on it.\n *\n * ADR-0109: scoring is judgement, not a tool call. The lead is read\n * with the platform's data tools; the two outcomes that change state\n * (`convert_lead`, `schedule_followup`) are HotCRM's own Actions,\n * reached through their materialised `action_<name>` tools.\n *\n * Auto-activates when the user is viewing a lead record so the LLM\n * surfaces the capability without the user having to ask for it.\n */\nexport const LeadQualificationSkill = defineSkill({\n  name: 'lead_qualification',\n  label: 'Lead Qualification',\n  description: 'Qualifies inbound leads using BANT criteria and assigns a 0\u2013100 score.',\n\n  instructions: `When the user asks to qualify, score, or analyse a lead:\n\n1. Read the lead \u2014 \\`describe_object\\` for \\`crm_lead\\` first (fields\n   change), then \\`get_record\\`. Use \\`query_records\\` to pull the\n   related activity history when the lead has any.\n2. Score it yourself, 0\u2013100, with BANT. There is no scoring tool:\n   Budget (is spend confirmed or inferable from company size?),\n   Authority (is the contact a decision maker?), Need (is there a\n   stated problem you solve?), Timeline (is there a date?). Weight\n   them evenly unless the user says otherwise.\n3. Report the score, one line of justification per BANT dimension\n   naming the field or activity you read, and the single recommended\n   next step. Cite the lead ID.\n4. Score >= 70 and the user agrees \u2192 call \\`action_convert_lead\\`.\n5. Otherwise, or when the user wants to nurture, call\n   \\`action_schedule_followup\\` with the date you recommend. Say why\n   that date.\n6. Never convert without explicit confirmation \u2014 conversion is not\n   reversible from this surface.`,\n\n  tools: [\n    'describe_object',\n    'get_record',\n    'query_records',\n    'action_convert_lead',\n    'action_schedule_followup',\n  ],\n\n  triggerConditions: [\n    { field: 'objectName', operator: 'eq', value: 'crm_lead' },\n  ],\n});\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/sales/skills/email-drafting.skill.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/sales/skills\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/sales/skills/email-drafting.skill.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport { defineSkill } from '@objectstack/spec';\n\n/**\n * Email Drafting \u2014 write the copy, then send it through the real Action.\n *\n * ADR-0109: writing a subject line and personalising a body is what the\n * model does; it is not a tool call. Sending is HotCRM's `send_email`\n * Action, which carries no `ai` block \u2014 ADR-0011 exposure is opt-in and\n * default off, so no `action_send_email` tool is materialised and the\n * skill has nothing to call. The agent therefore drafts and hands over; a\n * human reviews the copy and presses Send. For outbound email that review\n * step is a feature, not a limitation.\n */\nexport const EmailDraftingSkill = defineSkill({\n  name: 'email_drafting',\n  label: 'Email Drafting',\n  description: 'Drafts personalised outbound emails grounded in live contact data, ready for a human to review and send.',\n\n  instructions: `When the user asks to draft, write, or optimise an email:\n\n1. Ground it in real data before writing a word: \\`get_record\\` the\n   contact (and the related account or opportunity when the request\n   references one) so names, titles and recent activity are accurate.\n   Use \\`query_records\\` when you need the recent history.\n2. Write the copy yourself \u2014 subject and body. You do not have, and do\n   not need, a copy-generation tool. Aim for: a subject under 60\n   characters naming the concrete value, a first line referencing\n   something specific to THIS recipient rather than a generic\n   pleasantry, one clear ask, and no more than 150 words.\n3. Offer two subject-line variants, say which you recommend and why,\n   so the user can A/B them.\n4. Show the draft and stop. You cannot send \u2014 say so plainly rather\n   than implying a send is queued.\n5. Point the user at **Send Email** on the contact record, where the\n   subject and body you drafted can be pasted, reviewed and sent.`,\n\n  tools: ['get_record', 'query_records'],\n\n});\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/sales/skills/revenue-forecasting.skill.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/sales/skills\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/sales/skills/revenue-forecasting.skill.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport { defineSkill } from '@objectstack/spec';\n\n/**\n * Revenue Forecasting \u2014 analysis over live pipeline data.\n *\n * ADR-0109: forecasting is the whole point of giving a model\n * aggregation over the user's own records; it is not a bespoke tool.\n * This skill declares no tool records at all \u2014 it composes the\n * platform's `aggregate_data` / `query_records` / `visualize_data`\n * with instructions that carry the actual method.\n */\nexport const RevenueForecastingSkill = defineSkill({\n  name: 'revenue_forecasting',\n  label: 'Revenue Forecasting',\n  description: 'Analyses pipeline health, surfaces at-risk deals, and forecasts revenue from live opportunity data.',\n\n  instructions: `When the user asks about pipeline health, forecast,\nrisk, or deal slippage:\n\n1. Establish the shape first: \\`describe_object\\` for\n   \\`crm_opportunity\\` so you use the CURRENT stage, amount,\n   probability and close-date fields rather than assumed ones.\n2. Summarise the pipeline with \\`aggregate_data\\` \u2014 count and summed\n   amount grouped by stage, scoped to the period the user names\n   (default: the current quarter). Weighted value is amount \u00D7\n   probability; compute it yourself from what you read.\n3. Surface at-risk deals with \\`query_records\\`: close date already\n   past, or no activity in 30+ days, or the stage unchanged for longer\n   than its typical duration. Name each deal and the specific signal.\n4. Forecast by summing weighted value for open deals plus closed-won\n   in the period. State the assumption behind the number in one line,\n   and give a range rather than false precision \u2014 the spread between\n   commit-only (high-probability stages) and full weighted pipeline.\n5. Offer \\`visualize_data\\` when a chart would carry the answer better\n   than prose, e.g. stage distribution or month-over-month trend.\n6. Be quantitative: every claim cites a number or a deal name. If the\n   data cannot support a claim, say so instead of estimating.`,\n\n  tools: ['describe_object', 'aggregate_data', 'query_records', 'visualize_data'],\n\n  triggerConditions: [\n    { field: 'objectName', operator: 'in', value: ['crm_opportunity', 'dashboard'] },\n  ],\n});\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/sales/skills/customer-360.skill.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/sales/skills\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/sales/skills/customer-360.skill.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport { defineSkill } from '@objectstack/spec';\n\n/**\n * Customer 360 \u2014 one profile assembled from the records that already exist.\n *\n * ADR-0109: this skill declares no bespoke tools. Its whole tool list used\n * to be `search_knowledge`, while the instructions promised an account +\n * cases + opportunities + knowledge roll-up it had no tool to read \u2014 it\n * could not fetch a single record.\n *\n * `search_knowledge` is NOT fictional; #557 dropped it on that premise and\n * the premise was wrong. It is a real platform tool \u2014 re-measured\n * 2026-09-10 on the 17.4.0 pin, `PLATFORM_PROVIDED_TOOL_NAMES` lists it\n * (from `@objectstack/spec/system`; the `/ai` subpath does not carry that\n * export) and `spec/src/ai/knowledge-source.zod.ts:143` documents it.\n * Added to `tools` it resolves and lints clean.\n *\n * It is left out because there is nothing else to retrieve from. A\n * knowledge source is not app metadata on 17.4.0 \u2014 sources belong to the\n * knowledge service, and no app of any shape declares one. The knowledge\n * base here is `crm_knowledge_article`, a normal CRM object, so\n * `query_records` reaches it like every other object this skill reads;\n * `content/docs/ai-copilot/knowledge-bases.mdx` is that promise. Revisit\n * if a source becomes declarable \u2014 objectstack#17464 is the trigger.\n */\nexport const Customer360Skill = defineSkill({\n  name: 'customer_360',\n  label: 'Customer 360',\n  description: 'Aggregates account, recent cases, open opportunities, and knowledge hits into a single customer profile.',\n\n  instructions: `When the user asks for \"the full picture\" of a\ncustomer / account / contact:\n\n1. Read the shape first \u2014 \\`describe_object\\` for \\`crm_account\\`, and for\n   each related object before you query it. Admins add fields; never\n   summarise from memory of a previous turn.\n2. \\`get_record\\` the account, then pull the related work with\n   \\`query_records\\`, each filtered to this account:\n   - \\`crm_contact\\` \u2014 who the people are, primary contact first.\n   - \\`crm_case\\` \u2014 cases where \\`is_closed\\` is false, newest first.\n   - \\`crm_opportunity\\` \u2014 open deals with stage, amount and close date.\n   Quote totals from \\`aggregate_data\\` (open pipeline amount, case count\n   by status) rather than adding up rows yourself.\n3. For the policy or playbook context, \\`query_records\\` on\n   \\`crm_knowledge_article\\` \u2014 \\`status\\` published, matched on the\n   \\`category\\` or \\`tags\\` of the cases you just read. You have no\n   knowledge-search tool in this skill and do not need one: the knowledge\n   base is an object like any other.\n4. Summarise into three sections: **Account Snapshot** \u00B7 **Active Work** \u00B7\n   **Risks & Notes**. Every risk names the record and the signal that\n   raised it \u2014 an escalated case, a close date already past, a deal with\n   no activity in 30+ days. Do not infer risk you cannot cite.\n5. Cite record IDs inline (e.g. \"case CASE-01234\", \"article KA-0007\") so\n   the UI can deep link. If a section has no records, say so plainly\n   instead of filling it.`,\n\n  tools: ['describe_object', 'get_record', 'query_records', 'aggregate_data'],\n\n});\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/sales/skills/live-data.skill.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/sales/skills\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/sales/skills/live-data.skill.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport { defineSkill } from '@objectstack/spec';\n\n/**\n * Live Data \u2014 the foundation of HotCRM's \"Wow #1\" demo.\n *\n * Wires the platform's built-in metadata + data tools into the\n * assistant so it always sees the current schema before querying.\n * This is what makes \"add a field, AI uses it 30s later\" actually\n * work \u2014 `describe_object` re-reads metadata on every call.\n */\nexport const LiveDataSkill = defineSkill({\n  name: 'live_data',\n  label: 'Live Data Access',\n  description:\n    'Queries any CRM object using the current live schema. Always inspects the object structure first so newly added fields are picked up immediately.',\n\n  instructions: `When the user asks a question that touches a CRM\nrecord (account, contact, lead, opportunity, case, quote, etc.):\n\n1. **Always** call \\`describe_object\\` for the relevant object FIRST,\n   even if you think you remember the fields. The schema can change\n   between turns \u2014 trust the tool, not your memory.\n2. Use \\`list_objects\\` if you are not sure which object holds the\n   data the user is asking about.\n3. Use \\`query_records\\` (filters, sort, limit) for lists,\n   \\`get_record\\` for a single ID, \\`aggregate_data\\` for sums /\n   counts / averages.\n4. When you reference data, cite the record ID inline so the UI\n   can deep-link (e.g. \"opportunity OPP-1234\").\n5. If \\`describe_object\\` shows a field you've never seen before,\n   USE IT \u2014 that's the user's whole point in adding it. Surface it\n   in your answer when relevant.`,\n\n  tools: [\n    'describe_object',\n    'list_objects',\n    'query_records',\n    'get_record',\n    'aggregate_data',\n  ],\n\n});\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/sales/sharing/account.sharing.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/sales/sharing\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/sales/sharing/account.sharing.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport { P } from '@objectstack/spec';\nimport { TERRITORY } from '../objects/_territory';\n\n/** Share accounts with sales managers/directors based on customer status */\nexport const AccountTeamSharingRule = {\n  name: 'account_team_sharing',\n  label: 'Account Team Sharing',\n  object: 'crm_account',\n  type: 'criteria' as const,\n  condition: P`record.type == \"customer\" && record.is_active == true`,\n  accessLevel: 'edit' as const,\n  sharedWith: { type: 'position' as const, value: 'sales_manager' },\n};\n\n/**\n * Territory-Based Sharing (criteria-based, by declared territory).\n *\n * These filter on `crm_account.territory` \u2014 a declared `select` whose value\n * `account.hook.ts` derives from `billing_address.country` against the one\n * authored mapping in `src/sales/objects/_territory.ts`.\n *\n * ### Two defects, in the order they were fixed\n *\n * 1. The condition used to read `record.billing_address.country`. A sharing\n *    rule's condition is compiled to a pushdown-able filter by\n *    `compileCelToFilter`, which rejects any path reaching inside an `address`\n *    value; `plugin-sharing` then refuses to seed the rule at all rather than\n *    degrade it to match-all, which is how both of these shipped inert for\n *    months while the docs promised they worked (#621). The fix was a FLAT\n *    column, `billing_country`. The `in [...]` operator was never the blocker\n *    \u2014 `test/sharing-seeding.test.ts` measures the whole supported operator\n *    set and fails if any declared rule stops translating.\n *\n * 2. That column is free text, so the rules still matched a TYPED STRING: an\n *    account whose billing country read `United States` matched neither\n *    territory, silently, and the country lists were duplicated across two CEL\n *    strings and six localised documentation tables (#639). The fix is to\n *    match a declared value instead. The country never reaches a rule now, and\n *    the `UK`-vs-`GB` question that could not be fixed in isolation dissolved\n *    with it: both spellings are `emea` in the mapping, so nothing migrated.\n *\n * The literal values below are INTERPOLATED from the declared domain \u2014 `P`\n * quotes an interpolated string, so `record.territory == \"na\"` is what is\n * authored, and renaming a territory value cannot be half-applied.\n * `test/territory-single-source.test.ts` pins the rest of the derivation:\n * every value one of these rules names must be a declared option, and must be\n * reachable from at least one country.\n */\nexport const TerritorySharingRules = [\n  {\n    name: 'north_america_territory',\n    label: 'North America Territory',\n    object: 'crm_account',\n    type: 'criteria' as const,\n    condition: P`record.territory == ${TERRITORY.NA}`,\n    accessLevel: 'edit' as const,\n    sharedWith: { type: 'position' as const, value: 'na_sales_team' },\n  },\n  {\n    name: 'europe_territory',\n    label: 'Europe Territory',\n    object: 'crm_account',\n    type: 'criteria' as const,\n    condition: P`record.territory == ${TERRITORY.EMEA}`,\n    accessLevel: 'edit' as const,\n    sharedWith: { type: 'position' as const, value: 'eu_sales_team' },\n  },\n];\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/sales/sharing/opportunity.sharing.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/sales/sharing\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/sales/sharing/opportunity.sharing.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport { P } from '@objectstack/spec';\nimport { LARGE_DEAL_AMOUNT } from '../objects/_thresholds';\n\n/**\n * Share high-value open opportunities with the sales director.\n * ADR-0090 D3: `role_and_subordinates` is gone (positions are flat); the\n * grant now targets the director position itself.\n */\nexport const OpportunitySalesSharingRule = {\n  name: 'opportunity_sales_sharing',\n  label: 'Opportunity Sales Team Sharing',\n  object: 'crm_opportunity',\n  type: 'criteria' as const,\n  condition: P`!(record.stage in [\"closed_won\", \"closed_lost\"]) && record.amount >= ${LARGE_DEAL_AMOUNT}`,\n  accessLevel: 'read' as const,\n  sharedWith: { type: 'position' as const, value: 'sales_director' },\n};\n\n/**\n * The same large-deal visibility one rung up.\n *\n * Positions are FLAT (ADR-0090 D3): nothing rolls the director's grant up to the\n * executive rung, so the rule that gives leadership its pipeline view has to be\n * authored per position. Same criteria, same read-only level \u2014 an executive\n * reads the deal, the deal team still owns it.\n */\nexport const OpportunityExecutiveSharingRule = {\n  name: 'opportunity_executive_sharing',\n  label: 'Large Open Deals \u2014 Executive',\n  object: 'crm_opportunity',\n  type: 'criteria' as const,\n  condition: P`!(record.stage in [\"closed_won\", \"closed_lost\"]) && record.amount >= ${LARGE_DEAL_AMOUNT}`,\n  accessLevel: 'read' as const,\n  sharedWith: { type: 'position' as const, value: 'executive' },\n};\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/sales/sharing/positions.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/sales/sharing\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/sales/sharing/positions.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\n/**\n * CRM Positions (ADR-0090 D3 \u2014 formerly the role hierarchy).\n *\n * Positions are deliberately FLAT: no parent, no hierarchy. The v1 role\n * tree's reporting lines belong on the business-unit tree / manager chain,\n * which this app does not model \u2014 so the old `parentRole` links were\n * dropped rather than translated.\n *\n * Flat also means visibility does NOT roll up: every rung that needs access to\n * a record carries its own sharing rule. That is why each leadership rung has\n * an explicit companion rule (`opportunity_executive_sharing`,\n * `case_director_sharing`, `campaign_leadership_*`) rather than inheriting the\n * manager's \u2014 a position that no sharing rule and no permission-set binding\n * names grants nothing at all (#488).\n */\nexport const CrmPositions = [\n  { name: 'executive',          label: 'Executive' },\n  { name: 'sales_director',     label: 'Sales Director' },\n  { name: 'sales_manager',      label: 'Sales Manager' },\n  { name: 'sales_rep',          label: 'Sales Representative' },\n  { name: 'service_director',   label: 'Service Director' },\n  { name: 'service_manager',    label: 'Service Manager' },\n  { name: 'service_agent',      label: 'Service Agent' },\n  { name: 'marketing_director', label: 'Marketing Director' },\n  { name: 'marketing_manager',  label: 'Marketing Manager' },\n  { name: 'marketing_user',     label: 'Marketing User' },\n  // Territory groupings referenced by the account sharing rules.\n  { name: 'na_sales_team',      label: 'NA Sales Team' },\n  { name: 'eu_sales_team',      label: 'EU Sales Team' },\n];\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/marketing/sharing/campaign.sharing.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/marketing/sharing\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/marketing/sharing/campaign.sharing.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport { P } from '@objectstack/spec';\n\n/**\n * Campaign leadership sharing.\n *\n * `crm_campaign` is `public_read` (`src/marketing/objects/campaign.object.ts`), so the OWD\n * baseline already hands READ to everyone holding object-level read on it: a\n * marketing manager or director opens any campaign with or without this file.\n * What `public_read` does NOT hand out is WRITE. `@objectstack/plugin-sharing`\n * 17.0.0-rc.2 states the boundary in `buildWriteFilter`'s own comment \u2014 the\n * editable set \"applies to BOTH `private` and `read` (public_read) models \u2014\n * public_read is read-open but write-owned; only a fully `public` object is\n * write-open\" \u2014 i.e. owner-match OR records shared at a write access level.\n *\n * These two rules are that second branch, and `accessLevel: 'edit'` is the part\n * doing the work: they let a marketing manager / director EDIT a live campaign a\n * specialist owns, rather than having to take ownership of it. Nor does the\n * `marketing_user` permission set make them redundant \u2014 its\n * `marketing_campaign_updates` RLS policy (`id != null`) widens the RLS layer\n * only, and the sharing layer's write-owned baseline still refuses the update.\n *\n * MEASURED on 17.0.0-rc.2 against this app's own metadata (#724), for a user\n * holding the `marketing_user` set plus position `marketing_manager` and owning\n * no campaign: reads return EVERY campaign at all times; before these rules\n * materialise, `buildWriteFilter` is `{ owner_id: specialist }` and updating a\n * specialist-owned campaign is FORBIDDEN; after, the filter gains\n * `{ id: { $in: [live campaign] } }` and the same update succeeds, while the\n * completed campaign stays FORBIDDEN. So deleting these rules costs the two\n * rungs their only edit path and changes nothing about what they can READ \u2014\n * which is exactly what makes the loss easy to miss.\n *\n * ADR-0090 D3 positions are FLAT (no hierarchy to roll visibility up), so each\n * rung that needs the access carries its own grant. Scoped to live campaigns:\n * finished ones stay with their owner and the analytics surfaces that report on\n * them.\n */\nexport const CampaignLeadershipSharingRules = [\n  {\n    name: 'campaign_leadership_manager',\n    label: 'Live Campaigns \u2014 Marketing Manager',\n    object: 'crm_campaign',\n    type: 'criteria' as const,\n    condition: P`record.status in [\"planning\", \"in_progress\"] && record.is_active == true`,\n    accessLevel: 'edit' as const,\n    sharedWith: { type: 'position' as const, value: 'marketing_manager' },\n  },\n  {\n    name: 'campaign_leadership_director',\n    label: 'Live Campaigns \u2014 Marketing Director',\n    object: 'crm_campaign',\n    type: 'criteria' as const,\n    condition: P`record.status in [\"planning\", \"in_progress\"] && record.is_active == true`,\n    accessLevel: 'edit' as const,\n    sharedWith: { type: 'position' as const, value: 'marketing_director' },\n  },\n];\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/sales/data/sales.seed.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/sales/data\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/sales/data/sales.seed.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\n/**\n * Sales seeds \u2014 accounts, contacts, leads and opportunities.\n *\n * Split out of the former monolithic `src/data/index.ts` (#635). Seed doctrine\n * lives in `./_shared.ts`.\n *\n * `OPPORTUNITY_LINES` stays here, with the deals it prices: `dealValue()`\n * derives every opportunity's `amount` from it. The line-item ROWS it also\n * feeds are `crm_opportunity_line_item`, a revenue object, so they are seeded\n * from `src/revenue/data/opportunity-line-item.seed.ts`, which reads this\n * table along the revenue -> sales edge.\n */\nimport { defineSeed } from '@objectstack/spec/data';\nimport { cel } from '@objectstack/spec';\nimport { Account } from '../objects/account.object';\nimport { Contact } from '../objects/contact.object';\nimport { Lead } from '../objects/lead.object';\nimport { Opportunity } from '../objects/opportunity.object';\nimport { celDaysAgo, linesTotal, type LineSpec } from './_shared';\n\n// \u2500\u2500\u2500 Accounts \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n//\n// `billing_address` is load-bearing demo data, not decoration (#638). The two\n// territory sharing rules filter on `crm_account.billing_country` \u2014 the flat\n// projection `account_protection` derives from `billing_address.country` \u2014 so\n// an account with no address belongs to no territory. Until now not one seeded\n// account carried an address, which meant #621 shipped two territory rules\n// that installed correctly and then matched zero records: Setup listed two\n// territories with nothing behind them.\n//\n// The nine accounts partition deliberately across all THREE outcomes the rules\n// can produce, so a demo shows the split instead of asserting it:\n//\n//   north_america_territory  territory == \"na\"     \u2192 6  (5 \u00D7 US, 1 \u00D7 CA)\n//   europe_territory         territory == \"emea\"   \u2192 2  (DE, UK)\n//   neither territory        territory == \"other\"  \u2192 1  (SG)\n//\n// The rules match `territory`, a declared select the hook classifies the\n// address country into (#639) \u2014 no rule compares a country string any more.\n// `country` still carries the 2-LETTER CODE here: seed addresses keep to ISO\n// 3166-1 alpha-2 as a data-quality convention, and the spelling table in\n// `src/sales/objects/_territory.ts` exists for what USERS type, not for what this\n// file authors.\n//\n// `UK` on the London account is the one deliberate exception, and it is now\n// load-bearing rather than merely historical: `UK` is an ACCEPTED SPELLING of\n// `GB` in that table, so this row is the stock-data proof that the alias path\n// works end to end. Correcting it to `GB` would delete that coverage \u2014 and the\n// eviction #639 was worried about cannot happen, because both spellings are\n// `emea`.\n//\n// `billing_country` and `territory` are both deliberately NOT authored here.\n// Hooks DO run over seed writes (#617, corrected in `./_shared.ts`), so both\n// are computed at seed time; the field is `readonly` and hook-owned, and a\n// hand-copied value would be a second source of truth for something\n// `account_protection` already maintains \u2014 the exact drift the doctrine block\n// exists to prevent. `test/territory-seed-coverage.test.ts` pins the dependency\n// from the other side: every seeded address must carry a country the\n// projection can turn into the territory bucket claimed above.\n//\n// Phone numbers moved with the addresses: a Munich account answering a Denver\n// number is the kind of incoherence an evaluator notices before the feature.\n//\n// \u2500\u2500\u2500 `last_activity_date`: the churn clock, and who is allowed to set it \u2500\u2500\u2500\n//\n// The three \"Quiet 30 / 60 / 90+ Days\" tiles on the Sales Activity dashboard,\n// `at_risk_accounts` and `customer_churn_signals` all window this one column,\n// so the demo needs a real DISTRIBUTION across the three bands \u2014 not the\n// cluster inside a fortnight it used to be, which left every churn surface\n// empty while the data looked populated (#671).\n//\n// Authoring it here is legitimate, and the boundary is worth stating because it\n// is NOT the `billing_country` case three paragraphs up (doctrine rule 3 in\n// `./_shared.ts`). `billing_country` is `readonly` and DERIVED \u2014 the hook\n// recomputes it from `billing_address` on every write that carries one, so a\n// seeded copy would be a second source of truth for a value nothing else owns.\n// `last_activity_date` is neither: #592 removed the `readonly` flag precisely\n// so hooks could write it, and no hook derives it from anything on the account.\n// It is a HISTORICAL fact \u2014 \"when did anyone last speak to this customer\" \u2014 and\n// authoring history into a field whose writers only ever stamp the current date\n// is doctrine rule 1, the same licence `stage_entry_date` and the case seeds'\n// `created_at` already use.\n//\n// What the writers DO impose is a constraint on the events seeded beside these\n// rows, and it decides the whole layout below. Lifecycle hooks run over seed\n// writes (#617), and two of them stamp TODAY on an account:\n//\n//   \u00B7 `event_activity_bubble` \u2014 on any `held` event, walking up from its\n//     contact / opportunity / case (`src/sales/objects/event.hook.ts`);\n//   \u00B7 `task_activity_bubble`  \u2014 on any task seeded already completed.\n//\n// Neither reads the activity's own timestamp: a `held` meeting seeded 45 days\n// ago still stamps the day the demo was seeded. So an account may carry an\n// authored age ONLY if nothing in the seed book bubbles to it; otherwise the\n// authored value is overwritten at seed time and the demo shows something\n// nobody wrote (doctrine rule 2). Hence the three-way split:\n//\n//   today()   Acme, Wayne, Vertex, Stark \u2014 every account something in the seed\n//             book bubbles to. Acme / Wayne / Vertex carry `held` events;\n//             Stark carries the completed welcome-package task, which has\n//             bubbled since long before this issue (its authored `daysAgo(5)`\n//             was being silently overwritten). Authored as today because that\n//             is exactly what the bubble writes, so the value is right whether\n//             or not hooks fire.\n//   6\u20138 days  Lattice, Globex \u2014 recency from channels this seed book does not\n//             model (an email thread, a signature). They carry only `planned`\n//             and `cancelled` events, neither of which bubbles.\n//   41/72/104 Northwind, Initech, Apex \u2014 one per churn band. Nothing held\n//             reaches them; each carries a BOOKED re-engagement meeting\n//             instead, which is #592's whole point: a meeting on the calendar\n//             is not an interaction that happened, and only `held` moves the\n//             clock. Internal pipeline motion (a `stage_entry_date`) is not\n//             customer contact either, which is why a stagnating deal can sit\n//             on a silent account \u2014 that pairing is what the stagnation sweep\n//             and the churn tiles are each looking at from one side.\n//\n// `test/activity-seed-coverage.test.ts` recomputes the bubble's reachability\n// from the seeds themselves and fails if a held event ever reaches one of the\n// three quiet accounts, so the split above cannot rot into a comment.\n//\n// \u2500\u2500\u2500 `health_score`: the churn signal a HUMAN asserts \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n//\n// Four options ship (`healthy` / `watching` / `at_risk` / `churning`) and the\n// churn report's first panel, `csm_flagged_accounts`, selects the worst two.\n// That panel is the ONLY one on the report with no time window, so the\n// population it exists for is an account being worked right now and still\n// flagged. The seed book has to contain one, or the demo renders a panel that\n// merely restates the 60-day window stacked below it (#1414). Hence a\n// deliberate three-way split, the same shape as the territory and activity\n// partitions above:\n//\n//   Initech  `at_risk`  + 72 days quiet \u2014 flagged AND derived. It lands in\n//            this panel and in `at_risk_accounts`; the report's own header\n//            says the two blocks are allowed to overlap.\n//   Wayne    `churning` + clock at today() \u2014 flagged and NOT derived. Its\n//            `strategic` tier is inside `silent_high_value`'s scope as well,\n//            so the clock alone keeps it out of BOTH windowed panels: the\n//            account no derived signal can see. It is what makes the set\n//            difference FLAGGED \\ QUIET60 non-empty.\n//   Stark    `at_risk`  + clock at today(), and NOT a customer \u2014 the row the\n//            panel's `rows: ['type']` grouping exists for (#1647). While every\n//            flagged account was a `customer` the grouping rendered a single\n//            row and could demonstrate nothing; the grid view\n//            `crm_account.at_risk_accounts` filters `type == 'customer'`\n//            before anything else, so a flagged PARTNER is a row the report\n//            block can show and that grid cannot.\n//\n// The other customers stay `healthy` on purpose. A severity every record\n// carries demonstrates nothing, and `churning` is the most severe option in\n// the model \u2014 one record is what makes it real rather than declared.\n//\n// The three PROSPECTS carry no `health_score` at all, and that blank is a\n// stated choice rather than an oversight: the column is what a CSM asserts\n// about a RELATIONSHIP, and nobody has been in the room with an account that\n// was never won. The criterion `$in [at_risk, churning]` does not match an\n// absent value, so a blank row is outside the panel either way \u2014 it says\n// \"nobody has assessed this\", which is exactly true of a prospect.\n//\n// \u2500\u2500\u2500 `approval_status`: every seeded account is already signed off \u2500\u2500\u2500\u2500\u2500\n//\n// Each row below states `approval_status: 'approved'`, and it has to. On a real\n// insert the column is born blank and `account_approval` submits it (REQ-0003;\n// the request's mirror writes `pending`, #2067). A seed row never reaches that\n// flow: the platform writes every seed row with `skipTriggers`\n// (`SEED_WRITE_EXECUTION_CONTEXT`, `@objectstack/spec`), because a seed is\n// established END-STATE data, not a user event. Left unstated, a row would\n// claim no sign-off at all; under the former `pending` default it read\n// `pending` with no request behind it, the console showed \"Locked for\n// approval\" and disabled Edit, and no admin could edit a seeded account\n// (#2042). These accounts carry deals, contracts and cases; they are past\n// their sign-off, so the row says so.\n// \u26D4 Do not \"fix\" it with an `approved` field default instead: that switches\n// the gate off for every account a user creates.\nexport const accounts = defineSeed(Account, {\n  mode: 'upsert',\n  externalId: 'name',\n  records: [\n    {\n      name: 'Acme Corporation',\n      approval_status: 'approved',\n      type: 'customer',\n      industry: 'technology',\n      annual_revenue: 5000000,\n      number_of_employees: 250,\n      phone: '+1-415-555-0100',\n      billing_address: { street: '500 Howard Street, Suite 400', city: 'San Francisco', state: 'CA', postalCode: '94105', country: 'US' },\n      website: 'https://acme.example.com',\n      tier: 'enterprise',\n      segment: 'growth',\n      health_score: 'healthy',\n      // Held: workshop, demo, calls and an onsite visit \u2014 see `service.seed.ts`.\n      last_activity_date: cel`today()`,\n      // The ARR line below used to read \"signed Q1 2025 renewal\" while the\n      // deal it describes closes `daysAgo(15)` \u2014 a fixed calendar quarter on a\n      // relative-date record, wrong in both the quarter and the year (#1692).\n      // The label is not re-derived here either: that date belongs to\n      // `Acme Annual Renewal 2025` (`close_date`) and to its contract\n      // (`signed_date`, `revenue.seed.ts`), and computing a copy in this module\n      // means re-stating that record's own offset \u2014 a second source of truth\n      // for a value two records already own. Same ruling as the `next_step`\n      // block below (#1660): no date goes back into this prose, absolute OR\n      // relative. What stays true however the renewal is dated is that it IS\n      // signed: the deal is `closed_won` and its contract `activated`.\n      description: `**Strategic Customer \u00B7 Enterprise Tier**\n\nAcme Corporation is a Series-C robotics & industrial automation\ncompany that switched from a competitor 18 months ago. They run\nHotCRM as their system of record for sales + service across\nthree regional teams (NA, EMEA, APAC).\n\n**Relationship**\n- Primary economic buyer: Jordan Park (CTO) \u2014 values our open\n  architecture and AI roadmap.\n- Day-to-day champion: John Smith (VP Engineering) \u2014 owns the\n  technical evaluation and integration questions.\n- Procurement: handled by Lisa Kim \u2014 prefers annual contracts,\n  net-30 terms.\n\n**Current state**\n- ARR: $220K (signed renewal). Up 22% YoY.\n- 1 open enterprise opportunity ($150K platform upgrade) in proposal\n  stage, 1 service ticket open (login issues), 1 billing dispute\n  awaiting customer response.\n- AI agent governance became a hard requirement for that upgrade\n  after their internal compliance review, so the workshop now on\n  the calendar is the gate on signature.\n\n**Red flags**\n- Lost the $75K Marketing Cloud add-on on timing \u2014 their marketing\n  org is locked into a 2-year HubSpot contract, and the buying\n  window opens when that contract renews.\n- Login issues ticket is already past its SLA clock \u2014 needs eyes\n  today.`,\n    },\n    {\n      name: 'Globex Industries',\n      approval_status: 'approved',\n      type: 'prospect',\n      industry: 'manufacturing',\n      annual_revenue: 12000000,\n      number_of_employees: 800,\n      phone: '+1-312-555-0200',\n      billing_address: { street: '233 South Wacker Drive', city: 'Chicago', state: 'IL', postalCode: '60606', country: 'US' },\n      website: 'https://globex.example.com',\n      tier: 'enterprise',\n      segment: 'net_new',\n      // Only a booked demo and a cancelled review \u2014 neither bubbles, so this\n      // 8-day age survives the seed load and stays inside every churn window.\n      last_activity_date: cel`daysAgo(8)`,\n    },\n    {\n      name: 'Initech Solutions',\n      approval_status: 'approved',\n      type: 'customer',\n      industry: 'finance',\n      annual_revenue: 3500000,\n      number_of_employees: 150,\n      phone: '+1-212-555-0300',\n      billing_address: { street: '1 Liberty Plaza, 23rd Floor', city: 'New York', state: 'NY', postalCode: '10006', country: 'US' },\n      website: 'https://initech.example.com',\n      tier: 'mid_market',\n      segment: 'at_risk',\n      health_score: 'at_risk',\n      // QUIET 60+ \u2014 the `at_risk` segment and health score, with a clock that\n      // finally agrees with them: ten weeks of silence. A no-show call 55 days\n      // ago was the last attempt; the re-engagement call on the calendar is\n      // `planned`, so it moves nothing.\n      last_activity_date: cel`daysAgo(72)`,\n    },\n    {\n      name: 'Stark Medical',\n      approval_status: 'approved',\n      type: 'partner',\n      industry: 'healthcare',\n      annual_revenue: 8000000,\n      number_of_employees: 400,\n      // The one Canadian account: still inside north_america_territory, and the\n      // reason that rule's `$in` list is not a single-country list in disguise.\n      phone: '+1-416-555-0400',\n      billing_address: { street: '181 Bay Street, Suite 2200', city: 'Toronto', state: 'ON', postalCode: 'M5J 2T3', country: 'CA' },\n      website: 'https://starkmed.example.com',\n      tier: 'mid_market',\n      segment: 'stable',\n      // `at_risk` rather than `churning`, and the distinction is the reason\n      // this row can exist at all: a partner whose pilot was WON and whose\n      // expansion then died on a capital freeze can be at risk, but it was\n      // never a subscription that could churn. The records say it \u2014 `Stark\n      // Expansion (Lost)` closed `no_budget` 60 days ago and the partnership\n      // contract is still in legal review \u2014 and the panel's criterion admits\n      // both values, so the honest severity is also the one that flags.\n      //\n      // Diverging from `segment: 'stable'` is deliberate, the same split\n      // Wayne demonstrates below: `segment` is how the book classifies the\n      // account, `health_score` is what a person asserts about it. The clock\n      // stays at today(), so like Wayne this row is outside every windowed\n      // panel on that report: it reaches `csm_flagged_accounts` and no other\n      // block.\n      health_score: 'at_risk',\n      // The completed 'Send welcome package' task bubbles here on every seed\n      // load, so this has ALWAYS resolved to today \u2014 the previous `daysAgo(5)`\n      // was authored and then overwritten before anyone could read it.\n      last_activity_date: cel`today()`,\n    },\n    {\n      name: 'Wayne Enterprises',\n      approval_status: 'approved',\n      type: 'customer',\n      industry: 'technology',\n      annual_revenue: 25000000,\n      number_of_employees: 2000,\n      phone: '+1-650-555-0500',\n      billing_address: { street: '3000 Hanover Street', city: 'Palo Alto', state: 'CA', postalCode: '94304', country: 'US' },\n      website: 'https://wayne.example.com',\n      tier: 'strategic',\n      segment: 'growth',\n      // CHURNING, with the clock still running \u2014 the population\n      // `csm_flagged_accounts` exists for (#1414). Every DERIVED signal on\n      // this row reads healthy: an operations rollout closed four days ago, a\n      // licence sits at 80% two weeks from signature, three meetings were held\n      // this month. The CSM who has been in the room says the account is going\n      // anyway, and `health_score` is the only churn signal in the model a\n      // person ASSERTS \u2014 which is why the panel that reads it is first on the\n      // report and carries no time window.\n      //\n      // \u26D4 Do not \"correct\" this to `at_risk` to agree with the pipeline, and\n      // \u26D4 do not stop the clock to agree with the health score: either edit\n      // folds the row back into `at_risk_accounts` (60-day window) and the\n      // flagged panel goes back to restating its neighbour.\n      health_score: 'churning',\n      // Held: negotiation meeting, security-addendum call, governance webinar.\n      last_activity_date: cel`today()`,\n    },\n    {\n      name: 'Northwind Energy',\n      approval_status: 'approved',\n      type: 'prospect',\n      industry: 'energy',\n      annual_revenue: 18000000,\n      number_of_employees: 1100,\n      // europe_territory, half 1: DE.\n      phone: '+49-89-5550-0600',\n      billing_address: { street: 'Leopoldstrasse 21', city: 'Munich', state: 'BY', postalCode: '80802', country: 'DE' },\n      website: 'https://northwind.example.com',\n      tier: 'enterprise',\n      segment: 'net_new',\n      // QUIET 30+ \u2014 the field-service pilot was lost 80 days ago and the grid\n      // program has not been worked since. The discovery workshop is booked,\n      // not held.\n      last_activity_date: cel`daysAgo(41)`,\n      description: 'A regional energy provider evaluating a unified operations and customer-data platform.',\n    },\n    {\n      name: 'Vertex Analytics',\n      approval_status: 'approved',\n      type: 'customer',\n      industry: 'software',\n      annual_revenue: 9500000,\n      number_of_employees: 420,\n      phone: '+1-512-555-0700',\n      billing_address: { street: '600 Congress Avenue, Floor 14', city: 'Austin', state: 'TX', postalCode: '78701', country: 'US' },\n      website: 'https://vertex.example.com',\n      tier: 'enterprise',\n      segment: 'growth',\n      health_score: 'healthy',\n      // Held: rollout meeting, analytics demo, committee call, retrospective.\n      last_activity_date: cel`today()`,\n      description: 'An analytics SaaS customer expanding usage from the data team to its revenue organization.',\n    },\n    {\n      name: 'Lattice Education',\n      approval_status: 'approved',\n      type: 'customer',\n      industry: 'education',\n      annual_revenue: 6800000,\n      number_of_employees: 320,\n      // europe_territory, half 2 \u2014 and the alias fixture. `UK` is not ISO\n      // 3166-1 alpha-2 (`GB` is); it is an ACCEPTED SPELLING in\n      // `src/sales/objects/_territory.ts`, so this row proves on stock data that a\n      // legacy spelling still lands in `emea` (#639). No `state`: an address\n      // without a subdivision is a normal shape, and only `country` is read.\n      phone: '+44-20-7946-0800',\n      billing_address: { street: '20 Fenchurch Street', city: 'London', postalCode: 'EC3M 3BY', country: 'UK' },\n      website: 'https://lattice.example.com',\n      tier: 'mid_market',\n      segment: 'stable',\n      health_score: 'healthy',\n      // Signed the analytics expansion six days ago; the renewal review is\n      // booked, not held, so nothing bubbles and this age stands.\n      last_activity_date: cel`daysAgo(6)`,\n      description: 'A higher-education technology company consolidating admissions, student-success and alumni workflows.',\n    },\n    {\n      name: 'Apex Logistics',\n      approval_status: 'approved',\n      type: 'prospect',\n      industry: 'logistics',\n      annual_revenue: 22000000,\n      number_of_employees: 1400,\n      // `territory == \"other\"` on purpose: without a record that matches\n      // neither rule, \"the rules partition the accounts\" is unfalsifiable \u2014\n      // a match-all regression would look identical to a working one. `SG` is\n      // a real country the staffed territories do not cover, which is exactly\n      // what `other` is for (#639) \u2014 it is a stated classification here, not a\n      // blank.\n      phone: '+65-6555-0900',\n      billing_address: { street: '10 Marina Boulevard, #30-01', city: 'Singapore', postalCode: '018983', country: 'SG' },\n      website: 'https://apexlogistics.example.com',\n      tier: 'enterprise',\n      segment: 'net_new',\n      // QUIET 90+ \u2014 a lost compliance deal 110 days ago and a data-hub\n      // evaluation that has been silent for a quarter. Only a booked\n      // re-engagement call.\n      last_activity_date: cel`daysAgo(104)`,\n      description: 'A fast-growing logistics provider assessing a modern data hub for its operations and commercial teams.',\n    },\n  ]\n});\n\n// \u2500\u2500\u2500 Contacts \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\nexport const contacts = defineSeed(Contact, {\n  mode: 'upsert',\n  externalId: 'email',\n  records: [\n    {\n      salutation: 'mr',\n      first_name: 'John',\n      last_name: 'Smith',\n      email: 'john.smith@acme.example.com',\n      phone: '+1-415-555-0101',\n      title: 'VP of Engineering',\n      department: 'engineering',\n      crm_account: 'Acme Corporation',\n      is_primary: true,\n    },\n    {\n      salutation: 'ms',\n      first_name: 'Sarah',\n      last_name: 'Johnson',\n      email: 'sarah.j@globex.example.com',\n      phone: '+1-312-555-0201',\n      title: 'Chief Procurement Officer',\n      department: 'executive',\n      crm_account: 'Globex Industries',\n      is_primary: true,\n    },\n    {\n      salutation: 'dr',\n      first_name: 'Michael',\n      last_name: 'Chen',\n      email: 'mchen@initech.example.com',\n      phone: '+1-212-555-0301',\n      title: 'Director of Operations',\n      department: 'operations',\n      crm_account: 'Initech Solutions',\n      is_primary: true,\n    },\n    {\n      salutation: 'ms',\n      first_name: 'Emily',\n      last_name: 'Davis',\n      email: 'emily.d@starkmed.example.com',\n      phone: '+1-617-555-0401',\n      title: 'Head of Partnerships',\n      department: 'sales',\n      crm_account: 'Stark Medical',\n      is_primary: true,\n    },\n    {\n      salutation: 'mr',\n      first_name: 'Robert',\n      last_name: 'Wilson',\n      email: 'rwilson@wayne.example.com',\n      phone: '+1-650-555-0501',\n      title: 'CTO',\n      department: 'engineering',\n      crm_account: 'Wayne Enterprises',\n      is_primary: true,\n    },\n    {\n      salutation: 'ms',\n      first_name: 'Olivia',\n      last_name: 'Chen',\n      email: 'olivia.chen@northwind.example.com',\n      phone: '+1-303-555-0601',\n      title: 'VP of Digital Operations',\n      department: 'operations',\n      crm_account: 'Northwind Energy',\n      is_primary: true,\n    },\n    {\n      salutation: 'mr',\n      first_name: 'Ethan',\n      last_name: 'Brooks',\n      email: 'ethan.brooks@vertex.example.com',\n      phone: '+1-512-555-0701',\n      title: 'Chief Revenue Officer',\n      department: 'executive',\n      crm_account: 'Vertex Analytics',\n      is_primary: true,\n    },\n    {\n      salutation: 'ms',\n      first_name: 'Priya',\n      last_name: 'Shah',\n      email: 'priya.shah@lattice.example.com',\n      phone: '+1-617-555-0801',\n      title: 'VP of Student Success',\n      department: 'operations',\n      crm_account: 'Lattice Education',\n      is_primary: true,\n    },\n    {\n      salutation: 'mr',\n      first_name: 'Marcus',\n      last_name: 'Reed',\n      email: 'marcus.reed@apexlogistics.example.com',\n      phone: '+1-404-555-0901',\n      title: 'Director of Commercial Systems',\n      department: 'operations',\n      crm_account: 'Apex Logistics',\n      is_primary: true,\n    },\n  ]\n});\n\n// \u2500\u2500\u2500 Leads \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n/**\n * Disqualification reasons for the generated `unqualified` demo leads, paired\n * with the note that explains them.\n *\n * `crm_lead.disqualification_reason_required` rejects an unqualified lead that\n * carries no reason, so every seeded unqualified row must supply one \u2014 the rows\n * used to carry a budget-flavoured note and no reason at all. Rotated over four\n * values so the demo's disqualification breakdown has more than one bar, and\n * the note always matches the reason it sits next to.\n */\nconst DISQUALIFICATION_REASONS = [\n  { reason: 'no_budget',     note: 'No budget approved for this fiscal year \u2014 revisit next planning cycle.' },\n  { reason: 'not_a_fit',     note: 'Requirements sit outside what the product covers today.' },\n  { reason: 'wrong_persona', note: 'Contact has no say in the buying decision and no path to an owner.' },\n  { reason: 'unreachable',   note: 'Six touches across email and phone over four weeks, no response.' },\n] as const;\n\nexport const leads = defineSeed(Lead, {\n  mode: 'upsert',\n  externalId: 'email',\n  records: [\n    {\n      first_name: 'Alice',\n      last_name: 'Martinez',\n      company: 'NextGen Retail',\n      email: 'alice@nextgenretail.example.com',\n      phone: '+1-503-555-0600',\n      status: 'new',\n      lead_source: 'web',\n      industry: 'retail',\n      rating: 3,\n      next_followup_date: cel`daysFromNow(2)`,\n    },\n    {\n      first_name: 'David',\n      last_name: 'Kim',\n      company: 'EduTech Labs',\n      email: 'dkim@edutechlabs.example.com',\n      phone: '+1-408-555-0700',\n      status: 'contacted',\n      lead_source: 'referral',\n      industry: 'education',\n      rating: 4,\n      next_followup_date: cel`daysFromNow(1)`,\n      // A seeded `held` event names this lead, and `event_activity_bubble`\n      // stamps `last_contacted_date` with the SEED MOMENT rather than the\n      // event's own timestamp \u2014 so an authored age here would be overwritten\n      // the instant it was written (doctrine rule 2 in `./_shared.ts`). Day\n      // granularity is the honest match: the seed writes today's UTC midnight,\n      // the bubble writes today's instant, and both render as \"today\".\n      last_contacted_date: cel`today()`,\n    },\n    {\n      first_name: 'Lisa',\n      last_name: 'Thompson',\n      company: 'CloudFirst Inc',\n      email: 'lisa.t@cloudfirst.example.com',\n      phone: '+1-206-555-0800',\n      status: 'qualified',\n      lead_source: 'event',\n      industry: 'technology',\n      // WHOLE stars only. `lead.hook.ts` rounds its computed score to an\n      // integer because \"half values rendered inconsistently in the star\n      // widget\", and the hook leaves an explicitly seeded number alone \u2014 so a\n      // seeded 4.5 was the one rating in the system the contract could never\n      // produce, and it rendered as the broken half-star it was meant to\n      // prevent (#591).\n      rating: 5,\n      next_followup_date: cel`daysFromNow(0)`,\n      // Same as David Kim above: a `held` qualification call names this lead.\n      last_contacted_date: cel`today()`,\n    },\n    // \u2500\u2500\u2500 Generated demo leads \u2014 spread across 6 months for monthly-bucket reports\n    // (`LeadInflowByMonthSourceReport`). Each `last_contacted_date` lives in a\n    // distinct month / source pair so the matrix has multiple cells populated.\n    ...[\n      { fn: 'Noah',    ln: 'Patel',    co: 'Vertex Analytics',     src: 'web',         ind: 'technology',   age: 7   },\n      { fn: 'Maya',    ln: 'Singh',    co: 'BluePeak Logistics',   src: 'referral',    ind: 'logistics',    age: 14  },\n      { fn: 'Owen',    ln: 'Becker',   co: 'Northwind Energy',     src: 'event',       ind: 'energy',       age: 21  },\n      { fn: 'Sara',    ln: 'Lopez',    co: 'Helios Solar',         src: 'partner',     ind: 'energy',       age: 28  },\n      { fn: 'Leo',     ln: 'Vance',    co: 'CleanCart',            src: 'web',         ind: 'retail',       age: 38  },\n      { fn: 'Iris',    ln: 'Okafor',   co: 'PulseHealth',          src: 'cold_call',   ind: 'healthcare',   age: 45  },\n      { fn: 'Ravi',    ln: 'Mehta',    co: 'Foundry Robotics',     src: 'event',       ind: 'manufacturing',age: 52  },\n      { fn: 'Tess',    ln: 'Brown',    co: 'Lattice Education',    src: 'referral',    ind: 'education',    age: 67  },\n      { fn: 'Marco',   ln: 'Ricci',    co: 'Aurora Travel',        src: 'advertisement', ind: 'hospitality',       age: 74  },\n      { fn: 'Pia',     ln: 'Anand',    co: 'Citrine Finance',      src: 'partner',     ind: 'finance', age: 81 },\n      { fn: 'Jonas',   ln: 'Holt',     co: 'Polar Cargo',          src: 'web',         ind: 'logistics',    age: 95  },\n      { fn: 'Anya',    ln: 'Volkov',   co: 'RedOak Realty',        src: 'cold_call',   ind: 'real_estate',  age: 102 },\n      { fn: 'Theo',    ln: 'Park',     co: 'Skyline Media',        src: 'advertisement', ind: 'media',        age: 116 },\n      { fn: 'Wren',    ln: 'Garcia',   co: 'Maple Bakery Group',   src: 'event',       ind: 'retail', age: 123 },\n      { fn: 'Hugo',    ln: 'Dubois',   co: 'Nimbus Aerospace',     src: 'referral',    ind: 'manufacturing',age: 138 },\n      { fn: 'Lena',    ln: 'Fischer',  co: 'Granite Insurance',    src: 'partner',     ind: 'finance', age: 145 },\n      { fn: 'Kai',     ln: 'Watanabe', co: 'Coral Reef Hotels',    src: 'web',         ind: 'hospitality',       age: 162 },\n      { fn: 'Mira',    ln: 'Costa',    co: 'Atlas Construction',   src: 'cold_call',   ind: 'other', age: 175 },\n    ].map((l, i) => {\n      const domain = `${l.co.toLowerCase().replace(/\\s+/g, '')}.example.com`;\n      const status = (['new', 'contacted', 'qualified', 'unqualified'] as const)[i % 4];\n      return {\n        first_name: l.fn,\n        last_name: l.ln,\n        company: l.co,\n        email: `${l.fn.toLowerCase()}.${l.ln.toLowerCase()}@${domain}`,\n        phone: `+1-555-01${String(i).padStart(2, '0')}-${String(1000 + i * 7)}`,\n        status,\n        lead_source: l.src,\n        industry: l.ind,\n        rating: 1 + ((i * 7) % 5),\n        last_contacted_date: celDaysAgo(l.age),\n        // The qualification fields were left blank on every generated lead, so\n        // the detail page's Contact / Lead Detail / Description sections had\n        // nothing to render (they also drop whatever the highlights strip\n        // already shows, so all four collapsed to nothing) and the demo read\n        // like a half-finished import.\n        title: (['VP Operations', 'Head of IT', 'Director of Sales', 'COO', 'Procurement Lead'] as const)[i % 5],\n        mobile: `+1-555-02${String(i).padStart(2, '0')}-${String(2000 + i * 3)}`,\n        website: `https://${domain}`,\n        annual_revenue: 2_000_000 + ((i * 3_700_000) % 90_000_000),\n        number_of_employees: 25 + ((i * 137) % 4_800),\n        description:\n          `Inbound via ${l.src.replace(/_/g, ' ')}. Evaluating a CRM to replace spreadsheets ` +\n          `across their ${l.ind.replace(/_/g, ' ')} operation.`,\n        ...(status === 'unqualified'\n          ? {\n              disqualification_reason: DISQUALIFICATION_REASONS[(i >> 2) % DISQUALIFICATION_REASONS.length].reason,\n              notes: DISQUALIFICATION_REASONS[(i >> 2) % DISQUALIFICATION_REASONS.length].note,\n            }\n          : {}),\n      };\n    }),\n  ]\n});\n\n// \u2500\u2500\u2500 Line items: the one source of truth for deal value \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n/**\n * Opportunity line items, keyed by the opportunity's name (its seed\n * externalId). Every seeded deal is itemised \u2014 before #591 not one was, so the\n * Products related list was empty on every opportunity in the demo and the CPQ\n * story had nothing to show.\n *\n * These sums are AUTHORITATIVE: each opportunity's `amount` below is computed\n * from its lines by `dealValue()` rather than typed in, which is the same\n * answer `opportunity_amount_rollup` computes when a rep touches a line. There\n * is therefore no seeded parent total that a first line-item edit can silently\n * rewrite \u2014 the acceptance condition of #591 holds by construction rather than\n * by anyone re-checking the arithmetic.\n *\n * Deriving rather than delegating is deliberate. Letting the rollup own the\n * number would make every seeded `amount` depend on whether hooks fire over\n * seed writes \u2014 which the doctrine block above says they do not and a boot log\n * says they do (#617) \u2014 and on that hook surviving its own write call (#616).\n * A derived literal is correct under every one of those combinations: if the\n * rollup runs it recomputes the same figure, and if it never runs the figure\n * was already right.\n */\nexport const OPPORTUNITY_LINES: Record<string, readonly LineSpec[]> = {\n  'Acme Platform Upgrade': [\n    { product: 'ObjectStack Platform', quantity: 2, unit_price: 50000, discount: 10, description: 'Enterprise edition \u2014 NA + EMEA production tenants (multi-year discount).' },\n    { product: 'Premium Support', quantity: 1, unit_price: 25000, description: '24\u00D77 premium support with a named TAM.' },\n    { product: 'AI Agent Seat (Annual)', quantity: 35, unit_price: 1000, description: 'Agent seats for the Ops organization.' },\n  ],\n  'Globex Manufacturing Suite': [\n    { product: 'ObjectStack Platform', quantity: 1, unit_price: 50000, description: 'Enterprise edition \u2014 one shared tenant serving all six manufacturing sites.' },\n    { product: 'Admin Training Workshop', quantity: 4, unit_price: 6000, description: 'Four workshop days, one per regional plant cluster.' },\n    { product: 'Standard Support', quantity: 1, unit_price: 9000, description: 'Business-hours support for the first year.' },\n    { product: 'AI Agent Seat (Annual)', quantity: 12, unit_price: 1000, description: 'Agent seats for the plant operations leads.' },\n  ],\n  'Wayne Enterprise License': [\n    { product: 'ObjectStack Platform', quantity: 20, unit_price: 50000, discount: 15, description: 'Enterprise-wide license, volume discount at 20 tenants.' },\n    { product: 'Premium Support', quantity: 4, unit_price: 25000, description: 'Premium support across four business units.' },\n    { product: 'AI Agent Seat (Annual)', quantity: 250, unit_price: 1000, description: 'Agent seats for the global revenue organization.' },\n  ],\n  'Initech Cloud Migration': [\n    { product: 'Data Migration Services', quantity: 1, unit_price: 35000, description: 'Migration off the legacy on-premise CRM.' },\n    { product: 'Cloud Hosting (Annual)', quantity: 2, unit_price: 12000, description: 'Managed hosting, primary + DR region.' },\n    { product: 'Standard Support', quantity: 1, unit_price: 9000, description: 'Business-hours support for the first year.' },\n    { product: 'AI Agent Seat (Annual)', quantity: 12, unit_price: 1000, description: 'Agent seats for the service desk.' },\n  ],\n  'Acme Annual Renewal 2025': [\n    { product: 'ObjectStack Platform', quantity: 3, unit_price: 50000, description: 'Renewal of the three production tenants.' },\n    { product: 'Premium Support', quantity: 1, unit_price: 25000, description: 'Premium support renewal.' },\n    { product: 'AI Agent Seat (Annual)', quantity: 45, unit_price: 1000, description: 'Seat expansion driven by the new EMEA team.' },\n  ],\n  'Stark Medical Pilot': [\n    { product: 'ObjectStack Platform', quantity: 2, unit_price: 50000, description: 'Pilot tenants for two clinical service lines.' },\n    { product: 'Standard Support', quantity: 1, unit_price: 9000, description: 'Standard support during the pilot.' },\n    { product: 'Admin Training Workshop', quantity: 6, unit_price: 6000, description: 'Six workshop days for the clinical operations admins.' },\n  ],\n  'Wayne Q1 Expansion': [\n    { product: 'ObjectStack Platform', quantity: 6, unit_price: 50000, description: 'Expansion into six additional subsidiaries.' },\n    { product: 'Premium Support', quantity: 2, unit_price: 25000, description: 'Premium support for the expanded footprint.' },\n    { product: 'AI Agent Seat (Annual)', quantity: 30, unit_price: 1000, description: 'Agent seats for the expansion teams.' },\n  ],\n  'Globex Training Package': [\n    { product: 'Admin Training Workshop', quantity: 10, unit_price: 6000, description: 'Ten workshop days across the plant admin community.' },\n    { product: 'AI Agent Seat (Annual)', quantity: 5, unit_price: 1000, description: 'Agent seats for the training sandbox.' },\n  ],\n  'Initech Phase 1': [\n    { product: 'Implementation Services', quantity: 1, unit_price: 75000, description: 'Phase 1 implementation: accounts, contacts, pipeline.' },\n    { product: 'Standard Support', quantity: 1, unit_price: 9000, description: 'Standard support for phase 1.' },\n    { product: 'AI Agent Seat (Annual)', quantity: 6, unit_price: 1000, description: 'Agent seats for the phase-1 pilot group.' },\n  ],\n  'Acme Add-on (Lost)': [\n    { product: 'Analytics Add-on', quantity: 2, unit_price: 22000, description: 'Marketing analytics for two business units.' },\n    { product: 'Integration Connector Pack', quantity: 1, unit_price: 16000, description: 'Marketing-automation connector pack.' },\n    { product: 'Sandbox Environment (Annual)', quantity: 2, unit_price: 7500, description: 'Two sandboxes for the marketing build-out.' },\n  ],\n  'Stark Expansion (Lost)': [\n    { product: 'ObjectStack Platform', quantity: 2, unit_price: 50000, description: 'Two additional clinical tenants.' },\n    { product: 'Field Service Mobile', quantity: 1, unit_price: 14000, description: 'Field service mobile for the device-servicing team.' },\n    { product: 'AI Agent Seat (Annual)', quantity: 6, unit_price: 1000, description: 'Agent seats for the service coordinators.' },\n  ],\n  'Globex Line Expansion (Lost)': [\n    { product: 'ObjectStack Platform', quantity: 2, unit_price: 50000, description: 'Two further production-line tenants.' },\n    { product: 'Integration Connector Pack', quantity: 1, unit_price: 16000, description: 'Connector pack for the line-control systems.' },\n    { product: 'AI Agent Seat (Annual)', quantity: 8, unit_price: 1000, description: 'Agent seats for the line supervisors.' },\n  ],\n  'Northwind Field Service Pilot (Lost)': [\n    { product: 'Field Service Mobile', quantity: 1, unit_price: 14000, description: 'Field-service mobile for the metering crews.' },\n    { product: 'Standard Support', quantity: 1, unit_price: 9000, description: 'Business-hours support during the pilot.' },\n    { product: 'AI Agent Seat (Annual)', quantity: 10, unit_price: 1000, description: 'Agent seats for the dispatch desk.' },\n  ],\n  'Apex Compliance Reporting (Lost)': [\n    { product: 'Analytics Add-on', quantity: 1, unit_price: 22000, description: 'Regulatory reporting pack for fleet compliance.' },\n    { product: 'Sandbox Environment (Annual)', quantity: 1, unit_price: 7500, description: 'Sandbox for the compliance rule build-out.' },\n    { product: 'AI Agent Seat (Annual)', quantity: 6, unit_price: 1000, description: 'Agent seats for the compliance analysts.' },\n  ],\n  'Northwind Grid Modernization': [\n    { product: 'ObjectStack Platform', quantity: 1, unit_price: 50000, description: 'Enterprise edition for grid, field and customer operations.' },\n    { product: 'Field Service Mobile', quantity: 1, unit_price: 14000, description: 'Field-service mobile for the grid maintenance crews.' },\n    { product: 'Sandbox Environment (Annual)', quantity: 1, unit_price: 7500, description: 'Sandbox for the operational-data assessment.' },\n    { product: 'AI Agent Seat (Annual)', quantity: 15, unit_price: 1000, description: 'Agent seats for the control-room pilot.' },\n  ],\n  'Lattice Student Success Platform': [\n    { product: 'ObjectStack Platform (SMB Edition)', quantity: 2, unit_price: 18000, description: 'Student-success tenants for the two pilot colleges.' },\n    { product: 'Admin Training Workshop', quantity: 2, unit_price: 6000, description: 'Two workshop days for the student-success advisers.' },\n    { product: 'AI Agent Seat (Annual)', quantity: 5, unit_price: 1000, description: 'Agent seats for the advising team.' },\n  ],\n  'Vertex Analytics Expansion': [\n    { product: 'Analytics Add-on', quantity: 2, unit_price: 22000, description: 'Analytics for the sales and marketing teams.' },\n    { product: 'Premium Support', quantity: 1, unit_price: 25000, description: 'Premium support for the expanded footprint.' },\n    { product: 'AI Agent Seat (Annual)', quantity: 10, unit_price: 1000, description: 'Agent seats for the revenue operations team.' },\n  ],\n  'Apex Logistics Data Hub': [\n    { product: 'ObjectStack Platform', quantity: 1, unit_price: 50000, description: 'Data-hub tenant shared by commercial, operations and finance.' },\n    { product: 'Data Migration Services', quantity: 1, unit_price: 35000, description: 'Consolidation of four fragmented commercial systems.' },\n    { product: 'AI Agent Seat (Annual)', quantity: 8, unit_price: 1000, description: 'Agent seats for the commercial operations team.' },\n  ],\n  'Lattice Education Renewal': [\n    { product: 'ObjectStack Platform', quantity: 1, unit_price: 50000, description: 'Renewal of the institution-wide tenant.' },\n    { product: 'Analytics Add-on', quantity: 1, unit_price: 22000, description: 'Expanded analytics package for the renewal term.' },\n    { product: 'AI Agent Seat (Annual)', quantity: 15, unit_price: 1000, description: 'Student-success automation seats.' },\n  ],\n  'Vertex Enterprise Rollout': [\n    { product: 'ObjectStack Platform', quantity: 1, unit_price: 50000, discount: 20, description: 'Phase-one tenant for the first region, with data-residency controls (multi-phase commitment discount).' },\n    { product: 'Data Migration Services', quantity: 1, unit_price: 35000, description: 'Phase-one migration of the regional revenue data.' },\n    { product: 'Standard Support', quantity: 1, unit_price: 9000, description: 'Business-hours support for phase one.' },\n    { product: 'AI Agent Seat (Annual)', quantity: 10, unit_price: 1000, description: 'Agent seats for the first rollout wave.' },\n  ],\n  // Campaign-attributed wins \u2014 see the campaign metrics note below.\n  'Lattice Analytics Expansion': [\n    { product: 'Analytics Add-on', quantity: 2, unit_price: 22000, description: 'Analytics for admissions and alumni engagement.' },\n    { product: 'Admin Training Workshop', quantity: 1, unit_price: 6000, description: 'Analytics enablement day for the institutional-research team.' },\n    { product: 'AI Agent Seat (Annual)', quantity: 20, unit_price: 1000, description: 'Agent seats for the admissions team.' },\n  ],\n  'Wayne Operations Module Rollout': [\n    { product: 'ObjectStack Platform', quantity: 2, unit_price: 50000, description: 'Operations tenants for two manufacturing divisions.' },\n    { product: 'Standard Support', quantity: 1, unit_price: 9000, description: 'Standard support for the operations rollout.' },\n    { product: 'AI Agent Seat (Annual)', quantity: 11, unit_price: 1000, description: 'Agent seats for the operations planners.' },\n  ],\n  'Vertex Developer Platform Adoption': [\n    { product: 'ObjectStack Platform', quantity: 3, unit_price: 50000, description: 'Developer platform tenants for three product teams.' },\n    { product: 'Integration Connector Pack', quantity: 1, unit_price: 16000, description: 'Connector pack for the internal data warehouse.' },\n    { product: 'Analytics Add-on', quantity: 1, unit_price: 22000, description: 'Product-usage analytics for the platform team.' },\n    { product: 'AI Agent Seat (Annual)', quantity: 12, unit_price: 1000, description: 'Agent seats for the developer-experience team.' },\n  ],\n};\n\n/**\n * `amount` + `expected_revenue` for a seeded deal, both derived from its line\n * items. `expected_revenue` uses opportunity.hook.ts's own expression\n * (`Math.round(amount * probability) / 100`) so the two agree to the cent.\n */\nconst dealValue = (opportunityName: string, probability: number) => {\n  const lines = OPPORTUNITY_LINES[opportunityName];\n  if (!lines) throw new Error(`Seed error: no line items authored for opportunity \"${opportunityName}\"`);\n  const amount = linesTotal(lines);\n  return { amount, expected_revenue: Math.round(amount * probability) / 100 };\n};\n\n// \u2500\u2500\u2500 Opportunities \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n// `probability`, `forecast_category` and `expected_revenue` are derived from\n// `stage` by opportunity.hook.ts (STAGE_PROBABILITY / STAGE_FORECAST). Hooks\n// don't run over seeds, so every row below carries the exact values the hook\n// would compute \u2014 anything else gets silently rewritten on the first user\n// edit (#490).\n//\n// `stage_entry_date` follows the same rule: the hook stamps it on every insert\n// and stage change, so a seeded deal without one is a shape real data never\n// has \u2014 and it is what the stagnation sweep filters on and what the\n// `days_in_stage` FORMULA counts from, so it replaces the old hardcoded\n// `days_in_stage` numbers (#489). Open deals carry an age that spans the\n// 14-day stale threshold in both directions; settled deals entered their\n// closed stage on their close date.\nexport const opportunities = defineSeed(Opportunity, {\n  mode: 'upsert',\n  externalId: 'name',\n  records: [\n    {\n      name: 'Acme Platform Upgrade',\n      crm_account: 'Acme Corporation',\n      ...dealValue('Acme Platform Upgrade', 60),\n      stage: 'proposal',\n      probability: 60,\n      close_date: cel`daysFromNow(30)`,\n      type: 'existing_upgrade',\n      forecast_category: 'commit',\n      lead_source: 'web',\n      stage_entry_date: celDaysAgo(12),\n      description: `Upgrade from Standard to Enterprise edition for the\nNA + EMEA teams. Drivers: (1) AI agent governance becomes a hard\nrequirement after their internal compliance review, (2) advanced\nanalytics seats for the Ops org, (3) priority support SLA.`,\n      // This sentence used to DATE the workshop itself (\"the week of\n      // close_date - 14d\" => daysFromNow(16)) while the seeded event had it at\n      // daysFromNow(6) and a seeded task chased it at daysFromNow(7) \u2014 three\n      // records, three answers (#1660). The date now lives in exactly ONE\n      // place, the `crm_event` row in service.seed.ts, and this prose states\n      // only what stays true however that event is scheduled: it is booked,\n      // and its invitation has gone out (the attendee builder clamps\n      // `invited_date` at daysAgo(0), so a planned event's invite is never in\n      // the future). Re-dating the event therefore cannot strand this line.\n      // Do not put a date back here, absolute OR relative: a second copy is\n      // a second thing to drift.\n      next_step: `Send the revised proposal (Enterprise edition, 18-month term, 12% multi-year discount) to Jordan Park by EOW. The AI governance workshop with their compliance team is already booked and the invitation is out.`,\n    },\n    {\n      name: 'Globex Manufacturing Suite',\n      crm_account: 'Globex Industries',\n      ...dealValue('Globex Manufacturing Suite', 25),\n      stage: 'qualification',\n      probability: 25,\n      close_date: cel`daysFromNow(60)`,\n      type: 'new_business',\n      forecast_category: 'pipeline',\n      lead_source: 'referral',\n      stage_entry_date: celDaysAgo(45),\n    },\n    {\n      name: 'Wayne Enterprise License',\n      crm_account: 'Wayne Enterprises',\n      ...dealValue('Wayne Enterprise License', 80),\n      stage: 'negotiation',\n      probability: 80,\n      close_date: cel`daysFromNow(14)`,\n      type: 'new_business',\n      forecast_category: 'commit',\n      lead_source: 'partner',\n      stage_entry_date: celDaysAgo(7),\n    },\n    {\n      name: 'Initech Cloud Migration',\n      crm_account: 'Initech Solutions',\n      ...dealValue('Initech Cloud Migration', 40),\n      stage: 'needs_analysis',\n      probability: 40,\n      close_date: cel`daysFromNow(45)`,\n      type: 'existing_upgrade',\n      forecast_category: 'best_case',\n      lead_source: 'event',\n      stage_entry_date: celDaysAgo(38),\n    },\n    // \u2500\u2500\u2500 Closed Won deals (powers KPIs & revenue trends) \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n    {\n      name: 'Acme Annual Renewal 2025',\n      crm_account: 'Acme Corporation',\n      ...dealValue('Acme Annual Renewal 2025', 100),\n      stage: 'closed_won',\n      probability: 100,\n      close_date: cel`daysAgo(15)`,\n      stage_entry_date: cel`daysAgo(15)`,\n      type: 'existing_renewal',\n      forecast_category: 'closed',\n      lead_source: 'partner',\n      win_reason: 'relationship',\n      description: `Annual renewal of the Acme Standard subscription, signed two weeks ahead of the renewal date. 22% YoY uplift driven by seat expansion in the new EMEA team. Multi-year option declined this round \u2014 they want to see how the platform upgrade lands first.`,\n    },\n    {\n      name: 'Stark Medical Pilot',\n      crm_account: 'Stark Medical',\n      ...dealValue('Stark Medical Pilot', 100),\n      stage: 'closed_won',\n      probability: 100,\n      close_date: cel`daysAgo(50)`,\n      stage_entry_date: cel`daysAgo(50)`,\n      type: 'new_business',\n      forecast_category: 'closed',\n      lead_source: 'event',\n      win_reason: 'best_fit',\n    },\n    {\n      name: 'Wayne Q1 Expansion',\n      crm_account: 'Wayne Enterprises',\n      ...dealValue('Wayne Q1 Expansion', 100),\n      stage: 'closed_won',\n      probability: 100,\n      close_date: cel`daysAgo(95)`,\n      stage_entry_date: cel`daysAgo(95)`,\n      type: 'existing_upgrade',\n      forecast_category: 'closed',\n      lead_source: 'web',\n      win_reason: 'better_product',\n    },\n    {\n      name: 'Globex Training Package',\n      crm_account: 'Globex Industries',\n      ...dealValue('Globex Training Package', 100),\n      stage: 'closed_won',\n      probability: 100,\n      close_date: cel`daysAgo(140)`,\n      stage_entry_date: cel`daysAgo(140)`,\n      type: 'new_business',\n      forecast_category: 'closed',\n      lead_source: 'referral',\n      win_reason: 'better_support',\n    },\n    {\n      name: 'Initech Phase 1',\n      crm_account: 'Initech Solutions',\n      ...dealValue('Initech Phase 1', 100),\n      stage: 'closed_won',\n      probability: 100,\n      close_date: cel`daysAgo(200)`,\n      stage_entry_date: cel`daysAgo(200)`,\n      type: 'new_business',\n      forecast_category: 'closed',\n      lead_source: 'web',\n      win_reason: 'better_price',\n    },\n    // \u2500\u2500\u2500 Campaign-attributed wins \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n    // `crm_campaign` is what `campaign_attribution_refresh` counts\n    // (`num_opportunities` / `num_won_opportunities` / the summed\n    // `actual_revenue`) \u2014 on every opportunity insert, update and delete, not\n    // once at completion. Before #591 not one opportunity carried it, so those\n    // three metrics were structurally zero and every campaign's seeded\n    // `actual_revenue` was a number the hook would have overwritten on the\n    // first attributed write.\n    // These three wins are what make the marketing ROI numbers below TRUE.\n    {\n      name: 'Lattice Analytics Expansion',\n      crm_account: 'Lattice Education',\n      primary_contact: 'priya.shah@lattice.example.com',\n      crm_campaign: 'Q3 Enterprise Email Nurture',\n      ...dealValue('Lattice Analytics Expansion', 100),\n      stage: 'closed_won',\n      probability: 100,\n      close_date: cel`daysAgo(6)`,\n      stage_entry_date: cel`daysAgo(6)`,\n      type: 'existing_expansion',\n      forecast_category: 'closed',\n      lead_source: 'email_campaign',\n      win_reason: 'best_fit',\n      description: 'Analytics package for admissions and alumni engagement, sourced from the enterprise nurture track.',\n    },\n    {\n      name: 'Wayne Operations Module Rollout',\n      crm_account: 'Wayne Enterprises',\n      primary_contact: 'rwilson@wayne.example.com',\n      crm_campaign: 'Operations Platform Launch',\n      ...dealValue('Wayne Operations Module Rollout', 100),\n      stage: 'closed_won',\n      probability: 100,\n      close_date: cel`daysAgo(4)`,\n      stage_entry_date: cel`daysAgo(4)`,\n      type: 'existing_upgrade',\n      forecast_category: 'closed',\n      lead_source: 'content',\n      description: 'Operations module for two manufacturing divisions, closed off the operations-platform launch program.',\n      win_reason: 'relationship',\n    },\n    {\n      name: 'Vertex Developer Platform Adoption',\n      crm_account: 'Vertex Analytics',\n      primary_contact: 'ethan.brooks@vertex.example.com',\n      crm_campaign: 'Developer Content Marketing Push',\n      ...dealValue('Vertex Developer Platform Adoption', 100),\n      stage: 'closed_won',\n      probability: 100,\n      close_date: cel`daysAgo(6)`,\n      stage_entry_date: cel`daysAgo(6)`,\n      type: 'existing_expansion',\n      forecast_category: 'closed',\n      lead_source: 'content',\n      description: 'Three product teams adopted the developer platform after the technical content series.',\n      win_reason: 'better_product',\n    },\n    // \u2500\u2500\u2500 Closed Lost deals (powers win-rate + loss-reason analytics) \u2500\u2500\u2500\u2500\n    //\n    // Five losses across five distinct `loss_reason` values, and every one of\n    // them is now MANDATORY rather than decorative: `loss_reason` is\n    // `requiredWhen` stage is `closed_lost` (#593), so a seeded lost deal\n    // without one is rejected by the engine at seed time \u2014 the demo database\n    // cannot boot with the empty column that made the loss-reason widget\n    // unbuildable in the first place.\n    //\n    // Their `lead_source` values are chosen so that the sources carrying a loss\n    // ALSO carry a win (`web`, `referral`, `content`), plus two sources that\n    // only ever lost (`cold_call`, `advertisement`). That is what makes\n    // `win_rate_by_lead_source` a real measurement instead of a column of\n    // 100%s: three rows where both halves of the ratio move, and two rows that\n    // show what an all-loss source looks like.\n    {\n      name: 'Acme Add-on (Lost)',\n      crm_account: 'Acme Corporation',\n      ...dealValue('Acme Add-on (Lost)', 0),\n      stage: 'closed_lost',\n      probability: 0,\n      close_date: cel`daysAgo(25)`,\n      stage_entry_date: cel`daysAgo(25)`,\n      type: 'existing_upgrade',\n      forecast_category: 'omitted',\n      lead_source: 'cold_call',\n      loss_reason: 'timing',\n      loss_details: 'Marketing is locked into a 2-year HubSpot contract; the buying window opens when that renews.',\n      // This line used to end \"Revisit in Q3\" \u2014 a hand-typed calendar quarter\n      // on a record whose `close_date` is `daysAgo(25)`, so the quarter it told\n      // a rep to wait for is the one the deal was already lost in, and it\n      // contradicted this record's own `loss_details`: a 2-year lock does not\n      // reopen inside the quarter the deal closed in (#1712). Same ruling as\n      // the `next_step` block above (#1660): no date goes back into this prose,\n      // absolute OR relative. The renewal is the anchor that stays true however\n      // this record is dated \u2014 which is how `loss_details` and the account\n      // description already state it.\n      description: `Tried to bolt on the Marketing Cloud module via cold outbound. Lost because Acme's marketing org is already on a 2-year HubSpot contract. Revisit when that contract comes up for renewal \u2014 that is when the buying window opens.`,\n    },\n    {\n      name: 'Stark Expansion (Lost)',\n      crm_account: 'Stark Medical',\n      ...dealValue('Stark Expansion (Lost)', 0),\n      stage: 'closed_lost',\n      probability: 0,\n      close_date: cel`daysAgo(60)`,\n      stage_entry_date: cel`daysAgo(60)`,\n      type: 'new_business',\n      forecast_category: 'omitted',\n      lead_source: 'advertisement',\n      loss_reason: 'no_budget',\n      loss_details: 'Capital freeze on non-clinical systems for the rest of the fiscal year.',\n    },\n    {\n      name: 'Globex Line Expansion (Lost)',\n      crm_account: 'Globex Industries',\n      ...dealValue('Globex Line Expansion (Lost)', 0),\n      stage: 'closed_lost',\n      probability: 0,\n      close_date: cel`daysAgo(35)`,\n      stage_entry_date: cel`daysAgo(35)`,\n      type: 'existing_expansion',\n      forecast_category: 'omitted',\n      lead_source: 'referral',\n      loss_reason: 'competitor',\n      loss_details: 'Incumbent MES vendor bundled the two additional lines into an existing master agreement.',\n      description: 'Expansion into two further production lines, lost to the incumbent MES vendor on bundling.',\n    },\n    {\n      name: 'Northwind Field Service Pilot (Lost)',\n      crm_account: 'Northwind Energy',\n      ...dealValue('Northwind Field Service Pilot (Lost)', 0),\n      stage: 'closed_lost',\n      probability: 0,\n      close_date: cel`daysAgo(80)`,\n      stage_entry_date: cel`daysAgo(80)`,\n      type: 'new_business',\n      forecast_category: 'omitted',\n      lead_source: 'web',\n      loss_reason: 'price',\n      loss_details: 'Per-technician pricing landed ~30% above the budget the operations director had approved.',\n      description: 'Field-service pilot for the metering crews, lost on price against a cheaper point solution.',\n    },\n    {\n      name: 'Apex Compliance Reporting (Lost)',\n      crm_account: 'Apex Logistics',\n      ...dealValue('Apex Compliance Reporting (Lost)', 0),\n      stage: 'closed_lost',\n      probability: 0,\n      close_date: cel`daysAgo(110)`,\n      stage_entry_date: cel`daysAgo(110)`,\n      type: 'new_business',\n      forecast_category: 'omitted',\n      lead_source: 'content',\n      loss_reason: 'features',\n      loss_details: 'No native hours-of-service audit trail; the compliance team could not sign off without it.',\n      description: 'Regulatory reporting pack for the fleet compliance team, lost on a missing audit-trail capability.',\n    },\n    // \u2500\u2500\u2500 Curated active pipeline \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n    // Two cards in each active stage make the kanban immediately legible in\n    // a customer demo. They also tell a coherent sales story instead of\n    // overwhelming the board with anonymous generated rows.\n    //\n    // PRICED TO STAY DRAGGABLE (#1902). A deal at or above\n    // `LARGE_DEAL_AMOUNT` is born into `opportunity_approval_on_create`, whose\n    // approval nodes hold the record with `lockRecord: true` \u2014 on the board\n    // that card refuses every drag with `RECORD_LOCKED`. When nine of the ten\n    // open deals sat over the line, the one board a demo opens first was\n    // frozen. So exactly TWO open deals exhibit the approval flow, one per\n    // tier, and both are in the block above: `Acme Platform Upgrade`\n    // (manager review only, $100K\u2013$500K) and `Wayne Enterprise License`\n    // (manager, then director sign-off, over `HIGH_VALUE_DEAL_AMOUNT`). Every\n    // deal in this block is priced under the line, so each active stage keeps\n    // at least one card that moves. `test/seed-consistency.test.ts` pins the\n    // two by name \u2014 re-pricing a deal here over $100K goes red there.\n    {\n      name: 'Northwind Grid Modernization',\n      crm_account: 'Northwind Energy',\n      primary_contact: 'olivia.chen@northwind.example.com',\n      ...dealValue('Northwind Grid Modernization', 10),\n      stage: 'prospecting',\n      probability: 10,\n      close_date: cel`daysFromNow(72)`,\n      type: 'new_business',\n      forecast_category: 'pipeline',\n      lead_source: 'webinar',\n      stage_entry_date: celDaysAgo(4),\n      description: 'Northwind is assessing a unified grid-modernization program after an executive webinar.',\n      next_step: 'Confirm discovery participants and agree the operational-data assessment scope.',\n    },\n    {\n      name: 'Lattice Student Success Platform',\n      crm_account: 'Lattice Education',\n      primary_contact: 'priya.shah@lattice.example.com',\n      crm_campaign: 'Developer Content Marketing Push',\n      ...dealValue('Lattice Student Success Platform', 10),\n      stage: 'prospecting',\n      probability: 10,\n      close_date: cel`daysFromNow(96)`,\n      type: 'new_business',\n      forecast_category: 'pipeline',\n      lead_source: 'content',\n      stage_entry_date: celDaysAgo(11),\n      description: 'A new student-success initiative sourced from the higher-education content series.',\n      next_step: 'Invite the operations sponsor to the discovery workshop.',\n    },\n    {\n      name: 'Vertex Analytics Expansion',\n      crm_account: 'Vertex Analytics',\n      primary_contact: 'ethan.brooks@vertex.example.com',\n      ...dealValue('Vertex Analytics Expansion', 25),\n      stage: 'qualification',\n      probability: 25,\n      close_date: cel`daysFromNow(52)`,\n      type: 'existing_expansion',\n      forecast_category: 'pipeline',\n      lead_source: 'partner',\n      stage_entry_date: celDaysAgo(8),\n      description: 'Vertex wants to extend the platform from its data team to the full revenue organization.',\n      next_step: 'Validate the buying committee, budget owner and expansion timeline.',\n    },\n    {\n      name: 'Apex Logistics Data Hub',\n      crm_account: 'Apex Logistics',\n      primary_contact: 'marcus.reed@apexlogistics.example.com',\n      ...dealValue('Apex Logistics Data Hub', 40),\n      stage: 'needs_analysis',\n      probability: 40,\n      close_date: cel`daysFromNow(38)`,\n      type: 'new_business',\n      forecast_category: 'best_case',\n      lead_source: 'partner',\n      stage_entry_date: celDaysAgo(18),\n      description: 'Apex is mapping its fragmented commercial systems before committing to a data-hub program.',\n      next_step: 'Complete the architecture workshop and quantify the integration backlog.',\n    },\n    {\n      name: 'Lattice Education Renewal',\n      crm_account: 'Lattice Education',\n      primary_contact: 'priya.shah@lattice.example.com',\n      crm_campaign: 'Q3 Enterprise Email Nurture',\n      ...dealValue('Lattice Education Renewal', 60),\n      stage: 'proposal',\n      probability: 60,\n      close_date: cel`daysFromNow(24)`,\n      type: 'existing_renewal',\n      forecast_category: 'commit',\n      lead_source: 'email_campaign',\n      stage_entry_date: celDaysAgo(6),\n      description: 'Renewal proposal adds student-success automation and an expanded analytics package.',\n      next_step: 'Review the two-year option with procurement before the executive sponsor meeting.',\n    },\n    {\n      name: 'Vertex Enterprise Rollout',\n      crm_account: 'Vertex Analytics',\n      primary_contact: 'ethan.brooks@vertex.example.com',\n      ...dealValue('Vertex Enterprise Rollout', 80),\n      stage: 'negotiation',\n      probability: 80,\n      close_date: cel`daysFromNow(11)`,\n      type: 'existing_expansion',\n      forecast_category: 'commit',\n      lead_source: 'referral',\n      stage_entry_date: celDaysAgo(3),\n      description: 'Phase one of an enterprise rollout, negotiated around phased deployment and data-residency requirements.',\n      next_step: 'Resolve the final security addendum and confirm the procurement signature date.',\n    },\n  ]\n});\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/sales/data/_shared.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/sales/data\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/sales/data/_shared.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\n/**\n * Seed helpers shared by every `*.seed.ts` family module.\n *\n * The seed data used to be one 100KB `src/data/index.ts`, which sat ~1.5KB\n * under the `pnpm hygiene` byte cap and turned the next demo record into a\n * build failure (#635). It is now split by object family \u2014 `catalog`, `sales`,\n * `service`, `marketing`, `revenue` \u2014 with `index.ts` reduced to the\n * aggregating `CrmSeedData` export. This module holds what more than one\n * family needs.\n */\nimport { cel } from '@objectstack/spec';\n\n/**\n * A note on system-computed fields in seeds (#490, #617).\n *\n * ### Hooks DO run over seed writes \u2014 automations do not\n *\n * The seed loader writes with `{ isSystem: true, skipTriggers: true,\n * seedReplay: true }`, and the premise this file used to state \u2014 \"hooks do NOT\n * run over seed rows\" \u2014 was wrong (#617). Measured against 17.0.0-rc.1, and\n * matching `SeedLoaderService.SEED_OPTIONS`' own contract:\n *\n *   - `isSystem`   bypasses RBAC and DISABLES the security plugin's injection\n *                  of `organization_id` / `owner_id` \u2014 which is why seeded rows\n *                  land ownerless until the platform's seed-ownership claim\n *                  hands them to the first administrator when the seed settles.\n *   - `skipTriggers` suppresses record-change AUTOMATION (autolaunched flows),\n *                  not lifecycle hooks. Seed data is pre-existing end state,\n *                  not a stream of user events.\n *   - `seedReplay` skips the `state_machine` entry/transition guards, so a\n *                  mid-lifecycle row (a `closed_won` deal) is accepted.\n *\n * Lifecycle HOOKS \u2014 derived fields, defaults, validation \u2014 still run. The boot\n * log shows them firing (`opportunity_amount_rollup`, `quote_total_rollup`),\n * and `crm_account.billing_country` / `crm_account.territory` are only ever\n * populated because `account_protection` derives them from `billing_address`\n * on the seed insert (#638, #639). `test/territory-seed-coverage.test.ts` pins that dependency.\n *\n * ### What that means for authoring\n *\n * The old conclusion survives the corrected premise, and is still the rule:\n *\n * 1. Seeding historical values into readonly fields (`stage_entry_date`,\n *    `last_contacted_date`, `actual_revenue`, and the platform's own\n *    `created_at` \u2014 which the case seeds author since #1992) is legitimate\n *    and load-bearing \u2014 it is the only way demo reports get history \u2014 and the\n *    platform explicitly preserves explicit seed values (`created_at` on the\n *    first insert since @objectstack/objectql 17.7.0, objectstack#21646).\n * 2. Every seeded value of a hook-owned field MUST equal what the hook would\n *    compute (`is_closed` \u21D4 status, `resolution_time_hours` \u21D4 closed\u2212created,\n *    opportunity `probability`/`forecast_category`/`expected_revenue` \u21D4 stage,\n *    forecast `period_label` \u21D4 period_start). Under the corrected premise a\n *    mismatch is rewritten immediately, at seed time, instead of on the first\n *    user edit \u2014 either way the demo does not show what was authored.\n * 3. A field the hook DERIVES and the schema marks `readonly` is not authored\n *    here at all (`crm_account.billing_country`, `crm_account.territory`):\n *    duplicating it would create a second source of truth for a value the hook\n *    already owns.\n *\n * Autonumber fields (`case_number`, `contract_number`, `quote_number`) are\n * NEVER seeded: the runtime owns those sequences (the SQL driver bootstraps\n * each counter past existing rows), so hand-numbering them only invites\n * drift. Upsert identity uses a natural key instead (subject / name /\n * description).\n */\n\n/**\n * Build a CEL `daysAgo(N)` expression from a runtime number. Mirrors the\n * existing tagged-template usage (`cel\\`daysAgo(N)\\``) so we can produce\n * timestamps inside `.map()` generators without manufacturing fake template\n * string arrays.\n */\nexport const celDaysAgo = (n: number) => cel`daysAgo(${n})`;\nexport const celDaysFromNow = (n: number) => cel`daysFromNow(${n})`;\n\n/**\n * A configured product line. `unit_price` is the NEGOTIATED price (what the\n * rep sold at); the catalog `list_price` is stamped separately from the\n * product record, exactly as the price-fill hook would.\n */\nexport type LineSpec = {\n  readonly product: string;\n  readonly quantity: number;\n  readonly unit_price: number;\n  /** Line-level discount %, defaults to 0. */\n  readonly discount?: number;\n  readonly description: string;\n};\n\n/** `quantity \u00D7 unit_price \u00D7 (1 \u2212 discount/100)`, rounded exactly as the rollup hooks round. */\nexport const lineTotal = (l: LineSpec): number =>\n  Math.round(l.quantity * l.unit_price * (1 - (l.discount ?? 0) / 100) * 100) / 100;\n\nexport const linesTotal = (lines: readonly LineSpec[]): number =>\n  Math.round(lines.reduce((sum, l) => sum + lineTotal(l), 0) * 100) / 100;\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/sales/data/activity.seed.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/sales/data\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/sales/data/activity.seed.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\n/**\n * Activity seeds \u2014 the task list and the interaction log.\n *\n * `crm_task`, `crm_event` and `crm_event_attendee` are the activity layer over\n * every object in the app (accounts, opportunities AND cases), which is why\n * plan item 4 folds them into the app package rather than giving activities a\n * module of their own: \"activities are a cross-cutting capability no customer\n * buys separately\". Their rows were authored in `src/data/service.seed.ts`,\n * beside the cases they most often hang off; those cases are now\n * `src/service/data/service.seed.ts` and are referenced from here by natural\n * key exactly as before. The cases are registered by the service package and\n * these rows by the app package; measured on a fresh boot of the two-package\n * artifact (#1907), every seeded event's `related_to_case` resolves to a real\n * case.\n *\n * Seed doctrine lives in `./_shared.ts`.\n */\nimport { defineSeed } from '@objectstack/spec/data';\nimport { cel } from '@objectstack/spec';\nimport { Task } from '../objects/task.object';\nimport { Event } from '../objects/event.object';\nimport { EventAttendee } from '../objects/event_attendee.object';\nimport { celDaysAgo } from './_shared';\n\n// \u2500\u2500\u2500 Tasks \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n// Polymorphic parents need BOTH halves: `related_to_type` names the parent\n// object and the matching `related_to_*` lookup carries the record. The\n// Related tab and task.hook's activity bubble key off `related_to_type`, so a\n// lookup without it is invisible to both (#490).\nexport const tasks = defineSeed(Task, {\n  mode: 'upsert',\n  externalId: 'subject',\n  records: [\n    {\n      subject: 'Follow up with Acme on proposal',\n      description: 'Send Jordan Park the revised Enterprise proposal and a 30-min calendar slot to walk through the AI governance section.',\n      status: 'not_started',\n      priority: 'high',\n      priority_rank: 3,\n      due_date: cel`daysFromNow(2)`,\n      related_to_type: 'crm_opportunity',\n      related_to_account: 'Acme Corporation',\n      related_to_opportunity: 'Acme Platform Upgrade',\n    },\n    {\n      // The workshop this task asks someone to book is ALREADY on the\n      // calendar: the `Acme \u2014 AI agent governance workshop` event lower in\n      // this file is `planned` at daysFromNow(6), and the attendee builder\n      // dates its invitation `daysAgo(max(-6 + invitedDaysBefore(9), 0))` =\n      // daysAgo(3) \u2014 already sent, and already answered `tentative`. So the\n      // booking task is DONE, and it was done the day the invitation went\n      // out. An open \"schedule it\" task beside a booked-and-invited meeting\n      // is the contradiction itself, not a due date to nudge (#1660).\n      //\n      // The EVENT owns the workshop's date. Nothing here restates it \u2014 both\n      // dates below derive from the invitation instant \u2014 so there is no\n      // second copy to drift out of step.\n      subject: 'Acme \u2014 schedule AI governance workshop',\n      description: 'Block a 90-min joint workshop with Acme\u2019s compliance team to walk through how HotCRM agents handle data scoping, RBAC, audit trails, and human-in-the-loop. Pre-read: ADR-0007 + the governance demo deck.',\n      status: 'completed',\n      priority: 'high',\n      priority_rank: 3,\n      due_date: cel`daysAgo(3)`,\n      completed_date: cel`daysAgo(3)`,\n      // Hooks don't run over seeds \u2014 mirror what task_completion would stamp.\n      is_completed: true,\n      progress_percent: 100,\n      related_to_type: 'crm_opportunity',\n      related_to_account: 'Acme Corporation',\n      related_to_opportunity: 'Acme Platform Upgrade',\n    },\n    {\n      subject: 'Acme \u2014 close out login-issues ticket before SLA',\n      description: 'Confirm engineering has the EMEA SSO clock-skew patch ready, deploy to Acme\u2019s tenant, and send Lisa Kim a customer-facing post-mortem.',\n      status: 'in_progress',\n      priority: 'urgent',\n      priority_rank: 4,\n      due_date: cel`daysFromNow(1)`,\n      related_to_type: 'crm_case',\n      related_to_account: 'Acme Corporation',\n      related_to_case: 'Login issues after platform upgrade',\n    },\n    {\n      subject: 'Schedule demo for Globex team',\n      status: 'in_progress',\n      priority: 'normal',\n      priority_rank: 2,\n      due_date: cel`daysFromNow(5)`,\n      related_to_type: 'crm_account',\n      related_to_account: 'Globex Industries',\n    },\n    {\n      subject: 'Prepare contract for Wayne Enterprises',\n      status: 'not_started',\n      priority: 'urgent',\n      priority_rank: 4,\n      due_date: cel`daysFromNow(1)`,\n      related_to_type: 'crm_account',\n      related_to_account: 'Wayne Enterprises',\n    },\n    {\n      subject: 'Send welcome package to Stark Medical',\n      status: 'completed',\n      priority: 'low',\n      priority_rank: 1,\n      completed_date: cel`daysAgo(2)`,\n      // Hooks don't run over seeds \u2014 mirror what task_completion would stamp.\n      is_completed: true,\n      progress_percent: 100,\n      related_to_type: 'crm_account',\n      related_to_account: 'Stark Medical',\n    },\n    {\n      // Internal housekeeping task \u2014 deliberately unparented (the\n      // related_to_required rule is a warning, not an error).\n      subject: 'Update CRM pipeline report',\n      status: 'not_started',\n      priority: 'normal',\n      priority_rank: 2,\n      due_date: cel`daysFromNow(7)`,\n    },\n  ]\n});\n\n// \u2500\u2500\u2500 Events & attendees: the interaction log \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n//\n// #592 shipped the activity model \u2014 `crm_event`, `crm_event_attendee`, the\n// per-object log/schedule actions, the `event_metrics` cube and the Sales\n// Activity dashboard \u2014 and deliberately left the demo rows to this issue\n// (#671). Until now the demo booted with the whole model installed and not one\n// row in it: every widget on that dashboard read 0, the calendar and\n// interaction-history views were empty, and the three churn tiles had nothing\n// to stratify.\n//\n// # Time is authored in CEL, never in TypeScript\n//\n// `start_datetime` / `end_datetime` are `cel` expressions\n// (`daysAgo(12) + duration(\"9h0m\")`), resolved by the seed loader at BOOT.\n// Plain-TS dates would freeze into `dist/objectstack.json` at BUILD time, and a\n// published artifact would ship a calendar that ages out \u2014 the same hazard\n// `test/analytics-integrity.test.ts` guards on report filters. `daysAgo()`\n// alone returns UTC midnight, which is why the duration term is there: a\n// calendar object whose every row starts at 00:00 is a calendar nobody would\n// demo.\n//\n// # A `held` event stamps TODAY on its account \u2014 that is the whole layout rule\n//\n// Lifecycle hooks run over seed writes (#617), so `event_activity_bubble` fires\n// on these inserts and stamps `crm_account.last_activity_date` /\n// `crm_contact.last_contacted_date` / `crm_lead.last_contacted_date` with the\n// SEED MOMENT \u2014 not with the event's own timestamp. Nothing here can make an\n// account look quiet AND give it a held interaction; the two are the same\n// column. So the quiet accounts of `sales.seed.ts` carry only `planned`,\n// `cancelled` and `no_show` rows, none of which bubble, and the accounts that\n// do carry held rows are authored at `today()` there. The long note beside the\n// account records states the boundary; `test/activity-seed-coverage.test.ts`\n// recomputes the bubble's own reachability over these rows and fails if a held\n// event ever reaches an account the churn tiles depend on.\n//\n// # Upsert identity is `subject`\n//\n// Same choice as `crm_task` and `crm_case` above, and it carries the same known\n// cost: a user who logs an interaction under a subject this file also uses\n// would have their row adopted (and overwritten) by the next re-seed. The\n// forecast seeds escape that with a dedicated `seed_key` column (#613), which\n// is an OBJECT change and out of this issue's scope; the subjects below are\n// long and account-specific so the collision needs deliberate effort, and the\n// two activity-shaped objects that came before already accept the same trade.\n// No collision exists with the runtime writer's own rows: `log_call` /\n// `log_meeting` / `schedule_meeting` insert with an explicit `owner_id`\n// (`src/sales/actions/activity-actions.ts`), so they are never ownerless and the\n// platform's seed-ownership claim never touches them \u2014 the \"one producer per\n// window\" question #702 raised, answered for this object.\n\n/** Which `related_to_*` lookup carries each `related_to_type`. */\nconst EVENT_RELATED_FIELD = {\n  crm_account: 'related_to_account',\n  crm_contact: 'related_to_contact',\n  crm_opportunity: 'related_to_opportunity',\n  crm_lead: 'related_to_lead',\n  crm_case: 'related_to_case',\n} as const;\n\ntype EventRelatedType = keyof typeof EVENT_RELATED_FIELD;\n\ntype AttendeeSpec = {\n  /** Contact email \u2014 the contact dataset's externalId. Exclusive with `lead`. */\n  readonly contact?: string;\n  /** Lead email \u2014 the lead dataset's externalId. */\n  readonly lead?: string;\n  readonly response: 'accepted' | 'declined' | 'tentative' | 'no_response';\n};\n\ntype EventSpec = {\n  readonly subject: string;\n  readonly type: 'meeting' | 'call' | 'demo' | 'webinar' | 'onsite_visit' | 'other';\n  readonly status: 'held' | 'planned' | 'cancelled' | 'no_show';\n  /** Days before boot. NEGATIVE means that many days AFTER boot. */\n  readonly daysAgo: number;\n  /** UTC wall clock the slot opens at: `[hour, minute]`. */\n  readonly at: readonly [number, number];\n  /** Slot length in minutes \u2014 the gap between start and end on the calendar. */\n  readonly minutes: number;\n  readonly relatedType: EventRelatedType;\n  /** Natural key of the related record (that dataset's externalId). */\n  readonly relatedKey: string;\n  /**\n   * Account natural key, when the related record hangs off one. Authored on the\n   * event as well as implied through the parent \u2014 same shape the task seeds\n   * use, and it is what puts the row in the ACCOUNT's activity related list.\n   */\n  readonly account?: string;\n  readonly location?: string;\n  readonly description?: string;\n  readonly outcome?: string;\n  readonly attendees: readonly AttendeeSpec[];\n  /** Days before the event the invitation went out. Defaults to 3. */\n  readonly invitedDaysBefore?: number;\n};\n\n/**\n * A wall-clock instant on a day relative to the boot date.\n *\n * `daysAgo(n)` / `daysFromNow(n)` both return UTC midnight of that calendar\n * day, and CEL timestamp + duration arithmetic is what puts a real time on it.\n */\nconst celClock = (daysAgo: number, hour: number, minute: number) => {\n  const clock = `${hour}h${minute}m`;\n  return daysAgo >= 0\n    ? cel`daysAgo(${daysAgo}) + duration(${clock})`\n    : cel`daysFromNow(${-daysAgo}) + duration(${clock})`;\n};\n\n/**\n * The interaction log.\n *\n * `held` rows span all five `related_to_type` values and five of the six\n * `type` values across roughly nine weeks, because that is what the Sales\n * Activity dashboard reads: the mix donut groups by `type`, the \"where the\n * activity lands\" bar groups by `related_to_type`, and the volume area chart\n * buckets `start_datetime` by week. A block of rows in one week on one parent\n * would light every widget up while proving none of them.\n */\nconst EVENT_SPECS: readonly EventSpec[] = [\n  // \u2500\u2500\u2500 Acme Corporation \u2014 the hero account, worked across every parent \u2500\u2500\u2500\u2500\n  {\n    subject: 'Acme \u2014 Enterprise edition walkthrough',\n    type: 'demo', status: 'held', daysAgo: 2, at: [10, 0], minutes: 60,\n    relatedType: 'crm_opportunity', relatedKey: 'Acme Platform Upgrade', account: 'Acme Corporation',\n    location: 'Zoom',\n    outcome: 'Walked the Ops team through agent governance and the analytics seats. Revised proposal to follow this week.',\n    attendees: [{ contact: 'john.smith@acme.example.com', response: 'accepted' }],\n  },\n  {\n    subject: 'Acme \u2014 proposal follow-up call',\n    type: 'call', status: 'held', daysAgo: 5, at: [15, 30], minutes: 25,\n    relatedType: 'crm_contact', relatedKey: 'john.smith@acme.example.com', account: 'Acme Corporation',\n    outcome: 'Procurement wants an 18-month term. Pricing to be re-cut before the governance workshop.',\n    attendees: [{ contact: 'john.smith@acme.example.com', response: 'accepted' }],\n  },\n  {\n    subject: 'Acme \u2014 AI governance scoping session',\n    type: 'meeting', status: 'held', daysAgo: 12, at: [9, 0], minutes: 90,\n    relatedType: 'crm_account', relatedKey: 'Acme Corporation',\n    location: 'Google Meet',\n    outcome: 'Agreed the workshop agenda: data scoping, RBAC, audit trails, human-in-the-loop.',\n    attendees: [{ contact: 'john.smith@acme.example.com', response: 'accepted' }],\n  },\n  {\n    subject: 'Acme \u2014 login incident status call',\n    type: 'call', status: 'held', daysAgo: 16, at: [8, 30], minutes: 20,\n    relatedType: 'crm_case', relatedKey: 'Login issues after platform upgrade', account: 'Acme Corporation',\n    outcome: 'Confirmed the EMEA SSO clock-skew hypothesis; engineering reproducing in staging.',\n    attendees: [{ contact: 'john.smith@acme.example.com', response: 'accepted' }],\n  },\n  {\n    subject: 'Acme \u2014 renewal signature review',\n    type: 'meeting', status: 'held', daysAgo: 20, at: [14, 0], minutes: 45,\n    relatedType: 'crm_opportunity', relatedKey: 'Acme Annual Renewal 2025', account: 'Acme Corporation',\n    outcome: 'Signed two weeks ahead of the renewal date. Multi-year deferred to the upgrade decision.',\n    attendees: [{ contact: 'john.smith@acme.example.com', response: 'accepted' }],\n  },\n  {\n    subject: 'Acme \u2014 San Francisco HQ business review',\n    type: 'onsite_visit', status: 'held', daysAgo: 33, at: [13, 0], minutes: 120,\n    relatedType: 'crm_account', relatedKey: 'Acme Corporation',\n    location: '500 Howard Street, Suite 400, San Francisco',\n    outcome: 'Quarterly review with the CTO org. Expansion into the EMEA team confirmed as the next motion.',\n    attendees: [{ contact: 'john.smith@acme.example.com', response: 'accepted' }],\n  },\n\n  // \u2500\u2500\u2500 Wayne Enterprises \u2014 a deal in negotiation \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n  {\n    subject: 'Wayne \u2014 enterprise license negotiation',\n    type: 'meeting', status: 'held', daysAgo: 3, at: [16, 0], minutes: 60,\n    relatedType: 'crm_opportunity', relatedKey: 'Wayne Enterprise License', account: 'Wayne Enterprises',\n    location: 'Zoom',\n    outcome: 'Volume tier agreed at 20 tenants. Security addendum is the last open item.',\n    attendees: [{ contact: 'rwilson@wayne.example.com', response: 'accepted' }],\n  },\n  {\n    subject: 'Wayne \u2014 security addendum walkthrough',\n    type: 'call', status: 'held', daysAgo: 8, at: [11, 0], minutes: 30,\n    relatedType: 'crm_contact', relatedKey: 'rwilson@wayne.example.com', account: 'Wayne Enterprises',\n    outcome: 'Legal to return redlines within the week.',\n    attendees: [{ contact: 'rwilson@wayne.example.com', response: 'accepted' }],\n  },\n  {\n    subject: 'Wayne \u2014 platform governance webinar',\n    type: 'webinar', status: 'held', daysAgo: 26, at: [15, 0], minutes: 60,\n    relatedType: 'crm_account', relatedKey: 'Wayne Enterprises',\n    location: 'https://acme.example.com/webinars/governance',\n    outcome: 'Four business units attended; two asked for their own rollout plan.',\n    attendees: [{ contact: 'rwilson@wayne.example.com', response: 'accepted' }],\n  },\n  {\n    subject: 'Wayne \u2014 bulk import rollout check-in',\n    type: 'call', status: 'held', daysAgo: 45, at: [10, 30], minutes: 25,\n    relatedType: 'crm_case', relatedKey: 'Request: bulk import via CSV', account: 'Wayne Enterprises',\n    outcome: 'CSV import shipped and documented; the customer closed the request out on the call.',\n    attendees: [{ contact: 'rwilson@wayne.example.com', response: 'accepted' }],\n  },\n\n  // \u2500\u2500\u2500 Vertex Analytics \u2014 expansion, then an enterprise rollout \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n  {\n    subject: 'Vertex \u2014 rollout phasing and data residency',\n    type: 'meeting', status: 'held', daysAgo: 1, at: [9, 30], minutes: 75,\n    relatedType: 'crm_opportunity', relatedKey: 'Vertex Enterprise Rollout', account: 'Vertex Analytics',\n    location: 'Zoom',\n    outcome: 'Phase 1 scoped to four regions. Residency controls to be confirmed with their security team.',\n    attendees: [{ contact: 'ethan.brooks@vertex.example.com', response: 'accepted' }],\n  },\n  {\n    subject: 'Vertex \u2014 revenue analytics demo',\n    type: 'demo', status: 'held', daysAgo: 10, at: [14, 30], minutes: 45,\n    relatedType: 'crm_opportunity', relatedKey: 'Vertex Analytics Expansion', account: 'Vertex Analytics',\n    location: 'Zoom',\n    outcome: 'Sales, marketing and service leads all asked for their own workspace \u2014 the expansion case makes itself.',\n    attendees: [{ contact: 'ethan.brooks@vertex.example.com', response: 'accepted' }],\n  },\n  {\n    subject: 'Vertex \u2014 expansion buying committee call',\n    type: 'call', status: 'held', daysAgo: 19, at: [16, 30], minutes: 30,\n    relatedType: 'crm_contact', relatedKey: 'ethan.brooks@vertex.example.com', account: 'Vertex Analytics',\n    outcome: 'CRO owns the budget; the data team stays the technical sponsor.',\n    attendees: [{ contact: 'ethan.brooks@vertex.example.com', response: 'accepted' }],\n  },\n  {\n    subject: 'Vertex \u2014 developer platform retrospective',\n    type: 'meeting', status: 'held', daysAgo: 38, at: [11, 0], minutes: 60,\n    relatedType: 'crm_account', relatedKey: 'Vertex Analytics',\n    outcome: 'Three product teams live on the developer platform; usage analytics is the next ask.',\n    attendees: [{ contact: 'ethan.brooks@vertex.example.com', response: 'accepted' }],\n  },\n\n  // \u2500\u2500\u2500 Stark Medical \u2014 the partner motion \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n  {\n    subject: 'Stark Medical \u2014 Toronto clinical operations visit',\n    type: 'onsite_visit', status: 'held', daysAgo: 52, at: [9, 0], minutes: 180,\n    relatedType: 'crm_account', relatedKey: 'Stark Medical',\n    location: '181 Bay Street, Suite 2200, Toronto',\n    outcome: 'Two clinical service lines live on the pilot. Device-servicing expansion parked on budget.',\n    attendees: [{ contact: 'emily.d@starkmed.example.com', response: 'accepted' }],\n  },\n\n  // \u2500\u2500\u2500 Leads: the only held rows that touch a prospect's own clock \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n  {\n    subject: 'CloudFirst \u2014 qualification call with Lisa Thompson',\n    type: 'call', status: 'held', daysAgo: 1, at: [11, 0], minutes: 30,\n    relatedType: 'crm_lead', relatedKey: 'lisa.t@cloudfirst.example.com',\n    outcome: 'Budget confirmed and a technical evaluation agreed \u2014 qualified.',\n    attendees: [{ lead: 'lisa.t@cloudfirst.example.com', response: 'accepted' }],\n  },\n  {\n    subject: 'EduTech Labs \u2014 discovery call with David Kim',\n    type: 'call', status: 'held', daysAgo: 4, at: [13, 0], minutes: 30,\n    relatedType: 'crm_lead', relatedKey: 'dkim@edutechlabs.example.com',\n    outcome: 'Replacing spreadsheets across admissions. Referral source confirmed.',\n    attendees: [{ lead: 'dkim@edutechlabs.example.com', response: 'accepted' }],\n  },\n  // The earlier touch on each of the two leads above, so each lead's Activity\n  // tab reads as a short history rather than a single row. Both leads already\n  // carry `last_contacted_date: today()` for their later call, so a second held\n  // row moves no recency clock (`event_activity_bubble` stamps the seed moment).\n  {\n    subject: 'CloudFirst \u2014 follow-up meeting after the Cloud Summit booth',\n    type: 'meeting', status: 'held', daysAgo: 8, at: [15, 0], minutes: 45,\n    relatedType: 'crm_lead', relatedKey: 'lisa.t@cloudfirst.example.com',\n    outcome: 'Walked through pipeline and forecasting. Asked for a qualification call with finance.',\n    attendees: [{ lead: 'lisa.t@cloudfirst.example.com', response: 'accepted' }],\n  },\n  {\n    subject: 'EduTech Labs \u2014 referral intro call with David Kim',\n    type: 'call', status: 'held', daysAgo: 9, at: [10, 0], minutes: 15,\n    relatedType: 'crm_lead', relatedKey: 'dkim@edutechlabs.example.com',\n    outcome: 'Warm intro from the referring partner. Booked a proper discovery call.',\n    attendees: [{ lead: 'dkim@edutechlabs.example.com', response: 'accepted' }],\n  },\n\n  // \u2500\u2500\u2500 Booked, not held: the calendar ahead \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n  // These are what `status` exists for. Not one of them moves a recency clock,\n  // and the three re-engagement rows below sit on the accounts the churn tiles\n  // count \u2014 which is the demonstration, not an oversight.\n  {\n    subject: 'Acme \u2014 AI agent governance workshop',\n    type: 'meeting', status: 'planned', daysAgo: -6, at: [9, 0], minutes: 90,\n    relatedType: 'crm_opportunity', relatedKey: 'Acme Platform Upgrade', account: 'Acme Corporation',\n    location: 'Google Meet',\n    description: 'Joint workshop with Acme compliance: data scoping, RBAC, audit trails, human-in-the-loop.',\n    attendees: [{ contact: 'john.smith@acme.example.com', response: 'tentative' }],\n    invitedDaysBefore: 9,\n  },\n  {\n    subject: 'Wayne \u2014 procurement signature call',\n    type: 'meeting', status: 'planned', daysAgo: -1, at: [11, 0], minutes: 30,\n    relatedType: 'crm_opportunity', relatedKey: 'Wayne Enterprise License', account: 'Wayne Enterprises',\n    description: 'Confirm the signature date once the security addendum is closed.',\n    attendees: [{ contact: 'rwilson@wayne.example.com', response: 'accepted' }],\n    invitedDaysBefore: 4,\n  },\n  {\n    subject: 'Globex \u2014 manufacturing suite demo',\n    type: 'demo', status: 'planned', daysAgo: -5, at: [15, 0], minutes: 60,\n    relatedType: 'crm_opportunity', relatedKey: 'Globex Manufacturing Suite', account: 'Globex Industries',\n    location: 'Zoom',\n    description: 'Plant-operations demo for the six-site rollout, ahead of the qualification review.',\n    attendees: [{ contact: 'sarah.j@globex.example.com', response: 'accepted' }],\n    invitedDaysBefore: 8,\n  },\n  {\n    subject: 'Lattice \u2014 renewal proposal review',\n    type: 'meeting', status: 'planned', daysAgo: -3, at: [10, 0], minutes: 45,\n    relatedType: 'crm_opportunity', relatedKey: 'Lattice Education Renewal', account: 'Lattice Education',\n    description: 'Walk procurement through the two-year option before the executive sponsor meeting.',\n    attendees: [{ contact: 'priya.shah@lattice.example.com', response: 'accepted' }],\n    invitedDaysBefore: 6,\n  },\n  {\n    subject: 'Initech \u2014 re-engagement call before renewal',\n    type: 'call', status: 'planned', daysAgo: -2, at: [14, 0], minutes: 30,\n    relatedType: 'crm_account', relatedKey: 'Initech Solutions',\n    description: 'Nobody has spoken to Initech in ten weeks and the renewal is 75 days out. Re-open the relationship.',\n    attendees: [{ contact: 'mchen@initech.example.com', response: 'no_response' }],\n    invitedDaysBefore: 5,\n  },\n  {\n    subject: 'Northwind \u2014 grid modernization discovery workshop',\n    type: 'meeting', status: 'planned', daysAgo: -7, at: [9, 30], minutes: 120,\n    relatedType: 'crm_opportunity', relatedKey: 'Northwind Grid Modernization', account: 'Northwind Energy',\n    location: 'Leopoldstrasse 21, Munich',\n    description: 'Confirm discovery participants and agree the operational-data assessment scope.',\n    attendees: [{ contact: 'olivia.chen@northwind.example.com', response: 'tentative' }],\n    invitedDaysBefore: 10,\n  },\n  {\n    subject: 'Apex Logistics \u2014 data hub re-engagement call',\n    type: 'call', status: 'planned', daysAgo: -4, at: [16, 0], minutes: 30,\n    relatedType: 'crm_account', relatedKey: 'Apex Logistics',\n    description: 'The data-hub evaluation has been silent for a quarter. Re-establish the commercial sponsor.',\n    attendees: [{ contact: 'marcus.reed@apexlogistics.example.com', response: 'no_response' }],\n    invitedDaysBefore: 6,\n  },\n  {\n    subject: 'NextGen Retail \u2014 first discovery call with Alice Martinez',\n    type: 'call', status: 'planned', daysAgo: -2, at: [15, 0], minutes: 30,\n    relatedType: 'crm_lead', relatedKey: 'alice@nextgenretail.example.com',\n    description: 'Inbound web lead, booked on her follow-up date.',\n    attendees: [{ lead: 'alice@nextgenretail.example.com', response: 'no_response' }],\n    invitedDaysBefore: 3,\n  },\n\n  // \u2500\u2500\u2500 Neither held nor booked \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n  // `duration_minutes` is 0 on both, exactly as `event_schedule_derive`\n  // recomputes it: a meeting nobody attended occupies nobody's time, while the\n  // calendar slot it was booked into stays on the record as evidence of the\n  // attempt.\n  {\n    subject: 'Globex \u2014 line expansion review',\n    type: 'meeting', status: 'cancelled', daysAgo: 30, at: [14, 0], minutes: 60,\n    relatedType: 'crm_opportunity', relatedKey: 'Globex Line Expansion (Lost)', account: 'Globex Industries',\n    description: 'Cancelled by the customer: the incumbent MES vendor had already bundled the two lines.',\n    attendees: [{ contact: 'sarah.j@globex.example.com', response: 'declined' }],\n    invitedDaysBefore: 7,\n  },\n  {\n    subject: 'Initech \u2014 SSO configuration check-in',\n    type: 'call', status: 'no_show', daysAgo: 55, at: [10, 0], minutes: 30,\n    relatedType: 'crm_account', relatedKey: 'Initech Solutions',\n    description: 'Customer did not join. The last attempt to reach Initech before the account went quiet.',\n    attendees: [{ contact: 'mchen@initech.example.com', response: 'no_response' }],\n    invitedDaysBefore: 4,\n  },\n];\n\n/** `[hour, minute]` plus `minutes`, as the end-of-slot wall clock. */\nconst endClock = (spec: EventSpec): readonly [number, number] => {\n  const total = spec.at[0] * 60 + spec.at[1] + spec.minutes;\n  return [Math.floor(total / 60), total % 60];\n};\n\nexport const events = defineSeed(Event, {\n  mode: 'upsert',\n  externalId: 'subject',\n  records: EVENT_SPECS.map((spec) => {\n    const [endHour, endMinute] = endClock(spec);\n    return {\n      subject: spec.subject,\n      type: spec.type,\n      status: spec.status,\n      start_datetime: celClock(spec.daysAgo, spec.at[0], spec.at[1]),\n      end_datetime: celClock(spec.daysAgo, endHour, endMinute),\n      // Authored rather than left to the hook, and authored to the value the\n      // hook computes: `event_schedule_derive` measures the gap between the two\n      // timestamps above, then zeroes it for a cancelled / no-show row. Both\n      // branches agree with this literal, so the figure is right whether or not\n      // hooks fire over the seed write (`./_shared.ts`, doctrine rule 2).\n      duration_minutes: spec.status === 'cancelled' || spec.status === 'no_show' ? 0 : spec.minutes,\n      all_day: false,\n      related_to_type: spec.relatedType,\n      [EVENT_RELATED_FIELD[spec.relatedType]]: spec.relatedKey,\n      // The account link is authored on every row that has one, including rows\n      // whose `related_to_type` is the contact / opportunity / case \u2014 the same\n      // shape the task seeds use, and what fills the ACCOUNT's activity list.\n      ...(spec.account && spec.relatedType !== 'crm_account'\n        ? { related_to_account: spec.account }\n        : {}),\n      ...(spec.location ? { location: spec.location } : {}),\n      ...(spec.description ? { description: spec.description } : {}),\n      ...(spec.outcome ? { outcome_notes: spec.outcome } : {}),\n      // No `owner_id`: a seed cannot name a user (see `objectstack.composition.ts`,\n      // \"A seed can't name a user\"), so these rows land ownerless and the\n      // platform's seed-ownership claim hands them to the first administrator\n      // when the seed settles (#671, #1892).\n    };\n  }),\n});\n\n/**\n * Attendees, seeded as TWO datasets over one object, split by which party\n * lookup is populated \u2014 the same construction, for the same reason, as\n * `campaignMembersFromLeads` / `campaignMembersFromContacts`: the loader's\n * composite key is EMPTY when any component is null, which silently disables\n * dedupe and re-inserts every row on each replay boot.\n *\n * There is no third dataset for `sys_user` attendees, and no `is_organizer:\n * true` row anywhere below. The organiser of every one of these meetings is the\n * rep \u2014 a `sys_user` \u2014 and a seed cannot name a user: lookup values resolve\n * against the target's externalId, which only works inside the app's own\n * object graph. `activity-actions.ts` adds the organiser row at runtime, where\n * the id exists. Nothing is invented here to stand in for it.\n *\n * # The external guest, revisited (#740)\n *\n * #671 seeded no external-only attendee for a reason that has now EXPIRED, and\n * the note is updated rather than deleted because the reason was a defect, not\n * a taste: `attendee_type` had no `external` value, so the only way to store a\n * guest who is in no CRM object was to file the row under `contact` and leave\n * `crm_contact` empty \u2014 a seed that lies about its own discriminator. #740 added\n * the fourth option and made `attendee_resolves` / `attendee_type_exclusive`\n * enforce the pairing, so `{ attendee_type: 'external', external_name: \"\u2026\" }` is\n * now an honest, accepted row and seeding one is legitimate.\n *\n * It is still not seeded, on the narrower ground that survives: every row below\n * is drawn from a seeded contact or lead so the demo's related lists and churn\n * tiles hang together, and an invented outside counsel would buy a third\n * dataset (its own `externalId: ['crm_event', 'external_name']`, since the\n * loader's composite key is empty when a component is null) for one decorative\n * row that no view, cube or dashboard reads. The capability is proven where the\n * question actually is \u2014 on the real engine, in\n * `test/attendee-type-resolution.test.ts` \u2014 not in the fixture book. Add one\n * here the day a demo scenario genuinely has a guest in the room; nothing in\n * the metadata stands in the way any more.\n */\nconst attendeeRecords = (kind: 'contact' | 'lead') =>\n  EVENT_SPECS.flatMap((spec) =>\n    spec.attendees\n      .filter((a) => (kind === 'lead' ? a.lead : a.contact))\n      .map((a) => ({\n        crm_event: spec.subject,\n        attendee_type: kind,\n        ...(kind === 'lead' ? { crm_lead: a.lead } : { crm_contact: a.contact }),\n        response: a.response,\n        is_organizer: false,\n        // The invitation predates the slot. Clamped at 0 so a meeting booked\n        // for the day after tomorrow was invited today, never tomorrow.\n        invited_date: celDaysAgo(Math.max(spec.daysAgo + (spec.invitedDaysBefore ?? 3), 0)),\n      })),\n  );\n\nexport const eventAttendeesFromContacts = defineSeed(EventAttendee, {\n  mode: 'upsert',\n  externalId: ['crm_event', 'crm_contact'],\n  records: attendeeRecords('contact'),\n});\n\nexport const eventAttendeesFromLeads = defineSeed(EventAttendee, {\n  mode: 'upsert',\n  externalId: ['crm_event', 'crm_lead'],\n  records: attendeeRecords('lead'),\n});\n\n/**\n * The lead timeline pointers \u2014 what `log_call` would have written (#1258).\n *\n * A held interaction logged through `log_call` / `log_meeting`\n * (`src/sales/actions/activity-actions.ts`) writes three things: the\n * `crm_event`, its attendees, and one `sys_activity` row \u2014 the ADR-0052\n * ActivityPointer the lead's **Activity** tab reads\n * (`record:activity` \u2192 `sys_activity` by `{ object_name, record_id }`, filtered\n * to the `task` kind, which is `type: 'completed'`). The seeds above author the\n * first two for every held lead interaction; this dataset authors the third,\n * derived from the SAME specs so the two cannot drift apart.\n *\n * `record_id` and `source_id` carry NATURAL KEYS \u2014 the lead's email and the\n * event's subject. Both are `referenceVia` pointer pairs on the platform object\n * (`record_id` \u2194 `object_name`, `source_id` \u2194 `source_object`), so the seed\n * loader resolves each against the object its sibling column names and\n * refuses an unresolvable one loudly rather than storing the literal.\n *\n * Two platform facts bound what is authored here:\n *\n *   - `sys_activity` is `lifecycle.class: 'telemetry'` with\n *     `retention: { maxAge: '14d' }`, so only interactions younger than a\n *     fortnight are seeded \u2014 an older row would be reaped before anyone demos\n *     it. The filter below enforces that rather than trusting the spec list.\n *   - A seed cannot name a user, so `actor_id` / `actor_name` are not authored\n *     (see `objectstack.composition.ts`, \"A seed can't name a user\"). The\n *     action stamps the rep at runtime, where the id exists.\n */\nconst SYS_ACTIVITY_RETENTION_DAYS = 14;\n\n/**\n * The summary prefix of the action that logs each held event type \u2014 the two\n * writers that exist (`LOG_CALL_SPEC` / `LOG_MEETING_SPEC`). A held event of\n * any other type has no action that would have written a pointer for it, so it\n * gets none here either: this dataset mirrors a writer, it is not a fourth one.\n */\nconst LOGGED_SUMMARY_PREFIX: Partial<Record<EventSpec['type'], string>> = {\n  call: '',\n  meeting: 'Meeting: ',\n};\n\nexport const leadInteractionPointers = {\n  object: 'sys_activity',\n  mode: 'upsert' as const,\n  // One timeline pointer per rich source record, exactly as the action writes\n  // it. Matched on the RESOLVED ids, so replay boots dedupe.\n  externalId: ['source_object', 'source_id'],\n  records: EVENT_SPECS.filter(\n    (spec) =>\n      spec.relatedType === 'crm_lead' &&\n      spec.status === 'held' &&\n      LOGGED_SUMMARY_PREFIX[spec.type] !== undefined &&\n      spec.daysAgo >= 0 &&\n      spec.daysAgo < SYS_ACTIVITY_RETENTION_DAYS,\n  ).map((spec) => {\n    const [endHour, endMinute] = endClock(spec);\n    return {\n      // `held` is what both actions write as `completed` \u2014 the `task` feed\n      // kind, the one the lead Activity tab renders.\n      type: 'completed',\n      // The action's own summary: prefix, subject, duration in brackets.\n      summary: `${LOGGED_SUMMARY_PREFIX[spec.type]}${spec.subject} (${spec.minutes} min)`,\n      // Logged when the slot ended.\n      timestamp: celClock(spec.daysAgo, endHour, endMinute),\n      object_name: 'crm_lead',\n      record_id: spec.relatedKey,\n      source_object: 'crm_event',\n      source_id: spec.subject,\n      metadata: JSON.stringify({\n        kind: spec.type,\n        duration_minutes: spec.minutes,\n        notes: spec.outcome ?? '',\n        attendee_count: spec.attendees.length,\n      }),\n    };\n  }),\n};\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/sales/data/forecast.seed.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/sales/data\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/sales/data/forecast.seed.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\n/**\n * Forecast seeds \u2014 the quarterly and monthly snapshot rows.\n *\n * `crm_forecast` is a sales object (plan item 4: the customer core and the\n * activity objects fold into the app package), so its seed rows are sales' \u2014\n * they were authored in `src/data/revenue.seed.ts` because a forecast is a\n * revenue NUMBER, but the assignment rule follows the object, not the subject.\n * Seed doctrine lives in `./_shared.ts`.\n */\nimport { defineSeed } from '@objectstack/spec/data';\nimport { cel } from '@objectstack/spec';\nimport { Forecast } from '../objects/forecast.object';\n\n// \u2500\u2500\u2500 Forecasts \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n// `owner_id` is left unset: a seed cannot name a user and seed writes run\n// `isSystem`, so nothing stamps it \u2014 ownership is backfilled by the platform's\n// seed-ownership claim when the seed settles, which covers `crm_forecast`\n// alongside every other owner-scoped object (#702, #1892). See the note on\n// ownership in `objectstack.composition.ts`.\n//\n// \u2500\u2500\u2500 ONE PRODUCER PER WINDOW (#702) \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n//\n// `forecast_snapshot` (#590) upserts the row whose window contains today, and\n// its lookup is OWNER-SCOPED:\n//\n//     { owner_id: '{currentOwner.id}', period: 'quarter',\n//       period_start: { $lte: '{TODAY()}' }, period_end: { $gte: '{TODAY()}' } }\n//\n// A seeded row in that same window can never satisfy that filter at the moment\n// the sweep reads it \u2014 the seed writes no owner, and the claim is a separate,\n// later sweep \u2014 so the flow concludes the period is missing and opens a SECOND\n// row beside it. Both span the same quarter; one has an owner and one does not.\n// Every owner-grouped consumer then renders a phantom, ownerless duplicate for\n// the current quarter, on every re-seeded dev boot (`quota_attainment_by_rep`\n// most visibly, since it pins exactly that window).\n//\n// Claiming the row does not fix that, it only re-labels the phantom: whichever\n// of the two scheduled sweeps reaches the window first decides whether the\n// second one adopts the row or duplicates it, and a duplicate never heals.\n//\n// So the seeds stop at the window's edge. They ship SETTLED quarters only, plus\n// the current MONTH \u2014 a window no runtime writer touches, since the sweep's\n// period is fixed to `quarter`. The current quarter belongs to\n// `forecast_snapshot` alone. `test/forecast-seeds.test.ts` derives the\n// forbidden window from the flow's own lookup filter and fails on any seeded\n// row that lands inside it.\n//\n// The cost, stated rather than hidden: on a freshly seeded org the Sales\n// dashboard's *Quota Attainment by Rep* table is empty until the 03:00 sweep\n// opens the quarter's rows, and their `quota` stays blank until someone sets\n// one by hand (`quota` has no automated writer \u2014 see `forecast.object.ts`).\n// That is the same honest-empty state the widget already chooses at a quarter\n// boundary; the alternative was a row attributed to nobody, carrying a quota no\n// rep is on the hook for.\n//\n// Periods are REAL calendar periods, labelled exactly the way\n// forecast.hook.ts derives them ('Q3 2026' / 'Aug 2026') \u2014 hooks don't run\n// over seeds, and the hook only fills a BLANK period_label, so seeded rows\n// must speak the same dialect as runtime snapshots or list views end up\n// mixing 'This Quarter' with 'Q3 2026' (#490). Calendar-true `period_start`\n// values carry the same obligation on the QUERY side: `period_start` is one\n// half of the (owner, period, period_start) key the snapshot sweep upserts on,\n// the object indexes, and every period-scoped surface pins by equality \u2014 a\n// value that is not the period's real first day names a row no such filter can\n// ever select, and no rollup can line up against its neighbours.\n//\n// What these rows must NOT do is answer a CURRENT-quarter filter: per #702 that\n// window belongs to `forecast_snapshot` alone, so the seeds below ship settled\n// quarters plus the current month, and `this_quarter_forecasts` /\n// `quota_attainment_by_rep` correctly return none of them.\n//\n// (The sentence that stood here said the opposite \u2014 that these values make the\n// `this_quarter_forecasts` view's `{this_quarter_start}` filter \"match the\n// seeded row\". Corrected in #744, and it was wrong three ways:\n// `{this_quarter_start}` is not in the token vocabulary \u2014 the spelling is\n// `{current_quarter_start}`, and since 17.0.0-rc.0 the misspelling throws\n// `Unresolvable filter placeholder` instead of silently matching nothing; the\n// filter itself was removed from the view in #515 and only came back in #730;\n// and matching is the outcome #702 rules out.)\n//\n// Computed in plain TS (UTC, mirroring the hook's helpers): this module is\n// evaluated when the app bundle loads, the same moment the cel`...` seeds\n// are resolved.\nconst FORECAST_MONTHS = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'];\nconst forecastIsoDate = (d: Date) =>\n  `${d.getUTCFullYear()}-${String(d.getUTCMonth() + 1).padStart(2, '0')}-${String(d.getUTCDate()).padStart(2, '0')}`;\nconst forecastQuarterLabel = (d: Date) => `Q${Math.floor(d.getUTCMonth() / 3) + 1} ${d.getUTCFullYear()}`;\nconst forecastMonthLabel = (d: Date) => `${FORECAST_MONTHS[d.getUTCMonth()]} ${d.getUTCFullYear()}`;\nconst forecastNow = new Date();\nconst forecastYear = forecastNow.getUTCFullYear();\nconst forecastMonth = forecastNow.getUTCMonth();\nconst forecastQuarterMonth = Math.floor(forecastMonth / 3) * 3;\n// No `thisQuarterStart` / `thisQuarterEnd`: that window is `forecast_snapshot`'s\n// and nothing here may open a row in it (#702, note above).\nconst thisMonthStart = new Date(Date.UTC(forecastYear, forecastMonth, 1));\nconst thisMonthEnd = new Date(Date.UTC(forecastYear, forecastMonth + 1, 0));\nconst lastQuarterStart = new Date(Date.UTC(forecastYear, forecastQuarterMonth - 3, 1));\nconst lastQuarterEnd = new Date(Date.UTC(forecastYear, forecastQuarterMonth, 0));\n// Deeper history: quota-attainment and coverage trends need more than a single\n// prior period to plot (#591). These are all SETTLED periods \u2014 deliberately so:\n// the forecast snapshot sweep upserts the CURRENT quarter, so historical rows\n// can never collide with what it writes. That rule is now the whole rule for\n// quarters (#702): every quarterly seed below is settled.\nconst quarterStartAgo = (n: number) => new Date(Date.UTC(forecastYear, forecastQuarterMonth - 3 * n, 1));\nconst quarterEndAgo = (n: number) => new Date(Date.UTC(forecastYear, forecastQuarterMonth - 3 * (n - 1), 0));\nconst monthStartAgo = (n: number) => new Date(Date.UTC(forecastYear, forecastMonth - n, 1));\nconst monthEndAgo = (n: number) => new Date(Date.UTC(forecastYear, forecastMonth - n + 1, 0));\n\n/**\n * The three open-pipeline buckets of a settled snapshot, in the shape the\n * forecast object defines them (`src/sales/objects/forecast.object.ts`).\n *\n * The buckets are CUMULATIVE subsets of one another, so every row satisfies\n * `pipeline >= bestCase >= commit`. Named rather than positional: three bare\n * numbers in a row of eight arguments is the shape a later edit transposes\n * without anything noticing.\n */\ntype OpenBuckets = { pipeline: number; bestCase: number; commit: number };\n\n/**\n * A settled (past) period snapshot, captured on the day the period closed.\n *\n * `open` is what was still OPEN in the period at that moment \u2014 the deals that\n * had not resolved by the last day and went on to slip into the next period.\n *\n * These rows carried `0` for all three buckets until #1244. The theory was\n * \"a closed period has no pipeline left\", and it is the one reading a\n * period-END snapshot cannot have: a period ends with deals still open, which\n * is exactly what the \"slipped into the next quarter\" note below describes.\n * The cost was not cosmetic \u2014 `pipeline_amount`, `best_case_amount`,\n * `commit_amount` and the `coverage_ratio` formula that divides by the first\n * of them are four of the thirteen columns the forecast list renders, so the\n * module opened on six rows of zeros and could not answer the question the\n * object exists for.\n *\n * NOT a licence to seed the CURRENT quarter: that window has exactly one\n * producer, `forecast_snapshot` (#702), and the note above is the whole rule.\n * Pinned by `test/forecast-seeds.test.ts`.\n */\nconst closedPeriod = (\n  seed_key: string,\n  period: 'month' | 'quarter',\n  start: Date,\n  end: Date,\n  quota: number,\n  closed: number,\n  open: OpenBuckets,\n  notes: string,\n) => ({\n  seed_key,\n  period,\n  period_label: period === 'quarter' ? forecastQuarterLabel(start) : forecastMonthLabel(start),\n  period_start: forecastIsoDate(start),\n  period_end: forecastIsoDate(end),\n  snapshot_date: forecastIsoDate(end),\n  quota,\n  pipeline_amount: open.pipeline,\n  best_case_amount: open.bestCase,\n  commit_amount: open.commit,\n  closed_amount: closed,\n  source: 'scheduled' as const,\n  notes,\n});\n\n// Upsert identity is the synthetic `seed_key`, NOT `period_label` (#613).\n// `period_label` names a SET of rows once the forecast_snapshot sweep (#590)\n// writes one per active owner per quarter \u2014 all reading 'Q3 2026' \u2014 and the\n// loader matches against the whole table, so a re-seed could overwrite a real\n// rep's snapshot with the demo numbers. Why a synthetic key and not the true\n// (owner, period, period_start) identity or an insert-once mode: see the\n// `seed_key` declaration in `src/sales/objects/forecast.object.ts`.\n//\n// The keys are POSITIONAL ('current month', 'two quarters back'), not calendar\n// values, because the records are positional \u2014 recomputed against `new Date()`\n// on every import. A positional key keeps the demo at exactly these seven rows\n// as the calendar rolls forward, re-pointing each at its new period; a\n// calendar-derived key would strand last quarter's demo row and add one row per\n// re-seed.\n//\n// There is no `demo_quarter_current`: the current quarter is the one window\n// `forecast_snapshot` writes, and two producers in one window is what #702 was.\n// The current MONTH stays \u2014 the sweep's period is `quarter`, so no runtime\n// writer opens a monthly row.\nexport const forecasts = defineSeed(Forecast, {\n  mode: 'upsert',\n  externalId: 'seed_key',\n  records: [\n    {\n      seed_key: 'demo_month_current',\n      period: 'month',\n      period_label: forecastMonthLabel(thisMonthStart),\n      period_start: forecastIsoDate(thisMonthStart),\n      period_end: forecastIsoDate(thisMonthEnd),\n      snapshot_date: cel`today()`,\n      quota: 500000,\n      pipeline_amount: 760000,\n      best_case_amount: 540000,\n      commit_amount: 360000,\n      closed_amount: 295000,\n      source: 'scheduled',\n      notes: 'Healthy coverage; two commit deals expected to close this week.',\n    },\n    {\n      seed_key: 'demo_quarter_minus_1',\n      period: 'quarter',\n      period_label: forecastQuarterLabel(lastQuarterStart),\n      period_start: forecastIsoDate(lastQuarterStart),\n      period_end: forecastIsoDate(lastQuarterEnd),\n      snapshot_date: forecastIsoDate(lastQuarterEnd),\n      quota: 1400000,\n      pipeline_amount: 240000,\n      best_case_amount: 150000,\n      commit_amount: 95000,\n      closed_amount: 1485000,\n      source: 'scheduled',\n      notes: 'Closed at 106% of quota.',\n    },\n    closedPeriod('demo_quarter_minus_2', 'quarter', quarterStartAgo(2), quarterEndAgo(2), 1300000, 1196000,\n      { pipeline: 285000, bestCase: 190000, commit: 120000 },\n      'Closed at 92% of quota \u2014 two enterprise deals slipped into the next quarter.'),\n    closedPeriod('demo_quarter_minus_3', 'quarter', quarterStartAgo(3), quarterEndAgo(3), 1200000, 1308000,\n      { pipeline: 195000, bestCase: 130000, commit: 85000 },\n      'Closed at 109% of quota, carried by the enterprise renewal cohort.'),\n    closedPeriod('demo_quarter_minus_4', 'quarter', quarterStartAgo(4), quarterEndAgo(4), 1100000, 1045000,\n      { pipeline: 165000, bestCase: 110000, commit: 70000 },\n      'Closed at 95% of quota in the first quarter on the new territory model.'),\n    closedPeriod('demo_month_minus_1', 'month', monthStartAgo(1), monthEndAgo(1), 480000, 505000,\n      { pipeline: 96000, bestCase: 62000, commit: 40000 },\n      'Closed at 105% of quota; the expansion motion covered a soft new-business month.'),\n    closedPeriod('demo_month_minus_2', 'month', monthStartAgo(2), monthEndAgo(2), 460000, 414000,\n      { pipeline: 92000, bestCase: 58000, commit: 35000 },\n      'Closed at 90% of quota \u2014 summer slowdown across the mid-market segment.'),\n  ]\n});\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/sales/data/index.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/sales/data\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/sales/data/index.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\n/**\n * Sales seed data, and the composition knob every package's rows are selected\n * by.\n *\n * The rows themselves are authored per object family in the `*.seed.ts`\n * modules beside this file; `objectstack.composition.ts` collects all four\n * directories' families into the single ordered `CrmSeedData` union and cuts it\n * by owning package \u2014 each package stack registers the families whose object\n * it owns.\n * That assembly is NOT here, and cannot be: it names `crm_product`,\n * `crm_case`, `crm_campaign` and the rest, which are other packages' objects,\n * and a sales file may import from its own directory or from `src/sales/` only\n * (plan item 7). The ORDER it assembles in is load-bearing \u2014 rows reference\n * rows seeded earlier \u2014 so it lives in the one file that can see all four.\n *\n * Where to add a row follows from the object:\n *\n *   - `_shared.ts`        seed doctrine + helpers every package's rows use\n *   - `sales.seed.ts`     accounts, contacts, leads, opportunities\n *   - `activity.seed.ts`  tasks, events, event attendees\n *   - `forecast.seed.ts`  forecast snapshots\n *   - `src/revenue/data/` products, opportunity lines, contracts, quotes, quote lines\n *   - `src/service/data/` cases, knowledge articles\n *   - `src/marketing/data/` campaigns, campaign members\n */\nexport { accounts, contacts, leads, opportunities, OPPORTUNITY_LINES } from './sales.seed';\nexport { tasks, events, eventAttendeesFromContacts, eventAttendeesFromLeads, leadInteractionPointers } from './activity.seed';\nexport { forecasts } from './forecast.seed';\nexport { celDaysAgo, celDaysFromNow, lineTotal, linesTotal, type LineSpec } from './_shared';\n\n// \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500 the SaaS / multi-org composition \u2500\u2500\n\n/**\n * Which SHAPE of this app a build assembles (#1361).\n *\n * `default` is the community/single-org app and is what every build produces\n * unless something asks otherwise \u2014 the demo org and its storytelling data,\n * which the platform's seed-settle ownership claim binds to the first platform\n * administrator.\n *\n * `saas` is the shape a multi-org operator deploys on the enterprise runtime\n * under a walled tenancy posture (`OS_TENANCY_POSTURE=isolated`). The two\n * differ ONLY by what the composition registers; no code branches at runtime,\n * nothing is decided per tenant, and no enterprise package is imported. See\n * {@link SaasTenantSeedData} for why the seed set shrinks and\n * `objectstack.composition.ts` for the permission half.\n */\nexport type HotCrmComposition = 'default' | 'saas';\n\n/** The environment variable {@link resolveComposition} reads. */\nexport const COMPOSITION_ENV_VAR = 'HOTCRM_COMPOSITION';\n\n/** Every value {@link resolveComposition} accepts, for diagnostics and tests. */\nexport const HOTCRM_COMPOSITIONS: readonly HotCrmComposition[] = ['default', 'saas'];\n\n/**\n * Resolve the composition from the environment \u2014 and REFUSE anything else.\n *\n * The refusal is the point, and it is why this is a function rather than a\n * `=== 'saas'` comparison at the one call site. The failure mode a silent\n * default produces is not \"the build is a bit wrong\": `HOTCRM_COMPOSITION=sass`\n * would assemble the FULL demo union, and the operator would only find out when\n * every tenant they onboard receives nine accounts named after other people's\n * companies \u2014 a data-shape mistake that is expensive to unwind once tenants\n * have edited those rows. An unrecognised value therefore throws at\n * config-load time, where a build fails loudly and nothing has shipped.\n *\n * Unset and empty both mean `default`, deliberately: \"no opinion\" is the\n * community app, so no existing build, script or CI job changes behaviour by\n * saying nothing (`pnpm build`, `objectstack validate`, the cloud EE rigs'\n * `scripts/build-hotcrm-artifact.sh`).\n */\nexport function resolveComposition(\n  raw: string | undefined = process.env[COMPOSITION_ENV_VAR],\n): HotCrmComposition {\n  const value = (raw ?? '').trim();\n  if (value === '') return 'default';\n  if ((HOTCRM_COMPOSITIONS as readonly string[]).includes(value)) {\n    return value as HotCrmComposition;\n  }\n  throw new Error(\n    `${COMPOSITION_ENV_VAR}=\"${value}\" is not a HotCRM composition. ` +\n      `Expected one of: ${HOTCRM_COMPOSITIONS.join(', ')} (or leave it unset for 'default').`,\n  );\n}\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/revenue/data/catalog.seed.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/revenue/data\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/revenue/data/catalog.seed.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\n/**\n * Product catalogue seeds \u2014 and the two helpers that read prices back out of\n * it, so a line item's `list_price` can never disagree with the catalogue.\n *\n * Split out of the former monolithic `src/data/index.ts` (#635). Seed doctrine\n * lives in `src/sales/data/_shared.ts`.\n */\nimport { defineSeed } from '@objectstack/spec/data';\nimport { Product } from '../objects/product.object';\nimport type { LineSpec } from '../../sales/data/_shared';\n\n// \u2500\u2500\u2500 Products \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n// The catalog is what every line item below prices against, so it has to be\n// wide enough to configure a realistic deal: an edition, an add-on, a\n// per-seat subscription, support tiers and professional services. Four\n// products could not (#591).\n//\n// `cost` is populated on every product: `cost_less_than_price` is a real\n// validation rule that \"has never once evaluated\" while the field was blank\n// everywhere, and margin is what the product-mix analytics are for. Every row\n// keeps cost strictly below list price.\nexport const products = defineSeed(Product, {\n  mode: 'upsert',\n  externalId: 'name',\n  records: [\n    {\n      name: 'ObjectStack Platform',\n      description: 'The enterprise edition: unlimited objects, AI agents, governance and audit.',\n      category: 'software',\n      family: 'enterprise',\n      sku: 'OS-PLAT-ENT',\n      list_price: 50000,\n      cost: 12000,\n      is_active: true,\n    },\n    {\n      name: 'ObjectStack Platform (SMB Edition)',\n      description: 'The mid-market edition: core CRM objects and automation, capped agent usage.',\n      category: 'software',\n      family: 'smb',\n      sku: 'OS-PLAT-SMB',\n      list_price: 18000,\n      cost: 4500,\n      is_active: true,\n    },\n    {\n      name: 'Cloud Hosting (Annual)',\n      description: 'Managed hosting with regional data residency and a 99.9% availability target.',\n      category: 'subscription',\n      family: 'cloud',\n      sku: 'OS-CLOUD-HOST',\n      list_price: 12000,\n      cost: 4200,\n      is_active: true,\n    },\n    {\n      name: 'Sandbox Environment (Annual)',\n      description: 'A full-copy non-production environment for testing metadata changes before release.',\n      category: 'subscription',\n      family: 'cloud',\n      sku: 'OS-CLOUD-SBX',\n      list_price: 7500,\n      cost: 2600,\n      is_active: true,\n    },\n    {\n      name: 'AI Agent Seat (Annual)',\n      description: 'A named-user seat for the Co-Pilot and agent surfaces, billed annually.',\n      category: 'subscription',\n      family: 'cloud',\n      sku: 'OS-AI-SEAT',\n      list_price: 1000,\n      cost: 260,\n      is_active: true,\n    },\n    {\n      name: 'Analytics Add-on',\n      description: 'Dashboards, cubes and scheduled reporting for the revenue organization.',\n      category: 'software',\n      family: 'enterprise',\n      sku: 'OS-ADDON-ANL',\n      list_price: 22000,\n      cost: 6500,\n      is_active: true,\n    },\n    {\n      name: 'Integration Connector Pack',\n      description: 'Pre-built connectors for ERP, marketing automation and data warehouse targets.',\n      category: 'software',\n      family: 'enterprise',\n      sku: 'OS-ADDON-INT',\n      list_price: 16000,\n      cost: 5200,\n      is_active: true,\n    },\n    {\n      name: 'Field Service Mobile',\n      description: 'Offline-capable mobile app for field technicians and route-based service work.',\n      category: 'software',\n      family: 'smb',\n      sku: 'OS-ADDON-FSM',\n      list_price: 14000,\n      cost: 4200,\n      is_active: true,\n    },\n    {\n      name: 'Premium Support',\n      description: '24\u00D77 support with a one-hour P1 response target and a named technical account manager.',\n      category: 'support',\n      family: 'services',\n      sku: 'OS-SUP-PREM',\n      list_price: 25000,\n      cost: 9000,\n      is_active: true,\n    },\n    {\n      name: 'Standard Support',\n      description: 'Business-hours support with a next-business-day response target.',\n      category: 'support',\n      family: 'services',\n      sku: 'OS-SUP-STD',\n      list_price: 9000,\n      cost: 3600,\n      is_active: true,\n    },\n    {\n      name: 'Implementation Services',\n      description: 'Guided implementation: discovery, metadata build, integration and go-live support.',\n      category: 'service',\n      family: 'services',\n      sku: 'OS-SVC-IMPL',\n      list_price: 75000,\n      cost: 41000,\n      is_active: true,\n    },\n    {\n      name: 'Data Migration Services',\n      description: 'Extraction, mapping and reconciliation of legacy CRM and spreadsheet data.',\n      category: 'service',\n      family: 'services',\n      sku: 'OS-SVC-MIGR',\n      list_price: 35000,\n      cost: 19000,\n      is_active: true,\n    },\n    {\n      name: 'Admin Training Workshop',\n      description: 'A one-day workshop for administrators on metadata, permissions and analytics.',\n      category: 'service',\n      family: 'services',\n      sku: 'OS-SVC-TRN',\n      list_price: 6000,\n      cost: 2400,\n      is_active: true,\n    },\n  ]\n});\n\n/**\n * Catalog price of a seeded product, read back from the dataset above so the\n * price lives in exactly one place.\n *\n * Line items carry `list_price` explicitly because hooks do NOT run over seeds\n * (#490): the shared price-fill hook (`_line-item-price-fill.ts`) is what\n * stamps `list_price` from `crm_product.list_price` on a real write, so a\n * seeded line has to arrive already carrying what that hook would have\n * written. Reading it from the catalog record makes that literally impossible\n * to get wrong.\n */\nexport const catalogPrice = (productName: string): number => {\n  const product = products.records.find((r) => r.name === productName);\n  if (!product || typeof product.list_price !== 'number') {\n    throw new Error(`Seed error: no catalog product named \"${productName}\"`);\n  }\n  return product.list_price;\n};\n\n/**\n * Flatten a `{ parent \u2192 lines }` table into seed records for one line-item\n * object. `list_price` and `line_number` are the two fields a real write gets\n * from machinery a seed cannot count on (the price-fill hook, and the quote /\n * opportunity line editors), so both are materialised here \u2014 the row is then\n * correct whether or not the hook fires over a seed write (#617).\n */\nexport const lineItemRecords = <K extends string>(\n  parentField: K,\n  table: Record<string, readonly LineSpec[]>,\n): Array<Record<string, unknown>> =>\n  Object.entries(table).flatMap(([parent, lines]) =>\n    lines.map((l, i) => ({\n      [parentField]: parent,\n      crm_product: l.product,\n      description: l.description,\n      quantity: l.quantity,\n      list_price: catalogPrice(l.product),\n      unit_price: l.unit_price,\n      discount: l.discount ?? 0,\n      line_number: i + 1,\n    })),\n  );\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/revenue/data/opportunity-line-item.seed.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/revenue/data\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/revenue/data/opportunity-line-item.seed.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport { defineSeed } from '@objectstack/spec/data';\nimport { OpportunityLineItem } from '../objects/opportunity_line_item.object';\nimport { lineItemRecords } from './catalog.seed';\nimport { OPPORTUNITY_LINES } from '../../sales/data/sales.seed';\n\n/**\n * Opportunity line item seed rows.\n *\n * `crm_opportunity_line_item` is a revenue object, so its seed rows are the\n * revenue package's (plan item 5: an item lives with the object it is authored\n * against) \u2014 while the LINES themselves stay with the opportunities they price.\n * `OPPORTUNITY_LINES` is read from `src/sales/data/sales.seed.ts` along the\n * revenue -> sales edge, and it has to be: the same table is what\n * `dealValue()` derives every opportunity's `amount` from, so a second copy\n * here would be a second answer to what a deal is worth.\n *\n * \u2500\u2500\u2500 Opportunity line items \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n * Identity is the COMPOSITE natural key (opportunity, product): the object has\n * no single natural key \u2014 no name, and `line_number` is only unique within a\n * parent \u2014 and a junction-shaped dataset without one can only run\n * `mode: 'insert'`, which re-inserts every row on each replay boot and\n * duplicates the table (framework#3434). The loader matches composite key\n * fields by their RESOLVED ids, so this dedupes correctly across restarts.\n * The practical constraint it imposes: a product appears at most once per\n * deal, which is how these lines are authored anyway.\n */\nexport const opportunityLineItems = defineSeed(OpportunityLineItem, {\n  mode: 'upsert',\n  externalId: ['crm_opportunity', 'crm_product'],\n  records: lineItemRecords('crm_opportunity', OPPORTUNITY_LINES),\n});\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/revenue/data/revenue.seed.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/revenue/data\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/revenue/data/revenue.seed.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\n/**\n * Revenue seeds \u2014 contracts, quotes and their lines.\n *\n * Split out of the former monolithic `src/data/index.ts` (#635). Seed doctrine\n * lives in `src/sales/data/_shared.ts`.\n */\nimport { defineSeed } from '@objectstack/spec/data';\nimport { cel } from '@objectstack/spec';\nimport { Contract } from '../objects/contract.object';\nimport { Quote } from '../objects/quote.object';\nimport { QuoteLineItem } from '../objects/quote_line_item.object';\nimport { linesTotal, type LineSpec } from '../../sales/data/_shared';\nimport { lineItemRecords } from './catalog.seed';\nimport { OPPORTUNITY_LINES } from '../../sales/data/sales.seed';\n\n// \u2500\u2500\u2500 Contracts \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n// `contract_number` is a runtime-owned autonumber and is NOT seeded (#490).\n// Contract has no natural-name field, so the (unique, stable) description\n// doubles as the upsert identity for these fixtures.\nexport const contracts = defineSeed(Contract, {\n  mode: 'upsert',\n  externalId: 'description',\n  records: [\n    // The one ACTIVATED contract in the app \u2014 `contract_renewal`,\n    // `contract_expiration` and `billing_handoff` all filter on exactly that\n    // status \u2014 so it has to be a contract that was really signed, off a deal\n    // that was really won.\n    //\n    // It used to link `Acme Platform Upgrade` and carry that deal's line total\n    // (150000) while that deal is still `proposal`, closing `daysFromNow(30)`\n    // (#1661). Nothing in this app can produce that pairing: `quote_on_accepted`\n    // close-wins an opportunity the moment its quote is accepted, and\n    // `closed_won` is TERMINAL in `opportunity_stage_progression` \u2014 so a signed\n    // contract can never sit on an open deal, from either direction.\n    //\n    // Every field below is now derived from `Acme Annual Renewal 2025`, the\n    // `closed_won` deal this contract's own description was already describing:\n    //   contract_value \u2014 that deal's line-item total, which is also the ARR the\n    //                    account description reports. 150000 was the upgrade's\n    //                    total, i.e. the value came from a different deal than\n    //                    the link did;\n    //   signed_date    \u2014 its `close_date`: you sign when you win, and\n    //                    `quote_on_accepted` stamps that same day;\n    //   start_date     \u2014 signature + 14d, because that deal's description says\n    //                    it was \"signed two weeks ahead of the renewal date\";\n    //   end_date       \u2014 start + 365d, the span every other row here uses for a\n    //                    12-month term.\n    {\n      crm_account: 'Acme Corporation',\n      crm_contact: 'john.smith@acme.example.com',\n      crm_opportunity: 'Acme Annual Renewal 2025',\n      status: 'activated',\n      contract_term_months: 12,\n      start_date: cel`daysAgo(1)`,\n      end_date: cel`daysFromNow(364)`,\n      contract_value: 220000,\n      billing_frequency: 'annually',\n      payment_terms: 'net_30',\n      auto_renewal: true,\n      renewal_notice_days: 60,\n      contract_type: 'subscription',\n      signed_date: cel`daysAgo(15)`,\n      signed_by: 'John Smith',\n      description: 'Annual platform subscription with premium support tier.',\n    },\n    {\n      crm_account: 'Wayne Enterprises',\n      crm_contact: 'rwilson@wayne.example.com',\n      crm_opportunity: 'Wayne Enterprise License',\n      status: 'in_approval',\n      contract_term_months: 36,\n      start_date: cel`daysFromNow(14)`,\n      end_date: cel`daysFromNow(1109)`,\n      contract_value: 1200000,\n      billing_frequency: 'annually',\n      payment_terms: 'net_60',\n      auto_renewal: false,\n      renewal_notice_days: 90,\n      contract_type: 'license',\n      description: 'Multi-year enterprise license with custom SLA.',\n    },\n    {\n      crm_account: 'Initech Solutions',\n      crm_contact: 'mchen@initech.example.com',\n      status: 'expired',\n      contract_term_months: 12,\n      start_date: cel`daysAgo(400)`,\n      end_date: cel`daysAgo(35)`,\n      contract_value: 60000,\n      billing_frequency: 'quarterly',\n      payment_terms: 'net_30',\n      auto_renewal: false,\n      renewal_notice_days: 30,\n      contract_type: 'service',\n      signed_date: cel`daysAgo(405)`,\n      signed_by: 'Michael Chen',\n      description: 'Initial service agreement, pending renewal discussion.',\n    },\n    {\n      crm_account: 'Stark Medical',\n      crm_contact: 'emily.d@starkmed.example.com',\n      status: 'draft',\n      contract_term_months: 24,\n      start_date: cel`daysFromNow(30)`,\n      end_date: cel`daysFromNow(760)`,\n      contract_value: 350000,\n      billing_frequency: 'monthly',\n      payment_terms: 'net_30',\n      auto_renewal: true,\n      renewal_notice_days: 60,\n      contract_type: 'partnership',\n      description: 'Healthcare partnership agreement, currently under legal review.',\n    },\n  ]\n});\n\n// \u2500\u2500\u2500 Quotes \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n// `quote_number` is a runtime-owned autonumber and is NOT seeded (#490);\n// the (unique) quote name is the upsert identity instead.\n/**\n * Quote line items, keyed by quote name. The four quotes generated from a deal\n * carry that deal's configuration verbatim \u2014 which is exactly what the\n * `quote_generation` flow does when it clones opportunity lines onto a quote.\n */\nconst QUOTE_LINES: Record<string, readonly LineSpec[]> = {\n  'Acme Platform Upgrade Quote': OPPORTUNITY_LINES['Acme Platform Upgrade'],\n  'Acme Annual Renewal 2025 Quote': OPPORTUNITY_LINES['Acme Annual Renewal 2025'],\n  'Globex Manufacturing Suite Proposal': OPPORTUNITY_LINES['Globex Manufacturing Suite'],\n  'Wayne Enterprise License Quote': OPPORTUNITY_LINES['Wayne Enterprise License'],\n  'Initech Cloud Migration Estimate': OPPORTUNITY_LINES['Initech Cloud Migration'],\n  // Quoted standalone, before any opportunity existed \u2014 and then rejected.\n  'Stark Medical Pilot Quote': [\n    { product: 'Admin Training Workshop', quantity: 5, unit_price: 6000, description: 'Five workshop days for the pilot clinical teams.' },\n    { product: 'Standard Support', quantity: 1, unit_price: 9000, description: 'Standard support for the pilot term.' },\n    { product: 'AI Agent Seat (Annual)', quantity: 6, unit_price: 1000, description: 'Agent seats for the pilot coordinators.' },\n  ],\n};\n\n/**\n * `subtotal` / `discount_amount` / `total_price` for a quote, derived from its\n * lines with `quote_total_rollup`'s own model:\n *\n *   subtotal        = \u03A3 line (quantity \u00D7 unit_price \u00D7 (1 \u2212 line_discount/100))\n *   discount_amount = subtotal \u00D7 quote.discount%\n *   total_price     = subtotal \u2212 discount_amount + tax + shipping_handling\n *\n * Quote-level `tax` and `shipping_handling` stay manual inputs \u2014 the rollup\n * does not derive them either. Everything the rollup DOES own is computed here\n * so that the first edit to a seeded line item recomputes the same numbers\n * instead of visibly correcting them.\n */\nconst quoteTotals = (\n  quoteName: string,\n  opts: { discount: number; tax: number; shipping_handling: number },\n) => {\n  const lines = QUOTE_LINES[quoteName];\n  if (!lines) throw new Error(`Seed error: no line items authored for quote \"${quoteName}\"`);\n  const subtotal = linesTotal(lines);\n  const discount_amount = Math.round(subtotal * (opts.discount / 100) * 100) / 100;\n  const total_price =\n    Math.round((subtotal - discount_amount + opts.tax + opts.shipping_handling) * 100) / 100;\n  return {\n    subtotal,\n    discount: opts.discount,\n    discount_amount,\n    tax: opts.tax,\n    shipping_handling: opts.shipping_handling,\n    total_price,\n  };\n};\n\nexport const quotes = defineSeed(Quote, {\n  mode: 'upsert',\n  externalId: 'name',\n  records: [\n    {\n      name: 'Acme Platform Upgrade Quote',\n      crm_account: 'Acme Corporation',\n      crm_contact: 'john.smith@acme.example.com',\n      crm_opportunity: 'Acme Platform Upgrade',\n      // `expired`, not `accepted` (#1661). Accepting this quote would have\n      // close-won `Acme Platform Upgrade`, which is `proposal` and 30 days from\n      // close \u2014 the same impossible pairing the contract above carried, one\n      // object over. `expired` is what `quote_expiration` computes for a\n      // presented quote past its `expiration_date`, and it is what the deal's\n      // own next step assumes: the revised Enterprise proposal still has to go\n      // out. Its `crm_contact` stays put \u2014 the row is no longer gated by\n      // `requiredWhen`, but the recipient is still who it was sent to.\n      status: 'expired',\n      quote_date: cel`daysAgo(45)`,\n      expiration_date: cel`daysAgo(15)`,\n      ...quoteTotals('Acme Platform Upgrade Quote', { discount: 10, tax: 11475, shipping_handling: 0 }),\n      payment_terms: 'net_30',\n      description: 'Platform upgrade with 10% loyalty discount applied.',\n    },\n    // The renewal's own quote, and the seed's one ACCEPTED quote. Acceptance is\n    // only coherent here: `quote_on_accepted` close-wins whatever opportunity a\n    // quote links, so an accepted quote can only ever point at a `closed_won`\n    // deal. It also completes the provenance chain the contract above needs \u2014\n    // deal won, quote accepted, contract drafted, then completed and activated\n    // by an admin (the draft the hook writes is explicitly a starting point).\n    // `Acme Annual Renewal 2025` keeps its rep-recorded `relationship` win\n    // reason: the hook only supplies `quote_accepted` when nobody recorded one.\n    {\n      name: 'Acme Annual Renewal 2025 Quote',\n      crm_account: 'Acme Corporation',\n      crm_contact: 'john.smith@acme.example.com',\n      crm_opportunity: 'Acme Annual Renewal 2025',\n      status: 'accepted',\n      quote_date: cel`daysAgo(30)`,\n      expiration_date: cel`daysAgo(1)`,\n      // No discount \u2014 the renewal went at list (\"multi-year option declined\n      // this round\"), which is what its 22% YoY uplift is made of. Tax is 8.5%\n      // of the post-discount subtotal, the rate the other Acme quote bills at;\n      // every non-Acme quote here bills 8%.\n      ...quoteTotals('Acme Annual Renewal 2025 Quote', { discount: 0, tax: 18700, shipping_handling: 0 }),\n      payment_terms: 'net_30',\n      description: 'Annual renewal \u2014 three production tenants, premium support and the EMEA seat expansion.',\n    },\n    {\n      name: 'Globex Manufacturing Suite Proposal',\n      crm_account: 'Globex Industries',\n      crm_contact: 'sarah.j@globex.example.com',\n      crm_opportunity: 'Globex Manufacturing Suite',\n      status: 'presented',\n      quote_date: cel`daysAgo(7)`,\n      expiration_date: cel`daysFromNow(23)`,\n      ...quoteTotals('Globex Manufacturing Suite Proposal', { discount: 5, tax: 7220, shipping_handling: 2500 }),\n      payment_terms: 'net_60',\n      description: 'Manufacturing suite licensing with plant-admin training.',\n    },\n    {\n      name: 'Wayne Enterprise License Quote',\n      crm_account: 'Wayne Enterprises',\n      crm_contact: 'rwilson@wayne.example.com',\n      crm_opportunity: 'Wayne Enterprise License',\n      status: 'in_review',\n      quote_date: cel`daysAgo(3)`,\n      expiration_date: cel`daysFromNow(27)`,\n      ...quoteTotals('Wayne Enterprise License Quote', { discount: 15, tax: 81600, shipping_handling: 0 }),\n      payment_terms: 'net_60',\n      description: 'Multi-year enterprise license with volume discount.',\n    },\n    {\n      name: 'Initech Cloud Migration Estimate',\n      crm_account: 'Initech Solutions',\n      crm_contact: 'mchen@initech.example.com',\n      crm_opportunity: 'Initech Cloud Migration',\n      status: 'draft',\n      quote_date: cel`daysAgo(1)`,\n      expiration_date: cel`daysFromNow(29)`,\n      ...quoteTotals('Initech Cloud Migration Estimate', { discount: 0, tax: 6400, shipping_handling: 0 }),\n      payment_terms: 'net_30',\n      description: 'Cloud migration services, awaiting internal review.',\n    },\n    {\n      name: 'Stark Medical Pilot Quote',\n      crm_account: 'Stark Medical',\n      crm_contact: 'emily.d@starkmed.example.com',\n      status: 'rejected',\n      quote_date: cel`daysAgo(60)`,\n      expiration_date: cel`daysAgo(30)`,\n      ...quoteTotals('Stark Medical Pilot Quote', { discount: 0, tax: 3600, shipping_handling: 0 }),\n      payment_terms: 'net_30',\n      description: 'Pilot project quote, rejected due to budget constraints.',\n      internal_notes: 'Customer requested re-quote with smaller scope.',\n    },\n  ]\n});\n\n// \u2500\u2500\u2500 Quote line items \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n// Same composite-key reasoning as the opportunity lines above: (quote,\n// product) is the only natural key this junction-shaped object has.\nexport const quoteLineItems = defineSeed(QuoteLineItem, {\n  mode: 'upsert',\n  externalId: ['crm_quote', 'crm_product'],\n  records: lineItemRecords('crm_quote', QUOTE_LINES),\n});\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/service/data/service.seed.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/service/data\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/service/data/service.seed.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\n/**\n * Service seeds \u2014 the case backlog and the knowledge base.\n *\n * The task list and the interaction log used to be here too: tasks, events and\n * event attendees are the activity layer over every object, and the case seeds\n * are the records they most often hang off (#671). Those three objects are the\n * SALES package's under the ADR-0130 layout (plan item 4 \u2014 the activity\n * objects fold into the app package), so their rows moved with them to\n * `src/sales/data/activity.seed.ts`. Nothing about the rows changed: they still\n * reference cases by natural key. These case rows are registered by the service\n * package and the activity rows by the app package; measured on a fresh boot\n * of the two-package artifact (#1907), the lookups resolve in both directions \u2014\n * every seeded case's account, and every seeded event's case.\n *\n * Split out of the former monolithic `src/data/index.ts` (#635). Seed doctrine\n * lives in `src/sales/data/_shared.ts`.\n */\nimport { defineSeed } from '@objectstack/spec/data';\nimport { cel } from '@objectstack/spec';\nimport { Case } from '../objects/case.object';\nimport { KnowledgeArticle } from '../objects/knowledge_article.object';\nimport { CASE_SLA_DEFAULT_TIER, caseSlaBreached, caseSlaCalendarHours } from '../objects/_case-sla';\nimport { celDaysAgo } from '../../sales/data/_shared';\nimport { accounts } from '../../sales/data/sales.seed';\n\n// \u2500\u2500\u2500 Seeded SLA due dates \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n//\n// Hooks do not run over seeds, so a hook-owned field has to arrive already\n// holding what the hook would have computed (`test/seed-consistency.test.ts`\n// is the enforcement). `sla_due_date` used to be hand-typed per case \u2014 eight\n// numbers picked to look plausible \u2014 and it is now DERIVED from the same\n// priority \u00D7 account-tier matrix `case_sla_defaults` applies, so a cell change\n// moves the demo data with it instead of leaving it lying.\n//\n// The account tier is read off the account seed itself rather than copied into\n// a table here: `crm_account.tier` is the input the matrix takes, and there is\n// no reason for this file to hold a second opinion about which tier Acme is.\nconst TIER_BY_ACCOUNT = new Map<string, string>(\n  (accounts.records as ReadonlyArray<Record<string, unknown>>).map((a) => [\n    String(a.name),\n    typeof a.tier === 'string' ? a.tier : CASE_SLA_DEFAULT_TIER,\n  ]),\n);\n\n/** The matrix cell `case_sla_defaults` would have applied, in calendar hours after creation. */\nconst seededSlaHours = (priority: string, accountName?: string): number => {\n  const hours = caseSlaCalendarHours(priority, accountName ? TIER_BY_ACCOUNT.get(accountName) : undefined);\n  if (hours === undefined) throw new Error(`seed: no SLA matrix row for priority \"${priority}\"`);\n  return hours;\n};\n\n/**\n * `created_at + matrix(priority, tier)`, as a CEL expression \u2014 the case's\n * authored creation instant (the platform's own `created_at`, which the seed\n * loader keeps on first insert since @objectstack/objectql 17.7.0,\n * objectstack#21646) plus the cell `case_sla_defaults` would have applied.\n *\n * `daysAgo(n)` is a UTC midnight, so the hour offset has to be added on top of\n * it \u2014 hence `+ duration('Nh')` rather than a second day-granular helper.\n *\n * A due date that lands in the past is expected and correct on an old open case\n * \u2014 that is what a breach IS. On an OPEN case the flag is `case_sla_monitor`'s\n * to write, on a deployment that runs scheduled work, and the seed only pre-sets\n * it where the demo wants a breach visible without a sweep.\n */\nconst celCaseSlaDue = (createdDaysAgo: number, priority: string, accountName?: string) =>\n  cel`daysAgo(${createdDaysAgo}) + duration('${seededSlaHours(priority, accountName)}h')`;\n\n/**\n * `is_sla_violated` of a SETTLED case (resolved or closed) \u2014 DERIVED, never\n * picked (#2070). `case_sla_defaults` records the breach on the write that\n * settles a case after its due date, so a settled seed row has to arrive\n * holding exactly what that write would have recorded: `caseSlaBreached` over\n * the row's own dates. Both instants are offsets from the same `daysAgo()`\n * midnight \u2014 the due date `matrix(priority, tier)` hours after creation, the\n * settle instant (`closed_date`, which a settled seed row carries as its\n * resolved-date proxy) whole days after it \u2014 so the hour counts compare\n * directly, and a case settled exactly on its deadline met it.\n *\n * These rows used to be authored `false` across the board, which made the\n * `sla_performance` report and the compliance gauge read 100% met over closed\n * cases that had finished days late by their own dates.\n */\nconst seededSettledBreach = (\n  createdDaysAgo: number,\n  settledDaysAgo: number,\n  priority: string,\n  accountName?: string,\n): boolean => caseSlaBreached(seededSlaHours(priority, accountName), (createdDaysAgo - settledDaysAgo) * 24);\n\n// \u2500\u2500\u2500 Cases \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\nexport const cases = defineSeed(Case, {\n  mode: 'upsert',\n  externalId: 'subject',\n  records: [\n    {\n      subject: 'Login issues after platform upgrade',\n      description: `Users in the EMEA office report intermittent 401 errors when logging in after the v4.2 upgrade rolled out Wednesday night. Pattern: only affects users authenticating via SAML through Okta, only between 09:00\u201310:30 UTC. NA and APAC users are unaffected.\n\n**Customer impact:** ~40 users blocked at peak, costing ~3 productive hours per affected user.\n\n**Initial triage:** Suspect a clock-skew issue on the EMEA SSO relay added during the upgrade window. Engineering is reproducing in staging.`,\n      crm_account: 'Acme Corporation',\n      crm_contact: 'john.smith@acme.example.com',\n      status: 'in_progress',\n      priority: 'high',\n      priority_rank: 3,\n      type: 'problem',\n      origin: 'email',\n      is_closed: false,\n      is_sla_violated: false,\n      is_escalated: false,\n      created_at: cel`daysAgo(2)`,\n      sla_due_date: celCaseSlaDue(2, 'high', 'Acme Corporation'),\n    },\n    {\n      subject: 'Data export timing out for large datasets',\n      description: 'CSV export fails for datasets over 10k rows.',\n      crm_account: 'Globex Industries',\n      crm_contact: 'sarah.j@globex.example.com',\n      status: 'escalated',\n      priority: 'critical',\n      priority_rank: 4,\n      type: 'bug',\n      origin: 'phone',\n      is_closed: false,\n      is_sla_violated: true,\n      is_escalated: true,\n      escalation_reason: 'Customer threatening churn',\n      created_at: cel`daysAgo(5)`,\n      sla_due_date: celCaseSlaDue(5, 'critical', 'Globex Industries'),\n    },\n    {\n      subject: 'How to configure SSO with Okta?',\n      description: 'Customer needs guidance on SSO setup with Okta.',\n      crm_account: 'Initech Solutions',\n      crm_contact: 'mchen@initech.example.com',\n      status: 'resolved',\n      priority: 'medium',\n      priority_rank: 2,\n      type: 'question',\n      origin: 'web',\n      // Resolved-but-not-closed: case.hook keeps is_closed=false and stamps\n      // closed_date as the resolved-date proxy; resolution_time_hours is the\n      // closed\u2212created delta the hook would compute (daysAgo() is day-granular,\n      // so deltas come in 24h steps).\n      is_closed: false,\n      is_sla_violated: seededSettledBreach(3, 2, 'medium', 'Initech Solutions'),\n      is_escalated: false,\n      resolution_time_hours: 24.0,\n      created_at: cel`daysAgo(3)`,\n      closed_date: cel`daysAgo(2)`,\n      sla_due_date: celCaseSlaDue(3, 'medium', 'Initech Solutions'),\n    },\n    {\n      subject: 'API rate limit exceeded on production',\n      description: 'Production environment hitting rate limits during peak hours.',\n      crm_account: 'Wayne Enterprises',\n      crm_contact: 'rwilson@wayne.example.com',\n      status: 'closed',\n      priority: 'high',\n      priority_rank: 3,\n      type: 'problem',\n      origin: 'chat',\n      is_closed: true,\n      is_sla_violated: seededSettledBreach(7, 6, 'high', 'Wayne Enterprises'),\n      is_escalated: false,\n      // `resolution` is REQUIRED when status is 'closed' (object validation\n      // `resolution_required_for_closed`) \u2014 without it the seed row is rejected.\n      resolution: 'Raised the production rate-limit tier and added client-side backoff; usage now within limits.',\n      // The deflection link (#601): this case was answered out of the knowledge\n      // base, so it names the article that resolved it. Referenced by the\n      // article seed's `externalId` (`title`), the same way every other seeded\n      // lookup names its target.\n      resolved_by_article: 'API Rate Limits',\n      // closed\u2212created delta, as case.hook computes it.\n      resolution_time_hours: 24.0,\n      created_at: cel`daysAgo(7)`,\n      closed_date: cel`daysAgo(6)`,\n      sla_due_date: celCaseSlaDue(7, 'high', 'Wayne Enterprises'),\n    },\n    {\n      subject: 'PDF reports not rendering charts correctly',\n      description: 'Charts appear blank when exporting dashboard to PDF.',\n      crm_account: 'Stark Medical',\n      crm_contact: 'emily.d@starkmed.example.com',\n      status: 'new',\n      priority: 'medium',\n      priority_rank: 2,\n      type: 'bug',\n      origin: 'email',\n      is_closed: false,\n      is_sla_violated: false,\n      is_escalated: false,\n      created_at: cel`daysAgo(1)`,\n      sla_due_date: celCaseSlaDue(1, 'medium', 'Stark Medical'),\n    },\n    {\n      subject: 'Billing discrepancy on last invoice',\n      description: `Customer (Lisa Kim, Procurement) flagged that the May invoice shows 15 active seats but Acme is only using 12. Two of the seats were de-provisioned in early April when two engineers left the company.\n\n**Root cause:** the de-provisioning happened in our admin console but the seat-count metric in billing only refreshes monthly, so the May invoice picked up the pre-change count.\n\n**Resolution path:** issue a $1,200 credit memo and switch Acme to the new real-time seat-billing pipeline so this can't recur. Waiting on Lisa to confirm she's good with the credit-memo treatment vs a refund.`,\n      crm_account: 'Acme Corporation',\n      crm_contact: 'john.smith@acme.example.com',\n      status: 'waiting_customer',\n      priority: 'low',\n      priority_rank: 1,\n      type: 'problem',\n      origin: 'email',\n      is_closed: false,\n      is_sla_violated: false,\n      is_escalated: false,\n      created_at: cel`daysAgo(4)`,\n      sla_due_date: celCaseSlaDue(4, 'low', 'Acme Corporation'),\n    },\n    {\n      subject: 'Mobile app crashes on iOS 17',\n      description: 'App crashes on launch for users running iOS 17.2+.',\n      crm_account: 'Globex Industries',\n      crm_contact: 'sarah.j@globex.example.com',\n      status: 'in_progress',\n      priority: 'critical',\n      priority_rank: 4,\n      type: 'bug',\n      origin: 'web',\n      is_closed: false,\n      is_sla_violated: true,\n      is_escalated: true,\n      escalation_reason: 'Affects 30% of mobile users',\n      created_at: cel`daysAgo(3)`,\n      sla_due_date: celCaseSlaDue(3, 'critical', 'Globex Industries'),\n    },\n    {\n      subject: 'Request: bulk import via CSV',\n      description: 'Customer requesting ability to import records via CSV upload.',\n      crm_account: 'Wayne Enterprises',\n      crm_contact: 'rwilson@wayne.example.com',\n      status: 'closed',\n      priority: 'low',\n      priority_rank: 1,\n      type: 'feature_request',\n      origin: 'web',\n      is_closed: true,\n      is_sla_violated: seededSettledBreach(10, 8, 'low', 'Wayne Enterprises'),\n      is_escalated: false,\n      // Required for closed cases (resolution_required_for_closed).\n      resolution: 'Delivered CSV bulk-import in the 9.4 release; shared the docs link with the customer.',\n      // closed\u2212created delta, as case.hook computes it.\n      resolution_time_hours: 48.0,\n      created_at: cel`daysAgo(10)`,\n      closed_date: cel`daysAgo(8)`,\n      sla_due_date: celCaseSlaDue(10, 'low', 'Wayne Enterprises'),\n    },\n    // \u2500\u2500\u2500 Generated demo cases \u2014 30 cases over the last 30 days, mixed across\n    // priorities. Powers `CasesOpenedByDayPriorityReport` (daily bucketing\n    // matrix) and the service dashboard's daily-volume area chart.\n    //\n    // ### Why every axis carries a rotation, and not just `i % length` (#1659)\n    //\n    // These rows used to read ONE counter for every axis: `crm_account` and\n    // `status` both took `i % 5`, and `priority`, `type` and `origin` all took\n    // `i % 4`. Equal-length lists walked by one index advance in lockstep, so\n    // each group came out PERFECTLY correlated \u2014 every Acme case `new`, every\n    // Globex case `in_progress`, and every `low` case a `question` raised by\n    // `email`. Thirty rows of volume with no variety, which is the opposite of\n    // what a volume generator is for: the account \u00D7 status cross-tab held 5 of\n    // its 25 cells, and priority \u00D7 type \u00D7 origin 4 of 16 apiece.\n    //\n    // Each list now advances one step per row PLUS a rotation \u2014 `c` extra steps\n    // every `m` rows. Two axes stay correlated exactly when their relative\n    // offset never moves, so the rotations are chosen to make every relative\n    // offset sweep its whole cycle. `crm_account` is the anchor and carries no\n    // rotation; the other four are stated relative to it.\n    //\n    // `account \u00D7 status` is complete BY CONSTRUCTION rather than by luck, and\n    // the proof is one line: account `a` takes rows i = a, a+5 \u2026 a+25, whose\n    // block numbers run 0\u20265, so its statuses are `(a + b) % 5` over b = 0\u20265 \u2014\n    // all five of them. The thirty rows therefore walk the whole 5 \u00D7 5 grid,\n    // twenty-five cells once and five of them a second time.\n    //\n    // \u26A0\uFE0F The remaining three constants are TUNED, not derived. They were picked\n    // by computing all ten pairwise cross-tabs and keeping the assignment that\n    // left the fewest empty cells. Measured over the lists as shipped: 188 of\n    // the 193 pairwise cells are occupied, no cell holds more than 3 rows, and\n    // the marginals stay as flat as thirty rows allow \u2014 6/6/6/6/6 by account\n    // and by status, 8/7/7/8 by priority, type and origin. \u26D4 Changing the\n    // LENGTH of any list below voids that tuning: re-measure the cross-tabs\n    // rather than assuming the rotations still separate the axes.\n    //\n    // Two schemes that read as more principled than they measure were rejected\n    // here, and are recorded so they are not re-derived: rotating the 5-lists\n    // on the 4-block and the 4-lists on the 5-block (\"the lengths are coprime,\n    // so they cannot resonate\") empties one status completely; and rotating\n    // `crm_account` as well \u2014 to break the every-fifth-day beat it walks the\n    // calendar on \u2014 costs twelve further empty cells. That beat is the\n    // deliberate price of anchoring: with one row per day, some axis has to be\n    // the fixed one the other four are measured against.\n    ...((): readonly Record<string, unknown>[] => {\n      const priorities = ['low', 'medium', 'high', 'critical'] as const;\n      // Mirror of case.hook's priority rank map \u2014 hooks don't run over seeds.\n      const rankByPriority: Record<typeof priorities[number], number> = { low: 1, medium: 2, high: 3, critical: 4 };\n      const types = ['question', 'bug', 'problem', 'feature_request'] as const;\n      const origins = ['email', 'phone', 'web', 'chat'] as const;\n      const statuses = ['new', 'in_progress', 'resolved', 'closed', 'escalated'] as const;\n      const accountsList = ['Acme Corporation', 'Globex Industries', 'Wayne Enterprises', 'Initech Solutions', 'Stark Medical'] as const;\n      const out: Record<string, unknown>[] = [];\n      for (let i = 0; i < 30; i++) {\n        // The anchor, then the four rotations the block comment above derives.\n        // `10` is the one constant with no reading off a list length \u2014 it is\n        // the rotation that measured best for `origin` against the other four.\n        const account = accountsList[i % accountsList.length];\n        const status = statuses[(i + Math.floor(i / accountsList.length)) % statuses.length];\n        const priority = priorities[(i + Math.floor(i / priorities.length)) % priorities.length];\n        const type = types[(i + 2 * Math.floor(i / types.length)) % types.length];\n        const origin = origins[(i + Math.floor(i / 10)) % origins.length];\n        const settled = status === 'resolved' || status === 'closed';\n        const ageDays = 1 + (i % 30);\n        // Settled cases get a resolution delay of 1\u20133 days (capped at the\n        // case's age); resolution_time_hours is exactly the closed\u2212created\n        // delta case.hook would compute (daysAgo() is day-granular \u2192 24h steps).\n        const resolutionDays = Math.min(ageDays, 1 + (i % 3));\n        // A SETTLED row's flag is derived from its own dates (#2070,\n        // `seededSettledBreach`): the write that settled it would have recorded\n        // a late finish, so the seed does too.\n        //\n        // An OPEN row's flag is the sweep's definition \u2014 open, and its due date\n        // already in the past. The old generator flagged rows as violated while\n        // giving every row a FUTURE due date; since #595 the due date is DERIVED\n        // (`celCaseSlaDue` below), so \"already in the past\" holds by\n        // construction here: a critical case is due 4h after creation and every\n        // generated case is at least a day old. The converse is deliberately not\n        // enforced \u2014 other open rows are past due too, and `case_sla_monitor`\n        // notices them where scheduled work runs. Pre-setting the flag here only\n        // decides which open breaches the demo shows without a sweep.\n        const slaViolated = settled\n          ? seededSettledBreach(ageDays, ageDays - resolutionDays, priority, account)\n          : priority === 'critical' && i % 3 === 0;\n        out.push({\n          subject: `Demo case ${String(i + 1).padStart(2, '0')} \u2014 ${priority} ${type}`,\n          description: `Auto-generated demo case for ${priority} priority on day -${ageDays}.`,\n          crm_account: account,\n          status,\n          priority,\n          priority_rank: rankByPriority[priority],\n          type,\n          origin,\n          // is_closed strictly mirrors case.hook: true ONLY for status\n          // 'closed' \u2014 a resolved case is NOT closed yet.\n          is_closed: status === 'closed',\n          is_sla_violated: slaViolated,\n          is_escalated: status === 'escalated',\n          ...(settled ? { resolution_time_hours: resolutionDays * 24 } : {}),\n          // Object validations require these when closed/escalated \u2014 without\n          // them the generated rows are rejected (resolution_required_for_closed\n          // / escalation_reason_required).\n          ...(status === 'closed' ? { resolution: 'Resolved per standard runbook; root cause documented and customer confirmed.' } : {}),\n          ...(status === 'escalated' ? { escalation_reason: 'Escalated to tier-2 engineering for SLA-risk review.' } : {}),\n          created_at: celDaysAgo(ageDays),\n          // Resolved cases also carry closed_date: case.hook stamps it as the\n          // resolved-date proxy while keeping is_closed=false.\n          ...(settled ? { closed_date: celDaysAgo(ageDays - resolutionDays) } : {}),\n          sla_due_date: celCaseSlaDue(ageDays, priority, account),\n        });\n      }\n      return out;\n    })(),\n  ],\n});\n\n// \u2500\u2500\u2500 Knowledge Articles \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n//\n// No `helpful_count` / `not_helpful_count` here, deliberately (#601). Those two\n// are now DERIVED: `article_feedback_metrics_refresh` recounts them from\n// `crm_article_feedback` on every vote. This file used to type in 38, 96, 5, 9\n// \u2014 numbers with no rows behind them \u2014 and the first real vote on an article\n// would have recounted 96 down to 1, in front of whoever pressed the button.\n//\n// The seed doctrine at the top of this file is what decides it: a hook-owned\n// field must arrive holding what the hook WOULD have computed. With no seeded\n// feedback rows the honest value is the field's own default, 0. Rows are not\n// seeded either, because a seed cannot name a user (see the note on\n// `crm_event_attendee` below) and the voter's identity is exactly what the\n// one-vote-per-reader index keys on \u2014 a table of ownerless verdicts would be\n// the same fiction one level down.\n//\n// The deflection half of #601 does not have this problem and IS seeded: a case\n// naming the article that resolved it needs no user, so the closed\n// `API rate limit exceeded on production` case above carries a real\n// `resolved_by_article` and the Service dashboard's KB tiles have something\n// true to show on a fresh `pnpm demo:reset`.\nexport const knowledgeArticles = defineSeed(KnowledgeArticle, {\n  mode: 'upsert',\n  externalId: 'title',\n  records: [\n    {\n      title: 'Getting Started with HotCRM',\n      summary: 'A five-minute tour of accounts, contacts, leads and the sales pipeline.',\n      category: 'getting_started',\n      status: 'published',\n      audience: 'public',\n      language: 'en',\n      body: `# Getting Started with HotCRM\n\nWelcome! This guide walks you through the core objects:\n\n1. **Accounts** \u2014 the companies you sell to and serve.\n2. **Contacts** \u2014 the people at those accounts.\n3. **Leads** \u2014 unqualified prospects in the top of the funnel.\n4. **Opportunities** \u2014 qualified deals moving through your pipeline.\n\nOpen the **Sales Pipeline** kanban to drag deals between stages, and use the\n**Executive Overview** dashboard to track revenue at a glance.`,\n      published_at: cel`daysAgo(40)`,\n      last_reviewed_at: cel`daysAgo(20)`,\n    },\n    {\n      title: 'Resetting Your Password',\n      summary: 'How end users reset a forgotten password from the login screen.',\n      category: 'how_to',\n      status: 'published',\n      audience: 'public',\n      language: 'en',\n      body: `# Resetting Your Password\n\n1. On the login screen, click **Forgot password?**\n2. Enter the email associated with your account.\n3. Check your inbox for a reset link (valid for 30 minutes).\n4. Choose a new password of at least 12 characters.\n\nIf the email does not arrive, check spam or contact your administrator.`,\n      published_at: cel`daysAgo(25)`,\n      last_reviewed_at: cel`daysAgo(10)`,\n    },\n    {\n      title: 'API Rate Limits',\n      summary: 'Per-token request quotas and recommended back-off strategy.',\n      category: 'api',\n      status: 'draft',\n      audience: 'internal',\n      language: 'en',\n      body: `# API Rate Limits (DRAFT)\n\nDefault quota is 600 requests/minute per token. On HTTP 429, back off\nexponentially starting at 1s. Numbers pending final review with platform team.`,\n    },\n    {\n      title: 'Legacy SSO Setup',\n      summary: 'SAML configuration for the pre-2025 identity stack.',\n      category: 'troubleshooting',\n      status: 'published',\n      audience: 'internal',\n      language: 'en',\n      body: `# Legacy SSO Setup\n\nThis covers the deprecated SAML 1.1 flow. New tenants should use the OIDC\nconnector instead. Retained for customers still on the legacy stack.`,\n      published_at: cel`daysAgo(240)`,\n      last_reviewed_at: cel`daysAgo(220)`,\n    },\n  ]\n});\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/service/objects/_case-sla.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/service/objects\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/service/objects/_case-sla.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\n/**\n * The case SLA policy matrix \u2014 priority \u00D7 account tier, in CALENDAR HOURS.\n *\n * # What this replaces\n *\n * Until #595 the only SLA rule in the app was \"critical \u21D2 now + 4h\", hardcoded\n * in `case_sla_defaults`. Three of the four priorities therefore got NO\n * `sla_due_date` at all, which meant `case_sla_monitor` \u2014 the hourly sweep that\n * flags and escalates breaches \u2014 could never fire for them: it selects on\n * `sla_due_date < now`, and a blank date is never in the past. A High case\n * nobody touched entered neither the priority-escalation path nor the time\n * path. The field, the sweep and the four published per-priority targets were\n * all shipped; only the clock behind three of them was missing.\n *\n * `crm_account.tier` was the other half of the same gap: four options declared\n * on the account object and read by nothing outside `src/views/account.view.ts`.\n *\n * # \u26A0\uFE0F CALENDAR HOURS, NOT BUSINESS HOURS\n *\n * Every number below is added to the WALL CLOCK. This app ships no\n * business-hours calendar, no working-day definition and no holiday list \u2014\n * there is nothing in its metadata a deadline could be counted against, and\n * the platform provides no such service either. So a P1 raised at 5pm on a\n * Friday is due at 9pm that same Friday, and a Low case raised on the 23rd of\n * December runs its week down over the holidays.\n *\n * This is stated rather than hidden because it is the single most likely way\n * for these numbers to be misread. Teaching the deadline to skip non-working\n * time means teaching this module a calendar \u2014 it is not a matter of changing\n * a cell.\n *\n * This header is the ONE place the app says it in prose (#1974). Everywhere\n * else the unit rides in a name \u2014 `CASE_SLA_CALENDAR_HOURS` and\n * `caseSlaCalendarHours` below, `slaCalendarHours` in the hook body \u2014 and in\n * `test/case-sla-matrix.test.ts`, which drives the hook on a fixed Friday\n * 17:00 clock and pins the deadlines that land on the weekend. The operator\n * reads it in the `sla_due_date` field description.\n *\n * # Why the `critical` row is flat\n *\n * Every cell in the `critical` row is 4 \u2014 deliberately, and it is the one\n * constraint on this table that is not a product opinion. Before #595 EVERY\n * critical case got 4 hours regardless of tier. Differentiating the row by\n * tier would LOOSEN the deadline on the critical cases of non-strategic\n * accounts, i.e. this change would take a clock away from work that already\n * had one. Flat at 4 keeps the new behaviour a strict superset of the old:\n * every case that had a due date still gets the same one, and three whole\n * priorities gain one. (The ruling on #595 asks for 4h as the *strategic*\n * cell; holding the rest of the row to it too is what makes \"superset\" true\n * rather than approximately true.)\n *\n * The remaining rows never exceed the per-priority target the user docs have\n * always published (High 8h, Medium 2 days = 48h, Low 7 days = 168h) \u2014 the\n * lowest tier gets exactly that commitment and the higher tiers get tighter.\n * No account is worse off at any priority than the docs already promised.\n *\n * # Where this constant is, and is not, the source of truth\n *\n * The hook body in `case.hook.ts` carries a HAND-COPIED mirror of this table\n * and cannot import it: L2 hook bodies run body-only in the QuickJS sandbox,\n * so a module constant resolves at authoring time and arrives as `undefined`\n * at runtime (see `_line-item-price-fill.ts`, and the same forced duplication\n * behind `test/priority-rank-parity.test.ts`). `src/service/data/service.seed.ts`\n * imports this module for real \u2014 seeds are authored-time data and hooks do not\n * run over them, so the seeded due dates have to be right on arrival.\n *\n * `test/case-sla-matrix.test.ts` is what keeps the two copies honest: it pins\n * all sixteen cells by DRIVING the shipped hook handler, so changing a cell in\n * either place without the other fails the suite.\n */\n\n/** The four `crm_account.tier` options, tightest service level first. */\nexport const CASE_SLA_TIERS = ['strategic', 'enterprise', 'mid_market', 'smb'] as const;\nexport type CaseSlaTier = (typeof CASE_SLA_TIERS)[number];\n\n/** The four `crm_case.priority` options that carry a clock. */\nexport const CASE_SLA_PRIORITIES = ['critical', 'high', 'medium', 'low'] as const;\nexport type CaseSlaPriority = (typeof CASE_SLA_PRIORITIES)[number];\n\n/**\n * Tier used when the case names no account, or the account's tier is blank, or\n * the reader cannot see the account row (guest intake through the web form is\n * the ordinary case \u2014 it can create a case and read nothing else).\n *\n * `smb` is the loosest column AND the `defaultValue` the account object already\n * declares for `tier`, so an unreadable account is treated exactly like an\n * account nobody has classified. Erring loose is the safe direction: a deadline\n * invented tighter than the customer's contract would manufacture breaches out\n * of a permission error.\n */\nexport const CASE_SLA_DEFAULT_TIER: CaseSlaTier = 'smb';\n\n/** Calendar hours from case creation to `sla_due_date`, by priority and account tier. */\nexport const CASE_SLA_CALENDAR_HOURS: Record<CaseSlaPriority, Record<CaseSlaTier, number>> = {\n  //           strategic  enterprise  mid_market  smb\n  critical: { strategic: 4, enterprise: 4, mid_market: 4, smb: 4 },\n  high: { strategic: 6, enterprise: 8, mid_market: 8, smb: 8 },\n  medium: { strategic: 24, enterprise: 36, mid_market: 48, smb: 48 },\n  low: { strategic: 96, enterprise: 120, mid_market: 168, smb: 168 },\n};\n\n/** Look a cell up with the documented fallbacks. Unknown priority \u21D2 no clock. */\nexport function caseSlaCalendarHours(priority: string, tier?: string | null): number | undefined {\n  const row = CASE_SLA_CALENDAR_HOURS[priority as CaseSlaPriority];\n  if (!row) return undefined;\n  return row[tier as CaseSlaTier] ?? row[CASE_SLA_DEFAULT_TIER];\n}\n\n/**\n * THE BREACH RULE (#2070): a case breached its SLA when its `sla_due_date` is\n * STRICTLY before the instant its clock stopped. Both arguments are read on one\n * clock \u2014 epoch milliseconds, or hours after the case was created \u2014 so a case\n * that stops exactly on its deadline met it. A case with no due date has no\n * clock, and is never judged at all: callers do not reach this without one.\n *\n * The clock stops when the case stops being live work \u2014 the first write that\n * takes it into `CLOSED_CASE_STATUSES` (`_case-assignment.ts`). Two writers\n * record a breach, one per side of that line, and both apply THIS rule:\n *\n *   - while the case is live: `case_sla_monitor` selects\n *     `sla_due_date: { $lt: NOW() }`, the same strict comparison, with \"now\" as\n *     the instant \u2014 but only on a deployment that runs scheduled work;\n *   - at the stop: `case_sla_defaults` (`case.hook.ts`) compares the due date\n *     with the instant of the resolving or closing write. It needs no schedule,\n *     so the closed-case surfaces \u2014 the `sla_performance` report and the\n *     `sla_compliance_rate` gauge \u2014 are right on every deployment.\n *\n * Neither writer ever clears the flag: a breach, once recorded, stays.\n *\n * The hook body spells this comparison inline, for the reason the matrix above\n * is mirrored there (no module scope in the sandbox). The seed derives the\n * flag of every settled demo case from this function, and\n * `test/case-sla-breach-on-close.test.ts` drives the LOWERED hook body against\n * it on both sides of the boundary, so the two cannot drift.\n */\nexport const caseSlaBreached = (dueAt: number, clockStoppedAt: number): boolean => dueAt < clockStoppedAt;\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/marketing/data/marketing.seed.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/marketing/data\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/marketing/data/marketing.seed.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\n/**\n * Marketing seeds \u2014 campaigns and their membership.\n *\n * Reads the sales seeds (`leads`, `opportunities`) because the campaign metric\n * block is DERIVED from them rather than typed in \u2014 see `campaignMetrics`.\n *\n * Split out of the former monolithic `src/data/index.ts` (#635). Seed doctrine\n * lives in `src/sales/data/_shared.ts`.\n */\nimport { defineSeed } from '@objectstack/spec/data';\nimport { cel } from '@objectstack/spec';\nimport { Campaign } from '../objects/campaign.object';\nimport { CampaignMember } from '../objects/campaign_member.object';\nimport { celDaysAgo } from '../../sales/data/_shared';\nimport { leads, opportunities } from '../../sales/data/sales.seed';\n\n// \u2500\u2500\u2500 Campaign membership \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n/**\n * Campaign members, keyed by campaign name.\n *\n * Membership is the ONLY path from a campaign to a lead \u2014 `crm_lead` has no\n * campaign field \u2014 so with this table empty (as it was before #591) every\n * campaign reported `num_sent` 0, `response_rate` 0% and no attributed leads\n * at all, whatever the campaign records claimed.\n *\n * Status vocabulary is restricted to the lifecycle values a writer actually\n * produces: `sent` (what the campaign_enrollment flow and the two\n * Add-to-Campaign actions stamp), `responded` (the `mark_responded` action)\n * and `unsubscribed`. The `opened` / `clicked` / `bounced` states and the\n * `first_opened_date` / `first_clicked_date` stamps were REMOVED from the\n * object under #597 \u2014 no email-tracking engine exists on the platform, so\n * nothing could ever have written them.\n *\n * `converted` is a live status with a real writer\n * (`campaign_lead_conversion_refresh` promotes a member when its lead's\n * `is_converted` flips) but is deliberately not SEEDED: no seeded lead is\n * converted \u2014 conversion is the lead_conversion flow's job at runtime \u2014 so a\n * `converted` member would be a member state no lead record backs up.\n */\ntype CampaignMemberSpec = {\n  /** Lead email (the lead dataset's externalId) \u2014 mutually exclusive with `contact`. */\n  readonly lead?: string;\n  /** Contact email (the contact dataset's externalId). */\n  readonly contact?: string;\n  readonly status: 'sent' | 'responded' | 'unsubscribed';\n  readonly addedDaysAgo: number;\n  /** Days ago the member responded. Required by `responded`, absent otherwise. */\n  readonly respondedDaysAgo?: number;\n};\n\nconst CAMPAIGN_MEMBERS: Record<string, readonly CampaignMemberSpec[]> = {\n  'Q3 Enterprise Email Nurture': [\n    { lead: 'noah.patel@vertexanalytics.example.com', status: 'responded', addedDaysAgo: 14, respondedDaysAgo: 9 },\n    { lead: 'maya.singh@bluepeaklogistics.example.com', status: 'sent', addedDaysAgo: 14 },\n    { lead: 'owen.becker@northwindenergy.example.com', status: 'responded', addedDaysAgo: 14, respondedDaysAgo: 11 },\n    { lead: 'sara.lopez@heliossolar.example.com', status: 'sent', addedDaysAgo: 14 },\n    { lead: 'leo.vance@cleancart.example.com', status: 'unsubscribed', addedDaysAgo: 14 },\n    { lead: 'iris.okafor@pulsehealth.example.com', status: 'sent', addedDaysAgo: 13 },\n    { lead: 'ravi.mehta@foundryrobotics.example.com', status: 'sent', addedDaysAgo: 13 },\n    { lead: 'tess.brown@latticeeducation.example.com', status: 'responded', addedDaysAgo: 13, respondedDaysAgo: 8 },\n    { contact: 'john.smith@acme.example.com', status: 'responded', addedDaysAgo: 14, respondedDaysAgo: 10 },\n    { contact: 'ethan.brooks@vertex.example.com', status: 'sent', addedDaysAgo: 14 },\n    { contact: 'priya.shah@lattice.example.com', status: 'responded', addedDaysAgo: 14, respondedDaysAgo: 7 },\n    { contact: 'rwilson@wayne.example.com', status: 'sent', addedDaysAgo: 13 },\n  ],\n  'Operations Platform Launch': [\n    { lead: 'jonas.holt@polarcargo.example.com', status: 'responded', addedDaysAgo: 11, respondedDaysAgo: 6 },\n    { lead: 'anya.volkov@redoakrealty.example.com', status: 'sent', addedDaysAgo: 11 },\n    { lead: 'theo.park@skylinemedia.example.com', status: 'sent', addedDaysAgo: 11 },\n    { lead: 'wren.garcia@maplebakerygroup.example.com', status: 'responded', addedDaysAgo: 10, respondedDaysAgo: 5 },\n    { lead: 'hugo.dubois@nimbusaerospace.example.com', status: 'sent', addedDaysAgo: 10 },\n    { contact: 'rwilson@wayne.example.com', status: 'responded', addedDaysAgo: 11, respondedDaysAgo: 7 },\n    { contact: 'marcus.reed@apexlogistics.example.com', status: 'sent', addedDaysAgo: 11 },\n    { contact: 'olivia.chen@northwind.example.com', status: 'sent', addedDaysAgo: 10 },\n    { contact: 'sarah.j@globex.example.com', status: 'sent', addedDaysAgo: 10 },\n  ],\n  'Developer Content Marketing Push': [\n    { lead: 'lena.fischer@graniteinsurance.example.com', status: 'responded', addedDaysAgo: 33, respondedDaysAgo: 27 },\n    { lead: 'kai.watanabe@coralreefhotels.example.com', status: 'sent', addedDaysAgo: 33 },\n    { lead: 'mira.costa@atlasconstruction.example.com', status: 'unsubscribed', addedDaysAgo: 33 },\n    { lead: 'pia.anand@citrinefinance.example.com', status: 'responded', addedDaysAgo: 32, respondedDaysAgo: 24 },\n    { lead: 'marco.ricci@auroratravel.example.com', status: 'sent', addedDaysAgo: 32 },\n    { lead: 'lisa.t@cloudfirst.example.com', status: 'responded', addedDaysAgo: 30, respondedDaysAgo: 21 },\n    { contact: 'ethan.brooks@vertex.example.com', status: 'responded', addedDaysAgo: 33, respondedDaysAgo: 19 },\n    { contact: 'mchen@initech.example.com', status: 'sent', addedDaysAgo: 33 },\n    { contact: 'john.smith@acme.example.com', status: 'sent', addedDaysAgo: 32 },\n    { contact: 'emily.d@starkmed.example.com', status: 'sent', addedDaysAgo: 32 },\n    { contact: 'sarah.j@globex.example.com', status: 'sent', addedDaysAgo: 30 },\n  ],\n  // Campaigns still in `planning` carry their invitation / registration list:\n  // the enrollment flow runs for `planning` and `in_progress` campaigns alike\n  // and stamps `sent` on enrollment, so a pre-launch target list looks exactly\n  // like this.\n  'Cloud Migration Webinar': [\n    { lead: 'dkim@edutechlabs.example.com', status: 'sent', addedDaysAgo: 4 },\n    { lead: 'alice@nextgenretail.example.com', status: 'sent', addedDaysAgo: 4 },\n    { lead: 'jonas.holt@polarcargo.example.com', status: 'sent', addedDaysAgo: 3 },\n    { lead: 'anya.volkov@redoakrealty.example.com', status: 'sent', addedDaysAgo: 3 },\n    { contact: 'mchen@initech.example.com', status: 'sent', addedDaysAgo: 4 },\n    { contact: 'marcus.reed@apexlogistics.example.com', status: 'sent', addedDaysAgo: 3 },\n  ],\n  'Executive AI Governance Roundtable': [\n    { contact: 'john.smith@acme.example.com', status: 'sent', addedDaysAgo: 6 },\n    { contact: 'rwilson@wayne.example.com', status: 'sent', addedDaysAgo: 6 },\n    { contact: 'ethan.brooks@vertex.example.com', status: 'sent', addedDaysAgo: 5 },\n    { contact: 'priya.shah@lattice.example.com', status: 'sent', addedDaysAgo: 5 },\n    { contact: 'emily.d@starkmed.example.com', status: 'sent', addedDaysAgo: 5 },\n  ],\n  'Partner Operations Roadshow': [\n    { lead: 'maya.singh@bluepeaklogistics.example.com', status: 'sent', addedDaysAgo: 7 },\n    { lead: 'ravi.mehta@foundryrobotics.example.com', status: 'sent', addedDaysAgo: 7 },\n    { contact: 'marcus.reed@apexlogistics.example.com', status: 'sent', addedDaysAgo: 6 },\n    { contact: 'olivia.chen@northwind.example.com', status: 'sent', addedDaysAgo: 6 },\n  ],\n  'SaaSCon 2026 Trade Show': [\n    { lead: 'theo.park@skylinemedia.example.com', status: 'sent', addedDaysAgo: 8 },\n    { lead: 'wren.garcia@maplebakerygroup.example.com', status: 'sent', addedDaysAgo: 8 },\n    { lead: 'hugo.dubois@nimbusaerospace.example.com', status: 'sent', addedDaysAgo: 7 },\n    { lead: 'marco.ricci@auroratravel.example.com', status: 'sent', addedDaysAgo: 7 },\n  ],\n};\n\n/**\n * The metric block the campaign metric hooks maintain, computed here from the\n * very same inputs they read: the membership table above and the opportunities\n * attributed via `crm_campaign`.\n *\n * Seeding these by hand is what made them wrong before \u2014 a hand-typed\n * `actual_revenue` survived untouched until something recomputed, at which\n * point the hook replaced it with the truth and the number \"mysteriously\"\n * changed. Deriving it here makes the first recompute a no-op instead: same\n * inputs, same arithmetic, same answer.\n *\n * That first recompute now arrives much sooner than it used to. Before #597 the\n * only writer fired on the `\u2192 completed` transition, so these seeded values\n * were the ONLY numbers a live campaign ever showed; today any membership,\n * attribution or conversion change refreshes them (see the four refresh hooks:\n * `campaign_metrics_refresh` and `campaign_member_metrics_refresh` in\n * `src/marketing/objects/`, `campaign_lead_conversion_refresh` and\n * `campaign_attribution_refresh` in `src/sales/objects/`). The derivation below\n * is therefore a mirror of their one inlined recompute and has to stay one \u2014\n * `test/seed-consistency.test.ts` checks the seeds against it.\n */\nconst campaignMetrics = (campaignName: string) => {\n  const members = CAMPAIGN_MEMBERS[campaignName] ?? [];\n  const leadKeys = new Set(members.map((m) => m.lead).filter((e): e is string => Boolean(e)));\n  const convertedLeads = leads.records.filter(\n    (l) => typeof l.email === 'string' && leadKeys.has(l.email) && l.is_converted === true,\n  ).length;\n  const attributed = opportunities.records.filter((o) => o.crm_campaign === campaignName);\n  const won = attributed.filter((o) => o.stage === 'closed_won');\n  return {\n    // \"Total members enrolled\" \u2014 campaign.hook.ts's single definition of num_sent.\n    num_sent: members.length,\n    // `responded` or `converted`, as in `computeCampaignMetrics`. The seed set\n    // holds no `converted` member (see the note on CAMPAIGN_MEMBERS), so the\n    // two predicates coincide on this data \u2014 spelled the narrow way because\n    // widening it here would suggest a seeded state that does not exist.\n    num_responses: members.filter((m) => m.status === 'responded').length,\n    num_leads: leadKeys.size,\n    num_converted_leads: convertedLeads,\n    num_opportunities: attributed.length,\n    num_won_opportunities: won.length,\n    actual_revenue: won.reduce((sum, o) => sum + (typeof o.amount === 'number' ? o.amount : 0), 0),\n  };\n};\n\n// \u2500\u2500\u2500 Campaigns \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\nexport const campaigns = defineSeed(Campaign, {\n  mode: 'upsert',\n  externalId: 'name',\n  records: [\n    {\n      name: 'Q3 Enterprise Email Nurture',\n      description: 'Multi-touch nurture for enterprise IT decision makers evaluating AI governance and analytics.',\n      type: 'email',\n      channel: 'email',\n      status: 'in_progress',\n      start_date: cel`daysAgo(15)`,\n      end_date: cel`daysFromNow(21)`,\n      budgeted_cost: 28000,\n      actual_cost: 14000,\n      expected_revenue: 560000,\n      target_size: 5000,\n      ...campaignMetrics('Q3 Enterprise Email Nurture'),\n      landing_page_url: 'https://acme.example.com/lp/enterprise-q3',\n      is_active: true,\n    },\n    {\n      name: 'Executive AI Governance Roundtable',\n      description: 'A live executive roundtable on operating AI agents with governance, auditability and trust.',\n      type: 'conference',\n      channel: 'events',\n      status: 'planning',\n      start_date: cel`daysFromNow(2)`,\n      end_date: cel`daysFromNow(3)`,\n      budgeted_cost: 22000,\n      expected_revenue: 320000,\n      target_size: 120,\n      ...campaignMetrics('Executive AI Governance Roundtable'),\n      is_active: true,\n    },\n    {\n      name: 'Cloud Migration Webinar',\n      description: 'A technical webinar on modernizing customer operations and data workflows in the cloud.',\n      type: 'webinar',\n      channel: 'digital',\n      status: 'planning',\n      start_date: cel`daysFromNow(6)`,\n      end_date: cel`daysFromNow(8)`,\n      budgeted_cost: 18000,\n      expected_revenue: 360000,\n      target_size: 1500,\n      ...campaignMetrics('Cloud Migration Webinar'),\n      landing_page_url: 'https://acme.example.com/webinars/cloud-migration',\n      is_active: true,\n    },\n    {\n      name: 'Operations Platform Launch',\n      description: 'Launch campaign for the operations platform, pairing product content with customer proof points.',\n      type: 'content',\n      channel: 'digital',\n      status: 'in_progress',\n      // Was `daysFromNow(12)` \u2014 an `in_progress` campaign that had not started\n      // yet, which no attribution can be consistent with (#591).\n      start_date: cel`daysAgo(12)`,\n      end_date: cel`daysFromNow(14)`,\n      budgeted_cost: 36000,\n      actual_cost: 12000,\n      expected_revenue: 480000,\n      target_size: 8000,\n      ...campaignMetrics('Operations Platform Launch'),\n      landing_page_url: 'https://acme.example.com/launch/operations-platform',\n      is_active: true,\n    },\n    {\n      name: 'Partner Operations Roadshow',\n      description: 'Joint regional sessions with strategic partners for operations and IT leaders.',\n      type: 'partner',\n      channel: 'partner',\n      status: 'planning',\n      start_date: cel`daysFromNow(19)`,\n      end_date: cel`daysFromNow(22)`,\n      budgeted_cost: 48000,\n      expected_revenue: 720000,\n      target_size: 600,\n      ...campaignMetrics('Partner Operations Roadshow'),\n      is_active: true,\n    },\n    {\n      name: 'SaaSCon 2026 Trade Show',\n      description: 'A focused booth, executive dinner and customer-story program at the SaaSCon industry conference.',\n      type: 'trade_show',\n      channel: 'events',\n      status: 'planning',\n      start_date: cel`daysFromNow(27)`,\n      end_date: cel`daysFromNow(30)`,\n      budgeted_cost: 75000,\n      expected_revenue: 1200000,\n      target_size: 3000,\n      ...campaignMetrics('SaaSCon 2026 Trade Show'),\n      is_active: true,\n    },\n    {\n      name: 'Developer Content Marketing Push',\n      description: 'Technical blog posts, video tutorials and developer community engagement completed last month.',\n      type: 'content',\n      channel: 'digital',\n      status: 'completed',\n      start_date: cel`daysAgo(35)`,\n      end_date: cel`daysAgo(4)`,\n      budgeted_cost: 40000,\n      actual_cost: 25000,\n      expected_revenue: 250000,\n      target_size: 10000,\n      ...campaignMetrics('Developer Content Marketing Push'),\n      landing_page_url: 'https://acme.example.com/developers',\n      is_active: true,\n    },\n  ]\n});\n\n/**\n * Campaign members are seeded as TWO datasets over one object, split by which\n * side of the junction is populated.\n *\n * Not a stylistic choice: the object has no single natural key (its only text\n * identity is a runtime-owned autonumber), so identity has to be the composite\n * of campaign + member. The loader builds a composite key by joining the\n * per-field values and returns an EMPTY key \u2014 no dedupe, so a replay boot\n * re-inserts every row \u2014 as soon as ANY component is null. `crm_lead` and\n * `crm_contact` are mutually exclusive by design, so a single\n * `['crm_campaign', 'crm_lead', 'crm_contact']` key would be blank on every\n * row. Splitting the rows by member type gives each dataset a key whose parts\n * are all present.\n */\nconst memberRecords = (\n  kind: 'lead' | 'contact',\n): Array<Record<string, unknown>> =>\n  Object.entries(CAMPAIGN_MEMBERS).flatMap(([campaign, members]) =>\n    members\n      .filter((m) => (kind === 'lead' ? m.lead : m.contact))\n      .map((m) => ({\n        crm_campaign: campaign,\n        ...(kind === 'lead' ? { crm_lead: m.lead } : { crm_contact: m.contact }),\n        status: m.status,\n        added_date: celDaysAgo(m.addedDaysAgo),\n        // `has_responded` / `response_date` track the `responded` status\n        // exactly \u2014 a responded member with no response date is a shape the\n        // response-tracking surfaces cannot render.\n        has_responded: m.status === 'responded',\n        ...(m.respondedDaysAgo !== undefined ? { response_date: celDaysAgo(m.respondedDaysAgo) } : {}),\n      })),\n  );\n\nexport const campaignMembersFromLeads = defineSeed(CampaignMember, {\n  mode: 'upsert',\n  externalId: ['crm_campaign', 'crm_lead'],\n  records: memberRecords('lead'),\n});\n\nexport const campaignMembersFromContacts = defineSeed(CampaignMember, {\n  mode: 'upsert',\n  externalId: ['crm_campaign', 'crm_contact'],\n  records: memberRecords('contact'),\n});\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/objectstack.composition.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/objectstack.composition.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\n/**\n * The four packages, collected into the two package stacks this artifact\n * carries.\n *\n * A directory under `src/` IS a package (ADR-0130, `module-split-plan.md`\n * items 4\u20139). Two of them are packages of the ARTIFACT as well:\n *\n *   - `src/sales/` \u2014 `app.objectstack.hotcrm`, the `type: 'app'` package this\n *     artifact takes its identity from. Its `defineStack` is the factory in\n *     `src/sales/index.ts`, and this file hands it its collections: the sales\n *     barrels plus those of `src/revenue/` and `src/marketing/`, which stay\n *     directories of the app package until they get packaging cards of their\n *     own, and which a file under `src/sales/` may not import.\n *   - `src/service/` \u2014 `app.objectstack.hotcrm.service`, a `type: 'module'`.\n *     Its `defineStack` is `src/service/index.ts`, which assembles its own\n *     collections from its own barrels; this file hands it only the seed rows\n *     the composition knob selects.\n *\n * `objectstack.config.ts` composes the two into ONE release artifact. This file\n * builds them, because it is the one place that may see every package AND carry\n * named exports.\n *\n * ## Why this is not simply the top of `objectstack.config.ts`\n *\n * That file may carry NO named export. `objectstack build` reads the config\n * module and parses it against `ObjectStackDefinitionSchema`, which is\n * `.strict`, so any export beside the default is an unrecognised top-level\n * stack key and the build fails by name. Measured on the pre-move tree, not\n * assumed: appending `export const ProbeNamedExport = [1, 2, 3];` to the\n * unmodified `objectstack.config.ts` at 590b095 fails `pnpm build` with\n * \"Unrecognized key(s) on this stack definition: `ProbeNamedExport`\".\n *\n * Two kinds of value need to be importable, so they live here:\n *\n *   - the AUTHORED collections \u2014 about a dozen suites assert against them\n *     upstream of `defineStack()`, which is the only side of that call where\n *     `CrmSeedData` and the stack's `data` are distinguishable at all (see the\n *     note in `test/saas-composition.test.ts`);\n *   - the two BUILT package stacks \u2014 a multi-package artifact carries every\n *     collection once, inside its package's body in `packages[]`, and no longer\n *     beside them at the top level (ADR-0130 D4, 2026-09-22 addendum), so a\n *     suite that reads \"every object of the app\" composes these two itself.\n *\n * ## Order\n *\n * Registration order within a collection is a property of each PACKAGE now:\n * the artifact carries each package's collections in its own body, in the order\n * that package's stack was handed them. Two orders stay load-bearing and are\n * stated explicitly below \u2014 `CrmSeedData`, the replay order a seed row's\n * natural-key lookups were written against, and the hand-ordered lists\n * (`appHooks`, `appFlows`, `appSkills`, `appSharingRules`) that keep the order\n * the single-tree barrels had. Everything else uses `byExportName()` \u2014 a\n * module namespace enumerates its exports in ascending code-unit order of the\n * export NAME, so merging several barrels and sorting by that name is the same\n * rule one barrel already applied, rather than a new one.\n */\n\nimport { createHotCrmAppStack } from './src/sales/index.js';\nimport {\n  createHotCrmServiceStack, serviceHooks, serviceFlows, serviceSkills, serviceSharingRules,\n} from './src/service/index.js';\n\nimport * as salesObjects from './src/sales/objects/index.js';\nimport * as revenueObjects from './src/revenue/objects/index.js';\nimport * as marketingObjects from './src/marketing/objects/index.js';\n\nimport * as salesActions from './src/sales/actions/index.js';\nimport * as marketingActions from './src/marketing/actions/index.js';\n\nimport * as salesDashboards from './src/sales/dashboards/index.js';\n\nimport * as salesDatasets from './src/sales/datasets/index.js';\nimport * as revenueDatasets from './src/revenue/datasets/index.js';\n\nimport * as salesReports from './src/sales/reports/index.js';\n\nimport * as mappings from './src/sales/mappings/index.js';\nimport * as apps from './src/sales/apps/index.js';\nimport * as profiles from './src/sales/profiles/index.js';\nimport * as translations from './src/sales/translations/index.js';\n\nimport * as salesViews from './src/sales/views/index.js';\nimport * as revenueViews from './src/revenue/views/index.js';\nimport * as marketingViews from './src/marketing/views/index.js';\n\nimport * as salesPages from './src/sales/pages/index.js';\n\nimport * as salesEmailTemplates from './src/sales/email-templates/index.js';\nimport * as revenueEmailTemplates from './src/revenue/email-templates/index.js';\n\nimport { SystemAdminProfile } from './src/sales/profiles/index.js';\nimport { TenantAdminProfile } from './src/sales/profiles/tenant-admin.profile.js';\n\n// Hooks \u2014 one barrel per directory, assembled below in source-file-name order.\nimport {\n  accountHook, contactHook, eventHook, forecastHook, leadHook,\n  leadCampaignMetricsHook, opportunityHook, opportunityCampaignMetricsHook, taskHook,\n} from './src/sales/objects/hooks.js';\nimport {\n  contractHook, opportunityLineItemHook, productHook, quoteHook, quoteLineItemHook,\n} from './src/revenue/objects/hooks.js';\nimport { campaignHook, campaignMemberHook } from './src/marketing/objects/hooks.js';\n\n// Flows \u2014 the registration order the single `allFlows` array used to hold.\nimport {\n  ContactWelcomeFlow, ForecastSnapshotFlow, LeadAssignmentFlow,\n  AccountApprovalFlow,\n  LeadConversionFlow, LeadConversionApprovalFlow,\n  OpportunityApprovalFlow, OpportunityApprovalOnCreateFlow,\n  OpportunityStatusChangeApprovalFlow, OpportunityQualificationApprovalFlow,\n  OpportunityStagnationFlow, OpportunityWonAlertFlow, ScheduleFollowUpFlow,\n  TaskDueReminderFlow, TaskUrgentAlertFlow, BillingHandoffClosedWonFlow,\n} from './src/sales/flows/index.js';\nimport {\n  QuoteGenerationFlow, ContractRenewalFlow, QuoteExpirationFlow, ContractExpirationFlow,\n  BillingHandoffContractActivatedFlow,\n} from './src/revenue/flows/index.js';\nimport {\n  CampaignEnrollmentFlow, CampaignLeadMemberEnrollFlow, CampaignContactMemberEnrollFlow,\n  CampaignCompletionFlow,\n} from './src/marketing/flows/index.js';\n\n// Skills \u2014 likewise.\nimport {\n  LeadQualificationSkill, EmailDraftingSkill, RevenueForecastingSkill,\n  Customer360Skill, LiveDataSkill,\n} from './src/sales/skills/index.js';\n\nimport {\n  AccountTeamSharingRule, TerritorySharingRules,\n  OpportunitySalesSharingRule, OpportunityExecutiveSharingRule,\n  CrmPositions,\n} from './src/sales/sharing/index.js';\nimport { CampaignLeadershipSharingRules } from './src/marketing/sharing/index.js';\n\nimport type { EmailTemplateDefinition } from '@objectstack/spec/system';\n\n// Seed rows \u2014 the replay order lives in `CrmSeedData` below.\nimport type { HotCrmComposition } from './src/sales/data/index.js';\nimport {\n  resolveComposition,\n  accounts, contacts, leads, opportunities,\n  tasks, events, eventAttendeesFromContacts, eventAttendeesFromLeads, leadInteractionPointers, forecasts,\n} from './src/sales/data/index.js';\nimport { products, opportunityLineItems, contracts, quotes, quoteLineItems } from './src/revenue/data/index.js';\nimport { cases, knowledgeArticles } from './src/service/data/index.js';\nimport { campaigns, campaignMembersFromLeads, campaignMembersFromContacts } from './src/marketing/data/index.js';\n\n/**\n * One registration array out of the merged per-package barrels of a metadata\n * type, ordered by EXPORT NAME.\n *\n * `Object.values(<module namespace>)` \u2014 what this file did for each of these\n * collections while there was one barrel per type \u2014 enumerates in ascending\n * code-unit order of the export name, not in the barrel's declaration order.\n * (Measured on the pre-move artifact: `src/pages/index.ts` declared\n * `LeadDetailPage` first and the artifact's `pages[]` still began with\n * `account_detail_page`.) So sorting the merged entries by export name is not\n * a new ordering rule \u2014 it is the same one, applied across four namespaces\n * instead of one.\n *\n * The namespaces are spread into one object at the call site, which is also\n * what keeps the entries TYPED: each barrel is its own module namespace with\n * its own element union, so passing them as separate arguments makes\n * TypeScript infer `T` from the first one alone and reject the rest. A\n * duplicate export name across two packages would collide in that spread \u2014 it\n * could not happen while the exports shared one namespace either, and it is a\n * compile error the day two packages export the same name.\n */\nconst byExportName = <T>(merged: Record<string, T>): T[] =>\n  Object.entries(merged)\n    .sort(([a], [b]) => (a < b ? -1 : a > b ? 1 : 0))\n    .map(([, value]) => value);\n\n/* \u2500\u2500\u2500 The app package's collections \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500 */\n\n/**\n * Every CRM lifecycle hook the APP PACKAGE registers, in the order\n * `src/hooks/index.ts` registered them (by hook source file name) \u2014 see the\n * ORDER note at the top of this file.\n *\n * `*.hook.ts` files sit beside the `*.object.ts` they name, one directory each,\n * which is what enforces ADR-0130 R4. Two entries therefore come from a\n * different directory than the campaign metadata they maintain:\n * `opportunityCampaignMetricsHook` and `leadCampaignMetricsHook` are attached\n * to `crm_opportunity` and `crm_lead`, so they live in sales. The three service\n * hooks register with the service package (`serviceHooks`).\n */\nexport const appHooks = [\n  accountHook,\n  campaignHook,\n  opportunityCampaignMetricsHook,\n  leadCampaignMetricsHook,\n  campaignMemberHook,\n  contactHook,\n  contractHook,\n  eventHook,\n  forecastHook,\n  leadHook,\n  opportunityHook,\n  opportunityLineItemHook,\n  productHook,\n  quoteHook,\n  quoteLineItemHook,\n  taskHook,\n].flatMap((entry) => (Array.isArray(entry) ? entry : [entry]));\n\n/**\n * Every flow the app package registers, in the order the single `allFlows`\n * array registered them. The seven case flows register with the service\n * package (`serviceFlows`).\n */\nexport const appFlows = [\n  CampaignEnrollmentFlow,\n  CampaignLeadMemberEnrollFlow,\n  CampaignContactMemberEnrollFlow,\n  AccountApprovalFlow,\n  LeadConversionFlow,\n  LeadConversionApprovalFlow,\n  ScheduleFollowUpFlow,\n  OpportunityApprovalFlow,\n  OpportunityApprovalOnCreateFlow,\n  OpportunityStatusChangeApprovalFlow,\n  OpportunityQualificationApprovalFlow,\n  QuoteGenerationFlow,\n  ContractRenewalFlow,\n  OpportunityStagnationFlow,\n  ForecastSnapshotFlow,\n  LeadAssignmentFlow,\n  CampaignCompletionFlow,\n  QuoteExpirationFlow,\n  ContractExpirationFlow,\n  ContactWelcomeFlow,\n  OpportunityWonAlertFlow,\n  TaskUrgentAlertFlow,\n  TaskDueReminderFlow,\n  BillingHandoffClosedWonFlow,\n  BillingHandoffContractActivatedFlow,\n];\n\n/**\n * Every skill the app package registers \u2014 the cross-domain ones are all here.\n * The case-triage skill registers with the service package (`serviceSkills`).\n */\nexport const appSkills = [\n  LeadQualificationSkill,\n  EmailDraftingSkill,\n  RevenueForecastingSkill,\n  Customer360Skill,\n  LiveDataSkill,\n];\n\n/** Every object definition the app package registers. */\nexport const appObjects = byExportName({\n  ...salesObjects, ...revenueObjects, ...marketingObjects,\n});\n\n/** Every UI / AI-callable action it registers. */\nexport const appActions = byExportName({ ...salesActions, ...marketingActions });\n\n/** Its dashboards \u2014 the cross-domain ones included (plan item 4). */\nexport const appDashboards = byExportName({ ...salesDashboards });\n\n/** Its analytics datasets (ADR-0021). */\nexport const appDatasets = byExportName({ ...salesDatasets, ...revenueDatasets });\n\n/** Its reports. */\nexport const appReports = byExportName({ ...salesReports });\n\n/** Its list-view groups. */\nexport const appViews = byExportName({\n  ...salesViews, ...revenueViews, ...marketingViews,\n});\n\n/** Its page layouts \u2014 `home`, `app_launcher` and `utility_bar` among them. */\nexport const appPages = byExportName({ ...salesPages });\n\n/** Every import mapping \u2014 sales only; nothing else authors one. */\nexport const appMappings = byExportName({ ...mappings });\n\n/** The app itself, and its navigation GROUPS (the containers modules aim at). */\nexport const appApps = byExportName({ ...apps });\n\n/** The locale packs \u2014 whole in the app package (plan item 4), service labels included. */\nexport const appTranslations = byExportName({ ...translations });\n\n/**\n * Every `sys_email_template` row the app package registers \u2014 the localizable\n * content path for `notify` (#9205). The service package registers its own two\n * case templates, beside the flows that send them.\n *\n * A package barrel exports ONE symbol carrying that package's rows, so\n * `byExportName()` orders them by export name and `.flat()` produces the\n * single array `defineStack({ emailTemplates })` takes. Reaching the package\n * barrel IS reaching the registration here: no hand-kept ordered list, because\n * nothing about the order is load-bearing \u2014 a row is resolved by\n * `(name, locale)` at delivery time, never by position.\n */\nexport const appEmailTemplates = byExportName<EmailTemplateDefinition[]>({\n  ...salesEmailTemplates, ...revenueEmailTemplates,\n}).flat();\n\n/**\n * The permission sets, as the NAMESPACE rather than an array: the SaaS\n * composition filters them by identity below, which needs `Object.values()`\n * over the same object the named exports come from.\n *\n * They stay WHOLE in the app package (ADR-0130 addendum, 2026-09-02), service\n * grants included: a permission set is a role a person holds across the whole\n * product, not a property of one module.\n */\nexport const allProfiles = profiles;\n\nexport { SystemAdminProfile, TenantAdminProfile };\n\n/**\n * The sharing rules the app package registers, in the order this app has\n * always registered them. The three CASE rules are authored against\n * `crm_case` and register with the service package (`serviceSharingRules`).\n */\nexport const appSharingRules = [\n  AccountTeamSharingRule,\n  OpportunitySalesSharingRule,\n  OpportunityExecutiveSharingRule,\n  ...TerritorySharingRules,\n  ...CampaignLeadershipSharingRules,\n];\n\nexport { CrmPositions };\n\n/* \u2500\u2500\u2500 Artifact-wide sweeps \u2014 what the suites read \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500 */\n\n/**\n * Every hook in the ARTIFACT, both packages.\n *\n * The suites that sweep hooks (`test/refusal-envelope.test.ts`,\n * `test/runtime-coverage.test.ts`, `test/hook-write-shape.test.ts`,\n * `test/action-sandbox.test.ts`, `test/territory-single-source.test.ts`) are\n * about the app a customer installs, which is the whole artifact \u2014 so they keep\n * reading one list, assembled here from each package's own.\n */\nexport const allHooks = [...appHooks, ...serviceHooks];\n\n/** Every flow in the artifact, both packages \u2014 same reason as {@link allHooks}. */\nexport const allFlows = [...appFlows, ...serviceFlows];\n\n/** Every skill in the artifact, both packages \u2014 same reason as {@link allHooks}. */\nexport const allSkills = [...appSkills, ...serviceSkills];\n\n/** Every sharing rule in the artifact, both packages \u2014 same reason as {@link allHooks}. */\nexport const CrmSharingRules = [...appSharingRules, ...serviceSharingRules];\n\n\n/**\n * Ownership and CRM positions are NOT seeded here \u2014 they can't be.\n *\n * A seed can't name a user. Lookup values are resolved against the target's\n * externalId and that only works for objects in the app's own graph, so\n * `owner_id: 'Dev Admin'` would store the literal string rather than an id (verified:\n * a `sys_user_position` row seeded that way is unmatchable by the real user\n * id), and `cel\\`os.user.id\\`` inside a seed evaluates to nothing. The id does\n * not exist until first boot.\n *\n * The PLATFORM does it, at the only moment it can: when the seed settles,\n * `@objectstack/plugin-security` re-runs its seed-ownership claim on\n * `app:seeded` and hands every ownerless row of every object carrying\n * `owner_id` to the first platform administrator (objectstack#17872, shipped in\n * 17.6.0). No HotCRM flow is involved. The `demo_bootstrap` sweep that used\n * to do this every ten minutes was retired once a fresh boot measured that\n * claim leaving all twelve seeded owner-scoped objects at zero ownerless rows\n * with the sweep disabled (#1892).\n *\n * `owner_id` is the app's ONE ownership column (#548 retired the app-authored\n * `owner` lookup that used to sit beside it \u2014 the #622 split). Seed writes run\n * under `{ isSystem: true }`, which short-circuits the security middleware, so\n * its insert-time auto-stamp of `owner_id` never fires \u2014 \"seeds either declare\n * those fields explicitly per record\" \u2014 and per the paragraph above these seeds\n * cannot declare it. So a seeded row reaches the database owned by nobody\n * (`owner_id` null) until that claim runs. Nothing here should grow an\n * `owner_id` seed value to paper over that: the platform claim is the\n * mechanism.\n */\n\n/**\n * All CRM seed datasets, in REPLAY ORDER \u2014 the ARTIFACT's whole seed union.\n *\n * This list assembles here rather than in a package barrel for two reasons,\n * and the second is the binding one. It names rows from all four packages, and\n * no `src/` file may reach sideways into another package (plan item 7). And\n * the order is load-bearing \u2014 rows resolve their lookups against rows seeded\n * earlier, and the order interleaves the packages (products between\n * opportunities and tasks, contracts after campaign members), so it is not\n * recoverable by concatenating four per-package lists in any package order.\n * It is exactly the order `CrmSeedData` has always had. About ten suites read\n * this union; {@link seedDataFor} is what the two package stacks register.\n */\nexport const CrmSeedData = [\n  accounts,\n  contacts,\n  leads,\n  opportunities,\n  products,\n  opportunityLineItems,\n  tasks,\n  cases,\n  // Events come after the five objects their `related_to_*` lookups resolve\n  // against (accounts, contacts, leads, opportunities, cases); the attendee\n  // junctions come after the events they hang off.\n  events,\n  eventAttendeesFromContacts,\n  eventAttendeesFromLeads,\n  leadInteractionPointers,\n  campaigns,\n  campaignMembersFromLeads,\n  campaignMembersFromContacts,\n  contracts,\n  quotes,\n  quoteLineItems,\n  forecasts,\n  knowledgeArticles,\n];\n\n/**\n * The seed datasets a SaaS tenant gets: the product CATALOGUE, and nothing else.\n *\n * Maintainer ruling, 2026-08-27 (objectstack#12701, quoted untranslated):\n * \u300C\u6BCF\u4E2A\u79DF\u6237\u5E94\u8BE5\u5404\u81EA\u4F7F\u7528\u5404\u81EA\u7684\u6570\u636E\u5427\u300D \u2014 every tenant uses its own data, the\n * product catalogue included; and \u300C\u79CD\u5B50\u4E5F\u4E0D\u5E94\u8BE5\u662F\u5168\u5C40\u7684\u5440\uFF0C\u56E0\u4E3A\u79CD\u5B50\u6570\u636E\u4E0D\u540C\u7684\u5BA2\u6237\n * \u90FD\u662F\u8981\u6539\u7684\u5440\uFF0C\u53EA\u662F\u53C2\u8003\u5440\uFF0C\u79DF\u6237\u8981\u81EA\u5DF1\u5220\u9664\u5440\u300D \u2014 a seed is a per-tenant\n * REFERENCE copy the tenant edits and deletes.\n *\n * The platform already replays per tenant: `@objectstack/runtime`'s\n * `seed-replayer` replays the registered dataset union into each newly founded\n * organization stamped with that organization's id. What it has no notion of is\n * WHICH families to replay \u2014 it always replays the whole union \u2014 so the\n * selection is made HERE, once, at composition time. That is also the shape the\n * ruling wants: uniform for every tenant, with no per-tenant opt-in mechanism\n * to author, mis-set, or support.\n *\n * Why the catalogue and only the catalogue:\n *\n *  - A catalogue is the one family that is genuinely a starting point. A new\n *    tenant needs priceable products before they can quote anything, and the\n *    rows are theirs to rename, re-price and delete.\n *  - `sales` / `service` / `marketing` / `revenue` are STORYTELLING: Acme\n *    Corporation's pipeline, nine escalated cases, a finished campaign. Landing\n *    those in a paying tenant's org is not a helpful head start, it is someone\n *    else's data in their CRM.\n *  - It is also the family with no outgoing references, so the shrink cannot\n *    strand a lookup: `src/revenue/data/catalog.seed.ts` resolves nothing against\n *    another object, while every other family points at accounts, contacts or products\n *    by natural key.\n *\n * \u26D4 Not a place to grow a \"starter data\" bundle. A family added here ships\n * into every tenant of every SaaS deployment; the bar is \"a tenant cannot\n * operate without it\", not \"it looks nice on day one\".\n */\nexport const SaasTenantSeedData = [products];\n\n/**\n * The seed families of the SERVICE package \u2014 the rows whose object it owns.\n *\n * \u26A0\uFE0F A seed family is REGISTERED BY THE PACKAGE THAT OWNS ITS OBJECT. Named\n * here, beside the replay order it is cut out of, so the two cannot drift\n * apart: the split is a property of {@link CrmSeedData}.\n */\nexport const ServiceSeedData = [cases, knowledgeArticles];\n\n/** Everything else \u2014 the app package's own families, in {@link CrmSeedData} order. */\nexport const AppSeedData = CrmSeedData.filter((family) => !ServiceSeedData.includes(family));\n\n/**\n * The seed datasets each package registers under a composition.\n *\n * The SaaS selection is still made once, here: a tenant gets the product\n * catalogue and nothing else, so the service package registers no rows at all\n * in that shape. See {@link SaasTenantSeedData} for why.\n */\nexport const seedDataFor = (\n  composition: HotCrmComposition,\n): { app: typeof CrmSeedData; service: typeof CrmSeedData } =>\n  composition === 'saas'\n    ? { app: SaasTenantSeedData, service: [] }\n    : { app: AppSeedData, service: ServiceSeedData };\n\n// \u2500\u2500\u2500 Which SHAPE of HotCRM this build assembles (#1361) \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n//\n// `default` (unset, or `HOTCRM_COMPOSITION=default`) is the community app and\n// is byte-for-byte what it always was \u2014 every field below that a composition\n// touches falls through to the same value it had before this knob existed.\n// `HOTCRM_COMPOSITION=saas` assembles the shape a multi-org operator deploys on\n// the enterprise runtime under a walled tenancy posture; an unrecognised value\n// throws here rather than quietly assembling the wrong app (see\n// `resolveComposition`).\n//\n// The knob is resolved ONCE, here, and handed to the package stacks already\n// applied. It is deliberately COMPOSITION-time and uniform. The platform's\n// `seed-replayer` gives every newly founded organization its own private copy\n// of the registered dataset union (maintainer ruling 2026-08-27,\n// objectstack#12701: \u300C\u79CD\u5B50\u4E5F\u4E0D\u5E94\u8BE5\u662F\u5168\u5C40\u7684\u5440 \u2026\u53EA\u662F\u53C2\u8003\u5440\uFF0C\u79DF\u6237\u8981\u81EA\u5DF1\u5220\u9664\u5440\u300D),\n// but it has no per-family or per-tenant selection and none is chartered \u2014 so\n// WHAT gets replayed is decided once, here, for every tenant alike.\n//\n// Two things change, and nothing else. There is no runtime branch anywhere in\n// `src/`, and no enterprise package is imported: an artifact built either way\n// runs on the community runtime. Both shapes register the same flows: the one\n// flow the SaaS shape used to drop, the `demo_bootstrap` ownership sweep, is\n// retired from the app (#1892) \u2014 the platform claims seeded rows itself.\n//\n//  1. `data` \u2014 the catalogue family only, so the service package registers\n//     none. See `SaasTenantSeedData`.\n//     `demo-staffing` needs no exclusion \u2014 `src/sales/sharing/demo-staffing.ts` is\n//     deliberately not exported from `src/sales/sharing/index.js` and not registered\n//     in any composition (#640, pinned by `test/demo-staffing.test.ts`).\n//  2. `permissions` \u2014 `system_admin` is replaced by `tenant_admin`, which holds\n//     org-scoped `manage_org_users` instead of platform-scope `manage_users`.\n//     Read `src/sales/profiles/tenant-admin.profile.ts` for the full audit, including\n//     what `view_all_data` / `modify_all_data` mean under the wall.\nconst composition = resolveComposition();\nconst isSaas = composition === 'saas';\nconst seedData = seedDataFor(composition);\n\n/**\n * Permission sets this composition registers. Filtered by IDENTITY, not by name\n * string, so a rename cannot silently turn the substitution into a no-op.\n */\nconst compositionPermissions = isSaas\n  ? [...Object.values(allProfiles).filter((set) => set !== SystemAdminProfile), TenantAdminProfile]\n  : Object.values(allProfiles);\n\n/* \u2500\u2500\u2500 The two package stacks `objectstack.config.ts` composes \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500 */\n\n/** `app.objectstack.hotcrm.service` \u2014 see `src/service/index.ts`. */\nexport const serviceStack = createHotCrmServiceStack({ data: seedData.service });\n\n/**\n * `app.objectstack.hotcrm` \u2014 see `src/sales/index.ts`, including why it is\n * handed `artifactObjects`: its permission sets stay whole here and grant on\n * the service package's objects too.\n */\nexport const appStack = createHotCrmAppStack(\n  {\n    objects: appObjects,\n    actions: appActions,\n    dashboards: appDashboards,\n    datasets: appDatasets,\n    reports: appReports,\n    // Reusable import projections (#603). Referenced by name from the import\n    // endpoint \u2014 `mappingName: 'crm_account_import'` \u2014 so a customer's own\n    // spreadsheet loads without per-column mapping by hand. Templates:\n    // `assets/import-templates/`.\n    mappings: appMappings,\n    flows: appFlows,\n    skills: appSkills,\n    permissions: compositionPermissions,\n    apps: appApps,\n    views: appViews,\n    pages: appPages,\n    // Approvals are modeled as `record_change` flows with `approval` nodes\n    // (ADR-0019); see src/sales/flows/opportunity-approval.flow.ts. The\n    // standalone `approvals` stack field was removed in ObjectStack 7.4.\n    // No `analyticsCubes`: datasets (ADR-0021) are the semantic layer \u2014 the\n    // analytics service compiles each dataset into its cube internally, and a\n    // second hand-written cube layer only duplicates and drifts.\n\n    hooks: appHooks,\n\n    data: seedData.app,\n\n    translations: appTranslations,\n\n    // The localizable content path for `notify` (#9205). A node names a template\n    // and supplies its `templateData`; the delivery path resolves\n    // `(name, locale)` against these rows PER RECIPIENT, after fan-out \u2014 the\n    // recipient's own `sys_user.locale` when set, else `i18n.defaultLocale` \u2014\n    // so two people on one notification can read it in two languages.\n    emailTemplates: appEmailTemplates,\n\n    sharingRules: appSharingRules,\n    // ADR-0090 D3: positions are flat capability-distribution groups \u2014 the v1\n    // role hierarchy's parent links are gone (hierarchy belongs to the\n    // business-unit tree, which this app does not model).\n    positions: CrmPositions,\n  },\n  { artifactObjects: (serviceStack.objects ?? []).map((object) => object.name) },\n);\n"],
  "mappings": "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",
  "names": ["defineStack", "ObjectSchema", "Field", "P", "ObjectSchema", "Field", "P", "ObjectSchema", "Field", "F", "P", "ObjectSchema", "Field", "F", "P", "objects_exports", "ObjectSchema", "Field", "F", "ObjectSchema", "Field", "F", "ObjectSchema", "Field", "F", "ObjectSchema", "Field", "F", "P", "ObjectSchema", "Field", "ObjectSchema", "Field", "P", "ObjectSchema", "Field", "ObjectSchema", "Field", "ObjectSchema", "Field", "F", "P", "ObjectSchema", "Field", "F", "P", "ObjectSchema", "Field", "F", "P", "ObjectSchema", "Field", "F", "P", "ObjectSchema", "Field", "F", "P", "ObjectSchema", "Field", "F", "P", "ObjectSchema", "Field", "P", "ObjectSchema", "Field", "P", "objects_exports", "P", "P", "P", "P", "cel", "cel", "cel", "cel", "P", "cel", "P", "cel", "P", "P", "defineView", "defineView", "defineStack", "objects_exports", "ObjectSchema", "Field", "P", "ObjectSchema", "Field", "P", "ObjectSchema", "Field", "F", "P", "ObjectSchema", "Field", "F", "P", "ObjectSchema", "Field", "F", "P", "ObjectSchema", "Field", "F", "P", "ObjectSchema", "Field", "F", "P", "cel", "ObjectSchema", "Field", "F", "P", "cel", "ObjectSchema", "Field", "F", "P", "ObjectSchema", "Field", "F", "P", "objects_exports", "ObjectSchema", "Field", "F", "P", "ObjectSchema", "Field", "F", "P", "ObjectSchema", "Field", "P", "ObjectSchema", "Field", "P", "P", "P", "P", "P", "P", "P", "actions_exports", "P", "P", "defineDataset", "defineDataset", "defineDataset", "defineDataset", "defineDataset", "defineDataset", "defineDataset", "defineDataset", "defineDataset", "defineDataset", "defineDataset", "defineDataset", "defineDataset", "defineDataset", "datasets_exports", "defineDataset", "defineDataset", "defineMapping", "defineMapping", "defineMapping", "defineMapping", "en", "appSurface", "activityActions", "customer", "activityActions", "pipeline", "activityActions", "commerce", "service", "activityActions", "activity", "marketing", "zhCN", "customer", "service", "pipeline", "commerce", "activity", "marketing", "appSurface", "appSurface", "activityActions", "customer", "activityActions", "pipeline", "activityActions", "commerce", "service", "activityActions", "activity", "marketing", "jaJP", "customer", "service", "pipeline", "commerce", "activity", "marketing", "appSurface", "appSurface", "activityActions", "customer", "activityActions", "pipeline", "activityActions", "commerce", "service", "activityActions", "activity", "marketing", "esES", "customer", "service", "pipeline", "commerce", "activity", "marketing", "appSurface", "en", "zhCN", "jaJP", "esES", "P", "defineView", "P", "defineView", "defineView", "defineView", "defineView", "defineView", "defineView", "defineView", "defineView", "defineView", "defineView", "defineView", "defineView", "defineView", "defineView", "defineView", "views_exports", "defineView", "defineView", "defineView", "defineView", "defineView", "defineView", "views_exports", "defineView", "defineView", "P", "P", "en", "zhCN", "jaJP", "esES", "en", "zhCN", "jaJP", "esES", "email_templates_exports", "en", "zhCN", "jaJP", "esES", "en", "zhCN", "jaJP", "esES", "opportunities", "period", "input", "contacts", "leads", "type", "interval", "status", "P", "cel", "cel", "P", "P", "cel", "P", "cel", "P", "cel", "P", "cel", "cel", "cel", "P", "cel", "P", "cel", "P", "cel", "P", "cel", "P", "cel", "P", "cel", "P", "cel", "cel", "P", "P", "expression", "cel", "cel", "expression", "P", "P", "cel", "cel", "P", "P", "cel", "P", "cel", "P", "cel", "P", "cel", "P", "cel", "P", "cel", "cel", "cel", "P", "cel", "cel", "expression", "expression", "cel", "P", "cel", "P", "expression", "cel", "cel", "expression", "P", "P", "cel", "cel", "P", "cel", "cel", "cel", "cel", "P", "cel", "P", "cel", "P", "cel", "cel", "P", "cel", "cel", "cel", "cel", "defineSkill", "defineSkill", "defineSkill", "defineSkill", "defineSkill", "defineSkill", "defineSkill", "defineSkill", "defineSkill", "defineSkill", "P", "P", "P", "P", "P", "P", "cel", "cel", "cel", "cel", "defineSeed", "cel", "defineSeed", "cel", "defineSeed", "cel", "defineSeed", "cel", "defineSeed", "defineSeed", "defineSeed", "defineSeed", "defineSeed", "cel", "defineSeed", "cel", "defineSeed", "cel", "cel", "defineSeed", "defineSeed", "cel", "defineSeed", "cel", "objects_exports", "actions_exports", "datasets_exports", "views_exports", "email_templates_exports", "composition"]
}
 diff --git a/src/sales/views/lead.view.ts b/src/sales/views/lead.view.ts index e7fae774..049bedbe 100644 --- a/src/sales/views/lead.view.ts +++ b/src/sales/views/lead.view.ts @@ -290,10 +290,11 @@ export const LeadViews = defineView({ }, 'lead_source', 'industry', - { - field: 'owner_id', - required: true, - }, + // Offered, ⛔ not `required` (#2097): an insert that leaves it empty is + // stamped to the creator by the platform (see `lead.hook.ts`), so a + // rep's new lead is theirs without a pick, and a manager can still + // choose another owner. `required` blocked that save client-side. + 'owner_id', // `disqualification_reason` is enforced by the // `disqualification_reason_required` validation on crm_lead, so every // form that lets a user pick "Unqualified" must also offer the reason From b5237b67cfe3b730353775c0d31e890fc520a159 Mon Sep 17 00:00:00 2001 From: Claude Date: Wed, 14 Oct 2026 08:11:18 +0000 Subject: [PATCH 2/4] test(ownership): pin that the New Lead form does not require an owner Also drops objectstack.config.bundled_4tw0mek20uf.mjs, a dev-server compile artifact the previous commit picked up by accident. Claude-Session: https://claude.ai/code/session_01P8mZuzuyZAHSrgQKmv6ASv Co-authored-by: Claude --- objectstack.config.bundled_4tw0mek20uf.mjs | 35749 ------------------- test/ownership-model.test.ts | 16 + 2 files changed, 16 insertions(+), 35749 deletions(-) delete mode 100644 objectstack.config.bundled_4tw0mek20uf.mjs diff --git a/objectstack.config.bundled_4tw0mek20uf.mjs b/objectstack.config.bundled_4tw0mek20uf.mjs deleted file mode 100644 index 00f6fd91..00000000 --- a/objectstack.config.bundled_4tw0mek20uf.mjs +++ /dev/null @@ -1,35749 +0,0 @@ -var __defProp = Object.defineProperty; -var __export = (target, all) => { - for (var name in all) - __defProp(target, name, { get: all[name], enumerable: true }); -}; - -// objectstack.config.ts -import { composeStacks } from "@objectstack/spec"; - -// src/sales/index.ts -import { defineStack } from "@objectstack/spec"; -var createHotCrmAppStack = (collections, options) => defineStack({ - manifest: { - id: "app.objectstack.hotcrm", - namespace: "crm", - version: "4.0.1", - type: "app", - name: "HotCRM", - description: "AI-Native CRM for the ObjectStack marketplace \u2014 Accounts, Contacts, Leads, Opportunities, Cases, Knowledge, Forecasts, Campaigns, Contracts.", - // ADR-0087 protocol handshake (ADR-0025 §3.2): the metadata/runtime - // protocol major this app's metadata is authored against. Only the major - // participates in the check — a runtime on a different major refuses the - // load with a structured OS_PROTOCOL_INCOMPATIBLE diagnostic (naming the - // `objectstack migrate meta` replay) instead of failing deep in a schema - // parse. Bump together with `specVersion` on every platform upgrade - // (docs/MAINTENANCE.md §3) — `test/docs-declared-versions.test.ts` now - // enforces that pairing against `objectstack.manifest.json` instead of - // trusting this comment, because two platform upgrades in a row (rc.2, then - // rc.3) moved the manifest and left this line behind (#728). Every package - // of this artifact states the same protocol; `src/service/index.ts` - // repeats it for the same reason. - engines: { protocol: "^18.0.0-next.0" } - }, - // ─── Platform capabilities this app needs ───────────────────────── - // The runtime resolves each capability name to a built-in service plugin - // and auto-loads it (with extras like Automation's node packs). No need - // to hand-instantiate plugins or pass `--preset` flags. See - // packages/cli/src/commands/serve.ts CAPABILITY_PROVIDERS for the - // complete map; explicit `plugins: [...]` always shadows the resolver. - // `auth` enables the auth/login surface (login/register) via @objectstack/plugin-auth. - // `ui` serves the unified Console shell and CRM apps under /_console/ - // (login at /_console/login). ObjectStack 7.x replaced the legacy - // /_studio/ and /_account/ mounts with this single /_console/ surface. - // Both are required for a clickable login flow when running `objectstack start` - // off the compiled artifact. - // Note: the foundational slate (queue, job, cache, settings, email, - // storage) is auto-injected by the CLI for every non-`minimal` - // preset — see `ALWAYS_CAPS` in packages/cli/src/commands/serve.ts. - // Listed below only the *opt-in* capabilities this stack actually - // wants on top of that slate. - // `triggers` installs the record-change + schedule trigger providers that - // actually fire autolaunched flows (record_change & schedule types). Without - // it the `automation` engine registers flows but nothing ever launches them. - // Schedule triggers run via the job service (in the always-on slate). - // - // This is the APP package's slate. `defineStack` validates capabilities per - // stack, so `src/service/index.ts` declares the four its own metadata needs - // itself, and the artifact's slate is the union of the two lists. - // - // `ai` is deliberately NOT listed. ObjectStack 11.3.0 (ADR-0025 S2) removed - // `@objectstack/service-ai` from the open edition — the AI runtime now ships - // only in the closed cloud package, and the framework CLI does not depend on - // it. Under ObjectStack 16, `requires: ['ai']` is a *fail-fast* capability: - // the serve command hard-aborts boot when the package is absent, so keeping it - // here would break `objectstack start`/`dev` for this open-edition app (the AI - // block runs before every other capability resolves). The AI metadata is - // unaffected — the skills still validate, build into the artifact, and run - // wherever a runtime provides the `ai` tier (cloud's objectos-runtime). There - // are no app-authored agents: they were retired in #512 and the surface is - // skills-only (ADR-0063 §2); skills attach to a platform agent by `surface`. - // A local open-edition boot simply omits the AI service and hides its console - // surface. To run AI locally, declare `@objectstack/service-ai` (cloud) in - // package.json — its mere presence best-effort auto-loads it. - // `hierarchy-security` is the ONE enterprise-edition capability this app - // declares. It was introduced for #880 — `sales_manager` authored - // `writeScope: 'own_and_reports'` on `crm_contract`, an ADR-0057 HIERARCHY - // scope resolved by the `hierarchy-scope-resolver` service that ships only - // in `@objectstack/security-enterprise`, and `defineStack` refuses such a - // grant unless the capability is declared. Since #549 `crm_contract` is - // `controlled_by_parent` under the account, that scope is inert and is no - // longer authored; the app currently authors NO hierarchy scope at all. - // - // The declaration STAYS. Maintainer ruling 2026-08-31 (#1378, pinned by - // `test/hierarchy-read-depth.test.ts`): nothing is removed from `requires[]`. - // Maintainer ruling, 2026-08-11, verbatim: 「本项目是元数据app，在企业版运行就 - // 具备企业版相关的能力，不重复开发。」 The app states what it MEANS and the - // edition supplies the capability, rather than approximating it with a broader - // open-edition value. - // - // UNLIKE `ai` above, this is SAFE to declare on an open-edition boot and does - // NOT fail fast. Verified against `@objectstack/cli`'s serve command: the - // capability resolver looks the token up in `CAPABILITY_PROVIDERS`, finds no - // entry, and because `hierarchy-security` IS in the known - // `PLATFORM_CAPABILITY_TOKENS` vocabulary it takes the deliberate "stay quiet" - // branch — no warning, no abort — since the capability arrives via an explicit - // enterprise plugin in `plugins[]`. Only tier-gated tokens (ai / ai-studio / - // i18n / ui / auth) have the dedicated hard-abort blocks the note above - // describes. `objectstack validate` does print one informational line naming - // the package to install; that is expected output, not a defect to silence. - requires: ["automation", "triggers", "analytics", "auth", "ui", "approvals", "sharing", "hierarchy-security"], - // The locale configuration is the ARTIFACT's, and `i18n` is a - // `'single'`-disposition key: two stacks declaring different values make - // `composeStacks` throw, and declaring identical ones twice is a second - // place to drift. It lives on the App package, alone. - i18n: { - defaultLocale: "en", - supportedLocales: ["en", "zh-CN", "ja-JP", "es-ES"], - fallbackLocale: "en" - }, - ...collections -}, { artifactObjects: options.artifactObjects }); - -// src/service/index.ts -import { defineStack as defineStack2 } from "@objectstack/spec"; - -// src/service/actions/case.actions.ts -import { P } from "@objectstack/spec"; -var EscalateCaseAction = { - name: "escalate_case", - label: "Escalate Case", - objectName: "crm_case", - icon: "alert-triangle", - type: "flow", - target: "escalate_case", - locations: ["record_header", "list_item"], - visible: P`has(record.is_escalated) && record.is_escalated == false && has(record.is_closed) && record.is_closed == false`, - confirmText: "This will escalate the case to the escalation team. Continue?", - successMessage: "Case escalated successfully!", - refreshAfter: true -}; -var CloseCaseAction = { - name: "close_case", - label: "Close Case", - objectName: "crm_case", - icon: "check-circle", - type: "flow", - target: "close_case", - locations: ["record_header"], - visible: P`has(record.is_closed) && record.is_closed == false`, - confirmText: "Are you sure you want to close this case?", - successMessage: "Case closed successfully!", - refreshAfter: true -}; -var ClaimCaseAction = { - name: "claim_case", - label: "Claim Case", - objectName: "crm_case", - icon: "user-plus", - type: "flow", - target: "claim_case", - locations: ["record_header", "list_item"], - // ⛔ Deliberately NOT `has()`-guarded — the one site the #1890 totality sweep - // left alone after making every other `visible` in `src/actions/` total. This - // predicate is the sharing grant's own text, verbatim, and - // `test/claim-case-one-owner-writer.test.ts` compares the two strings; the - // grant itself cannot carry `has()`, because `plugin-sharing` compiles a - // criteria condition with `compileCelToFilter`, which rejects the whole - // function-call class, and an untranslatable rule is DROPPED by the seeder - // (#621). `src/service/sharing/case.sharing.ts` writes that out in full, including why - // `record.owner_id == null` is total one layer down (`{ owner_id: { $null: true } }`). - // ⚠️ What that reasoning does NOT cover is THIS surface: an action `visible` is - // interpreted by CEL in the browser against whatever the page holds, which is - // `{}` for the first renders, so this predicate does abort there. Making it - // total needs the grant and the parity pin moved together — a maintainer call, - // not this card's. (#1890) - visible: P`record.owner_id == null && record.status != "resolved" && record.status != "closed"`, - successMessage: "Case claimed \u2014 it is yours now.", - refreshAfter: true -}; - -// src/service/objects/index.ts -var objects_exports = {}; -__export(objects_exports, { - ArticleFeedback: () => ArticleFeedback, - Case: () => Case, - KnowledgeArticle: () => KnowledgeArticle -}); - -// src/service/objects/article_feedback.object.ts -import { ObjectSchema, Field } from "@objectstack/spec/data"; -var ArticleFeedback = ObjectSchema.create({ - name: "crm_article_feedback", - label: "Article Feedback", - pluralLabel: "Article Feedback", - icon: "thumbs-up", - description: "One reader\u2019s helpful / not-helpful verdict on a knowledge article", - // ADR-0090 D1/D7: OWD is an authored decision. Feedback is an attribute of - // the article, so record access DERIVES from it (ADR-0055) — the same call - // `crm_campaign_member` makes, and for the same reason: a vote row means - // nothing apart from the article it is about, and `crm_knowledge_article` is - // `public_read`, so anyone who can read the article can read its feedback. - // - // ⛔ Not `private`: with the voter as owner, the counters' own evidence would - // be invisible to the author trying to understand them — the same way it was - // wrong on `crm_campaign_member`. - sharingModel: "controlled_by_parent", - // ADR-0079: junction rows have no derivable text title; point the canonical - // nameField at the stored autonumber explicitly (autonumber is not in the - // auto-derivation whitelist). Same call as `crm_campaign_member` and - // `crm_event_attendee`. - nameField: "feedback_number", - // A related list takes its columns from the child's `highlightFields` MINUS - // the lookup it is scoped by, and this object ships no view of its own — so - // this list IS the feedback panel on an article's detail page (#944): the - // verdict, and who gave it. - // - // TWO fields are deliberately absent, for two different reasons: - // - // - `feedback_number`, the same call `crm_campaign_member` makes with - // `member_number`: it is the record TITLE, which a detail page hoists out - // of the body, so leading the strip with it would fill the panel with - // autonumbers instead of verdicts. - // - `comment`, a 500-character textarea. A highlight strip holds short - // values, and keeping it out is also what stops the `basic` group being - // ENTIRELY title-or-strip — a group whose every field is hoisted keeps its - // heading on forms and silently vanishes from detail pages - // (`field-group-shadowed`, the same trap `crm_campaign_member`'s `basic` - // group and `crm_task`'s `assignment` group each had to be rescued from). - // So the comment is the group's own content on the row's detail page, - // and reaches the panel through `relatedListColumns` on the article - // lookup below instead (#1199). - highlightFields: ["crm_knowledge_article", "verdict", "owner_id"], - fieldGroups: [ - { key: "basic", label: "Feedback", icon: "message-square" } - ], - fields: { - feedback_number: Field.autonumber({ - label: "Feedback #", - format: "AF-{0000}", - group: "basic" - }), - // Platform ownership anchor — canonical note in `account.object.ts` (#548). - // Here it is also the VOTER: the platform stamps it on insert, which is - // what `unique_vote_per_reader` keys on and what lets a reader change - // their own mind without an admin's help. - owner_id: Field.lookup("sys_user", { - label: "Reader", - group: "basic", - system: true, - readonly: false - }), - /** - * The article this verdict is about. - * - * `deleteBehavior: 'cascade'` — a vote on a deleted article denotes - * nothing. This is the lesson #696 cost the campaign junction: both party - * lookups there took `Field.lookup`'s `set_null` default, the cleared row - * instantly violated the object's own required-reference rule, and every - * enrolled person became permanently undeletable. A required lookup that - * defaults to `set_null` is that bug waiting to happen, so the behaviour is - * spelled out here rather than inherited. - */ - crm_knowledge_article: Field.lookup("crm_knowledge_article", { - label: "Article", - required: true, - storage: { notNull: true }, - group: "basic", - deleteBehavior: "cascade", - description: "Knowledge article this feedback is about.", - // Curates the feedback panel on the article's detail page — the surface - // the article's AUTHOR reads (#1199). A related list reads - // `relatedListColumns` on the child's lookup before it falls back to - // `highlightFields` minus that lookup (#944), so this is a SUPERSET of - // the fallback (Verdict / Reader) plus `comment`: the note a reader - // types to explain a verdict was stored and shown on no list, and the - // author the field's own description names could not see it without - // opening each row. Last, because it is the one long value. - // - // ⛔ Deliberately NOT solved by adding `comment` to `highlightFields` — - // see the note above that list (`field-group-shadowed`). - relatedListColumns: ["verdict", "owner_id", "comment"] - }), - verdict: Field.select({ - label: "Verdict", - required: true, - storage: { notNull: true }, - group: "basic", - options: [ - { label: "Helpful", value: "helpful", color: "#10B981", default: true }, - { label: "Not Helpful", value: "not_helpful", color: "#EF4444" } - ] - }), - comment: Field.textarea({ - label: "Comment", - group: "basic", - maxLength: 500, - description: "Optional note explaining the verdict \u2014 read by the article\u2019s author." - }) - }, - indexes: [ - { fields: ["crm_knowledge_article"] }, - { fields: ["verdict"] }, - // One vote per reader per article. Without it the counters answer "how many - // clicks", which is not a number anybody wants next to "Not Helpful". - // - // `unique: 'organization'` states the scope explicitly, per ADR-0120: the - // driver prepends the NULL-safe organization key part - // (`COALESCE(organization_id, '__global__')`) at registration, so the - // constraint is one vote per reader per article WITHIN an organization, - // and rows with no organization form one bucket rather than each escaping - // under SQL's NULL-distinct semantics. Bare `unique: true` is the - // deprecated positional spelling of `'global'` — it warns today - // (`unique/unscoped-declared-index`) and protocol 18 rejects it, and - // "globally unique across every installation" is not what one reader's - // opinion of one article means. - { fields: ["crm_knowledge_article", "owner_id"], unique: "organization" } - ], - enable: { - apiEnabled: true, - apiMethods: ["get", "list", "create", "update", "delete"] - } -}); - -// src/service/objects/case.object.ts -import { ObjectSchema as ObjectSchema2, Field as Field2 } from "@objectstack/spec/data"; -import { F, P as P2 } from "@objectstack/spec"; -var Case = ObjectSchema2.create({ - name: "crm_case", - label: "Case", - pluralLabel: "Cases", - icon: "life-buoy", - description: "Customer support cases and service requests", - // ADR-0090 D1/D7: OWD is an authored decision. Owner + escalation sharing rule. - sharingModel: "private", - fieldGroups: [ - { key: "basic", label: "Case Information", icon: "info" }, - { key: "origin", label: "Origin & Routing", icon: "route" }, - { key: "sla", label: "SLA & Priority", icon: "clock" }, - { key: "resolution", label: "Resolution", icon: "check-circle" }, - { key: "escalation", label: "Escalation", icon: "alert-triangle", collapse: "collapsed" }, - { key: "system", label: "System", icon: "database", collapse: "collapsed" } - ], - fields: { - // Platform ownership anchor — canonical note in `account.object.ts` (#548). - owner_id: Field2.lookup("sys_user", { - label: "Case Owner", - group: "origin", - system: true, - readonly: false, - trackHistory: true - }), - // Case Information - // - // `unique: true` is declared HERE, on the field, and deliberately NOT as a - // `{ fields: ['organization_id', 'case_number'], unique: true }` entry in - // `indexes[]` below (#1023) — same spelling `crm_account.name`, - // `crm_contact.email` and `crm_product.sku` already use, for the same - // reason. Since framework #3696 the field-level form is per-organization: - // it materializes as the composite `(organization key part, case_number)`, - // unique WITHIN an organization. Since platform 17.0.0-rc.4 (ADR-0120 D3, - // #5030) that key part is NULL-safe — `COALESCE(organization_id, - // '__global__')` — so rows with no organization form ONE bucket instead of - // each escaping the constraint under SQL's NULL-distinct semantics. - // - // The hand-written table composite this replaced could not get that: a - // declared index is taken verbatim, so it materialized as plain - // `UNIQUE (organization_id, case_number)` and enforced NOTHING on any row - // whose `organization_id` was NULL — i.e. every row of a single-organization - // or untenanted install. It also read as "unique per organization" while - // materializing as an unscoped composite, which is the bare-`unique: true` - // spelling ADR-0120 warns on in 17.x and protocol 18 rejects (#5082). - // - // Scope spelling: bare `true` at FIELD level already means "per - // organization" and carries no deprecation (`'organization'` is its - // explicit synonym with byte-identical materialization — measured). It is - // written as `true` to match the four sibling objects above; switching the - // repo to the explicit word is a uniform decision for all of them, not - // something `crm_case` forks on alone. - case_number: Field2.autonumber({ - label: "Case Number", - group: "basic", - format: "CASE-{00000}", - unique: true - }), - subject: Field2.text({ - label: "Subject", - group: "basic", - required: true, - storage: { notNull: true }, - searchable: true, - maxLength: 255 - }), - // ADR-0079 record title (was titleFormat '{case_number} - {subject}'). - display_title: Field2.formula({ - label: "Display Title", - group: "basic", - expression: F`record.case_number + " - " + record.subject` - }), - description: Field2.markdown({ - label: "Description", - group: "basic", - required: true, - storage: { notNull: true } - }), - // Relationships - crm_account: Field2.lookup("crm_account", { - label: "Account", - group: "basic" - }), - crm_contact: Field2.lookup("crm_contact", { - label: "Contact", - group: "basic", - // Optional so Web-to-Case (anonymous) submissions can land without - // an existing CRM contact. Back-office staff or a triage flow links - // the case to a contact after the fact. This matches the Salesforce - // Web-to-Case convention. - // @objectstack 12: string[] `referenceFilters` is dead (not read by the - // picker). `dependsOn` is the live cascading-lookup form — it scopes the - // contact candidates to those sharing the case's `crm_account` (ADR-0049). - dependsOn: ["crm_account"] - }), - // Case Management - status: Field2.select({ - label: "Status", - group: "basic", - required: true, - storage: { notNull: true }, - // ADR-0052 §5b.1 — platform auto-renders status changes on the timeline - // ("Status: New → Escalated"). Delivers the case timeline declaratively - // (the hand-coded version was deferred in #396 due to a hook-crash bug). - trackHistory: true, - options: [ - { label: "New", value: "new", color: "#808080", default: true }, - { label: "In Progress", value: "in_progress", color: "#FFA500" }, - { label: "Waiting on Customer", value: "waiting_customer", color: "#FFD700" }, - { label: "Waiting on Support", value: "waiting_support", color: "#4169E1" }, - { label: "Escalated", value: "escalated", color: "#FF0000" }, - { label: "Resolved", value: "resolved", color: "#00AA00" }, - { label: "Closed", value: "closed", color: "#006400" } - ] - }), - priority: Field2.select({ - label: "Priority", - group: "sla", - required: true, - storage: { notNull: true }, - trackHistory: true, - options: [ - { label: "Low", value: "low", color: "#4169E1", default: true }, - { label: "Medium", value: "medium", color: "#FFA500" }, - { label: "High", value: "high", color: "#FF4500" }, - { label: "Critical", value: "critical", color: "#FF0000" } - ] - }), - // Sortable ordinal for `priority`. Ordering a queue by the select field - // itself sorts the raw strings, so `priority desc` yields - // medium > low > high > critical — the exact inversion of urgency, which - // buried every critical case at the bottom of the agent's queue. Select - // options carry no ordinal in the spec, so the rank is materialised here - // and stamped by `case_sla_defaults`; queue views sort on it instead. - // `0` is the UNRANKED sentinel, shared with crm_task.priority_rank: it is - // what a record carries when no recognised priority has been stamped, and - // it sorts below every real rank (1–4) on the `priority_rank desc` queues. - // ⛔ It must not be `1` here (or `2` on crm_task): a non-zero sentinel - // orders the same unknown priority differently on the two objects, and on - // this one it is indistinguishable from a genuine `low`. - priority_rank: Field2.number({ - label: "Priority Rank", - readonly: true, - defaultValue: 0 - }), - type: Field2.select({ - label: "Case Type", - group: "basic", - options: [ - { label: "Question", value: "question" }, - { label: "Problem", value: "problem" }, - { label: "Feature Request", value: "feature_request" }, - { label: "Bug", value: "bug" } - ] - }), - origin: Field2.select({ - label: "Case Origin", - group: "origin", - options: [ - { label: "Email", value: "email" }, - { label: "Phone", value: "phone" }, - { label: "Web", value: "web" }, - { label: "Chat", value: "chat" }, - { label: "Social Media", value: "social_media" } - ] - }), - // Assignment - // SLA and Metrics - // - // NO `created_date` here (#1992, the #575 B2 precedent on - // `crm_opportunity`): the platform already injects `created_at` on every - // object and stamps it on every insert, while this duplicate had no writer - // at all — only the seed data set it, so every case created through the - // UI or REST stored null and fell out of "Cases Opened by Priority × Day" - // and the service dashboard's date range. Surfaces that need the creation - // instant read `created_at` (the `case_metrics` dataset, the dashboard - // range, the `case_timeline` view, `case_sla_defaults`' resolution time); - // the seeds author it directly, and the seed loader keeps an authored - // `created_at` on first insert since @objectstack/objectql 17.7.0 - // (objectstack#21646). - closed_date: Field2.datetime({ - label: "Closed Date", - group: "sla", - readonly: true - }), - // ⛔ NOT `readonly`: stamped by `event_activity_bubble` - // (`src/sales/objects/event.hook.ts`) on the first HELD `crm_event` related to the - // case, whoever wrote that event. ⚠️ That hook reaches this case through - // `ctx.api`, a `ScopedContext` over the ACTING USER's execution context — - // so its write is a CALLER-supplied write from a non-`isSystem` context, - // which `stripReadonlyFields` deletes. `readonly` here silently disables - // the stamp. (A hook writing its OWN record's `ctx.input.data` is a - // different case and SURVIVES `readonly` — hook-written keys are not - // caller-supplied. Measured in `test/readonly-write-semantics.test.ts`.) - // - // Definition: the moment the customer first heard back from us, matching - // Salesforce `FirstResponseDateTime` / Zendesk first reply time — NOT an - // internal status change, which would report "responded" while the customer - // is still waiting. - first_response_date: Field2.datetime({ - label: "First Response Date", - group: "sla" - }), - resolution_time_hours: Field2.number({ - label: "Resolution Time (Hours)", - group: "sla", - readonly: true, - scale: 2 - }), - // Stamped once, on the first write that gives the case a priority, from the - // priority × account-tier matrix in `./_case-sla.ts` (`case_sla_defaults`). - // Not `readonly`: a service manager may legitimately renegotiate a deadline, - // and the hook never overwrites a value that is already there. - sla_due_date: Field2.datetime({ - label: "SLA Due Date", - description: "Set from the case priority and the account\u2019s Customer Tier, in calendar hours: nights, weekends and holidays count.", - group: "sla" - }), - // Stamped by two writers, one per side of the clock stop (#2070): the - // `case_sla_monitor` schedule flow while the case is live work, and - // `case_sla_defaults` on the write that resolves or closes it late. The - // rule both apply is `caseSlaBreached` in `./_case-sla.ts`. - // - // NOT `readonly` — but NOT for the reason this comment used to give, and - // the difference is measured in `test/readonly-write-semantics.test.ts` - // (#1429). `case_sla_monitor` declares `runAs: 'system'`, so its writes - // would SURVIVE a `readonly: true` here. It stays writable pending a - // decision that has to weigh the other surfaces (seed data, - // `service-agent.profile.ts`, the create form), not because the platform - // would drop the sweep's write. - // - // ⚠️ This is now the ONLY escalation-group flag still declared writable: - // `is_escalated` and `escalated_date` became `readonly: true` when #1434 - // moved their user-context writer into a system sub-flow. So the open - // question here is narrower than it was — it is purely about this field's - // authoring surfaces, with no platform obstacle left to blame. - is_sla_violated: Field2.boolean({ - label: "SLA Violated", - group: "sla", - defaultValue: false - }), - // Escalation - // - // `readonly: true` — the honest declaration, because nobody types this. - // Its three writers are now unanimously elevated (#1434, maintainer- - // approved decision batch #21 ②): - // - // case_escalation runAs: 'system' (record-change) - // case_sla_monitor runAs: 'system' (schedule) - // case_escalation_stamp runAs: 'system' (called by the escalate_case - // screen flow via a subflow node) - // - // ⭐ What changed, and why the readonly declaration is now safe: the - // `escalate_case` screen flow used to write this field itself, and it - // stays `runAs: 'user'` because a person clicks it. The platform's - // readonly strip is one branch of the UPDATE path - // (`if (!opCtx.context?.isSystem)`, over CALLER-supplied keys), so that - // user-context write WOULD have been silently dropped. Rather than - // elevating the whole screen flow, the stamp moved into the dedicated - // `case_escalation_stamp` sub-flow. The agent's own writes - // (`escalation_reason`, `priority`, `status`) still carry their identity; - // only these two stamps are elevated. - // - // The guest-submission branch of `case.hook.ts` also forces this false, and - // is unaffected: it is a `beforeInsert` hook, so its key is not - // caller-supplied AND the INSERT path is exempt from the strip entirely. - // Seed data (`service.seed.ts`) is exempt for the same reason. - // - // ⛔ If you find yourself reverting this to writable so a user-context flow - // write lands, you are re-opening #1434 — add a `subflow` step instead. - // Semantics measured in `test/readonly-write-semantics.test.ts`. - is_escalated: Field2.boolean({ - label: "Escalated", - group: "escalation", - readonly: true, - defaultValue: false - }), - // `readonly: true`, same reasoning as `is_escalated` above and stamped by - // the same writers — `case_escalation` and the `case_escalation_stamp` - // sub-flow, both `runAs: 'system'`. Never typed by a person. - escalated_date: Field2.datetime({ - label: "Escalated Date", - group: "escalation", - readonly: true - }), - // ⛔ DELIBERATELY NOT `readonly`, and this is load-bearing (#1434). This is - // the agent's own screen input — `escalate_case`'s screen collects it and - // writes it with the USER's context. Declaring it readonly would make the - // platform silently strip the reason the agent just typed, which is the - // harm #1434 was filed about, inverted onto user input. It is also - // required whenever `is_escalated` flips true (the - // `escalation_reason_required` validation below), so dropping it would - // reject the escalation outright. - escalation_reason: Field2.textarea({ - label: "Escalation Reason", - group: "escalation" - }), - // No `parent_case`. A case hierarchy was declared here and never - // traversed: nothing rolled child cases up, nothing closed or notified them - // with the parent, and no service flow read the link. Related cases that - // matter in this app are linked through the knowledge article that resolved - // them (`resolved_by_article`), which the deflection measures do read. - // Resolution - resolution: Field2.markdown({ - label: "Resolution", - group: "resolution" - }), - /** - * The knowledge article that RESOLVED this case (#601). - * - * The second half of a two-way link, and deliberately not a replacement for - * the first. `crm_knowledge_article.related_to_case` points the other way — - * "the case this article was WRITTEN FROM" — and the two answer different - * questions: provenance (where did this article come from) versus - * deflection (what did this article save us). Merging them would make both - * unanswerable, so both stay. - * - * This is the column the deflection measures on `case_metrics` read - * (`kb_resolved_count` / `kb_deflection_rate`), which is why blank is - * normalised to NULL by `case_resolution_article_normalize` in - * `case.hook.ts`: the close-case screen sends `''` for a field the agent - * left empty, an empty string is NOT null, and `count(resolved_by_article)` - * counts it — a silently inflated numerator on a ratio widget, the exact - * shape of #614. - */ - resolved_by_article: Field2.lookup("crm_knowledge_article", { - label: "Resolved by Article", - group: "resolution", - description: "Knowledge article that resolved this case \u2014 the deflection signal." - }), - // Internal notes - internal_notes: Field2.markdown({ - label: "Internal Notes", - group: "system", - description: "Internal notes; not visible to the customer." - }), - // Flags - is_closed: Field2.boolean({ - label: "Is Closed", - group: "system", - defaultValue: false, - readonly: true - }) - }, - // Database indexes for performance - // - // `case_number` is an autonumber (`CASE-{00000}`), and the platform's - // autonumber sequence is PER TENANT — every organization counts from 1. A - // platform-wide unique index on it therefore rejects the second - // organization's `CASE-00001` on insert: the exact collision framework #3696 - // exists to prevent. The constraint has to match the sequence that feeds it. - // - // No `{ fields: ['organization_id', 'case_number'], unique: true }` here - // (#1023). Case-number uniqueness is declared on the `case_number` field - // itself — see the note there for why the hand-written table composite could - // not express it. Do NOT add it back alongside the field-level declaration - // either: declaring both makes the verbatim index win and leaves the - // per-organization one unreachable (framework#3991 - // `unique/double-declaration`), which would silently undo the fix. - indexes: [ - { fields: ["crm_account"] }, - { fields: ["owner_id"] }, - { fields: ["status"] }, - { fields: ["priority"] } - ], - // API surface. History → Field.trackHistory (ADR-0052). - enable: { - apiEnabled: true, - // #602 — screenshots and logs are how a support case gets diagnosed. - // See the canonical capability note in `src/sales/objects/index.ts`. - files: true - }, - // ADR-0052 §5b.2 — declarative milestone activity for the service narrative. - // The caseSideEffects hook still owns its real side-effects (escalation task, - // closed-date stamping); these are timeline entries only, emitted by the platform. - activityMilestones: [ - { field: "status", value: "escalated", summary: "Case escalated \u2014 {subject}", type: "updated" }, - { field: "status", value: "resolved", summary: "Case resolved \u2014 {subject}", type: "completed" }, - { field: "status", value: "closed", summary: "Case closed \u2014 {subject}", type: "completed" } - ], - // ADR-0079: render-only `titleFormat` retired in favor of `nameField`, - // which names a real field. The former template composed two local fields, so - // the `display_title` formula field (see fields) reproduces it. - nameField: "display_title", - // Explicit search targets (ADR-0061). REQUIRED because nameField is a - // FORMULA (display_title/full_name): without this, $search auto-defaults to - // the formula field, which isn't a real column, so the lookup picker + global - // search silently return zero. These are real, indexed columns. - searchableFields: ["subject", "case_number"], - highlightFields: ["case_number", "subject", "crm_account", "status", "priority"], - // Removed: list_views and form_views belong in UI configuration, not object definition - // Predicates below are TOTAL: every `record.x` read is `has()`-guarded, so the - // rule returns a verdict even when the merged record has no such key. See - // AGENTS.md "Validation predicates must be TOTAL" and - // test/object-validation-predicates.test.ts, which fails the build otherwise. - validations: [ - { - name: "resolution_required_for_closed", - type: "script", - severity: "error", - message: "Resolution is required when closing a case", - condition: P2`has(record.status) && record.status == "closed" && (!has(record.resolution) || isBlank(record.resolution))` - }, - { - name: "escalation_reason_required", - type: "script", - severity: "error", - message: "Escalation reason is required when escalating a case", - condition: P2`has(record.is_escalated) && record.is_escalated == true && (!has(record.escalation_reason) || isBlank(record.escalation_reason))` - }, - { - name: "case_status_progression", - type: "state_machine", - severity: "warning", - message: "Invalid status transition", - field: "status", - // Escalate + Close actions are available from ANY open status (see - // escalate_case / close_case visibility). The transition map must permit - // →escalated and →closed from every open state, else those actions emit a - // spurious "Invalid status transition" warning (e.g. escalating a brand-new - // case, which is a legitimate support move). - transitions: { - "new": ["in_progress", "waiting_customer", "escalated", "closed"], - "in_progress": ["waiting_customer", "waiting_support", "escalated", "resolved", "closed"], - "waiting_customer": ["in_progress", "waiting_support", "escalated", "closed"], - "waiting_support": ["in_progress", "waiting_customer", "escalated", "closed"], - "escalated": ["in_progress", "resolved", "closed"], - "resolved": ["closed", "in_progress"], - // Can reopen - "closed": ["in_progress"] - // Can reopen - } - } - ] - // ⚠️ No `workflows[]` here, and none is possible: object `workflows[]` were - // removed from the platform. Field updates live in this object's `*.hook.ts`; - // scheduled status flips and notifications live in `src/*/flows/*.flow.ts`. -}); - -// src/service/objects/knowledge_article.object.ts -import { ObjectSchema as ObjectSchema3, Field as Field3 } from "@objectstack/spec/data"; -import { F as F2, P as P3 } from "@objectstack/spec"; -var KnowledgeArticle = ObjectSchema3.create({ - name: "crm_knowledge_article", - label: "Knowledge Article", - pluralLabel: "Knowledge Articles", - icon: "book-open", - description: "Reusable knowledge base articles for self-service and AI grounding", - // ADR-0090 D1/D7: OWD is an authored decision. Knowledge base is org-readable; authors edit. - sharingModel: "public_read", - // ─── Public access ───────────────────────────────────────────────────── - // - // Publishing a public article mints a share link through the platform's - // `publicSharing` surface (maintainer ruling, 2026-08-02: no customer portal, - // no anonymous-grant widening). ⛔ The whole safety of that rests on - // `eligibility`, which is the ONLY thing standing between a share dialog and - // a stranger reading an internal or draft article — so this block may only be - // declared while every key below is enforced. - // - // MEASURED on `@objectstack/plugin-sharing@17.1.0` — the version - // installed AT THE TIME of the measurement, not the current pin (this table - // has NOT been re-taken on any later pin — not 17.3.0, #1676, not 17.4.0, - // PR #1814, and not 17.5.0) — - // against the real `ShareLinkService` and a real engine, - // not read off a grep count: - // - // | key | measured on 17.1.0 | - // | -------------------- | ---------------------------------------------- | - // | `enabled` | ENFORCED — false ⇒ SHARING_NOT_ENABLED 422 | - // | `allowedAudiences` | ENFORCED — `signed_in` refused 422 | - // | `allowedPermissions` | ENFORCED — non-`view` refused 422 | - // | `redactFields` | APPLIED to every token-served response | - // | `eligibility` | **ENFORCED — false verdict ⇒ 422, no link** | - // - // `test/knowledge-article-share-links.test.ts` drives all of it end to end - // and is the acceptance evidence; read it before changing anything here. - // - // ⚠️ TWO SPELLING TRAPS, both measured, both of which produce a block that - // LOOKS declared and silently is not: - // - // 1. `eligibility` must be a PLAIN STRING. It is `z.ZodString` in the spec - // and `getPolicy()` keeps it only when `typeof raw.eligibility === - // 'string'`. The `P` tagged template used by `validations[].condition` - // below returns an Expression OBJECT `{ dialect, source }` — passing one - // here does not narrow anything, it makes the predicate vanish. - // - // 2. Every field read is `record.`-PREFIXED. The evaluator is - // `ExpressionEngine` from `@objectstack/formula` (record-level CEL), and - // `record` is the ONLY binding it is given. The bare-identifier spelling - // `status == 'published' && audience == 'public'` COMPILES and then fails - // at evaluate with `Unknown variable: audience`, - // which `assertEligible` turns into ELIGIBILITY_UNEVALUABLE 422. That - // fails CLOSED, so it is not a security hole; it is a feature that never - // mints a single link while reading as if it works. - // - // The predicate is TOTAL for the same reason the `validations` below are: - // `has()` guards every read. `assertEligible` materializes declared fields to - // `null` first, so an absent key would not abort here today — the guards keep - // that true if the field set changes. (The `has(record.x)` caveat carried - // from objectstack#7861 is about `compileCelToFilter`, the SHARING-RULE path. - // That is a different evaluator, it is not on this code path, and it is not - // even exported from `@objectstack/plugin-sharing`. Verified, not assumed.) - // - // ⚠️ Eligibility is evaluated at MINT time only; `resolveToken()` does not - // re-check it. Re-classifying a published/public article to internal or back - // to draft does NOT revoke links already minted from it — those must be - // revoked explicitly. That is platform behaviour, filed upstream, not - // something this app compensates for app-side. - publicSharing: { - enabled: true, - // `public` and `link_only` only. `signed_in` would be a different feature - // and `email` is refused at creation without an allowlist. - allowedAudiences: ["public", "link_only"], - // Read-only. Same as the platform default, declared anyway: this is a - // security boundary, and a default is not a decision. - allowedPermissions: ["view"], - // The gate. Published AND public-audience, nothing else — a draft, an - // in_review, an archived, or any internal-audience article is refused at - // `createLink` with RECORD_NOT_ELIGIBLE 422 and no row is written. - eligibility: 'has(record.status) && record.status == "published" && has(record.audience) && record.audience == "public"', - // Stripped from every token-served response. These are the fields that - // exist for staff: who owns the article, which customer case it was - // written from, and when an editor last reviewed it. None of them are part - // of the answer a reader followed the link for. - redactFields: ["owner_id", "related_to_case", "last_reviewed_at"] - }, - // ADR-0079: render-only `titleFormat` retired in favor of `nameField`, - // which names a real field. The former template composed two local fields, so - // a `display_title` formula field reproduces it for the record title. - nameField: "display_title", - // Explicit search targets (ADR-0061). REQUIRED because nameField is a - // FORMULA (display_title/full_name): without this, $search auto-defaults to - // the formula field, which isn't a real column, so the lookup picker + global - // search silently return zero. These are real, indexed columns. - searchableFields: ["title", "article_number", "summary"], - highlightFields: ["article_number", "title", "category", "status", "audience"], - fieldGroups: [ - { key: "basic", label: "Article Information", icon: "info" }, - { key: "content", label: "Content", icon: "file-text" }, - { key: "taxonomy", label: "Categorization", icon: "tag" }, - { key: "metrics", label: "Engagement", icon: "activity", collapse: "collapsed" } - ], - fields: { - // Platform ownership anchor — canonical note in `account.object.ts` (#548). - owner_id: Field3.lookup("sys_user", { - label: "Article Owner", - group: "basic", - system: true, - readonly: false, - trackHistory: true - }), - article_number: Field3.autonumber({ - label: "Article Number", - format: "KA-{0000}", - group: "basic" - }), - title: Field3.text({ - label: "Title", - required: true, - storage: { notNull: true }, - searchable: true, - maxLength: 255, - group: "basic" - }), - // ADR-0079 record title (was titleFormat '{article_number} - {title}'). - display_title: Field3.formula({ - label: "Display Title", - expression: F2`record.article_number + " - " + record.title`, - group: "basic" - }), - summary: Field3.text({ - label: "Summary", - description: "One-paragraph TL;DR shown in search results and AI citations.", - maxLength: 500, - searchable: true, - group: "basic" - }), - body: Field3.markdown({ - label: "Body", - description: "Full article content (Markdown).", - searchable: true, - group: "content" - }), - category: Field3.select({ - label: "Category", - group: "taxonomy", - options: [ - { label: "Getting Started", value: "getting_started", default: true }, - { label: "How-To", value: "how_to" }, - { label: "Troubleshooting", value: "troubleshooting" }, - { label: "Billing & Pricing", value: "billing" }, - { label: "API & Integrations", value: "api" }, - { label: "Release Notes", value: "release_notes" }, - { label: "Policy", value: "policy" } - ] - }), - tags: Field3.select({ - label: "Tags", - multiple: true, - group: "taxonomy", - options: [ - { label: "Auth", value: "auth" }, - { label: "SSO", value: "sso" }, - { label: "Mobile", value: "mobile" }, - { label: "Email", value: "email" }, - { label: "Reports", value: "reports" }, - { label: "Performance", value: "performance" }, - { label: "Data Import", value: "data_import" }, - { label: "Webhooks", value: "webhooks" } - ] - }), - status: Field3.select({ - label: "Status", - required: true, - storage: { notNull: true }, - group: "basic", - trackHistory: true, - options: [ - { label: "Draft", value: "draft", color: "#94A3B8", default: true }, - { label: "In Review", value: "in_review", color: "#F59E0B" }, - { label: "Published", value: "published", color: "#10B981" }, - { label: "Archived", value: "archived", color: "#475569" } - ] - }), - audience: Field3.select({ - label: "Audience", - required: true, - storage: { notNull: true }, - group: "basic", - description: "Public articles are visible in the customer portal; internal articles are agent-only.", - options: [ - { label: "Public", value: "public", default: true, color: "#0EA5E9" }, - { label: "Internal", value: "internal", color: "#7C3AED" } - ] - }), - language: Field3.select({ - label: "Language", - group: "basic", - options: [ - { label: "English", value: "en", default: true }, - { label: "Simplified Chinese", value: "zh_cn" }, - { label: "Spanish", value: "es_es" }, - { label: "Japanese", value: "ja_jp" } - ] - }), - related_to_case: Field3.lookup("crm_case", { - label: "Originating Case", - description: "Case this article was authored from (optional).", - group: "content" - }), - published_at: Field3.datetime({ - label: "Published At", - readonly: true, - group: "basic" - }), - last_reviewed_at: Field3.datetime({ - label: "Last Reviewed At", - readonly: true, - group: "basic" - }), - /** - * `view_count` is GONE (#601), and this note is the record of why. - * - * All three engagement counters were `readonly: true` with a writer - * nowhere — on the platform or in this app — so all three were pinned at - * whatever the seed said, forever, while the article grid summed a "Views" - * column. ADR-0049's enforce-or-remove leaves two honest endings per - * field: give it a writer, or delete it. The card left this one to the - * implementer, and the two below went the other way, so the split is - * argued rather than assumed. - * - * A page-view writer WOULD have been expressible — `afterFind` is a real - * hook event on this platform. It is not built, because of what the event - * actually means: `beforeFind`/`afterFind` fire on record MATERIALIZATION, - * for `find` and `findOne` alike, with no per-method read event - * (deliberately — see the spec's note on #3195). So a counter written - * there would increment on the article grid, on global search, on the - * lookup picker in the close-case screen, on the AI grounding queries that - * cite articles — every one of them a "view" of a row nobody read. The - * number would grow fastest for articles nobody opens, and it would carry - * a database write on every read path in the app to do it. - * - * "Views" that means "appearances in any query" is a worse lie than a - * field that is missing, because it looks like data. A real page-view - * counter needs a real view event from a real article surface — the day - * one exists, this field comes back with it, and not before. - * - * `helpful_count` / `not_helpful_count` DO get a writer, and it is the - * whole reason `crm_article_feedback` exists: reader verdicts are recorded - * as rows and these two are RECOUNTED from them by - * `article_feedback_metrics_refresh`. They stay `readonly: true` and that - * is now an accurate statement — derived from evidence, never typed in. - */ - helpful_count: Field3.number({ - label: "Helpful Votes", - group: "metrics", - readonly: true, - defaultValue: 0, - description: "Recounted from crm_article_feedback \u2014 never typed in." - }), - not_helpful_count: Field3.number({ - label: "Not Helpful Votes", - group: "metrics", - readonly: true, - defaultValue: 0, - description: "Recounted from crm_article_feedback \u2014 never typed in." - }) - }, - indexes: [ - { fields: ["title"] }, - { fields: ["category"] }, - { fields: ["status"] }, - { fields: ["audience"] }, - { fields: ["language"] } - ], - // API surface. History → Field.trackHistory (ADR-0052). - enable: { - apiEnabled: true, - apiMethods: ["get", "list", "create", "update", "delete"] - }, - // Predicates below are TOTAL: every `record.x` read is `has()`-guarded, so the - // rule returns a verdict even when the merged record has no such key. See - // AGENTS.md "Validation predicates must be TOTAL" and - // test/object-validation-predicates.test.ts, which fails the build otherwise. - validations: [ - { - name: "published_requires_body", - type: "script", - severity: "error", - message: "Articles cannot be published without a body.", - condition: P3`has(record.status) && record.status == "published" && (!has(record.body) || record.body == null || record.body == "")` - }, - { - name: "published_requires_summary", - type: "script", - severity: "warning", - message: "Published articles should have a summary for search results and AI citations.", - condition: P3`has(record.status) && record.status == "published" && (!has(record.summary) || record.summary == null || record.summary == "")` - } - ] -}); - -// src/sales/objects/index.ts -var objects_exports2 = {}; -__export(objects_exports2, { - Account: () => Account, - Contact: () => Contact, - Event: () => Event, - EventAttendee: () => EventAttendee, - Forecast: () => Forecast, - Lead: () => Lead, - Opportunity: () => Opportunity, - Task: () => Task -}); - -// src/sales/objects/account.object.ts -import { ObjectSchema as ObjectSchema4, Field as Field4 } from "@objectstack/spec/data"; -import { F as F3 } from "@objectstack/spec"; - -// src/sales/objects/_picklists.ts -var SALUTATION_OPTIONS = [ - { label: "Mr.", value: "mr" }, - { label: "Ms.", value: "ms" }, - { label: "Mrs.", value: "mrs" }, - { label: "Dr.", value: "dr" }, - { label: "Prof.", value: "prof" } -]; -var INDUSTRY_OPTIONS = [ - { label: "Technology", value: "technology" }, - { label: "Software / SaaS", value: "software" }, - { label: "Finance", value: "finance" }, - { label: "Healthcare", value: "healthcare" }, - { label: "Retail", value: "retail" }, - { label: "Manufacturing", value: "manufacturing" }, - { label: "Education", value: "education" }, - { label: "Real Estate", value: "real_estate" }, - { label: "Media & Entertainment", value: "media" }, - { label: "Logistics", value: "logistics" }, - { label: "Hospitality", value: "hospitality" }, - { label: "Energy & Utilities", value: "energy" }, - { label: "Government", value: "government" }, - { label: "Non-profit", value: "nonprofit" }, - { label: "Other", value: "other" } -]; -var LEAD_SOURCE_OPTIONS = [ - { label: "Web", value: "web" }, - { label: "Referral", value: "referral" }, - { label: "Event / Trade Show", value: "event" }, - { label: "Webinar", value: "webinar" }, - { label: "Partner", value: "partner" }, - { label: "Advertisement", value: "advertisement" }, - { label: "Paid Search", value: "paid_search" }, - { label: "Social Media", value: "social" }, - { label: "Content / Blog", value: "content" }, - { label: "Cold Call", value: "cold_call" }, - { label: "Email Campaign", value: "email_campaign" }, - { label: "Other", value: "other" } -]; -var PAYMENT_TERMS_OPTIONS = [ - { label: "Net 15", value: "net_15" }, - { label: "Net 30", value: "net_30", default: true }, - { label: "Net 60", value: "net_60" }, - { label: "Net 90", value: "net_90" }, - { label: "Due on Receipt", value: "due_on_receipt" } -]; -var TASK_TYPE_OPTIONS = [ - { label: "Call", value: "call" }, - { label: "Email", value: "email" }, - { label: "Meeting", value: "meeting" }, - { label: "Follow-up", value: "follow_up" }, - { label: "Demo", value: "demo" }, - { label: "Other", value: "other" } -]; -var OPPORTUNITY_STAGE_OPTIONS = [ - { label: "Prospecting", value: "prospecting", color: "#808080", default: true }, - { label: "Qualification", value: "qualification", color: "#FFA500" }, - { label: "Needs Analysis", value: "needs_analysis", color: "#FFD700" }, - { label: "Proposal", value: "proposal", color: "#4169E1" }, - { label: "Negotiation", value: "negotiation", color: "#9370DB" }, - { label: "Closed Won", value: "closed_won", color: "#00AA00" }, - { label: "Closed Lost", value: "closed_lost", color: "#FF0000" } -]; -var EVENT_TYPE_OPTIONS = [ - { label: "Meeting", value: "meeting", color: "#4169E1", default: true }, - { label: "Call", value: "call", color: "#00AA00" }, - { label: "Demo", value: "demo", color: "#9370DB" }, - { label: "Webinar", value: "webinar", color: "#FFA500" }, - { label: "Onsite Visit", value: "onsite_visit", color: "#0EA5E9" }, - { label: "Other", value: "other", color: "#808080" } -]; -var EVENT_STATUS_OPTIONS = [ - { label: "Planned", value: "planned", color: "#4169E1", default: true }, - { label: "Held", value: "held", color: "#00AA00" }, - { label: "Cancelled", value: "cancelled", color: "#999999" }, - { label: "No Show", value: "no_show", color: "#FF4500" } -]; -var ATTENDEE_RESPONSE_OPTIONS = [ - { label: "No Response", value: "no_response", color: "#808080", default: true }, - { label: "Accepted", value: "accepted", color: "#00AA00" }, - { label: "Declined", value: "declined", color: "#FF0000" }, - { label: "Tentative", value: "tentative", color: "#FFA500" } -]; -var RELATED_TO_TYPE_OPTIONS = [ - { label: "Account", value: "crm_account" }, - { label: "Contact", value: "crm_contact" }, - { label: "Opportunity", value: "crm_opportunity" }, - { label: "Lead", value: "crm_lead" }, - { label: "Case", value: "crm_case" } -]; -var DUPLICATE_OF_TYPE_AUTHORABLE_OPTIONS = [ - { label: "Lead", value: "crm_lead" }, - { label: "Contact", value: "crm_contact" } -]; -var DUPLICATE_OF_TYPE_ERASED = "erased"; -var DUPLICATE_OF_TYPE_OPTIONS = [ - ...DUPLICATE_OF_TYPE_AUTHORABLE_OPTIONS, - { label: "Erased Record", value: DUPLICATE_OF_TYPE_ERASED } -]; -var plainOptions = (options) => options.map(({ label, value }) => ({ label, value })); -var LEAD_NEED_TYPE_OPTIONS = [ - { label: "New Implementation", value: "new_implementation" }, - { label: "Expansion", value: "expansion" }, - { label: "Replacement", value: "replacement" }, - { label: "Renewal", value: "renewal" }, - { label: "Consulting", value: "consulting" }, - { label: "Support & Maintenance", value: "support" }, - { label: "Other", value: "other" } -]; - -// src/sales/objects/_territory.ts -var TERRITORY = { - NA: "na", - EMEA: "emea", - OTHER: "other" -}; -var TERRITORY_OPTIONS = [ - { label: "North America", value: TERRITORY.NA, color: "#0070D2" }, - { label: "EMEA", value: TERRITORY.EMEA, color: "#7C3AED" }, - { label: "Other", value: TERRITORY.OTHER, color: "#999999" } -]; -var TERRITORY_FALLBACK = TERRITORY.OTHER; -var TERRITORY_COUNTRIES = { - na: ["US", "CA", "MX"], - emea: ["GB", "DE", "FR", "IT", "ES"] -}; -var COUNTRY_ALIASES = { - "United States": "US", - "United States of America": "US", - USA: "US", - Canada: "CA", - Mexico: "MX", - UK: "GB", - "United Kingdom": "GB", - "Great Britain": "GB", - Germany: "DE", - France: "FR", - Italy: "IT", - Spain: "ES" -}; -var COUNTRY_TERRITORY = (() => { - const map = {}; - for (const [territory, countries] of Object.entries(TERRITORY_COUNTRIES)) { - for (const code of countries) map[code] = territory; - } - for (const [alias, code] of Object.entries(COUNTRY_ALIASES)) { - const territory = map[code]; - if (!territory) { - throw new Error(`COUNTRY_ALIASES: "${alias}" points at "${code}", which no territory covers`); - } - const key = normalizeCountry(alias); - if (map[key] && map[key] !== territory) { - throw new Error(`COUNTRY_ALIASES: "${alias}" collides with an entry mapped to "${map[key]}"`); - } - map[key] = territory; - } - return map; -})(); -function normalizeCountry(value) { - return typeof value === "string" ? value.trim().replace(/\s+/g, " ").toUpperCase() : ""; -} - -// src/sales/objects/account.object.ts -var Account = ObjectSchema4.create({ - name: "crm_account", - label: "Account", - pluralLabel: "Accounts", - icon: "building", - description: "Companies and organizations doing business with us", - // ADR-0090 D1/D7: OWD is an authored decision. Owner + sharing rules (team/territory grants below). - sharingModel: "private", - // ADR-0079: render-only `titleFormat` retired in favor of `nameField`, - // which names a real field. The former template composed two local fields, so - // a `display_title` formula field reproduces it for the record title. - nameField: "display_title", - // Explicit search targets (ADR-0061). REQUIRED because nameField is a - // FORMULA (display_title/full_name): without this, $search auto-defaults to - // the formula field, which isn't a real column, so the lookup picker + global - // search silently return zero. These are real, indexed columns. - searchableFields: ["name", "account_number", "registration_number"], - highlightFields: ["account_number", "name", "type", "owner_id"], - // The record's picture (#1199): the record chrome draws the logo beside the - // title in every account page header. No logo, no picture: the platform - // draws no placeholder or initials in its place. - imageField: "logo", - // Field groups organize the form layout. Array order == display order. - // Each field below opts in via `group: ''`. - fieldGroups: [ - { key: "basic", label: "Basic Information", icon: "building" }, - { key: "financials", label: "Financials", icon: "dollar-sign" }, - // REQ-0003 acceptance 3: the business-profile fields render as their own - // group with NO `record:details` section authored anywhere — the derived - // layout ladder's rung 1 (AGENTS.md: escape hatches are for extreme cases). - { key: "business_profile", label: "Business Profile", icon: "briefcase" }, - { key: "contact_info", label: "Contact Information", icon: "phone" }, - { key: "ownership", label: "Ownership & Status", icon: "users" }, - { key: "branding", label: "Branding", icon: "palette", collapse: "collapsed" }, - { key: "system", label: "System", icon: "settings", collapse: "collapsed" } - ], - fields: { - // ─── Ownership ───────────────────────────────────────────────────── - // - // `owner_id` is the PLATFORM ownership anchor, not an app invention: the - // registry injects exactly this column into every user-owned object - // (`applySystemFields`), and it is the one OWD, sharing rules, owner-scope - // widening and the `is_private` row filter all read. ⛔ Never author a - // SECOND `owner` lookup beside it — reassigning that moves the record in - // every list and report and moves no access at all. - // - // ⚠️ Declared rather than left to injection, which the platform supports - // explicitly ("author-declared fields with the same name always win over - // injection, no overwrite"). Three things only a declaration buys: - // • `os validate` resolves it. An injected column is invisible to every - // author-time rule, so `highlightFields: ['owner_id']` is reported as - // "not a field on this object — silently skipped by every consumer", - // and a CEL predicate reading `record.owner_id` fails outright. - // • the per-object label and `group` survive (an injected field carries - // the generic label "Owner" and no group at all); - // • `trackHistory` survives, so a transfer still renders on the record - // timeline instead of only in the compliance audit log. - // `system: true` keeps the injected marker the platform's own tooling - // reads — notably the clone path, which strips system columns so a copy is - // stamped to the cloner rather than inheriting the source's owner. - // - // No `defaultValue`: the security middleware stamps `owner_id` to the - // acting user on any insert that leaves it empty, and denies one that names - // another user without `allowTransfer` (#3004). That is stronger than a - // field default, which evaluates to nothing on every user-less write. - owner_id: Field4.lookup("sys_user", { - label: "Account Owner", - group: "ownership", - system: true, - readonly: false, - trackHistory: true - }), - // AutoNumber field - Unique account identifier - account_number: Field4.autonumber({ - label: "Account Number", - format: "ACC-{000000}", - group: "basic" - }), - // Basic Information - // - // ⚠️ `unique: true` is declared HERE, on the field, and deliberately NOT as - // a `{ fields: ['name'], unique: true }` entry in `indexes[]` below. The - // field-level form is tenant-scoped — it materializes as - // `(organization_id, name)`, unique WITHIN an organization — while a - // declared index is taken verbatim, i.e. platform-wide. The table form - // means the SECOND organization to create an "Acme Corp" is rejected by the - // database, and account name is also the seed data's external-id / upsert - // key (`src/sales/data/sales.seed.ts`), so it bites the first multi-tenant - // install. The composite also indexes the column, so no separate - // `{ fields: ['name'] }` entry is needed for the `searchableFields` / - // seed-upsert read paths. - name: Field4.text({ - label: "Account Name", - required: true, - storage: { notNull: true }, - searchable: true, - unique: true, - maxLength: 255, - group: "basic" - }), - /** - * Case- and whitespace-folded copy of `name` — the key lead conversion - * matches accounts on. - * - * ### Why a stored column, and not any of the cheaper shapes - * - * ⚠️ Three cheaper fixes are all dead ends, and each is a live platform - * constraint. `test/account-name-normalized-match.test.ts` re-measures every - * one so this note cannot quietly go stale: - * - * - **A flow cannot normalize.** `service-automation`'s `resolveToken` - * understands exactly one function form, `/^(NOW|TODAY)\s*\(\s*\)…/`. - * `{LOWER(x)}`, `{TRIM(x)}` and `{x.toLowerCase()}` all resolve to - * `undefined` (every bare identifier is substituted before the expression - * is evaluated, so no string method is reachable), and an unwrapped - * `LOWER({x})` interpolates literally to `"LOWER(Acme Corp)"`. - * - **A formula field cannot be the match key.** `driver-sql`'s - * `fieldHasColumn` returns false for `type: 'formula'`, so a computed - * value has no physical column and nothing can filter on it. - * - **`$regex` is not an answer.** On `driver-sql` it does not run as a - * regex at all: it compiles to `LIKE '%value%'`, a SUBSTRING match, so - * `"Acme Corp"` also matches `"Not Acme Corp Ltd"`. It cannot collapse - * internal whitespace, the leading wildcard defeats the index, and on the - * in-memory driver it does compile user-controlled text into a `RegExp`. - * - * So the canonical form is established by the PRODUCER at write time — the - * same doctrine `crm_lead.email` / `crm_contact.email` follow — and the - * reader does a plain, indexed equality match. The other side of that - * comparison is `crm_lead.company_normalized`, which exists for the same - * reason: a flow can compare two stored columns, it cannot compute either. - * - * ### What it holds - * - * `name`, trimmed, lower-cased, with runs of internal whitespace collapsed - * to one space. Nothing else — normalize-then-EXACT. Fuzzy matching - * (punctuation folding, legal-suffix stripping, edit distance) is - * deliberately out of scope; it turns a lookup into a ranking problem and - * needs a human review affordance this app does not have. - * - * Derived, never authored: `account.hook.ts` recomputes it on every write - * that carries `name`, and leaves it alone otherwise. `readonly` keeps - * user/API writes off it (INSERT is exempt from the strip and UPDATE strips - * only CALLER-supplied keys, so the hook's own write always survives); - * `hidden` keeps a machine-owned column out of forms and pickers — the same - * pairing `crm_forecast.seed_key` uses. - */ - name_normalized: Field4.text({ - label: "Account Name (Normalized)", - description: "Match key for lead conversion: Account Name lower-cased, trimmed, with internal whitespace collapsed. Maintained by the account_protection hook \u2014 never edit directly.", - readonly: true, - hidden: true, - maxLength: 255, - group: "system" - }), - // ADR-0079 record title (was titleFormat '{account_number} - {name}'). - display_title: Field4.formula({ - label: "Display Title", - expression: F3`record.account_number + " - " + record.name`, - group: "basic" - }), - /** - * The counterparty's registered identity in a government registry. - * - * ⛔ NOT named after one country's registry, and that is the whole design - * constraint (REQ-0003 *Disposition & rationale*). The requirement arrived - * as 社会信用代码 because the customer registers in China; a Japanese install - * writes 法人番号 here, a German one a Handelsregisternummer, a US one an - * EIN. A `unified_social_credit_code` field would carry one country's - * registry in its NAME, where no install can rename it — so the core field - * is generic and the registry it came from is the install's own knowledge. - * - * ⚠️ Distinct from `account_number` above, which is OUR sequence - * (`Field.autonumber`, `ACC-{000000}`) and already spent as half the record - * title. That is an identifier we issue; this is one we were given, and - * invoicing, credit checks and entity resolution key on the latter. - * - * `searchable` + the `searchableFields` entry above is REQ-0003 acceptance - * 1 — the value is findable from global search and the lookup picker. It is - * indexed below for that read path. - * - * ⛔ NOT `unique: true`. Refusing a save because two rows carry the same - * registered identity is a data-quality POLICY, and this repo has already - * chosen the soft shape for that question once — the hard unique on - * `crm_lead.email` was removed because refusing a repeat is worse than - * recording it. The same reasoning `name_normalized` records: a match key, - * not a policy. Deduplication is a review affordance this app does not have. - */ - registration_number: Field4.text({ - label: "Registration Number", - description: "The counterparty's registered identity as issued by its own government registry \u2014 whichever registry that is. Not the Account Number, which we issue.", - searchable: true, - maxLength: 64, - group: "basic" - }), - /** - * What this account may be used for commercially — the category that GATES - * capability rather than merely classifying (REQ-0003, the record's most - * valuable primitive: *some counterparties are payable but not sellable*). - * - * ## Why a field BESIDE `type`, and not four more options on it - * - * REQ-0003 leaves this open ("either new options on `type` or a field - * beside it, decided when built"). It is a separate field because `type` - * is a RELATIONSHIP-STAGE axis — prospect → customer → former, plus - * partner — and it already has two readers that would be broken by a value - * meaning "may not be sold to": `account.hook.ts` promotes on it, and - * `opportunity.hook.ts` flips a won deal's account to `customer`. An - * `agency` option on `type` would therefore be overwritten into `customer` - * by the first won deal booked against it, silently un-restricting the - * account. The two axes are independent — an agency can be a prospect, a - * customer or a former customer — so they are two fields. - * - * ## Generic values only - * - * REQ-0003 rules the customer's own vocabulary (招标代理公司 …) **C**: - * overlay configuration, ⛔ never committed into core. Core ships the - * capability distinction itself; an install maps its market's categories - * onto these two values. - * - * ## What reads it: `opportunity.hook.ts` `beforeInsert` - * - * REQ-0003 is explicit that "a category no rule reads is prose, and the - * rule is the point", so this field ships WITH its reader. The reader is a - * hook, and which construct carries the gate is a maintainer ruling - * (2026-09-16), quoted verbatim and kept untranslated: - * - * 「闸门走 `opportunity.hook.ts` 的 `beforeInsert`，用 hook 的 `ctx.api` 读客户类别。 - * REQ-0003 第 128 行的 `validations[]` 与该记录自己的验收第 2 条冲突，以验收为准。」 - * - * ⛔ Do NOT restate the gate as the `validations[]` entry REQ-0003 line - * 128 names. TWO independent measurements say it cannot be that, and both - * are recorded here because each alone would be talked past: - * - * 1. **It would brick history.** A validation is evaluated against - * `{...previous, ...data}` on EVERY write, so "already linked to a - * restricted account" and "linking now" are the same state and every - * later edit to every historical opportunity would be refused — the - * exact thing REQ-0003 acceptance 2 forbids ("opportunities that - * already point at it keep working and keep being editable"). - * `lead.hook.ts` carries the same finding for its own gate. - * 2. **It cannot read the account at all.** A predicate is evaluated by - * `checkPredicate(rule, merged, previous)` over plain data objects — - * the opportunity's OWN stored columns. `record.crm_account.type` - * does not traverse the lookup (measured: `runtime: No such key: - * type`), and `os.lookup(...)` has no overload because `buildScope()` - * in `@objectstack/formula` composes `os` from only `ctx.user` / - * `ctx.org` / `ctx.env` and never binds `ctx.api` (measured: - * `runtime: found no matching overload for 'dyn.lookup(string, - * dyn)'`; filed upstream as objectstack#18318). An unevaluable - * predicate REJECTS THE WRITE, so authoring it literally refuses - * every opportunity write, insert and update alike. - * - * ⚠️ The hook's `ctx.api` is a DIFFERENT surface from the formula - * `EvalContext.api` that measurement 2 is about, and the two are routinely - * confused. The hook one is live and used ~20 times across - * `src/sales/objects/*.hook.ts`; its shape is `./_hook-api.ts`, pinned - * against a real engine by `test/hook-query-predicate.test.ts` and - * `test/hook-write-shape.test.ts`. objectstack#18318 does not block this - * field. - * - * ⛔ Do NOT "fix" anything here by denormalising this value onto - * `crm_opportunity`: a copy needs a writer and goes stale the moment an - * account is reclassified, and anything able to write the copy is able to - * simply refuse. - */ - commercial_capability: Field4.select({ - label: "Commercial Capability", - group: "basic", - description: "Whether new business may be opened against this account. Settlement Only accounts stay fully usable for billing and payment, but no new opportunity may be linked to them.", - defaultValue: "full", - options: [ - { label: "Full", value: "full", color: "#00AA00", default: true }, - { label: "Settlement Only", value: "settlement_only", color: "#FFA500" } - ] - }), - // Select fields with custom options - type: Field4.select({ - label: "Account Type", - group: "basic", - options: [ - { label: "Prospect", value: "prospect", color: "#FFA500", default: true }, - { label: "Customer", value: "customer", color: "#00AA00" }, - { label: "Partner", value: "partner", color: "#0000FF" }, - { label: "Former Customer", value: "former", color: "#999999" } - ] - }), - industry: Field4.select({ - label: "Industry", - group: "basic", - // Canonical set shared with Lead (#490): lead_conversion copies - // `leadRecord.industry` onto the account it creates, so this must - // accept every Lead value. - options: [...INDUSTRY_OPTIONS] - }), - description: Field4.markdown({ - label: "Description", - group: "basic" - }), - // Number fields - annual_revenue: Field4.currency({ - label: "Annual Revenue", - min: 0, - group: "financials", - trackHistory: true - }), - /** - * Rolled-up annual revenue of this account's direct children. - * - * ⚠️ DIRECT children only, one level — the engine aggregates over the rows - * whose `parent_account` is this account, not over a transitive closure. A - * grandparent shows the sum of its own children, and the docs say so; - * anything else needs a different (and much more expensive) primitive than - * the one the platform ships. - * - * Self-referencing roll-ups are worth measuring rather than assuming, - * because parent and child are the same object and the engine's summary - * index is keyed by child object. `test/decorative-field-sweep.test.ts` - * drives all four legs of the lifecycle (insert, raise, re-parent, delete) - * so a platform regression cannot quietly turn this back into decoration. - */ - child_account_revenue: Field4.summary({ - label: "Child Account Revenue", - group: "financials", - scale: 2, - summaryOperations: { - object: "crm_account", - field: "annual_revenue", - function: "sum", - relationshipField: "parent_account" - } - }), - number_of_employees: Field4.number({ - label: "Employees", - min: 0, - group: "financials" - }), - // ─── Business profile (REQ-0003 step 3) ──────────────────────────── - // - // Generic B2B sales intelligence, not IT-services vocabulary: who holds the - // account today, how much there is to win this year, and how they pay. - // - // ⚠️ `annual_revenue` above answers none of these — it is the account's OWN - // turnover, what the counterparty earns, whereas the budget below is what - // it will SPEND with vendors. Reusing one for the other is the mistake this - // group exists to prevent. - // - // ⚠️ `pnpm validate` reports all three as "carrier-only — declared but - // nothing in this stack reads or displays it", and that reading is EXPECTED - // here rather than a defect to tidy away. The liveness diagnostic counts - // view columns, form sections, page bindings, flow nodes, formulas, hooks - // and actions as sites; it does NOT count `fieldGroups` membership, which - // is precisely the DERIVED layout REQ-0003 acceptance 3 asks for ("render - // as their own group … without any `record:details` section being - // authored"). These are data-entry fields a person fills in and a person - // reads off the derived form. ⛔ Do NOT answer the warning by authoring a - // `record:details` section — that is the escape hatch AGENTS.md reserves - // for a named customer demand, and it would trade acceptance 3 for a - // quieter log. No guard reads this warning. - incumbent_vendor: Field4.text({ - label: "Incumbent Vendor", - description: "The supplier currently holding this account for the spend we are chasing.", - maxLength: 255, - group: "business_profile" - }), - annual_purchasing_budget: Field4.currency({ - label: "Annual Purchasing Budget", - description: "What this account expects to SPEND with vendors this year \u2014 not its own revenue.", - min: 0, - group: "business_profile" - }), - // Payment terms as a select, not free text: it is read by a person sizing - // cash-flow risk, and a picklist keeps that domain knowable. The values are - // the net-terms ladder every B2B install shares; a customer whose contracts - // use a different ladder overlays its own. - payment_cycle: Field4.select({ - label: "Payment Cycle", - group: "business_profile", - options: [ - { label: "Prepaid", value: "prepaid" }, - { label: "Net 30", value: "net_30" }, - { label: "Net 60", value: "net_60" }, - { label: "Net 90", value: "net_90" } - ] - }), - // Contact Information - phone: Field4.text({ - label: "Phone", - format: "phone", - group: "contact_info" - }), - website: Field4.url({ - label: "Website", - group: "contact_info" - }), - // Structured Address field (new field type) - billing_address: Field4.address({ - label: "Billing Address", - group: "contact_info" - }), - /** - * Flat projection of `billing_address.country`. - * - * ### Why the flat column exists — the trap that catches every rule - * ### authored against an `address` - * - * ⚠️ `billing_address` is an `address` field: the platform stores the whole - * {street, city, state, postalCode, country, countryCode, formatted} value - * in ONE column. A sharing rule's CEL condition is compiled to a - * pushdown-able `FilterCondition` by `compileCelToFilter`, and that compiler - * rejects every path reaching INSIDE such a value: - * - * record.billing_address.country in ["US","CA","MX"] - * → unsupported: cross-object/nested field path - * "record.billing_address.country" is not pushdown-able - * - * `plugin-sharing` then refuses to seed the rule rather than degrade it to - * match-all, so the rule is dropped on every boot and its recipients get - * nothing at all. Measured: the blocker is the NESTED PATH, not the - * `in [...]` operator — `in [...]`, `==`, `!=`, `<`, `>`, `&&`, `||`, `!`, - * `startsWith()` and `== null` all compile fine against a FLAT field. - * Rewriting the condition as a disjunction of `==` therefore does NOT help; - * only a flat column does. `test/sharing-seeding.test.ts` measures that - * matrix instead of assuming it. - * - * ### What it holds - * - * `billing_address.country`, trimmed, internal whitespace collapsed, and - * upper-cased — nothing else. It is what was TYPED, so it is still free - * text and still capable of holding `Deutschland`. Nothing matches against - * it: `territory` below classifies it, and an unrecognised spelling lands in - * a stated `other`. `countryCode` is deliberately not consulted; see the - * note in `account.hook.ts` for why the ISO slot is not the input. - * - * Derived, never authored: `account.hook.ts` recomputes it on every write - * that carries `billing_address`, and leaves it untouched otherwise. - */ - billing_country: Field4.text({ - label: "Billing Country", - description: "Derived from Billing Address \u2014 the country exactly as it was entered, trimmed and upper-cased. Territory is classified from it.", - readonly: true, - maxLength: 64, - group: "contact_info" - }), - /** - * Territory — the declared value the territory sharing rules filter on. - * - * ### Why a select and not the country - * - * Matching free-text `billing_country` against a list of country codes - * inside a CEL string means an account whose address reads `United States` - * belongs to NO territory, silently — the metadata says territory sharing - * works and for that account it does nothing, with no error anywhere. A - * `select` makes the domain knowable: three values, declared, every one - * reachable, and an account outside the staffed territories says `other` - * rather than nothing. - * - * It also collapses four copies of the country list (two CEL strings and - * six localised documentation tables) into one authored table in - * `./_territory.ts`. Adding a country is a line there; the sharing rules, - * this picklist and the docs all follow, and - * `test/territory-single-source.test.ts` fails if any of them does not. - * - * ### Readonly, and always stated - * - * Derived by `account_protection` from `billing_address.country`, never - * authored — correcting an account's territory means correcting its - * address, which keeps ONE fact behind the classification. Every insert - * states it (an account with no address at all is `other`), and an update - * that does not carry the address leaves it alone. - */ - territory: Field4.select({ - label: "Territory", - description: "Derived from Billing Address \u2014 the sales territory this account belongs to. Accounts outside the staffed territories are Other.", - readonly: true, - options: [...TERRITORY_OPTIONS], - group: "contact_info" - }), - // Office Location (new field type) - office_location: Field4.location({ - label: "Office Location", - group: "contact_info" - }), - // Relationship fields - /** - * The account hierarchy. `child_account_revenue` below is its one reader — - * the platform computes roll-up summaries itself, so the honest consumer is - * a single declaration rather than hand-written recompute hooks. - */ - parent_account: Field4.lookup("crm_account", { - label: "Parent Account", - description: "Parent company in hierarchy", - group: "ownership" - }), - // Boolean field - is_active: Field4.boolean({ - label: "Active", - defaultValue: true, - group: "ownership", - trackHistory: true - }), - /** - * Where this account stands in its sign-off (REQ-0003 step 5 / acceptance 4). - * - * `readonly`, so only the platform's own approval write reaches it: a - * user's insert or edit that names this column has it stripped (measured - * on 17.7.0 for `approved`, `pending` and `rejected` alike, #2067). - * - * ⛔ NOT a second boolean beside `is_active`, which REQ-0003 rules out by - * name. `is_active` answers "is this account live at all"; this answers - * "has the record been signed off", and collapsing them would make - * deactivating an account indistinguishable from rejecting one. - * - * ⚠️ Ships with NO default, and that is what keeps the gate armed (#2067). - * A new account is born blank, `account_approval` starts on the blank, and - * its approval node opens the request; the node's `approvalStatusField` - * mirror then writes `pending` (plugin-approvals `openNodeRequest`) before - * the create returns; only the create's own response body still shows the - * blank row it inserted. So with approvals in the composition REQ-0003 - * acceptance 4 holds in as many words ("A newly created account sits in a - * pending state, appears in the platform approval inbox …"), and `pending` - * always has a request behind it. Without approvals (a plan or edition - * that omits the capability) nothing opens a request, so nothing writes - * `pending`: the account stays blank and editable instead of reading - * "locked for approval" forever, which is what a shipped `pending` default - * did, since the console derives its lock from this column's value. - * - * ⛔ Do not restore `defaultValue: 'pending'`, nor an option-level - * `default: true` on Pending (the form would preselect it). An install - * that wants no account sign-off ADDS `defaultValue: 'approved'`; the - * flow's start condition is then false for every record and the gate is - * off, switchable and inert. That is the same kind of off switch - * `crm_lead.conversion_approval_status` records, and ⛔ NOT the flow's - * `status`, for the reasons measured in `lead-conversion-approval.flow.ts`. - * - * ⛔ There is deliberately no `not_required` value. Blank already says - * "no request has been opened", and `approved` already spells "nothing to - * decide". - */ - approval_status: Field4.select({ - label: "Approval Status", - group: "ownership", - readonly: true, - trackHistory: true, - options: [ - { label: "Pending", value: "pending", color: "#FFA500" }, - { label: "Approved", value: "approved", color: "#00AA00" }, - { label: "Rejected", value: "rejected", color: "#FF0000" } - ] - }), - // Brand color (new field type) - brand_color: Field4.color({ - label: "Brand Color", - group: "branding" - }), - // Company logo (uploaded image). `accept` / `maxSize` are server-enforced - // from @objectstack 17 — see the note on `crm_product.image`. - logo: Field4.image({ - label: "Company Logo", - group: "branding", - accept: ["image/png", "image/jpeg", "image/svg+xml", "image/webp"], - maxSize: 2 * 1024 * 1024 - }), - // Date field - // - // ⛔ NOT `readonly`, and it must not become readonly. This is the signal - // `at_risk_accounts` and `customer_churn_signals` are built on, and it is - // written by ONE path: another object's hook calling - // `api.object('crm_account').update({ last_activity_date }, …)`. - // - // ⚠️ Platform constraint: `stripReadonlyFields` deletes a readonly key from - // any payload whose CALLER supplied it, for every context that is not - // `isSystem` — and a hook's `ctx.api` is a `ScopedContext` over the ACTING - // USER's execution context, not a system one. So a readonly field a hook - // writes is silently dropped: the engine logs `Field '…' is read-only — - // ignoring incoming change` and the column stays null forever. - // - // ⛔ `crm_campaign_member.added_date` was cited here as a twin and is NOT - // one — it was ruled `readonly: true` in #1667 precisely because its - // writers are INSERTs, which the strip never reaches. THIS field is an - // UPDATE through a hook's `ctx.api`, which is the one shape that cannot be - // `readonly`. Note the rule - // is about the CONTEXT, not about hooks or flows as such — a hook stamping - // its own `ctx.input.data` survives, and a flow survives when its `runAs` - // is `'system'` (measured: `test/readonly-write-semantics.test.ts`, #1429; - // `crm_case.is_sla_violated` is cited elsewhere as a twin of this field - // and is NOT one — its writer is a system flow). This field stays out of - // every form section instead, which is the protection that actually - // holds. `test/activity-recency.test.ts` proves - // the write lands — and fails if the flag comes back. - last_activity_date: Field4.date({ - label: "Last Activity Date", - group: "system" - }), - // ─── Customer Success / Account Health ──────────────────────────── - tier: Field4.select({ - label: "Customer Tier", - group: "ownership", - options: [ - { label: "Strategic", value: "strategic", color: "#7C3AED" }, - { label: "Enterprise", value: "enterprise", color: "#4169E1" }, - { label: "Mid-Market", value: "mid_market", color: "#00AA00" }, - { label: "SMB", value: "smb", color: "#FFA500", default: true } - ] - }), - segment: Field4.select({ - label: "Segment", - group: "ownership", - options: [ - { label: "Net New", value: "net_new" }, - { label: "Growth", value: "growth" }, - { label: "At Risk", value: "at_risk" }, - { label: "Stable", value: "stable" } - ] - }), - health_score: Field4.select({ - label: "Health Score", - group: "ownership", - description: "CSM-maintained health indicator", - options: [ - { label: "Healthy", value: "healthy", color: "#00AA00" }, - { label: "Watching", value: "watching", color: "#FFA500" }, - { label: "At Risk", value: "at_risk", color: "#FF4500" }, - { label: "Churning", value: "churning", color: "#FF0000" } - ] - }) - // ⛔ No account-level renewal model here, on purpose. Renewal is a - // CONTRACT-level process with exactly one home — `crm_contract.end_date` + - // `renewal_notice_days`, swept daily by `src/revenue/flows/contract-renewal.flow.ts`, - // which books the task and notifies the CONTRACT owner; the user-facing - // queue is that object's `renewal_calendar` view. A `renewal_owner` / - // `next_renewal_date` pair here would be declared and inert, telling an - // admin a renewal reaches the CSM they named when nothing would. If an - // account-level renewal owner is ever wanted, it is a change to that flow - // plus a real writer for the date — not a second pair of fields. - }, - // Database indexes for performance - // - // ⚠️ No `{ fields: ['name'], unique: true }` here. Account-name uniqueness is - // declared on the `name` field itself, which the framework builds as the - // tenant composite `(organization_id, name)`. Declaring the single-column - // index too makes the platform-wide constraint win and leaves the per-tenant - // one unreachable (framework#3991 `unique/double-declaration`) — the same - // trap `crm_contact`, `crm_lead` and `crm_product` document. Two - // organizations must be able to each have their own "Acme Corp". - indexes: [ - { fields: ["owner_id"] }, - { fields: ["type", "is_active"] }, - // The territory sharing rules filter on this column, so it is read on every - // account query a territory recipient makes. `billing_country` carries no - // index of its own: nothing filters on it — it is displayed, and classified - // into this column by the hook. - { fields: ["territory"] }, - // Lead conversion filters on this column on every conversion — the column - // exists to replace an unindexed `$regex` scan. Plain index, NOT - // `unique: true`, deliberately: - // - // 1. Per-tenant uniqueness of account names is already declared on the - // `name` field. A unique `name_normalized` would SUBSUME it (equal names - // normalize equally) and force that constraint to be re-decided. - // 2. This column is a MATCH key, not a policy. Rejecting a near-duplicate - // name outright is a separate data-quality decision, and this repo has - // already chosen the soft shape for that question once (the hard unique - // on `crm_lead.email` was removed because refusing a repeat enquiry is - // worse than recording it). - // 3. ⚠️ Measured hazard: `create_index` FAILS on any deployment already - // holding `Acme Corp` and `ACME Corp` separately, so a unique index - // could not be an upgrade step without a merge pass first. That hazard - // is bounded today ONLY because this repo's deployment shape is fresh - // installs — see docs/MAINTENANCE.md §3.3. The conclusion is conditional - // on that premise, not universal. - // - // Consequence, recorded rather than hidden: two accounts CAN still hold the - // same normalized name if something outside the flow creates them, and - // `get_record` has no `sort` option, so the conversion would reuse an - // arbitrary one. Reusing one of N is still better than creating the N+1th. - { fields: ["name_normalized"] }, - // `searchableFields` carries `registration_number`, and the note at the top - // of this file records why those must be real, indexed columns. - { fields: ["registration_number"] } - ], - // API surface + capabilities. `files` and `feeds` are live and enforced (see - // the canonical note in `src/sales/objects/index.ts`). Field history lives on - // individual `Field.trackHistory` (ADR-0052); global search uses - // `searchableFields` / per-field `searchable`. - enable: { - apiEnabled: true, - // Expose via REST/GraphQL - apiMethods: ["get", "list", "create", "update", "delete"], - // Whitelist allowed API operations - // Contracts, org charts and RFPs live on the account record. Opt-in (spec - // default false); attach/download/delete authority is the parent record's - // own, so this adds a surface, not a grant. - files: true - } - // ⚠️ No `workflows[]` here, and none is possible: object `workflows[]` were - // removed from the platform. Field updates live in this object's `*.hook.ts`; - // scheduled status flips and notifications live in `src/*/flows/*.flow.ts`. -}); - -// src/sales/objects/contact.object.ts -import { ObjectSchema as ObjectSchema5, Field as Field5 } from "@objectstack/spec/data"; -import { F as F4 } from "@objectstack/spec"; -var Contact = ObjectSchema5.create({ - name: "crm_contact", - label: "Contact", - pluralLabel: "Contacts", - icon: "user", - description: "People associated with accounts", - // ADR-0090 D1/D7: OWD is an authored decision. Master-detail child of crm_account — inherits the account's sharing. - sharingModel: "controlled_by_parent", - fieldGroups: [ - { key: "identity", label: "Identity", icon: "user" }, - { key: "account_info", label: "Account & Title", icon: "briefcase" }, - { key: "buying_centre", label: "Buying Centre", icon: "users" }, - { key: "contact_info", label: "Contact Information", icon: "phone" }, - { key: "mailing_address", label: "Mailing Address", icon: "map-pin", collapse: "collapsed" }, - { key: "additional", label: "Additional Info", icon: "info", collapse: "collapsed" }, - { key: "preferences", label: "Communication Preferences", icon: "bell-off", collapse: "collapsed" } - ], - fields: { - // Platform ownership anchor — canonical note in `account.object.ts` (#548). - owner_id: Field5.lookup("sys_user", { - label: "Contact Owner", - group: "account_info", - system: true, - readonly: false, - trackHistory: true - }), - // Name fields - salutation: Field5.select({ - label: "Salutation", - group: "identity", - // Canonical set shared with Lead (#490) — see _picklists.ts. - options: [...SALUTATION_OPTIONS] - }), - first_name: Field5.text({ - label: "First Name", - required: true, - storage: { notNull: true }, - searchable: true, - group: "identity" - }), - last_name: Field5.text({ - label: "Last Name", - required: true, - storage: { notNull: true }, - searchable: true, - group: "identity" - }), - // Formula field - Full name - // `salutation` is a picklist, so the formula sees the raw VALUE (`ms`, `dr`), - // not the label — names rendered as "ms Emily Davis" in lists and details - // (#461). The formula language has no proper-case or option-label lookup, and - // hardcoding "Ms." would defeat translation, so the name is built from the - // name fields alone; salutation stays its own (translated) field. - full_name: Field5.formula({ - label: "Full Name", - expression: F4`joinNonEmpty([record.first_name, record.last_name], ' ')`, - group: "identity" - }), - // Avatar field. `accept` / `maxSize` are server-enforced from - // @objectstack 17 — see the note on `crm_product.image`. - avatar: Field5.avatar({ - label: "Profile Picture", - group: "identity", - accept: ["image/png", "image/jpeg", "image/webp"], - maxSize: 2 * 1024 * 1024 - }), - // Relationship: Link to Account (Master-Detail) - crm_account: Field5.masterDetail("crm_account", { - label: "Account", - required: true, - storage: { notNull: true }, - deleteBehavior: "cascade", - // Delete contacts when account is deleted - group: "account_info" - }), - // Professional Information - title: Field5.text({ - label: "Job Title", - group: "account_info" - }), - department: Field5.select({ - label: "Department", - group: "account_info", - options: [ - { label: "Executive", value: "executive" }, - { label: "Sales", value: "sales" }, - { label: "Marketing", value: "marketing" }, - { label: "Engineering", value: "engineering" }, - { label: "Support", value: "support" }, - { label: "Finance", value: "finance" }, - { label: "Human Resources", value: "hr" }, - { label: "Operations", value: "operations" } - ] - }), - // ── Buying centre (REQ-0004) ───────────────────────────────────────── - // - // The three attributes that turn an account's contact list from a - // DIRECTORY into a MAP: what this person does in the purchase decision, - // where they stand on us, and how strong our relationship with them is. - // `title` above is the employer's job title and `is_primary` below is a - // one-bit answer to "who do we call" — neither of them is this fact. - // - // ⛔ Read by people and by reporting, never by a gate. No hook, no flow - // and no validation is authored against any of the three, none is - // `required`, and none carries an option `default`: a contact with all - // three blank saves exactly as it did before this group existed - // (REQ-0004 acceptance 4). They are sales intelligence, and AGENTS.md - // metadata semantics rule 8 is what keeps a machine signal from refusing - // a write. - // ⚠️ `buying_function`, not `buying_role` — and 'Buying Function', not - // 'Buying Role'. `security-role-word` (an author-time rule, ADR-0090 D3) - // refuses the word `role` on BOTH, measured on this branch as two - // successive `pnpm validate` exit-1 runs: first the field name, then the - // label, because "admins must meet ONE vocabulary" and `role` is the - // platform's security vocabulary (permission_set / position / - // business_unit). Its own remedy prescribes the replacement used here — - // "a domain word (e.g. 'function', 'duty')". - // - // The rule's surface is the ENGLISH one it can read: it matches - // `/\brole(s)?\b/i` over object/field/action/permission-set/position/app - // declarations and does not reach the locale packs. So the three - // non-English packs keep the natural business term for this concept in - // their own language (zh-CN 采购角色, es-ES Rol de Compra, ja-JP 購買役割) - // — same fact, each written the way its reader says it. - buying_function: Field5.select({ - label: "Buying Function", - group: "buying_centre", - // SINGLE-valued, and REQ-0004 left that call to the implementing PR. - // `multiple: true` would cost the field the property acceptance 2 asks - // for: `GroupingConfigSchema` (`@objectstack/spec/ui`, the installed - // pin) answers a grouped list with ONE server-side aggregate query, and - // its `GroupingFieldSchema.field` says the group header "carries its - // raw stored value" — so a multi-valued column groups by the - // COMBINATION. `decision_maker` + `user` would become a group of its - // own instead of feeding both, which is the opposite of reading an - // account as a map. A person who is genuinely two things is recorded as - // the role that governs THIS decision; the second one is already - // legible from `title` / `department`. - // - // The six are the generic buying-centre slots every industry reads the - // same way — ⛔ deliberately not one company's role model. - options: [ - { label: "Decision Maker", value: "decision_maker" }, - { label: "Economic Buyer", value: "economic_buyer" }, - { label: "Technical Evaluator", value: "technical_evaluator" }, - { label: "User", value: "user" }, - { label: "Influencer", value: "influencer" }, - { label: "Gatekeeper", value: "gatekeeper" } - ] - }), - attitude: Field5.select({ - label: "Attitude to Us", - group: "buying_centre", - // ORDERED, most to least favourable — declaration order IS the order a - // picklist and a grouped list present, so the ladder is authored rather - // than described. A blank means nobody has formed a view yet, which is - // a different fact from `neutral`. - options: [ - { label: "Champion", value: "champion" }, - { label: "Supportive", value: "supportive" }, - { label: "Neutral", value: "neutral" }, - { label: "Skeptical", value: "skeptical" }, - { label: "Blocker", value: "blocker" } - ] - }), - relationship_strength: Field5.select({ - label: "Relationship Strength", - group: "buying_centre", - // ORDERED, weakest to strongest. ⛔ Not a free-text score, and ⛔ not - // derived from `last_contacted_date` below: recency is machine-written - // and measures something else — a weekly call with someone who will not - // take our side is not a strong relationship. A blank means unassessed; - // `distant` is an assessment that came back weak. - options: [ - { label: "Distant", value: "distant" }, - { label: "Acquaintance", value: "acquaintance" }, - { label: "Working Relationship", value: "working" }, - { label: "Strong", value: "strong" }, - { label: "Trusted Advisor", value: "trusted_advisor" } - ] - }), - // No `reports_to`. The org chart was declared and never built: no page - // rendered the tree the contact docs promised, no skill read the chain when - // summarising an account, and no flow escalated along it. Sharing derives - // from the master `crm_account`, never from this lookup. - // Contact Information - email: Field5.email({ - label: "Email", - required: true, - storage: { notNull: true }, - unique: true, - group: "contact_info" - }), - phone: Field5.text({ - label: "Phone", - format: "phone", - group: "contact_info" - }), - mobile: Field5.text({ - label: "Mobile", - format: "phone", - group: "contact_info" - }), - // Mailing Address — one structured `address` value, the same shape as - // `crm_account.billing_address` and `crm_lead.address`, because a postal - // address is one fact and AGENTS.md's field-type guidance names - // `Field.address()` for it (ruling on #1836; it replaced five flat - // `mailing_*` text fields, converted by `scripts/backfill-contact-mailing-address.ts`). - mailing_address: Field5.address({ - label: "Mailing Address", - group: "mailing_address" - }), - // Additional Information - // - // No `birthdate`. Nothing greeted, segmented or reported on it, and an - // importable date of birth with no consumer is personal data held for no - // stated purpose — the one field on this object where "declared but inert" - // also carries a data-protection cost. - lead_source: Field5.select({ - label: "Lead Source", - group: "additional", - // Canonical set shared with Lead + Opportunity (#490) — a converted - // lead's source must remain representable on the contact. - options: [...LEAD_SOURCE_OPTIONS] - }), - description: Field5.markdown({ - label: "Description", - group: "additional" - }), - // Flags - is_primary: Field5.boolean({ - label: "Primary Contact", - defaultValue: false, - description: "Is this the main contact for the account?", - group: "preferences" - }), - do_not_call: Field5.boolean({ - label: "Do Not Call", - defaultValue: false, - group: "preferences" - }), - email_opt_out: Field5.boolean({ - label: "Email Opt Out", - defaultValue: false, - group: "preferences" - }), - // Interaction recency for the PERSON (#592). `crm_account` carries - // `last_activity_date` for the company and `crm_lead` carries - // `last_contacted_date` for a prospect; the contact — the record a rep - // actually calls and emails — had neither, so "when did anyone last speak - // to our champion?" was unanswerable. - // - // Written by the activity bubble in `event.hook.ts` / `task.hook.ts` and by - // `send_email`. Deliberately NOT `readonly`: a readonly field is stripped - // from every non-system write whose caller supplied the key (#2948), which - // is exactly how the account and lead columns above ended up permanently - // null. It is kept off the form sections instead. - last_contacted_date: Field5.datetime({ - label: "Last Contacted", - group: "additional" - }) - }, - // Enable features - // API surface. History → Field.trackHistory (ADR-0052). - enable: { - apiEnabled: true, - // #602 — signed NDAs, business cards, meeting notes attach to the person. - // See the canonical capability note in `src/sales/objects/index.ts`. - files: true - }, - // Database indexes for performance - // - // NOTE: no `{ fields: ['email'], unique: true }` here. Email uniqueness is - // declared on the field itself (`unique: true`), which since framework #3696 - // materializes as the tenant composite `(organization_id, email)` — unique - // WITHIN an organization, which is what a multi-tenant CRM wants (two orgs - // may each know john@acme.com). A declared single-column index is taken - // verbatim, i.e. platform-wide, so declaring both left the global index - // enforcing the old behaviour and the per-tenant constraint unreachable - // (framework#3991 `unique/double-declaration`). - indexes: [ - { fields: ["crm_account"] }, - { fields: ["owner_id"] }, - { fields: ["last_name", "first_name"] } - ], - // Display configuration. ADR-0079 `nameField` names the real field holding - // the record title — here the `full_name` formula field defined above. - nameField: "full_name", - // Explicit search targets (ADR-0061). REQUIRED because nameField is a - // FORMULA (display_title/full_name): without this, $search auto-defaults to - // the formula field, which isn't a real column, so the lookup picker + global - // search silently return zero. These are real, indexed columns. - searchableFields: ["first_name", "last_name", "email"], - highlightFields: ["full_name", "email", "crm_account", "phone"] - // ⚠️ No standalone `type: 'unique'` validation exists on this platform - // (ADR-0032 validation union). Email uniqueness is enforced by the - // field-level `unique: true` above, scoped per organization. - // ⚠️ No `workflows[]` here, and none is possible: object `workflows[]` were - // removed from the platform. Field updates live in this object's `*.hook.ts`; - // scheduled status flips and notifications live in `src/*/flows/*.flow.ts`. -}); - -// src/sales/objects/event.object.ts -import { P as P4 } from "@objectstack/spec"; -import { ObjectSchema as ObjectSchema6, Field as Field6 } from "@objectstack/spec/data"; -var Event = ObjectSchema6.create({ - name: "crm_event", - label: "Event", - pluralLabel: "Events", - icon: "calendar-days", - description: "Meetings, calls and other scheduled interactions with customers", - // ADR-0090 D1/D7: OWD is an authored decision. Mirrors `crm_task`: an event - // is a personal activity record, owned by the rep who ran it. - sharingModel: "private", - fieldGroups: [ - { key: "basic", label: "Event Information", icon: "info" }, - { key: "schedule", label: "Schedule", icon: "calendar" }, - { key: "related", label: "Related Records", icon: "link" }, - { key: "outcome", label: "Outcome", icon: "clipboard-check", collapse: "collapsed" } - ], - fields: { - // Platform ownership anchor — canonical note in `account.object.ts` (#548). - owner_id: Field6.lookup("sys_user", { - label: "Assigned To", - group: "basic", - system: true, - readonly: false, - trackHistory: true - }), - // ─── Event Information ──────────────────────────────────────────── - subject: Field6.text({ - group: "basic", - label: "Subject", - required: true, - storage: { notNull: true }, - searchable: true, - maxLength: 255 - }), - type: Field6.select({ - group: "basic", - label: "Event Type", - required: true, - storage: { notNull: true }, - // Field-level default, not just the option flag: the option `default` - // only preselects in some form surfaces, so a quick-create opened from a - // related list left this required field blank (same defect crm_task.status - // carries a note about). - defaultValue: "meeting", - options: [...EVENT_TYPE_OPTIONS] - }), - status: Field6.select({ - group: "basic", - label: "Status", - required: true, - storage: { notNull: true }, - trackHistory: true, - defaultValue: "planned", - options: [...EVENT_STATUS_OPTIONS] - }), - description: Field6.markdown({ - group: "basic", - label: "Description" - }), - // ─── Schedule ───────────────────────────────────────────────────── - start_datetime: Field6.datetime({ - group: "schedule", - label: "Start", - required: true, - storage: { notNull: true } - }), - end_datetime: Field6.datetime({ - group: "schedule", - label: "End" - }), - all_day: Field6.boolean({ - group: "schedule", - label: "All Day Event", - defaultValue: false - }), - // Derived in `event.hook.ts` from start/end. NOT `readonly`: the field is - // also what the activity actions supply directly when a rep logs a call - // that took 20 minutes, and a readonly field is stripped from any write - // whose CALLER supplied the key (#2948) — including an action body running - // under the rep's own context. Derivation inside this object's own - // before-hook is unaffected either way (the strip keys off the caller's - // payload, not the post-hook document), so leaving it writable costs - // nothing and keeps `log_call` honest. - duration_minutes: Field6.number({ - group: "schedule", - label: "Duration (minutes)", - min: 0, - scale: 0 - }), - location: Field6.text({ - group: "schedule", - label: "Location", - maxLength: 255, - description: "Room, address, or meeting link" - }), - // ─── Related Records (polymorphic, same shape as crm_task) ───────── - related_to_type: Field6.select({ - group: "related", - label: "Related To Type", - options: [...RELATED_TO_TYPE_OPTIONS] - }), - related_to_account: Field6.lookup("crm_account", { - group: "related", - label: "Related Account" - }), - related_to_contact: Field6.lookup("crm_contact", { - group: "related", - label: "Related Contact" - }), - related_to_opportunity: Field6.lookup("crm_opportunity", { - group: "related", - label: "Related Opportunity" - }), - related_to_lead: Field6.lookup("crm_lead", { - group: "related", - label: "Related Lead" - }), - related_to_case: Field6.lookup("crm_case", { - group: "related", - label: "Related Case" - }), - // ─── Outcome ────────────────────────────────────────────────────── - outcome_notes: Field6.markdown({ - group: "outcome", - label: "Outcome Notes", - description: "What was agreed, and what happens next" - }) - // No `is_past` / `is_upcoming` boolean. A write-time snapshot of "has this - // happened yet" is stale the moment the clock passes it, and the app has - // already been burnt by exactly that (`crm_task.is_overdue` — see the - // `overdue_tasks` view's label note). `status` is the authored, non-decaying - // signal, and the upcoming/past views filter on it and sort by - // `start_datetime` instead. - }, - // API surface. History → Field.trackHistory (ADR-0052). - enable: { - apiEnabled: true - }, - indexes: [ - { fields: ["start_datetime"] }, - { fields: ["owner_id"] }, - { fields: ["status"] }, - { fields: ["related_to_account"] }, - { fields: ["related_to_opportunity"] } - ], - // ADR-0079: `nameField` names the real field holding the record title. - nameField: "subject", - highlightFields: ["subject", "type", "status", "start_datetime", "owner_id"], - searchableFields: ["subject", "location"], - // Predicates below are TOTAL: every `record.x` read is `has()`-guarded, so the - // rule returns a verdict even when the merged record has no such key. See - // AGENTS.md "Validation predicates must be TOTAL" and - // test/object-validation-predicates.test.ts, which fails the build otherwise. - validations: [ - { - name: "end_after_start", - type: "script", - severity: "error", - message: "The end time must be after the start time", - // BOTH guards, on both operands, because they answer different hazards - // (AGENTS.md "Validation predicates must be TOTAL"): - // · `has(...)` — absent key. On a driver that stores only the columns - // a row was written with, an absent `end_datetime` aborts the whole - // predicate under strict CEL, and from 17.0.0-rc.2 that abort REJECTS - // the save rather than skipping the rule (#4649). - // · `!= null` — present-but-null. `dyn < dyn` aborts too, and - // `has()` says nothing about it. - // An ordering comparison needs both; neither substitutes for the other. - condition: P4`has(record.start_datetime) && has(record.end_datetime) && record.start_datetime != null && record.end_datetime != null && !isBlank(record.end_datetime) && record.end_datetime < record.start_datetime` - }, - { - name: "related_to_required", - type: "script", - severity: "warning", - message: "At least one related record should be selected", - condition: P4`(!has(record.related_to_account) || isBlank(record.related_to_account)) && (!has(record.related_to_contact) || isBlank(record.related_to_contact)) && (!has(record.related_to_opportunity) || isBlank(record.related_to_opportunity)) && (!has(record.related_to_lead) || isBlank(record.related_to_lead)) && (!has(record.related_to_case) || isBlank(record.related_to_case))` - } - ] -}); - -// src/sales/objects/event_attendee.object.ts -import { expression } from "@objectstack/spec"; -import { ObjectSchema as ObjectSchema7, Field as Field7 } from "@objectstack/spec/data"; -var ATTENDEE_RESOLUTIONS = [ - { value: "contact", column: "crm_contact", label: "Contact", color: "#4169E1" }, - { value: "lead", column: "crm_lead", label: "Lead", color: "#FFA500" }, - { value: "user", column: "sys_user", label: "User", color: "#00AA00" }, - { value: "external", column: "external_name", label: "External", color: "#8A8A8A" } -]; -var DEFAULT_ATTENDEE_TYPE = "contact"; -var blank = (f) => `(!has(record.${f}) || isBlank(record.${f}))`; -var filled = (f) => `(has(record.${f}) && !isBlank(record.${f}))`; -var typeIs = (v) => `(has(record.attendee_type) && record.attendee_type == "${v}")`; -var typeIsNot = (v) => `(has(record.attendee_type) && record.attendee_type != "${v}")`; -var RESOLVES_CONDITION = ATTENDEE_RESOLUTIONS.map((r) => `(${typeIs(r.value)} && ${blank(r.column)})`).join(" || "); -var EXCLUSIVE_CONDITION = ATTENDEE_RESOLUTIONS.map((r) => `(${filled(r.column)} && ${typeIsNot(r.value)})`).join(" || "); -var partyFormHints = (column) => { - const resolution = ATTENDEE_RESOLUTIONS.find((r) => r.column === column); - if (!resolution) { - throw new Error(`No attendee resolution declares the column "${column}"`); - } - return { - requiredWhen: expression(typeIs(resolution.value), "cel") - }; -}; -var EventAttendee = ObjectSchema7.create({ - name: "crm_event_attendee", - label: "Event Attendee", - pluralLabel: "Event Attendees", - icon: "users", - description: "A person invited to or present at an event", - sharingModel: "controlled_by_parent", - // ADR-0079: junction rows have no derivable text title; point the canonical - // nameField at the stored autonumber explicitly (autonumber is not in the - // auto-derivation whitelist). - nameField: "attendee_number", - highlightFields: ["crm_event", "attendee_type", "response", "is_organizer"], - fieldGroups: [ - { key: "basic", label: "Attendee", icon: "user" }, - { key: "response", label: "Invitation", icon: "mail-check" } - ], - fields: { - attendee_number: Field7.autonumber({ - group: "basic", - label: "Attendee Number", - format: "EA-{00000}" - }), - // ⚠️ Deliberately left on the spec default, and NOT cascaded with the party - // lookups below. Because it is REQUIRED, the engine escalates the stored - // `set_null` to a refusal at delete time, with a message naming the real - // obstacle instead of an unrelated rule: "Cannot delete crm_event (...): 3 - // dependent crm_event_attendee record(s) reference it via crm_event - // (crm_event is required, so it cannot be cleared)." That is the correct - // answer on this side, for the same reason `crm_campaign_member.crm_campaign` - // keeps it: a meeting's attendee list is the meeting's historical record, - // not a per-person artefact. `test/event-attendee-cascade.test.ts` pins the - // resolved value so a copy-paste of the three cascades cannot reach here. - crm_event: Field7.lookup("crm_event", { - group: "basic", - label: "Event", - required: true, - storage: { notNull: true } - }), - // The discriminator says which of the four columns below is the live one. It - // is authored rather than derived so a query can filter "internal attendees - // only" without four OR'd null checks. The options are GENERATED from the - // resolution table rather than retyped — see the note at the top of this - // file for why the pairing is declared once. - attendee_type: Field7.select({ - group: "basic", - label: "Attendee Type", - required: true, - storage: { notNull: true }, - defaultValue: DEFAULT_ATTENDEE_TYPE, - options: ATTENDEE_RESOLUTIONS.map((r) => ({ - label: r.label, - value: r.value, - color: r.color, - ...r.value === DEFAULT_ATTENDEE_TYPE ? { default: true } : {} - })) - }), - // ⛔ `deleteBehavior: 'cascade'` on ALL THREE party lookups, not the default. - // - // ⚠️ Platform constraint: a lookup defaults to `set_null`, and the engine - // implements `set_null` by UPDATING the row that holds it. On a column a - // validation rule reads, that makes the referenced party permanently - // UNDELETABLE: clearing this column leaves the row the engine just edited in - // violation of `attendee_resolves` below, and the whole delete rolls back - // with an error naming an object the caller never addressed. The same - // construction bites `crm_campaign_member`. - // - // `external_name` is the fourth resolution, but it is blank on every row the - // product actually writes (`src/sales/actions/activity-actions.ts` logs attendees - // with a party reference and never an external name), so it rescues nothing. - // - // Cascade rather than `restrict`: an attendee row is a JUNCTION whose whole - // meaning is "this person was in this room". Once the person is gone the row - // denotes nothing, and the query it exists to serve ("meetings this person - // attended") has lost its subject. `restrict` would produce an accurate - // message but keep the person undeletable until someone deleted their - // attendance by hand, and undeletable PEOPLE is the impact being fixed. - // Cascade also leaves no reachable state in which a stored attendee row - // breaks its own object's rule. - crm_contact: Field7.lookup("crm_contact", { - group: "basic", - label: "Contact", - deleteBehavior: "cascade", - description: "Set when the attendee is an existing customer contact", - ...partyFormHints("crm_contact") - }), - crm_lead: Field7.lookup("crm_lead", { - group: "basic", - label: "Lead", - deleteBehavior: "cascade", - description: "Set when the attendee is still an unconverted lead", - ...partyFormHints("crm_lead") - }), - // `sys_user` gets the SAME answer as the two CRM parties, and it was worth a - // second look rather than a copy-paste: - // - // · Deleting a user is a real, reachable operation. Generic CRUD delete on - // the identity table is off (`sys_user` ships `apiMethods: ['get', - // 'list', 'update', 'bulk']`), but better-auth's own routes — - // `/api/v1/auth/delete-user`, which the platform's `sys_user` object - // surfaces as the "Delete My Account" record action, and - // `/api/v1/auth/admin/remove-user` — resolve `user` to `sys_user` and - // land on `dataEngine.delete(...)`, i.e. the SAME ObjectQL delete that - // runs the referential pass. So `set_null` here is not dormant: it breaks - // account erasure for any colleague who ever attended a meeting. - // · The app's shipped stance is already "a deleted user's references - // degrade". EVERY other `sys_user` lookup in HotCRM (every `owner_id`, - // plus `product_manager`) is `set_null` and NO validation rule reads any - // of them — the rule below is the only one in the app that reads a user - // reference at all, which is precisely why this is the only lookup where - // the default misbehaves. `restrict` here would make this junction the - // ONE app row able to veto a platform identity erasure — an app object - // holding a `protection: { lock: 'full' }`, better-auth-managed table - // hostage, surfacing as an opaque failure from an auth route. That is a - // layering inversion, not a fix. - // · The cost of cascade is bounded and is the right half to lose: the - // meeting itself (`crm_event` — subject, times, outcome notes) survives - // untouched; only the per-person row goes, and it goes because the - // person's identity record was erased. Deactivation, not deletion, is the - // ordinary offboarding path (the platform ships ban/unban), and it - // touches nothing here. - sys_user: Field7.lookup("sys_user", { - group: "basic", - label: "User", - deleteBehavior: "cascade", - description: "Set when the attendee is a colleague", - ...partyFormHints("sys_user") - }), - // Free text is the LAST resort, not the default: it exists only for the - // genuinely unmodelled guest (a prospect's lawyer who is in no CRM object). - // It is the resolution of ONE attendee type — `external` — and the rules - // below enforce that both ways: an `external` row must fill it, and no - // other type may. It is not a place to paste a list, and not a note field - // to hang off a Contact row. - external_name: Field7.text({ - group: "basic", - label: "External Attendee", - maxLength: 255, - description: "Name of an attendee who is in no CRM object \u2014 set when Attendee Type is External", - ...partyFormHints("external_name") - }), - response: Field7.select({ - group: "response", - label: "Response", - required: true, - storage: { notNull: true }, - trackHistory: true, - defaultValue: "no_response", - options: [...ATTENDEE_RESPONSE_OPTIONS] - }), - is_organizer: Field7.boolean({ - group: "response", - label: "Organizer", - defaultValue: false - }), - // ⛔ NOT `readonly` — but the cross-reference this note used to carry is - // retired, not merely reworded: `crm_campaign_member.added_date` was ruled - // `readonly: true` in #1667, so it is no longer a precedent for keeping an - // insert-stamped column open, and the reason it cited ("the engine strips a - // readonly key the CALLER supplied") does not reach an INSERT at all — the - // strip is an UPDATE-path rule (`test/readonly-write-semantics.test.ts`). - // What holds it open is now MEASURED (#1747, the per-writer census #1435 - // ran for the other three), not "nobody has ruled on it": this column has a - // user-context UPDATE writer, which none of the three columns #1666 / #1667 - // moved had. The census, in full: - // • the fifteen generated activity actions (5 `ACTIVITY_TARGETS` × 3 - // kinds, one shared body in `activity-actions.ts`) INSERT it, and an - // action body runs `isSystem` — exempt twice over; - // • the two `service.seed.ts` attendee seeds write it, and their - // `mode: 'upsert'` replay UPDATE is exempt too, because seed writes are - // `isSystem` (`flow-scheduled.test.ts` pins that via ownerless rows); - // • the record form — `event_attendee.view.ts` lists it in the - // `invitation` section, AUTHORED rather than synthesized, and the four - // profiles that name the object all grant `allowEdit`. A rep correcting - // Invited on a saved row is a non-`isSystem` UPDATE carrying a - // caller-supplied key: precisely what the strip deletes. The three - // flipped columns appear in NO form section anywhere in `src/*/views/`, - // `crm_opportunity`'s authored form included. - // ⭐ It is also not the same KIND of column. `added_date` / `approved_date` - // are stamped `{NOW()}` by the writer, so their value IS the write moment; - // `invited_date` records when the invitation went out, and the seed dates it - // 3-10 days before its own event, per row. A column whose value is not the - // write moment is one a person can be right about. ⛔ Do not flip it on the - // strength of the sibling ruling. - invited_date: Field7.datetime({ - group: "response", - label: "Invited" - }) - }, - indexes: [ - { fields: ["crm_event"] }, - { fields: ["crm_contact"] }, - { fields: ["sys_user"] } - ], - // ⚠️ Predicates below are TOTAL: every `record.x` read is `has()`-guarded, so - // the rule returns a verdict even when the merged record has no such key. See - // AGENTS.md "Validation predicates must be TOTAL" and - // test/object-validation-predicates.test.ts, which fails the build otherwise. - // - // Both rules are GENERATED from `ATTENDEE_RESOLUTIONS` at the top of this - // file. ⚠️ `expression(..., 'cel')` is the same envelope the ``P`…` `` tag - // produces, but the tag JSON-quotes an interpolated string and so cannot - // splice a source fragment — which is why these use the function form. The - // pairing is declared once and read twice; see the note up there. - validations: [ - // The type's own column must be filled. - { - name: "attendee_resolves", - type: "script", - severity: "error", - message: "An attendee must fill the party its Attendee Type names \u2014 a Contact row needs a Contact, an External row needs an External Attendee name", - condition: expression(RESOLVES_CONDITION, "cel") - }, - // …and no other column may be filled. The separate rule is deliberate: one - // condition, one wording. Folding both into `attendee_resolves` would make - // its message a lie for half the rows it rejects, and "you filled the wrong - // column" is not the same instruction as "you filled nothing". - { - name: "attendee_type_exclusive", - type: "script", - severity: "error", - message: "An attendee names exactly one party \u2014 clear every party column its Attendee Type does not name", - condition: expression(EXCLUSIVE_CONDITION, "cel") - } - ] -}); - -// src/sales/objects/forecast.object.ts -import { ObjectSchema as ObjectSchema8, Field as Field8 } from "@objectstack/spec/data"; -import { F as F5, P as P5 } from "@objectstack/spec"; -var Forecast = ObjectSchema8.create({ - name: "crm_forecast", - label: "Forecast", - pluralLabel: "Forecasts", - icon: "trending-up", - description: "Periodic pipeline snapshot by owner used for revenue forecasting.", - // OWD is an authored decision (ADR-0090 D1/D7). Forecasts are personal to the - // owner. - sharingModel: "private", - // ADR-0079 record title. ⚠️ A formula cannot dot-walk a lookup (ADR-0072), so - // `display_title` composes local fields only: period_label + (period_start). - nameField: "display_title", - // ⚠️ Explicit search targets (ADR-0061), REQUIRED because `nameField` is a - // FORMULA: without this, `$search` auto-defaults to the formula field, which - // is not a real column, so the lookup picker and global search silently - // return zero. These are real, indexed columns. - searchableFields: ["period_label"], - highlightFields: ["owner_id", "period", "period_start", "commit_amount", "closed_amount"], - fieldGroups: [ - { key: "basic", label: "Snapshot", icon: "info" }, - { key: "amounts", label: "Amounts", icon: "dollar-sign" }, - { key: "meta", label: "Source", icon: "database", collapse: "collapsed" } - ], - fields: { - // Platform ownership anchor — canonical note in `account.object.ts` (#548). - owner_id: Field8.lookup("sys_user", { - label: "Owner", - group: "basic", - system: true, - readonly: false, - trackHistory: true - }), - period: Field8.select({ - label: "Period", - required: true, - storage: { notNull: true }, - group: "basic", - options: [ - { label: "Month", value: "month", default: true }, - { label: "Quarter", value: "quarter" } - ] - }), - // Wording mirrors the two refusal messages this field is bound by - // (`period_start_first_of_period` / `quarter_starts_on_quarter_boundary`, - // both below) so the form and the rejection agree on the same rule - // instead of describing two different ones (#1085). - period_start: Field8.date({ - label: "Period Start", - description: "Must be the first day of the period \u2014 e.g. 2026-08-01 for Aug 2026. A quarterly forecast must additionally start on a quarter boundary: January 1, April 1, July 1 or October 1.", - required: true, - storage: { notNull: true }, - group: "basic" - }), - // Still not read-only: `forecast.hook.ts` fills it only when the write - // leaves it unset, and `src/sales/data/forecast.seed.ts` hand-fills it on every - // seeded row — so hand-entry is a capability this app uses. A hand-filled - // value is pinned to the same calendar period `period_start` is - // (`period_end_matches_calendar_period` below), and the description states - // that rule rather than the weaker `period_end_after_start` it subsumes: - // the form says what is actually enforced. - period_end: Field8.date({ - label: "Period End", - description: "Normally derived automatically from Period and Period Start. If set by hand, it must be the last day of that period \u2014 e.g. 2026-09-30 for a quarter starting 2026-07-01, or 2026-08-31 for Aug 2026.", - required: true, - storage: { notNull: true }, - group: "basic" - }), - period_label: Field8.text({ - label: "Period Label", - description: 'Human-friendly label, e.g. "Q3 2026" or "Aug 2026".', - group: "basic" - }), - // ADR-0079 record title. ⚠️ A formula cannot dot-walk a lookup (ADR-0072), - // so this composes local fields only; `period_start` (a date) is - // string()-coerced for concat. - // - // ⚠️ The coercion is `string()`, NOT `text()`. `text` is not a registered - // CEL function — it is absent from `CEL_STDLIB_FUNCTIONS` — so a formula - // using it faults at runtime and leaves the record's `nameField` null. The - // author-time `expression-invalid` rule now REPORTS it ("found no matching - // overload for 'text(dyn)'") instead of letting a broken formula through to - // null silently. `string` is the catalog's coercion, alongside - // `int`/`bool`/`double`/`timestamp`. - display_title: Field8.formula({ - label: "Display Title", - expression: F5`record.period_label + " (" + string(record.period_start) + ")"`, - group: "basic" - }), - snapshot_date: Field8.date({ - label: "Snapshot Date", - description: "The day this snapshot was captured.", - required: true, - storage: { notNull: true }, - group: "meta" - }), - quota: Field8.currency({ - label: "Quota", - min: 0, - group: "amounts", - trackHistory: true - }), - pipeline_amount: Field8.currency({ - label: "Pipeline", - description: "Sum of all open opportunities closing in this period (any stage).", - min: 0, - group: "amounts" - }), - best_case_amount: Field8.currency({ - label: "Best Case", - description: "Open opportunities in the Best Case or Commit forecast category.", - min: 0, - group: "amounts" - }), - commit_amount: Field8.currency({ - label: "Commit", - description: "Open opportunities in the Commit forecast category (owner-committed).", - min: 0, - group: "amounts" - }), - closed_amount: Field8.currency({ - label: "Closed Won", - description: "Already-closed-won amount in this period.", - min: 0, - group: "amounts" - }), - expected_amount: Field8.formula({ - label: "Expected", - description: "Closed Won + Commit \u2014 what the owner reasonably expects to land.", - expression: F5`coalesce(record.closed_amount, 0) + coalesce(record.commit_amount, 0)`, - scale: 2, - group: "amounts" - }), - attainment_pct: Field8.formula({ - label: "Attainment %", - description: "Closed Won \xF7 Quota \xD7 100. Reads 0% until a positive quota is set.", - expression: F5`coalesce(record.quota, 0) > 0 ? (coalesce(record.closed_amount, 0) * 100.0) / record.quota : 0.0`, - scale: 2, - group: "amounts" - }), - coverage_ratio: Field8.formula({ - label: "Coverage Ratio", - description: "Pipeline \xF7 (Quota \u2212 Closed Won) \u2014 whether enough pipeline remains to cover the gap. Reads 0 once the quota is already met.", - expression: F5`(coalesce(record.quota, 0) - coalesce(record.closed_amount, 0)) > 0 ? coalesce(record.pipeline_amount, 0) / (record.quota - coalesce(record.closed_amount, 0)) : 0.0`, - scale: 2, - group: "amounts" - }), - source: Field8.select({ - label: "Source", - group: "meta", - options: [ - { label: "Scheduled snapshot", value: "scheduled", default: true }, - { label: "AI skill", value: "ai" }, - { label: "Manual entry", value: "manual" } - ] - }), - notes: Field8.text({ - label: "Notes", - maxLength: 1e3, - group: "meta" - }), - // Fixture identity — the seed loader's `externalId`, and nothing else. - // - // `crm_forecast` is a PER-OWNER snapshot: its real identity is - // (owner_id, period, period_start), and every other column is a rendering of - // part of that. `period_label` in particular names a SET of rows once the - // `forecast_snapshot` sweep writes one row per active owner per quarter — - // they all read 'Q3 2026' — so upserting on that label lets a re-seed match, - // and overwrite, a real rep's snapshot. - // - // ⚠️ The true composite `externalId: ['owner_id', 'period', 'period_start']` - // is not available here: a seed cannot name a user (see the note in - // `objectstack.composition.ts`, "A seed can't name a user"), so `owner_id` - // is null on every seeded row, and - // the loader's `externalIdKey` returns "" as soon as any part is empty. An - // empty key never matches, so upsert degrades to insert-on-every-replay. - // Dropping `owner_id` does not rescue it: a runtime row for the current - // quarter carries exactly the same (period, period_start). - // - // ⚠️ `mode: 'insert'` does NOT mean "insert once" — the loader inserts - // unconditionally on every replay boot (framework#3434). `'ignore'` is the - // real insert-once mode, but it decides "already there?" from the same - // `externalId`, so on a broken key it would SKIP the demo row because a real - // rep's row already claimed 'Q3 2026'. Fixing the identity is a prerequisite - // either way. Hence this synthetic, seeder-only key. - // - // ⚠️ `readonly` is the load-bearing part, not decoration: seed writes run - // `{ isSystem: true }` and bypass readonly stripping, while readonly - // stripping does guard user/API writes — so a genuine forecast row can never - // acquire a `seed_key` and can never be matched by a re-seed. That is what - // makes the fix structural rather than a naming convention. `hidden` keeps a - // fixtures-only column out of forms and pickers. - seed_key: Field8.text({ - label: "Seed Key", - description: "Demo-fixture identity. Written only by the seed loader; empty on every real snapshot.", - maxLength: 64, - readonly: true, - hidden: true, - group: "meta" - }) - }, - indexes: [ - { fields: ["owner_id", "period_start", "period"] }, - { fields: ["snapshot_date"] }, - { fields: ["period_start"] } - ], - // API surface. History → Field.trackHistory (ADR-0052). - enable: { - apiEnabled: true, - apiMethods: ["get", "list", "create", "update", "delete"] - }, - // Predicates below are TOTAL: every `record.x` read is `has()`-guarded, so the - // rule returns a verdict even when the merged record has no such key. See - // AGENTS.md "Validation predicates must be TOTAL" and - // test/object-validation-predicates.test.ts, which fails the build otherwise. - validations: [ - { - name: "period_end_after_start", - type: "script", - severity: "error", - message: "Period End must be after Period Start.", - // `<=`, not `<`: the rule name says "after" and a forecast period is a - // month or a quarter, never a single instant, so `period_end == - // period_start` is a zero-length period rather than a valid one. Same - // operator and wording as the `end_after_start` twins on - // campaign/contract. - condition: P5`has(record.period_end) && record.period_end != null && has(record.period_start) && record.period_start != null && record.period_end <= record.period_start` - }, - // A hand-filled `period_start` must be the first day of the calendar period - // it labels. Maintainer ruling 2026-08-11: 「接受你的全部建议」 — refuse - // rather than accept or snap. - // - // The hook derives `period_end` as "start + one period" — a ROLLING window. - // That is calendar-true for a start on a boundary and drifts for anything - // else: `period: 'quarter'` + `period_start: 2026-08-15` derives - // `period_end: 2026-10-31` under `period_label: 'Q3 2026'`, a window - // labelled Q3 that reaches a month into Q4. The row is internally - // inconsistent in a way no consumer can detect: every "this quarter" - // equals-filter reads `period_start`, and the nightly sweep selects the - // current row by `period_start <= today <= period_end`. - // - // These rules are the ONE enforcement point — deliberately not a throw in - // `forecast.hook.ts` as well. ⚠️ A declared rule is the shape the platform - // can act on: it refuses the write with a `ValidationError` / - // `VALIDATION_FAILED` envelope (HTTP 400) on the record form, on the API and - // on a seed's system write alike, where a hook throw is a bare `Error`. The - // derivation is left alone: with the start pinned to a boundary, "start + - // one period" IS the calendar period. - // - // ⚠️ WHY A REGEX AND NOT DATE ARITHMETIC: the CEL stdlib this app compiles - // against (`CEL_STDLIB_FUNCTIONS`) has no month/day accessor — the date - // functions are `today`/`daysBetween`/`addDays`/`addMonths`/`date` — so "the - // 1st of its month" is not expressible as arithmetic. Both drivers this app - // can run on hand `period_start` back as a `YYYY-MM-DD` string, and an ISO - // *datetime* string still matches these prefix-anchored patterns. A caller - // that writes a JS `Date` object is the one shape `string()` has no overload - // for; the engine then rejects that write naming the rule rather than - // admitting it, and no writer in this app does that. - { - name: "period_start_first_of_period", - type: "script", - severity: "error", - message: "Period Start must be the first day of the period \u2014 e.g. 2026-08-01 for Aug 2026.", - condition: P5`has(record.period_start) && record.period_start != null && !matches(string(record.period_start), "^[0-9]{4}-[0-9]{2}-01")` - }, - { - name: "quarter_starts_on_quarter_boundary", - type: "script", - severity: "error", - // The month rule above already rejects any non-1st day, so this one only - // ever adds the quarter-month half: 2026-08-01 is a valid month start and - // not a valid quarter start. - message: "A quarterly forecast must start on a quarter boundary \u2014 January 1, April 1, July 1 or October 1.", - condition: P5`has(record.period) && record.period == "quarter" && has(record.period_start) && record.period_start != null && !matches(string(record.period_start), "^[0-9]{4}-(01|04|07|10)-01")` - }, - // …and the OTHER end of the same window. The two rules above pin the START; - // `period_end` stays reachable, because the hook derives it only when the - // write leaves it unset and the field sits editable on the record form. - // Without this rule, `period: 'quarter'` + `period_start: 2026-07-01` (a - // boundary the rules above admit) + a hand-typed `period_end: 2027-05-15` is - // ADMITTED under `period_label: 'Q3 2026'` — a ten-month window labelled as - // one quarter, reached through the other field. - // - // WHY A RULE AND NOT A READ-ONLY FIELD: deriving `period_end` always and - // locking the form breaks the demo seed — - // `src/sales/data/forecast.seed.ts` hand-fills it on every seeded row. - // Hand-entry stays; it is now bounded. - // - // ⚠️ WHY `type: 'script'` AND NOT A FIELD CONSTRAINT: a field bound judges - // only the value being written, so a row already stored wrong keeps - // accepting edits forever; a script validation is evaluated against the - // MERGED record on every write and is therefore a true invariant. - // `test/forecast-period-end-boundary.test.ts` pins both halves — a legacy - // row is refused on its next unrelated edit, and the repair is admitted. - // - // WHY DATE ARITHMETIC HERE WHEN THE TWO RULES ABOVE USE A REGEX: not taste. - // Those rules inspect ONE date's components ("is this the 1st of its - // month?"), and the CEL stdlib has no month/day accessor. This rule compares - // TWO dates, which `addMonths`/`addDays`/`daysBetween` express directly. - // - // The predicate says "one period long", and that is the same claim as "ends - // on the calendar boundary" ONLY because the two rules above pin the start - // to one. That coupling is deliberate: the three are one set enforcing one - // invariant (a row's window is exactly the calendar period it is labelled - // with), not three independent gates. - // - // ⚠️ `daysBetween(a, b) != 0` rather than `a == b`: both drivers this app - // runs on hand dates back as `YYYY-MM-DD` strings while `addDays` returns a - // timestamp, and a string never `==` a timestamp — the rule would be - // permanently green. `daysBetween` puts both sides through the same - // `toDate`, so the string, an ISO datetime spelling and a JS `Date` all - // compare alike. - // - // ⚠️ The `!= null` guards are load-bearing for a THIRD hazard beyond the two - // AGENTS.md names: `daysBetween(null, …)` reaches `BigInt(NaN)` and THROWS, - // which the engine reports as `predicate failed to evaluate` — a rule that - // cannot answer, i.e. a rejected ordinary save. This predicate has no - // ordering operator, so `object-validation-predicates.test.ts`'s - // unguarded-comparison sweep does not cover it; the pin lives in - // `test/forecast-period-end-boundary.test.ts` instead. - { - name: "period_end_matches_calendar_period", - type: "script", - severity: "error", - message: "Period End must be the last day of the period \u2014 e.g. 2026-09-30 for a quarter starting 2026-07-01, or 2026-08-31 for Aug 2026.", - // Spelled out per period value instead of a ternary on the month count: - // an undeclared `period` is refused BY NAME by the picklist ("Period must - // be one of: month, quarter", measured), so this rule judges only the two - // values it understands and leaves the rest to the schema. - condition: P5`has(record.period) && record.period != null && has(record.period_start) && record.period_start != null && has(record.period_end) && record.period_end != null && ((record.period == "month" && daysBetween(record.period_end, addDays(addMonths(record.period_start, 1), -1)) != 0) || (record.period == "quarter" && daysBetween(record.period_end, addDays(addMonths(record.period_start, 3), -1)) != 0))` - }, - { - name: "snapshot_amounts_non_negative", - type: "script", - severity: "error", - message: "Snapshot amounts cannot be negative.", - condition: P5`(has(record.pipeline_amount) && record.pipeline_amount != null && record.pipeline_amount < 0) || (has(record.best_case_amount) && record.best_case_amount != null && record.best_case_amount < 0) || (has(record.commit_amount) && record.commit_amount != null && record.commit_amount < 0) || (has(record.closed_amount) && record.closed_amount != null && record.closed_amount < 0)` - } - ] -}); - -// src/sales/objects/lead.object.ts -import { ObjectSchema as ObjectSchema9, Field as Field9 } from "@objectstack/spec/data"; -import { F as F6, P as P6 } from "@objectstack/spec"; -var Lead = ObjectSchema9.create({ - name: "crm_lead", - label: "Lead", - pluralLabel: "Leads", - icon: "user-plus", - description: "Potential customers not yet qualified", - // ADR-0090 D1/D7: OWD is an authored decision. Owner-worked queue. - sharingModel: "private", - fieldGroups: [ - { key: "identity", label: "Identity", icon: "user-plus" }, - { key: "company_info", label: "Company Information", icon: "building" }, - { key: "contact_info", label: "Contact Information", icon: "phone" }, - { key: "qualification", label: "Qualification", icon: "star" }, - { key: "assignment", label: "Assignment", icon: "user" }, - { key: "address", label: "Address", icon: "map-pin", collapse: "collapsed" }, - { key: "additional", label: "Additional Info", icon: "info", collapse: "collapsed" }, - { key: "preferences", label: "Communication Preferences", icon: "bell-off", collapse: "collapsed" }, - { key: "conversion", label: "Conversion", icon: "check-circle", collapse: "collapsed" }, - { key: "duplicates", label: "Duplicate Management", icon: "copy", collapse: "collapsed" } - ], - fields: { - // Platform ownership anchor — canonical note in `account.object.ts` (#548). - owner_id: Field9.lookup("sys_user", { - label: "Lead Owner", - group: "assignment", - system: true, - readonly: false, - trackHistory: true - }), - // Personal Information - salutation: Field9.select({ - label: "Salutation", - group: "identity", - // Canonical set shared with Contact (#490) — see _picklists.ts. - options: [...SALUTATION_OPTIONS] - }), - first_name: Field9.text({ - label: "First Name", - required: true, - storage: { notNull: true }, - searchable: true, - group: "identity" - }), - last_name: Field9.text({ - label: "Last Name", - required: true, - storage: { notNull: true }, - searchable: true, - group: "identity" - }), - // ⚠️ `salutation` is a picklist, so a formula sees the raw VALUE (`ms`, - // `dr`), not the label — including it renders names as "ms Emily Davis" in - // lists and details. Dropped here and from `display_title` below, matching - // Contact. - full_name: Field9.formula({ - label: "Full Name", - expression: F6`joinNonEmpty([record.first_name, record.last_name], ' ')`, - group: "identity" - }), - // ADR-0079 record title (was titleFormat '{full_name} - {company}'). - // Composed from the same source fields as `full_name` (not formula-on-formula) - // plus `company`, so the title resolves from real stored values. - display_title: Field9.formula({ - label: "Display Title", - expression: F6`joinNonEmpty([record.first_name, record.last_name], ' ') + " - " + record.company`, - group: "identity" - }), - // Company Information - company: Field9.text({ - label: "Company", - required: true, - storage: { notNull: true }, - searchable: true, - group: "company_info" - }), - /** - * Case- and whitespace-folded copy of `company` — the value lead conversion - * compares against `crm_account.name_normalized`. - * - * ### Why the LEAD needs one too - * - * ⚠️ A normalized column on `crm_account` alone fixes nothing: the - * conversion flow would then compare a raw company string against a folded - * account name, and `"ACME Corp"` still would not match `acme corp`. Both - * sides have to be canonical, and the flow can canonicalize neither — - * `service-automation`'s `resolveToken` accepts exactly one function form - * (`NOW()` / `TODAY()`), so `{LOWER(x)}`, `{TRIM(x)}` and - * `{x.toLowerCase()}` all resolve to `undefined`. See the field comment on - * `crm_account.name_normalized` for the full measurement. - * - * `company` itself is NOT folded in place: it is the display value, it is - * copied verbatim onto the account the conversion creates, and lower-casing - * it would ship `acme corp` as a customer-visible account name. That is the - * one way this differs from `email`, which has no meaningful case and so is - * canonicalized in place. - * - * Derived, never authored: `lead_duplicate_check` recomputes it on every - * write that carries `company`. Not indexed — nothing filters on it; it is - * read off the lead record the flow already fetched. - */ - company_normalized: Field9.text({ - label: "Company (Normalized)", - description: "Match key for lead conversion: Company lower-cased, trimmed, with internal whitespace collapsed. Maintained by the lead_duplicate_check hook \u2014 never edit directly.", - readonly: true, - hidden: true, - maxLength: 255, - group: "company_info" - }), - title: Field9.text({ - label: "Job Title", - group: "company_info" - }), - industry: Field9.select({ - label: "Industry", - group: "company_info", - // Canonical set shared with Account (#490): lead_conversion copies this - // value onto the created Account, so both objects MUST agree. - options: [...INDUSTRY_OPTIONS] - }), - // ⚠️ NOT `unique`. A hard uniqueness constraint on a lead's email says a - // person may enquire once, ever, and the database enforces it by REJECTING - // the second enquiry — turning an ordinary follow-up into a 500 on the - // public form. Real funnels re-capture the same address routinely. - // Duplicates are a fact to be RECORDED, not an error: `lead_duplicate_check` - // in lead.hook.ts links the new lead to the record it repeats (see the - // `duplicates` field group below). The plain index below is what keeps the - // column indexed in the constraint's absence — the intake dedupe lookup, the - // `crm_lead_import` upsert key and the conversion flow all read leads by - // email on every write. - email: Field9.email({ - label: "Email", - required: true, - storage: { notNull: true }, - group: "contact_info" - }), - phone: Field9.text({ - label: "Phone", - format: "phone", - group: "contact_info" - }), - mobile: Field9.text({ - label: "Mobile", - format: "phone", - group: "contact_info" - }), - website: Field9.url({ - label: "Website", - group: "contact_info" - }), - // Lead Qualification - status: Field9.select({ - label: "Lead Status", - required: true, - storage: { notNull: true }, - group: "qualification", - trackHistory: true, - // Field-level default: option-level `default: true` only preselects in - // UI forms after first paint; the quick-create dialog and API inserts - // need a real defaultValue (see approval_status for the same lesson). - defaultValue: "new", - options: [ - { label: "New", value: "new", color: "#808080", default: true }, - { label: "Contacted", value: "contacted", color: "#FFA500" }, - { label: "Qualified", value: "qualified", color: "#4169E1" }, - { label: "Unqualified", value: "unqualified", color: "#FF0000" }, - { label: "Converted", value: "converted", color: "#00AA00" } - ] - }), - rating: Field9.rating(5, { - label: "Lead Score", - description: "Lead quality score (1-5 stars)", - group: "qualification" - }), - lead_source: Field9.select({ - label: "Lead Source", - group: "qualification", - // Canonical set shared with Contact + Opportunity (#490): lead_conversion - // copies this value onto the created Opportunity, so all three MUST agree. - options: [...LEAD_SOURCE_OPTIONS] - }), - // ── Demand: what this prospect wants, and what it is worth ───────── - // - // REQ-0005 steps 6-7. Both fields are in `qualification` because they ARE - // qualification data — what the buyer is asking for and how big it is are - // the two facts a rep weighs before working a lead — and neither is - // required: a lead captured off the public form has neither, and saves - // exactly as it did before. - need_type: Field9.select({ - label: "Need Type", - group: "qualification", - description: "What this prospect is asking for. Routing, prioritisation and demand reporting read this.", - // Generic starter vocabulary, declared once in `_picklists.ts` — see the - // note there for why it is NOT shared with `crm_opportunity.type`. - options: [...LEAD_NEED_TYPE_OPTIONS] - }), - // ⛔ NEVER conflated with `annual_revenue`, which sits two groups below in - // `additional` and answers a different question: that is the prospect - // COMPANY's own turnover, a size signal, and it is the value - // `lead_conversion` copies onto the account it creates. This is the value - // of the DEMAND — the number that becomes `crm_opportunity.amount` when the - // lead converts, and the only figure the pipeline has before then. - // - // ⛔ Nor is it a second copy of `crm_opportunity.amount`. The opportunity's - // amount is a committed deal figure a rep defends in a forecast; this is an - // estimate taken before qualification, and the conversion screen is where a - // human turns one into the other (it PREFILLS from here — see the - // `opportunityAmount` screen field in `lead-conversion.flow.ts` — rather - // than copying silently, so the rep confirms the number that enters the - // forecast). - estimated_amount: Field9.currency({ - label: "Estimated Amount", - group: "qualification", - description: "Estimated value of this demand, before qualification. Prefills the deal amount at conversion." - }), - // ── The conversion approval gate (REQ-0005 step 7) ───────────────── - // - // ⚠️ `defaultValue: 'not_required'` IS THE GATE'S OFF SWITCH, and it is the - // one line an install changes to arm it. REQ-0005: "The gate must be - // configurable — off by default. A single-seller install must not be forced - // through an approval to convert a lead." - // - // OFF (shipped) every lead is born `not_required`; nothing ever writes - // `pending`, so `lead_conversion_approval` never enters, - // the Convert button never hides and the write-path gate in - // `lead.hook.ts` never fires. Conversion behaves EXACTLY as - // it did before this field existed. - // ON change this one value to `'pending'`. Every lead is then - // born pending, `lead_conversion_approval` opens its - // request, and conversion is refused until an approver - // decides. - // - // Leads that predate the switch keep whatever they were born with, which is - // the point: arming the gate does not invalidate or re-open a single - // existing record (REQ-0005 acceptance 4). This is a TRANSITION GATE, not an - // invariant (AGENTS.md metadata semantics rule 7) — what is refused is the - // ACT of converting, evaluated against `previous` in `lead.hook.ts`, never - // the state of a record that is already converted. - // - // Shape copied from `crm_opportunity.approval_status`: `readonly: true` - // plus a REAL field-level `defaultValue`, ⛔ not only an option-level - // `default: true` — the same lesson `status` above records, and the reason - // that field's own comment gives: an option default only preselects in UI - // forms after first paint, so a quick-create dialog or an API insert would - // land a null and a null matches no flow entry condition. - // - // ⛔ Do NOT add an "approved" value to `status` instead. That select is the - // qualification lifecycle; a sixth value there would break the - // `convert_lead` predicate, the `lead_status_progression` transitions and - // the seeded rows, and would conflate "this lead is worth working" with - // "someone signed off on converting it". - conversion_approval_status: Field9.select({ - label: "Conversion Approval", - group: "qualification", - readonly: true, - trackHistory: true, - description: "Whether this lead has been signed off for conversion. Not Required means no approval is asked for \u2014 the shipped default.", - defaultValue: "not_required", - options: [ - { label: "Not Required", value: "not_required", default: true }, - { label: "Pending", value: "pending", color: "#FFA500" }, - { label: "Approved", value: "approved", color: "#00AA00" }, - { label: "Rejected", value: "rejected", color: "#FF0000" } - ] - }), - // Assignment - // Conversion tracking. - // ⛔ NOT `readonly`: the `lead_conversion` flow's `mark_converted` node - // UPDATEs this column and the four `converted_*` ones below, and that flow - // declares no `runAs` — so it runs at the engine default `'user'`, which is - // also where house rule 9 keeps a screen flow. `stripReadonlyFields` runs - // under `if (!opCtx.context?.isSystem)` and deletes every readonly key the - // CALLER supplied, so `readonly` here would silently un-convert every - // conversion. - // ⚠️ The other writer is unaffected, and is not the reason: the - // guest-submission sanitiser in `lead.hook.ts` ASSIGNS these on - // `beforeInsert`, and hook-written keys are not caller-supplied — nor does - // the strip run on INSERT at all. Measured in - // `test/readonly-write-semantics.test.ts`. - // ⇒ Declaring these `readonly` would need the flow's write ELEVATED, which - // is a privilege decision on the maintainer's floor, not this file's (#1435). - // Edit-protection is the `beforeUpdate` guard in `lead.hook.ts`, which - // rejects any USER edit to a converted lead outside a small allow-list — - // and it is the ONLY guard, deliberately: a script validation beside it - // never fires, because the hook's throw always wins the race. - is_converted: Field9.boolean({ - label: "Converted", - defaultValue: false, - group: "conversion", - trackHistory: true - }), - converted_account: Field9.lookup("crm_account", { - label: "Converted Account", - group: "conversion" - }), - converted_contact: Field9.lookup("crm_contact", { - label: "Converted Contact", - group: "conversion" - }), - converted_opportunity: Field9.lookup("crm_opportunity", { - label: "Converted Opportunity", - group: "conversion" - }), - converted_date: Field9.datetime({ - label: "Converted Date", - group: "conversion" - }), - // Address (using new address field type) - address: Field9.address({ - label: "Address", - group: "address" - }), - // Additional Info - annual_revenue: Field9.currency({ - label: "Annual Revenue", - group: "additional" - }), - number_of_employees: Field9.number({ - label: "Number of Employees", - group: "additional" - }), - description: Field9.markdown({ - label: "Description", - group: "additional" - }), - // Custom notes with rich text formatting - notes: Field9.richtext({ - label: "Notes", - description: "Working notes on this lead \u2014 supports formatting.", - group: "additional" - }), - // Flags - do_not_call: Field9.boolean({ - label: "Do Not Call", - defaultValue: false, - group: "preferences" - }), - email_opt_out: Field9.boolean({ - label: "Email Opt Out", - defaultValue: false, - group: "preferences" - }), - // Follow-up & disqualification tracking - next_followup_date: Field9.date({ - label: "Next Follow-up Date", - group: "qualification" - }), - // NOT `readonly` (#592) — see the long note on - // `crm_account.last_activity_date`. The activity bubble writes this from - // another object's hook, and a readonly field is stripped from any - // non-system write whose caller supplied the key (#2948), so every bubble - // into this column was silently discarded. - last_contacted_date: Field9.datetime({ - label: "Last Contacted", - group: "qualification" - }), - disqualification_reason: Field9.select({ - label: "Disqualification Reason", - group: "qualification", - description: "Required when status is Unqualified", - options: [ - { label: "Not a Fit", value: "not_a_fit" }, - { label: "No Budget", value: "no_budget" }, - { label: "Wrong Persona", value: "wrong_persona" }, - { label: "Unreachable", value: "unreachable" }, - { label: "Duplicate", value: "duplicate" }, - { label: "Competitor", value: "competitor" }, - { label: "Other", value: "other" } - ] - }), - // ── Duplicate management ─────────────────────────────────────────── - // - // `disqualification_reason: 'duplicate'` is only meaningful if the record - // says WHAT it duplicates — otherwise the "duplicate" bar on the - // disqualification breakdown points at nothing you can open. - // - // ⚠️ The surviving record can live on either object — a still-open lead, or - // a contact the prospect already became — and `Field.lookup` takes exactly - // one target (`Field.lookup(['crm_lead','crm_contact'])` is rejected at - // schema parse: "reference: expected string, received array"). So the link - // is the same TYPE-DISCRIMINATOR shape `crm_task.related_to_*` already uses: - // one select naming the object, one lookup per object, and the pairing - // enforced declaratively. - // - // The vocabulary is TWO sets, declared and split in `_picklists.ts`: the two - // object names an author may pick, plus `erased` — a tombstone the form does - // not offer and only `lead_duplicate_check` ever writes. - // - // The tombstone is what lets an erasure COMPLETE against a lead a human - // confirmed as a duplicate, without relaxing one rule, so read it as a - // constraint rather than as a spare value: `requiredWhen` below pairs only - // `crm_lead` / `crm_contact`, so a tombstoned type never fires either - // pairing and never demands a pointer to a record that is gone; and - // `duplicate_disqualification_requires_survivor` asks for a NON-BLANK type - // plus `duplicate_status == "confirmed"`, both of which a tombstoned lead - // still satisfies — so the verdict a reviewer recorded survives the erasure - // instead of being deleted as a side effect of someone else's GDPR request. - duplicate_of_type: Field9.select({ - label: "Duplicate Of", - group: "duplicates", - description: "Which object holds the surviving record this lead repeats.", - options: [...DUPLICATE_OF_TYPE_OPTIONS] - }), - // ⚠️ The type↔lookup pairing is `requiredWhen`, not a script validation: - // "the lookup named by the type must be populated" is exactly a conditional - // write contract, the engine evaluates it on insert and update, and it - // reports against the FIELD, so the form marks the empty lookup instead of - // showing a record-level error. (`crm_task` states the same intent as a - // warning-severity script rule because it predates `requiredWhen`, - // ADR-0113.) - // - // ⚠️ `has(...)` is load-bearing, not decoration. A bare - // `record.duplicate_of_type == "crm_lead"` aborts with `No such key` on any - // record whose merged shape omits the column, and the engine's response to a - // predicate that fails to evaluate is to SKIP it ("requiredWhen for - // 'duplicate_of_lead' failed to evaluate — skipped"). The rule would then - // read as enforced and require nothing at all. - // - // ⚠️ Both lookups take the spec default `deleteBehavior: 'set_null'`, and - // that is deliberate: a lead is a first-class record that happens to carry a - // flag, so `cascade` would destroy the lead because the record it was - // compared against was deleted. What keeps the pairing honest under a - // `set_null` clear is the retirement block in `lead_duplicate_check` - // (`lead.hook.ts`, job 1c): when a write leaves the named lookup blank it - // drops `duplicate_of_type` and `duplicate_status` in the same write, so the - // pair is never left half-stated and this rule never has to be loosened to - // tolerate one. Read that note before changing either predicate. - duplicate_of_lead: Field9.lookup("crm_lead", { - label: "Duplicate Of Lead", - group: "duplicates", - requiredWhen: P6`has(record.duplicate_of_type) && record.duplicate_of_type == "crm_lead"` - }), - duplicate_of_contact: Field9.lookup("crm_contact", { - label: "Duplicate Of Contact", - group: "duplicates", - requiredWhen: P6`has(record.duplicate_of_type) && record.duplicate_of_type == "crm_contact"` - }), - // Machine suspicion and human verdict are ONE field with two values, not two - // parallel sets of link fields: the intake hook writes `suspected` and only - // ever when this is blank (lead.hook.ts), so a human's `confirmed` survives - // every later write, and both states stay queryable off one column. - duplicate_status: Field9.select({ - label: "Duplicate Status", - group: "duplicates", - trackHistory: true, - description: "Suspected = flagged automatically at intake. Confirmed = a human verified the match.", - options: [ - { label: "Suspected", value: "suspected", color: "#FFA500" }, - { label: "Confirmed", value: "confirmed", color: "#FF0000" } - ] - }) - }, - // Lifecycle transitions are enforced via a `state_machine` validation rule - // (see validations[] below). ⚠️ There is no top-level `stateMachines` key on - // the platform — status state machines are expressed in the validation union. - // Database indexes for performance - // - // ⚠️ `email` is indexed but NOT unique, and the index must stay explicit: it - // used to exist only as a side effect of a field-level `unique: true`, so - // dropping that constraint would otherwise have dropped the index with it and - // left three read paths — the `lead_duplicate_check` intake lookup, the - // `crm_lead_import` upsert key and the conversion flow — scanning the table - // on every write. - // - // ⛔ Do NOT add `unique: true` back here: a single-column unique index makes - // the platform-wide constraint win over the per-tenant composite - // (framework#3991), so two organizations could not work the same address - // independently. Uniqueness is not the rule this object wants at all. - indexes: [ - { fields: ["owner_id"] }, - { fields: ["status"] }, - { fields: ["company"] }, - { fields: ["email"] } - ], - // API surface. History → Field.trackHistory (ADR-0052). - enable: { - apiEnabled: true - }, - // ADR-0079 record title — the `display_title` formula field defined above. - nameField: "display_title", - // Explicit search targets (ADR-0061). REQUIRED because nameField is a - // FORMULA (display_title/full_name): without this, $search auto-defaults to - // the formula field, which isn't a real column, so the lookup picker + global - // search silently return zero. These are real, indexed columns. - searchableFields: ["first_name", "last_name", "company", "email"], - highlightFields: ["full_name", "company", "email", "status", "owner_id"], - // Removed: list_views and form_views belong in UI configuration, not object definition - // Predicates below are TOTAL: every `record.x` read is `has()`-guarded, so the - // rule returns a verdict even when the merged record has no such key. See - // AGENTS.md "Validation predicates must be TOTAL" and - // test/object-validation-predicates.test.ts, which fails the build otherwise. - validations: [ - { - name: "email_required", - type: "script", - severity: "error", - message: "Email is required", - condition: P6`!has(record.email) || isBlank(record.email)` - }, - { - // The field description promises "Required when status is Unqualified"; - // this is what enforces it. A lead in `unqualified` with no recorded - // reason loses the one datum a disqualification review needs. Same shape - // as `crm_case.escalation_reason_required`. - name: "disqualification_reason_required", - type: "script", - severity: "error", - message: "Disqualification reason is required when a lead is Unqualified", - condition: P6`has(record.status) && record.status == "unqualified" && (!has(record.disqualification_reason) || isBlank(record.disqualification_reason))` - }, - { - // "Disqualified as a duplicate" has to name the survivor. - // - // Same shape as `disqualification_reason_required` directly above — a - // declarative condition evaluated by the engine on insert and update, with - // no hook involved. The two clauses are the two things the field-level - // `requiredWhen` on the lookups cannot say: - // - // 1. `duplicate_of_type` must be chosen, which is what makes exactly one - // of the two `requiredWhen` predicates fire and demand its lookup. - // 2. `duplicate_status` must be `confirmed` SPECIFICALLY. `requiredWhen` - // asks whether a field is populated, not what it holds — and a lead - // closed on the machine's `suspected` guess is precisely the outcome - // this rule exists to prevent. A human has to look and agree. - // - // ⚠️ Every field reference is wrapped in `has(...)`, and that is what makes - // this an enforced rule rather than a decorative one. The engine evaluates - // a validation against `{...previous, ...data}` and fills absent fields - // with null on INSERT — but not on UPDATE, where `previous` is whatever - // the driver returned, and a driver that stores only the columns a row was - // written with hands back a record with no `duplicate_status` key at all. - // Strict CEL then aborts the whole predicate with `No such key`, and a - // predicate that fails to evaluate is SKIPPED, not failed: - // - // WARN Validation rule '…' predicate failed to evaluate (…) — skipped - // - // The unguarded first draft of this rule let a lead be closed as a - // duplicate with no survivor named, silently, on the in-memory driver — - // the driver the whole test suite runs on. - name: "duplicate_disqualification_requires_survivor", - type: "script", - severity: "error", - message: "Disqualifying a lead as Duplicate requires naming the surviving record and setting Duplicate Status to Confirmed", - condition: P6`has(record.disqualification_reason) && record.disqualification_reason == "duplicate" && !(has(record.duplicate_of_type) && !isBlank(record.duplicate_of_type) && has(record.duplicate_status) && record.duplicate_status == "confirmed")` - }, - { - name: "lead_status_progression", - type: "state_machine", - severity: "warning", - message: "Invalid lead status transition", - field: "status", - // Conversion (→ converted) is allowed from any worked-open status so the - // Convert action's widened visibility (new/contacted/qualified) never trips - // a spurious "invalid transition" warning when the flow stamps - // status:'converted'. - transitions: { - new: ["contacted", "qualified", "unqualified", "converted"], - contacted: ["qualified", "unqualified", "converted"], - qualified: ["converted", "unqualified"], - unqualified: ["new"], - converted: [] - } - } - ] - // ⚠️ No `workflows[]` here, and none is possible: object `workflows[]` were - // removed from the platform. Field updates live in this object's `*.hook.ts`; - // scheduled status flips and notifications live in `src/*/flows/*.flow.ts`. -}); - -// src/sales/objects/opportunity.object.ts -import { ObjectSchema as ObjectSchema10, Field as Field10 } from "@objectstack/spec/data"; -import { F as F7, P as P7 } from "@objectstack/spec"; -var Opportunity = ObjectSchema10.create({ - name: "crm_opportunity", - label: "Opportunity", - pluralLabel: "Opportunities", - icon: "dollar-sign", - description: "Sales opportunities and deals in the pipeline", - // ADR-0090 D1/D7: OWD is an authored decision. Owner + high-value management sharing rule. - sharingModel: "private", - // ⚠️ ADR-0079 `nameField` is a FIELD, not a render template, and a FORMULA - // sees the stored select VALUE rather than its translated label — so a - // `'{name} - {stage}'` title renders every deal "Enterprise Deal - - // closed_won" in lookups, related lists and search, in every locale. The - // formula language has no option-label lookup, so the title is the plain - // `name` column; `stage` still leads the highlight strip below, translated. - nameField: "name", - // Explicit search targets (ADR-0061). `name` is a real indexed column, so - // $search resolves on its own here; the list is kept explicit to pin the - // intent (other objects whose nameField IS a formula rely on it). - searchableFields: ["name"], - highlightFields: ["name", "crm_account", "amount", "stage", "owner_id"], - fieldGroups: [ - { key: "basic", label: "Basic Information", icon: "dollar-sign" }, - { key: "financials", label: "Financials", icon: "trending-up" }, - { key: "sales_process", label: "Sales Process", icon: "target" }, - { key: "qualification", label: "Qualification", icon: "filter" }, - { key: "narrative", label: "Deal Narrative", icon: "book-open" }, - { key: "classification", label: "Classification", icon: "tag" }, - { key: "campaign", label: "Campaigns", icon: "flag", collapse: "collapsed" }, - { key: "notes", label: "Notes & Next Steps", icon: "file-text" }, - { key: "crm_forecast", label: "Forecast & Metrics", icon: "bar-chart", collapse: "collapsed" } - ], - fields: { - // Platform ownership anchor — canonical note in `account.object.ts` (#548). - owner_id: Field10.lookup("sys_user", { - label: "Opportunity Owner", - group: "basic", - system: true, - readonly: false, - trackHistory: true - }), - // Basic Information - name: Field10.text({ - label: "Opportunity Name", - required: true, - storage: { notNull: true }, - searchable: true, - group: "basic" - }), - // (No `display_title` formula — see `nameField` above: composing the title - // from `stage` leaked the raw select value into every rendered title.) - // Relationships - crm_account: Field10.lookup("crm_account", { - label: "Account", - required: true, - storage: { notNull: true }, - group: "basic" - }), - primary_contact: Field10.lookup("crm_contact", { - label: "Primary Contact", - // @objectstack 12: string[] `referenceFilters` is dead (not read by the - // picker); `dependsOn` is the live cascading form — scopes contacts to the - // opportunity's `crm_account` (ADR-0049). - dependsOn: ["crm_account"], - group: "basic" - }), - // Financial Information - amount: Field10.currency({ - label: "Amount", - required: true, - storage: { notNull: true }, - min: 0, - group: "financials", - trackHistory: true - }), - expected_revenue: Field10.currency({ - label: "Expected Revenue", - readonly: true, - // Calculated field - group: "financials" - }), - // ─── Qualification (REQ-0006 step 8) ─────────────────────────────── - // - // The standard triage vocabulary of a seller that cannot pursue every - // deal. `forecast_category` answers a different question — it is the - // forecast roll-up bucket, derived from `stage` — so none of this is - // folded into it. GENERIC values only: a customer's own grading scale is - // overlay configuration (REQ-0006 acceptance 5). - // - // ⚠️ `pnpm validate` reports the fields in this block, in the narrative - // block below, and the customer-side dates as "carrier-only — declared - // but nothing in this stack reads or displays it", and that reading is - // EXPECTED here rather than a defect to tidy away. The liveness - // diagnostic counts view columns, form sections, page bindings, flow - // nodes, formulas, hooks and actions as sites; it does NOT count - // `fieldGroups` membership, which is precisely the DERIVED layout - // REQ-0006 acceptance 1 asks for. ⛔ Do NOT answer the warning by - // authoring a `record:details` section — that is the escape hatch - // AGENTS.md reserves for a named customer demand, and it would trade - // acceptance 1 for a quieter log. `crm_account`'s business-profile block - // carries the same verdict on `main` for the same reason (#1948). - will_bid: Field10.boolean({ - label: "Will Bid", - description: "Whether we intend to bid. Unset means the decision is open.", - group: "qualification" - }), - controllability: Field10.select({ - label: "Controllability", - group: "qualification", - options: [ - { label: "High", value: "high" }, - { label: "Medium", value: "medium" }, - { label: "Low", value: "low" } - ] - }), - priority: Field10.select({ - label: "Priority", - group: "qualification", - options: [ - { label: "High", value: "high" }, - { label: "Medium", value: "medium" }, - { label: "Low", value: "low" } - ] - }), - deal_level: Field10.select({ - label: "Deal Level", - group: "qualification", - options: [ - { label: "Strategic", value: "strategic" }, - { label: "Key", value: "key" }, - { label: "Standard", value: "standard" } - ] - }), - // The FACT of subcontracting is generic and belongs in core; the - // customer's supplier list is not and is not proposed here. - is_subcontracted: Field10.boolean({ - label: "Involves Subcontracting", - defaultValue: false, - group: "qualification" - }), - subcontracting_note: Field10.textarea({ - label: "Subcontracting Note", - group: "qualification" - }), - // ─── The 立项 (qualification) gate: the rep's request ───────────── - // - // REQ-0006 step 11: 「销售立项需走审批流程；新增商机可跟进，立项通过后方可更新阶段、 - // 投标、赢丢单操作。」 The rep ASKS for 立项 by ticking this box, and - // `opportunity_qualification_approval` opens one approval when it turns on - // (the TRANSITION, not the current value). A rejection clears it, so - // ticking it again is a fresh request — the role `requested_status` plays - // for the status-change gate, as a boolean because 立项 asks for one thing. - // - // `defaultValue: false` is load-bearing for the start condition: every deal - // born after this column then STORES the key, so `has(previous.…)` holds - // on every driver and the off→on transition is visible. Not readonly: this - // is the one half of the gate a person writes. Inert while the gate is - // off — nothing reads it unless an install arms the verdict below. - qualification_requested: Field10.boolean({ - label: "Request Qualification Approval", - description: "Tick to send this deal for qualification approval. A rejection clears it; tick it again to ask again.", - defaultValue: false, - group: "qualification" - }), - // ─── The 立项 gate's switch AND its verdict column ───────────────── - // - // ⚠️ This `defaultValue` IS the switch, exactly as on - // `status_change_approval_status` below, and shipped it is `not_required`: - // the gate is OFF by default (REQ-0006 *Disposition*: "Both gates must be - // configurable — off by default"). No deal is born `pending`, the flow's - // start condition and the `opportunity_lifecycle` refusal are false for - // every record that has ever existed, and a stage move, Will Bid and a - // direct close work exactly as they do without it. An install ARMS the gate - // by changing this one value to `'pending'`; deals that already exist keep - // `not_required`, so arming it invalidates no record. ⛔ Not the flow's - // `status` — `lead-conversion-approval.flow.ts` records why. - // - // ⚠️ Its OWN column — ⛔ never `approval_status` (the amount-tiered - // flow's; its entry keys on `not_required`, so sharing would re-arm it) and - // ⛔ never `status_change_approval_status` (one gate's verdict would erase - // the other's, and the step-14 hook reads that column input-first). - // - // `readonly: true` on the #1666 grounds: the only writers are the gate's - // own `runAs: 'system'` flow and the insert default, and both survive the - // readonly strip. A user-supplied verdict is stripped BEFORE the - // `beforeUpdate` hooks run — measured on 17.6.0 with a real ObjectQL: a - // user update of `{ stage, qualification_approval_status: 'approved' }` - // reached the hooks as `{ id, stage }` and was refused 409 — so the - // input-first read in `opportunity_lifecycle` cannot be fed an `approved` - // by hand. - qualification_approval_status: Field10.select({ - label: "Qualification Approval", - group: "qualification", - readonly: true, - defaultValue: "not_required", - options: [ - { label: "Not Required", value: "not_required", default: true }, - { label: "Pending", value: "pending", color: "#FFA500" }, - { label: "Approved", value: "approved", color: "#00AA00" }, - { label: "Rejected", value: "rejected", color: "#FF0000" } - ] - }), - // Sales Process - stage: Field10.select({ - label: "Stage", - required: true, - storage: { notNull: true }, - group: "sales_process", - // ADR-0052 §5b.1 — the platform auto-renders each stage change on the - // activity timeline as "Stage: Proposal → Negotiation" (no hook code). - trackHistory: true, - // Canonical set (#490) — the mass_update_stage action renders the same - // list; see _picklists.ts. - options: [...OPPORTUNITY_STAGE_OPTIONS] - }), - probability: Field10.percent({ - label: "Probability (%)", - min: 0, - max: 100, - defaultValue: 10, - group: "sales_process" - }), - // Important Dates - close_date: Field10.date({ - label: "Close Date", - required: true, - storage: { notNull: true }, - group: "sales_process", - trackHistory: true - }), - // NO `created_date` here: the platform already injects `created_at` on - // every object, and this duplicate had no writer at all — not the seed - // data, not a hook, not a flow — so it was permanently null while - // `created_at` carried the real value (#575 B2). Surfaces that need the - // creation instant read `created_at` (see the deal_timeline view). - // - // Stage-age clock (#489). This is the STORED half of the pair: a real, - // indexed date column, so it is what automation and views may filter and - // sort on. `days_in_stage` below is a formula derived from it. - // `opportunity_lifecycle` stamps it on insert and re-stamps it on every - // stage change; readonly because nothing but that hook should move it - // (before-hook writes survive readonly stripping — only caller-supplied - // keys are dropped). - stage_entry_date: Field10.date({ - label: "Stage Entry Date", - description: "Date this opportunity entered its current stage.", - readonly: true, - group: "sales_process" - }), - // ─── The customer's own procurement calendar (REQ-0006 step 8) ───── - // - // ⛔ Never folded into `close_date`: that is a single date and it is OUR - // expected close. These are three distinct BUYER-side events, and - // REQ-0006 acceptance 2 requires them to be reportable independently of - // the forecast close date — see the `tender_this_quarter` list view, - // which predicates on `expected_tender_date` alone. - customer_initiation_date: Field10.date({ - label: "Customer Initiation Date", - group: "sales_process" - }), - expected_tender_date: Field10.date({ - label: "Expected Tender Date", - group: "sales_process" - }), - expected_signing_date: Field10.date({ - label: "Expected Signing Date", - group: "sales_process" - }), - expected_tender_amount: Field10.currency({ - label: "Expected Tender Amount", - min: 0, - group: "sales_process" - }), - expected_signing_amount: Field10.currency({ - label: "Expected Signing Amount", - min: 0, - group: "sales_process" - }), - // Additional Classification - type: Field10.select({ - label: "Opportunity Type", - group: "classification", - options: [ - { label: "New Business", value: "new_business" }, - { label: "Existing Customer - Upgrade", value: "existing_upgrade" }, - { label: "Existing Customer - Renewal", value: "existing_renewal" }, - { label: "Existing Customer - Expansion", value: "existing_expansion" } - ] - }), - // ⛔ BESIDE `type`, never replacing or overloading it: `type`'s four - // values are a RELATIONSHIP taxonomy that `opportunity.hook.ts` and - // reporting read. Generic delivery-model values only — the customer's own - // line-of-business list is overlay (REQ-0006 acceptance 5). - business_line: Field10.select({ - label: "Business Line", - group: "classification", - options: [ - { label: "Product", value: "product" }, - { label: "Professional Services", value: "services" }, - { label: "Consulting", value: "consulting" }, - { label: "Support & Maintenance", value: "support" }, - { label: "Other", value: "other" } - ] - }), - lead_source: Field10.select({ - label: "Lead Source", - group: "classification", - // Canonical set shared with Lead + Contact (#490): lead_conversion - // copies `leadRecord.lead_source` onto the opportunity it creates, so - // this must accept every Lead value. - options: [...LEAD_SOURCE_OPTIONS] - }), - // Campaign tracking - crm_campaign: Field10.lookup("crm_campaign", { - label: "Campaign", - description: "Marketing campaign that generated this opportunity", - group: "campaign" - }), - // Sales cycle metrics - // - // ⚠️ FORMULA, not a stored counter. As a plain number column nothing ever - // raises it: the hook resets it to 0 on a stage change and no sweep - // increments it, so `days_in_stage > 14` matches only rows a seed hardcoded - // and the `opportunity_stagnation` flow never fires on real data. Deriving - // it from `stage_entry_date` is correct on every read and costs no nightly - // full-table pass. - // - // ⚠️ The trade-off: formulas are evaluated AFTER the query (the engine's - // `applyFormulaPlan` walks the returned rows), so this is not a real column - // and CANNOT appear in a filter or a sort. Anything that needs to *select* - // stalled deals predicates on `stage_entry_date` instead — see - // `opportunity-stagnation.flow.ts` and the `stale_opportunities` view. - // - // ⚠️ `has()` + null guard: `daysBetween(null, …)` faults and the whole field - // silently evaluates to null, so an unstamped row is spelled out as null - // rather than arriving there by accident. - days_in_stage: Field10.formula({ - label: "Days in Current Stage", - expression: F7`has(record.stage_entry_date) && record.stage_entry_date != null ? daysBetween(record.stage_entry_date, today()) : null`, - returnType: "number", - group: "crm_forecast" - }), - // Additional information - description: Field10.markdown({ - label: "Description", - group: "notes" - }), - next_step: Field10.textarea({ - label: "Next Steps", - group: "notes" - }), - // ─── Deal narrative (REQ-0006 step 10) ───────────────────────────── - // - // The standard deal-review narrative, split out of `description` so each - // part is reviewable, templatable and (later) reportable on its own — - // ⛔ not more prose crammed into one markdown field. - // - // ⚠️ `payment_terms` is PROSE here and a select on `crm_quote` / - // `crm_contract`: what a rep records mid-pursuit is the shape of a term - // still being negotiated, not the net-terms ladder a signed document - // carries. ⛔ Do not "unify" it onto PAYMENT_TERMS_OPTIONS — that would - // force a half-agreed term into a closed vocabulary. - // - // All four are `Field.textarea` (REQ-0006 names markdown OR textarea per - // field). Measured on the 17.6.0 console, the Details tab's edit mode — - // the surface these fields render on — has no markdown editor, so a - // markdown field here could be read but never written. The maintainer - // ruled textarea for the three that were markdown (2026-10-03, on #1950: - // 「改成 textarea(推荐)」). - customer_background: Field10.textarea({ - label: "Customer Background", - group: "narrative" - }), - project_background: Field10.textarea({ - label: "Project Background", - group: "narrative" - }), - risk_analysis: Field10.textarea({ - label: "Risk Analysis", - group: "narrative" - }), - payment_terms: Field10.textarea({ - label: "Payment Terms", - group: "narrative" - }), - // Flags - is_private: Field10.boolean({ - label: "Private", - defaultValue: false, - group: "crm_forecast" - }), - forecast_category: Field10.select({ - label: "Forecast Category", - group: "crm_forecast", - options: [ - { label: "Pipeline", value: "pipeline" }, - { label: "Best Case", value: "best_case" }, - { label: "Commit", value: "commit" }, - { label: "Omitted", value: "omitted" }, - { label: "Closed", value: "closed" } - ] - }), - // Approval workflow tracking. - // ⭐ `readonly: true` — DECLARED, and the declaration is the honest one - // rather than a hopeful one. Audited per writer (#1666): every writer of - // this column and of `approved_date` is elevated or an insert. - // `opportunity_approval` declares `runAs: 'system'`, and - // `opportunity_approval_on_create` inherits it by spreading that flow, so - // `resolveRunDataContext` hands the engine `isSystem: true` and the - // `if (!opCtx.context?.isSystem)` strip branch is skipped outright; the - // `approval` node's own `approvalStatusField` write runs inside those same - // system runs; seeds write on INSERT, which the strip never touches. No - // view, page or action writes either column. ⇒ No writer loses its write. - // Ruled #1666 (director seat, decision batch #74, 2026-09-07): "Declared = - // enforced" applies to the audit surface too. ⛔ The hand-edit escape hatch - // — an admin clearing a stuck approval by typing over the stamp — is given - // up ON PURPOSE: a stuck approval is a platform or flow defect to be fixed - // as one, not a reason to keep an audit stamp hand-editable. ⛔ Do not - // reintroduce a bypass, and do not soften either column back to editable - // without a new ruling. Both halves are pinned in - // `test/audit-stamp-readonly.test.ts`: the system path still lands both - // stamps, and a plain user-context UPDATE of either is stripped. - // ⚠️ `defaultValue` at FIELD level: option-level `default: true` - // only preselects in UI forms — API and flow inserts land null without it, - // and a null `approval_status` never matches the flow's entry condition. - approval_status: Field10.select({ - label: "Approval Status", - group: "sales_process", - readonly: true, - defaultValue: "not_required", - options: [ - { label: "Not Required", value: "not_required", default: true }, - { label: "Pending", value: "pending", color: "#FFA500" }, - { label: "Approved", value: "approved", color: "#00AA00" }, - { label: "Rejected", value: "rejected", color: "#FF0000" } - ] - }), - approved_date: Field10.datetime({ - label: "Approved Date", - group: "sales_process", - readonly: true - }), - // ─── The status-change gate's switch AND its verdict column ──────── - // - // ⚠️ This `defaultValue` IS the switch, and shipped it is `not_required`, - // so the gate is OFF by default — REQ-0006 acceptance 3: "with it off - // (the default), the existing amount-tiered behaviour of - // `opportunity-approval.flow.ts` is bit-for-bit what it is today". No - // record is ever born `pending`, `opportunity_status_change_approval`'s - // start condition is false for every row that has ever existed, and - // nothing about the amount-tiered flow changes. An install ARMS the gate - // by changing this one value to `'pending'`. - // - // ⛔ Not the flow's `status`, for the reason - // `lead-conversion-approval.flow.ts` records and measured: `draft` still - // fires its triggers, and `obsolete` composes with the installation's - // activation ledger into a gate no install can ever turn ON. - // - // ⚠️ Deliberately NOT `approval_status`. That column is the amount-tiered - // flow's, and sharing it would make either gate's verdict erase the - // other's — and re-trigger the amount flow, whose entry condition keys on - // `approval_status == "not_required"`. - // - // `readonly: true` on the same audited grounds as `approval_status` - // (#1666): the only writers are the gate's own `runAs: 'system'` flow and - // the insert default, and both survive the readonly strip. - // What the rep is ASKING for, ⛔ never the stage itself: REQ-0006 - // acceptance 3 requires the stage not to move until the request is - // decided, and a `record_change` flow binds an AFTER hook — by the time it - // runs, a stage the rep wrote has already moved. So the rep writes the - // request here (with the win/loss reason), and the approved decision - // writes `stage` — the customer's own step 14, 「通过后商机状态正式生效」. - // - // Values ARE the two stage values, so the flow's approve branch can apply - // it with `stage: '{oppRecord.requested_status}'` and no mapping table can - // drift. Not readonly: this is the one half of the gate a person writes. - // Inert while the gate is off — nothing reads it unless the install arms - // `status_change_approval_status`. - requested_status: Field10.select({ - label: "Requested Status", - group: "sales_process", - options: [ - { label: "Won", value: "closed_won" }, - { label: "Lost", value: "closed_lost" } - ] - }), - status_change_approval_status: Field10.select({ - label: "Status Change Approval", - group: "sales_process", - readonly: true, - defaultValue: "not_required", - options: [ - { label: "Not Required", value: "not_required", default: true }, - { label: "Pending", value: "pending", color: "#FFA500" }, - { label: "Approved", value: "approved", color: "#00AA00" }, - { label: "Rejected", value: "rejected", color: "#FF0000" } - ] - }), - // ─── Win / Loss analysis ─────────────────────────────────────────── - // - // ⛔ The reason is captured AT CLOSE, and that is enforced, not requested. - // Leaving both fields optional means every seeded and user-closed deal - // lands with them empty and the win/loss widgets below have nothing to draw. - // - // `requiredWhen`, not a script validation, for the same reason - // `crm_lead.duplicate_of_lead` uses it (ADR-0113): "this field must hold a - // value when the record looks like X" is exactly a conditional write - // contract, the engine evaluates it on insert AND update inside - // `evaluateValidationRules`, and it reports against the FIELD — so the form - // marks the empty picklist instead of showing a record-level banner. It is - // ALSO the only shape the freeze below leaves usable: once a deal is closed, - // `opportunity.hook.ts` refuses every user edit outside the narrative - // fields, so a reason not captured in the closing write can never be added - // afterwards. Close time is the only chance. - // `test/win-loss-capture.test.ts` drives both predicates through a real - // ObjectQL over a real driver, on insert and on update. - // - // ⚠️ `has(...)` is load-bearing. A bare `record.stage == "closed_lost"` - // aborts with `No such key` on any merged record that omits the column, and - // the engine's answer to a predicate that cannot evaluate is to SKIP it - // ("requiredWhen for 'loss_reason' failed to evaluate — skipped"), which - // would make this read as enforced while requiring nothing at all. - win_reason: Field10.select({ - label: "Win Reason", - description: "Why this deal was won. Required to close an opportunity as Won.", - group: "classification", - requiredWhen: P7`has(record.stage) && record.stage == "closed_won"`, - options: [ - { label: "Better Product", value: "better_product" }, - { label: "Better Price", value: "better_price" }, - { label: "Existing Relationship", value: "relationship" }, - { label: "Better Support", value: "better_support" }, - { label: "Best Fit / Features", value: "best_fit" }, - // Written by the machine, not chosen by a rep: `quote_on_accepted` - // (quote.hook.ts) wins the deal the moment a customer accepts the - // quote, and no human is in that write to attribute it. Naming the - // automated path is this repo's existing idiom for exactly that split - // (`crm_lead.duplicate_status` = machine `suspected` vs human - // `confirmed`) and it keeps the rule exception-free: every closed_won - // row carries a reason, and an analyst can still tell a CPQ close from - // a rep's attribution instead of reading a fabricated "Better Product". - { label: "Quote Accepted", value: "quote_accepted" }, - { label: "Other", value: "other" } - ] - }), - loss_reason: Field10.select({ - label: "Loss Reason", - description: "Why this deal was lost. Required to close an opportunity as Lost.", - group: "classification", - requiredWhen: P7`has(record.stage) && record.stage == "closed_lost"`, - options: [ - { label: "Price Too High", value: "price" }, - { label: "Lost to Competitor", value: "competitor" }, - { label: "No Budget", value: "no_budget" }, - { label: "No Decision", value: "no_decision" }, - { label: "Bad Timing", value: "timing" }, - { label: "Missing Features", value: "features" }, - { label: "Other", value: "other" } - ] - }), - loss_details: Field10.textarea({ - label: "Loss/Win Details", - description: "Free-text context behind the win or loss reason.", - group: "classification" - }) - }, - // Database indexes for performance - indexes: [ - { fields: ["name"] }, - { fields: ["crm_account"] }, - { fields: ["owner_id"] }, - { fields: ["stage"] }, - { fields: ["close_date"] }, - // The stagnation sweep filters on this every morning. - { fields: ["stage_entry_date"] } - ], - // Enable advanced features - // - // Stage/amount history is tracked per-field via `Field.trackHistory` - // (ADR-0052). ⚠️ Ownership is NOT: it lives on the platform's injected - // `owner_id`, which carries no `trackHistory` flag — a transfer is recorded - // in the compliance audit log (`sys_audit_log`, unconditional) rather than on - // the activity feed. - enable: { - apiEnabled: true, - apiMethods: ["get", "list", "create", "update", "delete"], - // Whitelist allowed API operations - // #602 — proposals, redlines and signed orders belong on the deal. - // See the canonical capability note in `src/sales/objects/index.ts`. - files: true - }, - // ADR-0052 §5b.2 — declarative milestone activity. When `stage` enters these - // values the platform emits a semantic timeline entry (no hook code). - // Combined with the field-level `trackHistory` above (stage-change rows) this - // replaces any hand-coded activity hook. - activityMilestones: [ - { field: "stage", value: "closed_won", summary: "Deal won \u2014 {name}", type: "completed" }, - { field: "stage", value: "closed_lost", summary: "Deal lost \u2014 {name}", type: "completed" } - ], - // Removed: list_views and form_views belong in UI configuration, not object definition - // Lifecycle transitions are enforced via a `state_machine` validation rule - // (see validations[] below). ⚠️ There is no top-level `stateMachines` key on - // the platform — status state machines live in the validation union. - // Validation Rules - // - // Predicates below are TOTAL: every `record.x` read is `has()`-guarded, so the - // rule returns a verdict even when the merged record has no such key. See - // AGENTS.md "Validation predicates must be TOTAL" and - // test/object-validation-predicates.test.ts, which fails the build otherwise. - validations: [ - { - name: "close_date_future", - type: "script", - severity: "warning", - message: "Close date should not be in the past unless opportunity is closed", - // An absent `stage` key means "no stage recorded", which is not a closed - // stage — hence `!has(record.stage) || (…)` rather than a leading - // `has(record.stage) &&`, which would suppress the warning instead. - condition: P7`has(record.close_date) && record.close_date != null && record.close_date < today() && (!has(record.stage) || (record.stage != "closed_won" && record.stage != "closed_lost"))` - }, - { - name: "amount_positive", - type: "script", - severity: "error", - message: "Amount must be greater than zero", - condition: P7`has(record.amount) && record.amount != null && record.amount <= 0` - }, - { - name: "opportunity_stage_progression", - type: "state_machine", - severity: "warning", - message: "Invalid opportunity stage transition", - field: "stage", - transitions: { - // `→ proposal` is legal from every pre-proposal stage: the - // quote_generation flow fast-forwards the deal to `proposal` when a - // quote is generated, which can happen at any open stage. - prospecting: ["qualification", "proposal", "closed_lost"], - qualification: ["needs_analysis", "proposal", "closed_lost"], - needs_analysis: ["proposal", "closed_lost"], - // `proposal → closed_won` is legal: the quote_on_accepted hook closes - // the linked deal directly from the CPQ path (quote_generation parks - // the opportunity at `proposal`; an accepted quote wins it without a - // separate negotiation step). - proposal: ["negotiation", "closed_won", "closed_lost"], - negotiation: ["closed_won", "closed_lost"], - closed_won: [], - closed_lost: [] - } - } - ] - // ⚠️ `probability` and `expected_revenue` are NOT computed declaratively. - // They are derived in `opportunity.hook.ts` (single source of truth = - // stage → STAGE_PROBABILITY); keeping the math in one place avoids drift - // between a declarative CASE() table and the hook's lookup table. - // - // ⚠️ No `workflows[]` here, and none is possible: object `workflows[]` were - // removed from the platform. Field updates live in this object's `*.hook.ts`; - // scheduled status flips and notifications live in `src/*/flows/*.flow.ts`. -}); - -// src/sales/objects/task.object.ts -import { ObjectSchema as ObjectSchema11, Field as Field11 } from "@objectstack/spec/data"; -import { P as P8 } from "@objectstack/spec"; -var Task = ObjectSchema11.create({ - name: "crm_task", - label: "Task", - pluralLabel: "Tasks", - icon: "check-square", - description: "Activities and to-do items", - // ADR-0090 D1/D7: OWD is an authored decision. Personal activity records. - sharingModel: "private", - // Every other business object with a detail page groups its fields; task was - // one of the two that did not, so its detail page fell back to one flat grid - // where the five polymorphic `related_to_*` lookups and the recurrence - // machinery sat inline with the subject. The keys mirror the sections the - // task form already uses (Task / Related Records / Recurrence & Effort) so - // the two surfaces agree. - fieldGroups: [ - { key: "basic", label: "Task Information", icon: "info" }, - { key: "scheduling", label: "Scheduling", icon: "calendar" }, - // No 'assignment' group: the assignee (`owner_id`) was its only member, and - // the synthesized detail page hoists it into the highlight strip — so the - // group rendered on forms and never on detail pages - // (`field-group-shadowed`). It lives in `basic` alongside - // subject/status/priority instead. - { key: "related", label: "Related Records", icon: "link" }, - { key: "recurrence", label: "Recurrence", icon: "refresh-ccw", collapse: "collapsed" }, - { key: "effort", label: "Progress & Effort", icon: "activity", collapse: "collapsed" }, - { key: "system", label: "System", icon: "database", collapse: "collapsed" } - ], - fields: { - // Platform ownership anchor — canonical note in `account.object.ts` (#548). - owner_id: Field11.lookup("sys_user", { - label: "Assigned To", - group: "basic", - system: true, - readonly: false, - trackHistory: true - }), - // Task Information - subject: Field11.text({ - group: "basic", - label: "Subject", - required: true, - storage: { notNull: true }, - searchable: true, - maxLength: 255 - }), - description: Field11.markdown({ - group: "basic", - label: "Description" - }), - // Task Management - status: Field11.select({ - group: "basic", - label: "Status", - required: true, - storage: { notNull: true }, - trackHistory: true, - // Field-level default, not just the option flag: the option `default` - // only preselects in some form surfaces, so a quick-create modal opened - // from a related list left this required field blank and the rep had to - // pick "Not Started" by hand every time. - defaultValue: "not_started", - options: [ - { label: "Not Started", value: "not_started", color: "#808080", default: true }, - { label: "In Progress", value: "in_progress", color: "#FFA500" }, - { label: "Waiting", value: "waiting", color: "#FFD700" }, - { label: "Completed", value: "completed", color: "#00AA00" }, - { label: "Deferred", value: "deferred", color: "#999999" } - ] - }), - priority: Field11.select({ - group: "basic", - label: "Priority", - required: true, - storage: { notNull: true }, - trackHistory: true, - // `normal` is the default rather than `low`: a rep filing a to-do has - // made no priority judgement, and defaulting everything to Low made the - // field meaningless (nothing ever sorted above the noise). - defaultValue: "normal", - options: [ - { label: "Low", value: "low", color: "#4169E1" }, - { label: "Normal", value: "normal", color: "#00AA00", default: true }, - { label: "High", value: "high", color: "#FFA500" }, - { label: "Urgent", value: "urgent", color: "#FF0000" } - ] - }), - // Sortable ordinal for `priority` — see crm_case.priority_rank. Sorting on - // the select itself compares raw strings (normal > low > high > urgent), - // which pushes urgent work to the bottom of the to-do queue. - // - // `0` is the UNRANKED sentinel, identical to crm_case.priority_rank. ⛔ It - // must stay identical on both: a differing sentinel orders the same unknown - // priority differently on the two objects, and `2` here would make an - // unranked task indistinguishable from a genuine `normal`. - priority_rank: Field11.number({ - label: "Priority Rank", - readonly: true, - defaultValue: 0 - }), - type: Field11.select({ - group: "basic", - label: "Task Type", - // Canonical set (#490) — the schedule_followup screen renders the same - // list; see _picklists.ts. - options: [...TASK_TYPE_OPTIONS] - }), - // Dates - due_date: Field11.date({ - group: "scheduling", - label: "Due Date" - }), - reminder_date: Field11.datetime({ - group: "scheduling", - label: "Reminder Date/Time" - }), - completed_date: Field11.datetime({ - group: "scheduling", - label: "Completed Date", - readonly: true - }), - // Related To (Polymorphic relationship - can link to multiple object types) - related_to_type: Field11.select({ - group: "related", - label: "Related To Type", - options: [ - { label: "Account", value: "crm_account" }, - { label: "Contact", value: "crm_contact" }, - { label: "Opportunity", value: "crm_opportunity" }, - { label: "Lead", value: "crm_lead" }, - { label: "Case", value: "crm_case" } - ] - }), - related_to_account: Field11.lookup("crm_account", { - group: "related", - label: "Related Account" - }), - related_to_contact: Field11.lookup("crm_contact", { - group: "related", - label: "Related Contact" - }), - related_to_opportunity: Field11.lookup("crm_opportunity", { - group: "related", - label: "Related Opportunity" - }), - related_to_lead: Field11.lookup("crm_lead", { - group: "related", - label: "Related Lead" - }), - related_to_case: Field11.lookup("crm_case", { - group: "related", - label: "Related Case" - }), - // Recurrence (for recurring tasks) - is_recurring: Field11.boolean({ - group: "recurrence", - label: "Recurring Task", - defaultValue: false - }), - recurrence_type: Field11.select({ - group: "recurrence", - label: "Recurrence Type", - options: [ - { label: "Daily", value: "daily" }, - { label: "Weekly", value: "weekly" }, - { label: "Monthly", value: "monthly" }, - { label: "Yearly", value: "yearly" } - ] - }), - recurrence_interval: Field11.number({ - group: "recurrence", - label: "Recurrence Interval", - defaultValue: 1, - min: 1 - }), - recurrence_end_date: Field11.date({ - group: "recurrence", - label: "Recurrence End Date" - }), - // Flags - is_completed: Field11.boolean({ - group: "system", - label: "Is Completed", - defaultValue: false, - readonly: true - }), - is_overdue: Field11.boolean({ - group: "system", - label: "Is Overdue", - defaultValue: false, - readonly: true - }), - // Set by the `task_due_reminder` schedule flow once a reminder has fired - // (the sweep de-dups on `reminder_date`, which it clears; this flag is the - // audit trail), and defaulted to `false` by `task.hook.ts` on insert. - // - // NOT readonly — but the old reason here ("16.x drops flow writes to - // readonly fields") does not survive measurement. Taken on 17.1.0, - // RE-TAKEN on 17.2.0 (#1460) and RE-CONFIRMED on 17.3.0 (#1676) — the pin - // at each of those takings; not re-taken on 17.4.0 (PR #1814, #1807) or - // 17.5.0 — same verdict all three times: `task_due_reminder` - // declares `runAs: 'system'`, so its write WOULD survive a - // `readonly: true`. - // - // ⚠️ The other half of that reason EXPIRED at 17.4.0 and is ⛔ NOT - // renumbered here: "the insert path is exempt from the strip" held through - // 17.3.0 and was reversed as a declared BREAKING change — the retirement - // is recorded in the INSERT-path section of - // `test/readonly-write-semantics.test.ts` (#1429) and in - // `campaign_member.object.ts`. Neither half moves this field, which is not - // `readonly` at all. Left writable as-is; flipping it is a separate - // decision, not a comment fix. - reminder_sent: Field11.boolean({ - group: "system", - label: "Reminder Sent", - defaultValue: false - }), - // Progress - progress_percent: Field11.percent({ - group: "effort", - label: "Progress (%)", - min: 0, - max: 100, - defaultValue: 0 - }) - // No time tracking. `estimated_hours` / `actual_hours` were declared and - // inert: no rollup summed them onto a case or an opportunity, no variance - // report compared them, and nothing warned when actual overran estimate. - // Effort on a task is `progress_percent`, which the task views do read. - }, - // API surface. History → Field.trackHistory (ADR-0052). - enable: { - apiEnabled: true - }, - // Database indexes for performance - indexes: [ - { fields: ["status"] }, - { fields: ["priority"] }, - { fields: ["owner_id"] }, - { fields: ["due_date"] } - ], - // ADR-0079: render-only `titleFormat` retired in favor of `nameField`, - // which names the real field holding the record title (here: `subject`). - nameField: "subject", - highlightFields: ["subject", "status", "priority", "due_date", "owner_id"], - // Removed: list_views and form_views belong in UI configuration, not object definition - // Predicates below are TOTAL: every `record.x` read is `has()`-guarded, so the - // rule returns a verdict even when the merged record has no such key. See - // AGENTS.md "Validation predicates must be TOTAL" and - // test/object-validation-predicates.test.ts, which fails the build otherwise. - validations: [ - { - name: "completed_date_required", - type: "script", - severity: "error", - message: "Completed date is required when status is Completed", - condition: P8`has(record.status) && record.status == "completed" && (!has(record.completed_date) || isBlank(record.completed_date))` - }, - { - name: "recurrence_fields_required", - type: "script", - severity: "error", - message: "Recurrence type is required for recurring tasks", - condition: P8`has(record.is_recurring) && record.is_recurring == true && (!has(record.recurrence_type) || isBlank(record.recurrence_type))` - }, - { - name: "related_to_required", - type: "script", - severity: "warning", - message: "At least one related record should be selected", - condition: P8`(!has(record.related_to_account) || isBlank(record.related_to_account)) && (!has(record.related_to_contact) || isBlank(record.related_to_contact)) && (!has(record.related_to_opportunity) || isBlank(record.related_to_opportunity)) && (!has(record.related_to_lead) || isBlank(record.related_to_lead)) && (!has(record.related_to_case) || isBlank(record.related_to_case))` - } - ] - // ⚠️ No `workflows[]` here, and none is possible: object `workflows[]` were - // removed from the platform. Field updates live in this object's `*.hook.ts`; - // scheduled status flips and notifications live in `src/*/flows/*.flow.ts`. -}); - -// src/sales/actions/activity-actions.ts -var nameFieldMap = (objectDefs) => Object.fromEntries( - Object.values(objectDefs).filter( - (o) => typeof o?.name === "string" && typeof o?.nameField === "string" - ).map((o) => [o.name, o.nameField]) -); -var ACTIVITY_TARGETS = { - crm_lead: "related_to_lead", - crm_contact: "related_to_contact", - crm_account: "related_to_account", - crm_opportunity: "related_to_opportunity", - crm_case: "related_to_case" -}; -var lit = (value) => JSON.stringify(value); -var ACTOR_NAME_RESOLUTION_SOURCE = `// The acting user's DISPLAY name, for the sys_activity row (#673 / #678). - // - // PLATFORM WORKAROUND. \`ctx.user.name\` is not a display name on the - // dispatch path the Console uses: the REST action dispatcher builds the - // body's user as \`{ id: ec.userId, name: ec.userId, \u2026 }\` \u2014 the key is - // present and carries the raw id, so \`ctx.user?.name\` reads as a - // plausible string and silently wrote ids like - // "grDEyLoIgnunJ2M7Y2muLgcuQbDUT0s2" into \`sys_activity.actor_name\` - // (@objectstack/runtime 17.0.0-rc.2, dist/index.js:5397-5399). The MCP - // dispatcher does try a display name first - // (\`ec.userName ?? ec.userDisplayName ?? ec.userId\`, dist/index.js:1776) - // but nothing in the installed platform ever populates either field, so - // it falls back to the id too. - // - // So the name is resolved HERE, from \`sys_user.name\` (the column the - // platform itself treats as the profile display name), with the id kept - // as the last resort \u2014 an opaque id is bad, a blank actor is worse. - // A name that differs from the id is taken as already-resolved, which is - // what makes this one query and not a query per activity write. - // - // DELETE THIS once the platform delivers a display name on ctx.user.name - // for REST-dispatched action bodies: every splice site collapses back to - // \`actor_name: ctx.user?.name\` (objectstack-ai/objectstack#5372). - const ctxName = ctx.user?.name ? String(ctx.user.name).trim() : ''; - let actorName = ctxName && ctxName !== userId ? ctxName : ''; - if (!actorName && userId) { - try { - const found = await ctx.api.object('sys_user').find({ - where: { id: userId }, - fields: ['name'], - top: 1, - }); - const users = Array.isArray(found) ? found : (found?.records ?? []); - const resolved = users.length && users[0].name ? String(users[0].name).trim() : ''; - if (resolved) actorName = resolved; - } catch (e) { - // A denied or unavailable sys_user read must not fail the log \u2014 the - // interaction the rep just recorded matters more than its label. - } - } - if (!actorName) actorName = userId;`; -function activityAction(spec, objectName, nameField) { - const relatedField = ACTIVITY_TARGETS[objectName]; - if (!relatedField) { - throw new Error( - `activityAction: '${objectName}' is not an activity target \u2014 extend ACTIVITY_TARGETS together with crm_event.related_to_type and its related_to_* lookup.` - ); - } - return { - name: spec.name, - label: spec.label, - // Object-scoped, one registration per object. The runtime registers a body - // action under `:` and the dispatcher probes - // `` then `*`; a body action with no objectName lands under a - // 'global' key nothing ever probes ("Action 'log_call' on object '*' not - // found", verified 2026-07-28). ⛔ Never author an object-less body action. - objectName, - icon: spec.icon, - // script, not modal: modal submits die on GET /api/v1/meta/object/ - // → 400 in 16.1.0; script actions POST /api/v1/actions/... and execute. - type: "script", - body: { - language: "js", - source: ` - const OBJECT_NAME = ${lit(objectName)}; - const RELATED_FIELD = ${lit(relatedField)}; - const NAME_FIELD = ${lit(nameField)}; - const EVENT_TYPE = ${lit(spec.eventType)}; - const EVENT_STATUS = ${lit(spec.eventStatus)}; - - const record = ctx.record ?? {}; - const recordId = ctx.recordId ?? record.id ?? null; - const userId = ctx.user?.id ?? null; - const nowIso = new Date().toISOString(); - - ${ACTOR_NAME_RESOLUTION_SOURCE} - - const subject = input.subject ? String(input.subject) : ${lit(spec.defaultSubject)}; - const duration = input.duration ? Number(input.duration) : 0; - const notes = input.notes ? String(input.notes) : ''; - const location = input.location ? String(input.location) : ''; - - // A booking states its own start; a log is "just now". - // - // WORKAROUND for objectstack-ai/objectstack#5061 \u2014 the start is collected - // as a CALENDAR DAY + a WALL CLOCK (\`start_date\` / \`start_time\`) and - // joined here, instead of as one \`type: 'datetime'\` param. A datetime - // param is unusable from the Console: it renders as a zone-less - // \`\` and POSTs the raw value - // ("2026-08-10T15:00"), which the runtime's action-param validator rejects - // with 400 "expected an ISO-8601 instant with explicit zone" \u2014 no user - // input can pass. \`date\` and \`time\` are the two param types whose - // renderer output ("YYYY-MM-DD" / "HH:MM") the validator accepts verbatim, - // so the pair is submittable where the single datetime never was. - // - // TIMEZONE: the wall clock is interpreted as **UTC**, and both param - // labels say so. UTC is the only zone this body can apply deterministically - // \u2014 the sandbox context carries no user or org timezone (\`ctx.user\` is - // id/name/email), and reading the server's local zone would make the same - // input mean different instants on different hosts and in tests. Everything - // else this app writes is likewise a UTC instant (\`new Date().toISOString()\`). - // - // When #5061 lands (the Console serializing datetime-local in the - // browser's zone), this reverts to ONE \`type: 'datetime'\` param and the - // zone becomes the user's own \u2014 see \`collectsSchedule\` in this file. - let startIso = nowIso; - const startDate = input.start_date ? String(input.start_date).trim() : ''; - if (startDate) { - const startTime = input.start_time ? String(input.start_time).trim() : '00:00'; - // 'HH:MM' and 'HH:MM:SS' are both shapes the validator lets through. - const clock = startTime.length === 5 ? startTime + ':00' : startTime; - const parsed = new Date(startDate + 'T' + clock + '.000Z'); - // An unparseable value falls back to now rather than writing NaN into a - // required column. - if (!isNaN(parsed.getTime())) startIso = parsed.toISOString(); - } - - // 1. the interaction itself, as a queryable record. - const eventDoc = { - subject: subject, - type: EVENT_TYPE, - status: EVENT_STATUS, - start_datetime: startIso, - // Load-bearing, not decoration: an action body executes with - // isSystem: true (runtime buildActionExecutionContext), which - // short-circuits the security middleware \u2014 so the insert-time - // auto-stamp of owner_id never fires here. Omitting it would land the - // interaction ownerless, i.e. invisible in "My \u2026" and uneditable under - // a private OWD (#548, the #622 failure mode). - owner_id: userId, - related_to_type: OBJECT_NAME, - }; - if (duration > 0) eventDoc.duration_minutes = duration; - if (location) eventDoc.location = location; - if (notes) eventDoc.description = notes; - if (recordId) eventDoc[RELATED_FIELD] = recordId; - const event = await ctx.api.object('crm_event').insert(eventDoc); - const eventId = event?.id ?? null; - - // 2. attendees, as rows \u2014 the point of #592. - // A multi-lookup param may arrive as an array or, on a surface that - // renders it single-valued, as one scalar. Normalising both is not a - // lenient parse of authored metadata: it is the console's own input - // shape, which this body does not control. - const toList = (v) => { - if (v === null || v === undefined || v === '') return []; - return Array.isArray(v) ? v : [v]; - }; - const attendees = []; - if (userId) { - attendees.push({ attendee_type: 'user', sys_user: userId, is_organizer: true, response: 'accepted' }); - } - // The record the action was fired from IS an attendee when it is a - // person. On an account / opportunity / case it is not, so nothing is - // invented for it \u2014 the event's related_to_* link already records it. - if (OBJECT_NAME === 'crm_contact' && recordId) { - attendees.push({ attendee_type: 'contact', crm_contact: recordId, response: 'no_response' }); - } - if (OBJECT_NAME === 'crm_lead' && recordId) { - attendees.push({ attendee_type: 'lead', crm_lead: recordId, response: 'no_response' }); - } - for (const c of toList(input.attendee_contacts)) { - attendees.push({ attendee_type: 'contact', crm_contact: String(c), response: 'no_response' }); - } - for (const u of toList(input.attendee_users)) { - attendees.push({ attendee_type: 'user', sys_user: String(u), response: 'no_response' }); - } - - const seen = {}; - const attendeeIds = []; - for (const a of attendees) { - const who = a.sys_user ?? a.crm_contact ?? a.crm_lead ?? ''; - const key = a.attendee_type + ':' + who; - if (seen[key]) continue; - seen[key] = true; - const doc = Object.assign({}, a, { crm_event: eventId, invited_date: nowIso }); - const row = await ctx.api.object('crm_event_attendee').insert(doc); - if (row?.id) attendeeIds.push(row.id); - } - - // 3. the unified-timeline pointer. - // \`metadata\` no longer carries the attendee list: it is a display hint - // beside a real record now, not the record itself. ADR-0052 - // source_object/source_id is the queryable drill to the crm_event row. - const summary = duration ? subject + ' (' + duration + ' min)' : subject; - const activity = await ctx.api.object('sys_activity').insert({ - type: EVENT_STATUS === 'held' ? 'completed' : 'scheduled', - summary: ${lit(spec.summaryPrefix)} + summary, - actor_id: userId, - actor_name: actorName, - object_name: OBJECT_NAME, - record_id: recordId, - // #514 item 2: the object's DECLARED nameField, not a hardcoded name. - record_label: record[NAME_FIELD] ?? null, - source_object: 'crm_event', - source_id: eventId, - metadata: JSON.stringify({ - kind: EVENT_TYPE, - duration_minutes: duration, - notes: notes, - attendee_count: attendeeIds.length, - }), - }); - - // 4. SLA first-response stamp \u2014 NOT here. #575 B2 originally stamped - // \`crm_case.first_response_date\` from this body, which meant the metric - // was only ever written when the interaction was recorded through the two - // buttons this factory builds; an event created any other way left it - // null, under a comment asking every future author to remember. #595 - // moved the stamp to \`event_activity_bubble\` in - // \`src/sales/objects/event.hook.ts\`, which already fires on exactly the - // condition that matters ("a held event, on its transition into held") - // and already resolves \`related_to_case\`. Step 1 above writes that - // event, so this action still stamps the case \u2014 through one writer - // instead of a convention. Do not reintroduce a copy here: two writers - // racing on a "first" timestamp is how it becomes a "last" one. - - return { eventId: eventId, activityId: activity?.id ?? null, attendeeIds: attendeeIds }; - `, - capabilities: ["api.read", "api.write"], - timeoutMs: 5e3 - }, - locations: ["record_header", "list_item", "record_related"], - params: [ - { - name: "subject", - label: spec.subjectLabel, - type: "text", - required: true - }, - // WORKAROUND objectstack-ai/objectstack#5061 — one `type: 'datetime'` - // param ("Starts At") is what this WANTS to be, and it is unusable: the - // Console renders it as a zone-less `` and - // POSTs the raw value, which the action-param validator rejects with a - // 400 (`expected an ISO-8601 instant with explicit zone`). The renderer's - // output shape and the validator's accepted shape do not intersect, so - // NO user input can submit the action — reproduced from both the list-row - // menu and the record header. - // - // `date` and `time` are the two param types where they DO intersect: the - // Console renders native `` / `` - // pickers (`ui-components` DateField / TimeField, both emitting - // `e.target.value` verbatim) and the validator's `CalendarDateValueSchema` - // /`ClockTimeValueSchema` accept exactly `YYYY-MM-DD` and `HH:MM`. Two - // native pickers are also better UX than one free-text box, which is the - // other shape that would have submitted. - // - // The zone is stated in the LABELS, not in `helpText`: the Console's - // action-param form forwards only name/label/type/required/placeholder/ - // options/multiple/accept/maxSize to the field widget, so a `helpText` - // here would never reach the user. - // - // REVERT WHEN #5061 LANDS: back to - // { name: 'start', label: 'Starts At', type: 'datetime', required: true } - // and drop the join in the body above. - ...spec.collectsSchedule ? [ - { name: "start_date", label: "Start Date (UTC)", type: "date", required: true }, - { name: "start_time", label: "Start Time (UTC)", type: "time", required: true }, - { name: "location", label: "Location", type: "text", required: false } - ] : [], - { - name: "duration", - label: "Duration (minutes)", - type: "number", - required: false - }, - // Two typed lookups, not one free-text box: the platform has no - // polymorphic picker, and typed lookups produce queryable rows where a - // text box produces a comma-separated sentence nothing can filter on. - { - name: "attendee_contacts", - label: "Contact Attendees", - type: "lookup", - reference: "crm_contact", - multiple: true, - required: false - }, - { - name: "attendee_users", - label: "Internal Attendees", - type: "lookup", - reference: "sys_user", - multiple: true, - required: false - }, - { - name: "notes", - label: spec.notesLabel, - type: "textarea", - required: false - } - ], - successMessage: spec.successMessage, - refreshAfter: true - }; -} -var LOG_CALL_SPEC = { - name: "log_call", - label: "Log a Call", - icon: "phone", - eventType: "call", - eventStatus: "held", - summaryPrefix: "", - defaultSubject: "Untitled Call", - subjectLabel: "Call Subject", - notesLabel: "Call Notes", - successMessage: "Call logged successfully!" -}; -var LOG_MEETING_SPEC = { - name: "log_meeting", - label: "Log a Meeting", - icon: "calendar-check", - eventType: "meeting", - eventStatus: "held", - summaryPrefix: "Meeting: ", - defaultSubject: "Untitled Meeting", - subjectLabel: "Meeting Subject", - notesLabel: "Meeting Notes", - successMessage: "Meeting logged successfully!" -}; -var SCHEDULE_MEETING_SPEC = { - name: "schedule_meeting", - label: "Schedule a Meeting", - icon: "calendar-plus", - eventType: "meeting", - // `planned`, and that is the whole difference that matters: a booking must - // NOT reset the customer's recency clock (see event.hook.ts). - eventStatus: "planned", - summaryPrefix: "Meeting scheduled: ", - defaultSubject: "Untitled Meeting", - subjectLabel: "Meeting Subject", - notesLabel: "Agenda", - collectsSchedule: true, - successMessage: "Meeting scheduled!" -}; -var ACTIVITY_SPECS = [LOG_CALL_SPEC, LOG_MEETING_SPEC, SCHEDULE_MEETING_SPEC]; -var activityActionsFor = (objectName, objectDefs) => { - const nameField = nameFieldMap(objectDefs)[objectName] ?? "name"; - const built = ACTIVITY_SPECS.map((spec) => activityAction(spec, objectName, nameField)); - return Object.fromEntries(built.map((a) => [a.name, a])); -}; -var leadActivityActions = activityActionsFor("crm_lead", objects_exports2); -var contactActivityActions = activityActionsFor("crm_contact", objects_exports2); -var accountActivityActions = activityActionsFor("crm_account", objects_exports2); -var opportunityActivityActions = activityActionsFor("crm_opportunity", objects_exports2); -var LeadLogCallAction = leadActivityActions.log_call; -var LeadLogMeetingAction = leadActivityActions.log_meeting; -var LeadScheduleMeetingAction = leadActivityActions.schedule_meeting; -var ContactLogCallAction = contactActivityActions.log_call; -var ContactLogMeetingAction = contactActivityActions.log_meeting; -var ContactScheduleMeetingAction = contactActivityActions.schedule_meeting; -var AccountLogCallAction = accountActivityActions.log_call; -var AccountLogMeetingAction = accountActivityActions.log_meeting; -var AccountScheduleMeetingAction = accountActivityActions.schedule_meeting; -var OpportunityLogCallAction = opportunityActivityActions.log_call; -var OpportunityLogMeetingAction = opportunityActivityActions.log_meeting; -var OpportunityScheduleMeetingAction = opportunityActivityActions.schedule_meeting; - -// src/service/actions/case-activity.actions.ts -var caseActivityActions = activityActionsFor("crm_case", objects_exports); -var LogCallAction = caseActivityActions.log_call; -var LogMeetingAction = caseActivityActions.log_meeting; -var CaseScheduleMeetingAction = caseActivityActions.schedule_meeting; - -// src/service/actions/knowledge_article.actions.ts -import { P as P9 } from "@objectstack/spec"; -var feedbackBody = (verdict) => ` - const id = ctx.recordId; - if (!id) throw new Error('submit_article_feedback requires a recordId'); - const userId = ctx.user?.id ?? null; - if (!userId) throw new Error('Sign in to rate an article.'); - - // One row per (article, reader) \u2014 the unique index says so, and this - // read is what keeps a mind-change an UPDATE instead of a duplicate. - const existing = await ctx.api.object('crm_article_feedback').findOne({ - where: { crm_knowledge_article: id, owner_id: userId }, - }); - - if (existing && existing.id) { - if (existing.verdict === '${verdict}') { - return { ok: true, id: existing.id, verdict: '${verdict}', changed: false }; - } - await ctx.api.object('crm_article_feedback').update( - { id: existing.id, verdict: '${verdict}' }, - { where: { id: existing.id } }, - ); - return { ok: true, id: existing.id, verdict: '${verdict}', changed: true }; - } - - const inserted = await ctx.api.object('crm_article_feedback').insert({ - crm_knowledge_article: id, - verdict: '${verdict}', - owner_id: userId, - }); - return { ok: true, id: inserted?.id ?? null, verdict: '${verdict}', changed: true }; - `; -var publishedOnly = P9`has(record.status) && record.status == "published"`; -var MarkArticleHelpfulAction = { - name: "mark_article_helpful", - label: "Helpful", - objectName: "crm_knowledge_article", - icon: "thumbs-up", - type: "script", - body: { - language: "js", - source: feedbackBody("helpful"), - capabilities: ["api.read", "api.write"], - timeoutMs: 5e3 - }, - locations: ["record_header"], - visible: publishedOnly, - successMessage: "Thanks \u2014 recorded as helpful.", - refreshAfter: true -}; -var MarkArticleNotHelpfulAction = { - name: "mark_article_not_helpful", - label: "Not Helpful", - objectName: "crm_knowledge_article", - icon: "thumbs-down", - type: "script", - body: { - language: "js", - source: feedbackBody("not_helpful"), - capabilities: ["api.read", "api.write"], - timeoutMs: 5e3 - }, - locations: ["record_header"], - visible: publishedOnly, - successMessage: "Thanks \u2014 recorded as not helpful.", - refreshAfter: true -}; - -// src/service/dashboards/service.dashboard.ts -var dataset = "case_metrics"; -var ServiceDashboard = { - name: "service_dashboard", - label: "Customer Service", - description: "Case load, SLA health, and resolution performance", - columns: 12, - gap: 4, - refreshIntervalSeconds: 60, - // 1 minute — service desks need fresh numbers - header: { - showTitle: true, - showDescription: true - // Header action buttons removed: `create_case` is not a defined action and - // `/objects/case?owner=current_user` / `/reports/sla` are not in-app view - // routes — all three were dead. Re-add real, wired-up actions here when available. - }, - // Historical note (#460 → #1157): this dashboard shipped without a date - // picker from PR #546 until the 17.0.0 GA upgrade, because windowing a - // `Field.datetime()` could not be compared — `driver-sql` 16.1.0 coerced - // datetime bounds to epoch-ms INTEGER while every datetime in the database is - // ISO TEXT, so `$gte` matched everything and `$lte` matched nothing and the - // whole dashboard read zeros. Both named preconditions are fixed and - // released: objectstack#3912 (the coercion) and objectstack#3777 (a bare-date - // `$lte` dropping same-day rows). The window below is not restored on the - // strength of those closures alone — `test/dashboard-date-range-window.test.ts` - // executes it against a real SQLite database and compares every widget to a - // ground truth computed in the same run, so a re-regression fails CI here - // rather than being discovered as an all-zero dashboard again. - // - // The range windows `created_at`, the platform's creation stamp (#1992). It - // used to window `created_date`, which nothing wrote on a real case, so - // every case created through the UI or REST fell outside every range. - dateRange: { field: "created_at", defaultRange: "last_90_days", allowCustomRange: true }, - globalFilters: [ - { - field: "owner_id", - label: { en: "Agent", "zh-CN": "\u8D1F\u8D23\u4EBA", "es-ES": "Propietario del Caso", "ja-JP": "\u30B1\u30FC\u30B9\u62C5\u5F53\u8005" }, - type: "lookup", - scope: "dashboard", - optionsFrom: { object: "sys_user", valueField: "id", labelField: "name" } - }, - { - field: "priority", - label: { en: "Priority", "zh-CN": "\u4F18\u5148\u7EA7", "es-ES": "Prioridad", "ja-JP": "\u512A\u5148\u5EA6" }, - type: "select", - scope: "dashboard", - options: [ - // zh-CN `critical` is 严重, never 紧急 — 紧急 belongs to crm_task.priority.urgent - // and the two vocabularies are distinct sets (ruling #1342). Same wording as - // `objects.crm_case.fields.priority.options` in every locale pack. - { value: "critical", label: { en: "Critical", "zh-CN": "\u4E25\u91CD", "es-ES": "Cr\xEDtica", "ja-JP": "\u91CD\u5927" } }, - { value: "high", label: { en: "High", "zh-CN": "\u9AD8", "es-ES": "Alta", "ja-JP": "\u9AD8" } }, - { value: "medium", label: { en: "Medium", "zh-CN": "\u4E2D", "es-ES": "Media", "ja-JP": "\u4E2D" } }, - { value: "low", label: { en: "Low", "zh-CN": "\u4F4E", "es-ES": "Baja", "ja-JP": "\u4F4E" } } - ] - } - ], - widgets: [ - // ─── Row 1: Case-Load KPIs ──────────────────────────────────────── - { - id: "open_cases", - title: "Open Cases", - description: "Cases that are not yet closed", - type: "metric", - filter: { is_closed: false }, - colorVariant: "orange", - dataset, - values: ["case_count"], - layout: { x: 0, y: 0, w: 3, h: 2 } - }, - { - id: "critical_cases", - title: "Critical Cases", - description: "Open cases marked as critical priority", - type: "metric", - filter: { priority: "critical", is_closed: false }, - colorVariant: "danger", - dataset, - values: ["case_count"], - layout: { x: 3, y: 0, w: 3, h: 2 } - }, - { - id: "avg_resolution_time", - title: "Avg Resolution Time", - description: "Mean time to close, in hours", - type: "metric", - filter: { is_closed: true }, - colorVariant: "blue", - dataset, - values: ["avg_resolution"], - layout: { x: 6, y: 0, w: 3, h: 2 } - }, - { - id: "sla_violations", - title: "SLA Violations", - description: "Cases that breached their SLA", - type: "metric", - // Counted at READ time (#2070): a case already flagged, OR a case still - // open whose deadline has passed. The second branch is the selection - // `case_sla_monitor` sweeps — same status set, same strict `$lt` at the - // current instant (`{now}` is that instant in a query filter; `{NOW()}` - // in a flow template) — so the tile reads true on a deployment that runs - // no scheduled work, where nothing flags an open breach. It counts; it - // does not act: escalation and the owner's alert still need the sweep. - // `test/case-sla-breach-on-close.test.ts` pins the two to one selection. - filter: { - $or: [ - { is_sla_violated: true }, - { status: { $nin: ["resolved", "closed"] }, sla_due_date: { $lt: "{now}" } } - ] - }, - colorVariant: "warning", - dataset, - values: ["case_count"], - layout: { x: 9, y: 0, w: 3, h: 2 } - }, - // ─── Row 2: Distribution ────────────────────────────────────────── - { - id: "cases_by_status", - title: "Cases by Status", - description: "Workload distribution across the pipeline", - type: "donut", - filter: { is_closed: false }, - colorVariant: "blue", - dataset, - dimensions: ["status"], - values: ["case_count"], - layout: { x: 0, y: 2, w: 4, h: 4 }, - chartConfig: { - showLegend: true, - showDataLabels: true, - colors: ["#0EA5E9", "#06B6D4", "#14B8A6", "#10B981", "#F59E0B"] - } - }, - { - id: "cases_by_priority", - title: "Cases by Priority", - description: "Open case mix by urgency", - type: "pie", - filter: { is_closed: false }, - colorVariant: "warning", - dataset, - dimensions: ["priority"], - values: ["case_count"], - layout: { x: 4, y: 2, w: 4, h: 4 }, - chartConfig: { - showLegend: true, - showDataLabels: true, - // critical → high → medium → low - colors: ["#DC2626", "#F97316", "#F59E0B", "#10B981"] - } - }, - { - id: "cases_by_origin", - title: "Cases by Origin", - description: "Where our cases are coming from", - type: "bar", - colorVariant: "purple", - dataset, - dimensions: ["origin"], - values: ["case_count"], - layout: { x: 8, y: 2, w: 4, h: 4 }, - chartConfig: { - showLegend: false, - showDataLabels: true, - colors: ["#8B5CF6"] - } - }, - // ─── Row 3: Volume & SLA Trends ─────────────────────────────────── - { - id: "daily_case_volume", - title: "Daily Case Volume", - description: "New cases created over the last 30 days", - type: "area", - filter: { created_at: { $gte: "{30_days_ago}" } }, - // Opted out ON PURPOSE, re-decided in #1157 rather than inherited. - // - // The floor above is no longer inert: on 17.0.0 `{30_days_ago}` resolves - // to a start-of-day bound the driver compares correctly (measured, with a - // ground truth, in `test/dashboard-date-range-window.test.ts`), so this - // chart really does plot the last 30 days and its title is true again. - // That is exactly why it must not follow the picker: the dashboard range - // is ANDed into every bound widget, so a reader who selects "last 7 days" - // would get a 7-day chart still labelled "last 30 days". Self-described - // windows opt out — the same rule the Executive dashboard's YTD tile - // follows, pinned by `test/action-references.test.ts`. Binding it instead - // would mean dropping this filter and retitling the widget in all four - // locale bundles; the fixed 30-day volume trend beside a 90-day case load - // is the intended reading. - filterBindings: { dateRange: false }, - colorVariant: "blue", - dataset, - dimensions: ["created_at"], - values: ["case_count"], - layout: { x: 0, y: 6, w: 8, h: 4 }, - chartConfig: { - showLegend: false, - showDataLabels: false, - colors: ["#0EA5E9"], - interaction: { tooltips: true, brush: true } - }, - options: { dateGranularity: "day" } - }, - { - id: "sla_compliance_gauge", - title: "SLA Compliance", - description: "Percent of cases resolved within SLA this period", - type: "gauge", - filter: { is_closed: true }, - colorVariant: "success", - // Plots COMPLIANCE, the quantity the title, the description, the - // success colouring and the 0.95 target line all name (#1213). It used - // to plot `avg_sla_violated` — the complement — with `options.invert` - // asking the renderer to flip it. `invert` is not a declared key on - // `DashboardWidgetOptionsSchema`; it rode the `.passthrough()`, nothing - // could report it inert, and the gauge read 0.0% on an org with 100% - // compliance. The key is gone rather than left pretending: a measure - // that means what the widget says is the fix, and the measure's own - // label prints under the number, so the two cannot drift apart again. - dataset, - values: ["sla_compliance_rate"], - layout: { x: 8, y: 6, w: 4, h: 4 }, - chartConfig: { - showLegend: false, - showDataLabels: true, - colors: ["#10B981", "#F59E0B", "#EF4444"], - annotations: [ - { type: "line", axis: "y", value: 0.95, label: "Target", style: "dashed", color: "#10B981" } - ] - } - // The target line was written for COMPLIANCE and is unchanged: it was - // always right — it was the plotted value that disagreed with it. (The - // green/amber/red `options.thresholds` ladder beside it was deleted in - // 17.6.0's strict cleanup: no dashboard renderer reads widget - // `thresholds`, so it never coloured anything.) - }, - // ─── Row 4: Knowledge deflection (#601) ─────────────────────────── - // - // The deflection metric the card asks the service dashboard to show, and - // the reason it is THREE tiles rather than one: a ratio widget on its own - // is unreadable — 100% could be "40 of 40" or "1 of 1", and a blank rate - // could be "no closed cases" or "no KB resolutions" (measured: a filtered - // measure contributes NO row for a group it selects nothing in, so the - // rate comes back absent, not 0). Numerator and denominator therefore ship - // beside the percentage, the same rule the sales dashboard's win rate - // follows after #614. - { - id: "kb_deflection_rate", - title: "KB Deflection Rate", - description: "Share of closed cases resolved with a knowledge article", - type: "metric", - colorVariant: "success", - dataset, - values: ["kb_deflection_rate"], - layout: { x: 0, y: 10, w: 4, h: 2 } - }, - { - id: "kb_resolved_cases", - title: "Resolved by KB", - description: "Closed cases pointing at the article that resolved them", - type: "metric", - colorVariant: "blue", - dataset, - values: ["kb_resolved_count"], - layout: { x: 4, y: 10, w: 4, h: 2 } - }, - { - id: "closed_cases_total", - title: "Closed Cases", - description: "The denominator behind the deflection rate", - type: "metric", - colorVariant: "default", - dataset, - values: ["closed_count"], - layout: { x: 8, y: 10, w: 4, h: 2 } - }, - { - id: "top_resolving_articles", - title: "Top Resolving Articles", - description: "Knowledge articles ranked by the closed cases they resolved", - type: "table", - filter: { is_closed: true }, - colorVariant: "default", - dataset, - dimensions: ["resolved_article"], - values: ["kb_resolved_count"], - layout: { x: 0, y: 12, w: 12, h: 4 }, - options: { - sortBy: "kb_resolved_count", - sortOrder: "desc", - limit: 10 - } - }, - // ─── Row 5: My Open Cases by Priority ───────────────────────────── - // A dashboard `table` binds to an analytics cube and aggregates; it cannot - // list individual cases (ADR-0021) — for the case-by-case queue, use the - // my_open_cases ListView ("My Cases" in the My Work nav group). - // `{current_user_id}` scopes what this widget SHOWS; it is presentation - // scope, not an access boundary — row-level security owns that (#510). - { - id: "my_open_cases_by_priority", - title: "My Open Cases by Priority", - description: "Your open cases and their SLA-violation rate, broken down by priority", - type: "table", - filter: { is_closed: false, owner_id: "{current_user_id}" }, - // Opts out of the Agent global filter (keyed by its field, `owner_id`): - // ANDing an agent pick into "mine" empties the widget for anyone else. - filterBindings: { owner_id: false }, - colorVariant: "default", - dataset, - dimensions: ["priority"], - values: ["case_count", "avg_sla_violated"], - layout: { x: 0, y: 16, w: 12, h: 4 }, - options: { - sortBy: "case_count", - sortOrder: "desc", - limit: 10 - } - } - ] -}; - -// src/service/datasets/case.dataset.ts -import { defineDataset } from "@objectstack/spec/ui"; -var CaseDataset = defineDataset({ - name: "case_metrics", - label: "Case Metrics", - description: "Semantic layer for support-case counts, resolution time and SLA", - object: "crm_case", - dimensions: [ - { name: "status", label: "Status", field: "status", type: "string" }, - { name: "priority", label: "Priority", field: "priority", type: "string" }, - { name: "origin", label: "Origin", field: "origin", type: "string" }, - { name: "type", label: "Type", field: "type", type: "string" }, - // The platform's creation stamp (#1992) — the same dimension - // `account_metrics` and `lead_metrics` declare, bucketed by day here. - { name: "created_at", label: "Created", field: "created_at", type: "date", dateGranularity: "day" }, - // Article ranking by resolutions (#601) — group closed cases by the - // article that resolved them. `type: 'lookup'`, the same spelling the - // `owner` dimension on `opportunity_metrics` uses for `owner_id`. - { name: "resolved_article", label: "Resolving Article", field: "resolved_by_article", type: "lookup" } - ], - measures: [ - { name: "case_count", label: "Cases", aggregate: "count" }, - { name: "avg_resolution", label: "Avg Resolution (h)", aggregate: "avg", field: "resolution_time_hours", format: "0.0" }, - { name: "avg_sla_violated", label: "SLA Violation Rate", aggregate: "avg", field: "is_sla_violated", format: "0.0%" }, - // ─── Knowledge deflection (#601) ──────────────────────────────────── - // - // "% of closed cases resolved with an article". Built to the shape - // `opportunity_metrics.win_rate` arrived at the hard way (#593/#614): the - // two halves of the ratio are declared HERE as named measures, once, so no - // widget improvises a denominator — a wrong denominator does not error, it - // returns a plausible number. - // - // Each half carries its OWN `filter`, which the executor runs as a - // sub-query and merges back on the selected dimensions. A widget-level - // filter cannot express this: it would narrow BOTH halves to the same row - // set, which is how you end up dividing a number by itself. - // - // `kb_resolved_count` counts the COLUMN, not the rows: `count()` - // counts non-NULL values, so it needs no `$ne: null` predicate and no - // parallel boolean flag to drift out of step with the lookup. MEASURED on - // 17.0.0-rc.6 against both drivers — the numbers are pinned in - // `test/knowledge-deflection.test.ts`. The one thing it CANNOT discount is - // an empty string, which is non-NULL; that is why the blank is normalised - // to NULL at write time by `case_resolution_article_normalize`, and why - // that hook is part of this metric rather than a tidy-up beside it. - // - // Every widget that shows `kb_deflection_rate` also shows - // `kb_resolved_count` and `closed_count` beside it, so a reader can check - // the arithmetic that produced the percentage. - { name: "closed_count", label: "Closed Cases", aggregate: "count", filter: { is_closed: true } }, - { - name: "kb_resolved_count", - label: "Resolved by KB", - aggregate: "count", - field: "resolved_by_article", - filter: { is_closed: true } - }, - { - name: "kb_deflection_rate", - label: "KB Deflection Rate", - derived: { op: "ratio", of: ["kb_resolved_count", "closed_count"] }, - format: "0%" - }, - // ─── SLA compliance (#1213) ───────────────────────────────────────── - // - // The service dashboard's gauge asks "are we meeting SLA?", so the number - // it plots has to BE compliance. It used to plot `avg_sla_violated` — the - // complement — and ask the renderer to flip it with `options.invert`. That - // key is not declared by `DashboardWidgetOptionsSchema`; it rides the - // schema's `.passthrough()`, so no validator, lint rule or gate could ever - // tell the author it does nothing — and none did. The gauge read 0.0% on - // an org with 100% compliance. - // - // Spelled as a ratio of two counts rather than `1 - avg_sla_violated` - // because `DerivedMeasureOp` operands are MEASURE NAMES only (`of: - // string[]` — "no raw fields, no raw SQL"), so there is no literal `1` to - // subtract from. `difference` cannot express it either. This is the card's - // own second option and the spec's sanctioned shape — the one - // `kb_deflection_rate` above already uses. - // - // `is_sla_violated: false`, not `$ne: true`: the field declares - // `defaultValue: false`, and MEASURED on both drivers this app runs, a - // closed case inserted without the column stores `false` rather than NULL. - // So `sla_met_count + violated = closed_count` holds with no NULL hole. - // Both spellings measured identical (2 of 3, both drivers); the plain one - // is the one that reads as what it means. - // - // The denominator is `closed_count`, already declared above — the same - // measure the `closed_cases_total` tile shows, so a reader can check the - // percentage against a number on the same page. An empty numerator group - // does NOT blank the rate: the executor fills a `count` column's empty - // group with 0 BEFORE evaluating derived measures, so a fully-breached org - // reads 0%, not blank. A zero DENOMINATOR (no closed cases at all) does - // return null — "no data", which is the honest reading. - { name: "sla_met_count", label: "Cases Within SLA", aggregate: "count", filter: { is_closed: true, is_sla_violated: false } }, - { - name: "sla_compliance_rate", - label: "SLA Compliance Rate", - derived: { op: "ratio", of: ["sla_met_count", "closed_count"] }, - format: "0%" - } - ] -}); - -// src/sales/email-templates/_bundle.ts -var bundle = (packs) => Object.entries(packs).flatMap(([locale, pack]) => Object.entries(pack).map(([name, row]) => ({ name, locale, ...row }))); - -// src/service/email-templates/en.ts -var en = { - "crm.case_escalated": { - label: "Case Escalated", - subject: "Case escalated: {{case_number}}", - bodyHtml: "

Case {{case_number}} ({{priority}}) has been auto-escalated on critical priority. Ownership passes to the service manager with the lightest load; while nobody holds that position the case stays with you. Open the case to see who owns it now.

" - }, - "crm.case_sla_breach": { - label: "Case SLA Breached", - subject: "SLA breached: case {{case_number}}", - bodyHtml: "

Case {{case_number}} ({{priority}}) passed its SLA due date and has been auto-escalated.

" - } -}; - -// src/service/email-templates/zh-CN.ts -var zhCN = { - "crm.case_escalated": { - label: "\u5DE5\u5355\u5DF2\u5347\u7EA7", - subject: "\u5DE5\u5355\u5DF2\u5347\u7EA7\uFF1A{{case_number}}", - bodyHtml: "

\u5DE5\u5355 {{case_number}}\uFF08{{priority}}\uFF09\u56E0\u4E25\u91CD\u7EA7\u522B\u5DF2\u81EA\u52A8\u5347\u7EA7\u3002\u6240\u6709\u6743\u5C06\u8F6C\u4EA4\u7ED9\u5F53\u524D\u8D1F\u8377\u6700\u8F7B\u7684\u670D\u52A1\u7ECF\u7406\uFF1B\u82E5\u8BE5\u804C\u4F4D\u6682\u65E0\u4EBA\u62C5\u4EFB\uFF0C\u5DE5\u5355\u4ECD\u5F52\u60A8\u6240\u6709\u3002\u8BF7\u6253\u5F00\u5DE5\u5355\u67E5\u770B\u5F53\u524D\u8D1F\u8D23\u4EBA\u3002

" - }, - "crm.case_sla_breach": { - label: "\u5DE5\u5355 SLA \u8D85\u65F6", - subject: "SLA \u8D85\u65F6\uFF1A\u5DE5\u5355 {{case_number}}", - bodyHtml: "

\u5DE5\u5355 {{case_number}}\uFF08{{priority}}\uFF09\u5DF2\u8D85\u8FC7 SLA \u5230\u671F\u65F6\u95F4\uFF0C\u5E76\u5DF2\u81EA\u52A8\u5347\u7EA7\u3002

" - } -}; - -// src/service/email-templates/ja-JP.ts -var jaJP = { - "crm.case_escalated": { - label: "\u30B1\u30FC\u30B9\u306E\u30A8\u30B9\u30AB\u30EC\u30FC\u30B7\u30E7\u30F3", - subject: "\u30B1\u30FC\u30B9\u304C\u30A8\u30B9\u30AB\u30EC\u30FC\u30B7\u30E7\u30F3\u3055\u308C\u307E\u3057\u305F: {{case_number}}", - bodyHtml: "

\u30B1\u30FC\u30B9 {{case_number}}\uFF08{{priority}}\uFF09\u306F\u91CD\u5927\u5EA6\u304C\u9AD8\u3044\u305F\u3081\u81EA\u52D5\u7684\u306B\u30A8\u30B9\u30AB\u30EC\u30FC\u30B7\u30E7\u30F3\u3055\u308C\u307E\u3057\u305F\u3002\u6240\u6709\u6A29\u306F\u8CA0\u8377\u306E\u6700\u3082\u8EFD\u3044\u30B5\u30FC\u30D3\u30B9\u30DE\u30CD\u30FC\u30B8\u30E3\u30FC\u306B\u79FB\u308A\u307E\u3059\u3002\u305D\u306E\u5F79\u8077\u306B\u8AB0\u3082\u3044\u306A\u3044\u9593\u306F\u3001\u30B1\u30FC\u30B9\u306F\u3042\u306A\u305F\u306E\u307E\u307E\u3067\u3059\u3002\u30B1\u30FC\u30B9\u3092\u958B\u3044\u3066\u73FE\u5728\u306E\u6240\u6709\u8005\u3092\u3054\u78BA\u8A8D\u304F\u3060\u3055\u3044\u3002

" - }, - "crm.case_sla_breach": { - label: "\u30B1\u30FC\u30B9\u306E SLA \u8D85\u904E", - subject: "SLA \u8D85\u904E: \u30B1\u30FC\u30B9 {{case_number}}", - bodyHtml: "

\u30B1\u30FC\u30B9 {{case_number}}\uFF08{{priority}}\uFF09\u306F SLA \u671F\u9650\u3092\u904E\u304E\u305F\u305F\u3081\u3001\u81EA\u52D5\u7684\u306B\u30A8\u30B9\u30AB\u30EC\u30FC\u30B7\u30E7\u30F3\u3055\u308C\u307E\u3057\u305F\u3002

" - } -}; - -// src/service/email-templates/es-ES.ts -var esES = { - "crm.case_escalated": { - label: "Caso escalado", - subject: "Caso escalado: {{case_number}}", - bodyHtml: "

El caso {{case_number}} ({{priority}}) se ha escalado autom\xE1ticamente por prioridad cr\xEDtica. La propiedad pasa al responsable de servicio con menos carga; mientras nadie ocupe ese puesto, el caso sigue siendo tuyo. Abre el caso para ver qui\xE9n lo tiene ahora.

" - }, - "crm.case_sla_breach": { - label: "SLA del caso incumplido", - subject: "SLA incumplido: caso {{case_number}}", - bodyHtml: "

El caso {{case_number}} ({{priority}}) super\xF3 su fecha l\xEDmite de SLA y se ha escalado autom\xE1ticamente.

" - } -}; - -// src/service/email-templates/crm.email-template.ts -var ServiceEmailTemplates = bundle({ - "en-US": en, - "zh-CN": zhCN, - "ja-JP": jaJP, - "es-ES": esES -}); - -// src/service/flows/case-escalation.flow.ts -import { P as P10, cel } from "@objectstack/spec"; -var CaseEscalationFlow = { - name: "case_escalation", - label: "Case Escalation Process", - description: "Automatically escalate high-priority cases", - type: "record_change", - status: "active", - // A record-change flow fired by a SYSTEM write carries no trigger user - // either — the user-less exposure is NOT schedule-only (ADR-0049), and the - // platform's own build-time lint cannot see this shape - // because it is only knowable at run time. Measured on 17.0.0-rc.2: a - // user-less run refuses the very first data node — "[runAs] refusing a data - // operation (object 'crm_case', event 'record-after-update')" — so a case - // raised by the seed loader, an integration, or another runAs:'system' - // flow's write silently keeps its critical priority forever. - // - // Elevating the USER-driven runs too is correct here: escalation is a - // service-level policy, not the writer's own edit. Both data nodes are keyed - // to `{record.id}` — the row that just fired the trigger — so user scope - // buys no restriction that matters, while it does add a failure mode: an - // agent may legitimately raise a case without holding edit rights on the - // escalation lifecycle fields (`is_escalated` / `escalated_date` / `status`). - // This also puts the flow on the same footing as `case_sla_monitor`, which - // performs the same escalation on a schedule under `runAs: 'system'`. - runAs: "system", - variables: [ - { name: "caseId", type: "text", isInput: true, isOutput: false } - ], - nodes: [ - { - // Trigger wiring (7.4): bind to afterUpdate and gate on the critical - // transition. The re-fire guard MUST NOT rely on the boolean - // `is_escalated`: this flow's own escalation write re-triggers - // record-after-update, and on SQLite/libsql a boolean persists as integer - // `1`, so `record.is_escalated != true` is `1 != true` = true — the guard - // never trips and the flow loops forever (it wedged a first-boot seed on - // 2026-07-06). Instead: - // - `escalated_date == null` marks "never escalated" (the escalation write - // stamps it, suppressing the second fire AND any re-escalation when an - // agent later moves the case back to in_progress to work it); - // - the status terms keep the flow off cases already escalated or already - // finished — without them a critical case could never be resolved or - // closed (the flow would yank `status` straight back to `escalated`). - id: "start", - type: "start", - label: "Start", - config: { - objectName: "crm_case", - triggerType: "record-after-update", - // Also suppress on closed/resolved: closing a critical case is itself - // an afterUpdate, and with only the `!= "escalated"` guard this flow - // re-escalated the case the moment it was closed (observed live: - // close_case wrote status "closed", this flow immediately rewrote it - // to "escalated"). Status strings are the reliable guard — comparing - // the boolean is_closed suffers the SQLite `1 != true` trap above. - // `escalated_date == null` additionally keeps a case that was already - // escalated once (then reopened) from being escalated again. - // - // TOTALITY: every `record.x` read carries a `has(record.x)` - // guard — see the house-rule block in - // `test/flow-condition-totality.test.ts`. Measured end-to-end on - // driver-memory: a case BORN critical is stored without an - // `escalated_date` column at all, `record.escalated_date == null` - // aborted with `No such key: escalated_date`, and this flow never ran - // on the very population it exists for. The guards below preserve the - // predicate's answer on every shape where it previously had one. - // `escalated_date` absent means the same as null ("never escalated"); - // an absent `status` cannot be a terminal status, so it must not - // suppress the escalation. - condition: P10`has(record.priority) && record.priority == "critical" - && (!has(record.escalated_date) || record.escalated_date == null) - && (!has(record.status) - || (record.status != "escalated" && record.status != "resolved" && record.status != "closed"))` - } - }, - { - id: "get_case", - type: "get_record", - label: "Get Case Record", - config: { objectName: "crm_case", filter: { id: cel`record.id` }, outputVariable: "caseRecord" } - }, - { - // The `label` names what this node actually does: it flags the case as - // escalated (see `fields` below) and reassigns nothing. The `id` keeps - // its original `assign_senior_agent` spelling on purpose — `edges[]` - // reference nodes by id, and `CaseEscalationOnCreateFlow` rewrites the - // node list by id, so renaming one is a behaviour change, not a wording - // fix. - id: "assign_senior_agent", - type: "update_record", - label: "Flag as Escalated", - config: { - objectName: "crm_case", - filter: { id: cel`record.id` }, - // `escalation_reason` must be set whenever `is_escalated` flips true — the - // object's `escalation_reason_required` validation rejects the write - // otherwise (which silently aborted this flow until it was supplied). - // - // ⛔ This node writes NO owner, and cannot: reassigning from a flow - // would mean `{caseRecord.owner_id.manager}`, and a flow template - // cannot traverse a lookup — it interpolates to the literal "undefined" - // and would orphan the case under a phantom owner. The hand-off does not - // need to happen here: this very update fires the - // `case_escalation_reassign` beforeUpdate hook - // (`src/service/objects/_case-assignment.ts`), which puts the case with the - // least-loaded holder of the flat `service_manager` position — a pool, - // which the app can resolve, rather than a manager chain, which it - // cannot. With that pool unstaffed the case keeps its owner and this - // write is unchanged. - fields: { is_escalated: true, escalation_reason: "Auto-escalated: critical priority", escalated_date: cel`isoDatetime(now())`, status: "escalated" } - } - }, - // No `create_task` node here: the escalation write above flips `status` to - // `escalated`, which fires the `case_status_side_effects` hook — the single - // owner of escalation follow-up tasks (it also covers the `escalate_case` - // action and the SLA monitor). A second task node here produced duplicate, - // disagreeing tasks (case owner/high vs account owner/urgent) per escalation. - { - // Gateway only — the live predicate is on the out-edge `e4`. The engine - // never reads a `decision` node's singular `config.condition`, so a copy - // here would restate the gate without BEING the gate - // (`flow-inert-node-condition`); `pnpm lint` — `os lint --strict` — - // fails on that. - // - // Why the gate exists: `crm_case.owner_id` is NULLABLE and an unowned case - // is an ordinary state — this repo ships `scripts/backfill-owner-id.ts` - // and `pnpm backfill:owner` precisely because ownerless rows happen, and - // ordinary REST creation / import reach the same state. `notify_team` - // below addresses exactly ONE recipient, so an ownerless case leaves it - // with an empty slate, which the builtin node treats as a HARD failure: - // `execute` returns `success: false`, `executeNode` turns that into a - // throw, and the run ends `status: 'failed'`. - // - // BLAST RADIUS, stated precisely because it differs from the sibling - // defect in `case_sla_monitor` and the difference is structural: these two - // are `record_change` flows with NO loop, so one ownerless case kills only - // its OWN run — there is no queue of other records behind it. A `schedule` - // flow whose work sits inside a `loop` awaits `runRegion` with no - // try/catch, and there one ownerless row takes down every record ordered - // behind it. - // - // ⛔ The gate sits AFTER `assign_senior_agent`, which stays - // UNCONDITIONAL: the escalation itself must still land (measured - // `is_escalated: true`, `status: 'escalated'` on every failing run), so an - // ownerless critical case stays visible in views and reports. Only the - // notify is gated — and here that loses nothing a reader would want, - // because `caseRecord` is read by `get_case` UPSTREAM of the escalation - // write, so `{caseRecord.owner_id}` is deliberately the owner the case had - // BEFORE the hand-off. With no such person there is no "previous owner" - // for the message to be addressed to. - // - // ⚠️ This guard is exactly the duplication objectstack#13682 exists to - // retire — `notify` should treat an empty audience as a RECORDED SKIP - // rather than a hard failure. When that lands, delete this node and edge - // `e4`'s predicate here, and the same pair in `case-sla-monitor.flow.ts`. - id: "check_owner", - type: "decision", - label: "Case Has an Owner?" - }, - { - // ADR-0012: the dedicated `notify` node dispatches through the messaging - // service (inbox + email + push). The legacy `script` + `actionType:'email'` - // shape is a no-op stub in 7.4 and never delivered anything. - // Owner only: `{caseRecord.owner_id.manager}` cannot traverse a lookup in - // flow templates — it interpolates to the literal "undefined". - // The `label` names the single recipient this node has (`recipients` - // below); the `id` keeps its `notify_team` spelling because `edges[]` - // reference it. Cf. the same node in `case-sla-monitor.flow.ts`, whose - // label already says `Alert Owner`. - id: "notify_team", - type: "notify", - label: "Notify Case Owner", - config: { - // Owner only, and the owner it reaches is the one the case had BEFORE - // the escalation: `caseRecord` was read by `get_case` upstream of the - // write, so `{caseRecord.owner_id}` is the agent being handed off from - // — exactly the person this message is for. Flow templates cannot - // traverse a lookup (see the note on `assign_senior_agent` above): - // `{caseRecord.owner_id.manager}` and `{caseRecord.crm_account.name}` - // both interpolate to the literal string "undefined" — a phantom - // recipient and a garbled body. - recipients: [cel`caseRecord.owner_id`], - channels: ["inbox", "email"], - severity: "critical", - topic: "case_escalated", - // ⚠️ The body — now `crm.case_escalated` in `../email-templates/`, one - // row per locale — must stay true on BOTH outcomes. "It remains - // assigned to you" is false whenever the hand-off finds a manager; the - // opposite claim ("it has been reassigned") is false whenever the - // `service_manager` pool is unstaffed, which is the first-install norm. - // So it states the rule and points at the record for the answer, in - // every language. - template: "crm.case_escalated", - templateData: { case_number: cel`caseRecord.case_number`, priority: cel`caseRecord.priority` }, - actionUrl: "/crm_case/{{record.id}}" - } - }, - { id: "end", type: "end", label: "End" } - ], - edges: [ - { id: "e1", source: "start", target: "get_case", type: "default" }, - { id: "e2", source: "get_case", target: "assign_senior_agent", type: "default" }, - { id: "e3", source: "assign_senior_agent", target: "check_owner", type: "default" }, - // The gate. A `decision` with no matching out-edge simply ends the run - // here, after the escalation has already been written. - // - // TOTALITY: `caseRecord` is a `get_record` OUTPUT — a raw driver row, sparse - // in the way `driver-memory` / `driver-mongodb` store only the columns a row - // was written with — so only `has()` is total, and it must be `vars.`-scoped - // (measured: bare `has(caseRecord.owner_id)` still aborts with `Unknown - // variable` on an unbound root, while `has(vars.caseRecord)` answers - // `false`). - // - // ⛔ EVERY TERM IS LOAD-BEARING — do not simplify this predicate. The last - // one MIRRORS THE NOTIFY NODE'S OWN emptiness rule rather than guessing at - // it: builtin `notify` builds its audience with `String(v).trim()` + - // `.filter(Boolean)`, so null, undefined, `''` and any all-whitespace value - // all collapse to the same empty slate. Each term was measured through - // `evaluateCondition` on the shape it alone covers, by dropping it and - // recording what the rest do: - // - `has(vars.caseRecord)` — an UNBOUND root. Without it the predicate - // aborts with `No such key: caseRecord`. `get_case` binds the variable - // on every path here (it sets it even when it matched nothing), so this - // term is what keeps a future graph edit from turning a gate into an - // abort — and the `vars.`-scoped `has()` pair is the house rule - // `test/flow-variable-conditions.test.ts` enforces. - // - `has(vars.caseRecord.owner_id)` — the ABSENT key. Without it, - // `vars.caseRecord.owner_id != null` aborts with `No such key: owner_id`. - // - `vars.caseRecord.owner_id != null` — the explicit NULL. Without it the - // wrap is handed one and aborts with `no matching overload for - // 'string(null)'`, so this term must short-circuit in front of it. - // - `string(...).trim() != ""` — the BLANK/whitespace id. `' ' != ""` is - // TRUE in CEL, so a gate written that way opens for a whitespace - // `owner_id` and reproduces this very defect one input narrower. The - // `string()` wrap is not decoration either: measured, a bare `.trim()` - // on a numeric id aborts with `no matching overload for - // 'double.trim()'` and `.matches()` with `'double.matches(string)'` — a - // thrown condition, the fault mode this gate exists to remove. - // - // ⛔ Do NOT add a `vars.caseRecord != null` term for the row that is GONE by - // the time `get_case` reads it. Measured INERT: `get_record` with no match - // sets the variable to `null`, key present, and `has()` on a null base - // answers `false` rather than aborting, so the four terms above already - // close that shape (`test/flow-escalation-ownerless-case.test.ts` covers - // it). A term that cannot change an answer is an inert copy, not defence in - // depth. - { id: "e4", source: "check_owner", target: "notify_team", type: "conditional", condition: P10`has(vars.caseRecord) && has(vars.caseRecord.owner_id) - && vars.caseRecord.owner_id != null && string(vars.caseRecord.owner_id).trim() != ""`, label: "Has owner" }, - { id: "e5", source: "notify_team", target: "end", type: "default" } - ] -}; -var CaseEscalationOnCreateFlow = { - ...CaseEscalationFlow, - name: "case_escalation_on_create", - label: "Case Escalation Process (on create)", - description: "Escalate cases created critical (insert-time twin of case_escalation)", - nodes: CaseEscalationFlow.nodes.map( - (n) => n.id === "start" ? { ...n, config: { ...n.config, triggerType: "record-after-create" } } : n - ) -}; - -// src/service/flows/case-actions.flow.ts -import { cel as cel2 } from "@objectstack/spec"; - -// src/service/objects/_case-assignment.ts -var CLAIMABLE_TARGET_STATUSES = [ - "in_progress", - "waiting_customer", - "waiting_support" -]; -function createCaseRoundRobinAssign(hookName = "case_auto_assign") { - return { - name: hookName, - object: "crm_case", - events: ["beforeInsert"], - priority: 250, - description: "Assign ownerless new cases to the least-loaded service agent.", - handler: async (ctx) => { - const { input } = ctx; - if (typeof input.owner_id === "string" && input.owner_id) return; - const api = ctx.api; - if (!api) return; - try { - const holders = await api.object("sys_user_position").find({ - where: { position: "service_agent" }, - fields: ["user_id"], - top: 1e3 - }); - const agentIds = Array.from( - new Set( - (holders ?? []).map((r) => typeof r.user_id === "string" ? r.user_id : "").filter(Boolean) - ) - ); - if (agentIds.length === 0) return; - let best; - let bestCount = Infinity; - for (const agentId of agentIds) { - const openCount = await api.object("crm_case").count({ - where: { owner_id: agentId, status: { $nin: ["resolved", "closed"] } } - }); - if (openCount < bestCount) { - bestCount = openCount; - best = agentId; - } - } - if (best) input.owner_id = best; - } catch { - } - } - }; -} -function createCaseEscalationReassign(hookName = "case_escalation_reassign") { - return { - name: hookName, - object: "crm_case", - events: ["beforeUpdate"], - priority: 250, - runAs: "system", - description: "Hand a case being escalated to the least-loaded service manager.", - handler: async (ctx) => { - if (ctx.dispatch?.mode === "per-row") return; - const { input } = ctx; - const previous = ctx.previous; - if (!previous) return; - if (input.status !== "escalated" || previous.status === "escalated") return; - if (typeof input.owner_id === "string" && input.owner_id) return; - const api = ctx.api; - if (!api) return; - const organizationId = typeof previous.organization_id === "string" && previous.organization_id !== "" ? previous.organization_id : void 0; - const inOrganization = organizationId ? { organization_id: organizationId } : {}; - try { - const holders = await api.object("sys_user_position").find({ - where: { position: "service_manager", ...inOrganization }, - fields: ["user_id"], - top: 1e3 - }); - const managerIds = Array.from( - new Set( - (holders ?? []).map((r) => typeof r.user_id === "string" ? r.user_id : "").filter(Boolean) - ) - ); - if (managerIds.length === 0) return; - const currentOwner = typeof previous.owner_id === "string" && previous.owner_id || ""; - if (currentOwner && managerIds.indexOf(currentOwner) !== -1) return; - let best; - let bestCount = Infinity; - for (const managerId of managerIds) { - const openCount = await api.object("crm_case").count({ - where: { owner_id: managerId, status: { $nin: ["resolved", "closed"] }, ...inOrganization } - }); - if (openCount < bestCount) { - bestCount = openCount; - best = managerId; - } - } - if (best) input.owner_id = best; - } catch { - } - } - }; -} -function createCaseSelfClaim(hookName = "case_self_claim") { - return { - name: hookName, - object: "crm_case", - events: ["beforeUpdate"], - priority: 260, - description: "Let a user claim an unowned open case by picking it up; the owner written is always the caller.", - handler: async (ctx) => { - if (ctx.dispatch?.mode === "per-row") return; - const { input } = ctx; - const previous = ctx.previous; - if (!previous) return; - const claimant = ctx.user?.id; - if (typeof claimant !== "string" || !claimant) return; - if (ctx.session?.isSystem) return; - if ("owner_id" in input) return; - if (typeof previous.owner_id === "string" && previous.owner_id) return; - if (previous.status === "closed") return; - if (previous.is_closed === true || previous.is_closed === 1) return; - const next = input.status; - if (typeof next !== "string" || next === previous.status) return; - if (next !== "in_progress" && next !== "waiting_customer" && next !== "waiting_support") return; - input.owner_id = claimant; - } - }; -} - -// src/service/flows/case-actions.flow.ts -var EscalateCaseFlow = { - name: "escalate_case", - label: "Escalate Case", - description: "Collect an escalation reason, then flag and re-prioritise the case.", - type: "screen", - status: "active", - variables: [ - // MUST be `recordId` — the console's flow-action contract seeds only that - // name (and its camelCase object alias); a custom name arrives undefined. - { name: "recordId", type: "text", isInput: true, isOutput: false }, - { name: "reason", type: "text", isInput: true, isOutput: false } - ], - nodes: [ - { id: "start", type: "start", label: "Start", config: { objectName: "crm_case" } }, - { - id: "screen_1", - type: "screen", - label: "Escalate Case", - config: { - fields: [ - { name: "reason", label: "Escalation Reason", type: "textarea", required: true } - ] - } - }, - { - // The USER-CONTEXT half of the escalation. Everything here is a - // column the acting agent may legitimately write, so it is written with - // their identity — this flow stays `runAs: 'user'`. - // - // escalation_reason the agent's own screen input - // priority an ordinary editable field - // status ordinary, and the hook trigger (below) - // - // The two stamps a person never types — `is_escalated` and - // `escalated_date` — are `readonly: true` on `crm_case` and are written - // by the `case_escalation_stamp` subflow that follows, with the system - // context. See `src/service/flows/case-escalation-stamp.flow.ts`. - // - // ⚠️ `status: 'escalated'` MUST stay in this node, and not only because - // it is user-writable: it is the trigger both escalation hooks key off — - // `case_escalation_reassign` (`_case-assignment.ts`) gates on - // `input.status !== 'escalated' || previous.status === 'escalated'`, and - // `case_status_side_effects` (`case.hook.ts`) reads the same transition. - // Keeping it here keeps the ownership hand-off and the side-effect tasks - // firing from the ACTING USER's write, exactly as they did before the - // split. Moving it into the elevated subflow would silently re-attribute - // both to the system. - // - // It is also what suppresses a double-fire of the automatic - // `case_escalation` record-change flow. - id: "escalate", - type: "update_record", - label: "Escalate Case", - config: { - objectName: "crm_case", - filter: { id: cel2`recordId` }, - fields: { - escalation_reason: cel2`reason`, - status: "escalated", - priority: "critical" - } - } - }, - { - // The ELEVATED half, and the only elevation in this flow: one - // `runAs: 'system'` flow, one `update_record`, two readonly columns. - // The maintainer-approved direction — elevate the write, not the flow. - // - // ⚠️ THIS NODE MUST RUN AFTER `escalate`, NOT BEFORE. `crm_case`'s - // `escalation_reason_required` validation rejects any write whose merged - // record has `is_escalated == true` and a blank `escalation_reason`. The - // reason is written by the node above, so by the time the flag flips it - // is already stored. Reversing these two nodes fires that validation - // against a record with no reason yet and the stamp is rejected. - // - // ⛔ Do not "simplify" this by giving THIS flow `runAs: 'system'` and - // folding the stamp back into the node above. That is option A, costed - // and explicitly not adopted: it elevates every write this screen flow - // makes and stops it carrying the acting user's context downstream. - // `AGENTS.md` house rule 9 states it as standing policy. - id: "stamp_escalation", - type: "subflow", - label: "Stamp Escalation Flags", - config: { - flowName: "case_escalation_stamp", - input: { recordId: cel2`recordId` } - } - }, - { id: "end", type: "end", label: "End" } - ], - edges: [ - { id: "e1", source: "start", target: "screen_1", type: "default" }, - { id: "e2", source: "screen_1", target: "escalate", type: "default" }, - { id: "e3", source: "escalate", target: "stamp_escalation", type: "default" }, - { id: "e4", source: "stamp_escalation", target: "end", type: "default" } - ] -}; -var CloseCaseFlow = { - name: "close_case", - label: "Close Case", - description: "Collect the resolution, then close the case and stop the SLA clock.", - type: "screen", - status: "active", - // `is_closed` is a readonly lifecycle field. This trusted screen flow owns - // the transition and must therefore run with the system writer. - // - // ⛔ A HISTORICAL PRECEDENT, NOT A POLICY — do not cite this line to justify - // elevating another screen flow (#1434, the maintainer ruling that settled - // it). The standing rule is the opposite one: a screen flow stays - // `runAs: 'user'` and a write that genuinely needs elevation is split into a - // dedicated `system` sub-flow reached by a `subflow` node — see - // `escalate_case` above and `src/service/flows/case-escalation-stamp.flow.ts`. - // "Readonly stripped my write, so I made the flow system" is the pattern - // that ruling exists to stop being copied; `AGENTS.md` house rule 9 carries - // it as house policy. This flow predates that rule and has not been - // re-shaped to match it. - runAs: "system", - variables: [ - { name: "recordId", type: "text", isInput: true, isOutput: false }, - { name: "resolution", type: "text", isInput: true, isOutput: false }, - { name: "resolved_by_article", type: "text", isInput: true, isOutput: false } - ], - nodes: [ - { id: "start", type: "start", label: "Start", config: { objectName: "crm_case" } }, - { - // The "attach the article that resolved it" affordance. Optional - // on purpose: most cases are not resolved out of the knowledge base, and - // a required field here would be answered with a junk value rather than - // left honest — which is worse than an absent link for a measure whose - // whole job is to say how OFTEN the KB resolves a case. - // - // `reference` names the object the picker offers. Up to - // `@objectstack/spec@17.4.0` a screen field had no such key, so this - // `type: 'lookup'` field had nothing to resolve a record picker from; - // 17.5.0 added `reference` to `ScreenFieldConfigSchema` and made it - // REQUIRED on a lookup screen field (#17913) — the stack does not load - // without it. It is the same target the case's own `resolved_by_article` - // lookup declares (`crm_knowledge_article`). - // - // The `Resolved by Article` lookup in the case's Resolution group, on the - // record form, writes the same column; the action is - // `refreshAfter: true`, so the record form is what the agent lands on - // immediately after closing. - id: "screen_1", - type: "screen", - label: "Close Case", - config: { - fields: [ - { name: "resolution", label: "Resolution", type: "textarea", required: true }, - { - name: "resolved_by_article", - label: "Resolved by Article (optional)", - type: "lookup", - reference: "crm_knowledge_article", - required: false - } - ] - } - }, - { - // `resolved_by_article` is written unconditionally, and a blank one is - // normalised to NULL by `case_resolution_article_normalize` - // (`src/service/objects/case.hook.ts`) rather than branched around here: MEASURED - // on the real engine, a screen field left empty resumes as `''` and lands - // as an empty string, which `count(resolved_by_article)` counts. A - // `decision` node could not have branched it either — this repo has - // measured `decision.config.condition` to be inert metadata - // (`test/win-loss-capture.test.ts`'s table of five such surfaces). - // - // The read is guarded because the field is optional: a resume that omits - // it leaves the variable unbound, which the 17.x template wrote as nothing - // (the stored link left alone) and CEL refuses. The guard writes NULL - // there — the value a blank field already lands as after the normalize - // hook — so an omitted answer and an empty one now close the case alike. - id: "close", - type: "update_record", - label: "Close Case", - config: { - objectName: "crm_case", - filter: { id: cel2`recordId` }, - fields: { - is_closed: true, - resolution: cel2`resolution`, - status: "closed", - resolved_by_article: cel2`has(vars.resolved_by_article) ? resolved_by_article : null` - } - } - }, - { id: "end", type: "end", label: "End" } - ], - edges: [ - { id: "e1", source: "start", target: "screen_1", type: "default" }, - { id: "e2", source: "screen_1", target: "close", type: "default" }, - { id: "e3", source: "close", target: "end", type: "default" } - ] -}; -var CLAIM_STATUS_LABEL = { - in_progress: "In Progress", - waiting_customer: "Waiting on Customer", - waiting_support: "Waiting on Support" -}; -var CLAIM_STATUS_OPTIONS = CLAIMABLE_TARGET_STATUSES.map((value) => ({ - value, - label: CLAIM_STATUS_LABEL[value] -})); -var ClaimCaseFlow = { - name: "claim_case", - label: "Claim Case", - description: "Take an unowned case out of triage by moving it to a status that means you are on it.", - type: "screen", - status: "active", - // Load-bearing, not boilerplate — see the header. A system run claims nobody. - runAs: "user", - variables: [ - // MUST be `recordId` — the console's flow-action contract seeds only that - // name (and its camelCase object alias); a custom name arrives undefined. - { name: "recordId", type: "text", isInput: true, isOutput: false }, - { name: "claimStatus", type: "text", isInput: true, isOutput: false } - ], - nodes: [ - { id: "start", type: "start", label: "Start", config: { objectName: "crm_case" } }, - { - id: "screen_1", - type: "screen", - label: "Claim Case", - config: { - fields: [ - { - name: "claimStatus", - label: "Working status", - type: "select", - required: true, - defaultValue: "in_progress", - options: CLAIM_STATUS_OPTIONS - } - ] - } - }, - { - // ⛔ `status` is the ONLY field this node may ever carry. Adding - // `owner_id` here does not "make the claim explicit" — it makes the write - // refused by the transfer gate before any hook runs, and it takes - // `case_self_claim` out of the path on the one caller it would reach. - // The guard beside this file fails on any such addition. - id: "claim", - type: "update_record", - label: "Claim Case", - config: { - objectName: "crm_case", - filter: { id: cel2`recordId` }, - fields: { - status: cel2`claimStatus` - } - } - }, - { id: "end", type: "end", label: "End" } - ], - edges: [ - { id: "e1", source: "start", target: "screen_1", type: "default" }, - { id: "e2", source: "screen_1", target: "claim", type: "default" }, - { id: "e3", source: "claim", target: "end", type: "default" } - ] -}; - -// src/service/flows/case-escalation-stamp.flow.ts -import { cel as cel3 } from "@objectstack/spec"; -var CaseEscalationStampFlow = { - name: "case_escalation_stamp", - label: "Stamp Case Escalation", - description: "Write the two readonly escalation stamps (is_escalated, escalated_date) with the system context. Called by escalate_case through a subflow node.", - type: "autolaunched", - status: "active", - // ⭐ THE ENTIRE POINT OF THIS FILE. This is the only elevation in the - // escalate path, and it covers exactly one `update_record` node. - runAs: "system", - variables: [ - // Supplied by the caller's `subflow` node, whose `input` envelope reads its own `recordId`. - { name: "recordId", type: "text", isInput: true, isOutput: false } - ], - nodes: [ - // `config: {}` matches the shape measured in - // `test/readonly-write-semantics.test.ts`: an autolaunched callee is handed - // its params by the `subflow` executor and resolves no trigger record of - // its own, so there is no `objectName` for the start node to load. - { id: "start", type: "start", label: "Start", config: {} }, - { - id: "stamp", - type: "update_record", - label: "Stamp Escalation Flags", - config: { - objectName: "crm_case", - filter: { id: cel3`recordId` }, - // ⛔ Do not add fields here. Every column in this node is written with - // the elevated context; anything a user can legitimately type belongs - // in `escalate_case` instead. - fields: { - is_escalated: true, - escalated_date: cel3`isoDatetime(now())` - } - } - }, - { id: "end", type: "end", label: "End" } - ], - edges: [ - { id: "e1", source: "start", target: "stamp", type: "default" }, - { id: "e2", source: "stamp", target: "end", type: "default" } - ] -}; - -// src/service/flows/case-sla-monitor.flow.ts -import { P as P11, cel as cel4 } from "@objectstack/spec"; - -// src/sales/flows/_guarded-iteration.ts -var guarded = (key, region) => ({ - nodes: [{ - id: `guard_${key}`, - type: "try_catch", - label: "Guarded Iteration", - config: { - try: region, - catch: { nodes: [{ id: `handled_${key}`, type: "assignment", label: "Skip This Item" }] } - } - }] -}); - -// src/service/flows/case-sla-monitor.flow.ts -var CASE_HAS_OWNER = () => P11`has(vars.currentCase) && has(vars.currentCase.owner_id) - && vars.currentCase.owner_id != null && string(vars.currentCase.owner_id).trim() != ""`; -var CASE_HAS_NO_OWNER = () => P11`has(vars.currentCase) && (!has(vars.currentCase.owner_id) - || vars.currentCase.owner_id == null || string(vars.currentCase.owner_id).trim() == "")`; -var CaseSlaMonitorFlow = { - name: "case_sla_monitor", - label: "Case SLA Monitor", - description: "Hourly sweep: flag and escalate open cases that have breached their SLA due date.", - type: "schedule", - status: "active", - // Scheduled runs have no trigger user, so under the default runAs:'user' the - // data nodes execute UNSCOPED anyway. Declare runAs:'system' to make that - // RLS-bypassing elevation explicit and intended (ADR-0049). - runAs: "system", - variables: [], - nodes: [ - { id: "start", type: "start", label: "Start (hourly)", config: { schedule: "0 * * * *" } }, - { - id: "query_breached", - type: "get_record", - label: "Find Breached Cases", - config: { - objectName: "crm_case", - // ⛔ `$nin` on `status`, never `is_closed: false`: a case in `resolved` - // has met its SLA — work is finished — but `is_closed` only flips on - // `closed`, so the boolean filter stamps false breaches on resolved - // cases and drags them back to `escalated`. - // - // `$lt` is `caseSlaBreached` (`src/service/objects/_case-sla.ts`) read - // with "now" as the instant: STRICTLY past due. Its other half is - // `case_sla_defaults`, which applies the same rule on the write that - // settles a case — so a case settled late is flagged even when this - // sweep never reached it, or never runs (#2070). - // - // "Now" is the query engine's own `{now}` placeholder, which an - // 18.0.0-next.0 filter operand leaves to the engine as written. It - // renders the instant's ISO text, as the retired `{NOW()}` flow token - // did, and it is the spelling the SLA Violations tile reads, so the - // sweep and the tile say "past due" in one wording. - filter: { - status: { $nin: ["resolved", "closed"] }, - is_sla_violated: false, - sla_due_date: { $lt: "{now}" } - }, - limit: 500, - outputVariable: "caseList" - } - }, - { - id: "loop_cases", - type: "loop", - label: "For Each Breached Case", - config: { - collection: cel4`caseList`, - iteratorVariable: "currentCase", - body: guarded("case", { - nodes: [ - { - id: "flag_breach", - type: "update_record", - label: "Flag SLA Breach", - config: { - objectName: "crm_case", - filter: { id: cel4`currentCase.id` }, - // `escalation_reason` must accompany `is_escalated: true` — the - // object's `escalation_reason_required` validation (severity: - // error) rejects the whole write otherwise, turning this sweep - // into a silent no-op (cf. the same fix in case_escalation). - fields: { - is_sla_violated: true, - is_escalated: true, - status: "escalated", - escalated_date: cel4`isoDatetime(now())`, - escalation_reason: "Auto-escalated: SLA due date breached" - } - } - }, - { - // Gateway only — the predicate lives on the out-edge. - // - // `crm_case.owner_id` is NULLABLE and an unowned case is an - // ordinary state (this repo ships `scripts/backfill-owner-id.ts` / - // `pnpm backfill:owner` precisely because ownerless rows happen; - // ordinary REST creation and import reach it too). The `notify` - // node below addresses exactly one recipient, so an ownerless case - // left it with an empty slate — which the builtin node treats as a - // HARD failure, and that failure is not scoped to the one case: - // `executeNode` throws, `runRegion` rethrows, and the `loop` node - // awaits it with no try/catch, so the whole sweep died on the - // ownerless row and every breached case ORDERED BEHIND IT was - // never even flagged. Measured, not assumed — see - // `test/flow-sla-ownerless-case.test.ts`. - // - // The gate sits AFTER `flag_breach` on purpose. `flag_breach` is - // unconditional, so an ownerless breach is still RECORDED on the - // record — visible in views and reports, where a service manager - // finds it. Gating both would trade a dead run for a silently - // dropped alert on exactly the cases most likely to be neglected. - // - // The ownerless branch is not a dead end: it goes to - // `reload_case`, because by the time the gate is reached the - // sweep's own write may ALREADY HAVE GIVEN THE CASE AN OWNER — - // see that node (maintainer ruling 2026-09-03, option C). - id: "check_owner", - type: "decision", - label: "Case Has an Owner?" - }, - { - // Re-read the case the sweep just wrote. - // - // ⚠️ THE ASSIGNMENT IS NOT AUTHORED HERE, AND MUST NOT BE. - // `flag_breach` writes `status: 'escalated'`, and that IS the - // escalation transition `case_escalation_reassign` - // (`src/service/objects/_case-assignment.ts`, `beforeUpdate`, priority - // 250) fires on: it stamps the least-loaded holder of the - // `service_manager` position onto the payload of the update - // already in flight. So the sweep does not need a seam to "call" - // the assignment — performing the transition IS putting the case - // through it, and the app keeps ONE answer to "who should own - // this case" instead of a flow-shaped second implementation of - // least-loaded balancing. - // - // MEASURED, not assumed (`test/flow-sla-ownerless-case.test.ts` - // drives the real flow, the real engine and the real hooks): with - // a staffed pool an ownerless breached case comes back owned; with - // an empty pool the hook stands down and the case comes back - // ownerless. No second write, no re-entry, no loop — the hook - // mutates the in-flight payload and issues no operation of its - // own. - // - // ⛔ The READ is what this node is for, not a second write: - // `currentCase` is the loop item bound by `query_breached` BEFORE - // `flag_breach` ran, so the owner the sweep just assigned is - // invisible to it and `{currentCase.owner_id}` addresses the - // pre-write state. Re-binding the SAME variable is what makes the - // rest of the iteration — the gate below and the notify node's - // whole template — read the case as it now stands, with no second - // notify node to keep in step. - // - // No `limit`: `get_record` calls `findOne` at or below 1 and binds - // the single row itself, which is what `{currentCase.}` - // needs. A miss binds `null` — `get_record` always binds — which - // `check_assigned` below is there to read. - id: "reload_case", - type: "get_record", - label: "Re-read Case After Escalation", - config: { - objectName: "crm_case", - filter: { id: cel4`currentCase.id` }, - outputVariable: "currentCase" - } - }, - { - // Gateway only — the predicate lives on the out-edge. - // - // The ruled empty-pool clause, as a gate rather than a failure: - // when the `service_manager` pool resolves empty the hook assigns - // nobody, the re-read case is still ownerless, no edge matches and - // the iteration ends. The breach stays on the record and in the - // run summary, the notification is skipped at a NAMED gate, and - // the run survives. ⛔ No hard failure, no fallback recipient, no - // manager-chain dot-walk. - id: "check_assigned", - type: "decision", - label: "Escalation Found an Owner?" - }, - { - // Owner only: `{currentCase.owner_id.manager}` cannot traverse a - // lookup in flow templates — it interpolates to the literal - // "undefined" (cf. case_escalation / opportunity_won_alert). - // - // Reached from BOTH gates, and the whole template reads - // `currentCase` either way: on the owned branch that is the row - // `query_breached` bound, on the ownerless branch the row - // `reload_case` re-bound. One node, one wording, one recipient - // rule — a second notify node would be the same alert authored - // twice, free to drift on the half nobody is looking at. - // - // ⚠️ THE RECIPIENT IS RULED, NOT INCIDENTAL — #1535, maintainer - // ruling 2026-09-07, option A. On a breached - // case that ALREADY HAS AN OWNER, `flag_breach` writes - // `status: 'escalated'` and `case_escalation_reassign` hands the - // case to the least-loaded `service_manager` inside that same - // write — yet this node addresses `currentCase` as - // `query_breached` bound it, BEFORE the hand-off. So the breach - // alert deliberately reaches the agent the case is being taken - // FROM, not the manager who now owns it. - // - // It is the SAME etiquette `case_escalation` already states in - // `content/docs/service/sla-and-escalation.mdx` — "the - // notification goes to the previous owner alone" — and that page - // now states it for this sweep too. One escalation etiquette - // across both mechanisms. - // - // ⛔ Do not "fix" this into an alert for the new owner. That is - // option C, and it would have to re-rule `case_escalation` in the - // same stroke — ⛔ never one mechanism only. - // - // `test/flow-sla-ownerless-assignment.test.ts` pins the pairing - // (the owned breach IS handed over AND its alert still goes to - // the pre-hand-off owner), and records the ruling's declared gap - // as measured: the hand-off hook issues no notice of its own, so - // the receiving manager is told nothing by this run. - id: "notify_team", - type: "notify", - label: "Alert Owner", - config: { - // Owner only — `{currentCase.owner_id.manager}` dot-walks a - // lookup, which flow templates interpolate as "undefined". - recipients: [cel4`currentCase.owner_id`], - channels: ["inbox", "email"], - severity: "critical", - topic: "case_sla_breach", - template: "crm.case_sla_breach", - templateData: { - case_number: cel4`currentCase.case_number`, - priority: cel4`currentCase.priority` - }, - actionUrl: "/crm_case/{{currentCase.id}}" - } - } - ], - edges: [ - { id: "b1", source: "flag_breach", target: "check_owner", type: "default" }, - // The two out-edges of `check_owner` are an exact PARTITION of the - // cases where `currentCase` is bound (see {@link CASE_HAS_OWNER} / - // {@link CASE_HAS_NO_OWNER}) — never a `default` edge alongside a - // conditional one, which would traverse BOTH and notify twice. - // - // ⚠️ The owned branch reads `currentCase` as `query_breached` bound - // it, deliberately: a case that already had an - // owner keeps alerting THAT owner, which is what the sweep has - // always done. ⚠️ That is RULED intent now, no longer an open - // question — the `notify_team` node carries the ruling. - { id: "b2", source: "check_owner", target: "notify_team", type: "conditional", condition: CASE_HAS_OWNER(), label: "Has owner" }, - { id: "b3", source: "check_owner", target: "reload_case", type: "conditional", condition: CASE_HAS_NO_OWNER(), label: "No owner \u2014 re-read after escalation" }, - { id: "b4", source: "reload_case", target: "check_assigned", type: "default" }, - // Both branches converge on the ONE notify node, which is why the - // re-read re-binds `currentCase` rather than a second variable: the - // recipient, the title, the message and the action URL are authored - // once and cannot drift into two versions of the same alert. - // - // A gate with no matching edge simply ends the iteration, so an - // ownerless case the pool could not place is skipped and the loop - // moves on to the next breached case — the run survives, which is - // the property this flow was repaired for. - { id: "b5", source: "check_assigned", target: "notify_team", type: "conditional", condition: CASE_HAS_OWNER(), label: "Escalation assigned an owner" } - ] - }) - } - }, - { id: "end", type: "end", label: "End" } - ], - edges: [ - { id: "e1", source: "start", target: "query_breached", type: "default" }, - { id: "e2", source: "query_breached", target: "loop_cases", type: "default" }, - { id: "e3", source: "loop_cases", target: "end", type: "default" } - ] -}; - -// src/service/objects/article_feedback.hook.ts -var articleFeedbackMetricsRefresh = { - name: "article_feedback_metrics_refresh", - object: "crm_article_feedback", - events: ["afterInsert", "afterUpdate", "afterDelete"], - priority: 800, - async: true, - onError: "log", - runAs: "system", - description: "Recount an article\u2019s helpful / not-helpful votes from crm_article_feedback.", - handler: async (ctx) => { - const api = ctx.api; - if (!api) return; - const { input } = ctx; - const previous = ctx.previous; - const articleIds = Array.from(new Set([ - typeof input?.crm_knowledge_article === "string" ? input.crm_knowledge_article : "", - typeof previous?.crm_knowledge_article === "string" ? previous.crm_knowledge_article : "" - ].filter(Boolean))); - for (const id of articleIds) { - const helpful = await api.object("crm_article_feedback").count({ - where: { crm_knowledge_article: id, verdict: "helpful" } - }); - const notHelpful = await api.object("crm_article_feedback").count({ - where: { crm_knowledge_article: id, verdict: "not_helpful" } - }); - await api.object("crm_knowledge_article").update({ - id, - helpful_count: helpful, - not_helpful_count: notHelpful - }, { where: { id } }); - } - } -}; -var article_feedback_hook_default = [articleFeedbackMetricsRefresh]; - -// src/service/objects/case.hook.ts -var caseValidation = { - name: "case_sla_defaults", - object: "crm_case", - events: ["beforeInsert", "beforeUpdate"], - priority: 200, - description: "Apply the priority \xD7 account-tier SLA matrix and the case lifecycle defaults.", - handler: async (ctx) => { - if (ctx.event === "beforeUpdate" && ctx.dispatch?.mode === "per-row") return; - const { input } = ctx; - const api = ctx.api; - const isGuestSubmission = !ctx.previous && !ctx.user?.id && !ctx.session?.isSystem; - if (isGuestSubmission) { - if (!input.origin) input.origin = "web"; - if (!input.status) input.status = "new"; - input.owner_id = null; - input.is_escalated = false; - input.escalation_reason = null; - input.internal_notes = null; - input.resolution = null; - } - const priority = typeof input.priority === "string" && input.priority || typeof ctx.previous?.priority === "string" && ctx.previous.priority || void 0; - if (priority) { - const rank = { low: 1, medium: 2, high: 3, critical: 4 }; - input.priority_rank = rank[priority] ?? 0; - } - if (priority && !input.sla_due_date && !ctx.previous?.sla_due_date) { - const slaCalendarHours = { - critical: { strategic: 4, enterprise: 4, mid_market: 4, smb: 4 }, - high: { strategic: 6, enterprise: 8, mid_market: 8, smb: 8 }, - medium: { strategic: 24, enterprise: 36, mid_market: 48, smb: 48 }, - low: { strategic: 96, enterprise: 120, mid_market: 168, smb: 168 } - }; - const DEFAULT_TIER = "smb"; - const row = slaCalendarHours[priority]; - if (row) { - let tier = DEFAULT_TIER; - const variesByTier = row.strategic !== row.enterprise || row.enterprise !== row.mid_market || row.mid_market !== row.smb; - const accountId = typeof input.crm_account === "string" && input.crm_account || typeof ctx.previous?.crm_account === "string" && ctx.previous.crm_account || void 0; - if (variesByTier && accountId && api) { - try { - const found = await api.object("crm_account").find({ - where: { id: accountId }, - fields: ["tier"], - top: 1 - }); - const rows = Array.isArray(found) ? found : []; - const stored = rows.length ? rows[0].tier : void 0; - if (typeof stored === "string" && stored) tier = stored; - } catch { - } - } - const hours = row[tier] ?? row[DEFAULT_TIER]; - input.sla_due_date = new Date(Date.now() + hours * 36e5).toISOString(); - } - } - const effStatus = typeof input.status === "string" && input.status || typeof ctx.previous?.status === "string" && ctx.previous.status || void 0; - if (typeof effStatus === "string") input.is_closed = effStatus === "closed"; - if (!isGuestSubmission) { - const becameClosed = input.status === "closed" && ctx.previous?.status !== "closed"; - if (becameClosed && !input.closed_date && !ctx.previous?.closed_date) { - input.closed_date = (/* @__PURE__ */ new Date()).toISOString(); - } - const closedDate = typeof input.closed_date === "string" && input.closed_date || typeof ctx.previous?.closed_date === "string" && ctx.previous.closed_date || void 0; - const createdDate = typeof input.created_at === "string" && input.created_at || typeof ctx.previous?.created_at === "string" && ctx.previous.created_at || void 0; - if (closedDate && createdDate) { - const hrs = (new Date(closedDate).getTime() - new Date(createdDate).getTime()) / 36e5; - if (Number.isFinite(hrs) && hrs >= 0) input.resolution_time_hours = Math.round(hrs * 10) / 10; - } - const settledStatuses = ["resolved", "closed"]; - if (settledStatuses.includes(String(effStatus)) && !settledStatuses.includes(String(ctx.previous?.status))) { - const due = input.sla_due_date !== void 0 ? input.sla_due_date : ctx.previous?.sla_due_date; - const stoppedAt = typeof input.closed_date === "string" && input.closed_date || (/* @__PURE__ */ new Date()).toISOString(); - if (typeof due === "string" && Date.parse(due) < Date.parse(stoppedAt)) input.is_sla_violated = true; - } - } - } -}; -var caseSideEffects = { - name: "case_status_side_effects", - object: "crm_case", - events: ["afterUpdate"], - priority: 800, - async: true, - onError: "log", - description: "Open the escalation follow-up task for the account owner.", - handler: async (ctx) => { - const { input } = ctx; - const previous = ctx.previous; - if (!previous) return; - const api = ctx.api; - if (!api) return; - const caseId = typeof input.id === "string" && input.id || (typeof previous.id === "string" ? previous.id : void 0); - const accountId = typeof input.crm_account === "string" && input.crm_account || typeof previous.crm_account === "string" && previous.crm_account || void 0; - if (input.status === "escalated" && previous.status !== "escalated" && accountId) { - const account = await api.object("crm_account").findOne({ where: { id: accountId } }); - const ownerId = account?.owner_id ?? ctx.user?.id; - const due = /* @__PURE__ */ new Date(); - due.setUTCDate(due.getUTCDate() + 1); - const caseNumber = typeof previous.case_number === "string" ? previous.case_number.trim() : ""; - const caseSubject = typeof input.subject === "string" && input.subject.trim() || typeof previous.subject === "string" && previous.subject.trim() || ""; - const label = [caseNumber, caseSubject].filter(Boolean).join(" \xB7 "); - const titled = label ? `Escalated: ${label}` : "Escalated case needs attention"; - await api.object("crm_task").insert({ - subject: titled.length > 255 ? `${titled.slice(0, 254)}\u2026` : titled, - status: "not_started", - priority: "urgent", - type: "follow_up", - due_date: due.toISOString().slice(0, 10), - owner_id: ownerId, - related_to_type: "crm_case", - related_to_case: caseId, - related_to_account: accountId - }); - } - } -}; -var caseResolutionAccountActivity = { - name: "case_resolution_account_activity", - object: "crm_case", - events: ["afterUpdate"], - priority: 800, - async: true, - onError: "log", - runAs: "system", - description: "Bump the account\u2019s last activity date when a case is resolved.", - handler: async (ctx) => { - const { input } = ctx; - const previous = ctx.previous; - if (!previous) return; - if (input.status !== "resolved" || previous.status === "resolved") return; - const api = ctx.api; - if (!api) return; - const accountId = typeof input.crm_account === "string" && input.crm_account || typeof previous.crm_account === "string" && previous.crm_account || void 0; - if (!accountId) return; - await api.object("crm_account").update( - { id: accountId, last_activity_date: (/* @__PURE__ */ new Date()).toISOString().slice(0, 10) }, - { where: { id: accountId } } - ); - } -}; -var caseAutoAssign = createCaseRoundRobinAssign(); -var caseEscalationReassign = createCaseEscalationReassign(); -var caseSelfClaim = createCaseSelfClaim(); -var caseResolutionArticleNormalize = { - name: "case_resolution_article_normalize", - object: "crm_case", - events: ["beforeInsert", "beforeUpdate"], - priority: 150, - description: "Normalise a blank resolved_by_article to null so the deflection measure counts only real links.", - handler: async (ctx) => { - const { input } = ctx; - if (!("resolved_by_article" in input)) return; - const value = input.resolved_by_article; - if (value === "" || value === void 0) { - input.resolved_by_article = null; - return; - } - if (typeof value === "string" && value.trim() === "") { - input.resolved_by_article = null; - } - } -}; -var case_hook_default = [ - caseValidation, - caseAutoAssign, - caseEscalationReassign, - caseSelfClaim, - caseResolutionArticleNormalize, - caseSideEffects, - caseResolutionAccountActivity -]; - -// src/service/objects/knowledge_article.hook.ts -var knowledgeArticlePublish = { - name: "knowledge_article_publish_timestamps", - object: "crm_knowledge_article", - events: ["beforeInsert", "beforeUpdate"], - priority: 300, - description: "Stamp published_at on the first publish; refresh last_reviewed_at while published.", - handler: async (ctx) => { - if (ctx.event === "beforeUpdate" && ctx.dispatch?.mode === "per-row") return; - const { input } = ctx; - const previous = ctx.previous; - const nextStatus = typeof input.status === "string" && input.status || previous?.status; - if (nextStatus !== "published") return; - const nowIso = (/* @__PURE__ */ new Date()).toISOString(); - input.last_reviewed_at = nowIso; - const existing = input.published_at ?? previous?.published_at; - if (existing === void 0 || existing === null || existing === "") { - input.published_at = nowIso; - } - } -}; -var knowledge_article_hook_default = knowledgeArticlePublish; - -// src/service/pages/case_detail.page.ts -var CaseDetailPage = { - name: "case_detail_page", - label: "Case Detail", - description: "Service-agent case record: highlights, SLA path, details and activity timeline.", - type: "record", - object: "crm_case", - template: "full-width", - kind: "full", - variables: [ - { name: "activeTab", type: "string", defaultValue: "details" } - ], - regions: [ - { - name: "header", - width: "full", - components: [ - { - type: "page:header", - id: "case_header", - label: "Case Information", - properties: { - title: "{case_number} \xB7 {subject}", - // The lookup field is `crm_account` — `{account}` matched nothing - // and the subtitle rendered blank. - subtitle: "{crm_account}", - // `icon` removed from `page:header` in @objectstack/spec 17.0.0 - // (#6946, ADR-0087 D2) — deleted, not renamed. See the full note on - // `account_detail.page.ts`; nothing ever drew it. - // `breadcrumb` retired from `page:header` in @objectstack/spec 17.6.0 - // (#20785, `page-header-breadcrumb-removed`) — deleted: no renderer - // ever drew a trail for it; the app shell's own trail is unchanged. - // Action IDs, not `ActionDef` objects: `PageHeaderProps.actions` is - // `z.array(z.string())` ("Action IDs to show in header") in - // @objectstack/spec 17.3.0, and this repo authors against the - // protocol (#1653). Each id is the `name` of a crm_case-scoped - // action — `claim_case` / `escalate_case` / `close_case` in - // `src/service/actions/case.actions.ts`, the activity trio in - // `src/service/actions/case-activity.actions.ts`. - // - // This list is the whole header (#2072, the #592 sentence on - // `lead_detail.page.ts`): an action it does not name is reachable - // only from the list row's ⋮ menu, which is how an agent on an - // unowned case had to go back to the list to claim it, and could - // not log or book a meeting here at all. Each action's own - // `visible` still decides when it shows — `claim_case` only on an - // ownerless open case. `claim_case` goes FIRST because the header - // draws three buttons inline and folds the rest into ⋯: on an - // ownerless case claiming is the gesture, and on an owned one it - // is hidden, so the inline three stay escalate / close / call. - // `test/action-references.test.ts` holds this list to every - // crm_case action placed at `record_header`. - actions: ["claim_case", "escalate_case", "close_case", "log_call", "log_meeting", "schedule_meeting"] - } - }, - { - type: "record:highlights", - id: "case_highlights", - label: "Key Information", - properties: { - // crm_case carries a single `sla_due_date` plus the derived - // `is_sla_violated` flag — the split response/resolution deadlines - // named here do not exist, so the agent's most time-critical fact - // was missing from the strip entirely. - fields: [ - "status", - "priority", - "sla_due_date", - "is_sla_violated", - "owner_id", - "crm_account" - ] - } - }, - { - type: "record:path", - id: "case_status_path", - label: "Case Status Path", - properties: { - statusField: "status", - stages: [ - { value: "new", label: "New" }, - { value: "in_progress", label: "In Progress" }, - // The status option is `waiting_customer`; the longer spelling - // matched no option, so this stage never lit up and rendered - // untranslated next to its neighbours. - { value: "waiting_customer", label: "Waiting on Customer" }, - { value: "escalated", label: "Escalated" }, - { value: "resolved", label: "Resolved" }, - { value: "closed", label: "Closed" } - ] - } - } - ] - }, - { - name: "main", - width: "large", - components: [ - { - type: "page:tabs", - id: "case_main_tabs", - properties: { - // `type` → `tabStyle` (@objectstack/spec 17.0.0, #6776, ADR-0087 - // D2). Same concept, same three values (`line` | `card` | `pill`); - // the rename exists because a props key called `type` collides with - // the component node's own dispatch key and is unauthorable in the - // flat and JSX carriers. See the full note on `home.page.ts`. - tabStyle: "line", - position: "top", - items: [ - { - // Tab item `key` → `value` (#1269). `value` is the stable - // `?tab=` URL token the renderer reads (`it.value`, falling back - // to an index-derived `tab-`); `key` is read by nothing, so - // these tabs were addressable only as `tab-0`/`tab-1`/`tab-2`, - // which point at different tabs the moment the item list - // changes. `PageTabsProps`' own alias table answers `key` with - // `value` for exactly this reason. - value: "details", - label: "Details", - children: [ - { - type: "record:details", - id: "case_details", - label: "Case Details", - properties: { - // `columns` is a STRING enum ('1'|'2'|'3'|'4') in - // @objectstack/spec 17, and `layout` was removed there - // (#6946 / ADR-0087 D2). - columns: "2", - // Every section references one of crm_case's `fieldGroups` - // (#970, the #806 class ruling C): the renderer derives - // members, label, icon and collapse state from the object, - // so this page curates only the order. The full note — - // what a group section does on 17.6.0 and what may not sit - // beside `group` — is on `lead_detail.page.ts`. - // - // The highlights strip still wins (#1211): the renderer - // drops what `record:highlights` registered (`status`, - // `priority`, `sla_due_date`, `is_sla_violated`, - // `owner_id`, `crm_account`) and the title candidate - // `subject` from the derived members. - // - // `escalated_date` — written by three flows and shown - // nowhere until now (#970) — arrives with the `escalation` - // group, beside `is_escalated` and `escalation_reason`. - // - // `internal_notes` (#1428) is in the `system` group with - // `is_closed`. A group whose members are ALL empty renders - // nothing, but a boolean always holds a value, so `system` - // renders on every case and an unwritten `internal_notes` - // stays reachable the way every empty field here is: the - // section's "Show N empty fields" toggle, then inline edit. - // ⛔ Not the create form — `/new` and edit both resolve - // `view.form`, and `case.hook.ts` nulls the column for - // anonymous web-to-case submissions. - // - // `resolution` / `resolved_by_article` render once the case - // carries one; `close_case` is the flow that collects the - // resolution. - // - // `hideEmpty: false` (#2003, the #1211 reasoning) only on - // `origin`: with `owner_id` in the strip, its one member is - // the channel an agent picks, and without the key the - // section vanishes on a new case. Not on `sla`: outside - // the strip its members are stamps no one types - // (`closed_date` and `resolution_time_hours` at close, - // `first_response_date` by `event.hook.ts`), so the key - // would draw empty rows to look at, not to fill. - sections: [ - { group: "basic" }, - { group: "origin", hideEmpty: false }, - { group: "sla" }, - { group: "escalation" }, - { group: "resolution" }, - { group: "system" } - ] - } - } - ] - }, - { - value: "related", - label: "Related", - children: [ - { - type: "page:accordion", - id: "case_related_accordion", - properties: { - items: [ - { - // An accordion item `key` is DELETED, not renamed to - // `value` — the opposite verdict to the tab items - // above, and the difference is a read point (#1269). - // `PageAccordionProps`' item shape is - // `{ label, icon?, collapsed?, children }` and it - // prescribes AGAINST `value` by name: the renderer - // maps every item to `{ ...it, value: `panel-` }` - // before rendering, so an authored value is - // overwritten. `page:tabs` really does read `it.value`; - // `page:accordion` does not. Nothing addresses these - // panels, so the identifier has nowhere to land. - label: "Open Tasks", - children: [ - { - type: "record:related_list", - id: "case_tasks", - properties: { - objectName: "crm_task", - relationshipField: "related_to_case", - columns: [ - "subject", - "status", - "priority", - "due_date", - "owner_id" - ], - filter: [ - { field: "status", operator: "not_equals", value: "completed" } - ], - limit: 10 - } - } - ] - } - ] - } - } - ] - }, - { - value: "activity", - label: "Activity", - children: [ - { - type: "record:activity", - id: "case_activity", - properties: { - filterMode: "all", - showFilterToggle: true, - limit: 25, - unifiedTimeline: true, - showCommentInput: true, - enableMentions: true, - enableReactions: true, - enableThreading: true, - // Load-bearing (#2071): a call or meeting logged on the - // case is a `sys_activity` row of type `completed` (the - // `task` feed kind), and the renderer drops every such - // row unless this is true — so an agent's logged call - // never reached this tab. The case's other `completed` - // writers are its own `resolved` / `closed` milestones - // (`case.object.ts`), which belong on this timeline too. - // Completed crm_task rows do NOT arrive here: a task's - // audit rows are keyed to the task, and this feed reads - // only rows keyed to the case. No `types` filter, unlike - // the lead page: this timeline mixes comments and field - // changes on purpose (`unifiedTimeline` above). - showCompleted: true - } - } - ] - } - ] - } - } - ] - } - ], - isDefault: true, - aria: { - ariaLabel: "Case Detail Page", - ariaDescribedBy: "Service-agent case detail view with SLA path, details, related items and activity timeline." - } -}; - -// src/service/reports/case.report.ts -var CasesByStatusPriorityReport = { - name: "cases_by_status_priority", - label: "Cases by Status and Priority", - description: "Summary of cases by status and priority", - // The chart counts cases, so `case_count` must be selected alongside the - // resolution time — and the yAxis must name that MEASURE ('case_number' - // was a raw-field name that exists in no dataset, so the axis was empty). - dataset: "case_metrics", - rows: ["status", "priority"], - values: ["case_count", "avg_resolution"], - type: "summary", - chart: { type: "bar", title: "Cases by Status", showLegend: true, xAxis: "status", yAxis: "case_count" } -}; -var SlaPerformanceReport = { - name: "sla_performance", - label: "SLA Performance Report", - description: "Analysis of SLA compliance", - // 'avg_sla_violated' (not a duplicated 'case_count') — the table showed two - // identical Cases columns and no violation measure; the chart's yAxis must - // name a dataset MEASURE, not a raw field ('is_sla_violated' leaked the - // column name onto the axis). - dataset: "case_metrics", - rows: ["priority"], - values: ["case_count", "avg_sla_violated", "avg_resolution"], - type: "summary", - runtimeFilter: { is_closed: true }, - chart: { type: "column", title: "SLA Violations by Priority", showLegend: false, xAxis: "priority", yAxis: "avg_sla_violated" } -}; -var CasesOpenedByDayPriorityReport = { - name: "cases_opened_by_day_priority", - label: "Cases Opened by Priority \xD7 Day", - description: "Daily case inflow split by priority", - dataset: "case_metrics", - rows: ["priority"], - columns: ["created_at"], - values: ["case_count"], - type: "matrix" -}; - -// src/service/sharing/case.sharing.ts -import { P as P12 } from "@objectstack/spec"; -var CaseEscalationSharingRule = { - name: "case_escalation_sharing", - label: "Escalated Cases Sharing", - object: "crm_case", - type: "criteria", - condition: P12`record.priority == "critical" && record.is_closed == false`, - accessLevel: "edit", - sharedWith: { type: "position", value: "service_manager" } -}; -var CaseDirectorSharingRule = { - name: "case_director_sharing", - label: "Escalated Cases \u2014 Service Director", - object: "crm_case", - type: "criteria", - condition: P12`record.priority == "critical" && record.is_closed == false`, - accessLevel: "read", - sharedWith: { type: "position", value: "service_director" } -}; -var CaseUnassignedTriageSharingRule = { - name: "case_unassigned_triage_sharing", - label: "Unassigned Cases \u2014 Triage", - object: "crm_case", - type: "criteria", - condition: P12`record.owner_id == null && record.status != "resolved" && record.status != "closed"`, - accessLevel: "edit", - sharedWith: { type: "position", value: "service_agent" } -}; - -// src/service/skills/case-triage.skill.ts -import { defineSkill } from "@objectstack/spec"; -var CaseTriageSkill = defineSkill({ - name: "case_triage", - label: "Case Triage", - description: "Triages a support case, assigns a priority with its justification, and points at the escalate/close action.", - instructions: `When the user asks to triage, prioritise, or classify a case: - -1. Read the case first \u2014 call \`describe_object\` for \`crm_case\` (the - schema is alive; admins add fields), then \`get_record\` for the case - at hand. Never triage from memory of a previous turn. -2. Assign a priority yourself from what you read. There is no triage - tool and you do not need one \u2014 weigh, in order: customer tier and - contract value, whether the customer is blocked with no workaround, - how long the case has been open against its SLA, and the sentiment - of the latest customer message. -3. State the priority and the ONE reason that drove it. Cite the case - ID and the field values you used. -4. If the priority is critical, say so and point the user at - **Escalate Case** on the record header \u2014 offer a ready-to-paste - \`reason\` built from step 3. You cannot escalate yourself, and should - not imply otherwise. -5. If the case is resolved in substance, point at **Close Case** and - offer a \`resolution\` summary the user can paste. -6. For the customer-facing reply, hand off to the \`email_drafting\` - skill rather than drafting it here.`, - tools: ["describe_object", "get_record"], - triggerConditions: [ - { field: "objectName", operator: "eq", value: "crm_case" } - ] -}); - -// src/service/views/case.view.ts -import { defineView } from "@objectstack/spec/ui"; -var data = { provider: "object", object: "crm_case" }; -var CaseViews = defineView({ - list: { - type: "grid", - name: "all_cases", - label: "All Cases", - userActions: { editInline: true }, - data, - columns: [ - { field: "case_number", width: 130, sortable: true, link: true, pinned: "left" }, - { field: "subject", width: 280, sortable: true }, - { field: "crm_account", width: 180 }, - { field: "crm_contact", width: 160 }, - { field: "priority", width: 110, sortable: true }, - { field: "status", width: 130, sortable: true }, - { field: "origin", width: 120 }, - { field: "sla_due_date", width: 160, sortable: true }, - { field: "is_sla_violated", width: 110, align: "center" }, - { field: "is_escalated", width: 110, align: "center" }, - { field: "owner_id", width: 150 } - ], - // Sort on the materialised ordinal, not the select itself: `priority desc` - // compares raw strings and lands medium > low > high > critical, burying - // every critical case at the bottom of the queue. - sort: [ - { field: "priority_rank", order: "desc" }, - { field: "sla_due_date", order: "asc" } - ], - rowColor: { - field: "priority", - colors: { critical: "red", high: "orange", medium: "yellow", low: "slate" } - }, - selection: { type: "multiple" }, - pagination: { pageSize: 50 }, - // The UI door for the `allowExport` grant four profiles already hold on - // `crm_case`. Export runs on ONE server-side route - // (`GET /api/v1/data/crm_case/export`, gated by `security.canExport`), so - // this declares which formats the toolbar offers — not a second gate: a - // profile without the grant gets 403 whether it clicks the button or - // curls the route. Measured in #798/#816; before this the grant was live - // but reachable only by `curl`. - exportOptions: { formats: ["csv", "xlsx"] }, - appearance: { - showDescription: true, - allowedVisualizations: ["grid", "kanban", "calendar", "timeline"] - }, - // Binds the 'calendar' entry above: the switcher opens the same deadlines - // the dedicated `sla_calendar` view shows, on the field this list already - // sorts by. `sla_due_date` is optional — a case the SLA monitor has not - // stamped carries no date at all, which is the truthful answer; the - // alternative the platform refuses is a guessed field putting every such - // case on today. - calendar: { - startDateField: "sla_due_date", - titleField: "subject", - colorField: "priority" - } - // Escalate straight from the queue: escalate_case's own - // `locations: ['list_item']` auto-injects the row-menu item. - }, - listViews: { - /** Service workflow board */ - case_workflow: { - name: "case_workflow", - type: "kanban", - label: "Service Workflow", - data, - columns: ["case_number", "subject", "priority", "sla_due_date"], - kanban: { - groupByField: "status", - columns: ["case_number", "subject", "crm_account", "priority", "owner_id"] - }, - filter: [{ field: "is_closed", operator: "equals", value: false }], - navigation: { mode: "drawer", width: "640px" } - }, - /** SLA calendar */ - sla_calendar: { - name: "sla_calendar", - type: "calendar", - label: "SLA Calendar", - data, - columns: ["case_number", "subject", "priority"], - calendar: { - startDateField: "sla_due_date", - titleField: "subject", - colorField: "priority" - } - }, - /** Chronological case stream */ - case_timeline: { - name: "case_timeline", - type: "timeline", - label: "Case Timeline", - data, - columns: ["case_number", "subject"], - timeline: { - // `created_at`, the platform's own creation stamp — the object's - // duplicate `created_date` was removed in #1992 because nothing wrote - // it on a real case, so every user-created case started its bar at - // null. Same spelling as `deal_timeline` on crm_opportunity (#575 B2). - startDateField: "created_at", - endDateField: "closed_date", - titleField: "subject", - groupByField: "owner_id", - colorField: "status", - scale: "day" - } - }, - /** - * The agent's personal queue: the cases themselves, one row each. Its - * aggregate counterpart is service_dashboard's "My Open Cases by - * Priority" (#510) — a dashboard widget counts, it cannot list. - */ - my_open_cases: { - name: "my_open_cases", - type: "grid", - label: "My Open Cases", - userActions: { editInline: true }, - data, - columns: ["case_number", "subject", "crm_account", "priority", "status", "sla_due_date"], - // ⚠️ `status not_in CLOSED_CASE_STATUSES`, NOT `is_closed == false`: the - // flag is derived as `effStatus === 'closed'` and never flips on - // `resolved`, so the flag spelling listed every RESOLVED case under a tab - // labelled "My Open Cases" — measured on the seeded demo population, the - // flag returned 30 of 38 cases and 7 of those 30 were resolved. A resolved - // case is finished work awaiting closure, not an open queue, and the - // mainstream service-cloud reading of "open" excludes it (Zendesk's open - // set omits Solved; ServiceNow's OOTB Open filter is - // `state not in (Resolved, Closed, Cancelled)`). Ruled 2026-08-31; pinned by - // `test/live-work-predicate-parity.test.ts` (#1145), whose consumer roster - // this view joined in the same change. - filter: [ - { field: "owner_id", operator: "equals", value: "{current_user_id}" }, - { field: "status", operator: "not_in", value: ["resolved", "closed"] } - ], - sort: [ - { field: "priority_rank", order: "desc" }, - { field: "sla_due_date", order: "asc" } - ] - }, - /** - * Unassigned — triage (#596). The second half of the queue substitute. - * - * `case_auto_assign` (`src/service/objects/_case-assignment.ts`) is a NO-OP whenever - * the `service_agent` pool is empty, and an empty pool is the FIRST-INSTALL - * NORM rather than an edge case: `sys_user_position` membership is runtime - * data, so on a fresh org — and any time every agent has been unassigned - * from the position — an inbound web-to-case lands ownerless. Best-effort - * assignment also stands down on a permission denial (the anonymous - * public-form context cannot read `sys_user_position` at all). - * - * Those cases used to be invisible: no view filtered on the absence of an - * owner, so an unowned case appeared in `All Cases` with a blank Owner - * column and nothing distinguished it from the rest. This view is the - * standing answer — silence replaced by a pinned tab whose row count IS the - * intake backlog. - * - * `is_null` on `owner_id`, not `equals: null`: the ownerless shape is an - * ABSENT column on driver-memory (see the totality note in - * `case-escalation.flow.ts`, where `record.escalated_date == null` aborted - * with `No such key`) as well as a NULL one on SQL, and only the operator - * form answers the same way for both. - * - * The predicate for "no longer live work" is `status not_in ['resolved', - * 'closed']`, NOT `is_closed == false`. `is_closed` is derived by - * `case_sla_defaults` as `effStatus === 'closed'`, so it never flips on - * `resolved` — and a resolved ownerless case satisfied both of this view's - * old filters and sat here forever, which is neither "arrives with no - * owner" nor "work waiting for a human". `not_in` lowers to the `$nin` the - * load-balancing hooks and `case_sla_monitor` already use for the same - * concept, so the four consumers now state one predicate; the roster that - * holds them together by NAME is `test/live-work-predicate-parity.test.ts`. - * `closed` stays excluded for the reason it always was: history, not - * backlog. - * - * ⚠️ WHO ACTUALLY SEES ROWS HERE is decided by record-level access, not by - * this view, and the answer today is narrower than the tab suggests. A - * view tab carries no role scoping — `ViewTabSchema` has `pinned`, - * `isDefault` and a boolean `visible`, and nothing per-profile — so this is - * pinned for everyone who can open Cases, while the ROWS resolve per - * profile: - * - * - `system_admin` — `viewAllRecords`, so the full backlog. This is the - * persona the empty-pool state is FOR: an empty `service_agent` pool is - * fixed by staffing `sys_user_position`, which only an admin can do. - * - `sales_manager` — `viewAllRecords`, read-only. - * - a service manager / director — the critical, open slice only, via the - * existing `case_escalation_sharing` / `case_director_sharing` criteria - * rules (`src/service/sharing/case.sharing.ts`). - * - `service_agent` — `readScope: 'own'` on `crm_case`, and an unowned - * row is owned by nobody, so **an agent's triage tab is empty**. - * - * The last line is a real gap for the "agent pulls from the queue" story - * and is deliberately NOT closed here: granting service roles sight of - * unowned cases is a sharing-model change (a new criteria rule, or a - * `readScope` widening), which is outside this card's file surface and is - * exactly the kind of quiet permission widening the #596 ruling rules out. - * Filed as #1096 for a decision, with the reach table above and the three - * options priced. - */ - unassigned_triage: { - name: "unassigned_triage", - type: "grid", - label: "Unassigned \u2014 triage", - userActions: { editInline: true }, - data, - columns: ["case_number", "subject", "crm_account", "crm_contact", "priority", "status", "origin", "sla_due_date"], - filter: [ - { field: "owner_id", operator: "is_null" }, - { field: "status", operator: "not_in", value: ["resolved", "closed"] } - ], - // Same ordering as the main queue: urgency first (on the materialised - // ordinal, never the raw select), then soonest deadline. - sort: [ - { field: "priority_rank", order: "desc" }, - { field: "sla_due_date", order: "asc" } - ], - rowColor: { - field: "priority", - colors: { critical: "red", high: "orange", medium: "yellow", low: "slate" } - }, - // The empty state carries the operational instruction, because "no rows" - // here is ambiguous on its own: it means either "the round-robin placed - // everything" (good) or "no case has arrived yet" (also fine) — and the - // reader most likely to be looking is someone who just found the tab - // full and needs to know why. - emptyState: { - title: "Nothing waiting for triage", - message: "Every case has an owner. Cases appear here when they arrive with no owner \u2014 typically a web-to-case submission that arrived while nobody held the Service Agent position.", - icon: "inbox" - } - }, - escalated_cases: { - name: "escalated_cases", - type: "grid", - label: "Escalated Cases", - userActions: { editInline: true }, - data, - columns: ["case_number", "subject", "crm_account", "priority", "sla_due_date", "owner_id"], - filter: [{ field: "is_escalated", operator: "equals", value: true }], - sort: [{ field: "priority_rank", order: "desc" }] - }, - /** - * SLA-at-risk: open cases at High or Critical priority needing attention. - * - * ⚠️ Names what the filter below actually selects. This read - * "high/urgent" until #1333 — but `crm_case.priority` is - * low/medium/high/critical (`case.object.ts:138-142`) and has NO `urgent`; - * that value belongs to `crm_task`. The mirror-image crossing already - * shipped a real defect once (`task.view.ts:35` — Case colour keys on the - * task view left every urgent and normal row uncoloured), and the - * direction that cost something was the one where the comment was - * believed. Two overlapping-but-unequal vocabularies: keep them apart. - */ - sla_at_risk: { - name: "sla_at_risk", - type: "grid", - label: "\u23F0 SLA at Risk", - userActions: { editInline: true }, - data, - columns: ["case_number", "subject", "crm_account", "priority", "sla_due_date", "owner_id"], - // Operator-only filter — sort by SLA due date ascending so the soonest - // surface first. (The view runtime does not interpolate `{NOW() + 4h}`.) - // - // ⚠️ `status not_in CLOSED_CASE_STATUSES`, NOT `is_closed == false`: the - // flag is derived as `effStatus === 'closed'` and never flips on - // `resolved`, so the flag spelling listed resolved cases as at risk while - // `case_sla_monitor` — the automation that OWNS SLA — had already - // excluded them (`status: { $nin: ['resolved', 'closed'] }`). The tab a - // human reads and the sweep that acts must answer this one question the - // same way. Pinned by `test/live-work-predicate-parity.test.ts` (#1145). - filter: [ - { field: "status", operator: "not_in", value: ["resolved", "closed"] }, - { field: "priority", operator: "in", value: ["high", "critical"] } - ], - sort: [{ field: "sla_due_date", order: "asc" }] - } - }, - /** - * The record form — and, because the platform has ONE, the CREATE form too. - * - * ## ⚠️ This object's `form` IS the create dialog (#1214 item 3) - * - * Measured against the console this app shipped at that taking - * (`@objectstack/console` 17.1.0, `dist/assets/`; this bundle read was ⛔ NOT - * re-taken on any later pin), BOTH - * entry points that open a case form resolve - * it the same way and neither takes a create/edit argument: - * - * RecordFormPage (`/{object}/new`, `/{object}/record/{id}/edit`) - * view.form ?? view.formViews?.default - * useActionModal (the `+ New` modal off a list view) - * view.form ?? view.formViews?.default - * - * ⇒ There is no create-only form to author. `ListViewSchema.addRecord` - * carries a `formView` key in `@objectstack/spec`, but NO console code path - * reads it (the string appears only in the view designer's own i18n table), - * so pointing it at a second form view would ship an ADR-0049 - * declared-but-unenforced shape and change nothing on screen. - * - * ⇒ Therefore the create-safe field set has to BE this form's field set. - * That is why the SLA and Resolution sections are gone rather than gated. - * - * ## ⛔ Why the tab strip was not the object's `fieldGroups` - * - * `crm_case.fieldGroups` declares SIX groups (Case Information / Origin & - * Routing / SLA & Priority / Resolution / Escalation / System) and the - * dialog showed THREE tabs — these sections. The renderer only reaches for - * `fieldGroups` on its AUTO-DERIVED path, taken when a form authors no - * `sections` at all; an authored `sections` array wins outright. So - * `src/service/objects/case.object.ts` is not part of this surface. - * - * ## ⚠️ Authoring `sections` OPTS OUT of the create-mode field strip - * - * That auto-derived path also runs two filters the authored path never sees - * (`plugin-form`: `Qe` → `qe` drops `readonly`/`hidden` fields, and on - * `mode === 'create'` `Je` additionally drops formula / summary / autonumber - * fields). An authored section renders its list VERBATIM. That is the whole - * mechanism behind this defect: the platform would have hidden - * `created_date` (retired in #1992), `closed_date`, `resolution_time_hours` - * and `is_closed` from a creator by itself, and naming them in a section put - * them back. - * - * ## ⛔ Why not gate the old sections on a predicate instead - * - * A section-level `visibleWhen` is parsed by `FormSectionSchema` and read by - * NOTHING in the form renderer (only FIELD-level `visibleWhen` is - * evaluated), so it would hide nothing. And field-level predicate evaluation - * FAILS OPEN — an unevaluable predicate renders the field visible, with no - * diagnostic (the house rule at the top of `lead.view.ts`, upstream - * objectstack-ai/objectstack#5149). A gate that fails open is not a gate for - * a data-integrity control, which is what this one is. - * - * ## What a creator may author here, and why the rest left - * - * Everything below is a fact the person raising the case HAS at intake. - * `case_number` stays because it is `readonly: true` on the object, so the - * renderer disables it — it is shown, never authored. - * - * The removed fields are all written by the lifecycle, and every one of them - * still has the surface it belongs on (pinned in - * `test/case-create-form-narrowing.test.ts`, both directions): - * - * closed_date readonly; `case_timeline` end - * (its start is the platform's - * `created_at`; `created_date` was - * retired in #1992) - * sla_due_date `case.hook.ts` stamps it from the - * priority × tier matrix; list column, - * sort key, `sla_calendar.startDateField`, - * detail-page highlights - * first_response_date `event.hook.ts` is its SINGLE writer - * resolution_time_hours readonly; derived at close; detail page - * is_sla_violated list column + detail-page highlights - * is_escalated, escalation_reason written by `case_escalation` / - * `case_sla_monitor` / `escalate_case`; - * detail page's Status & SLA section - * resolution detail page's Description section - * (the `resolution_required_on_close` - * validation still has its surface) - * is_closed readonly; derived from `status` - * - * ⚠️ `internal_notes`, `customer_rating` and `customer_feedback` left with - * the Resolution section and had NO other authoring surface at all. #1428 - * settled both halves of that, and neither answer was "put them back here": - * - * internal_notes `case_detail.page.ts`'s Description - * section, authored by inline edit — - * staff prose an agent writes while - * WORKING a case, which is why it did not - * come back to this form. The guest - * branch of `case.hook.ts` nulls the - * column on anonymous intake, so an - * intake surface for it would be a - * surface for a value the app discards. - * - * customer_rating, RETIRED under ADR-0049 enforce-or-remove - * customer_feedback (maintainer ruling, decision batch #21, - * 2026-09-03). Neither column exists on - * `crm_case` any more, so there is nothing - * here to omit and nothing anywhere to - * author. - * - * ⛔ Do not re-introduce either field, here or elsewhere. The ruling was not - * "no room on this form": a satisfaction score typed by the person being - * scored is not the same fact as one the customer gave, and neither field was - * named in ANY profile's `fields` map — which on this platform means - * unrestricted, not restricted. `case_csat_followup`, whose only purpose was - * to notify the case owner to log a rating, was retired in the same change. - * A customer-answered survey is a feature and would arrive as its own card, - * not as two inputs added back here. - * - * `type: 'simple'`, not `'tabbed'`: one section is not a tab strip. - */ - form: { - type: "simple", - sections: [ - { - name: "case", - label: "Case", - columns: 2, - fields: [ - "case_number", - { field: "subject", required: true, span: "full" }, - { field: "crm_account", required: true }, - "crm_contact", - { field: "status", required: true }, - "priority", - "origin", - "owner_id", - // Required on the object with no default — a form without it could - // never save a new case. - { field: "description", required: true, span: "full" } - ] - } - ] - }, - /** - * Additional named form views. - * - * `web_to_case` is a PUBLIC / ANONYMOUS support form (Salesforce - * Web-to-Case equivalent). Hosted at `/forms/support` and embeddable in - * a help center. Guests can ONLY submit — the `guest_portal` profile - * denies read/edit/delete on `crm_case`. Internal fields (status, origin, - * owner_id, SLA) are stamped by `case.hook.ts` after a guest submission. - * `priority` is NOT one of them: this form asks the guest for it, and an - * unset one is filled by the `low` option `crm_case.priority` declares - * `default: true`. Field defaults are applied before `beforeInsert`, so the - * hook only ever reads `priority` (to derive `priority_rank`). - */ - formViews: { - web_to_case: { - type: "simple", - data, - sections: [ - { - name: "how_can_we_help", - label: "How can we help?", - columns: 1, - fields: [ - { - field: "subject", - required: true, - placeholder: "Short summary of the issue" - }, - { - field: "description", - required: true, - placeholder: "Steps to reproduce, error messages, screenshots..." - }, - { - field: "type", - helpText: "Pick the option that best matches your issue." - }, - { - field: "priority", - helpText: "Critical issues should also be reported via phone." - } - ] - } - ], - sharing: { - enabled: true, - allowAnonymous: true, - publicLink: "/forms/support" - } - } - } -}); - -// src/service/views/knowledge_article.view.ts -import { defineView as defineView2 } from "@objectstack/spec/ui"; -var KnowledgeArticleViews = defineView2({ - list: { - type: "grid", - name: "all_articles", - label: "All Articles", - userActions: { editInline: true }, - data: { provider: "object", object: "crm_knowledge_article" }, - columns: [ - { field: "article_number", width: 120, link: true, pinned: "left", sortable: true }, - { field: "title", width: 320, sortable: true }, - { field: "category", width: 160 }, - { field: "status", width: 130, sortable: true }, - { field: "audience", width: 110 }, - { field: "language", width: 110 }, - { field: "owner_id", width: 150 }, - { field: "published_at", width: 160, sortable: true }, - { field: "helpful_count", width: 110, align: "right", summary: "sum" } - ], - sort: [{ field: "published_at", order: "desc" }], - grouping: { fields: [{ field: "category", order: "asc" }] }, - selection: { type: "multiple" }, - pagination: { pageSize: 50 }, - rowColor: { - field: "status", - colors: { draft: "slate", in_review: "amber", published: "emerald", archived: "gray" } - }, - appearance: { - showDescription: true, - allowedVisualizations: ["grid", "kanban"] - } - }, - listViews: { - published_articles: { - name: "published_articles", - type: "grid", - label: "Published", - userActions: { editInline: true }, - data: { provider: "object", object: "crm_knowledge_article" }, - columns: ["article_number", "title", "category", "audience", "helpful_count", "not_helpful_count", "published_at"], - filter: [{ field: "status", operator: "equals", value: "published" }], - sort: [{ field: "helpful_count", order: "desc" }] - }, - my_drafts: { - name: "my_drafts", - type: "grid", - label: "My Drafts", - userActions: { editInline: true }, - data: { provider: "object", object: "crm_knowledge_article" }, - columns: ["article_number", "title", "category", "status", "updated_at"], - filter: [ - { field: "status", operator: "in", value: ["draft", "in_review"] }, - // `{current_user_id}` is the only user token the view runtime resolves. - { field: "owner_id", operator: "equals", value: "{current_user_id}" } - ], - sort: [{ field: "updated_at", order: "desc" }] - } - }, - form: { - type: "simple", - sections: [ - { - name: "article", - label: "Article", - columns: 2, - fields: [ - "article_number", - { field: "title", required: true, span: "full" }, - { field: "summary", span: "full" }, - "category", - "tags", - "status", - "audience", - "language", - "owner_id" - ] - }, - { - name: "content", - label: "Content", - columns: 1, - fields: ["body"] - }, - { - // `name` alongside `label` (#1100): a form section declaring only a - // label renders its ENGLISH label under every locale, and neither the - // existing i18n tests nor the `i18n/missing-*` gate can see it — the - // heading has no key for a translator to miss. This section is named - // because this change edits it (`view_count` was removed from it, #601); - // the app-wide sweep of the other headings is #1100's job, held behind - // this card precisely so the two do not collide in the locale packs. - name: "engagement", - label: "Engagement", - columns: 3, - fields: ["helpful_count", "not_helpful_count", "published_at", "last_reviewed_at", "related_to_case"] - } - ] - } -}); - -// src/service/index.ts -var serviceHooks = [article_feedback_hook_default, case_hook_default, knowledge_article_hook_default].flat(); -var serviceFlows = [ - CaseEscalationFlow, - CaseEscalationOnCreateFlow, - EscalateCaseFlow, - CloseCaseFlow, - ClaimCaseFlow, - CaseEscalationStampFlow, - CaseSlaMonitorFlow -]; -var serviceSkills = [CaseTriageSkill]; -var serviceSharingRules = [ - CaseEscalationSharingRule, - CaseDirectorSharingRule, - CaseUnassignedTriageSharingRule -]; -var createHotCrmServiceStack = (collections) => defineStack2({ - manifest: { - id: "app.objectstack.hotcrm.service", - name: "HotCRM Service", - // The app package's namespace, deliberately (ADR-0130 D1). - namespace: "crm", - // The ARTIFACT's version: one `package.json`, one build, one release - // (ADR-0130 D6), so a module of this artifact is never at a version of its - // own. Bump it with the app package's and `package.json` — - // `test/docs-declared-versions.test.ts` holds all three, and the range - // below, to one value. - version: "4.0.1", - type: "module", - description: "HotCRM support module \u2014 cases, knowledge articles, and the SLA surface.", - // The same protocol as the app package (ADR-0087 handshake); bump it with - // `specVersion` on every platform upgrade, exactly as the app's is. - engines: { protocol: "^18.0.0-next.0" }, - // The App package this module extends. - dependencies: { "app.objectstack.hotcrm": "^4.0.1" }, - /** - * The five navigation entries this module puts into the app's menu - * (ADR-0029 D7). - * - * Not a design choice: an app's own `navigation` may not name another - * package's object (ADR-0130 §1.5, rule R3 of `module-split-plan.md`), so - * all five became contributions the moment `crm_case`, - * `crm_knowledge_article`, `service_dashboard` and `sla_performance` left - * the app package. The app keeps the GROUPS (`group_service`, `group_work`, - * `group_insights`) — a container a module cannot declare inside an app it - * does not own — and this module fills them. - * - * `app` is the app's bare `name` (`crm_enterprise`), not the manifest id: a - * dotted id is refused as a non-snake_case identifier. - * - * ⚠️ `priority` orders CONTRIBUTIONS against each other inside a group. It - * does NOT interleave them with the app's own children — a contributed item - * is appended after everything the app itself declares in that group. The - * one visible consequence is `nav_my_cases`, 4th of 6 in *My Work* before - * the split and last after it; the three `group_service` items and - * `nav_report_sla` keep their positions because the app declares nothing - * after them. ⛔ Do not compensate with a per-item `order`: that key sorts - * in the renderer only, this app authors none anywhere, and adding one to - * work around a platform merge rule is what AGENTS.md forbids. - */ - navigationContributions: [ - { - app: "crm_enterprise", - group: "group_service", - // Stated rather than defaulted so that the day a second package - // contributes into one of these groups, the order is an authored fact - // instead of a registration-order accident. - priority: 10, - items: [ - { id: "nav_case", type: "object", objectName: "crm_case", label: "Cases", icon: "life-buoy" }, - { id: "nav_knowledge", type: "object", objectName: "crm_knowledge_article", label: "Knowledge", icon: "book-open" }, - { id: "nav_service_dashboard", type: "dashboard", dashboardName: "service_dashboard", label: "Service Overview", icon: "gauge" } - ] - }, - { - app: "crm_enterprise", - group: "group_work", - priority: 20, - items: [ - { id: "nav_my_cases", type: "object", objectName: "crm_case", viewName: "my_open_cases", label: "My Cases", icon: "life-buoy" } - ] - }, - { - app: "crm_enterprise", - group: "group_insights", - priority: 30, - items: [ - { id: "nav_report_sla", type: "report", reportName: "sla_performance", label: "SLA Performance", icon: "timer" } - ] - } - ] - }, - // What THIS package's metadata needs — see the `requires` paragraph above. - requires: ["automation", "triggers", "analytics", "sharing"], - objects: [ArticleFeedback, Case, KnowledgeArticle], - hooks: serviceHooks, - views: [CaseViews, KnowledgeArticleViews], - pages: [CaseDetailPage], - flows: serviceFlows, - actions: [ - EscalateCaseAction, - CloseCaseAction, - ClaimCaseAction, - LogCallAction, - LogMeetingAction, - CaseScheduleMeetingAction, - MarkArticleHelpfulAction, - MarkArticleNotHelpfulAction - ], - datasets: [CaseDataset], - reports: [CasesByStatusPriorityReport, SlaPerformanceReport, CasesOpenedByDayPriorityReport], - dashboards: [ServiceDashboard], - skills: serviceSkills, - sharingRules: serviceSharingRules, - emailTemplates: ServiceEmailTemplates, - ...collections -}); - -// src/revenue/objects/index.ts -var objects_exports3 = {}; -__export(objects_exports3, { - Contract: () => Contract, - OpportunityLineItem: () => OpportunityLineItem, - Product: () => Product, - Quote: () => Quote, - QuoteLineItem: () => QuoteLineItem -}); - -// src/revenue/objects/contract.object.ts -import { ObjectSchema as ObjectSchema12, Field as Field12 } from "@objectstack/spec/data"; -import { P as P13 } from "@objectstack/spec"; -var Contract = ObjectSchema12.create({ - name: "crm_contract", - label: "Contract", - pluralLabel: "Contracts", - icon: "file-pen-line", - description: "Legal contracts and agreements", - // ADR-0090 D1/D7: OWD is an authored decision. Master-detail child of - // crm_account — a contract IS account data: reachable by whoever can reach - // the account, editable by whoever can edit it (#549, ruling 2026-08-31). - sharingModel: "controlled_by_parent", - // ADR-0079: render-only `titleFormat` retired in favor of `nameField`. - // Original template was '{contract_number} - {crm_account.name}'. The - // `crm_account.name` segment is a lookup DOT-WALK, which a formula field - // cannot reference (ADR-0072), so it is DROPPED. Only the local - // `contract_number` (autonumber) remains, so no formula is needed — point - // `nameField` straight at it. - nameField: "contract_number", - highlightFields: ["contract_number", "crm_account", "status", "start_date", "end_date"], - fieldGroups: [ - { key: "basic", label: "Contract Information", icon: "info" }, - { key: "parties", label: "Parties", icon: "users" }, - { key: "terms", label: "Terms & Dates", icon: "calendar" }, - { key: "value", label: "Contract Value", icon: "dollar-sign" }, - { key: "status", label: "Status & Approval", icon: "check-circle" }, - { key: "renewal", label: "Renewal", icon: "refresh-ccw", collapse: "collapsed" } - ], - fields: { - // Platform ownership anchor — canonical note in `account.object.ts` (#548). - owner_id: Field12.lookup("sys_user", { - label: "Contract Owner", - group: "parties", - system: true, - readonly: false, - trackHistory: true - }), - // AutoNumber field - contract_number: Field12.autonumber({ - label: "Contract Number", - group: "basic", - format: "CTR-{0000}" - }), - // Relationships — the master the OWD derives from. Authored as - // master-detail so the master is not decided by declaration order against - // the required `crm_contact` lookup below (objectstack#14747). - crm_account: Field12.masterDetail("crm_account", { - label: "Account", - group: "parties", - required: true, - storage: { notNull: true }, - deleteBehavior: "cascade" - }), - crm_contact: Field12.lookup("crm_contact", { - label: "Primary Contact", - group: "parties", - required: true, - storage: { notNull: true }, - // @objectstack 12: string[] `referenceFilters` is dead (not read by the - // picker); `dependsOn` is the live cascading-lookup form — scopes contacts - // to the contract's `crm_account` (ADR-0049). - dependsOn: ["crm_account"] - }), - crm_opportunity: Field12.lookup("crm_opportunity", { - label: "Related Opportunity", - group: "parties", - // Scope opportunities to the contract's account (was dead referenceFilters). - dependsOn: ["crm_account"] - }), - // Status - status: Field12.select({ - label: "Status", - group: "status", - options: [ - { label: "Draft", value: "draft", color: "#999999", default: true }, - { label: "In Approval", value: "in_approval", color: "#FFA500" }, - { label: "Activated", value: "activated", color: "#00AA00" }, - { label: "Expired", value: "expired", color: "#FF0000" }, - { label: "Terminated", value: "terminated", color: "#666666" } - ], - required: true, - storage: { notNull: true }, - trackHistory: true - }), - // Contract Terms - contract_term_months: Field12.number({ - label: "Contract Term (Months)", - group: "terms", - required: true, - storage: { notNull: true }, - min: 1 - }), - start_date: Field12.date({ - label: "Start Date", - group: "terms", - required: true, - storage: { notNull: true } - }), - end_date: Field12.date({ - label: "End Date", - group: "terms", - required: true, - storage: { notNull: true } - }), - // Financial - contract_value: Field12.currency({ - label: "Contract Value", - group: "value", - min: 0, - required: true, - storage: { notNull: true } - }), - billing_frequency: Field12.select({ - label: "Billing Frequency", - group: "value", - options: [ - { label: "Monthly", value: "monthly", default: true }, - { label: "Quarterly", value: "quarterly" }, - { label: "Annually", value: "annually" }, - { label: "One-time", value: "one_time" } - ] - }), - payment_terms: Field12.select({ - label: "Payment Terms", - group: "value", - // Canonical set shared with Quote: an accepted quote's terms (incl. - // due_on_receipt) must survive the copy onto the contract. That copy is - // `quote_accepted_contract_draft` (src/revenue/objects/quote.hook.ts). This field's `net_30` - // option default applies only when the quote itself carried no term, - // which is the intended fall-through, not a gap. - options: [...PAYMENT_TERMS_OPTIONS] - }), - // Renewal - auto_renewal: Field12.boolean({ - label: "Auto Renewal", - group: "renewal", - defaultValue: false - }), - renewal_notice_days: Field12.number({ - label: "Renewal Notice (Days)", - group: "renewal", - min: 0, - defaultValue: 30 - }), - // Legal - contract_type: Field12.select({ - label: "Contract Type", - group: "basic", - options: [ - { label: "Subscription", value: "subscription" }, - { label: "Service Agreement", value: "service" }, - { label: "License", value: "license" }, - { label: "Partnership", value: "partnership" }, - { label: "NDA", value: "nda" }, - { label: "MSA", value: "msa" } - ] - }), - signed_date: Field12.date({ - label: "Signed Date", - group: "status" - }), - signed_by: Field12.text({ - label: "Signed By", - group: "status", - maxLength: 255 - }), - document_url: Field12.url({ - label: "Contract Document", - group: "basic" - }), - // Terms & Conditions - special_terms: Field12.markdown({ - label: "Special Terms", - group: "terms" - }), - description: Field12.markdown({ - label: "Description", - group: "basic" - }), - // Billing Address - billing_address: Field12.address({ - label: "Billing Address", - group: "value" - }) - }, - // Database indexes - indexes: [ - { fields: ["crm_account"] }, - { fields: ["status"] }, - { fields: ["start_date"] }, - { fields: ["end_date"] }, - { fields: ["owner_id"] } - ], - // Enable advanced features - // API surface. History → Field.trackHistory (ADR-0052). - enable: { - apiEnabled: true, - apiMethods: ["get", "list", "create", "update", "delete"], - // #602 — the executed contract itself. `document_url` remains the pointer - // to an external DMS copy; this is where the file actually lives. - // See the canonical capability note in `src/sales/objects/index.ts`. - files: true - }, - // Validation Rules - // - // Predicates below are TOTAL: every `record.x` read is `has()`-guarded, so the - // rule returns a verdict even when the merged record has no such key. See - // AGENTS.md "Validation predicates must be TOTAL" and - // test/object-validation-predicates.test.ts, which fails the build otherwise. - validations: [ - { - name: "end_after_start", - type: "script", - severity: "error", - message: "End Date must be after Start Date", - condition: P13`has(record.end_date) && record.end_date != null && has(record.start_date) && record.start_date != null && record.end_date <= record.start_date` - }, - // NOTE: the `valid_contract_term` warning (months-between term check) was - // dropped in the 9.8.0 upgrade — its CEL predicate used `monthsBetween()`, - // which 9.8.0's aligned CEL stdlib (ADR-0032) no longer provides. It was a - // non-blocking warning; the hard end-date>start-date rule above remains. - { - // #575 B4. Like `crm_quote`, this object shipped a lifecycle vocabulary - // with no transition constraint and no status guard in `contract.hook.ts` - // — so `draft → activated` was a legal move, activating an agreement that - // never passed approval. Activation is the consequential edge here: - // `contract_on_activation` stamps `signed_date`, promotes the account to - // `customer`, and the renewal flow starts counting from it. - name: "contract_status_progression", - type: "state_machine", - severity: "warning", - message: "Invalid contract status transition", - field: "status", - transitions: { - draft: ["in_approval", "terminated"], - // Approval either lands (`activated`) or sends the paperwork back. - in_approval: ["draft", "activated", "terminated"], - // `→ expired` is the contract_expiration flow, whose own sweep filter - // is `status: 'activated'` — nothing else ages out. - activated: ["expired", "terminated"], - // Both ends are terminal: a renewal is a NEW contract (the - // contract_renewal flow files a task, it does not revive the old row). - expired: [], - terminated: [] - } - } - ] - // Workflow Rules - // ⚠️ No `workflows[]` here, and none is possible: object `workflows[]` were - // removed from the platform. Field updates live in this object's `*.hook.ts`; - // scheduled status flips and notifications live in `src/*/flows/*.flow.ts`. -}); - -// src/revenue/objects/opportunity_line_item.object.ts -import { ObjectSchema as ObjectSchema13, Field as Field13 } from "@objectstack/spec/data"; -import { F as F8, P as P14 } from "@objectstack/spec"; -var OpportunityLineItem = ObjectSchema13.create({ - name: "crm_opportunity_line_item", - label: "Opportunity Line Item", - pluralLabel: "Opportunity Line Items", - icon: "package", - description: "A single product line on an Opportunity", - // ADR-0090 D1/D7: OWD is an authored decision. A line item has no meaning - // apart from its deal, so its record access DERIVES from the opportunity - // (ADR-0055), and as of 17.0.0-rc.4 that derivation means what it says. - // - // ⚠️ Reads ARE filtered to line items whose `crm_opportunity` the caller can - // read, and master accessibility resolves through the same paths a direct - // read of the opportunity takes — ownership and `sys_record_share` grants - // included, NOT the master's row-level security policies alone. So a rep - // reads the lines of the deals in their own book plus anything shared to - // them, and the private-deal RLS filter carried by the `sales_manager` and - // `marketing_user` sets narrows on top of that rather than being the only - // thing that narrows. The parent-write gate derives the same way: a line - // whose opportunity the caller cannot edit is refused. - // - // `test/parent-derived-reach.test.ts` pins the narrow semantics and was - // written to go red the day the platform widens them: with the master set - // resolved from RLS policies alone, any caller without the private-deal - // policy — `sales_rep` included — reaches EVERY opportunity's lines. - // ADR-0055's relation resolver accepts a REQUIRED LOOKUP as the parent, so - // this works without converting the relationship to master-detail. - // - // ⛔ Not `private`: this object has no owner of its own, so `private` falls - // back to the platform's auto-stamped `owner_id` (whoever inserted the row) — - // and the rep who owns the deal then cannot see a line the quote-generation - // flow or their manager added to it. - sharingModel: "controlled_by_parent", - // Per-field history is opt-in via `Field.trackHistory` (ADR-0052), set on - // quantity/unit_price/discount below. Master-detail children still inherit - // the master's sharing automatically. - highlightFields: ["crm_product", "quantity", "unit_price", "total_price"], - // Two groups, derived from the nine fields this object actually declares - // rather than copied off a neighbour (#1453). The split is the one the - // arithmetic already makes: everything `total_price` multiplies together is - // `pricing`, everything that says WHICH line this is is `basic`. - // - // `quantity` is a pricing field here, not an identity one — it is a factor in - // `total_price`, and separating it from the price it multiplies would put the - // two halves of one product on two sections. `crm_quote_line_item` takes the - // same split over its ten fields, and the parents agree: `crm_quote` and - // `crm_product` both keep every money field in `pricing` — `crm_quote`'s - // `tax` included — and both keep `description` in `basic`. - // - // ⚠️ Neither group may be a subset of the highlight strip: a synthesized - // detail page hoists the title plus the first four `highlightFields` out of - // the body, so an all-hoisted group renders on forms and nowhere else - // (`field-group-shadowed`; `pnpm lint` — `os lint --strict` — fails on it). - // `basic` keeps crm_opportunity/description/line_number and `pricing` keeps - // list_price/discount outside that strip, so both survive the hoist. - fieldGroups: [ - { key: "basic", label: "Line Item", icon: "package" }, - { key: "pricing", label: "Pricing", icon: "dollar-sign" } - ], - fields: { - // The parent link, and the ONE field on this object that decides whether the - // deal it belongs to can be deleted at all (#727). - // - // Declaring nothing here does not mean "no opinion": `Field.lookup` resolves - // `deleteBehavior` to the spec default `set_null`, and the engine's - // `cascadeDeleteRelations` escalates a `set_null` default on a REQUIRED - // lookup to `restrict` — a NOT NULL column cannot be cleared. So the silent - // default made every itemised opportunity undeletable, with a message that - // told the API caller to `set deleteBehavior:'cascade'` on this very field: - // - // DELETE /api/v1/data/crm_opportunity/ - // → 409 DELETE_RESTRICTED "…1 dependent crm_opportunity_line_item - // record(s) reference it via crm_opportunity…" - // - // `cascade` is the semantics this object already claims twice over: the - // header comment says a line has no meaning apart from its deal, and - // `opportunity_line_item.hook.ts` derives `crm_opportunity.amount` FROM the - // line set. A record whose parent is gone denotes nothing and would keep a - // dead deal's revenue in the line-level reports. - // - // This is deliberately NOT the campaign/event answer (#696, #711 kept - // `crm_campaign_member.crm_campaign` and `crm_event_attendee.crm_event` on - // the restricting default): a member list is a campaign's historical record - // and survives on its own terms. A price line does not. - crm_opportunity: Field13.masterDetail("crm_opportunity", { - label: "Opportunity", - group: "basic", - required: true, - storage: { notNull: true }, - deleteBehavior: "cascade" - }), - // Deliberately left on the default, which the same escalation turns into - // `restrict`: deleting a catalog product must NOT shred the priced history - // of deals that sold it. `product.hook.ts`'s own `beforeDelete` says the - // same thing in words ("Set is_active=false to retire instead"). - crm_product: Field13.lookup("crm_product", { - label: "Product", - group: "basic", - required: true, - storage: { notNull: true } - }), - description: Field13.text({ - label: "Description", - group: "basic", - maxLength: 500 - }), - quantity: Field13.number({ - label: "Quantity", - group: "pricing", - required: true, - storage: { notNull: true }, - scale: 2, - min: 0, - defaultValue: 1, - trackHistory: true - }), - list_price: Field13.currency({ - label: "List Price", - group: "pricing", - readonly: true, - description: "Auto-populated from the product's List Price." - }), - unit_price: Field13.currency({ - label: "Sales Price", - group: "pricing", - required: true, - storage: { notNull: true }, - description: "Negotiated unit price (may differ from list price)", - trackHistory: true - }), - discount: Field13.percent({ - label: "Discount %", - group: "pricing", - scale: 2, - min: 0, - max: 100, - defaultValue: 0, - trackHistory: true - }), - total_price: Field13.formula({ - label: "Total", - group: "pricing", - expression: F8`record.quantity * record.unit_price * (1 - record.discount / 100)` - }), - line_number: Field13.number({ - label: "Line #", - group: "basic", - scale: 0, - readonly: true - }) - }, - // Predicates below are TOTAL: every `record.x` read is `has()`-guarded, so the - // rule returns a verdict even when the merged record has no such key. See - // AGENTS.md "Validation predicates must be TOTAL" and - // test/object-validation-predicates.test.ts, which fails the build otherwise. - validations: [ - { - name: "unit_price_positive", - type: "script", - severity: "error", - message: "Sales price cannot be negative", - // Both guards are load-bearing, not defensive noise. `has(...)` answers - // "is the key present at all": on update the predicate sees - // `{...previous, ...data}`, and a driver that stores only written columns - // returns no key, which aborts the whole predicate and silently skips the - // rule (#630). `!= null` answers "does it hold a value": strict CEL - // ABORTS on `null < 0` instead of evaluating it false, so the unguarded - // form left this rule inert on a blank price — it never fired at all, - // which is the opposite of what a validation is for. The `null` hazard is - // written up at `account.object.ts:244-245`; the same-named rule in - // `quote_line_item.object.ts` has carried that guard all along. - condition: P14`has(record.unit_price) && record.unit_price != null && record.unit_price < 0` - } - ] -}); - -// src/revenue/objects/product.object.ts -import { ObjectSchema as ObjectSchema14, Field as Field14 } from "@objectstack/spec/data"; -import { F as F9, P as P15 } from "@objectstack/spec"; -var Product = ObjectSchema14.create({ - name: "crm_product", - label: "Product", - pluralLabel: "Products", - icon: "box", - description: "Products and services offered by the company", - // ADR-0090 D1/D7: OWD is an authored decision. Product catalog is org-visible; only owners edit. - sharingModel: "public_read", - // ADR-0079: render-only `titleFormat` retired in favor of `nameField`, - // which names a real field. The former template composed two local fields, so - // a `display_title` formula field reproduces it for the record title. - nameField: "display_title", - // Explicit search targets (ADR-0061). REQUIRED because nameField is a - // FORMULA (display_title/full_name): without this, $search auto-defaults to - // the formula field, which isn't a real column, so the lookup picker + global - // search silently return zero. These are real, indexed columns. - searchableFields: ["name", "product_code", "sku"], - highlightFields: ["product_code", "name", "category", "is_active"], - fieldGroups: [ - { key: "basic", label: "Product Information", icon: "info" }, - { key: "pricing", label: "Pricing", icon: "dollar-sign" }, - { key: "metadata", label: "Resources", icon: "link", collapse: "collapsed" } - ], - fields: { - // AutoNumber field - Unique product identifier - product_code: Field14.autonumber({ - label: "Product Code", - group: "basic", - format: "PRD-{0000}" - }), - // Basic Information - name: Field14.text({ - label: "Product Name", - group: "basic", - required: true, - storage: { notNull: true }, - searchable: true, - maxLength: 255 - }), - // ADR-0079 record title (was titleFormat '{product_code} - {name}'). - display_title: Field14.formula({ - label: "Display Title", - group: "basic", - expression: F9`record.product_code + " - " + record.name` - }), - description: Field14.markdown({ - label: "Description", - group: "basic" - }), - // Categorization - category: Field14.select({ - label: "Category", - group: "basic", - options: [ - { label: "Software", value: "software", default: true }, - { label: "Hardware", value: "hardware" }, - { label: "Service", value: "service" }, - { label: "Subscription", value: "subscription" }, - { label: "Support", value: "support" } - ] - }), - family: Field14.select({ - label: "Product Family", - group: "basic", - options: [ - { label: "Enterprise Solutions", value: "enterprise" }, - { label: "SMB Solutions", value: "smb" }, - { label: "Professional Services", value: "services" }, - { label: "Cloud Services", value: "cloud" } - ] - }), - // Pricing - list_price: Field14.currency({ - label: "List Price", - group: "pricing", - min: 0, - required: true, - storage: { notNull: true } - }), - cost: Field14.currency({ - label: "Cost", - group: "pricing", - min: 0 - }), - // SKU - // - // `quantity_on_hand` / `reorder_point` were removed with the rest of the - // inventory surface: nothing in this app decremented stock, and the "Low - // Stock" view they fed compared against a hardcoded 10 rather than the - // reorder point beside it. HotCRM sells from a catalog; warehouse state - // belongs to the system of record that owns it. - sku: Field14.text({ - label: "SKU", - group: "basic", - maxLength: 50, - unique: true - }), - // Status - is_active: Field14.boolean({ - label: "Active", - group: "basic", - defaultValue: true, - trackHistory: true - }), - // Relationships - product_manager: Field14.lookup("sys_user", { - label: "Product Manager", - group: "basic" - }), - // Images and Assets - // `accept` / `maxSize` are declarable AND server-enforced from - // @objectstack 17 (ADR-0104 D3 wave 2). Before that the upload widget read - // them but `FieldSchema` dropped them at parse, so the constraint existed - // only in the browser and any direct API caller walked past it. - image: Field14.image({ - label: "Product Image", - group: "metadata", - accept: ["image/png", "image/jpeg", "image/webp"], - maxSize: 5 * 1024 * 1024 - }), - datasheet: Field14.file({ - label: "Datasheet", - group: "metadata", - accept: ["application/pdf"], - maxSize: 20 * 1024 * 1024 - }) - // `billing_type` and `unit_of_measure` were removed with the tax flag: both - // were seeded on all 13 catalog products and read by nothing — no quote - // total, no revenue-recognition report and no line-item behaviour ever - // consulted either. A picklist that only ever renders itself is a - // maintenance obligation (four locales, an import column, every future - // migration) charged against a capability that does not exist. - }, - // Database indexes - // - // No `{ fields: ['sku'], unique: true }` here: the field-level `unique: true` - // already builds the tenant composite `(organization_id, sku)` since - // framework #3696. Declaring the single-column index too made the - // platform-wide constraint win and left the per-tenant one unreachable - // (framework#3991) — an SKU is unique inside a catalogue, and two - // organizations may legitimately both stock "ABC-123". - indexes: [ - { fields: ["name"] }, - { fields: ["category"] }, - { fields: ["is_active"] } - ], - // Enable advanced features - // API surface. History → Field.trackHistory (ADR-0052). - enable: { - apiEnabled: true, - apiMethods: ["get", "list", "create", "update", "delete"] - }, - // Validation Rules - // - // Predicates below are TOTAL: every `record.x` read is `has()`-guarded, so the - // rule returns a verdict even when the merged record has no such key. See - // AGENTS.md "Validation predicates must be TOTAL" and - // test/object-validation-predicates.test.ts, which fails the build otherwise. - validations: [ - { - name: "price_positive", - type: "script", - severity: "error", - message: "List Price must be positive", - // Two distinct guards, both required. `has(...)` answers "is the key - // there at all" — on update the merged record is `{...previous, ...data}` - // and a driver that stores only written columns hands back no key, which - // aborts the whole predicate (#630). `!= null` then answers "does it hold - // a value" — strict CEL cannot compare dyn < int, the hazard - // written up on `account.object.ts`. `list_price` is `required`, but the - // rule also runs on partial updates that omit it. - condition: P15`has(record.list_price) && record.list_price != null && record.list_price < 0` - }, - { - name: "cost_less_than_price", - type: "script", - severity: "warning", - message: "Cost should be less than List Price", - // Both operands need both guards: `cost` is optional and absent on every - // seeded product, so this warning has never once evaluated. - condition: P15`has(record.cost) && record.cost != null && has(record.list_price) && record.list_price != null && record.cost >= record.list_price` - } - ] -}); - -// src/revenue/objects/quote.object.ts -import { ObjectSchema as ObjectSchema15, Field as Field15 } from "@objectstack/spec/data"; -import { F as F10, P as P16, cel as cel5 } from "@objectstack/spec"; - -// src/sales/objects/_thresholds.ts -var LARGE_DEAL_AMOUNT = 1e5; -var HIGH_VALUE_DEAL_AMOUNT = 5e5; -var QUOTE_DISCOUNT_CEILING = 60; - -// src/revenue/objects/quote.object.ts -var Quote = ObjectSchema15.create({ - name: "crm_quote", - label: "Quote", - pluralLabel: "Quotes", - icon: "file-text", - description: "Price quotes for customers", - // ADR-0090 D1/D7: OWD is an authored decision. Master-detail child of - // crm_account — a quote is reachable by whoever can reach its account, and - // its line items derive one level further (#549, ruling 2026-08-31). - sharingModel: "controlled_by_parent", - // ADR-0079: render-only `titleFormat` retired in favor of `nameField`, - // which names a real field. The former template composed two local fields, so - // a `display_title` formula field reproduces it for the record title. - nameField: "display_title", - // Explicit search targets (ADR-0061). REQUIRED because nameField is a - // FORMULA (display_title/full_name): without this, $search auto-defaults to - // the formula field, which isn't a real column, so the lookup picker + global - // search silently return zero. These are real, indexed columns. - searchableFields: ["name", "quote_number"], - highlightFields: ["quote_number", "name", "crm_account", "status", "total_price"], - fieldGroups: [ - { key: "basic", label: "Quote Information", icon: "info" }, - { key: "pricing", label: "Pricing", icon: "dollar-sign" }, - { key: "terms", label: "Terms & Validity", icon: "calendar" }, - { key: "address", label: "Addresses", icon: "map-pin", collapse: "collapsed" }, - { key: "system", label: "System", icon: "database", collapse: "collapsed" } - ], - fields: { - // Platform ownership anchor — canonical note in `account.object.ts` (#548). - owner_id: Field15.lookup("sys_user", { - label: "Quote Owner", - group: "basic", - system: true, - readonly: false, - trackHistory: true - }), - // AutoNumber field - quote_number: Field15.autonumber({ - label: "Quote Number", - group: "basic", - format: "QTE-{0000}" - }), - // Basic Information - name: Field15.text({ - label: "Quote Name", - group: "basic", - required: true, - storage: { notNull: true }, - searchable: true, - maxLength: 255 - }), - // ADR-0079 record title (was titleFormat '{quote_number} - {name}'). - display_title: Field15.formula({ - label: "Display Title", - group: "basic", - expression: F10`record.quote_number + " - " + record.name` - }), - // Relationships — the master the OWD derives from (authored, not positional). - crm_account: Field15.masterDetail("crm_account", { - label: "Account", - group: "basic", - required: true, - storage: { notNull: true }, - deleteBehavior: "cascade" - }), - crm_contact: Field15.lookup("crm_contact", { - label: "Contact", - group: "basic", - // Optional AT DRAFT TIME, required from `presented` on (#1017). - // - // quote_generation maps the opportunity's `primary_contact`, which is - // itself optional — a flat `required: true` here meant contact-less - // opportunities could never draft a quote at all. So the recipient is - // nailed down by the time a quote is PRESENTED, not when it is drafted. - // That sentence sat in this comment for the field's whole life with - // nothing enforcing it: no rule stopped a contact-less quote reaching - // `presented` or `accepted`, and the bill came due one object over. - // `crm_contract.crm_contact` is `required` + `notNull`, so accepting such - // a quote made `quote_on_accepted` fail to draft the contract — since - // #714/#1013 that failure is honest and no longer swallows the close-won - // leg, but the hook is `async` + `onError: 'log'`, so the accepting write - // still answers 200 and the only evidence is a server log nobody reads. - // `requiredWhen` moves the same refusal to the synchronous, someone-is- - // watching moment: the rep is told on the write that turns the quote - // outward, against the field, with the quote still editable. - // - // WHY EXACTLY `presented` + `accepted`, and not the other two terminal - // states. Both of those are reachable WITHOUT the quote ever being sent - // (see the `quote_status_progression` transitions below): - // • `expired` — the `quote_expiration` flow sweeps on `expiration_date` - // alone and expires never-sent drafts as readily as presented ones. - // Requiring a recipient there would make a nightly system write fail - // on exactly the quotes that have no recipient BECAUSE nobody sent - // them, and the sweep's `runAs: 'system'` would not exempt it — the - // gate applies on write, not on actor. - // • `rejected` — legal straight from `in_review`, i.e. a quote killed - // internally before anyone saw it. Demanding a contact to file that - // verdict asks for a recipient the quote never had. - // Neither state passes anything on to a contract, so neither needs one. - // - // ⚠️ `has(record.status)` is load-bearing, not decoration — the same trap - // documented at `lead.object.ts`'s duplicate lookups: a bare - // `record.status == "presented"` aborts with `No such key` on any merged - // record that simply omits the column, and the engine's answer to a - // predicate that fails to evaluate is to SKIP it ("requiredWhen for - // 'crm_contact' failed to evaluate — skipped"). The rule would then read - // as enforced and require nothing at all. - // - // @objectstack 12: string[] `referenceFilters` is dead (not read by the - // picker); `dependsOn` is the live cascading form — scopes contacts to the - // quote's `crm_account` (ADR-0049). - dependsOn: ["crm_account"], - requiredWhen: P16`has(record.status) && (record.status == "presented" || record.status == "accepted")`, - description: "Required once the quote is Presented or Accepted \u2014 the drafted contract takes its Primary Contact from here." - }), - crm_opportunity: Field15.lookup("crm_opportunity", { - label: "Opportunity", - group: "basic", - // Scope opportunities to the quote's account (was dead referenceFilters). - dependsOn: ["crm_account"] - }), - // Status - status: Field15.select({ - label: "Status", - group: "basic", - options: [ - { label: "Draft", value: "draft", color: "#999999", default: true }, - { label: "In Review", value: "in_review", color: "#FFA500" }, - { label: "Presented", value: "presented", color: "#4169E1" }, - { label: "Accepted", value: "accepted", color: "#00AA00" }, - { label: "Rejected", value: "rejected", color: "#FF0000" }, - { label: "Expired", value: "expired", color: "#666666" } - ], - required: true, - storage: { notNull: true }, - trackHistory: true - }), - // Dates - quote_date: Field15.date({ - label: "Quote Date", - group: "terms", - required: true, - storage: { notNull: true }, - defaultValue: cel5`today()` - }), - expiration_date: Field15.date({ - label: "Expiration Date", - group: "terms", - required: true, - storage: { notNull: true } - }), - // Pricing - // subtotal/discount_amount/total_price are NOT `readonly`, and the writer - // that decides it is the LINE-ITEM ROLLUP — not the flow this note used to - // name. `quote_total_rollup` (`quote_line_item.hook.ts`) recomputes all - // three on every line insert/update/delete through - // `api.object('crm_quote').update(...)`: a cross-record write via `ctx.api`, - // which is a `ScopedContext` over the ACTING USER's context. The keys are - // therefore CALLER-supplied to a non-`isSystem` UPDATE, exactly what - // `stripReadonlyFields` deletes — with `readonly` on, a quote's totals would - // freeze at whatever the flow first seeded and never track its lines again. - // ⚠️ `quote_generation` writes them too, but at CREATE time, and the strip - // is an UPDATE-path rule — that write would survive `readonly` untouched. - // The retired 16.x claim rested on that create-time write, which is how this - // note reached a right conclusion from the wrong writer. - // Measured in `test/readonly-write-semantics.test.ts` (insert is exempt) and - // `test/activity-recency.test.ts` (the `ctx.api` strip, on the real engine). - subtotal: Field15.currency({ - label: "Subtotal", - group: "pricing" - }), - discount: Field15.percent({ - label: "Discount %", - group: "pricing", - scale: 2, - min: 0, - max: 100 - }), - discount_amount: Field15.currency({ - label: "Discount Amount", - group: "pricing" - }), - tax: Field15.currency({ - label: "Tax", - group: "pricing" - }), - shipping_handling: Field15.currency({ - label: "Shipping & Handling", - group: "pricing" - }), - total_price: Field15.currency({ - label: "Total Price", - group: "pricing" - }), - // Terms - payment_terms: Field15.select({ - label: "Payment Terms", - group: "terms", - // Canonical set shared with Contract (#490) — see _picklists.ts. - options: [...PAYMENT_TERMS_OPTIONS] - }), - shipping_terms: Field15.text({ - label: "Shipping Terms", - group: "terms", - maxLength: 255 - }), - // Billing & Shipping Address - billing_address: Field15.address({ - label: "Billing Address", - group: "address" - }), - shipping_address: Field15.address({ - label: "Shipping Address", - group: "address" - }), - // Notes - description: Field15.markdown({ - label: "Description", - group: "basic" - }), - internal_notes: Field15.textarea({ - label: "Internal Notes", - group: "system" - }) - }, - // Database indexes - indexes: [ - { fields: ["crm_account"] }, - { fields: ["crm_opportunity"] }, - { fields: ["owner_id"] }, - { fields: ["status"] }, - { fields: ["quote_date"] } - ], - // Enable advanced features - // API surface. History → Field.trackHistory (ADR-0052). - enable: { - apiEnabled: true, - apiMethods: ["get", "list", "create", "update", "delete"], - // #602 — the generated quote PDF and the customer's countersigned copy. - // See the canonical capability note in `src/sales/objects/index.ts`. - files: true - }, - // Validation Rules - // - // Predicates below are TOTAL: every `record.x` read is `has()`-guarded, so the - // rule returns a verdict even when the merged record has no such key. See - // AGENTS.md "Validation predicates must be TOTAL" and - // test/object-validation-predicates.test.ts, which fails the build otherwise. - validations: [ - { - name: "expiration_after_quote", - type: "script", - severity: "error", - message: "Expiration Date must be after Quote Date", - condition: P16`has(record.expiration_date) && record.expiration_date != null && has(record.quote_date) && record.quote_date != null && record.expiration_date <= record.quote_date` - }, - { - // #599. The only discount constraint this object ever had was the field's - // own `max: 100` — the arithmetic domain of a percentage — so a rep could - // put 90% off a $99K deal on a quote and nothing anywhere objected: the - // approval flow keys on the opportunity's AMOUNT, and $99K is under the - // large-deal line. This is the policy ceiling that constraint never was. - // - // ⚠️ A predicate of `record.discount > 100` here would be DEAD: field-level - // bounds are evaluated BEFORE object validations, so `discount: 150` is - // already refused by `max: 100` with `code: 'max_value'` and the message - // "Discount % must be ≤ 100", and the rule's own message is unreachable on - // every input that could reach it. - // - // ### Why a script validation and not a lower `max` on the field - // - // This is an INVARIANT — "a quote's discount may never exceed the - // ceiling" — not a transition condition, and #1069 is open on exactly - // that distinction for `requiredWhen`. Both instruments were measured - // against a row stored above the ceiling before the rule existed - // (`test/quote-discount-ceiling.test.ts` runs the measurement): - // - // Field.percent({ max: 60 }) legacy row, unrelated edit → ADMITTED - // this rule legacy row, unrelated edit → REFUSED - // - // A field bound checks the value being WRITTEN; a script validation is - // evaluated against the MERGED record on every write. So `max` carries - // the same silent legacy hole #1069 describes, in a second instrument, - // and the rule does not. The cost of the invariant, stated rather than - // hidden: an over-ceiling row is frozen to everything except the repair — - // bringing the discount back under the ceiling is admitted, and is an - // ordinary edit. HotCRM ships no such row (deepest seeded discount: 20%). - // - // `max: 100` stays on the field as the domain of a percentage. The policy - // number lives in `_thresholds.ts`, interpolated into both the predicate - // and the message so the two cannot disagree. - name: "discount_within_ceiling", - type: "script", - severity: "error", - message: `Discount cannot exceed ${QUOTE_DISCOUNT_CEILING}%`, - condition: P16`has(record.discount) && record.discount != null && record.discount > ${QUOTE_DISCOUNT_CEILING}` - }, - { - // #575 B4. `crm_quote` had a full lifecycle vocabulary and no transition - // constraint whatsoever — nor a status guard in `quote.hook.ts` — so a - // quote could go straight from `draft` to `accepted`, which in CPQ terms - // is a signed number nobody reviewed or sent. `warning` severity matches - // the lead / opportunity / case machines: it flags the jump on the record - // without blocking a support-driven correction. - name: "quote_status_progression", - type: "state_machine", - severity: "warning", - message: "Invalid quote status transition", - field: "status", - transitions: { - // `→ expired` is legal from every UNSETTLED state: the quote_expiration - // flow sweeps on `expiration_date` alone and expires drafts that were - // never sent as readily as presented ones. - draft: ["in_review", "expired"], - in_review: ["draft", "presented", "rejected", "expired"], - presented: ["accepted", "rejected", "expired"], - // `accepted` and `expired` are terminal, and not only by convention — - // `quote_pricing_guard` in quote.hook.ts freezes both, allowing edits - // to `internal_notes` and nothing else. - accepted: [], - expired: [], - // A rejected quote is not frozen: the rep revises the numbers and - // re-issues, which starts again at `draft`. - rejected: ["draft"] - } - } - ] - // Workflow Rules - // ⚠️ No `workflows[]` here, and none is possible: object `workflows[]` were - // removed from the platform. Field updates live in this object's `*.hook.ts`; - // scheduled status flips and notifications live in `src/*/flows/*.flow.ts`. -}); - -// src/revenue/objects/quote_line_item.object.ts -import { ObjectSchema as ObjectSchema16, Field as Field16 } from "@objectstack/spec/data"; -import { F as F11, P as P17 } from "@objectstack/spec"; -var QuoteLineItem = ObjectSchema16.create({ - name: "crm_quote_line_item", - label: "Quote Line Item", - pluralLabel: "Quote Line Items", - icon: "package", - description: "A single product line on a Quote", - // OWD is an authored decision (ADR-0090 D1/D7). Record access DERIVES from - // the quote (ADR-0055). - // - // ⚠️ Reads ARE filtered to lines whose `crm_quote` the caller can read, and - // "can read" resolves through the same paths a direct read of the quote takes - // — owner scope and `sys_record_share` grants included, NOT the master's - // row-level security policies alone. A rep who owns one quote reads that - // quote's lines and no others. The parent-write gate derives the same way: a - // line whose quote the caller cannot edit is refused with a - // `PermissionDeniedError` naming the master. - // - // `test/parent-derived-reach.test.ts` pins those semantics with positive - // controls, so a regression is caught in either direction — it was written to - // go red the day the platform widens them: with the derivation consulting - // master RLS policies only, under a SYSTEM context, and no policy authored on - // `crm_quote`, the master set is EVERY quote and a line item is readable — - // and writable — by every holder of object-level read on this object. The - // relation resolver accepts a REQUIRED LOOKUP as the parent, so no - // master-detail conversion is needed. - // - // ⛔ Not `private`: with no owner field on this object that resolves to the - // platform's auto-stamped `owner_id` — the row's inserter — so lines cloned - // onto a quote by the `quote_generation` flow are invisible to the rep who - // owns the quote. - sharingModel: "controlled_by_parent", - // Per-field history is opt-in via `Field.trackHistory` (ADR-0052), set on - // quantity/unit_price/discount below. Master-detail children still inherit - // the master's sharing automatically. - highlightFields: ["crm_product", "quantity", "unit_price", "total_price"], - // The same two-group split as `crm_opportunity_line_item` (#1453), derived - // from the ten fields declared here: every factor `total_price` multiplies - // is `pricing`, everything that says WHICH line this is is `basic`. - // - // ⚠️ Neither group may be a subset of the highlight strip — see the twin - // object for the hoisting rule this satisfies. - fieldGroups: [ - { key: "basic", label: "Line Item", icon: "package" }, - { key: "pricing", label: "Pricing", icon: "dollar-sign" } - ], - fields: { - // The parent link — same decision, same reasoning, as - // `opportunity_line_item.crm_opportunity` (#727); read the long note there. - // In short: declaring nothing resolves to the spec default `set_null`, which - // the engine escalates to `restrict` on a REQUIRED lookup, so every quote - // that had been itemised refused to delete with a 409 quoting this field. - // A quote line is subordinate to its quote (`quote_line_item.hook.ts` rolls - // the quote's subtotal/total UP from these rows), so it goes with it. - crm_quote: Field16.masterDetail("crm_quote", { - label: "Quote", - group: "basic", - required: true, - storage: { notNull: true }, - deleteBehavior: "cascade", - // Curates the line-items panel on a quote's detail page (#1199) — the - // mechanism that panel reads first (#944; the long note is on - // `crm_campaign_member.crm_campaign`). A SUPERSET of the fallback it - // replaces (`highlightFields` minus this lookup: Product / Quantity / - // Sales Price / Total) plus `subtotal`, the line's price after its own - // discount — the formula was evaluated on every read and shown in no list. - // - // ⛔ Not added to `highlightFields`: the detail page hoists the first - // four of that strip, so a fifth entry never reaches the strip, and - // reordering it would evict `total_price` from the record's header. - relatedListColumns: ["crm_product", "quantity", "unit_price", "subtotal", "total_price"] - }), - // Left on the restricting default on purpose — see the twin object: a - // product's catalog entry must not take priced quote history with it. - crm_product: Field16.lookup("crm_product", { - label: "Product", - group: "basic", - required: true, - storage: { notNull: true } - }), - description: Field16.text({ - label: "Description", - group: "basic", - maxLength: 500 - }), - quantity: Field16.number({ - label: "Quantity", - group: "pricing", - required: true, - storage: { notNull: true }, - scale: 2, - min: 0, - defaultValue: 1, - trackHistory: true - }), - list_price: Field16.currency({ - label: "List Price", - group: "pricing", - readonly: true - }), - unit_price: Field16.currency({ - label: "Sales Price", - group: "pricing", - required: true, - storage: { notNull: true }, - trackHistory: true - }), - discount: Field16.percent({ - label: "Discount %", - group: "pricing", - scale: 2, - min: 0, - max: 100, - defaultValue: 0, - trackHistory: true - }), - subtotal: Field16.formula({ - label: "Subtotal", - group: "pricing", - expression: F11`record.quantity * record.unit_price * (1 - record.discount / 100)` - }), - // A line carries no tax: tax is the quote's own amount (#2069), so Total is - // `subtotal`'s expression, not a read of `subtotal` — a formula reading a - // formula depends on hydration order (`lead.object.ts:61-64`). - total_price: Field16.formula({ - label: "Total", - group: "pricing", - expression: F11`record.quantity * record.unit_price * (1 - record.discount / 100)` - }), - line_number: Field16.number({ - label: "Line #", - group: "basic", - scale: 0, - readonly: true - }) - }, - // Predicates below are TOTAL: every `record.x` read is `has()`-guarded, so the - // rule returns a verdict even when the merged record has no such key. See - // AGENTS.md "Validation predicates must be TOTAL" and - // test/object-validation-predicates.test.ts, which fails the build otherwise. - validations: [ - { - name: "unit_price_positive", - type: "script", - severity: "error", - message: "Sales price cannot be negative", - condition: P17`has(record.unit_price) && record.unit_price != null && record.unit_price < 0` - }, - { - // #1086. The other half of #599's ceiling, and the reason that card's own - // acceptance criterion — "a quote with a 90% line discount cannot reach - // `presented`" — was not met by the quote-level rule alone. - // - // ### The walk-around this closes - // - // A quote's total has TWO independent discount multipliers, and - // `quote_total_rollup` composes them: - // - // subtotal = Σ line (quantity × unit_price × (1 − LINE discount/100)) - // discount_amount = subtotal × QUOTE discount% - // - // #599 put a ceiling on the second one only. So a quote at - // `discount: 0` — which clears `discount_within_ceiling` on `crm_quote` - // outright — with every line at `discount: 90` prices 90% below list, and - // nothing objected: this object's only discount constraint was the - // field's own `max: 100`, the arithmetic domain of a percentage. An - // invariant with a documented walk-around is worse than no invariant, - // because a reader (human or AI) cites the rule as the guarantee. - // - // ### Same constant, same instrument, deliberately - // - // The number is `QUOTE_DISCOUNT_CEILING` — imported, never retyped, so the - // two ceilings are one policy and cannot drift into two. The instrument is - // a `type: 'script'` validation for the reason #599 measured on the quote - // (and this card re-measured on this object, in - // `test/quote-discount-ceiling.test.ts`): a field-level `max` validates - // only the value being WRITTEN, so a line stored above the ceiling before - // the rule existed keeps accepting edits forever, while a script - // validation is evaluated against the MERGED record on every write and is - // therefore a true invariant. `max: 100` stays on the field as the domain - // of a percentage; the policy line lives here. - // - // ### What this rule does NOT decide - // - // 60% per line AND 60% on the quote still compounds to ~84% EFFECTIVE. - // Whether the ceiling should be read against the effective discount is a - // business-policy question with no answer in this codebase, and it is - // open as #1109 — deliberately not guessed here. A per-line ceiling is - // correct under either answer: it is the whole policy if the answer is - // per-line, and a component of it if the answer is effective. - name: "discount_within_ceiling", - type: "script", - severity: "error", - // Names the LINE, because the quote carries a same-named rule with its - // own message: on a refused save the rep must be able to tell which of - // the two numbers the platform is objecting to. - message: `Line discount cannot exceed ${QUOTE_DISCOUNT_CEILING}%`, - condition: P17`has(record.discount) && record.discount != null && record.discount > ${QUOTE_DISCOUNT_CEILING}` - } - ] -}); - -// src/marketing/objects/index.ts -var objects_exports4 = {}; -__export(objects_exports4, { - Campaign: () => Campaign, - CampaignMember: () => CampaignMember -}); - -// src/marketing/objects/campaign.object.ts -import { ObjectSchema as ObjectSchema17, Field as Field17 } from "@objectstack/spec/data"; -import { F as F12, P as P18 } from "@objectstack/spec"; -var Campaign = ObjectSchema17.create({ - name: "crm_campaign", - label: "Campaign", - pluralLabel: "Campaigns", - icon: "megaphone", - description: "Marketing campaigns and initiatives", - // ADR-0090 D1/D7: OWD is an authored decision. Campaign catalog is org-visible; only owners edit. - sharingModel: "public_read", - // ADR-0079: render-only `titleFormat` retired in favor of `nameField`, - // which names a real field. The former template composed two local fields, so - // a `display_title` formula field reproduces it for the record title. - nameField: "display_title", - // Explicit search targets (ADR-0061). REQUIRED because nameField is a - // FORMULA (display_title/full_name): without this, $search auto-defaults to - // the formula field, which isn't a real column, so the lookup picker + global - // search silently return zero. These are real, indexed columns. - searchableFields: ["name", "campaign_code"], - highlightFields: ["campaign_code", "name", "type", "status", "start_date"], - // Every other business object with a detail page groups its fields; campaign - // was one of the two that did not, so its detail page fell back to one flat - // 30-field grid with the ROI formulas sitting next to the campaign name. The - // labels mirror the sections the campaign form uses (Campaign Information / - // Schedule / Budget & ROI / Performance) so the two surfaces agree — the - // form's old three-section shape buried the two manual-entry cost fields in a - // combined "Schedule & Budget" row and was split to match this one (#597). - fieldGroups: [ - { key: "basic", label: "Campaign Information", icon: "megaphone" }, - { key: "schedule", label: "Schedule", icon: "calendar" }, - { key: "budget", label: "Budget & ROI", icon: "dollar-sign" }, - { key: "metrics", label: "Performance", icon: "bar-chart" }, - { key: "assignment", label: "Ownership", icon: "user" }, - { key: "assets", label: "Campaign Assets", icon: "link", collapse: "collapsed" } - ], - fields: { - // Platform ownership anchor — canonical note in `account.object.ts` (#548). - owner_id: Field17.lookup("sys_user", { - label: "Campaign Owner", - group: "assignment", - system: true, - readonly: false, - trackHistory: true - }), - // AutoNumber field - campaign_code: Field17.autonumber({ - group: "basic", - label: "Campaign Code", - format: "CPG-{0000}" - }), - // Basic Information - name: Field17.text({ - group: "basic", - label: "Campaign Name", - required: true, - storage: { notNull: true }, - searchable: true, - maxLength: 255 - }), - // ADR-0079 record title (was titleFormat '{campaign_code} - {name}'). - display_title: Field17.formula({ - group: "basic", - label: "Display Title", - expression: F12`record.campaign_code + " - " + record.name` - }), - description: Field17.markdown({ - group: "basic", - label: "Description" - }), - // Type & Channel - type: Field17.select({ - group: "basic", - label: "Campaign Type", - options: [ - { label: "Email", value: "email", default: true }, - { label: "Webinar", value: "webinar" }, - { label: "Trade Show", value: "trade_show" }, - { label: "Conference", value: "conference" }, - { label: "Direct Mail", value: "direct_mail" }, - { label: "Social Media", value: "social_media" }, - { label: "Content Marketing", value: "content" }, - { label: "Partner Marketing", value: "partner" } - ] - }), - channel: Field17.select({ - group: "basic", - label: "Primary Channel", - options: [ - { label: "Digital", value: "digital" }, - { label: "Social", value: "social" }, - { label: "Email", value: "email" }, - { label: "Events", value: "events" }, - { label: "Partner", value: "partner" } - ] - }), - // Status - status: Field17.select({ - group: "basic", - label: "Status", - options: [ - { label: "Planning", value: "planning", color: "#999999", default: true }, - { label: "In Progress", value: "in_progress", color: "#FFA500" }, - { label: "Completed", value: "completed", color: "#00AA00" }, - { label: "Aborted", value: "aborted", color: "#FF0000" } - ], - required: true, - storage: { notNull: true }, - trackHistory: true - }), - // Dates - start_date: Field17.date({ - group: "schedule", - label: "Start Date", - required: true, - storage: { notNull: true } - }), - end_date: Field17.date({ - group: "schedule", - label: "End Date", - required: true, - storage: { notNull: true } - }), - // Budget & ROI - budgeted_cost: Field17.currency({ - group: "budget", - label: "Budgeted Cost", - min: 0 - }), - actual_cost: Field17.currency({ - group: "budget", - label: "Actual Cost", - min: 0 - }), - expected_revenue: Field17.currency({ - group: "budget", - label: "Expected Revenue", - min: 0 - }), - // ⛔ NOT `readonly` (here and on the num_* snapshot fields below), and the - // reason holds on the pinned engine rather than on the retired 16.x claim - // this note used to carry. The metric block — `CAMPAIGN_METRIC_FIELDS` in - // `campaign.hook.ts` — is written by FOUR refresh hooks, not by the - // long-retired `campaign_snapshot_metrics`: `campaign_metrics_refresh`, - // `campaign_attribution_refresh`, `campaign_lead_conversion_refresh` and - // `campaign_member_metrics_refresh`. Every one of them writes - // `api.object('crm_campaign').update(...)`, and none declares `Hook.runAs`, - // which defaults to `'inherit'` — so `ctx.api` is a `ScopedContext` over the - // ACTING USER's context, and the keys are CALLER-supplied to a - // non-`isSystem` UPDATE, exactly what `stripReadonlyFields` deletes. Their - // least-privileged trigger is an ordinary user edit — a rep moving a - // campaign's status, saving an opportunity, enrolling a member — so - // `readonly` here would freeze the whole block at its seeded values. - // Measured in `test/activity-recency.test.ts`, which runs this same - // `ctx.api` shape through the real engine under a plain user context. - actual_revenue: Field17.currency({ - group: "budget", - label: "Actual Revenue", - min: 0 - }), - // Metrics - target_size: Field17.number({ - group: "metrics", - label: "Target Size", - description: "Target number of leads/contacts", - min: 0 - }), - // NOT `readonly`: written by the same four refresh hooks, and for the same - // reason — see the note on `actual_revenue` above. - // Definition: total members enrolled. - num_sent: Field17.number({ - group: "metrics", - label: "Number Sent", - min: 0 - }), - num_responses: Field17.number({ - group: "metrics", - label: "Number of Responses", - min: 0 - }), - num_leads: Field17.number({ - group: "metrics", - label: "Number of Leads", - min: 0 - }), - num_converted_leads: Field17.number({ - group: "metrics", - label: "Converted Leads", - min: 0 - }), - num_opportunities: Field17.number({ - group: "metrics", - label: "Opportunities Created", - min: 0 - }), - num_won_opportunities: Field17.number({ - group: "metrics", - label: "Won Opportunities", - min: 0 - }), - // Calculated Metrics (Formula Fields) - response_rate: Field17.formula({ - group: "metrics", - label: "Response Rate %", - expression: F12`coalesce(record.num_sent, 0) > 0 ? (coalesce(record.num_responses, 0) * 100.0) / record.num_sent : 0.0`, - scale: 2 - }), - roi: Field17.formula({ - group: "budget", - label: "ROI %", - expression: F12`coalesce(record.actual_cost, 0) > 0 ? ((coalesce(record.actual_revenue, 0) - record.actual_cost) * 100.0) / record.actual_cost : 0.0`, - scale: 2 - }), - // No `parent_campaign`. Campaign hierarchy was declared and never used: no - // page, doc or report mentioned it, and the honest consumer for it — a - // rolled-up ROI — cannot be one declaration. `roi` here is a formula over - // this campaign's OWN `actual_cost` / `actual_revenue`, so a hierarchy ROI - // would put a second, differently-scoped ROI on the same record and leave - // every reader to guess which one they were looking at. - // Campaign Assets - landing_page_url: Field17.url({ - group: "assets", - label: "Landing Page" - }), - is_active: Field17.boolean({ - group: "assets", - label: "Active", - defaultValue: true - }) - }, - // Database indexes - indexes: [ - { fields: ["name"] }, - { fields: ["type"] }, - { fields: ["status"] }, - { fields: ["start_date"] }, - { fields: ["owner_id"] } - ], - // Enable advanced features - // API surface. History → Field.trackHistory (ADR-0052). - enable: { - apiEnabled: true, - apiMethods: ["get", "list", "create", "update", "delete"] - }, - // Validation Rules - // - // Predicates below are TOTAL: every `record.x` read is `has()`-guarded, so the - // rule returns a verdict even when the merged record has no such key. See - // AGENTS.md "Validation predicates must be TOTAL" and - // test/object-validation-predicates.test.ts, which fails the build otherwise. - validations: [ - { - name: "end_after_start", - type: "script", - severity: "error", - message: "End Date must be after Start Date", - // `<=`, not `<`: the message promises "after", so a campaign that ends - // the day it starts is a violation. Matches `crm_contract`'s twin rule - // and `crm_forecast.period_end_after_start` (#514 item 12). - condition: P18`has(record.end_date) && record.end_date != null && has(record.start_date) && record.start_date != null && record.end_date <= record.start_date` - }, - { - name: "actual_cost_within_budget", - type: "script", - severity: "warning", - message: "Actual Cost exceeds Budgeted Cost", - condition: P18`has(record.actual_cost) && record.actual_cost != null && has(record.budgeted_cost) && record.budgeted_cost != null && record.actual_cost > record.budgeted_cost` - } - ] - // Workflow Rules - // ⚠️ No `workflows[]` here, and none is possible: object `workflows[]` were - // removed from the platform. Field updates live in this object's `*.hook.ts`; - // scheduled status flips and notifications live in `src/*/flows/*.flow.ts`. -}); - -// src/marketing/objects/campaign_member.object.ts -import { ObjectSchema as ObjectSchema18, Field as Field18 } from "@objectstack/spec/data"; -import { P as P19 } from "@objectstack/spec"; -var CampaignMember = ObjectSchema18.create({ - name: "crm_campaign_member", - label: "Campaign Member", - pluralLabel: "Campaign Members", - icon: "user-plus", - description: "Membership and response tracking for marketing campaigns", - // ADR-0090 D1/D7: OWD is an authored decision. Membership is an attribute of - // the campaign, so record access DERIVES from it (ADR-0055). The relation - // resolver accepts the REQUIRED `crm_campaign` LOOKUP as the parent, so no - // master-detail conversion is needed. - // - // The derivation delivers exactly "members whose `crm_campaign` the caller - // can read". ⚠️ Master accessibility resolves through the same paths a direct - // read of the campaign takes — ownership and `sys_record_share` grants folded - // in ALONGSIDE the master's row-level security policies, not the policies - // alone. `test/parent-derived-reach.test.ts` pins that, and was written to go - // red the day the platform changes it: an earlier version consulted master - // RLS ONLY, under a SYSTEM context, so with no policy narrowing a SELECT on - // `crm_campaign` a member row was readable by every holder of object-level - // read on this object. - // - // ⚠️ The write side reaches further than reads: the platform's - // `member_default` set carries an owner-only-writes RLS policy on updates, - // and because the derivation folds master RLS in, that policy reaches through - // to member writes — see the `marketing_campaign_updates` note in - // `src/sales/profiles/marketing-user.profile.ts`. - // - // ⛔ Not `private`: with no owner field on the junction row that resolves to - // "whoever inserted it", which is nobody's idea of campaign membership and - // hides rows written by the enrollment flow. - sharingModel: "controlled_by_parent", - // Per-field history is opt-in via `Field.trackHistory` (ADR-0052), set on - // `status` below — there is no object-level history flag. - // ADR-0079: junction rows have no derivable text title; point the canonical - // nameField at the stored autonumber explicitly (autonumber is not in the - // auto-derivation whitelist). - nameField: "member_number", - // Load-bearing on TWO surfaces, and the second one is why this list is not - // the side that gave way to fix `field-group-shadowed` below (#715). Besides the - // detail highlight strip, it is what curates the members panel on a - // campaign's detail page: a related list takes its columns from the child's - // `highlightFields` minus the lookup it is scoped by, and this object ships - // no view at all, so dropping `crm_lead`/`crm_contact` here would leave that - // panel showing Status / Response Date and no person — measured and pinned in - // `test/view-references.test.ts` (#944). - highlightFields: ["crm_campaign", "crm_lead", "crm_contact", "status", "response_date"], - // Both groups render on detail pages as well as on forms, and keeping them - // that way is a constraint on the two lists above, not a free choice (#715). - // A synthesized detail page hoists the record title plus the first four - // highlightFields out of the body, so a group whose every field is hoisted - // keeps its heading on forms and silently disappears from detail pages - // (`field-group-shadowed`). - // `basic` was exactly that: member_number is the title, and campaign/lead/ - // contact are the first three of the strip. `added_date` — the enrollment - // stamp, which describes the MEMBERSHIP rather than the person's response — - // sits here rather than under `response` so the group has something of its - // own to show. Same resolution as `crm_task`'s shadowed `assignment` group - // (#582): move the field to the group it reads under, leave the strip alone. - fieldGroups: [ - { key: "basic", label: "Basic Information", icon: "info" }, - { key: "response", label: "Response Tracking", icon: "activity" } - ], - fields: { - member_number: Field18.autonumber({ - label: "Member Number", - format: "CM-{00000}", - group: "basic" - }), - crm_campaign: Field18.lookup("crm_campaign", { - label: "Campaign", - required: true, - storage: { notNull: true }, - group: "basic", - // Curates the members panel on a campaign — and it is the ONE mechanism - // that actually reaches that panel. Measured in #944 and restated in - // `test/view-references.test.ts`: a detail-page related list reads - // `relatedListColumns` on the CHILD's lookup first, and only without it - // falls back to the child's `highlightFields` minus this lookup. The - // child's `list` view is never consulted, which is why authoring one - // here would not have shown anything. - // - // It is a SUPERSET of the fallback it replaces — Lead / Contact / - // Status / Response Date, in that order — plus the one column the panel - // was missing. `added_date` is the enrollment stamp: `readonly: true` - // (#1667) and written on every enrollment by the two elevated sub-flows - // #1807 built for it, so a marketer could see WHEN a member responded - // but not when they were added, on a register whose whole subject is - // the enrollment. It sits after the person and before the response - // lifecycle, which is the order the row happens in. - // - // ⛔ Deliberately NOT solved by adding `added_date` to - // `highlightFields`: that strip is hoisted out of the detail body, and - // `added_date` is the only field in the `basic` group that is neither - // the record title nor already in the strip — hoisting it would leave - // the group with nothing of its own and silently vanish its heading - // from every detail page (`field-group-shadowed`, the trap the note - // above this object's `fieldGroups` records being rescued from). - relatedListColumns: ["crm_lead", "crm_contact", "added_date", "status", "response_date"] - }), - // `deleteBehavior: 'cascade'` on BOTH party lookups (#696). A lookup - // defaults to `set_null`, and that default made every enrolled person - // permanently undeletable: deleting the lead cleared this column, the - // cleared row instantly violated `lead_or_contact_required` below, and the - // whole delete rolled back with a 400 naming an object the caller never - // touched ("A campaign member must reference either a Lead or a Contact", - // `"object":"crm_lead"`). A GDPR "delete this person" request could not be - // served through the API or the UI. - // - // Cascade rather than `restrict`: this is a JUNCTION row whose entire - // meaning is "this person is enrolled in this campaign". Once the person is - // gone the row denotes nothing, so keeping it (restrict) would only trade - // one undeletable person for a manual un-enrol chore, and the impact this - // fixes is undeletable people, not a confusing message. Cascade also makes - // the object's own rule unfalsifiable by construction: there is no longer a - // reachable state in which a stored member row breaks it. - crm_lead: Field18.lookup("crm_lead", { - label: "Lead", - group: "basic", - deleteBehavior: "cascade", - description: "Set when the member was a Lead at enrollment time" - }), - crm_contact: Field18.lookup("crm_contact", { - label: "Contact", - group: "basic", - deleteBehavior: "cascade", - description: "Set when the member is an existing Contact" - }), - // ⭐ `readonly: true` — DECLARED, and it still costs no writer its write, - // but the reason CHANGED on the @objectstack/* 17.4.0 migration. It used to - // be "the strip is an UPDATE-path rule and every writer here is an INSERT". - // objectql 17.4.0 retired that: a static readonly field is now stripped from - // a NON-SYSTEM caller's INSERT payload inside `engine.insert` too, so an - // ordinary user-context create no longer seeds this column. - // - // Every writer is therefore elevated now, and the elevation is scoped as - // narrowly as AGENTS.md house rule 9 requires — the `campaign_enrollment` - // SCREEN flow stays `runAs: 'user'` and hands only the insert to - // `campaign_lead_member_enroll` / `campaign_contact_member_enroll` - // (`runAs: 'system'`, one `create_record` each); the marketing seed is a - // system write already. Nothing updates it: there is no `update_record` - // node, no hook and no action that writes `added_date`. This column's own - // two halves are pinned in `test/audit-stamp-readonly.test.ts` — the - // enrollment writers still stamp it, and a user-context UPDATE is stripped. - // Ruled #1667 (director seat, decision batch #74, 2026-09-07): an - // enrollment stamp nobody is meant to hand-edit gets the declaration that - // says so. ⛔ The 16.x claim this note used to carry ("every member landed - // with a null Added Date while the flag was on") described an engine this - // repo no longer runs; ⛔ do not resurrect it as a reason to open the - // column back up. - // - // Grouped under `basic`, not `response` (#715): it records when the - // membership was created, which is a fact about the enrollment, not a step - // in the response lifecycle the other stamps track. - added_date: Field18.datetime({ - label: "Added Date", - group: "basic", - readonly: true - }), - // Writers, one per surviving value (#597): - // sent — campaign_enrollment flow, `create_campaign` (leads) and - // `add_contact_to_campaign` (contacts) stamp it on insert. - // responded — the `mark_responded` action (src/marketing/actions/campaign.actions.ts). - // converted — the member's lead converting; `campaign_lead_conversion_refresh` - // (src/sales/objects/lead.campaign-metrics.hook.ts) promotes - // the row when `crm_lead.is_converted` flips. - // unsubscribed — set by a rep (or an opt-out request) on the member row; - // `campaign_member_optout_sync` round-trips it to the - // lead/contact's `email_opt_out`, which is what makes the - // enrollment flow's opt-out filter honour it next run. - // - // `opened` / `clicked` / `bounced` were removed here — see the object - // docblock. Nothing on the platform can produce them. - status: Field18.select({ - label: "Status", - required: true, - storage: { notNull: true }, - group: "response", - trackHistory: true, - options: [ - { label: "Sent", value: "sent", default: true, color: "#A0A0A0" }, - { label: "Responded", value: "responded", color: "#00AA00" }, - { label: "Converted", value: "converted", color: "#7C3AED" }, - { label: "Unsubscribed", value: "unsubscribed", color: "#FF0000" } - ] - }), - // Written by the `mark_responded` action, and by - // `campaign_member_lifecycle` when it back-fills a member whose response - // was recorded by flipping `status` directly. - response_date: Field18.datetime({ - label: "Response Date", - group: "response" - }), - // Kept in lockstep with `status == "responded"` by - // `campaign_member_lifecycle` (beforeInsert/beforeUpdate) — a boolean that - // disagrees with the status it summarises is the shape the response - // surfaces cannot render, and it is what `test/seed-consistency.test.ts` - // already pins on the seed side. - has_responded: Field18.boolean({ - label: "Has Responded", - defaultValue: false, - group: "response" - }) - }, - // Predicates below are TOTAL: every `record.x` read is `has()`-guarded, so the - // rule returns a verdict even when the merged record has no such key. See - // AGENTS.md "Validation predicates must be TOTAL" and - // test/object-validation-predicates.test.ts, which fails the build otherwise. - validations: [ - { - name: "lead_or_contact_required", - type: "script", - severity: "error", - message: "A campaign member must reference either a Lead or a Contact", - condition: P19`(!has(record.crm_lead) || isBlank(record.crm_lead)) && (!has(record.crm_contact) || isBlank(record.crm_contact))` - } - ] -}); - -// src/sales/actions/index.ts -var actions_exports = {}; -__export(actions_exports, { - AccountLogCallAction: () => AccountLogCallAction, - AccountLogMeetingAction: () => AccountLogMeetingAction, - AccountScheduleMeetingAction: () => AccountScheduleMeetingAction, - AddContactToCampaignAction: () => AddContactToCampaignAction, - CloneOpportunityAction: () => CloneOpportunityAction, - ContactLogCallAction: () => ContactLogCallAction, - ContactLogMeetingAction: () => ContactLogMeetingAction, - ContactScheduleMeetingAction: () => ContactScheduleMeetingAction, - ConvertLeadAction: () => ConvertLeadAction, - CreateCampaignAction: () => CreateCampaignAction, - GenerateQuoteAction: () => GenerateQuoteAction, - LeadLogCallAction: () => LeadLogCallAction, - LeadLogMeetingAction: () => LeadLogMeetingAction, - LeadScheduleMeetingAction: () => LeadScheduleMeetingAction, - MarkPrimaryContactAction: () => MarkPrimaryContactAction, - MassUpdateStageAction: () => MassUpdateStageAction, - OpportunityLogCallAction: () => OpportunityLogCallAction, - OpportunityLogMeetingAction: () => OpportunityLogMeetingAction, - OpportunityScheduleMeetingAction: () => OpportunityScheduleMeetingAction, - ScheduleFollowUpAction: () => ScheduleFollowUpAction, - SendEmailAction: () => SendEmailAction -}); - -// src/sales/actions/contact.actions.ts -import { P as P20 } from "@objectstack/spec"; -var MarkPrimaryContactAction = { - name: "mark_primary", - label: "Mark as Primary Contact", - objectName: "crm_contact", - icon: "star", - type: "script", - body: { - language: "js", - source: ` - const id = ctx.recordId; - if (!id) throw new Error('mark_primary requires a recordId'); - await ctx.api.object('crm_contact').update({ id, is_primary: true }, { where: { id } }); - return { ok: true, id, is_primary: true }; - `, - capabilities: ["api.write"], - timeoutMs: 2e3 - }, - locations: ["record_header", "list_item"], - visible: P20`has(record.is_primary) && record.is_primary == false`, - confirmText: "Mark this contact as the primary contact for the account?", - successMessage: "Contact marked as primary!", - refreshAfter: true -}; -var AddContactToCampaignAction = { - name: "add_contact_to_campaign", - label: "Add to Campaign", - objectName: "crm_contact", - icon: "send", - type: "script", - body: { - language: "js", - source: ` - // Value key = the param's field name ('crm_campaign') since the param - // omits an explicit 'name'. Insert uses the REAL lookup field names on - // crm_campaign_member (crm_campaign / crm_contact). - const campaignId = input.crm_campaign ?? null; - if (!campaignId) throw new Error('add_contact_to_campaign requires a campaign id'); - const ids = ctx.recordId ? [ctx.recordId] : []; - if (!ids.length) throw new Error('add_contact_to_campaign: no contact selected'); - const raw = await ctx.api.object('crm_campaign_member').find({ - where: { crm_campaign: campaignId }, - fields: ['crm_contact'], - top: 5000, - }); - const existingRows = Array.isArray(raw) ? raw : (raw?.records ?? []); - const existing = new Set(existingRows.map((r) => r.crm_contact)); - const inserted = []; - let skipped = 0; - for (const contactId of ids) { - if (existing.has(contactId)) { skipped++; continue; } - const row = await ctx.api.object('crm_campaign_member').insert({ - crm_campaign: campaignId, - crm_contact: contactId, - status: 'sent', - }); - inserted.push(row?.id ?? null); - } - return { campaignId, count: inserted.length, skipped, ids: inserted }; - `, - capabilities: ["api.read", "api.write"], - timeoutMs: 1e4 - }, - locations: ["list_toolbar", "list_item"], - params: [ - { - field: "crm_campaign", - objectOverride: "crm_campaign_member", - label: "Campaign", - required: true - } - ], - // An opted-out contact must not be added to a campaign by hand either — the - // enrollment flow already filters them out, and a manual add-to-campaign is - // the obvious way around a filter nobody remembers is there. Same predicate - // the `send_email` action uses. - visible: P20`has(record.email_opt_out) && record.email_opt_out == false`, - successMessage: "Contacts added to campaign!", - refreshAfter: true -}; -var SendEmailAction = { - name: "send_email", - label: "Send Email", - objectName: "crm_contact", - icon: "mail", - // script, not modal: modal submits die on GET /api/v1/meta/object/ - // → 400 in 16.1.0; script actions POST /api/v1/actions/... and execute. - type: "script", - body: { - language: "js", - source: ` - const record = ctx.record ?? {}; - const recipientId = ctx.recordId ?? record.id ?? null; - const to = record.email ? String(record.email) : ''; - const from = ctx.user?.email ?? 'noreply@hotcrm.local'; - const userId = ctx.user?.id ?? null; - const subject = input.subject ? String(input.subject) : ('Email to ' + to); - const body = input.body ? String(input.body) : ''; - const email = await ctx.api.object('sys_email').insert({ - from_address: from, - to_addresses: to, - subject, - body_text: body, - status: 'queued', - related_object: 'crm_contact', - related_id: recipientId, - sent_by: userId, - }); - - ${ACTOR_NAME_RESOLUTION_SOURCE} - - // Surface the email on the contact's unified activity timeline - // (the audit writer only logs generic CRUD; this is the semantic event). - const activity = await ctx.api.object('sys_activity').insert({ - type: 'completed', - summary: 'Email: ' + subject, - actor_id: userId, - actor_name: actorName, - object_name: 'crm_contact', - record_id: recipientId, - record_label: record.full_name ?? record.name ?? to, - // ADR-0052 ActivityPointer: structured pointer to the rich source entity - // (the sys_email row) so the timeline renders a "View source \u2192" drill to - // the full email \u2014 the queryable replacement for stashing the id in metadata. - source_object: 'sys_email', - source_id: email?.id ?? null, - metadata: JSON.stringify({ kind: 'email', to, subject }), - }); - // #592 scope item 3: every activity writer bumps interaction recency. - // An email is an interaction but NOT a calendar slot, so it writes no - // \`crm_event\` \u2014 which means it cannot ride the event hook's bubble and - // has to stamp the two timestamps itself. Both columns are deliberately - // non-readonly (see crm_account.last_activity_date's note): a readonly - // field is stripped from any non-system write whose caller supplied the - // key (#2948), and an action body runs under the sending rep's context. - if (recipientId) { - const nowIso = new Date().toISOString(); - try { - await ctx.api.object('crm_contact').update( - { id: recipientId, last_contacted_date: nowIso }, - { where: { id: recipientId } }, - ); - } catch (e) { /* best-effort recency; never fail the send */ } - const accountId = record.crm_account ? String(record.crm_account) : null; - if (accountId) { - try { - await ctx.api.object('crm_account').update( - { id: accountId, last_activity_date: nowIso.slice(0, 10) }, - { where: { id: accountId } }, - ); - } catch (e) { /* best-effort recency; never fail the send */ } - } - } - return { emailId: email?.id, activityId: activity?.id }; - `, - capabilities: ["api.read", "api.write"], - timeoutMs: 5e3 - }, - locations: ["record_header", "list_item"], - visible: P20`has(record.email_opt_out) && record.email_opt_out == false`, - params: [ - { name: "subject", label: "Subject", type: "text", required: true }, - { name: "body", label: "Body", type: "textarea", required: true } - ], - refreshAfter: false -}; - -// src/sales/actions/lead.actions.ts -import { P as P21 } from "@objectstack/spec"; -var ConvertLeadAction = { - name: "convert_lead", - label: "Convert Lead", - objectName: "crm_lead", - icon: "arrow-right-circle", - type: "flow", - target: "lead_conversion", - locations: ["record_header", "list_item"], - // Convert is the lead's most basic outcome — surface it on ANY open lead - // (new / contacted / qualified), not just qualified. Gating to qualified-only - // hid the button on most seeded leads, so it read as "conversion is missing". - // Only already-converted or disqualified leads hide it. - // - // TOTALITY (AGENTS.md → "Validation predicates must be TOTAL", #630): every - // `record.x` read carries a `has(record.x)`, and the guards are arranged to - // fail CLOSED — an unknown record hides the button. That arrangement is a - // MEASUREMENT, not a preference. Measured in the browser on console 17.4.0 by - // instrumenting the shipped predicate evaluator: the record page evaluates this - // predicate twice against an EMPTY record (`record` is `{}`, zero keys) before - // the row lands, then re-evaluates it against the full row. So an absent - // `status` here means "no record yet", never "a lead with no status" — a lead - // with no status cannot exist, since `status` is `required` with - // `storage: { notNull: true }` and `defaultValue: 'new'` (src/sales/objects/lead.object.ts), - // and the REST payload this surface reads carries every declared column. - // Fail-open (`!has(record.status) || …`) would therefore buy nothing and cost - // something real: Convert would flash on a disqualified lead for the - // pre-hydration beat, on an IRREVERSIBLE action. - // Unguarded, strict CEL aborted the whole predicate on those two renders - // (`[runtime] No such key: status`) and object-ui fell back to its own - // `fallback: false`, so this spelling states the policy the error path was - // already applying — minus the console warning on every lead page load. (#1890) - // - // ⚠️ The approval term is the ONE fail-OPEN read in this predicate, and the - // asymmetry is deliberate rather than an oversight in an otherwise - // fail-closed arrangement (REQ-0005 step 7). The two terms above fail closed - // because an absent `status` means "no record yet" — a lead with no status - // cannot exist, since `status` is `required` with a `defaultValue`. An absent - // `conversion_approval_status` means something else entirely: a lead written - // before the column existed, which must convert the way it always did. And - // the shipped `not_required` default is the gate's OFF position, so treating - // "not one of the two refusing verdicts" as convertible is what makes the - // default install behave exactly as it did before this field. `lead.hook.ts` - // and `lead-conversion.flow.ts`'s `decision_approval` carry the same polarity - // — the three surfaces have to agree about what "off" means, or the button - // disappears on leads the write path would happily convert. - // - // ⛔ Hiding this button is NOT the gate. It is the courtesy half; the control - // is the `beforeUpdate` refusal in `lead.hook.ts`, which a REST caller cannot - // route around. - visible: P21`has(record.is_converted) && record.is_converted == false && has(record.status) && record.status != "unqualified" && record.status != "converted" - && (!has(record.conversion_approval_status) || (record.conversion_approval_status != "pending" && record.conversion_approval_status != "rejected"))`, - // NO `confirmText`. A screen flow IS the confirmation, and this one opens - // `Conversion Details` — a screen carrying the decision (`Create - // Opportunity?`, and the deal's name and amount), a Cancel button, and the - // suspected-duplicate warning that says something TRUE about THIS lead. A - // dialog in front of it costs every conversion one extra click to answer a - // question it cannot help anyone answer. Confirms are for DESTRUCTIVE actions - // with no follow-up UI — `close_case` / `escalate_case` in `case.actions.ts` - // are the shape that still earns one. - // - // Mechanism, measured on the console this app pinned at that taking - // (@objectstack/console 17.3.0, `dist/assets/`; this bundle read was ⛔ NOT - // re-taken on any later pin — 17.4.0, PR #1814, or 17.5.0) rather than - // assumed: the runner gates the dialog on - // the key's presence alone — - // if (action.confirmText && !await confirmHandler(evaluate(action.confirmText))) - // return { success: false, error: 'Action cancelled by user' }; - // — so REMOVING the key is what removes the dialog; there is no `confirm: - // false` to write, and no other key re-raises it. - successMessage: "Lead converted successfully!", - refreshAfter: true, - // ADR-0011 — opt this Action in to AI, which materialises the - // `action_convert_lead` tool the `lead_qualification` skill references. - // Flow-typed with a target, so it has a headless path. `requiresConfirmation` - // is the only key the AI path reads: `actionLooksDestructive` consults - // `ai.requiresConfirmation` and nothing else, and the console's - // confirm-dialog string reached no AI code — so dropping `confirmText` above - // leaves the AI approval signal exactly where it was. The flag is SURFACED, - // not enforced — `list_actions` reports `requiresConfirmation: true` and the - // calling client decides what to do with it, while `run_action` dispatches - // the flow with no server-side pause. It warns the caller that this is - // irreversible; it is not a lock. - ai: { - exposed: true, - requiresConfirmation: true, - description: "Converts a qualified lead into an account, contact and opportunity. Irreversible \u2014 requires human approval before it runs." - } -}; -var ScheduleFollowUpAction = { - name: "schedule_followup", - label: "Schedule Follow-up", - objectName: "crm_lead", - icon: "calendar-plus", - type: "flow", - target: "schedule_followup", - locations: ["record_header", "list_item"], - // A converted or disqualified lead has no next touch to schedule. - visible: P21`has(record.is_converted) && record.is_converted == false && has(record.status) && record.status != "unqualified" && record.status != "converted"`, - successMessage: "Follow-up scheduled.", - refreshAfter: true, - // ADR-0011 — materialises `action_schedule_followup` for the - // `lead_qualification` skill. Additive and reversible, so no approval gate. - ai: { - exposed: true, - description: "Schedules the next follow-up task on a lead, assigned to its owner, so the next touch lands on the rep list." - } -}; -var CreateCampaignAction = { - name: "create_campaign", - label: "Add to Campaign", - objectName: "crm_lead", - icon: "send", - // script, not modal — a `type: 'modal'` action has NO server dispatch at all: - // the renderer just opens its `target`, and the runtime refuses it over REST - // (`headlessActionTypeError`, 400 "a client-side action with no server - // dispatch"), so its `body` never runs. To collect input and then run - // server-side, the shape is `type: 'script'` + `params` — the runner collects - // the same dialog. See ScheduleFollowUpAction. - type: "script", - body: { - language: "js", - source: ` - // Value key = the param's field name ('crm_campaign') since the param - // omits an explicit 'name'. Insert uses the REAL lookup field names on - // crm_campaign_member (crm_campaign / crm_lead) \u2014 not the generic - // campaign_id / lead_id an earlier revision of the doc example taught, - // which don't exist here and left crm_campaign null \u2192 'Campaign required' - // validation failure. - const campaignId = input.crm_campaign ?? null; - if (!campaignId) throw new Error('create_campaign requires a campaign id'); - // One lead per dispatch \u2014 the bare-string \`bulkActions\` wiring fans this - // body out once per selected row (see the note above). \`ids\` stays a - // list so the dedupe + skip loop below reads the same on both contracts, - // should this action ever move to an aggregate def. - const ids = ctx.recordId ? [ctx.recordId] : []; - if (!ids.length) throw new Error('create_campaign: no lead selected'); - // Skip leads already on this campaign \u2014 the modal copy promises - // duplicates are skipped, and re-running the action on the same - // selection must not double-count marketing touches. - const raw = await ctx.api.object('crm_campaign_member').find({ - where: { crm_campaign: campaignId }, - fields: ['crm_lead'], - top: 5000, - }); - const existingRows = Array.isArray(raw) ? raw : (raw?.records ?? []); - const existing = new Set(existingRows.map((r) => r.crm_lead)); - const inserted = []; - let skipped = 0; - for (const leadId of ids) { - if (existing.has(leadId)) { skipped++; continue; } - const row = await ctx.api.object('crm_campaign_member').insert({ - crm_campaign: campaignId, - crm_lead: leadId, - status: 'sent', - }); - inserted.push(row?.id ?? null); - } - return { campaignId, count: inserted.length, skipped, ids: inserted }; - `, - capabilities: ["api.read", "api.write"], - timeoutMs: 1e4 - }, - // list_item gives every row a working record-scoped entry point. The - // list_toolbar button is single-record by construction: with no `_selectedIds` - // in the bag the dispatcher resolves a recordId from the grid selection, and a - // multi-row selection there is ambiguous, so it is refused client-side with - // "This action runs on a single record — select exactly one row." - // Multi-lead enrollment is the SELECTION-BAR button instead, which the view's - // `bulkActions: ['create_campaign']` produces and which fans out per row. - locations: ["list_toolbar", "list_item"], - params: [ - // Field-backed param: `field` + `objectOverride` make the console resolve - // the widget from crm_campaign_member.crm_campaign (a lookup → crm_campaign), - // rendering a RECORD PICKER. A bare `{ type:'lookup' }` with no field can't - // resolve a target object and silently falls back to a paste-the-ID textbox. - { - field: "crm_campaign", - objectOverride: "crm_campaign_member", - label: "Campaign", - required: true - } - ], - successMessage: "Leads added to campaign!", - refreshAfter: true -}; - -// src/sales/actions/opportunity.actions.ts -import { P as P22 } from "@objectstack/spec"; -var CloneOpportunityAction = { - name: "clone_opportunity", - label: "Clone Opportunity", - objectName: "crm_opportunity", - icon: "copy", - type: "script", - body: { - language: "js", - source: ` - const id = ctx.recordId; - if (!id) throw new Error('clone_opportunity requires a recordId'); - // Read the source from ctx.record (seeded by the runner for record-scoped - // actions \u2014 same source send_email uses). This avoids the in-sandbox - // find() that previously faulted, WHILE still copying the REQUIRED fields - // (crm_account / amount / close_date). The old minimal insert set only - // name+stage, so every clone failed the object's required-field + amount>0 - // validations at runtime and no opportunity was ever created. - const src = ctx.record ?? {}; - if (!src.crm_account) { - throw new Error('clone_opportunity: source account not loaded; cannot clone.'); - } - // Give the clone a fresh 90-day close horizon so a copied past date can't - // trip the "close date in the past" validation on a new prospecting deal. - // - // The step is on the UTC calendar because the render below is - // (\`toISOString()\`). The base is \`new Date()\` \u2014 an instant, not a - // stored \`YYYY-MM-DD\` \u2014 so unlike quote.hook/task.hook there is no - // UTC-midnight anchor being read back on the wrong calendar here; the - // only mixture was the step itself. A local \`getDate\`/\`setDate\` step - // preserves WALL-CLOCK time, so a 90-day window containing a DST - // transition is 23 h or 25 h long and the rendered UTC day lands one off - // whenever the clone instant is within an hour of a UTC day boundary. - const horizon = new Date(); - horizon.setUTCDate(horizon.getUTCDate() + 90); - const inserted = await ctx.api.object('crm_opportunity').insert({ - name: 'Copy of ' + (src.name ?? ('opportunity ' + id)), - crm_account: src.crm_account, - primary_contact: src.primary_contact ?? null, - amount: src.amount ?? 1, - stage: 'prospecting', - probability: 10, - close_date: horizon.toISOString().slice(0, 10), - type: src.type ?? null, - lead_source: src.lead_source ?? null, - crm_campaign: src.crm_campaign ?? null, - // Explicit because an action body runs \`isSystem\`, so nothing stamps - // \`owner_id\` for it \u2014 see the note in activity-actions.ts (#548). - owner_id: ctx.user?.id ?? null, - }); - return { id: inserted?.id ?? null }; - `, - capabilities: ["api.read", "api.write"], - timeoutMs: 5e3 - }, - locations: ["record_header", "record_more"], - successMessage: "Opportunity cloned successfully!", - refreshAfter: true -}; -var MassUpdateStageAction = { - name: "mass_update_stage", - label: "Update Stage", - objectName: "crm_opportunity", - icon: "layers", - type: "script", - body: { - language: "js", - source: ` - const newStage = input.stage ?? null; - if (!newStage) throw new Error('mass_update_stage requires a stage'); - // Selection first, single record as the fallback. An aggregate dispatch - // carries the whole selection in \`_selectedIds\` and NO recordId; a - // single-record dispatch carries recordId and no selection. The two are - // never both present, so the order only decides which shape wins if the - // platform ever sends both. - const selected = Array.isArray(input._selectedIds) ? input._selectedIds : []; - const ids = selected.length ? selected : (ctx.recordId ? [ctx.recordId] : []); - if (!ids.length) throw new Error('mass_update_stage: no opportunity selected'); - const missed = []; - let firstCause = ''; - let updated = 0; - for (const id of ids) { - // \`update(data, options)\` \u2014 \`ctx.api\` is the engine repo facade, whose - // update takes a DOCUMENT, not an id. \`updateById(id, data)\` exists on - // ObjectRepository but NOT on the facade the runtime builds when it has - // no scoped context, so this spelling is the only one live on both. - // - // An id that matches no row is a MISS, not an abort, and the engine has - // answered it both ways: through @objectstack/* 17.0.0-rc.6 \`update\` - // RESOLVED WITH NULL, and from 17.0.0 it REJECTS (RECORD_NOT_FOUND / - // 404). Both are handled here, and neither may end the loop \u2014 an - // uncaught rejection on the first stale id would leave every id after - // it unattempted, so re-running the action over the same selection - // would fail at the same row forever and the live rows behind it could - // never be covered. That is strictly worse than the silent-success - // failure #588 pulled this button for, because it is unrecoverable - // from the UI. Collect the miss, keep going, reject once at the end. - // - // The catch is deliberately cause-AGNOSTIC \u2014 but NOT because the cause - // is invisible. Read on 17.4.0 (\`hostErrorToVm\`; not re-read on 17.5.0), a host - // rejection reaches a body as \`name\` and \`message\` plus, when the host - // error carries them, \`code\`, \`status\`, \`fields\` and \`userMessage\` \u2014 - // nothing else, so a stale id arrives branchable as - // \`code === 'RECORD_NOT_FOUND'\` while \`details\` really is dropped. The - // branch is not taken because every cause has the same outcome here \u2014 - // the row did not move, so collect it and keep going \u2014 and narrowing - // the catch to a roster of known codes would let an unlisted cause - // abort the loop, the failure the paragraph above forbids. Message text - // is engine wording and not contract, so \`firstCause\` is carried - // verbatim and never parsed. - let row = null; - try { - row = await ctx.api.object('crm_opportunity').update( - { id: id, stage: newStage }, - { where: { id: id } }, - ); - } catch (err) { - row = null; - if (!firstCause) firstCause = (err && err.message) ? String(err.message) : String(err); - } - // Count only what came back: counting the ATTEMPT is how a stale or - // invisible id turns into a success toast for a write that never - // happened (#588). - if (row) { updated++; } else { missed.push(id); } - } - // Aggregate dispatch is all-or-nothing (objectui#3139): a handler that - // cannot cover the whole selection must reject rather than report partial - // work, because the bar offers no per-row retry \u2014 the retry IS re-running - // the action over the selection, which is safe here since setting a stage - // is idempotent. Rows already moved in this run keep the new stage; the - // error names the ones that did not so the rep can see the difference. - if (missed.length) { - throw new Error( - 'mass_update_stage: ' + missed.length + ' of ' + ids.length - + ' selected opportunities could not be updated (' + missed.join(', ') - + '). Re-run the action on the selection to retry.' - + (firstCause ? ' First cause: ' + firstCause : '') - ); - } - return { stage: newStage, updated }; - `, - capabilities: ["api.write"], - timeoutMs: 1e4 - }, - locations: ["list_toolbar"], - params: [ - { - name: "stage", - label: "New Stage", - type: "select", - required: true, - // Mirrors crm_opportunity.stage exactly — see _picklists.ts. - options: plainOptions(OPPORTUNITY_STAGE_OPTIONS) - } - ], - successMessage: "Opportunities updated successfully!", - refreshAfter: true -}; -var GenerateQuoteAction = { - name: "generate_quote", - label: "Generate Quote", - objectName: "crm_opportunity", - icon: "receipt", - type: "flow", - target: "quote_generation", - // Mirror clone_opportunity's placement (header + overflow menu) so the action - // is reachable both as a primary button and from the "…" menu on narrow - // viewports where the header collapses. - locations: ["record_header", "record_more", "list_item"], - visible: P22`has(record.stage) && record.stage != "closed_won" && record.stage != "closed_lost"`, - successMessage: "Quote created from opportunity!", - refreshAfter: true -}; - -// src/marketing/actions/index.ts -var actions_exports2 = {}; -__export(actions_exports2, { - EnrollLeadsAction: () => EnrollLeadsAction, - MarkRespondedAction: () => MarkRespondedAction -}); - -// src/marketing/actions/campaign.actions.ts -import { P as P23 } from "@objectstack/spec"; -var EnrollLeadsAction = { - name: "enroll_leads", - label: "Enroll Members", - objectName: "crm_campaign", - icon: "user-plus", - type: "flow", - target: "campaign_enrollment", - locations: ["record_header", "record_more"], - // Enrollment only makes sense while the campaign is open — the flow - // double-checks this server-side. - visible: P23`has(record.status) && (record.status == "planning" || record.status == "in_progress")`, - successMessage: "Eligible members enrolled in campaign.", - refreshAfter: true -}; -var MarkRespondedAction = { - name: "mark_responded", - label: "Mark Responded", - objectName: "crm_campaign_member", - icon: "reply", - // script, not modal — a `type: 'modal'` action has no server dispatch at all - // and its body never runs (see `create_campaign`'s note in lead.actions.ts). - type: "script", - body: { - language: "js", - source: ` - const id = ctx.recordId; - if (!id) throw new Error('mark_responded requires a recordId'); - const respondedAt = new Date().toISOString(); - await ctx.api.object('crm_campaign_member').update( - { id, status: 'responded', has_responded: true, response_date: respondedAt }, - { where: { id } }, - ); - return { id, status: 'responded', response_date: respondedAt }; - `, - capabilities: ["api.write"], - timeoutMs: 5e3 - }, - locations: ["record_header", "list_item"], - // Already-responded and converted members have nothing to record; an - // unsubscribed member must not be dragged back into the funnel by a - // mis-click (`campaign_member_optout_sync` has already opted that person out - // of email, and this action would not undo that — leaving the two records - // disagreeing about the same person). - visible: P23`has(record.status) && record.status == "sent"`, - successMessage: "Response recorded on this campaign member.", - refreshAfter: true -}; - -// src/sales/dashboards/index.ts -var dashboards_exports = {}; -__export(dashboards_exports, { - ActivityDashboard: () => ActivityDashboard, - CrmOverviewDashboard: () => CrmOverviewDashboard, - ExecutiveDashboard: () => ExecutiveDashboard, - SalesDashboard: () => SalesDashboard -}); - -// src/sales/dashboards/activity.dashboard.ts -var ActivityDashboard = { - name: "sales_activity_dashboard", - label: "Sales Activity", - description: "Who is talking to customers, how often, and which accounts have gone quiet", - columns: 12, - gap: 4, - refreshIntervalSeconds: 300, - header: { - showTitle: true, - showDescription: true - }, - globalFilters: [ - { - field: "owner_id", - label: { en: "Rep", "zh-CN": "\u9500\u552E\u4EE3\u8868", "es-ES": "Representante", "ja-JP": "\u62C5\u5F53\u8005" }, - type: "lookup", - scope: "dashboard", - optionsFrom: { object: "sys_user", valueField: "id", labelField: "name" } - } - ], - widgets: [ - // ─── Row 1: what happened, and what is booked ───────────────────── - { - id: "interactions_held", - title: "Interactions Logged", - description: "Calls and meetings that actually happened", - type: "metric", - filter: { status: "held" }, - colorVariant: "success", - dataset: "event_metrics", - values: ["event_count"], - layout: { x: 0, y: 0, w: 3, h: 2 } - }, - { - id: "meetings_booked", - title: "Meetings Booked", - description: "Meetings on the calendar that have not happened yet", - type: "metric", - filter: { status: "planned", type: "meeting" }, - colorVariant: "blue", - dataset: "event_metrics", - values: ["event_count"], - layout: { x: 3, y: 0, w: 3, h: 2 } - }, - { - id: "customer_minutes", - title: "Customer Minutes", - description: "Total time spent in front of customers", - type: "metric", - filter: { status: "held" }, - colorVariant: "purple", - dataset: "event_metrics", - values: ["total_minutes"], - layout: { x: 6, y: 0, w: 3, h: 2 } - }, - { - // First widget in the app to use `task_metrics`. The dataset shipped with - // the "My Day" work and then had no consumer at all (#592) — a semantic - // layer nobody queries is a maintenance cost with no reader. - id: "tasks_completed", - title: "Tasks Completed", - description: "Follow-ups closed out \u2014 the other half of activity", - type: "metric", - filter: { is_completed: true }, - colorVariant: "orange", - dataset: "task_metrics", - values: ["task_count"], - layout: { x: 9, y: 0, w: 3, h: 2 } - }, - // ─── Row 2: who, and when ───────────────────────────────────────── - { - id: "activity_by_rep", - title: "Activity by Rep", - description: "Logged interactions per owner \u2014 the coverage question", - type: "bar", - filter: { status: "held" }, - colorVariant: "success", - dataset: "event_metrics", - dimensions: ["owner"], - values: ["event_count"], - layout: { x: 0, y: 2, w: 6, h: 4 }, - chartConfig: { - showLegend: false, - showDataLabels: true, - colors: ["#10B981"] - } - }, - { - id: "activity_by_week", - title: "Activity Volume by Week", - description: "Interactions per week \u2014 is the team speeding up or going quiet?", - type: "area", - filter: { status: "held" }, - colorVariant: "blue", - // The week bucket lives on the DIMENSION, not in a filter — see the - // header note on why the trend belongs on an axis here. The datetime - // filter bound itself works (objectstack#3912 / #3777, 17.0.0); putting - // the trend in a filter would narrow it, which is a different objection. - dataset: "event_metrics", - dimensions: ["start_datetime"], - values: ["event_count"], - layout: { x: 6, y: 2, w: 6, h: 4 }, - chartConfig: { - showLegend: false, - showDataLabels: false, - colors: ["#0EA5E9"], - interaction: { tooltips: true, brush: true } - } - }, - // ─── Row 3: what the activity is about ──────────────────────────── - { - id: "activity_mix", - title: "Activity Mix", - description: "Calls vs meetings vs demos", - type: "donut", - filter: { status: "held" }, - colorVariant: "purple", - dataset: "event_metrics", - dimensions: ["type"], - values: ["event_count"], - layout: { x: 0, y: 6, w: 4, h: 4 }, - chartConfig: { - showLegend: true, - showDataLabels: true, - colors: ["#4169E1", "#10B981", "#8B5CF6", "#F59E0B", "#0EA5E9", "#94A3B8"] - } - }, - { - id: "activity_by_record_type", - title: "Where the Activity Lands", - description: "Which part of the funnel is getting attention", - type: "bar", - filter: { status: "held" }, - colorVariant: "blue", - dataset: "event_metrics", - dimensions: ["related_to_type"], - values: ["event_count"], - layout: { x: 4, y: 6, w: 4, h: 4 }, - chartConfig: { - showLegend: false, - showDataLabels: true, - colors: ["#4169E1"] - } - }, - { - // "Activity per open deal" as two honest numbers rather than one - // fabricated ratio: the semantic layer has no cross-dataset calculated - // measure, so a single "1.8 activities/deal" tile would have to be - // computed by the renderer over two independent queries — which nothing - // does today. A manager reads the pair; a made-up quotient would read as - // measured. Filed as a follow-up rather than faked here. - id: "deal_activity", - title: "Interactions on Deals", - description: "Logged interactions linked to an opportunity \u2014 read against Open Deals \u2192", - type: "metric", - filter: { status: "held", related_to_type: "crm_opportunity" }, - colorVariant: "success", - dataset: "event_metrics", - values: ["event_count"], - layout: { x: 8, y: 6, w: 2, h: 4 } - }, - { - id: "open_deals_for_activity", - title: "Open Deals", - description: "Opportunities still in play", - type: "metric", - filter: { stage: { $nin: ["closed_won", "closed_lost"] } }, - colorVariant: "blue", - dataset: "opportunity_metrics", - values: ["opp_count"], - layout: { x: 10, y: 6, w: 2, h: 4 } - }, - // ─── Row 4: the churn story, now backed by a real signal ────────── - // These window `crm_account.last_activity_date`, which is a `Field.date()` - // (TEXT `YYYY-MM-DD`) — the same shape `customer_churn_signals` already - // filters safely. Until #592 the column was written by nothing at all: the - // bubble that fed it was silently discarded on every invocation because - // the field was `readonly` (#2948). These three tiles are the reason that - // mattered. - { - id: "quiet_accounts_30", - title: "Quiet 30+ Days", - description: "Active accounts with no logged interaction in a month", - type: "metric", - filter: { is_active: true, last_activity_date: { $lt: "{30_days_ago}" } }, - colorVariant: "warning", - dataset: "account_metrics", - values: ["account_count"], - layout: { x: 0, y: 10, w: 4, h: 2 } - }, - { - id: "quiet_accounts_60", - title: "Quiet 60+ Days", - description: "Two months of silence \u2014 the at-risk threshold", - type: "metric", - filter: { is_active: true, last_activity_date: { $lt: "{60_days_ago}" } }, - colorVariant: "orange", - dataset: "account_metrics", - values: ["account_count"], - layout: { x: 4, y: 10, w: 4, h: 2 } - }, - { - id: "quiet_accounts_90", - title: "Quiet 90+ Days", - description: "A quarter with no contact \u2014 intervene or write it off", - type: "metric", - filter: { is_active: true, last_activity_date: { $lt: "{90_days_ago}" } }, - colorVariant: "danger", - dataset: "account_metrics", - values: ["account_count"], - layout: { x: 8, y: 10, w: 4, h: 2 } - } - ] -}; - -// src/sales/dashboards/shared-widgets.ts -var pipelineByStageFunnelWidget = (layout) => ({ - id: "pipeline_by_stage", - title: "Pipeline by Stage", - description: "Open opportunity value at each sales stage", - type: "funnel", - filter: { stage: { $nin: ["closed_won", "closed_lost"] } }, - dataset: "opportunity_metrics", - dimensions: ["stage"], - values: ["total_amount"], - layout, - suppressWarnings: ["chart-config-missing"] - // intentional default rendering -}); -var avgDealSizeMetricWidget = (layout, overrides = {}) => ({ - id: "avg_deal_size", - title: "Avg Deal Size", - description: "Average value of closed-won deals", - type: "metric", - filter: { stage: "closed_won" }, - colorVariant: "orange", - dataset: "opportunity_metrics", - values: ["avg_amount"], - layout, - ...overrides -}); - -// src/sales/dashboards/crm.dashboard.ts -var CrmOverviewDashboard = { - name: "crm_overview_dashboard", - label: "CRM Overview", - description: "Revenue metrics, pipeline analytics, and deal insights", - columns: 12, - gap: 4, - refreshIntervalSeconds: 300, - header: { - showTitle: true, - showDescription: true - // Header action buttons removed: `create_opportunity` / `create_lead` are not - // defined actions and `/reports` is not an in-app view route — all three were - // dead. Re-add real, wired-up actions here when available. - }, - dateRange: { - field: "close_date", - defaultRange: "this_quarter", - allowCustomRange: true - }, - globalFilters: [ - { - field: "owner_id", - label: { en: "Owner", "zh-CN": "\u8D1F\u8D23\u4EBA", "es-ES": "Responsable", "ja-JP": "\u62C5\u5F53\u8005" }, - type: "lookup", - scope: "dashboard", - optionsFrom: { object: "sys_user", valueField: "id", labelField: "name" } - } - ], - widgets: [ - // ─── KPI Row ────────────────────────────────────────────────────── - { - id: "total_revenue", - title: "Total Revenue", - description: "Closed-won revenue this period", - type: "metric", - filter: { stage: "closed_won" }, - colorVariant: "success", - dataset: "opportunity_metrics", - values: ["total_amount"], - layout: { x: 0, y: 0, w: 3, h: 2 } - }, - { - id: "active_deals", - title: "Active Deals", - description: "Open opportunities in the pipeline", - type: "metric", - filter: { stage: { $nin: ["closed_won", "closed_lost"] } }, - colorVariant: "blue", - dataset: "opportunity_metrics", - values: ["opp_count"], - layout: { x: 3, y: 0, w: 3, h: 2 } - }, - { - id: "won_deals", - title: "Won Deals", - description: "Closed-won deals this period", - type: "metric", - filter: { stage: "closed_won" }, - colorVariant: "purple", - dataset: "opportunity_metrics", - values: ["opp_count"], - layout: { x: 6, y: 0, w: 3, h: 2 } - }, - // No overrides left once the fabricated trend is gone. - avgDealSizeMetricWidget({ x: 9, y: 0, w: 3, h: 2 }), - // ─── Charts Row 1 ───────────────────────────────────────────────── - { - id: "revenue_trends", - title: "Revenue Trends", - description: "Closed-won revenue over the last 12 months", - type: "area", - filter: { stage: "closed_won", close_date: { $gte: "{12_months_ago}" } }, - filterBindings: { dateRange: false }, - // self-scoped to 12 months — the date picker must not narrow it - colorVariant: "success", - dataset: "opportunity_metrics", - dimensions: ["close_date"], - values: ["total_amount"], - layout: { x: 0, y: 2, w: 9, h: 4 }, - chartConfig: { - showLegend: false, - showDataLabels: false, - colors: ["#10B981"], - interaction: { tooltips: true, brush: true } - }, - options: { dateGranularity: "month" } - }, - { - id: "lead_source", - title: "Lead Source", - description: "Pipeline value by acquisition channel", - type: "donut", - colorVariant: "purple", - dataset: "opportunity_metrics", - dimensions: ["lead_source"], - values: ["total_amount"], - layout: { x: 9, y: 2, w: 3, h: 4 }, - chartConfig: { - showLegend: true, - showDataLabels: true, - colors: ["#4F46E5", "#06B6D4", "#10B981", "#F59E0B", "#EF4444", "#8B5CF6"] - } - }, - // ─── Charts Row 2 ───────────────────────────────────────────────── - pipelineByStageFunnelWidget({ x: 0, y: 6, w: 6, h: 4 }), - { - id: "top_products", - title: "Top Products", - description: "Total list-price revenue by product category", - type: "bar", - colorVariant: "blue", - // crm_product has no `close_date`, so the date picker would fail it with - // `no such column`. ObjectStack 15 (framework#2501) injects every dashboard - // filter (dateRange + globalFilters) into each widget's query. - // The `owner_id` opt-out is SEMANTIC, not structural: since #548 every - // business object carries the injected `owner_id`, so the filter would now - // resolve — it just means nothing on a shared product catalog, where the - // column records whoever created the entry. - filterBindings: { dateRange: false, owner_id: false }, - dataset: "product_metrics", - dimensions: ["category"], - values: ["list_price_sum"], - layout: { x: 6, y: 6, w: 6, h: 4 }, - chartConfig: { - showLegend: false, - showDataLabels: true, - colors: ["#4F46E5"] - } - }, - // ─── Pipeline by Owner ──────────────────────────────────────────── - // A dashboard `table` binds to an analytics dataset (a cube), so it must - // aggregate — it cannot list raw records (ADR-0021). The previous - // "Recent Opportunities" table selected only the `opp_count` measure with - // no dimension, which renders a single summary row, not a per-deal list. - // For a true per-record listing, surface an object-bound ListView through - // app navigation instead (ADR-0017). Here we group by owner for a rep - // pipeline breakdown that renders one row per owner. - { - id: "pipeline_by_owner", - title: "Pipeline by Owner", - description: "Open pipeline value and deal count per sales rep", - type: "table", - filter: { stage: { $nin: ["closed_won", "closed_lost"] } }, - colorVariant: "default", - dataset: "opportunity_metrics", - dimensions: ["owner"], - values: ["total_amount", "opp_count", "avg_amount"], - layout: { x: 0, y: 10, w: 12, h: 4 }, - options: { - sortBy: "total_amount", - sortOrder: "desc", - limit: 10 - } - } - ] -}; - -// src/sales/dashboards/executive.dashboard.ts -var LEAD_SOURCE_FILTER_LABELS = { - web: { en: "Web", "zh-CN": "\u7F51\u7AD9", "es-ES": "Web", "ja-JP": "\u30A6\u30A7\u30D6" }, - referral: { en: "Referral", "zh-CN": "\u63A8\u8350", "es-ES": "Referencia", "ja-JP": "\u7D39\u4ECB" }, - event: { en: "Event / Trade Show", "zh-CN": "\u6D3B\u52A8 / \u5C55\u4F1A", "es-ES": "Evento / Feria", "ja-JP": "\u30A4\u30D9\u30F3\u30C8\u30FB\u5C55\u793A\u4F1A" }, - webinar: { en: "Webinar", "zh-CN": "\u7EBF\u4E0A\u7814\u8BA8\u4F1A", "es-ES": "Seminario Web", "ja-JP": "\u30A6\u30A7\u30D3\u30CA\u30FC" }, - partner: { en: "Partner", "zh-CN": "\u5408\u4F5C\u4F19\u4F34", "es-ES": "Socio", "ja-JP": "\u30D1\u30FC\u30C8\u30CA\u30FC" }, - advertisement: { en: "Advertisement", "zh-CN": "\u5E7F\u544A", "es-ES": "Publicidad", "ja-JP": "\u5E83\u544A" }, - paid_search: { en: "Paid Search", "zh-CN": "\u4ED8\u8D39\u641C\u7D22", "es-ES": "B\xFAsqueda de Pago", "ja-JP": "\u6709\u6599\u691C\u7D22" }, - social: { en: "Social Media", "zh-CN": "\u793E\u4EA4\u5A92\u4F53", "es-ES": "Redes Sociales", "ja-JP": "\u30BD\u30FC\u30B7\u30E3\u30EB\u30E1\u30C7\u30A3\u30A2" }, - content: { en: "Content / Blog", "zh-CN": "\u5185\u5BB9 / \u535A\u5BA2", "es-ES": "Contenido / Blog", "ja-JP": "\u30B3\u30F3\u30C6\u30F3\u30C4\u30FB\u30D6\u30ED\u30B0" }, - cold_call: { en: "Cold Call", "zh-CN": "\u964C\u751F\u62DC\u8BBF", "es-ES": "Llamada en Fr\xEDo", "ja-JP": "\u30B3\u30FC\u30EB\u30C9\u30B3\u30FC\u30EB" }, - email_campaign: { en: "Email Campaign", "zh-CN": "\u90AE\u4EF6\u8425\u9500", "es-ES": "Campa\xF1a de Email", "ja-JP": "\u30E1\u30FC\u30EB\u30AD\u30E3\u30F3\u30DA\u30FC\u30F3" }, - other: { en: "Other", "zh-CN": "\u5176\u4ED6", "es-ES": "Otro", "ja-JP": "\u305D\u306E\u4ED6" } -}; -var ExecutiveDashboard = { - name: "executive_dashboard", - label: "Executive Overview", - description: "High-level revenue, customer, and pipeline KPIs for leadership", - columns: 12, - gap: 4, - refreshIntervalSeconds: 300, - // 5 minutes - header: { - showTitle: true, - showDescription: true - // Header action buttons removed: they referenced actions/routes that were - // never implemented (`export_dashboard_pdf`, `schedule_dashboard_email`, - // `customize_dashboard` are not defined anywhere), so they rendered as dead - // buttons. Re-add real, wired-up actions here if these features land. - }, - dateRange: { - field: "close_date", - defaultRange: "this_quarter", - allowCustomRange: true - }, - globalFilters: [ - { - field: "owner_id", - label: { en: "Owner", "zh-CN": "\u8D1F\u8D23\u4EBA", "es-ES": "Responsable", "ja-JP": "\u62C5\u5F53\u8005" }, - type: "lookup", - scope: "dashboard", - optionsFrom: { object: "sys_user", valueField: "id", labelField: "name" } - }, - { - field: "lead_source", - label: { en: "Lead Source", "zh-CN": "\u7EBF\u7D22\u6765\u6E90", "es-ES": "Origen del Prospecto", "ja-JP": "\u30EA\u30FC\u30C9\u30BD\u30FC\u30B9" }, - type: "select", - scope: "dashboard", - // Roster derived, wording from the language packs — see - // LEAD_SOURCE_FILTER_LABELS above. Order follows the canonical constant. - options: LEAD_SOURCE_OPTIONS.map(({ value }) => ({ - value, - label: LEAD_SOURCE_FILTER_LABELS[String(value)] - })) - } - ], - widgets: [ - // ─── Row 1: Headline KPIs ───────────────────────────────────────── - { - id: "total_revenue_ytd", - title: "Total Revenue (YTD)", - description: "Closed-won revenue this year", - type: "metric", - filter: { stage: "closed_won", close_date: { $gte: "{current_year_start}" } }, - // Self-scoped to YTD; without this the injected dashboard dateRange - // (default this_quarter) is ANDed in and the tile shows quarter revenue. - filterBindings: { dateRange: false }, - dataset: "opportunity_metrics", - values: ["total_amount"], - layout: { x: 0, y: 0, w: 3, h: 2 } - }, - { - id: "total_accounts", - title: "Active Accounts", - description: "Customers with at least one active relationship", - type: "metric", - filter: { is_active: true }, - // crm_account has neither `close_date` nor `lead_source`; opt this widget - // out of both dashboard filters bound to those fields. ObjectStack 15 - // (framework#2501) injects every dashboard filter (dateRange + globalFilters) - // into each widget's query, so a widget on an object lacking a filter field - // fails with `no such column`. crm_account DOES have `owner_id` (injected - // into every business object, #548), so the owner filter is left to apply. - filterBindings: { dateRange: false, lead_source: false }, - dataset: "account_metrics", - values: ["account_count"], - layout: { x: 3, y: 0, w: 3, h: 2 } - }, - { - id: "total_contacts", - title: "Total Contacts", - description: "People in our address book", - type: "metric", - filterBindings: { dateRange: false }, - // crm_contact has no close_date — opt out of the date picker - dataset: "contact_metrics", - values: ["contact_count"], - layout: { x: 6, y: 0, w: 3, h: 2 } - }, - { - id: "open_leads", - title: "Open Leads", - description: "Unconverted leads in the funnel", - type: "metric", - filter: { is_converted: false }, - filterBindings: { dateRange: false }, - // crm_lead has no close_date — opt out of the date picker - dataset: "lead_metrics", - values: ["lead_count"], - layout: { x: 9, y: 0, w: 3, h: 2 } - }, - // ─── Row 2: Revenue Analysis ────────────────────────────────────── - { - id: "revenue_trend", - title: "Revenue Trend", - description: "Closed-won revenue over the last 12 months", - type: "area", - filter: { stage: "closed_won", close_date: { $gte: "{12_months_ago}" } }, - filterBindings: { dateRange: false }, - // self-scoped to 12 months — the date picker must not narrow it - dataset: "opportunity_metrics", - dimensions: ["close_date"], - values: ["total_amount"], - layout: { x: 0, y: 2, w: 8, h: 4 }, - // Default rendering is intentional: the dataset widget plots the selected - // dimension × values directly; a chartConfig would duplicate them inertly. - suppressWarnings: ["chart-config-missing"] - }, - { - id: "revenue_by_industry", - title: "Revenue by Industry", - description: "YTD closed-won revenue split by customer industry", - type: "donut", - filter: { stage: "closed_won", close_date: { $gte: "{current_year_start}" } }, - filterBindings: { dateRange: false }, - // self-scoped to YTD — the date picker must not narrow it - dataset: "opportunity_metrics", - dimensions: ["account_industry"], - values: ["total_amount"], - layout: { x: 8, y: 2, w: 4, h: 4 }, - suppressWarnings: ["chart-config-missing"] - // intentional default rendering (see revenue_trend) - }, - // ─── Row 3: Pipeline & Activity ─────────────────────────────────── - // The funnel now comes from the shared factory (#539); its remaining inert - // config lives in shared-widgets.ts and is out of this PR's scope. - pipelineByStageFunnelWidget({ x: 0, y: 6, w: 6, h: 4 }), - { - id: "new_accounts_by_month", - title: "New Accounts", - description: "Account creation cadence \u2014 last 6 months", - type: "bar", - filter: { created_at: { $gte: "{6_months_ago}" } }, - filterBindings: { dateRange: false, lead_source: false }, - // crm_account has no close_date/lead_source; scopes itself by created_at - dataset: "account_metrics", - dimensions: ["created_at"], - values: ["account_count"], - layout: { x: 6, y: 6, w: 6, h: 4 }, - suppressWarnings: ["chart-config-missing"] - // intentional default rendering (see revenue_trend) - }, - // ─── Row 4: Revenue by Industry ─────────────────────────────────── - // A dashboard `table` binds to an analytics cube, so it aggregates rather - // than listing raw accounts (ADR-0021). The previous "Top Accounts by - // Revenue" table selected only the `account_count` measure with no - // dimension — a single summary row, not a customer ranking. Grouping by - // industry gives a real multi-row breakdown of book-of-business by sector; - // for a per-account list, use an object-bound ListView (ADR-0017). - // Column headers and number formats come from the dataset's dimension and - // measure metadata. - { - id: "accounts_by_industry", - title: "Accounts by Industry", - description: "Total annual revenue and account count per industry", - type: "table", - filterBindings: { dateRange: false, lead_source: false }, - // crm_account has no close_date/lead_source — opt out of both - dataset: "account_metrics", - dimensions: ["industry"], - values: ["annual_revenue_sum", "account_count"], - layout: { x: 0, y: 10, w: 12, h: 4 } - } - ] -}; - -// src/sales/dashboards/sales.dashboard.ts -var SalesDashboard = { - name: "sales_dashboard", - label: "Sales Performance", - description: "Pipeline analytics, win rate trends, and rep performance", - columns: 12, - gap: 4, - refreshIntervalSeconds: 180, - // 3 minutes - header: { - showTitle: true, - // Keep the opening KPI row in the first viewport for a live demo. The - // description remains available in dashboard metadata and translations. - showDescription: false - // Header action buttons removed: `create_opportunity` / `export_dashboard_pdf` - // are not defined actions, and `/reports/forecast` matches no report route — - // all three were dead. Re-add real, wired-up actions here when available. - }, - dateRange: { - field: "close_date", - defaultRange: "this_quarter", - allowCustomRange: true - }, - globalFilters: [ - { - field: "owner_id", - label: { en: "Sales Rep", "zh-CN": "\u9500\u552E\u4EE3\u8868", "es-ES": "Representante de Ventas", "ja-JP": "\u55B6\u696D\u62C5\u5F53\u8005" }, - type: "lookup", - scope: "dashboard", - optionsFrom: { object: "sys_user", valueField: "id", labelField: "name" } - }, - { - field: "type", - label: { en: "Deal Type", "zh-CN": "\u5546\u673A\u7C7B\u578B", "es-ES": "Tipo de Oportunidad", "ja-JP": "\u5546\u8AC7\u30BF\u30A4\u30D7" }, - type: "select", - scope: "dashboard", - options: [ - { value: "new_business", label: { en: "New Business", "zh-CN": "\u65B0\u4E1A\u52A1", "es-ES": "Nuevo Negocio", "ja-JP": "\u65B0\u898F\u30D3\u30B8\u30CD\u30B9" } }, - { value: "existing_upgrade", label: { en: "Existing Customer - Upgrade", "zh-CN": "\u8001\u5BA2\u6237\u5347\u7EA7", "es-ES": "Cliente Existente - Mejora", "ja-JP": "\u65E2\u5B58\u9867\u5BA2 - \u30A2\u30C3\u30D7\u30B0\u30EC\u30FC\u30C9" } }, - { value: "existing_renewal", label: { en: "Existing Customer - Renewal", "zh-CN": "\u8001\u5BA2\u6237\u7EED\u7EA6", "es-ES": "Cliente Existente - Renovaci\xF3n", "ja-JP": "\u65E2\u5B58\u9867\u5BA2 - \u66F4\u65B0" } }, - { value: "existing_expansion", label: { en: "Existing Customer - Expansion", "zh-CN": "\u8001\u5BA2\u6237\u62D3\u5C55", "es-ES": "Cliente Existente - Expansi\xF3n", "ja-JP": "\u65E2\u5B58\u9867\u5BA2 - \u62E1\u5927" } } - ] - } - ], - widgets: [ - // ─── Row 1: Pipeline KPIs ───────────────────────────────────────── - { - id: "total_pipeline_value", - title: "Total Pipeline", - description: "Sum of open opportunity value", - type: "metric", - filter: { stage: { $nin: ["closed_won", "closed_lost"] } }, - colorVariant: "blue", - dataset: "opportunity_metrics", - values: ["total_amount"], - layout: { x: 0, y: 0, w: 3, h: 2 } - }, - { - id: "closed_won_qtd", - title: "Closed Won (QTD)", - description: "Revenue closed this quarter", - type: "metric", - filter: { stage: "closed_won", close_date: { $gte: "{current_quarter_start}" } }, - filterBindings: { dateRange: false }, - // self-scoped to QTD — the date picker must not re-window it - colorVariant: "success", - dataset: "opportunity_metrics", - values: ["total_amount"], - layout: { x: 3, y: 0, w: 3, h: 2 } - }, - { - id: "open_opportunities", - title: "Open Opportunities", - description: "Active deals in flight", - type: "metric", - filter: { stage: { $nin: ["closed_won", "closed_lost"] } }, - colorVariant: "orange", - dataset: "opportunity_metrics", - values: ["opp_count"], - layout: { x: 6, y: 0, w: 3, h: 2 } - }, - avgDealSizeMetricWidget({ x: 9, y: 0, w: 3, h: 2 }, { - description: "Average value of closed-won deals this quarter", - filter: { stage: "closed_won", close_date: { $gte: "{current_quarter_start}" } }, - filterBindings: { dateRange: false }, - // self-scoped to QTD — the date picker must not re-window it - colorVariant: "purple" - }), - // ─── Row 2: Win / Loss KPIs ─────────────────────────────────────── - // - // The ratio and its two inputs sit side by side ON PURPOSE (#593). A win - // rate is the failure mode #614 shipped: a wrong denominator raises no - // error, it just prints a plausible percentage. Showing "62%" next to - // "8 won" and "5 lost" means a reader can check the arithmetic at a - // glance, and a half that silently loses its filter stops being invisible. - // - // All three windows are the same self-scoped 12 months (`dateRange: false` - // so the header's date picker cannot re-window one of them and not the - // others — three tiles over three different windows would be worse than - // no tiles at all). - { - // NOTE: no `stage` filter here, and that is deliberate. Both halves of - // the ratio come from the DATASET's own measure filters — `won_count` - // over closed_won, `decided_count` over closed_won + closed_lost — so - // open pipeline is excluded by the measures. A widget-level - // `stage: {$in: [...]}` filter would narrow numerator and denominator - // alike, which is how a ratio quietly becomes a division by itself. - id: "win_rate_12m", - title: "Win Rate (12M)", - description: "Deals won as a share of all deals settled in the last 12 months", - type: "metric", - filter: { close_date: { $gte: "{12_months_ago}" } }, - filterBindings: { dateRange: false }, - colorVariant: "success", - dataset: "opportunity_metrics", - values: ["win_rate"], - layout: { x: 0, y: 2, w: 4, h: 2 } - }, - { - id: "won_deals_12m", - title: "Deals Won (12M)", - description: "The numerator of the win rate", - type: "metric", - filter: { close_date: { $gte: "{12_months_ago}" } }, - filterBindings: { dateRange: false }, - colorVariant: "blue", - dataset: "opportunity_metrics", - values: ["won_count"], - layout: { x: 4, y: 2, w: 4, h: 2 } - }, - { - id: "lost_deals_12m", - title: "Deals Lost (12M)", - description: "The other half of the win-rate denominator", - type: "metric", - filter: { close_date: { $gte: "{12_months_ago}" } }, - filterBindings: { dateRange: false }, - colorVariant: "orange", - dataset: "opportunity_metrics", - values: ["lost_count"], - layout: { x: 8, y: 2, w: 4, h: 2 } - }, - // ─── Row 3: Pipeline & Trends ───────────────────────────────────── - pipelineByStageFunnelWidget({ x: 0, y: 4, w: 6, h: 4 }), - { - id: "monthly_revenue_trend", - title: "Monthly Revenue Trend", - description: "Closed-won revenue, last 12 months", - type: "area", - filter: { stage: "closed_won", close_date: { $gte: "{12_months_ago}" } }, - filterBindings: { dateRange: false }, - // self-scoped to 12 months — the date picker must not narrow it - colorVariant: "success", - dataset: "opportunity_metrics", - dimensions: ["close_date"], - values: ["total_amount"], - layout: { x: 6, y: 4, w: 6, h: 4 }, - chartConfig: { - showLegend: false, - showDataLabels: false, - colors: ["#10B981"], - // No quota annotation line: ChartAnnotationSchema only takes a STATIC - // value, and the real quotas live per-owner/per-period in - // crm_forecast.quota (seeded 500k–1.5M — the old hardcoded 100000 was - // fiction). Quota vs. actual is the quota_attainment_by_rep table - // below, bound to the forecast_metrics dataset. - interaction: { tooltips: true, brush: true } - }, - options: { dateGranularity: "month" } - }, - // ─── Row 4: Performance Breakdown ───────────────────────────────── - { - id: "pipeline_by_forecast_category", - title: "Pipeline by Forecast Category", - description: "Open pipeline grouped by sales forecast category", - type: "horizontal-bar", - filter: { stage: { $nin: ["closed_won", "closed_lost"] } }, - colorVariant: "blue", - dataset: "opportunity_metrics", - dimensions: ["forecast_category"], - values: ["total_amount"], - layout: { x: 0, y: 8, w: 6, h: 4 }, - chartConfig: { - showLegend: false, - showDataLabels: true, - colors: ["#4F46E5"] - } - }, - { - id: "lead_source_breakdown", - title: "Lead Source", - description: "Where our pipeline is coming from", - type: "donut", - filter: { stage: { $nin: ["closed_lost"] } }, - colorVariant: "purple", - dataset: "opportunity_metrics", - dimensions: ["lead_source"], - values: ["total_amount"], - layout: { x: 6, y: 8, w: 6, h: 4 }, - chartConfig: { - showLegend: true, - showDataLabels: true, - colors: ["#4F46E5", "#06B6D4", "#10B981", "#F59E0B", "#EF4444", "#8B5CF6"] - } - }, - // ─── Row 5: Rep Leaderboard ─────────────────────────────────────── - // A dashboard `table` binds to an analytics cube and aggregates; it cannot - // list raw deals (ADR-0021). The previous "Top Open Opportunities" table - // selected only `opp_count` with no dimension — one summary row, not a deal - // ranking. Grouping open pipeline by owner yields a rep leaderboard (one - // row per rep). For a per-deal list, surface an object-bound ListView - // through app navigation (ADR-0017). - { - id: "open_pipeline_by_owner", - title: "Open Pipeline by Owner", - description: "In-flight pipeline value, deal count and avg win probability per rep", - type: "table", - filter: { stage: { $nin: ["closed_won", "closed_lost"] } }, - colorVariant: "default", - dataset: "opportunity_metrics", - dimensions: ["owner"], - values: ["total_amount", "opp_count", "avg_probability"], - layout: { x: 0, y: 12, w: 12, h: 4 }, - options: { - sortBy: "total_amount", - sortOrder: "desc", - limit: 10 - } - }, - // ─── Row 6: Quota Attainment ────────────────────────────────────── - // The real per-rep quota data (crm_forecast.quota) surfaced as a table: - // dashboard chart annotations cannot reference a dataset (static values - // only), so quota vs. actual gets its own widget instead of a fake line. - { - id: "quota_attainment_by_rep", - title: "Quota Attainment by Rep", - description: "Current-quarter quota, closed revenue and attainment per rep, from forecast snapshots", - type: "table", - colorVariant: "default", - // crm_forecast has neither `close_date` nor `type`; opt out of the - // dashboard filters bound to those fields (framework#2501 injects every - // dashboard filter into each widget query). `owner` exists and applies. - filterBindings: { dateRange: false, type: false }, - // ONE period, or the numbers are nonsense (#614). `crm_forecast` holds a - // row per owner PER PERIOD, and `quota_sum` / `closed_sum` are plain - // `sum` measures — so an unpinned query adds this quarter's quota to this - // month's quota to every settled quarter's quota and labels the total - // "Quota". On the shipped seeds that turned a rep's real 1,500,000 - // quarterly quota into 7,940,000, with attainment wrong by the same - // construction (89% instead of 55%). - // - // Both halves of the key are needed. `period: 'quarter'` alone still sums - // every quarter ever snapshotted; `period_start` alone still merges the - // quarter row with the month row that opens the same quarter (Q3 and July - // both start on the 1st). Together they name exactly one snapshot per - // owner — the same (owner, period, period_start) tuple the snapshot sweep - // upserts on and the object indexes. - // - // `{current_quarter_start}` is resolved by the ANALYTICS path, verified - // rather than assumed: `queryDataset` runs both the dataset filter and the - // widget's `runtimeFilter` through `resolveFilterTokens`, which - // understands `{(current|last|next)_(week|month|quarter|year)_(start|end)}` - // and throws `FILTER_TOKEN_UNKNOWN` on anything else. - // - // The LIST path resolves the same macros, and has since 17.0.0-rc.0: - // `resolveFilterTokens()` was wired into the ObjectQL READ path (objectql - // `feat(filters): evaluate {filter-token} placeholders server-side`, - // #3582) ahead of the middleware chain, covering `find` / `findOne` / - // `count` / `aggregate` — the one gate every server-side read passes - // through, saved-view filters included. So this widget's filter and a - // saved view's filter now read the same way, and the sibling - // `this_quarter_forecasts` in `src/sales/views/forecast.view.ts` pins this same - // quarter with this same macro. Measured, not inferred: - // `test/forecast-current-quarter-view.test.ts` runs both filter shapes — - // the `period_start` equality (#730) and the `close_date` range (#743) — - // through a real engine and pins a three-way outcome (current quarter - // only: not zero rows, not every quarter). First taken on 17.0.0-rc.2; - // RE-RUN 2026-09-03 on 17.2.0 (#1467), RE-RUN on 17.3.0 (#1676, the PR - // #1577 pin) and RE-RUN again on 17.4.0 (PR #1814, #1807) — green all - // four times, so the outcome held on every pin it was taken on, not - // only the first. Not yet re-run on 17.5.0. - // - // What stood here before described the two paths as asymmetric and told - // the next author not to generalise between them. That was true on - // @objectstack 16.1.0 and expired at rc.0 (#744). - // - // Cost of pinning to the CURRENT quarter rather than the latest one: for - // the few hours between a quarter boundary and the 03:00 sweep that opens - // the new row, the table is empty. Empty is the honest state — the - // alternative renders last quarter's attainment under a header that says - // this one. - filter: { period: "quarter", period_start: "{current_quarter_start}" }, - dataset: "forecast_metrics", - dimensions: ["owner"], - values: ["quota_sum", "closed_sum", "attainment"], - layout: { x: 0, y: 16, w: 12, h: 4 }, - options: { - sortBy: "attainment", - sortOrder: "desc", - limit: 10 - } - }, - // ─── Row 7: Win / Loss analysis ─────────────────────────────────── - // - // Three widgets over the settled half of the pipeline (#593). Each of the - // two win-rate breakdowns is a TABLE, not a bar chart, and that is the - // whole design: a bar of "67%" is unfalsifiable, whereas a row reading - // "Won 2 · Lost 1 · Settled 3 · 67%" carries its own proof. Perturb either - // half — win a deal that was lost, or lose one that was won — and three of - // those four numbers move. `test/win-loss-capture.test.ts` does exactly - // that against the real dataset executor and the real seeds. - // - // Both tables opt out of the header's `close_date` window - // (`dateRange: false`) for the reason the quota table does: a win rate over - // "this quarter" on a demo database is computed from whichever one or two - // deals happen to have settled inside it, which is noise wearing the - // costume of a KPI. Twelve months is the same window the row-2 tiles and - // the revenue trend use, so the dashboard tells one consistent story. - { - id: "win_rate_by_owner", - title: "Win / Loss by Rep", - description: "Deals won, deals lost and win rate per rep \u2014 last 12 months", - type: "table", - filter: { close_date: { $gte: "{12_months_ago}" } }, - filterBindings: { dateRange: false }, - colorVariant: "default", - dataset: "opportunity_metrics", - dimensions: ["owner"], - values: ["won_count", "lost_count", "decided_count", "win_rate", "won_amount"], - layout: { x: 0, y: 20, w: 6, h: 4 }, - options: { - sortBy: "decided_count", - sortOrder: "desc", - limit: 10 - } - }, - { - id: "win_rate_by_lead_source", - title: "Win / Loss by Lead Source", - description: "Which sources produce deals that actually close \u2014 last 12 months", - type: "table", - filter: { close_date: { $gte: "{12_months_ago}" } }, - filterBindings: { dateRange: false }, - colorVariant: "default", - dataset: "opportunity_metrics", - dimensions: ["lead_source"], - values: ["won_count", "lost_count", "decided_count", "win_rate", "won_amount"], - layout: { x: 6, y: 20, w: 6, h: 4 }, - options: { - sortBy: "decided_count", - sortOrder: "desc", - limit: 12 - } - }, - { - // The loss-reason breakdown the fields were declared for and never got. - // - // `loss_reason` is mandatory on every `closed_lost` record (see - // crm_opportunity), so this chart has no "unattributed" slice to - // apologise for — an empty chart here means no losses in the window, - // never "nobody filled the field in". - // - // Counts, not amounts: the question a loss review asks is "how often did - // we lose for this reason", and one large lost deal should not outweigh - // five recurring feature gaps. `lost_amount` is declared on the dataset - // for the revenue view of the same question. - id: "loss_reason_breakdown", - title: "Why We Lose", - description: "Lost deals by reason \u2014 last 12 months", - type: "donut", - filter: { stage: "closed_lost", close_date: { $gte: "{12_months_ago}" } }, - filterBindings: { dateRange: false }, - colorVariant: "orange", - dataset: "opportunity_metrics", - dimensions: ["loss_reason"], - values: ["opp_count"], - layout: { x: 0, y: 24, w: 12, h: 4 }, - chartConfig: { - showLegend: true, - showDataLabels: true, - colors: ["#EF4444", "#F59E0B", "#8B5CF6", "#06B6D4", "#4F46E5", "#10B981", "#64748B"] - } - }, - // ─── Row 9: Pivot — Stage × Lead Source ─────────────────────────── - { - id: "pipeline_stage_by_source", - title: "Pipeline by Stage \xD7 Lead Source", - description: "Cross-tab of open opportunity amount by stage and source", - type: "pivot", - filter: { stage: { $nin: ["closed_won", "closed_lost"] } }, - colorVariant: "default", - dataset: "opportunity_metrics", - dimensions: ["stage", "lead_source"], - values: ["total_amount"], - layout: { x: 0, y: 28, w: 12, h: 4 } - } - ] -}; - -// src/sales/datasets/index.ts -var datasets_exports = {}; -__export(datasets_exports, { - AccountDataset: () => AccountDataset, - ContactDataset: () => ContactDataset, - EventDataset: () => EventDataset, - ForecastDataset: () => ForecastDataset, - LeadDataset: () => LeadDataset, - OpportunityDataset: () => OpportunityDataset, - TaskDataset: () => TaskDataset -}); - -// src/sales/datasets/opportunity.dataset.ts -import { defineDataset as defineDataset2 } from "@objectstack/spec/ui"; -var OpportunityDataset = defineDataset2({ - name: "opportunity_metrics", - label: "Opportunity Metrics", - description: "Semantic layer for sales-pipeline counts and amounts", - object: "crm_opportunity", - // Include the account relationship so dimensions can traverse it (the join is - // derived from the `crm_account` lookup — no hand-written ON clause). - include: ["crm_account"], - dimensions: [ - { name: "stage", label: "Stage", field: "stage", type: "string" }, - { name: "lead_source", label: "Lead Source", field: "lead_source", type: "string" }, - { name: "forecast_category", label: "Forecast Category", field: "forecast_category", type: "string" }, - { name: "type", label: "Deal Type", field: "type", type: "string" }, - // Semantic name `owner`; column `owner_id`, the platform anchor (#548). - { name: "owner", label: "Owner", field: "owner_id", type: "lookup" }, - // Win/loss attribution (#593). Both columns are now mandatory at close - // (`requiredWhen` on crm_opportunity), so grouping by either one over - // settled deals has no "unattributed" bucket to explain away. - { name: "win_reason", label: "Win Reason", field: "win_reason", type: "string" }, - { name: "loss_reason", label: "Loss Reason", field: "loss_reason", type: "string" }, - // v17 fixes scoped aggregate execution and SQLite's epoch bucketing. - // Trends and quarter coverage need different buckets over the same field, - // so each one is its own semantic dimension. - { name: "close_date", label: "Close Date", field: "close_date", type: "date", dateGranularity: "month" }, - { name: "close_quarter", label: "Close Quarter", field: "close_date", type: "date", dateGranularity: "quarter" }, - // Cross-object dimension: account industry via the crm_account relationship. - { name: "account_industry", label: "Account Industry", field: "crm_account.industry", type: "string" } - ], - measures: [ - { name: "opp_count", label: "Opportunities", aggregate: "count" }, - { name: "total_amount", label: "Total Amount", aggregate: "sum", field: "amount", format: "0,0" }, - { name: "avg_amount", label: "Avg Deal Size", aggregate: "avg", field: "amount", format: "0,0" }, - { name: "avg_probability", label: "Avg Probability", aggregate: "avg", field: "probability", format: "0%" }, - // ─── Win rate (#593) ──────────────────────────────────────────────── - // - // A ratio is the most dangerous kind of measure: a wrong denominator does - // not error, it returns a plausible number (#614 rendered a 1,500,000 - // quota as 7,940,000 because a filter was missing one of its two halves). - // So the two halves are declared here, ONCE, as named measures — not - // improvised per widget — and every widget that shows `win_rate` also - // shows `won_count` and `lost_count` beside it, so the reader can check - // the arithmetic that produced the percentage. - // - // Each carries its OWN `filter`, which the executor honours by running - // that measure as its own sub-query and merging the result back on the - // selected dimensions. That is what lets one widget row hold "won 2, lost - // 1, 67%" — the counts are over different row sets, and only a - // measure-level filter can say so. A widget-level `filter` cannot: it - // narrows the whole row set at once, which is exactly how you end up - // dividing a number by itself. - // - // `decided_count` is deliberately its own filtered count and NOT - // `derived: { op: 'sum', of: ['won_count', 'lost_count'] }`. Measured on - // 17.0.0-rc.1: a filtered measure contributes NO row for a group its - // filter selects nothing in — the count comes back absent, not 0 — and a - // derived measure over an absent input evaluates to null. Summing the two - // would therefore blank the win rate of any rep who has never lost a deal - // (100%, the group you least want to hide). Counting the union directly - // keeps the denominator present whenever the group has any settled deal at - // all. The remaining asymmetry — a group with losses but NO wins reports a - // null win rate rather than 0% — is a platform behaviour, not something a - // widget can paper over; it is pinned by `test/win-loss-capture.test.ts` - // and filed as #656. The tables show `lost_count` next to `win_rate` - // precisely so that a blank rate reads as "0 wins out of 3", not as - // "no data". - { name: "won_count", label: "Won Deals", aggregate: "count", filter: { stage: "closed_won" } }, - { name: "lost_count", label: "Lost Deals", aggregate: "count", filter: { stage: "closed_lost" } }, - { - name: "decided_count", - label: "Settled Deals", - aggregate: "count", - filter: { stage: { $in: ["closed_won", "closed_lost"] } } - }, - { name: "won_amount", label: "Won Revenue", aggregate: "sum", field: "amount", filter: { stage: "closed_won" }, format: "0,0" }, - { name: "lost_amount", label: "Lost Revenue", aggregate: "sum", field: "amount", filter: { stage: "closed_lost" }, format: "0,0" }, - { name: "win_rate", label: "Win Rate", derived: { op: "ratio", of: ["won_count", "decided_count"] }, format: "0%" } - ] -}); - -// src/sales/datasets/account.dataset.ts -import { defineDataset as defineDataset3 } from "@objectstack/spec/ui"; -var AccountDataset = defineDataset3({ - name: "account_metrics", - label: "Account Metrics", - description: "Semantic layer for account counts by industry / type", - object: "crm_account", - dimensions: [ - { name: "industry", label: "Industry", field: "industry", type: "string" }, - { name: "type", label: "Type", field: "type", type: "string" }, - { name: "created_at", label: "Created", field: "created_at", type: "date", dateGranularity: "month" } - ], - measures: [ - { name: "account_count", label: "Accounts", aggregate: "count" }, - { name: "annual_revenue_sum", label: "Annual Revenue", aggregate: "sum", field: "annual_revenue", format: "0,0" } - ] -}); - -// src/sales/datasets/contact.dataset.ts -import { defineDataset as defineDataset4 } from "@objectstack/spec/ui"; -var ContactDataset = defineDataset4({ - name: "contact_metrics", - label: "Contact Metrics", - description: "Semantic layer for contact counts", - object: "crm_contact", - dimensions: [], - measures: [{ name: "contact_count", label: "Contacts", aggregate: "count" }] -}); - -// src/sales/datasets/lead.dataset.ts -import { defineDataset as defineDataset5 } from "@objectstack/spec/ui"; -var LeadDataset = defineDataset5({ - name: "lead_metrics", - label: "Lead Metrics", - description: "Semantic layer for lead counts", - object: "crm_lead", - dimensions: [ - { name: "status", label: "Status", field: "status", type: "string" }, - { name: "lead_source", label: "Source", field: "lead_source", type: "string" }, - { name: "created_at", label: "Created", field: "created_at", type: "date" }, - { name: "last_contacted_date", label: "Last Contacted", field: "last_contacted_date", type: "date", dateGranularity: "month" } - ], - measures: [{ name: "lead_count", label: "Leads", aggregate: "count" }] -}); - -// src/sales/datasets/task.dataset.ts -import { defineDataset as defineDataset6 } from "@objectstack/spec/ui"; -var TaskDataset = defineDataset6({ - name: "task_metrics", - label: "Task Metrics", - description: "Semantic layer for task workload and completion", - object: "crm_task", - dimensions: [ - { name: "status", label: "Status", field: "status", type: "string" }, - { name: "priority", label: "Priority", field: "priority", type: "string" }, - { name: "priority_rank", label: "Urgency", field: "priority_rank", type: "number" }, - { name: "type", label: "Type", field: "type", type: "string" }, - { name: "due_date", label: "Due Date", field: "due_date", type: "date" }, - { name: "is_overdue", label: "Overdue", field: "is_overdue", type: "boolean" }, - { name: "is_completed", label: "Completed", field: "is_completed", type: "boolean" } - ], - measures: [ - { name: "task_count", label: "Tasks", aggregate: "count" }, - { name: "avg_progress", label: "Avg Progress", aggregate: "avg", field: "progress_percent", format: "0.0%" } - ] -}); - -// src/sales/datasets/event.dataset.ts -import { defineDataset as defineDataset7 } from "@objectstack/spec/ui"; -var EventDataset = defineDataset7({ - name: "event_metrics", - label: "Activity Metrics", - description: "Semantic layer for meetings, calls and interaction recency", - object: "crm_event", - dimensions: [ - { name: "type", label: "Activity Type", field: "type", type: "string" }, - { name: "status", label: "Status", field: "status", type: "string" }, - // `owner` is the SEMANTIC name every widget/report selects by; the column - // behind it is the platform ownership anchor `owner_id` (#548). - { name: "owner", label: "Owner", field: "owner_id", type: "string" }, - { name: "related_to_type", label: "Related To", field: "related_to_type", type: "string" }, - { - name: "start_datetime", - label: "Activity Week", - field: "start_datetime", - type: "date", - dateGranularity: "week" - } - ], - measures: [ - { name: "event_count", label: "Activities", aggregate: "count" }, - { - name: "total_minutes", - label: "Minutes", - aggregate: "sum", - field: "duration_minutes", - format: "0,0" - }, - { - name: "avg_minutes", - label: "Avg Duration", - aggregate: "avg", - field: "duration_minutes", - format: "0,0" - } - ] -}); - -// src/sales/datasets/forecast.dataset.ts -import { defineDataset as defineDataset8 } from "@objectstack/spec/ui"; -var ForecastDataset = defineDataset8({ - name: "forecast_metrics", - label: "Forecast Metrics", - description: "Semantic layer for per-owner quota, attainment and pipeline coverage", - object: "crm_forecast", - dimensions: [ - // Semantic name `owner`; column `owner_id`, the platform anchor (#548). - { name: "owner", label: "Owner", field: "owner_id", type: "lookup" }, - { name: "period", label: "Period Type", field: "period", type: "string" }, - { name: "period_label", label: "Period", field: "period_label", type: "string" }, - { name: "period_start", label: "Period Start", field: "period_start", type: "date" } - ], - measures: [ - { name: "quota_sum", label: "Quota", aggregate: "sum", field: "quota", format: "0,0" }, - { name: "closed_sum", label: "Closed", aggregate: "sum", field: "closed_amount", format: "0,0" }, - { name: "pipeline_sum", label: "Pipeline", aggregate: "sum", field: "pipeline_amount", format: "0,0" }, - { name: "commit_sum", label: "Commit", aggregate: "sum", field: "commit_amount", format: "0,0" }, - // Derived ratio (ADR-0021 Q1) rather than avg(attainment_pct): summing - // closed and quota before dividing weights every rep/period by quota - // size, where an average of per-row percentages would not. - { name: "attainment", label: "Attainment", derived: { op: "ratio", of: ["closed_sum", "quota_sum"] }, format: "0%" } - ] -}); - -// src/revenue/datasets/index.ts -var datasets_exports2 = {}; -__export(datasets_exports2, { - ProductDataset: () => ProductDataset -}); - -// src/revenue/datasets/product.dataset.ts -import { defineDataset as defineDataset9 } from "@objectstack/spec/ui"; -var ProductDataset = defineDataset9({ - name: "product_metrics", - label: "Product Metrics", - description: "Semantic layer for product catalog counts and list price", - object: "crm_product", - dimensions: [ - { name: "category", label: "Category", field: "category", type: "string" } - ], - measures: [ - { name: "product_count", label: "Products", aggregate: "count" }, - { name: "list_price_sum", label: "Total List Price", aggregate: "sum", field: "list_price", format: "0,0" } - ] -}); - -// src/sales/reports/index.ts -var reports_exports = {}; -__export(reports_exports, { - AccountsByIndustryTypeReport: () => AccountsByIndustryTypeReport, - CustomerChurnSignalsReport: () => CustomerChurnSignalsReport, - LeadInflowByMonthSourceReport: () => LeadInflowByMonthSourceReport, - OpportunitiesByStageReport: () => OpportunitiesByStageReport, - OpportunityFunnelByOwnerStageReport: () => OpportunityFunnelByOwnerStageReport, - PipelineCoverageByQuarterReport: () => PipelineCoverageByQuarterReport, - WonOpportunitiesByOwnerReport: () => WonOpportunitiesByOwnerReport -}); - -// src/sales/reports/account.report.ts -var AccountsByIndustryTypeReport = { - name: "accounts_by_industry_type", - label: "Accounts by Industry and Type", - description: "Matrix report showing accounts by industry and type", - dataset: "account_metrics", - rows: ["industry"], - columns: ["type"], - values: ["account_count", "annual_revenue_sum"], - type: "matrix", - runtimeFilter: { is_active: true } -}; - -// src/sales/reports/lead.report.ts -var LeadInflowByMonthSourceReport = { - name: "lead_inflow_by_month_source", - label: "Lead Engagement by Month \xD7 Source", - description: "Contacted-lead volume per month, broken down by acquisition channel", - dataset: "lead_metrics", - rows: ["lead_source"], - columns: ["last_contacted_date"], - values: ["lead_count"], - type: "matrix", - // A never-contacted lead has no engagement month, and grouping it produced a - // headerless '—' column next to the real ones. This report counts CONTACTED - // leads (see the label/description), so the empty bucket is excluded at the - // source rather than rendered as a mystery column. - runtimeFilter: { last_contacted_date: { $ne: null } } -}; - -// src/sales/reports/opportunity.report.ts -var OpportunitiesByStageReport = { - name: "opportunities_by_stage", - label: "Opportunities by Stage", - description: "Summary of opportunities grouped by stage", - dataset: "opportunity_metrics", - rows: ["stage"], - values: ["total_amount", "avg_probability"], - type: "summary", - // `{current_year_start}` is a spec date macro (DATE_MACRO_TOKENS) resolved - // per-query, so the YTD window rolls with time instead of freezing the year - // the artifact was built into dist/objectstack.json. - runtimeFilter: { stage: { $ne: "closed_lost" }, close_date: { $gte: "{current_year_start}" } }, - chart: { type: "bar", title: "Pipeline by Stage", showLegend: true, xAxis: "stage", yAxis: "total_amount" } -}; -var WonOpportunitiesByOwnerReport = { - name: "won_opportunities_by_owner", - label: "Won Opportunities by Owner", - description: "Closed won opportunities grouped by owner", - dataset: "opportunity_metrics", - rows: ["owner"], - values: ["total_amount"], - type: "summary", - runtimeFilter: { stage: "closed_won" }, - chart: { type: "column", title: "Revenue by Sales Rep", showLegend: false, xAxis: "owner", yAxis: "total_amount" } -}; -var PipelineCoverageByQuarterReport = { - name: "pipeline_coverage_by_quarter", - label: "Pipeline Coverage by Forecast \xD7 Quarter", - description: "Open pipeline amount by forecast category, bucketed by close quarter", - dataset: "opportunity_metrics", - rows: ["forecast_category"], - columns: ["close_quarter"], - values: ["total_amount", "opp_count"], - type: "matrix", - runtimeFilter: { stage: { $nin: ["closed_won", "closed_lost"] } } -}; -var OpportunityFunnelByOwnerStageReport = { - name: "opportunity_funnel_owner_stage", - label: "Opportunity Funnel by Owner \u2192 Stage", - description: "Per-rep stage-by-stage pipeline funnel", - dataset: "opportunity_metrics", - rows: ["owner", "stage"], - values: ["total_amount", "opp_count", "avg_probability"], - type: "summary", - runtimeFilter: { stage: { $ne: "closed_lost" } }, - chart: { type: "funnel", title: "Pipeline Funnel", showLegend: false, xAxis: "stage", yAxis: "total_amount" } -}; - -// src/sales/reports/churn.report.ts -var CustomerChurnSignalsReport = { - name: "customer_churn_signals", - label: "Customer Churn Signals", - description: "Three-panel early-warning view: at-risk customers, silent high-value accounts, and recently-lost opportunities.", - type: "joined", - blocks: [ - { - // Named for the ACTOR, not the value, because `at_risk` is also a - // `health_score` option and `at_risk_accounts` is already the block - // below (a time window, nothing to do with the field). The two are - // allowed to overlap: this one asks "who did a human flag", that one - // asks "whose clock stopped". - name: "csm_flagged_accounts", - label: "CSM-Flagged Accounts", - description: "Accounts a CSM has hand-flagged as at-risk or churning, grouped by type \u2014 human judgement, independent of the activity clock.", - type: "summary", - dataset: "account_metrics", - rows: ["type"], - values: ["account_count"], - // No date term on purpose (see the header). `is_active` matches the two - // account blocks below: a deactivated account has already churned, so it - // is not a retention queue item. Grouping by `type` separates a flagged - // CUSTOMER (revenue at risk today) from a flagged prospect or partner, - // which the grid view `crm_account.at_risk_accounts` cannot show — it is - // scoped to `type: 'customer'` before anything else. - runtimeFilter: { - is_active: true, - health_score: { $in: ["at_risk", "churning"] } - } - }, - { - name: "at_risk_accounts", - label: "At-Risk Accounts", - description: "Active accounts with no activity in 60+ days, grouped by industry.", - type: "summary", - dataset: "account_metrics", - rows: ["industry"], - values: ["account_count"], - runtimeFilter: { - is_active: true, - last_activity_date: { $lt: "{60_days_ago}" } - } - }, - { - name: "silent_high_value", - label: "Silent High-Value Accounts", - description: "Strategic and enterprise accounts gone quiet for 90+ days, grouped by type.", - type: "summary", - dataset: "account_metrics", - rows: ["type"], - values: ["account_count"], - // "High-value" is the account's tier, not a revenue threshold: the - // strategic/enterprise tiers are exactly the book the CSM team owns. - runtimeFilter: { - is_active: true, - tier: { $in: ["strategic", "enterprise"] }, - last_activity_date: { $lt: "{90_days_ago}" } - } - }, - { - name: "recently_closed_lost", - label: "Recently Lost Opportunities", - description: "Opportunities closed-lost in the last 30 days \u2014 investigate before the customer fully churns.", - type: "summary", - dataset: "opportunity_metrics", - rows: ["owner"], - values: ["total_amount", "opp_count"], - runtimeFilter: { - stage: "closed_lost", - close_date: { $gte: "{30_days_ago}" } - } - } - ] -}; - -// src/sales/mappings/index.ts -var mappings_exports = {}; -__export(mappings_exports, { - AccountImportMapping: () => AccountImportMapping, - ContactImportMapping: () => ContactImportMapping, - LeadImportMapping: () => LeadImportMapping -}); - -// src/sales/mappings/account_import.mapping.ts -import { defineMapping } from "@objectstack/spec/data"; - -// src/sales/mappings/_shared.ts -var INDUSTRY_SYNONYMS = { - "SaaS": "software", - "Saas": "software", - "IT": "technology", - "Tech": "technology", - "Information Technology": "technology", - "Financial Services": "finance", - "Banking": "finance", - "Insurance": "finance", - "Health Care": "healthcare", - "Pharmaceuticals": "healthcare", - "E-commerce": "retail", - "Ecommerce": "retail", - "Consumer Goods": "retail", - "Transportation": "logistics", - "Utilities": "energy", - "Oil & Gas": "energy", - "Public Sector": "government", - "Non Profit": "nonprofit", - "Non-Profit": "nonprofit", - "NGO": "nonprofit", - "Travel & Hospitality": "hospitality" -}; -var LEAD_SOURCE_SYNONYMS = { - "Website": "web", - "Web Site": "web", - "Inbound": "web", - "Word of mouth": "referral", - "Customer Referral": "referral", - "Trade Show": "event", - "Conference": "event", - "Seminar": "webinar", - "Partner Referral": "partner", - "Google Ads": "paid_search", - "AdWords": "paid_search", - "SEM": "paid_search", - "LinkedIn": "social", - "Facebook": "social", - "X": "social", - "Twitter": "social", - "Blog": "content", - "Whitepaper": "content", - "Phone Inquiry": "cold_call", - "Outbound": "cold_call", - "Email": "email_campaign", - "Newsletter": "email_campaign" -}; -var DEPARTMENT_SYNONYMS = { - "HR": "hr" -}; - -// src/sales/mappings/account_import.mapping.ts -var AccountImportMapping = defineMapping({ - name: "crm_account_import", - label: "Account Import (CSV)", - targetObject: "crm_account", - sourceFormat: "csv", - // also accepted for .xlsx uploads — both are tabular - mode: "upsert", - upsertKey: ["name"], - fieldMapping: [ - { source: "Account Name", target: "name" }, - { - source: "Account Type", - target: "type", - transform: "map", - params: { - valueMap: { - "Client": "customer", - "Reseller": "partner", - "Churned": "former", - "Lost Customer": "former" - } - } - }, - { - source: "Industry", - target: "industry", - transform: "map", - params: { valueMap: INDUSTRY_SYNONYMS } - }, - // The account hook rejects a website that is not http(s) — keep full URLs - // in the source sheet (see `src/sales/objects/account.hook.ts`). - { source: "Website", target: "website" }, - { source: "Phone", target: "phone" }, - { source: "Annual Revenue", target: "annual_revenue" }, - { source: "Employees", target: "number_of_employees" }, - { source: "Description", target: "description" }, - // Owner resolution. VERIFIED against the platform import path - // (`packages/rest/src/import-runner.ts` → `resolveRef`): a reference cell - // is resolved against the referenced object by `id`, the field's - // `displayField`, then `name` / `title` / `label` / `full_name` / `email` / - // `username`. `sys_user` has an `email` column, so an owner-email cell - // resolves to that user's id — no separate resolution step is needed here. - // An address that matches no user FAILS the row (`reference_not_found`); - // leaving the cell BLANK is the supported fallback — the security - // middleware's insert-time stamp then makes the importing user the owner - // (the import write carries the importer's context, not `isSystem`). - // - // The target is `owner_id`, the platform ownership anchor — #548 retired - // the app-authored `owner` lookup this used to name. A resolved cell is - // therefore an ownership TRANSFER: it plants the row under someone other - // than the importer, which the #3004 guard denies unless the importing user - // holds `allowTransfer` (system_admin / sales_manager do). That is the - // intended posture — a bulk file that silently reassigns the book is - // exactly what the grant exists to gate. - { source: "Account Owner Email", target: "owner_id", transform: "lookup" }, - // Self-reference: a parent named later in the same file still resolves — - // the runner flushes buffered creates and retries once (framework#3148). - { source: "Parent Account", target: "parent_account", transform: "lookup" } - // NOT MAPPED — `billing_address` / `office_location` are structured - // (json-backed `address` / `location`) fields. A joined string is not a - // way in: the engine rejects it per row — measured, `Billing Address has an - // invalid address value: Invalid input: expected object, received string`. - // (The dry run does NOT predict that rejection; it reports the row ok. - // Framework-side, filed as objectstack-ai/objectstack#4633.) - // Address columns are therefore left out of the account template. A target - // may now name a declared PART of a compound field — `contact_import.mapping.ts` - // maps five columns into `mailing_address.street` … `.country` (#1836) — so - // adding address columns here would be a template change, not a platform gap. - ] -}); - -// src/sales/mappings/contact_import.mapping.ts -import { defineMapping as defineMapping2 } from "@objectstack/spec/data"; -var ContactImportMapping = defineMapping2({ - name: "crm_contact_import", - label: "Contact Import (CSV)", - targetObject: "crm_contact", - sourceFormat: "csv", - mode: "upsert", - upsertKey: ["email"], - fieldMapping: [ - { source: "Salutation", target: "salutation" }, - { source: "First Name", target: "first_name" }, - { source: "Last Name", target: "last_name" }, - // Required master-detail parent; resolved by account name. - { source: "Account Name", target: "crm_account", transform: "lookup" }, - { source: "Title", target: "title" }, - { - source: "Department", - target: "department", - transform: "map", - params: { valueMap: DEPARTMENT_SYNONYMS } - }, - { source: "Email", target: "email" }, - { source: "Phone", target: "phone" }, - { source: "Mobile", target: "mobile" }, - // Five template columns, one structured field: each column names a part - // of `mailing_address`, and the import assembles the parts one row maps - // into that field's single value. - { source: "Mailing Street", target: "mailing_address.street" }, - { source: "Mailing City", target: "mailing_address.city" }, - { source: "Mailing State", target: "mailing_address.state" }, - { source: "Mailing Postal Code", target: "mailing_address.postalCode" }, - { source: "Mailing Country", target: "mailing_address.country" }, - { - source: "Lead Source", - target: "lead_source", - transform: "map", - params: { valueMap: LEAD_SOURCE_SYNONYMS } - }, - { source: "Description", target: "description" }, - // Owner-email resolution, the blank-cell fallback, and why a filled cell - // needs `allowTransfer`: see the long note in `account_import.mapping.ts`. - { source: "Contact Owner Email", target: "owner_id", transform: "lookup" } - ] -}); - -// src/sales/mappings/lead_import.mapping.ts -import { defineMapping as defineMapping3 } from "@objectstack/spec/data"; -var LeadImportMapping = defineMapping3({ - name: "crm_lead_import", - label: "Lead Import (CSV)", - targetObject: "crm_lead", - sourceFormat: "csv", - mode: "upsert", - upsertKey: ["email"], - fieldMapping: [ - { source: "Salutation", target: "salutation" }, - { source: "First Name", target: "first_name" }, - { source: "Last Name", target: "last_name" }, - { source: "Company", target: "company" }, - { source: "Title", target: "title" }, - { - source: "Industry", - target: "industry", - transform: "map", - params: { valueMap: INDUSTRY_SYNONYMS } - }, - { source: "Email", target: "email" }, - { source: "Phone", target: "phone" }, - { source: "Mobile", target: "mobile" }, - { source: "Website", target: "website" }, - { - source: "Lead Status", - target: "status", - transform: "map", - params: { - valueMap: { - "Open": "new", - "Working": "contacted", - "In Progress": "contacted", - "Nurturing": "contacted", - "Disqualified": "unqualified", - "Closed - Not Converted": "unqualified" - } - } - }, - { - source: "Lead Source", - target: "lead_source", - transform: "map", - params: { valueMap: LEAD_SOURCE_SYNONYMS } - }, - { source: "Annual Revenue", target: "annual_revenue" }, - { source: "Employees", target: "number_of_employees" }, - { source: "Description", target: "description" }, - // Owner-email resolution and the `allowTransfer` gate on a filled cell: - // see the long note in `account_import.mapping.ts`. The blank-cell - // behaviour differs — see the header comment above. - { source: "Lead Owner Email", target: "owner_id", transform: "lookup" } - // NOT MAPPED — `crm_lead.address` is a structured (json-backed) `address` - // field; the import path cannot compose one from separate street/city/ - // postcode columns, and a joined string is rejected per row. Same - // reasoning, and the same measurement, as the account mapping. - ] -}); - -// src/sales/apps/index.ts -var apps_exports = {}; -__export(apps_exports, { - CrmApp: () => CrmApp -}); - -// src/sales/apps/crm.app.ts -import { App } from "@objectstack/spec/ui"; -var HOTCRM_ICON = 'data:image/svg+xml,%0A %0A %0A%0A'; -var CrmApp = App.create({ - name: "crm_enterprise", - label: "HotCRM", - icon: "briefcase", - // ADR-0063 §1/§2 — `defaultAgent` is a surface binding, not a custom-agent - // slot: the only resolvable values are the two PLATFORM agents, `ask` (data - // surface) and `build` (authoring surface). HotCRM is a data surface, so it - // binds `ask`; the app's own AI capability ships as skills (`src/*/skills/`), - // which attach to the platform agents by `surface` affinity. The app-authored - // agents this key used to name were retired in #512. - defaultAgent: "ask", - // `logo` and `favicon` are the inlined `HOTCRM_ICON` above (#2051), never a - // server path: an install serves only what the artifact carries. The console - // passes each value through untouched — `logo` as the sidebar's ``, - // `favicon` as the favicon `link.href` — and a `data:` URI renders in both. - // `primaryColor` is the icon's tile fill (#2066): the mark and the theme are one orange. - branding: { - primaryColor: "#EA580C", - logo: HOTCRM_ICON, - favicon: HOTCRM_ICON - }, - navigation: [ - // Pinned landing — single executive view, single click from launcher. - { - id: "nav_home", - type: "dashboard", - dashboardName: "executive_dashboard", - label: "Home", - icon: "home" - }, - { - id: "group_sales", - type: "group", - label: "Sales", - icon: "chart-line", - expanded: true, - children: [ - { id: "nav_lead", type: "object", objectName: "crm_lead", label: "Leads", icon: "user-plus" }, - { id: "nav_account", type: "object", objectName: "crm_account", label: "Accounts", icon: "building" }, - // ADR-0047 interface page — the curated counterpart to the Accounts - // object entry (quick filters only; activates with spec > 9.2.0). - { id: "nav_account_workbench", type: "page", pageName: "account_workbench", label: "Account Workbench", icon: "sliders-horizontal" }, - { id: "nav_contact", type: "object", objectName: "crm_contact", label: "Contacts", icon: "user" }, - // No separate "Pipeline" entry: the kanban board is another tab on - // this same list page — `pipeline_kanban` in - // `OpportunityViews.listViews`, which the switcher puts on the strip - // under its own label, *Sales Pipeline* — one click from here and - // zero clicks further than a second sidebar row. The - // view-entry exemplar duty this item used to carry now sits with the - // "My Work" items below, which are all object + `viewName`. - { id: "nav_opportunity", type: "object", objectName: "crm_opportunity", label: "Opportunities", icon: "target" }, - { id: "nav_quote", type: "object", objectName: "crm_quote", label: "Quotes", icon: "receipt" }, - // Contracts close the sales cycle: quote → signed agreement → renewal. - // The object, its views and its renewal automation all shipped, but - // there was no way to reach any of it from the app. - { id: "nav_contract", type: "object", objectName: "crm_contract", label: "Contracts", icon: "file-signature" }, - // Products sit here, not under Marketing (#1259): they are the - // revenue master data every quote line and opportunity line item - // points at — a sales object that happened to be filed next to - // campaigns. - { id: "nav_product", type: "object", objectName: "crm_product", label: "Products", icon: "package" }, - { id: "nav_sales_dashboard", type: "dashboard", dashboardName: "sales_dashboard", label: "Sales Performance", icon: "chart-line" } - ] - }, - { - // Everything a rep owes someone. `crm_task` had views, seed data, a - // recurrence hook and two reminder flows, and no entry point — the only - // way to see a task was to open the record it hung off. - id: "group_work", - type: "group", - label: "My Work", - icon: "list-checks", - expanded: true, - // These are ListViews: they list the records themselves, which a - // dashboard widget (an aggregate over a dataset, ADR-0021) cannot. Both - // surfaces resolve `{current_user_id}` since objectstack#12230 — the - // Service dashboard's "My Open Cases by Priority" is the aggregate - // counterpart of "My Cases" (#510). - // - // Every item here is object + `viewName`, which makes this group the - // app's view-entry exemplar since #1259 retired the "Pipeline" row. - // The one exception is the approvals Inbox at the bottom — a - // `component` entry, and the app's only one. - children: [ - { id: "nav_my_tasks", type: "object", objectName: "crm_task", viewName: "my_open_tasks", label: "My Tasks", icon: "circle-check" }, - { id: "nav_my_deals", type: "object", objectName: "crm_opportunity", viewName: "my_open_deals", label: "My Deals", icon: "target" }, - { id: "nav_my_leads", type: "object", objectName: "crm_lead", viewName: "my_leads", label: "My Leads", icon: "user-plus" }, - // #592 — the rep's own calendar: a list of events, so a view, not a - // dashboard. - { id: "nav_my_calendar", type: "object", objectName: "crm_event", viewName: "my_events", label: "My Calendar", icon: "calendar-days" }, - // No "All Tasks" entry: "My Tasks" opens the `crm_task` list page, - // whose tab strip leads with *All Tasks* — `TaskViews.list`, name - // `all_tasks`. It leads because it is the object's PRIMARY list: the - // switcher moves the primary to the front of the strip and marks it - // default, so nothing has to be authored to say so. The whole book is - // one tab away, and the sidebar keeps one row per object instead of - // two. - // - // ── The approvals Inbox lives here, not in a group of its own (#1259) - // - // It used to be the single child of an "Approvals" group. Its content - // is a personal queue — the things waiting on *you* — which is what - // this group is; a one-item group next to it was structure without a - // distinction. Dissolving that group is why this entry moved, not any - // rule against single-item groups (Marketing is one and stays one). - // - // "Inbox" (zh-CN 待我审批) must land somewhere an approver can actually - // approve. It used to be `type: 'object'` on `sys_approval_request` — - // the approvals plugin's raw request table, which is read-only: no row - // actions, no approve/reject, only Share on the record detail. The label - // promised an action the destination could not perform (#1123). - // - // `component` — not `url`. The platform's approval centre is a - // first-party console surface registered in the ComponentRegistry as - // `approvals:inbox` (registered by @objectstack/console itself, source - // `@object-ui/console`, rendering ApprovalsInboxPage) — exactly what the - // spec documents `component` for: "a first-party UI shipped with the - // platform — typically admin/setup surfaces that have no row in any data - // store". `url` is documented as the *external link* type, and taking it - // would mean hard-coding a console-internal route plus this app's own - // name (`/apps/crm_enterprise/system/approvals`) into metadata. A - // `componentRef` instead resolves against the *current* app base, so the - // entry keeps the user inside HotCRM's shell without naming the app, and - // a ref that ever stops resolving renders a loud "Component not - // registered" panel rather than silently bouncing to the console home. - // - // The read-only object list is not kept as a second "history" entry: the - // approval centre already subsumes it — My Pending / Submitted by me / - // All tabs plus a status filter (Pending / Approved / Rejected / - // Recalled / Returned for revision) — so a second entry would add a - // strictly weaker view of the same rows. - // - // `requiresObject` is retained: it is a base nav-item field on every - // item type, so the entry still hides itself on installs where - // @objectstack/plugin-approvals is absent and no approval exists to act - // on. - // - // There is no "Processes" item either: @objectstack/plugin-approvals - // registers sys_approval_request / sys_approval_action / - // sys_approval_approver / sys_approval_delegation — but neither a bare - // `sys_approval` nor a `sys_approval_process` object exists in any - // installed plugin (measured on the 17.2.0 rosters), - // so the old item's requiresObject guard hid it on every install, - // forever. - { id: "nav_approval_requests", type: "component", componentRef: "approvals:inbox", label: "Inbox", icon: "inbox", requiresObject: "sys_approval_request" } - ] - }, - { - // #592 — activity was the app's largest blind spot: `crm_event` and its - // attendee rows had nowhere to be seen, and no dashboard anywhere counted - // an interaction. Kept as its own group rather than buried under Sales, - // because "what happened with this customer, and when?" is the question - // the whole batch was about. - id: "group_activity", - type: "group", - label: "Activity", - icon: "calendar-days", - expanded: true, - children: [ - // One row for the object, one for the dashboard. The calendar and the - // interaction history are two more tabs on this same list page — - // `event_calendar` and `held_events` in `EventViews.listViews`, which - // the switcher puts on the strip under each view's own label — #1259 - // removed the sidebar duplicates, not the surfaces. `crm_event` had - // four sidebar rows; - // it was the single largest source of the nav's growth. - { id: "nav_event", type: "object", objectName: "crm_event", label: "Events", icon: "calendar-days" }, - { id: "nav_activity_dashboard", type: "dashboard", dashboardName: "sales_activity_dashboard", label: "Sales Activity", icon: "activity" } - ] - }, - { - // Campaigns drive lead_source and the campaign-member records that - // "Add to Campaign" writes — with no nav entry the marketing half of - // the data model was invisible. - // - // A single-item group on purpose (#1259). Marketing is a domain of its - // own, and a reader scanning the sidebar for "where does campaign work - // live" finds it by name. Item-count symmetry is not the goal; the - // Approvals group was dissolved because its item *was* personal work, - // not because one child is too few. - id: "group_marketing", - type: "group", - label: "Marketing", - icon: "megaphone", - children: [ - { id: "nav_campaign", type: "object", objectName: "crm_campaign", label: "Campaigns", icon: "megaphone" } - ] - }, - { - id: "group_service", - type: "group", - label: "Service", - icon: "headset", - expanded: true, - // EMPTY ON PURPOSE — this group is a CONTAINER, not a menu. - // - // `crm_case`, `crm_knowledge_article`, `service_dashboard` and - // `sla_performance` belong to `app.objectstack.hotcrm.service`, and an - // app's own `navigation` may not name another package's object (ADR-0130 - // §1.5): the entry fails at author time with "references object - // `crm_case` which is not defined in objects". The module puts all three - // back through `navigationContributions` (ADR-0029 D7), and it can only - // aim at a group the app DECLARES — a module cannot create one inside an - // app it does not own. So the app publishes the anchor and the module - // fills it; `src/service/index.ts` holds the other half, and the two - // service items of *My Work* and *Insights* come back the same way. - // - // ⛔ Do not "tidy" the group away: deleting it relocates all three - // contributed items to the app's top level with a - // `nav_contribution_group_missing` warning. - children: [] - }, - { - id: "group_insights", - type: "group", - label: "Insights", - icon: "sparkles", - children: [ - // Trimmed to three high-signal reports. Full report catalogue still - // ships as metadata; admins can pin more from the report picker. - { id: "nav_crm_dashboard", type: "dashboard", dashboardName: "crm_overview_dashboard", label: "CRM Overview", icon: "layout-dashboard" }, - { id: "nav_forecast", type: "object", objectName: "crm_forecast", label: "Forecasts", icon: "trending-up" }, - { id: "nav_report_pipeline_coverage", type: "report", reportName: "pipeline_coverage_by_quarter", label: "Pipeline Coverage", icon: "columns-3" }, - { id: "nav_report_lead_inflow", type: "report", reportName: "lead_inflow_by_month_source", label: "Lead Inflow", icon: "trending-up" } - ] - } - ] -}); - -// src/sales/profiles/index.ts -var profiles_exports = {}; -__export(profiles_exports, { - GuestPortalProfile: () => GuestPortalProfile, - MarketingUserProfile: () => MarketingUserProfile, - SalesManagerProfile: () => SalesManagerProfile, - SalesRepProfile: () => SalesRepProfile, - ServiceAgentProfile: () => ServiceAgentProfile, - ServiceManagerProfile: () => ServiceManagerProfile, - SystemAdminProfile: () => SystemAdminProfile -}); - -// src/sales/profiles/guest-portal.profile.ts -var GuestPortalProfile = { - name: "guest_portal", - label: "Guest (Public Forms)", - description: "Anonymous visitors submitting public Web-to-Lead / Web-to-Case forms. INSERT-only on lead and case; no read/edit/delete on any object.", - // No `allowExport` anywhere below, deliberately: this set is bound to the - // `guest` anchor, and ADR-0090 D9 classes `allowExport` as a high-privilege - // bit no anchor may confer — the set would stop binding at all, on top of - // handing anonymous visitors bulk table egress. See `src/sales/profiles/index.ts`. - objects: { - crm_lead: { - allowCreate: true, - allowRead: false, - allowEdit: false, - allowDelete: false, - viewAllRecords: false, - modifyAllRecords: false - }, - crm_case: { - allowCreate: true, - allowRead: false, - allowEdit: false, - allowDelete: false, - viewAllRecords: false, - modifyAllRecords: false - } - } -}; - -// src/sales/profiles/marketing-user.profile.ts -var MarketingUserProfile = { - name: "marketing_user", - label: "Marketing User", - objects: { - // `allowExport` where an export surface exists — canonical note in - // `src/sales/profiles/index.ts`. Lead and contact list exports are marketing's - // core targeting workflow; account/opportunity back the campaign-ROI - // reports. No `crm_case` grant here, so no export bit for it either. - crm_lead: { allowCreate: true, allowRead: true, allowEdit: true, allowDelete: false, viewAllRecords: true, modifyAllRecords: false, allowExport: true }, - crm_account: { allowCreate: false, allowRead: true, allowEdit: false, allowDelete: false, viewAllRecords: true, modifyAllRecords: false, allowExport: true }, - crm_contact: { allowCreate: true, allowRead: true, allowEdit: true, allowDelete: false, viewAllRecords: true, modifyAllRecords: false, allowExport: true }, - crm_campaign: { allowCreate: true, allowRead: true, allowEdit: true, allowDelete: false, viewAllRecords: true, modifyAllRecords: false }, - // Org-wide read: marketing attributes campaign → pipeline ROI, which needs - // every opportunity, not just self-owned. viewAllRecords was false here - // while every other object on this set is true — an oversight that hid all - // pipeline from marketing (and tripped security-private-no-readscope). - crm_opportunity: { allowCreate: false, allowRead: true, allowEdit: false, allowDelete: false, viewAllRecords: true, modifyAllRecords: false, allowExport: true }, - // Campaign membership is THIS profile's core write surface: the - // "Add to Campaign" action (`src/sales/actions/lead.actions.ts`) inserts - // `crm_campaign_member` rows, and before #488 no permission set granted the - // object — the action failed for the only persona meant to run it. Rows - // derive from the campaign (controlled_by_parent), so there is no record - // scope to author — and as of 17.0.0-rc.4 that derivation does follow the - // campaign grant: MEASURED and pinned by - // `test/parent-derived-reach.test.ts`, master accessibility resolves through - // the same paths a direct read of the campaign takes, ownership and - // `sys_record_share` grants included. For THIS profile the delta is small — - // `crm_campaign` is `public_read` and this set holds org-wide campaign read, - // so the rows are the same either way — but the grant is now scope that - // follows the campaigns above, not org-wide read in fact as it was through - // 17.0.0-rc.3 (objectstack-ai/objectstack#5386, #694). - // Deleting membership history stays a manager/admin privilege, matching - // every other object here. - crm_campaign_member: { allowCreate: true, allowRead: true, allowEdit: true, allowDelete: false, viewAllRecords: false, modifyAllRecords: false }, - // Read-only reference: knowledge articles for campaign copy - // (public_read catalog). - // Reads the KB and may rate it; cannot author articles (#601). - crm_article_feedback: { allowCreate: true, allowRead: true, allowEdit: true, allowDelete: false, viewAllRecords: true, modifyAllRecords: false }, - crm_knowledge_article: { allowCreate: false, allowRead: true, allowEdit: false, allowDelete: false, viewAllRecords: true, modifyAllRecords: false }, - // The record Attachments panel, READ only: canonical note on `enable.files` - // in `src/sales/objects/index.ts` (#2029). Which attachments it lists - // derives from the parent record; upload and delete wait upstream. - sys_attachment: { allowCreate: false, allowRead: true, allowEdit: false, allowDelete: false, viewAllRecords: false, modifyAllRecords: false }, - // The record Discussion panel, comments and activity: canonical note on - // `enable.feeds` in `src/sales/objects/index.ts` (#2029). Which threads it - // reaches derives from the parent record; deleting a comment waits upstream. - sys_comment: { allowCreate: true, allowRead: true, allowEdit: true, allowDelete: false, viewAllRecords: false, modifyAllRecords: false }, - sys_activity: { allowCreate: false, allowRead: true, allowEdit: false, allowDelete: false, viewAllRecords: false, modifyAllRecords: false } - }, - fields: { - // Marketing reads pipeline for campaign ROI but never prices a deal, and - // account health is the renewal team's call — read, never write (#488). - "crm_opportunity.amount": { readable: true, editable: false }, - "crm_account.health_score": { readable: true, editable: false } - }, - // The same private-deal row filter the sales_manager set carries: this - // profile also holds org-wide opportunity read, so it is one of the readers - // `crm_opportunity.is_private` has to hold back. See sales-manager.profile.ts - // for the full rationale. - rowLevelSecurity: [ - { - name: "opportunity_private_owner_only_marketing", - // A deal flagged Private is visible only to its owner, even to holders of - // org-wide opportunity read. (`rowLevelSecurity[].label` / `description` - // are display copy — the 17.7.0 liveness ledger marks both live: the - // permission editor draws them on the policy card. This policy authors - // neither, so its intent lives in this comment.) - object: "crm_opportunity", - operation: "select", - using: "is_private == false || owner_id == current_user.id" - }, - // The platform's `member_default` set carries a wildcard owner-only-writes - // policy (`created_by == current_user.id` on update), and RLS policies are - // OR-combined — so without a policy of its own, this set's allowEdit on - // campaigns only reaches campaigns the user personally created. That also - // silently broke "Add to Campaign": enrolling a member is a write DERIVED - // from the campaign (controlled_by_parent), so it requires campaign edit at - // the row level. This is the one direction in which the ADR-0055 derivation - // really does narrow: a master RLS policy is exactly what it folds in, while - // ownership and `sys_record_share` grants are not (which is why the READ - // side of these member rows is org-wide — see the `crm_campaign_member` - // grant above and objectstack-ai/objectstack#5386, #694). This policy widens - // campaign updates to every holder of the set — exactly what the object - // grant above already declares. `id != null` - // is the pushdown-safe "all rows" predicate (verified: compiles to - // `{id: {$null: false}}`). - { - name: "marketing_campaign_updates", - // Marketing users edit any campaign (and thereby enrol members into it), - // not only campaigns they created. - object: "crm_campaign", - operation: "update", - using: "id != null" - }, - // Same widening for the member rows themselves: response tracking means - // updating rows the enrollment flow (system context) created, which the - // default owner-only-writes policy would otherwise deny. - { - name: "marketing_campaign_member_updates", - // Marketing users update member response state on rows they did not - // personally create. - object: "crm_campaign_member", - operation: "update", - using: "id != null" - } - ] -}; - -// src/sales/profiles/sales-manager.profile.ts -var SalesManagerProfile = { - name: "sales_manager", - label: "Sales Manager", - objects: { - // `allowTransfer` on exactly the objects this set holds `modifyAllRecords` - // on — the sales book a manager reassigns. Canonical note in - // `src/sales/profiles/index.ts`. - // `allowExport` where an export surface exists — canonical note in - // `src/sales/profiles/index.ts`. A manager owns the number, so the pipeline and - // book exports that feed offline forecasting are part of the job. - crm_lead: { allowCreate: true, allowRead: true, allowEdit: true, allowDelete: true, viewAllRecords: true, modifyAllRecords: true, allowTransfer: true, allowExport: true }, - crm_account: { allowCreate: true, allowRead: true, allowEdit: true, allowDelete: true, viewAllRecords: true, modifyAllRecords: true, allowTransfer: true, allowExport: true }, - crm_contact: { allowCreate: true, allowRead: true, allowEdit: true, allowDelete: true, viewAllRecords: true, modifyAllRecords: true, allowTransfer: true, allowExport: true }, - crm_opportunity: { allowCreate: true, allowRead: true, allowEdit: true, allowDelete: true, viewAllRecords: true, modifyAllRecords: true, allowTransfer: true, allowExport: true }, - crm_quote: { allowCreate: true, allowRead: true, allowEdit: true, allowDelete: true, viewAllRecords: true, modifyAllRecords: true, allowTransfer: true }, - // No writeScope: `crm_contract` is `controlled_by_parent` under - // `crm_account` (#549), so a scope here would be inert — the write gate - // asks for EDIT on the account instead, which this set holds org-wide - // (`modifyAllRecords` above). That retires the #880 gap on BOTH editions: - // the contract an accepted quote drafts hangs under the rep, and the - // manager edits it because they can edit its account, not because of a - // hierarchy depth. `own_and_reports` was the app's only authored hierarchy - // scope; `requires: ['hierarchy-security']` stays declared (#1378 ruling). - // `allowDelete: false` must keep holding; `modifyAllRecords: false` keeps - // this off the super-user bypass. `test/contract-write-depth.test.ts`. - crm_contract: { allowCreate: true, allowRead: true, allowEdit: true, allowDelete: false, viewAllRecords: true, modifyAllRecords: false }, - crm_product: { allowCreate: true, allowRead: true, allowEdit: true, allowDelete: false, viewAllRecords: true, modifyAllRecords: false }, - crm_campaign: { allowCreate: true, allowRead: true, allowEdit: true, allowDelete: false, viewAllRecords: true, modifyAllRecords: false }, - crm_case: { allowCreate: false, allowRead: true, allowEdit: false, allowDelete: false, viewAllRecords: true, modifyAllRecords: false, allowExport: true }, - crm_task: { allowCreate: true, allowRead: true, allowEdit: true, allowDelete: true, viewAllRecords: true, modifyAllRecords: true, allowTransfer: true }, - // A manager coaches on activity, so this is org-wide read AND write on a - // private object — the same shape their `crm_task` grant already has. - // `crm_event_attendee` is `controlled_by_parent` (ADR-0055): no scope to - // author — one would be inert metadata. It narrows to the events this set - // can read, which is every event: `viewAllRecords` on `crm_event` above puts - // the whole activity stack in reach, so the derived attendee rows follow. - // MEASURED on 17.0.0-rc.4 and pinned by `test/parent-derived-reach.test.ts`, - // master accessibility resolves through the same paths a direct read of the - // event takes — ownership and `sys_record_share` grants folded in, not the - // master's row-level security policies alone. Until 17.0.0-rc.3 this grant - // was org-wide in FACT rather than by derivation, whatever the event grants - // said (#694); objectstack-ai/objectstack#5386 fixed that upstream and it - // shipped in rc.4. Same note in `sales-rep.profile.ts`. - crm_event: { allowCreate: true, allowRead: true, allowEdit: true, allowDelete: true, viewAllRecords: true, modifyAllRecords: true, allowTransfer: true }, - crm_event_attendee: { allowCreate: true, allowRead: true, allowEdit: true, allowDelete: true, viewAllRecords: false, modifyAllRecords: false }, - // The forecast IS the manager's job: they read every rep's snapshot and - // adjust the committed number, so this is org-wide read AND write on a - // private object (#488 — the object had no grant at all). - crm_forecast: { allowCreate: true, allowRead: true, allowEdit: true, allowDelete: false, viewAllRecords: true, modifyAllRecords: true, allowTransfer: true }, - // Knowledge is service-authored; sales reads it (public_read OWD). - // Reads the KB and may rate it; cannot author articles (#601). - crm_article_feedback: { allowCreate: true, allowRead: true, allowEdit: true, allowDelete: false, viewAllRecords: true, modifyAllRecords: false }, - crm_knowledge_article: { allowCreate: false, allowRead: true, allowEdit: false, allowDelete: false, viewAllRecords: true, modifyAllRecords: false }, - // Enrollment is marketing's job; a manager only reads the membership rows - // behind campaign ROI. `crm_campaign_member` is `controlled_by_parent`, so - // no readScope/viewAllRecords applies (ADR-0055) — but the rows do not - // "follow the campaign": the derivation resolves the master set through the - // master's RLS policies only (none narrow a select on `crm_campaign`), so - // this is org-wide read on every member row. The practical delta is small - // here — `crm_campaign` is `public_read` and this set reads every campaign - // anyway — so the intended derivation would return the same rows. See - // `campaign_member.object.ts` and objectstack-ai/objectstack#5386 (#694). - crm_campaign_member: { allowCreate: false, allowRead: true, allowEdit: false, allowDelete: false, viewAllRecords: false, modifyAllRecords: false }, - // Line items: full CRUD so a manager can fix pricing on any rep's deal or - // quote. Both objects are `controlled_by_parent`, so there is no scope to - // author — but that derivation does not narrow these rows to the deals and - // quotes the manager can read. MEASURED (see the note in - // `sales-rep.profile.ts` and `test/parent-derived-reach.test.ts`): the master - // set comes from the master's RLS policies only, never from ownership or a - // share. This set authors one such policy — the private-deal filter on - // `crm_opportunity` below — and none on `crm_quote`, so quote lines are - // org-wide, and opportunity lines are bounded by that policy and nothing - // else (the guard test pins the quote chain; the opportunity side follows - // from the same measured mechanism). Upstream gap: - // objectstack-ai/objectstack#5386 (#694). - crm_opportunity_line_item: { allowCreate: true, allowRead: true, allowEdit: true, allowDelete: true, viewAllRecords: false, modifyAllRecords: false }, - crm_quote_line_item: { allowCreate: true, allowRead: true, allowEdit: true, allowDelete: true, viewAllRecords: false, modifyAllRecords: false }, - // The record Attachments panel, READ only: canonical note on `enable.files` - // in `src/sales/objects/index.ts` (#2029). Which attachments it lists - // derives from the parent record; upload and delete wait upstream. - sys_attachment: { allowCreate: false, allowRead: true, allowEdit: false, allowDelete: false, viewAllRecords: false, modifyAllRecords: false }, - // The record Discussion panel, comments and activity: canonical note on - // `enable.feeds` in `src/sales/objects/index.ts` (#2029). Which threads it - // reaches derives from the parent record; deleting a comment waits upstream. - sys_comment: { allowCreate: true, allowRead: true, allowEdit: true, allowDelete: false, viewAllRecords: false, modifyAllRecords: false }, - sys_activity: { allowCreate: false, allowRead: true, allowEdit: false, allowDelete: false, viewAllRecords: false, modifyAllRecords: false } - }, - fields: { - // Sensitive fields a manager must see in full. Authored explicitly rather - // than left absent: these are the fields other sets mask, and an unauthored - // grant reads as an oversight instead of a decision (#488). - "crm_opportunity.amount": { readable: true, editable: true }, - "crm_account.health_score": { readable: true, editable: true }, - "crm_quote.internal_notes": { readable: true, editable: true }, - // Case internal notes are the service team's working memory: a sales - // manager reads them for account context but never edits them. - "crm_case.internal_notes": { readable: true, editable: false } - }, - // ADR-0058: `crm_opportunity.is_private` is settable in the opportunity form - // (`opportunity.view.ts`) and, before this rule, was read by nothing — a - // checkbox that promised confidentiality and delivered none. Org-wide readers - // are exactly who it has to hold back, so the set that grants - // `viewAllRecords` on opportunities also carries the row filter that honours - // it. Compiles to `{ $or: [{ is_private: false }, { owner_id: }] }`. - // - // `owner_id`, not the app-authored `owner` lookup this used to name: #548 - // retired that field. The predicate now keys on the SAME column the OWD / - // sharing owner-match reads, so "its owner" means one thing app-wide. - rowLevelSecurity: [ - { - name: "opportunity_private_owner_only", - // A deal flagged Private is visible only to its owner, even to holders of - // org-wide opportunity read. (`rowLevelSecurity[].label` / `description` - // are display copy — the 17.7.0 liveness ledger marks both live: the - // permission editor draws them on the policy card. This policy authors - // neither, so its intent lives in this comment.) - object: "crm_opportunity", - operation: "select", - using: "is_private == false || owner_id == current_user.id" - } - ] -}; - -// src/sales/profiles/sales-rep.profile.ts -var SalesRepProfile = { - name: "sales_rep", - label: "Sales Representative", - // A rep's book of business is private by design (own records + whatever a - // sharing rule or team grant extends). The objects below carry an explicit - // `readScope: 'own'` so the intent is authored, not inferred — this both - // silences the `security-private-no-readscope` liveness warning and pins the - // behavior: without it, a private-OWD object with allowRead but no scope is - // an under-specified grant the engine reads as "own only" anyway. - // - // What widens that scope today is narrower than it sounds: the territory / - // account-team rules are authored on `crm_account` ONLY, and a sharing rule - // widens the object it names — not the records hanging off it. So a rep who - // receives an account through a territory rule reads that account, while the - // tasks on it stay own-only and opportunities widen only through the - // >= $100k leadership rules. Quotes and contracts are the exception since - // #549 (ruling 2026-08-31): both are `controlled_by_parent` under the - // account, so they arrive with it — the same derivation as contacts. - // - // The `controlled_by_parent` grants below read as narrow, and as of - // 17.0.0-rc.4 they ARE. MEASURED and pinned by - // `test/parent-derived-reach.test.ts`: the ADR-0055 derivation resolves master - // accessibility through the same paths a direct read of the master takes — - // owner scope AND `sys_record_share` grants, not the master's row-level - // security policies alone. A rep holding ONE account through a territory rule - // reads that account's contacts and no others, and reads line items only under - // the quotes they can reach. Writes derive the same way: a child of a master - // the rep cannot edit is refused. So each grant below is bounded by the - // parent's sharing, which is what it looks like. - // - // Until 17.0.0-rc.3 the same grants were org-wide reads and this note said so - // (#694): the derivation consulted master RLS policies only, and HotCRM - // authors none, so the master set was every record. - // objectstack-ai/objectstack#5386 fixed that upstream and it shipped in rc.4. - objects: { - // `allowExport` where an export surface exists — canonical note in - // `src/sales/profiles/index.ts`. Safe alongside `readScope: 'own'`: export is - // read-derived, so a rep's CSV carries their own book, not the org's. - crm_lead: { allowCreate: true, allowRead: true, allowEdit: true, allowDelete: false, viewAllRecords: false, modifyAllRecords: false, readScope: "own", allowExport: true }, - crm_account: { allowCreate: true, allowRead: true, allowEdit: true, allowDelete: false, viewAllRecords: false, modifyAllRecords: false, readScope: "own", allowExport: true }, - // NO readScope: `crm_contact` is `controlled_by_parent` (master-detail to - // crm_account), so a `readScope` here is inert — the sharing service only - // applies owner scope to `private` objects — and it read as a promise the - // engine never kept: it said "own contacts only" while access derived from - // the parent (#488). That derivation now delivers exactly "the accounts the - // rep can read": measured on 17.0.0-rc.4, a rep holding one territory - // account reads THAT account's contacts and no others (see the note at the - // top of this file, #694). - crm_contact: { allowCreate: true, allowRead: true, allowEdit: true, allowDelete: false, viewAllRecords: false, modifyAllRecords: false, allowExport: true }, - crm_opportunity: { allowCreate: true, allowRead: true, allowEdit: true, allowDelete: false, viewAllRecords: false, modifyAllRecords: false, readScope: "own", allowExport: true }, - // NO readScope on quote/contract either: both are `controlled_by_parent` - // under `crm_account` (#549), so a scope here would be inert. A rep reads - // the quotes and contracts of every account they can reach, edits the - // quotes of accounts they can edit, and never edits a contract (object - // gate). `test/parent-derived-reach.test.ts` measures both levels. - crm_quote: { allowCreate: true, allowRead: true, allowEdit: true, allowDelete: false, viewAllRecords: false, modifyAllRecords: false }, - crm_contract: { allowCreate: false, allowRead: true, allowEdit: false, allowDelete: false, viewAllRecords: false, modifyAllRecords: false }, - crm_product: { allowCreate: false, allowRead: true, allowEdit: false, allowDelete: false, viewAllRecords: true, modifyAllRecords: false }, - crm_campaign: { allowCreate: false, allowRead: true, allowEdit: false, allowDelete: false, viewAllRecords: true, modifyAllRecords: false }, - crm_case: { allowCreate: false, allowRead: true, allowEdit: false, allowDelete: false, viewAllRecords: false, modifyAllRecords: false, readScope: "own", allowExport: true }, - crm_task: { allowCreate: true, allowRead: true, allowEdit: true, allowDelete: true, viewAllRecords: false, modifyAllRecords: false, readScope: "own" }, - // ─── Activity (#592) ────────────────────────────────────────────── - // `crm_event` is `private` like `crm_task` — a personal activity record — - // so an explicit record scope is required alongside allowRead (an omitted - // scope silently means "own only" and reads as an unmade decision). - // `crm_event_attendee` is `controlled_by_parent`, so authoring a readScope - // here would be inert metadata the engine never applies. Its rows narrow to - // the events the rep can read — which, `crm_event` being private and - // own-scoped, is their own calendar (see the note at the top of this file, - // #694). - crm_event: { allowCreate: true, allowRead: true, allowEdit: true, allowDelete: true, viewAllRecords: false, modifyAllRecords: false, readScope: "own" }, - crm_event_attendee: { allowCreate: true, allowRead: true, allowEdit: true, allowDelete: true, viewAllRecords: false, modifyAllRecords: false }, - // Reference catalog (public_read OWD): reps read knowledge articles, which - // are authored by service. - // Reads the KB and may rate it; cannot author articles (#601). - crm_article_feedback: { allowCreate: true, allowRead: true, allowEdit: true, allowDelete: false, viewAllRecords: true, modifyAllRecords: false }, - crm_knowledge_article: { allowCreate: false, allowRead: true, allowEdit: false, allowDelete: false, viewAllRecords: true, modifyAllRecords: false }, - // Forecast snapshots are written by the nightly `forecast.hook` job and the - // `revenue_forecasting` skill, never by hand — read-only, and only the rep's - // own snapshots (private OWD + explicit own scope, as above). - crm_forecast: { allowCreate: false, allowRead: true, allowEdit: false, allowDelete: false, viewAllRecords: false, modifyAllRecords: false, readScope: "own" }, - // Product lines on deals and quotes. Both objects are - // `controlled_by_parent`, so there is no readScope to author — one would be - // inert metadata. That derivation scopes a rep to the lines under the deals - // and quotes they can reach: measured on 17.0.0-rc.4, a rep reads the lines - // of the one quote they own and none of the others (see the note at the top - // of this file, #694). Without these grants the opportunity "Products" - // related list and the whole CPQ path were denied for every non-admin user - // (#488). - crm_opportunity_line_item: { allowCreate: true, allowRead: true, allowEdit: true, allowDelete: true, viewAllRecords: false, modifyAllRecords: false }, - crm_quote_line_item: { allowCreate: true, allowRead: true, allowEdit: true, allowDelete: true, viewAllRecords: false, modifyAllRecords: false }, - // Which campaign sourced a lead — read-only context, derived from the - // campaign (controlled_by_parent). Enrollment belongs to marketing_user. - crm_campaign_member: { allowCreate: false, allowRead: true, allowEdit: false, allowDelete: false, viewAllRecords: false, modifyAllRecords: false }, - // The record Attachments panel, READ only: canonical note on `enable.files` - // in `src/sales/objects/index.ts` (#2029). Which attachments it lists - // derives from the parent record; upload and delete wait upstream. - sys_attachment: { allowCreate: false, allowRead: true, allowEdit: false, allowDelete: false, viewAllRecords: false, modifyAllRecords: false }, - // The record Discussion panel, comments and activity: canonical note on - // `enable.feeds` in `src/sales/objects/index.ts` (#2029). Which threads it - // reaches derives from the parent record; deleting a comment waits upstream. - sys_comment: { allowCreate: true, allowRead: true, allowEdit: true, allowDelete: false, viewAllRecords: false, modifyAllRecords: false }, - sys_activity: { allowCreate: false, allowRead: true, allowEdit: false, allowDelete: false, viewAllRecords: false, modifyAllRecords: false } - }, - fields: { - "crm_account.annual_revenue": { readable: true, editable: false }, - "crm_account.description": { readable: true, editable: true }, - "crm_opportunity.amount": { readable: true, editable: true }, - "crm_opportunity.probability": { readable: true, editable: true }, - // Health score drives the renewal book and the at-risk views: reps see it, - // the renewal/CS process sets it. Readable (the `at_risk_accounts` view - // filters and sorts on it, and a masked field cannot be filtered) but never - // rep-editable — it was previously unauthored on every set (#488). - "crm_account.health_score": { readable: true, editable: false }, - // Quote internal notes stay rep-editable: `quote.hook` deliberately keeps - // them writable after a quote is sent, when nothing else is. - "crm_quote.internal_notes": { readable: true, editable: true }, - // Case internal notes are the service team's private working notes. A rep - // reads the case (own scope) for account context; the agent-only commentary - // inside it is masked — no view filters or sorts on this field, so masking - // costs nothing but the value itself. - "crm_case.internal_notes": { readable: false, editable: false } - } -}; - -// src/sales/profiles/service-agent.profile.ts -var ServiceAgentProfile = { - name: "service_agent", - label: "Service Agent", - objects: { - // Reference context an agent needs to work ANY ticket — a customer's cases - // are meaningless without seeing the account/contact behind them, so these - // are org-visible reads (viewAllRecords: true), NOT own-only. This was the - // security-private-no-readscope warning's real signal: allowRead on a - // private object with no scope had silently locked agents out of every - // account they didn't personally own. - // `allowExport` where an export surface exists — canonical note in - // `src/sales/profiles/index.ts`. `crm_opportunity` carries no export bit: this - // set has no read on it at all, and the axis never widens read. - crm_lead: { allowCreate: false, allowRead: true, allowEdit: false, allowDelete: false, viewAllRecords: true, modifyAllRecords: false, allowExport: true }, - crm_account: { allowCreate: false, allowRead: true, allowEdit: false, allowDelete: false, viewAllRecords: true, modifyAllRecords: false, allowExport: true }, - crm_contact: { allowCreate: false, allowRead: true, allowEdit: true, allowDelete: false, viewAllRecords: true, modifyAllRecords: false, allowExport: true }, - crm_opportunity: { allowCreate: false, allowRead: false, allowEdit: false, allowDelete: false, viewAllRecords: false, modifyAllRecords: false }, - // Cases + tasks: an agent's own queue by default (readScope: 'own'). - // Cross-agent visibility exists for CASES only — the escalation rules widen - // open critical cases to service_manager / service_director. `crm_task` has - // no sharing rule at all, so an agent reading an account org-wide still - // sees only their own tasks on it (#549). - crm_case: { allowCreate: true, allowRead: true, allowEdit: true, allowDelete: false, viewAllRecords: false, modifyAllRecords: false, readScope: "own", allowExport: true }, - // `allowTransfer` on `crm_task` ONLY — canonical note in - // `src/sales/profiles/index.ts`. Narrow and load-bearing: escalating a case fires - // `case_status_side_effects`, which opens the follow-up task OWNED BY the - // account owner (`case.hook.ts`). That insert runs on `ctx.api` with the - // agent's own context, so planting it under another user is a transfer and - // is denied without this bit — the case update would fail with it. This is - // "assign work to a colleague", not "reassign the ticket": the agent holds - // no transfer grant on `crm_case` or any customer record. - // - // ⚠️ Escalation DOES now move a case to the `service_manager` pool (#1070), - // and it does so with no `crm_case` grant here — deliberately. That - // hand-off runs on the `beforeUpdate` seam, which the #3004 guard cannot - // see (measured, three readings, in `_case-assignment.ts`'s header and - // pinned in `test/case-assignment.test.ts`), so the case moves as part of - // the escalation write the automation is already performing rather than as - // an agent-initiated transfer. Doing it the other way — a `ctx.api` write - // from `afterUpdate` — WOULD need `crm_case.allowTransfer` here, which - // would let an agent reassign any case they can edit. That is a - // permission-model decision and is not being taken as a side effect of a - // hook: this line stays `crm_task` only. - crm_task: { allowCreate: true, allowRead: true, allowEdit: true, allowDelete: true, viewAllRecords: false, modifyAllRecords: false, readScope: "own", allowTransfer: true }, - // #592 — `log_call` / `log_meeting` are scoped to `crm_case` too, and an - // agent who cannot INSERT a `crm_event` gets a button that 403s. Same - // own-scoped shape as their tasks. - crm_event: { allowCreate: true, allowRead: true, allowEdit: true, allowDelete: true, viewAllRecords: false, modifyAllRecords: false, readScope: "own" }, - crm_event_attendee: { allowCreate: true, allowRead: true, allowEdit: true, allowDelete: true, viewAllRecords: false, modifyAllRecords: false }, - crm_product: { allowCreate: false, allowRead: true, allowEdit: false, allowDelete: false, viewAllRecords: true, modifyAllRecords: false }, - // The knowledge base is this team's own surface: agents draft and revise - // articles (draft → in_review → published is enforced by the KB flow, not by - // CRUD), and read every published article regardless of author. Archiving - // is destructive-by-policy, so deletion stays with admins. Before #488 the - // object had no grant at all — the "Knowledge" nav item was denied for - // everyone, including the agents it was built for. - // Agents rate the articles they use to close cases (#601). Create + edit - // their OWN row (`modifyAllRecords: false` keeps them off everyone else's - // vote); no delete — a withdrawn opinion is a changed verdict, not an - // erased one. - crm_article_feedback: { allowCreate: true, allowRead: true, allowEdit: true, allowDelete: false, viewAllRecords: true, modifyAllRecords: false }, - crm_knowledge_article: { allowCreate: true, allowRead: true, allowEdit: true, allowDelete: false, viewAllRecords: true, modifyAllRecords: false }, - // The record Attachments panel, READ only: canonical note on `enable.files` - // in `src/sales/objects/index.ts` (#2029). Which attachments it lists - // derives from the parent record; upload and delete wait upstream. - sys_attachment: { allowCreate: false, allowRead: true, allowEdit: false, allowDelete: false, viewAllRecords: false, modifyAllRecords: false }, - // The record Discussion panel, comments and activity: canonical note on - // `enable.feeds` in `src/sales/objects/index.ts` (#2029). Which threads it - // reaches derives from the parent record; deleting a comment waits upstream. - sys_comment: { allowCreate: true, allowRead: true, allowEdit: true, allowDelete: false, viewAllRecords: false, modifyAllRecords: false }, - sys_activity: { allowCreate: false, allowRead: true, allowEdit: false, allowDelete: false, viewAllRecords: false, modifyAllRecords: false } - }, - fields: { - "crm_case.is_sla_violated": { readable: true, editable: false }, - "crm_case.resolution_time_hours": { readable: true, editable: false }, - // Internal notes are the agent's working memory on a ticket — full access - // here, read-only for sales_manager, masked for sales_rep (#488). - "crm_case.internal_notes": { readable: true, editable: true }, - // Account health is renewal-team data an agent reads for context only. - "crm_account.health_score": { readable: true, editable: false } - } -}; -var ServiceManagerProfile = { - ...ServiceAgentProfile, - name: "service_manager", - label: "Service Manager" -}; - -// src/sales/profiles/system-admin.profile.ts -var SystemAdminProfile = { - name: "system_admin", - label: "System Administrator", - objects: { - // `allowTransfer` on every object — canonical note in `src/sales/profiles/index.ts`. - // The admin is the persona that reassigns ownership when someone leaves. - // `allowExport` on the five objects with an export surface — see the - // canonical note in `src/sales/profiles/index.ts`. It is authored even here: - // 17.0 gates export on the explicit bit, and `modifyAllRecords` does not - // stand in for it, so without these an admin cannot export either. - crm_lead: { allowCreate: true, allowRead: true, allowEdit: true, allowDelete: true, viewAllRecords: true, modifyAllRecords: true, allowTransfer: true, allowExport: true }, - crm_account: { allowCreate: true, allowRead: true, allowEdit: true, allowDelete: true, viewAllRecords: true, modifyAllRecords: true, allowTransfer: true, allowExport: true }, - crm_contact: { allowCreate: true, allowRead: true, allowEdit: true, allowDelete: true, viewAllRecords: true, modifyAllRecords: true, allowTransfer: true, allowExport: true }, - crm_opportunity: { allowCreate: true, allowRead: true, allowEdit: true, allowDelete: true, viewAllRecords: true, modifyAllRecords: true, allowTransfer: true, allowExport: true }, - crm_quote: { allowCreate: true, allowRead: true, allowEdit: true, allowDelete: true, viewAllRecords: true, modifyAllRecords: true, allowTransfer: true }, - crm_contract: { allowCreate: true, allowRead: true, allowEdit: true, allowDelete: true, viewAllRecords: true, modifyAllRecords: true, allowTransfer: true }, - crm_product: { allowCreate: true, allowRead: true, allowEdit: true, allowDelete: true, viewAllRecords: true, modifyAllRecords: true, allowTransfer: true }, - crm_campaign: { allowCreate: true, allowRead: true, allowEdit: true, allowDelete: true, viewAllRecords: true, modifyAllRecords: true, allowTransfer: true }, - crm_case: { allowCreate: true, allowRead: true, allowEdit: true, allowDelete: true, viewAllRecords: true, modifyAllRecords: true, allowTransfer: true, allowExport: true }, - crm_task: { allowCreate: true, allowRead: true, allowEdit: true, allowDelete: true, viewAllRecords: true, modifyAllRecords: true, allowTransfer: true }, - crm_event: { allowCreate: true, allowRead: true, allowEdit: true, allowDelete: true, viewAllRecords: true, modifyAllRecords: true, allowTransfer: true }, - crm_event_attendee: { allowCreate: true, allowRead: true, allowEdit: true, allowDelete: true, viewAllRecords: true, modifyAllRecords: true, allowTransfer: true }, - // The objects below shipped with navigation, views, hooks and seed data - // but no grant in ANY permission set (#488): "Knowledge" and "Forecasts" - // were permission-denied nav items for every user, admins included. - crm_forecast: { allowCreate: true, allowRead: true, allowEdit: true, allowDelete: true, viewAllRecords: true, modifyAllRecords: true, allowTransfer: true }, - crm_article_feedback: { allowCreate: true, allowRead: true, allowEdit: true, allowDelete: true, viewAllRecords: true, modifyAllRecords: true, allowTransfer: true }, - crm_knowledge_article: { allowCreate: true, allowRead: true, allowEdit: true, allowDelete: true, viewAllRecords: true, modifyAllRecords: true, allowTransfer: true }, - // Detail rows. Their RECORD-level access derives from the master - // (ADR-0055 `controlled_by_parent`), but object-level CRUD is a separate - // gate that is never derived — it has to be granted explicitly here. - crm_opportunity_line_item: { allowCreate: true, allowRead: true, allowEdit: true, allowDelete: true, viewAllRecords: true, modifyAllRecords: true, allowTransfer: true }, - crm_quote_line_item: { allowCreate: true, allowRead: true, allowEdit: true, allowDelete: true, viewAllRecords: true, modifyAllRecords: true, allowTransfer: true }, - crm_campaign_member: { allowCreate: true, allowRead: true, allowEdit: true, allowDelete: true, viewAllRecords: true, modifyAllRecords: true, allowTransfer: true }, - // The record Attachments panel, READ only: canonical note on `enable.files` - // in `src/sales/objects/index.ts` (#2029). Which attachments it lists - // derives from the parent record; upload and delete wait upstream. - sys_attachment: { allowCreate: false, allowRead: true, allowEdit: false, allowDelete: false, viewAllRecords: false, modifyAllRecords: false }, - // The record Discussion panel, comments and activity: canonical note on - // `enable.feeds` in `src/sales/objects/index.ts` (#2029). Which threads it - // reaches derives from the parent record; deleting a comment waits upstream. - sys_comment: { allowCreate: true, allowRead: true, allowEdit: true, allowDelete: false, viewAllRecords: false, modifyAllRecords: false }, - sys_activity: { allowCreate: false, allowRead: true, allowEdit: false, allowDelete: false, viewAllRecords: false, modifyAllRecords: false } - }, - systemPermissions: [ - "view_setup", - "manage_users", - "customize_application", - "view_all_data", - "modify_all_data", - "manage_profiles", - "manage_roles", - "manage_sharing" - ] -}; - -// src/sales/translations/index.ts -var translations_exports = {}; -__export(translations_exports, { - CrmTranslations: () => CrmTranslations -}); - -// src/sales/translations/en/app.ts -var appSurface = { - apps: { - crm_enterprise: { - label: "HotCRM", - description: "Customer relationship management for sales, service, and marketing", - navigation: { - group_activity: { label: "Activity" }, - group_sales: { label: "Sales" }, - group_service: { label: "Service" }, - group_marketing: { label: "Marketing" } - } - } - }, - messages: { - "common.save": "Save", - "common.cancel": "Cancel", - "common.delete": "Delete", - "common.edit": "Edit", - "common.create": "Create", - "common.search": "Search", - "common.filter": "Filter", - "common.export": "Export", - "common.back": "Back", - "common.confirm": "Confirm", - "nav.sales": "Sales", - "nav.service": "Service", - "nav.marketing": "Marketing", - "nav.products": "Products", - "nav.analytics": "Analytics", - "success.saved": "Record saved successfully", - "success.converted": "Lead converted successfully", - "confirm.delete": "Are you sure you want to delete this record?", - "confirm.convert_lead": "Convert this lead to account, contact, and opportunity?", - "error.required": "This field is required", - "error.load_failed": "Failed to load data" - }, - dashboards: { - sales_activity_dashboard: { - label: "Sales Activity", - description: "Who is talking to customers, how often, and which accounts have gone quiet", - widgets: { - interactions_held: { title: "Interactions Logged", description: "Calls and meetings that actually happened" }, - meetings_booked: { title: "Meetings Booked", description: "Meetings on the calendar that have not happened yet" }, - customer_minutes: { title: "Customer Minutes", description: "Total time spent in front of customers" }, - tasks_completed: { title: "Tasks Completed", description: "Follow-ups closed out \u2014 the other half of activity" }, - activity_by_rep: { title: "Activity by Rep", description: "Logged interactions per owner" }, - activity_by_week: { title: "Activity Volume by Week", description: "Interactions per week" }, - activity_mix: { title: "Activity Mix", description: "Calls vs meetings vs demos" }, - activity_by_record_type: { title: "Where the Activity Lands", description: "Which part of the funnel is getting attention" }, - deal_activity: { title: "Interactions on Deals", description: "Logged interactions linked to an opportunity" }, - open_deals_for_activity: { title: "Open Deals", description: "Opportunities still in play" }, - quiet_accounts_30: { title: "Quiet 30+ Days", description: "Active accounts with no logged interaction in a month" }, - quiet_accounts_60: { title: "Quiet 60+ Days", description: "Two months of silence \u2014 the at-risk threshold" }, - quiet_accounts_90: { title: "Quiet 90+ Days", description: "A quarter with no contact" } - } - }, - crm_overview_dashboard: { - label: "CRM Overview", - description: "Revenue metrics, pipeline analytics, and deal insights", - widgets: { - total_revenue: { title: "Total Revenue", description: "Closed-won revenue this period" }, - active_deals: { title: "Active Deals", description: "Open opportunities in the pipeline" }, - won_deals: { title: "Won Deals", description: "Closed-won deals this period" }, - avg_deal_size: { title: "Avg Deal Size", description: "Average value of closed-won deals" }, - revenue_trends: { title: "Revenue Trends", description: "Closed-won revenue over the last 12 months" }, - lead_source: { title: "Lead Source", description: "Pipeline value by acquisition channel" }, - pipeline_by_stage: { title: "Pipeline by Stage", description: "Open opportunity value at each sales stage" }, - top_products: { title: "Top Products", description: "Total list-price revenue by product category" }, - pipeline_by_owner: { title: "Pipeline by Owner", description: "Open pipeline value and deal count per sales rep" } - } - }, - executive_dashboard: { - label: "Executive Overview", - description: "High-level revenue, customer, and pipeline KPIs for leadership", - widgets: { - total_revenue_ytd: { title: "Total Revenue (YTD)", description: "Closed-won revenue this year" }, - total_accounts: { title: "Active Accounts", description: "Customers with at least one active relationship" }, - total_contacts: { title: "Total Contacts", description: "People in our address book" }, - open_leads: { title: "Open Leads", description: "Unconverted leads in the funnel" }, - revenue_trend: { title: "Revenue Trend", description: "Closed-won revenue over the last 12 months" }, - revenue_by_industry: { title: "Revenue by Industry", description: "YTD closed-won revenue split by customer industry" }, - pipeline_by_stage: { title: "Pipeline by Stage", description: "Open opportunity value at each sales stage" }, - new_accounts_by_month: { title: "New Accounts", description: "Account creation cadence \u2014 last 6 months" }, - accounts_by_industry: { title: "Accounts by Industry", description: "Total annual revenue and account count per industry" } - } - }, - sales_dashboard: { - label: "Sales Performance", - description: "Pipeline analytics, win rate trends, and rep performance", - widgets: { - total_pipeline_value: { title: "Total Pipeline", description: "Sum of open opportunity value" }, - closed_won_qtd: { title: "Closed Won (QTD)", description: "Revenue closed this quarter" }, - open_opportunities: { title: "Open Opportunities", description: "Active deals in flight" }, - avg_deal_size: { title: "Avg Deal Size", description: "Average value of closed-won deals this quarter" }, - pipeline_by_stage: { title: "Pipeline by Stage", description: "Open opportunity value at each sales stage" }, - monthly_revenue_trend: { title: "Monthly Revenue Trend", description: "Closed-won revenue, last 12 months" }, - pipeline_by_forecast_category: { title: "Pipeline by Forecast Category", description: "Open pipeline grouped by sales forecast category" }, - lead_source_breakdown: { title: "Lead Source", description: "Where our pipeline is coming from" }, - open_pipeline_by_owner: { title: "Open Pipeline by Owner", description: "In-flight pipeline value, deal count and avg win probability per rep" }, - quota_attainment_by_rep: { title: "Quota Attainment by Rep", description: "Current-quarter quota, closed revenue and attainment per rep, from forecast snapshots" }, - pipeline_stage_by_source: { title: "Pipeline by Stage \xD7 Lead Source", description: "Cross-tab of open opportunity amount by stage and source" }, - win_rate_12m: { title: "Win Rate (12M)", description: "Deals won as a share of all deals settled in the last 12 months" }, - won_deals_12m: { title: "Deals Won (12M)", description: "The numerator of the win rate" }, - lost_deals_12m: { title: "Deals Lost (12M)", description: "The other half of the win-rate denominator" }, - win_rate_by_owner: { title: "Win / Loss by Rep", description: "Deals won, deals lost and win rate per rep \u2014 last 12 months" }, - win_rate_by_lead_source: { title: "Win / Loss by Lead Source", description: "Which sources produce deals that actually close \u2014 last 12 months" }, - loss_reason_breakdown: { title: "Why We Lose", description: "Lost deals by reason \u2014 last 12 months" } - } - }, - service_dashboard: { - label: "Customer Service", - description: "Case load, SLA health, and resolution performance", - widgets: { - open_cases: { title: "Open Cases", description: "Cases that are not yet closed" }, - critical_cases: { title: "Critical Cases", description: "Open cases marked as critical priority" }, - avg_resolution_time: { title: "Avg Resolution Time", description: "Mean time to close, in hours" }, - sla_violations: { title: "SLA Violations", description: "Cases that breached their SLA" }, - cases_by_status: { title: "Cases by Status", description: "Workload distribution across the pipeline" }, - cases_by_priority: { title: "Cases by Priority", description: "Open case mix by urgency" }, - cases_by_origin: { title: "Cases by Origin", description: "Where our cases are coming from" }, - daily_case_volume: { title: "Daily Case Volume", description: "New cases created over the last 30 days" }, - sla_compliance_gauge: { title: "SLA Compliance", description: "Percent of cases resolved within SLA this period" }, - kb_deflection_rate: { title: "KB Deflection Rate", description: "Share of closed cases resolved with a knowledge article" }, - kb_resolved_cases: { title: "Resolved by KB", description: "Closed cases pointing at the article that resolved them" }, - closed_cases_total: { title: "Closed Cases", description: "The denominator behind the deflection rate" }, - top_resolving_articles: { title: "Top Resolving Articles", description: "Knowledge articles ranked by the closed cases they resolved" }, - my_open_cases_by_priority: { title: "My Open Cases by Priority", description: "Your open cases and their SLA-violation rate, broken down by priority" } - } - } - }, - pages: { - account_detail_page: { - label: "Account Detail", - description: "Slotted account record page \u2014 custom header + persistent discussion feed.", - // Required, though it equals the page source: a missing `title` falls - // back to `label`, and the header then read "Account Detail" instead of - // the account's name (#2042). - title: "{name}", - subtitle: "{industry} \xB7 {type}" - }, - account_workbench: { - label: "Account Workbench", - description: "Curated account list for the sales team: quick filters only, no view management." - }, - app_launcher_page: { - label: "App Launcher", - description: "Central hub for accessing all applications", - subtitle: "Select an app to get started", - components: { - app_search: { label: "Search Apps" }, - app_grid: { label: "Application Grid" } - } - }, - case_detail_page: { - label: "Case Detail", - description: "Service-agent case record: highlights, SLA path, details and activity timeline.", - title: "{case_number} \xB7 {subject}", - subtitle: "{crm_account}", - components: { - case_highlights: { label: "Key Information" }, - case_status_path: { label: "Case Status Path" } - } - }, - lead_detail_page: { - label: "Lead Detail", - description: "Comprehensive lead detail page with highlights, details, and related information", - title: "{first_name} {last_name}", - subtitle: "{company}", - components: { - lead_duplicate_alert_confirmed: { label: "Confirmed Duplicate Alert" }, - lead_duplicate_alert_suspected: { label: "Suspected Duplicate Alert" }, - lead_highlights: { label: "Key Information" }, - lead_path: { label: "Lead Status Path" }, - main_tabs: { label: "Lead Information Tabs" } - } - }, - opportunity_detail_page: { - label: "Opportunity Detail", - description: "Comprehensive opportunity detail page with path, highlights, details, and related lists", - title: "{name}", - subtitle: "{crm_account}", - components: { - opp_highlights: { label: "Key Information" }, - opp_stage_path: { label: "Opportunity Stage Path" } - } - }, - sales_home_page: { - label: "Sales Home", - description: "Sales team home page with key metrics and quick actions", - title: "Sales Dashboard", - subtitle: "Welcome back", - components: { - quick_create: { title: "Quick Create", label: "Quick Create" }, - key_metrics: { title: "Key Performance Indicators", label: "Key Metrics" }, - home_tabs: { label: "Home Tabs" }, - ai_briefing: { - title: "Ask the AI Assistant", - label: "Today with the AI Assistant" - }, - upcoming_events: { title: "Upcoming Events", label: "Upcoming Events" } - } - }, - utility_bar_page: { - label: "Utility Bar", - description: "Quick access utility bar with floating tools", - components: { - notifications_panel: { label: "Notifications" }, - quick_notes: { title: "Quick Notes", label: "Quick Notes" }, - quick_search: { label: "Quick Search" } - } - } - } -}; - -// src/sales/translations/en/_shared.ts -var activityActions = { - log_call: { - label: "Log a Call", - successMessage: "Call logged successfully!", - params: { - subject: { label: "Call Subject" }, - duration: { label: "Duration (minutes)" }, - attendee_contacts: { label: "Contact Attendees" }, - attendee_users: { label: "Internal Attendees" }, - notes: { label: "Call Notes" } - } - }, - log_meeting: { - label: "Log a Meeting", - successMessage: "Meeting logged successfully!", - params: { - subject: { label: "Meeting Subject" }, - duration: { label: "Duration (minutes)" }, - attendee_contacts: { label: "Contact Attendees" }, - attendee_users: { label: "Internal Attendees" }, - notes: { label: "Meeting Notes" } - } - }, - schedule_meeting: { - label: "Schedule a Meeting", - successMessage: "Meeting scheduled!", - params: { - subject: { label: "Meeting Subject" }, - start_date: { label: "Start Date (UTC)" }, - start_time: { label: "Start Time (UTC)" }, - location: { label: "Location" }, - duration: { label: "Duration (minutes)" }, - attendee_contacts: { label: "Contact Attendees" }, - attendee_users: { label: "Internal Attendees" }, - notes: { label: "Agenda" } - } - } -}; - -// src/sales/translations/en/objects.customer.ts -var customer = { - crm_account: { - label: "Account", - pluralLabel: "Accounts", - fields: { - account_number: { label: "Account Number" }, - registration_number: { - label: "Registration Number", - help: "The counterparty's registered identity as issued by its own government registry. Not the Account Number, which we issue." - }, - commercial_capability: { - label: "Commercial Capability", - help: "Whether new business may be opened against this account. Settlement Only accounts stay usable for billing and payment, but no new opportunity may be linked to them.", - options: { full: "Full", settlement_only: "Settlement Only" } - }, - incumbent_vendor: { label: "Incumbent Vendor", help: "The supplier currently holding this account for the spend we are chasing." }, - annual_purchasing_budget: { label: "Annual Purchasing Budget", help: "What this account expects to spend with vendors this year \u2014 not its own revenue." }, - payment_cycle: { - label: "Payment Cycle", - options: { prepaid: "Prepaid", net_30: "Net 30", net_60: "Net 60", net_90: "Net 90" } - }, - approval_status: { - label: "Approval Status", - help: "Where this account stands in its sign-off. A new account starts Pending and is decided in the approval inbox.", - options: { pending: "Pending", approved: "Approved", rejected: "Rejected" } - }, - name: { label: "Account Name", help: "Legal name of the company or organization" }, - type: { - label: "Type", - options: { prospect: "Prospect", customer: "Customer", partner: "Partner", former: "Former Customer" } - }, - industry: { - label: "Industry", - options: { - technology: "Technology", - software: "Software / SaaS", - finance: "Finance", - healthcare: "Healthcare", - retail: "Retail", - manufacturing: "Manufacturing", - education: "Education", - real_estate: "Real Estate", - media: "Media & Entertainment", - logistics: "Logistics", - hospitality: "Hospitality", - energy: "Energy & Utilities", - government: "Government", - nonprofit: "Non-profit", - other: "Other" - } - }, - annual_revenue: { label: "Annual Revenue" }, - child_account_revenue: { label: "Child Account Revenue", help: "Sum of the annual revenue of the direct children of this account." }, - number_of_employees: { label: "Number of Employees" }, - phone: { label: "Phone" }, - website: { label: "Website" }, - billing_address: { label: "Billing Address" }, - billing_country: { - label: "Billing Country", - help: "Derived from Billing Address \u2014 the country exactly as entered, trimmed and upper-cased." - }, - territory: { - label: "Territory", - help: "Derived from Billing Address \u2014 the sales territory the sharing rules match on. Accounts outside the staffed territories are Other.", - options: { na: "North America", emea: "EMEA", other: "Other" } - }, - office_location: { label: "Office Location" }, - owner_id: { label: "Account Owner" }, - parent_account: { label: "Parent Account", help: "Parent company in hierarchy" }, - description: { label: "Description" }, - is_active: { label: "Active" }, - last_activity_date: { label: "Last Activity Date" }, - brand_color: { label: "Brand Color" }, - logo: { label: "Company Logo" }, - tier: { - label: "Customer Tier", - options: { strategic: "Strategic", enterprise: "Enterprise", mid_market: "Mid-Market", smb: "SMB" } - }, - segment: { - label: "Segment", - options: { net_new: "Net New", growth: "Growth", at_risk: "At Risk", stable: "Stable" } - }, - health_score: { - label: "Health Score", - help: "CSM-maintained health indicator", - options: { healthy: "Healthy", watching: "Watching", at_risk: "At Risk", churning: "Churning" } - }, - name_normalized: { - label: "Account Name (Normalized)", - help: "Match key for lead conversion: Account Name lower-cased, trimmed, with internal whitespace collapsed. Maintained by the account_protection hook \u2014 never edit directly." - }, - display_title: { label: "Display Title" } - }, - _views: { - all_accounts: { label: "All Accounts", description: "Primary account list with revenue & industry summaries" }, - account_gallery: { label: "Account Cards", description: "Branded account cards with brand-color highlights" }, - account_map: { label: "Accounts by Location", description: "Geospatial distribution of accounts" }, - enterprise_accounts: { label: "Enterprise Accounts", description: "Accounts with the highest annual revenue" }, - my_accounts: { label: "My Accounts", description: "Accounts owned by the current user" }, - at_risk_accounts: { label: "\u26A0\uFE0F At-Risk Accounts" } - }, - _sections: { - basic: { label: "Basic Information" }, - financials: { label: "Financials" }, - business_profile: { label: "Business Profile" }, - contact_info: { label: "Contact Information" }, - ownership: { label: "Ownership & Status" }, - branding: { label: "Branding" }, - system: { label: "System" }, - // Form section names on account.view.ts (#1100) - profile: { label: "Profile" }, - customer_success: { label: "Customer Success" }, - locations: { label: "Locations" }, - description: { label: "Description" } - }, - _actions: { ...activityActions } - }, - crm_contact: { - label: "Contact", - pluralLabel: "Contacts", - fields: { - salutation: { - label: "Salutation", - options: { mr: "Mr.", ms: "Ms.", mrs: "Mrs.", dr: "Dr.", prof: "Prof." } - }, - first_name: { label: "First Name" }, - last_name: { label: "Last Name" }, - full_name: { label: "Full Name" }, - crm_account: { label: "Account" }, - email: { label: "Email" }, - phone: { label: "Phone" }, - mobile: { label: "Mobile" }, - title: { label: "Title" }, - department: { - label: "Department", - options: { - executive: "Executive", - sales: "Sales", - marketing: "Marketing", - engineering: "Engineering", - support: "Support", - finance: "Finance", - hr: "Human Resources", - operations: "Operations" - } - }, - // Buying centre (REQ-0004) — the decision map. English is the source - // wording for the option VALUES; every other pack translates these. - buying_function: { - label: "Buying Function", - options: { - decision_maker: "Decision Maker", - economic_buyer: "Economic Buyer", - technical_evaluator: "Technical Evaluator", - user: "User", - influencer: "Influencer", - gatekeeper: "Gatekeeper" - } - }, - attitude: { - label: "Attitude to Us", - options: { - champion: "Champion", - supportive: "Supportive", - neutral: "Neutral", - skeptical: "Skeptical", - blocker: "Blocker" - } - }, - relationship_strength: { - label: "Relationship Strength", - options: { - distant: "Distant", - acquaintance: "Acquaintance", - working: "Working Relationship", - strong: "Strong", - trusted_advisor: "Trusted Advisor" - } - }, - owner_id: { label: "Contact Owner" }, - description: { label: "Description" }, - is_primary: { label: "Primary Contact", help: "Is this the main contact for the account?" }, - avatar: { label: "Profile Picture" }, - mailing_address: { label: "Mailing Address" }, - lead_source: { - label: "Lead Source", - options: { - web: "Web", - referral: "Referral", - event: "Event / Trade Show", - webinar: "Webinar", - partner: "Partner", - advertisement: "Advertisement", - paid_search: "Paid Search", - social: "Social Media", - content: "Content / Blog", - cold_call: "Cold Call", - email_campaign: "Email Campaign", - other: "Other" - } - }, - do_not_call: { label: "Do Not Call" }, - email_opt_out: { label: "Email Opt Out" }, - last_contacted_date: { label: "Last Contacted" } - }, - _views: { - all_contacts: { label: "All Contacts" }, - contact_directory: { label: "People Directory" }, - primary_contacts: { label: "Primary Contacts" } - }, - _sections: { - identity: { label: "Identity" }, - account_info: { label: "Account & Title" }, - buying_centre: { label: "Buying Centre" }, - contact_info: { label: "Contact Information" }, - mailing_address: { label: "Mailing Address" }, - additional: { label: "Additional Info" }, - preferences: { label: "Communication Preferences" }, - // Form section names on contact.view.ts (#1100). `contact_details` / - // `comm_preferences`, not `contact_info` / `preferences` — those are - // already fieldGroup keys with their own (longer) wording above. - contact_details: { label: "Contact Info" }, - comm_preferences: { label: "Preferences" } - }, - _actions: { - ...activityActions, - mark_primary: { - label: "Mark as Primary Contact", - confirmText: "Mark this contact as the primary contact for the account?", - successMessage: "Contact marked as primary!" - }, - send_email: { - label: "Send Email", - params: { - subject: { label: "Subject" }, - body: { label: "Body" } - } - }, - add_contact_to_campaign: { - label: "Add to Campaign", - successMessage: "Contacts added to campaign!", - params: { - crm_campaign: { label: "Campaign" } - } - } - } - } -}; - -// src/sales/translations/en/objects.pipeline.ts -var pipeline = { - crm_lead: { - label: "Lead", - pluralLabel: "Leads", - fields: { - first_name: { label: "First Name" }, - last_name: { label: "Last Name" }, - company: { label: "Company" }, - title: { label: "Title" }, - email: { label: "Email" }, - phone: { label: "Phone" }, - status: { - label: "Status", - options: { - new: "New", - contacted: "Contacted", - qualified: "Qualified", - unqualified: "Unqualified", - converted: "Converted" - } - }, - lead_source: { - label: "Lead Source", - options: { - web: "Web", - referral: "Referral", - event: "Event / Trade Show", - webinar: "Webinar", - partner: "Partner", - advertisement: "Advertisement", - paid_search: "Paid Search", - social: "Social Media", - content: "Content / Blog", - cold_call: "Cold Call", - email_campaign: "Email Campaign", - other: "Other" - } - }, - owner_id: { label: "Lead Owner" }, - is_converted: { label: "Converted" }, - description: { label: "Description" }, - salutation: { - label: "Salutation", - options: { mr: "Mr.", ms: "Ms.", mrs: "Mrs.", dr: "Dr.", prof: "Prof." } - }, - full_name: { label: "Full Name" }, - industry: { - label: "Industry", - options: { - technology: "Technology", - software: "Software / SaaS", - finance: "Finance", - healthcare: "Healthcare", - retail: "Retail", - manufacturing: "Manufacturing", - education: "Education", - real_estate: "Real Estate", - media: "Media & Entertainment", - logistics: "Logistics", - hospitality: "Hospitality", - energy: "Energy & Utilities", - government: "Government", - nonprofit: "Non-profit", - other: "Other" - } - }, - mobile: { label: "Mobile" }, - website: { label: "Website" }, - rating: { label: "Lead Score", help: "Lead quality score (1-5 stars)" }, - converted_account: { label: "Converted Account" }, - converted_contact: { label: "Converted Contact" }, - converted_opportunity: { label: "Converted Opportunity" }, - converted_date: { label: "Converted Date" }, - address: { label: "Address" }, - annual_revenue: { label: "Annual Revenue" }, - number_of_employees: { label: "Number of Employees" }, - notes: { label: "Notes", help: "Working notes on this lead \u2014 supports formatting." }, - do_not_call: { label: "Do Not Call" }, - email_opt_out: { label: "Email Opt Out" }, - disqualification_reason: { - label: "Disqualification Reason", - help: "Required when status is Unqualified", - options: { - not_a_fit: "Not a Fit", - no_budget: "No Budget", - wrong_persona: "Wrong Persona", - unreachable: "Unreachable", - duplicate: "Duplicate", - competitor: "Competitor", - other: "Other" - } - }, - duplicate_of_type: { - label: "Duplicate Of", - help: "Which object holds the surviving record this lead repeats.", - // `erased` is a tombstone, not a choice: the form does not offer it - // (see `src/sales/views/lead.view.ts`), but a lead whose survivor was - // deleted carries it, so it needs a label wherever the record is - // READ — detail page, list column, export. Untranslated it would - // render as the raw `erased`. - options: { crm_lead: "Lead", crm_contact: "Contact", erased: "Erased Record" } - }, - duplicate_of_lead: { label: "Duplicate Of Lead" }, - duplicate_of_contact: { label: "Duplicate Of Contact" }, - duplicate_status: { - label: "Duplicate Status", - help: "Suspected = flagged automatically at intake. Confirmed = a human verified the match.", - options: { suspected: "Suspected", confirmed: "Confirmed" } - }, - display_title: { label: "Display Title" }, - company_normalized: { - label: "Company (Normalized)", - help: "Match key for lead conversion: Company lower-cased, trimmed, with internal whitespace collapsed. Maintained by the lead_duplicate_check hook \u2014 never edit directly." - }, - next_followup_date: { label: "Next Follow-up Date" }, - last_contacted_date: { label: "Last Contacted" }, - need_type: { - label: "Need Type", - help: "What this prospect is asking for. Routing, prioritisation and demand reporting read this.", - options: { - new_implementation: "New Implementation", - expansion: "Expansion", - replacement: "Replacement", - renewal: "Renewal", - consulting: "Consulting", - support: "Support & Maintenance", - other: "Other" - } - }, - estimated_amount: { - label: "Estimated Amount", - help: "Estimated value of this demand, before qualification. Prefills the deal amount at conversion." - }, - conversion_approval_status: { - label: "Conversion Approval", - help: "Whether this lead has been signed off for conversion. Not Required means no approval is asked for \u2014 the shipped default.", - options: { - not_required: "Not Required", - pending: "Pending", - approved: "Approved", - rejected: "Rejected" - } - } - }, - _views: { - all_leads: { - label: "All Leads", - emptyState: { title: "No Leads Yet", message: "Get started by creating your first lead" } - }, - kanban_by_status: { label: "Lead Pipeline" }, - calendar_by_created: { label: "Lead Calendar" }, - gallery_view: { label: "Lead Cards" }, - my_leads: { label: "My Leads" }, - high_priority: { label: "High Priority" }, - hot_leads: { label: "\u{1F525} Hot Leads" }, - suspected_duplicates: { - label: "Suspected Duplicates", - emptyState: { - title: "No Suspected Duplicates", - message: "Nothing to review \u2014 every re-captured email has been checked." - } - } - }, - _sections: { - identity: { label: "Identity" }, - company_info: { label: "Company Information" }, - contact_info: { label: "Contact Information" }, - qualification: { label: "Qualification" }, - assignment: { label: "Assignment" }, - address: { label: "Address" }, - additional: { label: "Additional Info" }, - preferences: { label: "Communication Preferences" }, - conversion: { label: "Conversion" }, - duplicates: { label: "Duplicate Management" }, - // The detail page's sections reference the groups above (#806), so it - // has no section names of its own. - // Form section names on lead.view.ts (#1100). The sections of the - // default form and of every named formView live here — add a form - // there, add its section names here. `address` / `qualification` above - // are reused (identical fieldGroup wording); every other name here is new. - contact_information: { label: "Contact Information" }, - lead_classification: { label: "Lead Classification" }, - company_information: { label: "Company Information" }, - additional_information: { label: "Additional Information" }, - privacy: { label: "Privacy" }, - general: { label: "General" }, - details: { label: "Details" }, - step_1_contact_details: { label: "Step 1: Contact Details" }, - step_2_company_information: { label: "Step 2: Company Information" }, - step_3_qualification: { label: "Step 3: Qualification" }, - step_4_review_and_convert: { label: "Step 4: Review & Convert" }, - primary_information: { label: "Primary Information" }, - extended_details: { label: "Extended Details" }, - quick_edit: { label: "Quick Edit" }, - update_lead_status: { label: "Update Lead Status" }, - tell_us_about_yourself: { label: "Tell us about yourself" }, - about_your_company: { label: "About your company" }, - how_can_we_help: { label: "How can we help?" }, - lead_information: { label: "Lead Information" }, - address_information: { label: "Address Information" }, - privacy_preferences: { label: "Privacy Preferences" } - }, - _actions: { - ...activityActions, - convert_lead: { - label: "Convert Lead", - successMessage: "Lead converted successfully!" - }, - create_campaign: { - label: "Add to Campaign", - successMessage: "Leads added to campaign!", - params: { - crm_campaign: { label: "Campaign" } - } - }, - schedule_followup: { - label: "Schedule Follow-up", - successMessage: "Follow-up scheduled." - } - } - }, - crm_opportunity: { - label: "Opportunity", - pluralLabel: "Opportunities", - fields: { - name: { label: "Opportunity Name" }, - crm_account: { label: "Account" }, - primary_contact: { label: "Primary Contact" }, - owner_id: { label: "Opportunity Owner" }, - amount: { label: "Amount" }, - expected_revenue: { label: "Expected Revenue" }, - stage: { - label: "Stage", - options: { - prospecting: "Prospecting", - qualification: "Qualification", - needs_analysis: "Needs Analysis", - proposal: "Proposal", - negotiation: "Negotiation", - closed_won: "Closed Won", - closed_lost: "Closed Lost" - } - }, - probability: { label: "Probability (%)" }, - close_date: { label: "Close Date" }, - type: { - label: "Type", - options: { - new_business: "New Business", - existing_upgrade: "Existing Customer - Upgrade", - existing_renewal: "Existing Customer - Renewal", - existing_expansion: "Existing Customer - Expansion" - } - }, - forecast_category: { - label: "Forecast Category", - options: { - pipeline: "Pipeline", - best_case: "Best Case", - commit: "Commit", - omitted: "Omitted", - closed: "Closed" - } - }, - description: { label: "Description" }, - next_step: { label: "Next Step" }, - lead_source: { - label: "Lead Source", - options: { - web: "Web", - referral: "Referral", - event: "Event / Trade Show", - webinar: "Webinar", - partner: "Partner", - advertisement: "Advertisement", - paid_search: "Paid Search", - social: "Social Media", - content: "Content / Blog", - cold_call: "Cold Call", - email_campaign: "Email Campaign", - other: "Other" - } - }, - crm_campaign: { label: "Campaign", help: "Marketing campaign that generated this opportunity" }, - days_in_stage: { label: "Days in Current Stage" }, - stage_entry_date: { - label: "Stage Entry Date", - help: "Date this opportunity entered its current stage." - }, - is_private: { label: "Private" }, - approval_status: { - label: "Approval Status", - options: { not_required: "Not Required", pending: "Pending", approved: "Approved", rejected: "Rejected" } - }, - approved_date: { label: "Approved Date" }, - win_reason: { - label: "Win Reason", - help: "Why this deal was won. Required to close an opportunity as Won.", - options: { - better_product: "Better Product", - better_price: "Better Price", - relationship: "Existing Relationship", - better_support: "Better Support", - best_fit: "Best Fit / Features", - quote_accepted: "Quote Accepted", - other: "Other" - } - }, - loss_reason: { - label: "Loss Reason", - help: "Why this deal was lost. Required to close an opportunity as Lost.", - options: { - price: "Price Too High", - competitor: "Lost to Competitor", - no_budget: "No Budget", - no_decision: "No Decision", - timing: "Bad Timing", - features: "Missing Features", - other: "Other" - } - }, - loss_details: { - label: "Loss/Win Details", - help: "Free-text context behind the win or loss reason." - }, - // REQ-0006 — qualification, the customer's procurement calendar, the - // deal narrative, the business line and the status-change gate. - will_bid: { - label: "Will Bid", - help: "Whether we intend to bid. Unset means the decision is open." - }, - controllability: { label: "Controllability", options: { high: "High", medium: "Medium", low: "Low" } }, - priority: { label: "Priority", options: { high: "High", medium: "Medium", low: "Low" } }, - deal_level: { label: "Deal Level", options: { strategic: "Strategic", key: "Key", standard: "Standard" } }, - is_subcontracted: { label: "Involves Subcontracting" }, - subcontracting_note: { label: "Subcontracting Note" }, - customer_initiation_date: { label: "Customer Initiation Date" }, - expected_tender_date: { label: "Expected Tender Date" }, - expected_signing_date: { label: "Expected Signing Date" }, - expected_tender_amount: { label: "Expected Tender Amount" }, - expected_signing_amount: { label: "Expected Signing Amount" }, - business_line: { - label: "Business Line", - options: { - product: "Product", - services: "Professional Services", - consulting: "Consulting", - support: "Support & Maintenance", - other: "Other" - } - }, - customer_background: { label: "Customer Background" }, - project_background: { label: "Project Background" }, - risk_analysis: { label: "Risk Analysis" }, - payment_terms: { label: "Payment Terms" }, - requested_status: { label: "Requested Status", options: { closed_won: "Won", closed_lost: "Lost" } }, - status_change_approval_status: { - label: "Status Change Approval", - options: { not_required: "Not Required", pending: "Pending", approved: "Approved", rejected: "Rejected" } - }, - // REQ-0006 step 11 — the 立项 (qualification) approval gate. - qualification_requested: { - label: "Request Qualification Approval", - help: "Tick to send this deal for qualification approval. A rejection clears it; tick it again to ask again." - }, - qualification_approval_status: { - label: "Qualification Approval", - options: { not_required: "Not Required", pending: "Pending", approved: "Approved", rejected: "Rejected" } - } - }, - _views: { - tender_this_quarter: { - label: "Tender This Quarter", - emptyState: { - title: "No Tenders Expected This Quarter", - message: "This tab lists open deals whose customer-side tender date falls inside the current quarter. Record Expected Tender Date on a deal to see it here." - } - }, - open_opportunities: { label: "Open Deals" }, - all_opportunities: { label: "All Opportunities" }, - pipeline_kanban: { label: "Sales Pipeline" }, - close_date_calendar: { label: "Forecast Calendar" }, - deal_timeline: { label: "Deal Timeline" }, - deal_gallery: { label: "Deal Cards" }, - my_open_deals: { label: "My Open Deals" }, - stale_opportunities: { label: "\u26A0\uFE0F Stale Opportunities \xB7 Longest in Stage First" }, - closing_this_quarter: { - label: "Closing This Quarter", - emptyState: { - title: "No Deals Closing This Quarter", - message: "This tab lists open commit and best-case deals with a close date inside the current quarter. Nothing matches right now \u2014 deals closing later are on the Open Deals tab." - } - } - }, - _sections: { - basic: { label: "Basic Information" }, - financials: { label: "Financials" }, - sales_process: { label: "Sales Process" }, - classification: { label: "Classification" }, - campaign: { label: "Campaigns" }, - notes: { label: "Notes & Next Steps" }, - qualification: { label: "Qualification" }, - narrative: { label: "Deal Narrative" }, - crm_forecast: { label: "Forecast & Metrics" }, - // The detail page's sections reference the groups above (#1452), so it - // has no section names of its own. - // Form section names on opportunity.view.ts (#1100) - overview: { label: "Overview" }, - forecast: { label: "Forecast" }, - sales_strategy: { label: "Sales Strategy" }, - win_loss: { label: "Win / Loss" } - }, - _actions: { - ...activityActions, - clone_opportunity: { - label: "Clone Opportunity", - successMessage: "Opportunity cloned successfully!" - }, - mass_update_stage: { - label: "Update Stage", - successMessage: "Opportunities updated successfully!", - params: { - stage: { label: "New Stage" } - } - }, - generate_quote: { - label: "Generate Quote", - successMessage: "Quote created from opportunity!" - } - } - }, - crm_opportunity_line_item: { - label: "Opportunity Line Item", - pluralLabel: "Opportunity Line Items", - description: "Per-product pricing lines under an opportunity", - fields: { - crm_opportunity: { label: "Opportunity" }, - crm_product: { label: "Product" }, - description: { label: "Description" }, - quantity: { label: "Quantity" }, - list_price: { label: "List Price", help: "Auto-populated from the product's List Price." }, - unit_price: { - label: "Sales Price", - help: "Negotiated unit price (may differ from list price)" - }, - discount: { label: "Discount %" }, - total_price: { label: "Total" }, - line_number: { label: "Line #" } - }, - _sections: { - basic: { label: "Line Item" }, - pricing: { label: "Pricing" } - } - }, - crm_forecast: { - label: "Forecast", - pluralLabel: "Forecasts", - description: "Periodic pipeline snapshot by owner used for revenue forecasting", - fields: { - owner_id: { label: "Owner" }, - period: { label: "Period", options: { month: "Month", quarter: "Quarter" } }, - period_start: { - label: "Period Start", - help: "Must be the first day of the period \u2014 e.g. 2026-08-01 for Aug 2026. A quarterly forecast must additionally start on a quarter boundary: January 1, April 1, July 1 or October 1." - }, - period_end: { - label: "Period End", - help: "Normally derived automatically from Period and Period Start. If set by hand, it must be the last day of that period \u2014 e.g. 2026-09-30 for a quarter starting 2026-07-01, or 2026-08-31 for Aug 2026." - }, - period_label: { label: "Period", help: 'Human-friendly label, e.g. "Q3 2026" or "Aug 2026".' }, - snapshot_date: { label: "Snapshot Date", help: "The day this snapshot was captured." }, - source: { - label: "Source", - options: { scheduled: "Scheduled snapshot", ai: "AI skill", manual: "Manual entry" } - }, - quota: { label: "Quota" }, - pipeline_amount: { - label: "Pipeline", - help: "Sum of all open opportunities closing in this period (any stage)." - }, - best_case_amount: { - label: "Best Case", - help: "Open opportunities in the Best Case or Commit forecast category." - }, - commit_amount: { - label: "Commit", - help: "Open opportunities in the Commit forecast category (owner-committed)." - }, - closed_amount: { label: "Closed Won", help: "Already-closed-won amount in this period." }, - expected_amount: { - label: "Expected", - help: "Closed Won + Commit \u2014 what the owner reasonably expects to land." - }, - attainment_pct: { label: "Attainment %", help: "Closed Won \xF7 Quota \xD7 100. Reads 0% until a positive quota is set." }, - coverage_ratio: { - label: "Coverage", - help: "Pipeline \xF7 (Quota \u2212 Closed Won) \u2014 whether enough pipeline remains to cover the gap. Reads 0 once the quota is already met." - }, - notes: { label: "Notes" }, - display_title: { label: "Display Title" }, - seed_key: { - label: "Seed Key", - help: "Demo-fixture identity. Written only by the seed loader; empty on every real snapshot." - } - }, - _views: { - all_forecasts: { label: "All Forecasts" }, - this_quarter_forecasts: { - label: "This Quarter", - emptyState: { - title: "This Quarter Has No Snapshots Yet", - message: "Quarterly snapshots are written by the nightly forecast sweep. Until it has run once for the current quarter this view is empty \u2014 settled quarters are on the All tab." - } - }, - my_forecast: { label: "My Forecast" } - }, - _sections: { - basic: { label: "Snapshot" }, - amounts: { label: "Amounts" }, - meta: { label: "Source" }, - // Form section names on forecast.view.ts (#1100). `basic`'s label - // matches "Snapshot" but its key does not, so this form section - // needs its own entry; `notes` has no fieldGroup counterpart at all. - snapshot: { label: "Snapshot" }, - notes: { label: "Notes" } - } - } -}; - -// src/sales/translations/en/objects.commerce.ts -var commerce = { - crm_quote: { - label: "Quote", - pluralLabel: "Quotes", - fields: { - quote_number: { label: "Quote Number" }, - name: { label: "Quote Name" }, - crm_account: { label: "Account" }, - crm_contact: { - label: "Contact", - help: "Required once the quote is Presented or Accepted \u2014 the drafted contract takes its Primary Contact from here." - }, - crm_opportunity: { label: "Opportunity" }, - owner_id: { label: "Quote Owner" }, - status: { - label: "Status", - options: { - draft: "Draft", - in_review: "In Review", - presented: "Presented", - accepted: "Accepted", - rejected: "Rejected", - expired: "Expired" - } - }, - quote_date: { label: "Quote Date" }, - expiration_date: { label: "Expiration Date" }, - subtotal: { label: "Subtotal" }, - discount: { label: "Discount %" }, - discount_amount: { label: "Discount Amount" }, - tax: { label: "Tax" }, - shipping_handling: { label: "Shipping & Handling" }, - total_price: { label: "Total Price" }, - payment_terms: { - label: "Payment Terms", - options: { - net_15: "Net 15", - net_30: "Net 30", - net_60: "Net 60", - net_90: "Net 90", - due_on_receipt: "Due on Receipt" - } - }, - shipping_terms: { label: "Shipping Terms" }, - billing_address: { label: "Billing Address" }, - shipping_address: { label: "Shipping Address" }, - description: { label: "Description" }, - internal_notes: { label: "Internal Notes" }, - display_title: { label: "Display Title" } - }, - _views: { - all_quotes: { label: "All Quotes" }, - quote_pipeline: { label: "Quote Pipeline" }, - quote_calendar: { label: "Quote Calendar" } - }, - _sections: { - basic: { label: "Quote Information" }, - pricing: { label: "Pricing" }, - terms: { label: "Terms & Validity" }, - address: { label: "Addresses" }, - system: { label: "System" }, - // Form section names on quote.view.ts (#1100). `quote_terms`, not - // `terms` — `terms` is already the fieldGroup key for "Terms & Validity". - quote: { label: "Quote" }, - totals: { label: "Totals" }, - quote_terms: { label: "Terms" }, - addresses_and_notes: { label: "Addresses & Notes" } - } - }, - crm_quote_line_item: { - label: "Quote Line Item", - pluralLabel: "Quote Line Items", - description: "Per-product pricing lines under a quote", - fields: { - crm_quote: { label: "Quote" }, - crm_product: { label: "Product" }, - description: { label: "Description" }, - quantity: { label: "Quantity" }, - list_price: { label: "List Price" }, - unit_price: { label: "Sales Price" }, - discount: { label: "Discount %" }, - subtotal: { label: "Subtotal" }, - total_price: { label: "Total" }, - line_number: { label: "Line #" } - }, - _sections: { - basic: { label: "Line Item" }, - pricing: { label: "Pricing" } - } - }, - crm_contract: { - label: "Contract", - pluralLabel: "Contracts", - fields: { - contract_number: { label: "Contract Number" }, - crm_account: { label: "Account" }, - crm_contact: { label: "Primary Contact" }, - crm_opportunity: { label: "Related Opportunity" }, - owner_id: { label: "Contract Owner" }, - status: { - label: "Status", - options: { - draft: "Draft", - in_approval: "In Approval", - activated: "Activated", - expired: "Expired", - terminated: "Terminated" - } - }, - contract_term_months: { label: "Contract Term (Months)" }, - start_date: { label: "Start Date" }, - end_date: { label: "End Date" }, - contract_value: { label: "Contract Value" }, - billing_frequency: { - label: "Billing Frequency", - options: { - monthly: "Monthly", - quarterly: "Quarterly", - annually: "Annually", - one_time: "One-time" - } - }, - payment_terms: { - label: "Payment Terms", - options: { - net_15: "Net 15", - net_30: "Net 30", - net_60: "Net 60", - net_90: "Net 90", - due_on_receipt: "Due on Receipt" - } - }, - auto_renewal: { label: "Auto Renewal" }, - renewal_notice_days: { label: "Renewal Notice (Days)" }, - contract_type: { - label: "Contract Type", - options: { - subscription: "Subscription", - service: "Service Agreement", - license: "License", - partnership: "Partnership", - nda: "NDA", - msa: "MSA" - } - }, - signed_date: { label: "Signed Date" }, - signed_by: { label: "Signed By" }, - document_url: { label: "Contract Document" }, - special_terms: { label: "Special Terms" }, - description: { label: "Description" }, - billing_address: { label: "Billing Address" } - }, - _views: { - all_contracts: { label: "All Contracts" }, - renewal_calendar: { label: "Renewal Calendar" }, - contract_gantt: { label: "Contract Terms" }, - contract_timeline: { label: "Contract Timeline" } - }, - _sections: { - basic: { label: "Contract Information" }, - parties: { label: "Parties" }, - terms: { label: "Terms & Dates" }, - value: { label: "Contract Value" }, - status: { label: "Status & Approval" }, - renewal: { label: "Renewal" }, - // Form section names on contract.view.ts (#1100). `contract_terms`, - // not `terms` — `terms` is already the fieldGroup key for "Terms & Dates". - contract_terms: { label: "Terms" }, - signing_and_documents: { label: "Signing & Documents" }, - notes: { label: "Notes" } - } - }, - crm_product: { - label: "Product", - pluralLabel: "Products", - fields: { - product_code: { label: "Product Code" }, - name: { label: "Product Name" }, - description: { label: "Description" }, - category: { - label: "Category", - options: { - software: "Software", - hardware: "Hardware", - service: "Service", - subscription: "Subscription", - support: "Support" - } - }, - family: { - label: "Product Family", - options: { - enterprise: "Enterprise Solutions", - smb: "SMB Solutions", - services: "Professional Services", - cloud: "Cloud Services" - } - }, - list_price: { label: "List Price" }, - cost: { label: "Cost" }, - sku: { label: "SKU" }, - is_active: { label: "Active" }, - product_manager: { label: "Product Manager" }, - image: { label: "Product Image" }, - datasheet: { label: "Datasheet" }, - display_title: { label: "Display Title" } - }, - _views: { - all_products: { label: "All Products" }, - product_catalog: { label: "Product Catalog" } - }, - _sections: { - basic: { label: "Product Information" }, - pricing: { label: "Pricing" }, - metadata: { label: "Resources" }, - // Form section names on product.view.ts (#1100) - product_info: { label: "Product Info" }, - pricing_info: { label: "Pricing" }, - media: { label: "Media" } - } - } -}; - -// src/sales/translations/en/objects.service.ts -var service = { - crm_case: { - label: "Case", - pluralLabel: "Cases", - fields: { - case_number: { label: "Case Number" }, - subject: { label: "Subject" }, - description: { label: "Description" }, - crm_account: { label: "Account" }, - crm_contact: { label: "Contact" }, - status: { - label: "Status", - options: { - new: "New", - in_progress: "In Progress", - waiting_customer: "Waiting on Customer", - waiting_support: "Waiting on Support", - escalated: "Escalated", - resolved: "Resolved", - closed: "Closed" - } - }, - priority: { - label: "Priority", - options: { low: "Low", medium: "Medium", high: "High", critical: "Critical" } - }, - type: { - label: "Case Type", - options: { - question: "Question", - problem: "Problem", - feature_request: "Feature Request", - bug: "Bug" - } - }, - origin: { - label: "Case Origin", - options: { email: "Email", phone: "Phone", web: "Web", chat: "Chat", social_media: "Social Media" } - }, - owner_id: { label: "Case Owner" }, - closed_date: { label: "Closed Date" }, - first_response_date: { label: "First Response Date" }, - resolution_time_hours: { label: "Resolution Time (Hours)" }, - sla_due_date: { label: "SLA Due Date", help: "Set from the case priority and the account\u2019s Customer Tier, in calendar hours: nights, weekends and holidays count." }, - is_sla_violated: { label: "SLA Violated" }, - is_escalated: { label: "Escalated" }, - escalation_reason: { label: "Escalation Reason" }, - resolution: { label: "Resolution" }, - resolved_by_article: { label: "Resolved by Article", help: "Knowledge article that resolved this case \u2014 the deflection signal." }, - internal_notes: { label: "Internal Notes", help: "Internal notes; not visible to the customer." }, - is_closed: { label: "Is Closed" }, - display_title: { label: "Display Title" }, - priority_rank: { label: "Priority Rank" }, - escalated_date: { label: "Escalated Date" } - }, - _views: { - all_cases: { label: "All Cases" }, - case_workflow: { label: "Service Workflow" }, - sla_calendar: { label: "SLA Calendar" }, - case_timeline: { label: "Case Timeline" }, - unassigned_triage: { - label: "Unassigned \u2014 triage", - emptyState: { - title: "Nothing waiting for triage", - message: "Every case has an owner. Cases appear here when they arrive with no owner \u2014 typically a web-to-case submission that arrived while nobody held the Service Agent position." - } - }, - escalated_cases: { label: "Escalated Cases" }, - my_open_cases: { label: "My Open Cases" }, - sla_at_risk: { label: "\u23F0 SLA at Risk" } - }, - _sections: { - basic: { label: "Case Information" }, - origin: { label: "Origin & Routing" }, - sla: { label: "SLA & Priority" }, - resolution: { label: "Resolution" }, - escalation: { label: "Escalation" }, - system: { label: "System" }, - // The detail page's sections reference the groups above (#970), so it - // has no section names of its own. - // Form section names on case.view.ts (#1100). - case: { label: "Case" }, - how_can_we_help: { label: "How can we help?" } - }, - _actions: { - ...activityActions, - escalate_case: { - label: "Escalate Case", - confirmText: "This will escalate the case to the escalation team. Continue?", - successMessage: "Case escalated successfully!" - }, - close_case: { - label: "Close Case", - confirmText: "Are you sure you want to close this case?", - successMessage: "Case closed successfully!" - }, - claim_case: { - label: "Claim Case", - successMessage: "Case claimed \u2014 it is yours now." - } - } - }, - crm_knowledge_article: { - label: "Knowledge Article", - pluralLabel: "Knowledge Base", - description: "Reusable answers and how-to guides for customers and agents", - fields: { - article_number: { label: "Article #" }, - title: { label: "Title" }, - summary: { label: "Summary", help: "One-paragraph TL;DR shown in search results and AI citations." }, - body: { label: "Body", help: "Full article content (Markdown)." }, - category: { - label: "Category", - options: { - getting_started: "Getting Started", - how_to: "How-To", - troubleshooting: "Troubleshooting", - billing: "Billing & Pricing", - api: "API & Integrations", - release_notes: "Release Notes", - policy: "Policy" - } - }, - tags: { - label: "Tags", - options: { - auth: "Auth", - sso: "SSO", - mobile: "Mobile", - email: "Email", - reports: "Reports", - performance: "Performance", - data_import: "Data Import", - webhooks: "Webhooks" - } - }, - status: { - label: "Status", - options: { draft: "Draft", in_review: "In Review", published: "Published", archived: "Archived" } - }, - audience: { - label: "Audience", - help: "Public articles are visible in the customer portal; internal articles are agent-only.", - options: { public: "Public", internal: "Internal" } - }, - language: { - label: "Language", - options: { en: "English", zh_cn: "Simplified Chinese", es_es: "Spanish", ja_jp: "Japanese" } - }, - owner_id: { label: "Owner" }, - related_to_case: { label: "Source Case", help: "Case this article was authored from (optional)." }, - published_at: { label: "Published At" }, - last_reviewed_at: { label: "Last Reviewed" }, - helpful_count: { label: "Helpful", help: "Recounted from crm_article_feedback \u2014 never typed in." }, - not_helpful_count: { label: "Not Helpful", help: "Recounted from crm_article_feedback \u2014 never typed in." }, - display_title: { label: "Display Title" } - }, - _views: { - all_articles: { label: "All Articles" }, - published_articles: { label: "Published" }, - my_drafts: { label: "My Drafts" } - }, - _sections: { - basic: { label: "Article Information" }, - content: { label: "Content" }, - taxonomy: { label: "Categorization" }, - metrics: { label: "Engagement" }, - engagement: { label: "Engagement" }, - // Form section name on knowledge_article.view.ts (#1100) - article: { label: "Article" } - }, - _actions: { - mark_article_helpful: { - label: "Helpful", - successMessage: "Thanks \u2014 recorded as helpful." - }, - mark_article_not_helpful: { - label: "Not Helpful", - successMessage: "Thanks \u2014 recorded as not helpful." - } - } - }, - crm_article_feedback: { - label: "Article Feedback", - pluralLabel: "Article Feedback", - description: "One reader\u2019s helpful / not-helpful verdict on a knowledge article", - fields: { - feedback_number: { label: "Feedback #" }, - owner_id: { label: "Reader" }, - crm_knowledge_article: { label: "Article", help: "Knowledge article this feedback is about." }, - verdict: { - label: "Verdict", - options: { helpful: "Helpful", not_helpful: "Not Helpful" } - }, - comment: { label: "Comment", help: "Optional note explaining the verdict \u2014 read by the article\u2019s author." } - }, - _sections: { - basic: { label: "Feedback" } - } - } -}; - -// src/sales/translations/en/objects.activity.ts -var activity = { - crm_task: { - label: "Task", - pluralLabel: "Tasks", - fields: { - subject: { label: "Subject" }, - description: { label: "Description" }, - status: { - label: "Status", - options: { - not_started: "Not Started", - in_progress: "In Progress", - waiting: "Waiting", - completed: "Completed", - deferred: "Deferred" - } - }, - priority: { - label: "Priority", - options: { low: "Low", normal: "Normal", high: "High", urgent: "Urgent" } - }, - type: { - label: "Task Type", - options: { - call: "Call", - email: "Email", - meeting: "Meeting", - follow_up: "Follow-up", - demo: "Demo", - other: "Other" - } - }, - due_date: { label: "Due Date" }, - reminder_date: { label: "Reminder Date/Time" }, - completed_date: { label: "Completed Date" }, - owner_id: { label: "Assigned To" }, - related_to_type: { - label: "Related To Type", - options: { - crm_account: "Account", - crm_contact: "Contact", - crm_opportunity: "Opportunity", - crm_lead: "Lead", - crm_case: "Case" - } - }, - related_to_account: { label: "Related Account" }, - related_to_contact: { label: "Related Contact" }, - related_to_opportunity: { label: "Related Opportunity" }, - related_to_lead: { label: "Related Lead" }, - related_to_case: { label: "Related Case" }, - is_recurring: { label: "Recurring Task" }, - recurrence_type: { - label: "Recurrence Type", - options: { daily: "Daily", weekly: "Weekly", monthly: "Monthly", yearly: "Yearly" } - }, - recurrence_interval: { label: "Recurrence Interval" }, - recurrence_end_date: { label: "Recurrence End Date" }, - is_completed: { label: "Is Completed" }, - is_overdue: { label: "Is Overdue" }, - progress_percent: { label: "Progress (%)" }, - priority_rank: { label: "Priority Rank" }, - reminder_sent: { label: "Reminder Sent" } - }, - _views: { - all_tasks: { label: "All Tasks" }, - task_board: { label: "Task Board" }, - task_calendar: { label: "Task Schedule" }, - task_gantt: { label: "Execution Plan" }, - task_timeline: { label: "Worklog Timeline" }, - my_open_tasks: { label: "My Open Tasks" }, - todays_tasks: { label: "\u{1F4C5} My Priority Tasks" }, - overdue_tasks: { label: "\u23F0 Open Tasks \xB7 Most Overdue First" } - }, - _sections: { - basic: { label: "Task Information" }, - scheduling: { label: "Scheduling" }, - related: { label: "Related Records" }, - recurrence: { label: "Recurrence" }, - effort: { label: "Progress & Effort" }, - system: { label: "System" }, - // Form section names on task.view.ts (#1100) - task: { label: "Task" }, - related_records: { label: "Related Records" }, - recurrence_and_effort: { label: "Recurrence & Effort" } - } - }, - crm_event: { - label: "Event", - pluralLabel: "Events", - description: "Meetings, calls and other scheduled interactions with customers", - fields: { - subject: { label: "Subject" }, - description: { label: "Description" }, - type: { - label: "Event Type", - options: { - meeting: "Meeting", - call: "Call", - demo: "Demo", - webinar: "Webinar", - onsite_visit: "Onsite Visit", - other: "Other" - } - }, - status: { - label: "Status", - options: { - planned: "Planned", - held: "Held", - cancelled: "Cancelled", - no_show: "No Show" - } - }, - owner_id: { label: "Assigned To" }, - start_datetime: { label: "Start" }, - end_datetime: { label: "End" }, - all_day: { label: "All Day Event" }, - duration_minutes: { label: "Duration (minutes)" }, - location: { label: "Location", help: "Room, address, or meeting link" }, - related_to_type: { - label: "Related To Type", - options: { - crm_account: "Account", - crm_contact: "Contact", - crm_opportunity: "Opportunity", - crm_lead: "Lead", - crm_case: "Case" - } - }, - related_to_account: { label: "Related Account" }, - related_to_contact: { label: "Related Contact" }, - related_to_opportunity: { label: "Related Opportunity" }, - related_to_lead: { label: "Related Lead" }, - related_to_case: { label: "Related Case" }, - outcome_notes: { label: "Outcome Notes", help: "What was agreed, and what happens next" } - }, - _views: { - all_events: { label: "All Events" }, - event_calendar: { label: "Event Calendar" }, - event_timeline: { label: "Team Schedule" }, - my_events: { label: "My Calendar" }, - upcoming_events: { label: "\u{1F4C5} Upcoming \xB7 Soonest First" }, - held_events: { label: "\u2705 Interaction History" } - }, - _sections: { - basic: { label: "Event Information" }, - schedule: { label: "Schedule" }, - related: { label: "Related Records" }, - outcome: { label: "Outcome" }, - // Form section names on event.view.ts (#1100). `related_records`, - // not `related` — `related` is already the fieldGroup key above. - event: { label: "Event" }, - related_records: { label: "Related Records" } - } - }, - crm_event_attendee: { - label: "Event Attendee", - pluralLabel: "Event Attendees", - description: "A person invited to or present at an event", - fields: { - attendee_number: { label: "Attendee Number" }, - crm_event: { label: "Event" }, - attendee_type: { - label: "Attendee Type", - options: { contact: "Contact", lead: "Lead", user: "User", external: "External" } - }, - crm_contact: { label: "Contact", help: "Set when the attendee is an existing customer contact" }, - crm_lead: { label: "Lead", help: "Set when the attendee is still an unconverted lead" }, - sys_user: { label: "User", help: "Set when the attendee is a colleague" }, - external_name: { - label: "External Attendee", - help: "Name of an attendee who is in no CRM object \u2014 set when Attendee Type is External" - }, - response: { - label: "Response", - options: { - no_response: "No Response", - accepted: "Accepted", - declined: "Declined", - tentative: "Tentative" - } - }, - is_organizer: { label: "Organizer" }, - invited_date: { label: "Invited" } - }, - _views: { - all_event_attendees: { label: "Event Attendees" } - }, - _sections: { - basic: { label: "Attendee" }, - response: { label: "Invitation" }, - // Form section names on event_attendee.view.ts (#1100) — same English - // text as the fieldGroups above, but a distinct key: `attendee` / - // `invitation` are not `basic` / `response`. - attendee: { label: "Attendee" }, - invitation: { label: "Invitation" } - } - } -}; - -// src/sales/translations/en/objects.marketing.ts -var marketing = { - crm_campaign: { - label: "Campaign", - pluralLabel: "Campaigns", - fields: { - campaign_code: { label: "Campaign Code" }, - name: { label: "Campaign Name" }, - description: { label: "Description" }, - type: { - label: "Campaign Type", - options: { - email: "Email", - webinar: "Webinar", - trade_show: "Trade Show", - conference: "Conference", - direct_mail: "Direct Mail", - social_media: "Social Media", - content: "Content Marketing", - partner: "Partner Marketing" - } - }, - channel: { - label: "Primary Channel", - options: { - digital: "Digital", - social: "Social", - email: "Email", - events: "Events", - partner: "Partner" - } - }, - status: { - label: "Status", - options: { - planning: "Planning", - in_progress: "In Progress", - completed: "Completed", - aborted: "Aborted" - } - }, - start_date: { label: "Start Date" }, - end_date: { label: "End Date" }, - budgeted_cost: { label: "Budgeted Cost" }, - actual_cost: { label: "Actual Cost" }, - expected_revenue: { label: "Expected Revenue" }, - actual_revenue: { label: "Actual Revenue" }, - target_size: { label: "Target Size", help: "Target number of leads/contacts" }, - num_sent: { label: "Number Sent" }, - num_responses: { label: "Number of Responses" }, - num_leads: { label: "Number of Leads" }, - num_converted_leads: { label: "Converted Leads" }, - num_opportunities: { label: "Opportunities Created" }, - num_won_opportunities: { label: "Won Opportunities" }, - response_rate: { label: "Response Rate %" }, - roi: { label: "ROI %" }, - owner_id: { label: "Campaign Owner" }, - landing_page_url: { label: "Landing Page" }, - is_active: { label: "Active" }, - display_title: { label: "Display Title" } - }, - _views: { - all_campaigns: { label: "All Campaigns" }, - campaign_gantt: { label: "Campaign Schedule" }, - campaign_calendar: { label: "Launch Calendar" }, - campaign_timeline: { label: "Marketing Timeline" } - }, - _sections: { - basic: { label: "Campaign Information" }, - schedule: { label: "Schedule" }, - budget: { label: "Budget & ROI" }, - metrics: { label: "Performance" }, - assignment: { label: "Ownership" }, - assets: { label: "Campaign Assets" } - }, - _actions: { - enroll_leads: { - label: "Enroll Members", - successMessage: "Eligible members enrolled in campaign." - } - } - }, - crm_campaign_member: { - label: "Campaign Member", - pluralLabel: "Campaign Members", - description: "Leads and contacts touched by a campaign, with response status", - fields: { - member_number: { label: "Member Number" }, - crm_campaign: { label: "Campaign" }, - crm_lead: { label: "Lead", help: "Set when the member was a Lead at enrollment time" }, - crm_contact: { label: "Contact", help: "Set when the member is an existing Contact" }, - status: { - label: "Status", - options: { - sent: "Sent", - responded: "Responded", - converted: "Converted", - unsubscribed: "Unsubscribed" - } - }, - added_date: { label: "Added Date" }, - response_date: { label: "Response Date" }, - has_responded: { label: "Has Responded" } - }, - _sections: { - basic: { label: "Basic Information" }, - response: { label: "Response Tracking" } - }, - _actions: { - mark_responded: { - label: "Mark Responded", - successMessage: "Response recorded on this campaign member." - } - } - } -}; - -// src/sales/translations/en.ts -var en2 = { - objects: { - crm_account: customer.crm_account, - crm_contact: customer.crm_contact, - crm_knowledge_article: service.crm_knowledge_article, - crm_forecast: pipeline.crm_forecast, - crm_lead: pipeline.crm_lead, - crm_opportunity: pipeline.crm_opportunity, - crm_case: service.crm_case, - crm_contract: commerce.crm_contract, - crm_product: commerce.crm_product, - crm_quote: commerce.crm_quote, - crm_task: activity.crm_task, - crm_campaign: marketing.crm_campaign, - crm_event: activity.crm_event, - crm_event_attendee: activity.crm_event_attendee, - crm_article_feedback: service.crm_article_feedback, - crm_campaign_member: marketing.crm_campaign_member, - crm_opportunity_line_item: pipeline.crm_opportunity_line_item, - crm_quote_line_item: commerce.crm_quote_line_item - }, - ...appSurface -}; - -// src/sales/translations/zh-CN/app.ts -var appSurface2 = { - apps: { - crm_enterprise: { - label: "HotCRM", - description: "\u6DB5\u76D6\u9500\u552E\u3001\u670D\u52A1\u548C\u5E02\u573A\u8425\u9500\u7684\u5BA2\u6237\u5173\u7CFB\u7BA1\u7406\u7CFB\u7EDF", - // Keyed by navigation-node `id` (a flat keyspace regardless of depth). - navigation: { - group_activity: { label: "\u6D3B\u52A8" }, - nav_event: { label: "\u6D3B\u52A8" }, - nav_activity_dashboard: { label: "\u9500\u552E\u6D3B\u52A8" }, - nav_my_calendar: { label: "\u6211\u7684\u65E5\u5386" }, - nav_home: { label: "\u9996\u9875" }, - group_sales: { label: "\u9500\u552E" }, - nav_lead: { label: "\u7EBF\u7D22" }, - nav_account: { label: "\u5BA2\u6237" }, - nav_account_workbench: { label: "\u5BA2\u6237\u5DE5\u4F5C\u53F0" }, - nav_contact: { label: "\u8054\u7CFB\u4EBA" }, - nav_opportunity: { label: "\u5546\u673A" }, - nav_quote: { label: "\u62A5\u4EF7" }, - nav_contract: { label: "\u5408\u540C" }, - nav_product: { label: "\u4EA7\u54C1" }, - nav_sales_dashboard: { label: "\u9500\u552E\u4E1A\u7EE9" }, - group_work: { label: "\u6211\u7684\u5DE5\u4F5C" }, - nav_my_tasks: { label: "\u6211\u7684\u4EFB\u52A1" }, - nav_my_deals: { label: "\u6211\u7684\u5546\u673A" }, - nav_my_leads: { label: "\u6211\u7684\u7EBF\u7D22" }, - nav_my_cases: { label: "\u6211\u7684\u5DE5\u5355" }, - nav_approval_requests: { label: "\u5F85\u6211\u5BA1\u6279" }, - group_marketing: { label: "\u5E02\u573A\u8425\u9500" }, - nav_campaign: { label: "\u8425\u9500\u6D3B\u52A8" }, - group_service: { label: "\u670D\u52A1" }, - nav_case: { label: "\u5DE5\u5355" }, - nav_knowledge: { label: "\u77E5\u8BC6\u5E93" }, - nav_service_dashboard: { label: "\u670D\u52A1\u6982\u89C8" }, - group_insights: { label: "\u6570\u636E\u6D1E\u5BDF" }, - nav_crm_dashboard: { label: "CRM \u603B\u89C8" }, - nav_forecast: { label: "\u9500\u552E\u9884\u6D4B" }, - nav_report_pipeline_coverage: { label: "\u7BA1\u9053\u8986\u76D6\u7387" }, - nav_report_lead_inflow: { label: "\u7EBF\u7D22\u6D41\u5165" }, - nav_report_sla: { label: "SLA \u8FBE\u6210" } - } - } - }, - messages: { - "common.save": "\u4FDD\u5B58", - "common.cancel": "\u53D6\u6D88", - "common.delete": "\u5220\u9664", - "common.edit": "\u7F16\u8F91", - "common.create": "\u65B0\u5EFA", - "common.search": "\u641C\u7D22", - "common.filter": "\u7B5B\u9009", - "common.export": "\u5BFC\u51FA", - "common.back": "\u8FD4\u56DE", - "common.confirm": "\u786E\u8BA4", - "nav.sales": "\u9500\u552E", - "nav.service": "\u670D\u52A1", - "nav.marketing": "\u8425\u9500", - "nav.products": "\u4EA7\u54C1", - "nav.analytics": "\u6570\u636E\u5206\u6790", - "success.saved": "\u8BB0\u5F55\u4FDD\u5B58\u6210\u529F", - "success.converted": "\u7EBF\u7D22\u8F6C\u5316\u6210\u529F", - "confirm.delete": "\u786E\u5B9A\u8981\u5220\u9664\u6B64\u8BB0\u5F55\u5417\uFF1F", - "confirm.convert_lead": "\u5C06\u6B64\u7EBF\u7D22\u8F6C\u5316\u4E3A\u5BA2\u6237\u3001\u8054\u7CFB\u4EBA\u548C\u5546\u673A\uFF1F", - "error.required": "\u6B64\u5B57\u6BB5\u4E3A\u5FC5\u586B\u9879", - "error.load_failed": "\u6570\u636E\u52A0\u8F7D\u5931\u8D25" - }, - dashboards: { - sales_activity_dashboard: { - label: "\u9500\u552E\u6D3B\u52A8", - description: "\u8C01\u5728\u548C\u5BA2\u6237\u6C9F\u901A\u3001\u9891\u7387\u5982\u4F55\uFF0C\u4EE5\u53CA\u54EA\u4E9B\u5BA2\u6237\u5DF2\u7ECF\u6C89\u9ED8", - widgets: { - interactions_held: { title: "\u5DF2\u8BB0\u5F55\u4E92\u52A8", description: "\u771F\u5B9E\u53D1\u751F\u8FC7\u7684\u901A\u8BDD\u4E0E\u4F1A\u8BAE" }, - meetings_booked: { title: "\u5DF2\u9884\u7EA6\u4F1A\u8BAE", description: "\u5DF2\u6392\u5165\u65E5\u5386\u4F46\u5C1A\u672A\u4E3E\u884C\u7684\u4F1A\u8BAE" }, - customer_minutes: { title: "\u5BA2\u6237\u63A5\u89E6\u5206\u949F\u6570", description: "\u9762\u5411\u5BA2\u6237\u7684\u603B\u65F6\u957F" }, - tasks_completed: { title: "\u5DF2\u5B8C\u6210\u4EFB\u52A1", description: "\u5DF2\u95ED\u73AF\u7684\u8DDF\u8FDB\u4E8B\u9879\u2014\u2014\u6D3B\u52A8\u7684\u53E6\u4E00\u534A" }, - activity_by_rep: { title: "\u6309\u9500\u552E\u4EE3\u8868\u7EDF\u8BA1\u7684\u6D3B\u52A8", description: "\u6BCF\u4F4D\u8D1F\u8D23\u4EBA\u8BB0\u5F55\u7684\u4E92\u52A8\u6570" }, - activity_by_week: { title: "\u6BCF\u5468\u6D3B\u52A8\u91CF", description: "\u6BCF\u5468\u4E92\u52A8\u6570" }, - activity_mix: { title: "\u6D3B\u52A8\u6784\u6210", description: "\u901A\u8BDD\u3001\u4F1A\u8BAE\u4E0E\u6F14\u793A\u7684\u5360\u6BD4" }, - activity_by_record_type: { title: "\u6D3B\u52A8\u843D\u5728\u54EA\u91CC", description: "\u6F0F\u6597\u7684\u54EA\u4E2A\u73AF\u8282\u83B7\u5F97\u4E86\u5173\u6CE8" }, - deal_activity: { title: "\u5546\u673A\u4E0A\u7684\u4E92\u52A8", description: "\u5173\u8054\u5230\u5546\u673A\u7684\u5DF2\u8BB0\u5F55\u4E92\u52A8" }, - open_deals_for_activity: { title: "\u8FDB\u884C\u4E2D\u7684\u5546\u673A", description: "\u4ECD\u5728\u63A8\u8FDB\u7684\u5546\u673A\u6570" }, - quiet_accounts_30: { title: "\u6C89\u9ED8 30 \u5929\u4EE5\u4E0A", description: "\u4E00\u4E2A\u6708\u5185\u6CA1\u6709\u4EFB\u4F55\u4E92\u52A8\u8BB0\u5F55\u7684\u6D3B\u8DC3\u5BA2\u6237" }, - quiet_accounts_60: { title: "\u6C89\u9ED8 60 \u5929\u4EE5\u4E0A", description: "\u4E24\u4E2A\u6708\u65E0\u8054\u7CFB\u2014\u2014\u98CE\u9669\u9608\u503C" }, - quiet_accounts_90: { title: "\u6C89\u9ED8 90 \u5929\u4EE5\u4E0A", description: "\u6574\u6574\u4E00\u4E2A\u5B63\u5EA6\u6CA1\u6709\u8054\u7CFB" } - } - }, - crm_overview_dashboard: { - label: "CRM \u603B\u89C8", - description: "\u6536\u5165\u6307\u6807\u3001\u7BA1\u9053\u5206\u6790\u4E0E\u5546\u673A\u6D1E\u5BDF", - widgets: { - total_revenue: { title: "\u603B\u6536\u5165", description: "\u672C\u671F\u5DF2\u6210\u4EA4\u6536\u5165" }, - active_deals: { title: "\u6D3B\u8DC3\u5546\u673A", description: "\u7BA1\u9053\u4E2D\u8FDB\u884C\u4E2D\u7684\u5546\u673A" }, - won_deals: { title: "\u8D62\u5355\u6570", description: "\u672C\u671F\u5DF2\u7ED3\u6848\u5546\u673A\u4E2D\u8D62\u5355\u7684\u603B\u6570" }, - avg_deal_size: { title: "\u5E73\u5747\u8BA2\u5355\u91D1\u989D", description: "\u5DF2\u6210\u4EA4\u5546\u673A\u7684\u5E73\u5747\u91D1\u989D" }, - revenue_trends: { title: "\u6536\u5165\u8D8B\u52BF", description: "\u8FC7\u53BB 12 \u4E2A\u6708\u7684\u5DF2\u6210\u4EA4\u6536\u5165" }, - lead_source: { title: "\u7EBF\u7D22\u6765\u6E90", description: "\u6309\u83B7\u5BA2\u6E20\u9053\u7EDF\u8BA1\u7684\u7BA1\u9053\u91D1\u989D" }, - pipeline_by_stage: { title: "\u9636\u6BB5\u7BA1\u9053\u5206\u5E03", description: "\u6309\u9636\u6BB5\u7EDF\u8BA1\u7684\u8FDB\u884C\u4E2D\u5546\u673A\u91D1\u989D" }, - top_products: { title: "\u70ED\u95E8\u4EA7\u54C1", description: "\u6309\u4EA7\u54C1\u7C7B\u522B\u7EDF\u8BA1\u7684\u76EE\u5F55\u4EF7\u6536\u5165" }, - pipeline_by_owner: { title: "\u6309\u8D1F\u8D23\u4EBA\u7EDF\u8BA1\u7BA1\u9053", description: "\u5404\u9500\u552E\u8D1F\u8D23\u4EBA\u7684\u8FDB\u884C\u4E2D\u7BA1\u9053\u91D1\u989D\u4E0E\u5546\u673A\u6570" } - } - }, - executive_dashboard: { - label: "\u9AD8\u7BA1\u603B\u89C8", - description: "\u9762\u5411\u7BA1\u7406\u5C42\u7684\u6536\u5165\u3001\u5BA2\u6237\u4E0E\u7BA1\u9053\u9AD8\u9636\u6307\u6807", - widgets: { - total_revenue_ytd: { title: "\u5E74\u5EA6\u7D2F\u8BA1\u6536\u5165", description: "\u672C\u5E74\u5EA6\u5DF2\u6210\u4EA4\u6536\u5165" }, - total_accounts: { title: "\u6D3B\u8DC3\u5BA2\u6237", description: "\u81F3\u5C11\u5B58\u5728\u4E00\u9879\u6D3B\u8DC3\u5173\u7CFB\u7684\u5BA2\u6237" }, - total_contacts: { title: "\u8054\u7CFB\u4EBA\u603B\u6570", description: "\u901A\u8BAF\u5F55\u4E2D\u7684\u8054\u7CFB\u4EBA" }, - open_leads: { title: "\u672A\u8F6C\u5316\u7EBF\u7D22", description: "\u6F0F\u6597\u4E2D\u5C1A\u672A\u8F6C\u5316\u7684\u7EBF\u7D22" }, - revenue_trend: { title: "\u6536\u5165\u8D8B\u52BF", description: "\u8FC7\u53BB 12 \u4E2A\u6708\u7684\u5DF2\u6210\u4EA4\u6536\u5165" }, - revenue_by_industry: { title: "\u884C\u4E1A\u6536\u5165\u5206\u5E03", description: "\u672C\u5E74\u5EA6\u5DF2\u6210\u4EA4\u6536\u5165\u6309\u5BA2\u6237\u884C\u4E1A\u62C6\u5206" }, - pipeline_by_stage: { title: "\u9636\u6BB5\u7BA1\u9053\u5206\u5E03", description: "\u6309\u9636\u6BB5\u7EDF\u8BA1\u7684\u8FDB\u884C\u4E2D\u5546\u673A\u91D1\u989D" }, - new_accounts_by_month: { title: "\u65B0\u589E\u5BA2\u6237", description: "\u8FC7\u53BB 6 \u4E2A\u6708\u7684\u5BA2\u6237\u521B\u5EFA\u8282\u594F" }, - accounts_by_industry: { title: "\u6309\u884C\u4E1A\u7EDF\u8BA1\u5BA2\u6237", description: "\u5404\u884C\u4E1A\u7684\u5E74\u8425\u6536\u603B\u989D\u4E0E\u5BA2\u6237\u6570" } - } - }, - sales_dashboard: { - label: "\u9500\u552E\u4E1A\u7EE9", - description: "\u7BA1\u9053\u5206\u6790\u3001\u8D62\u7387\u8D8B\u52BF\u53CA\u9500\u552E\u4EE3\u8868\u7EE9\u6548", - widgets: { - total_pipeline_value: { title: "\u7BA1\u9053\u603B\u989D", description: "\u6240\u6709\u8FDB\u884C\u4E2D\u5546\u673A\u91D1\u989D\u5408\u8BA1" }, - closed_won_qtd: { title: "\u672C\u5B63\u5EA6\u5DF2\u6210\u4EA4", description: "\u672C\u5B63\u5EA6\u5DF2\u8D62\u5F97\u7684\u6536\u5165" }, - open_opportunities: { title: "\u8FDB\u884C\u4E2D\u5546\u673A", description: "\u6B63\u5728\u63A8\u8FDB\u7684\u6D3B\u8DC3\u5546\u673A" }, - avg_deal_size: { title: "\u5E73\u5747\u8BA2\u5355\u91D1\u989D", description: "\u672C\u5B63\u5EA6\u5DF2\u6210\u4EA4\u5546\u673A\u7684\u5E73\u5747\u91D1\u989D" }, - pipeline_by_stage: { title: "\u9636\u6BB5\u7BA1\u9053\u5206\u5E03", description: "\u6309\u9636\u6BB5\u7EDF\u8BA1\u7684\u8FDB\u884C\u4E2D\u5546\u673A\u91D1\u989D" }, - monthly_revenue_trend: { title: "\u6708\u5EA6\u6536\u5165\u8D8B\u52BF", description: "\u8FC7\u53BB 12 \u4E2A\u6708\u7684\u5DF2\u6210\u4EA4\u6536\u5165" }, - pipeline_by_forecast_category: { title: "\u9884\u6D4B\u7C7B\u522B\u7BA1\u9053\u5206\u5E03", description: "\u6309\u9884\u6D4B\u7C7B\u522B\u7EDF\u8BA1\u7684\u8FDB\u884C\u4E2D\u7BA1\u9053\u91D1\u989D" }, - lead_source_breakdown: { title: "\u7EBF\u7D22\u6765\u6E90\u5206\u5E03", description: "\u6309\u6765\u6E90\u7EDF\u8BA1\u7684\u7EBF\u7D22\u6570\u91CF" }, - open_pipeline_by_owner: { title: "\u6309\u8D1F\u8D23\u4EBA\u7EDF\u8BA1\u8FDB\u884C\u4E2D\u7BA1\u9053", description: "\u5404\u9500\u552E\u8D1F\u8D23\u4EBA\u7684\u8FDB\u884C\u4E2D\u7BA1\u9053\u91D1\u989D\u3001\u5546\u673A\u6570\u4E0E\u5E73\u5747\u8D62\u5355\u6982\u7387" }, - quota_attainment_by_rep: { title: "\u6309\u9500\u552E\u4EE3\u8868\u7EDF\u8BA1\u914D\u989D\u8FBE\u6210", description: "\u6765\u81EA\u9884\u6D4B\u5FEB\u7167\u7684\u5404\u9500\u552E\u4EE3\u8868\u672C\u5B63\u5EA6\u914D\u989D\u3001\u5DF2\u6210\u4EA4\u6536\u5165\u4E0E\u8FBE\u6210\u7387" }, - pipeline_stage_by_source: { title: "\u9636\u6BB5 \xD7 \u7EBF\u7D22\u6765\u6E90", description: "\u6309\u9636\u6BB5\u548C\u6765\u6E90\u4EA4\u53C9\u7EDF\u8BA1\u8FDB\u884C\u4E2D\u5546\u673A\u91D1\u989D" }, - win_rate_12m: { title: "\u8D62\u7387\uFF08\u8FD1 12 \u4E2A\u6708\uFF09", description: "\u8FD1 12 \u4E2A\u6708\u5DF2\u7ED3\u5355\u5546\u673A\u4E2D\u8D62\u5355\u6240\u5360\u7684\u6BD4\u4F8B" }, - won_deals_12m: { title: "\u8D62\u5355\u6570\uFF08\u8FD1 12 \u4E2A\u6708\uFF09", description: "\u8D62\u7387\u7684\u5206\u5B50" }, - lost_deals_12m: { title: "\u4E22\u5355\u6570\uFF08\u8FD1 12 \u4E2A\u6708\uFF09", description: "\u8D62\u7387\u5206\u6BCD\u7684\u53E6\u4E00\u534A" }, - win_rate_by_owner: { title: "\u6309\u9500\u552E\u4EE3\u8868\u7EDF\u8BA1\u8D62/\u4E22\u5355", description: "\u8FD1 12 \u4E2A\u6708\u5404\u9500\u552E\u4EE3\u8868\u7684\u8D62\u5355\u6570\u3001\u4E22\u5355\u6570\u4E0E\u8D62\u7387" }, - win_rate_by_lead_source: { title: "\u6309\u7EBF\u7D22\u6765\u6E90\u7EDF\u8BA1\u8D62/\u4E22\u5355", description: "\u8FD1 12 \u4E2A\u6708\u54EA\u4E9B\u6765\u6E90\u5E26\u6765\u7684\u5546\u673A\u771F\u6B63\u6210\u4EA4" }, - loss_reason_breakdown: { title: "\u4E22\u5355\u539F\u56E0\u5206\u6790", description: "\u8FD1 12 \u4E2A\u6708\u4E22\u5355\u6309\u539F\u56E0\u5206\u5E03" } - } - }, - service_dashboard: { - label: "\u5BA2\u6237\u670D\u52A1", - description: "\u5DE5\u5355\u8D1F\u8F7D\u3001SLA \u5065\u5EB7\u5EA6\u4E0E\u5904\u7406\u7EE9\u6548", - widgets: { - open_cases: { title: "\u672A\u5173\u95ED\u5DE5\u5355", description: "\u5C1A\u672A\u5173\u95ED\u7684\u5DE5\u5355" }, - critical_cases: { title: "\u4E25\u91CD\u5DE5\u5355", description: "\u6807\u8BB0\u4E3A\u4E25\u91CD\u4F18\u5148\u7EA7\u7684\u672A\u5173\u95ED\u5DE5\u5355" }, - avg_resolution_time: { title: "\u5E73\u5747\u89E3\u51B3\u65F6\u957F", description: "\u5173\u95ED\u5DE5\u5355\u7684\u5E73\u5747\u5904\u7406\u65F6\u957F\uFF08\u5C0F\u65F6\uFF09" }, - sla_violations: { title: "SLA \u8FDD\u7EA6", description: "\u5DF2\u8D85\u51FA SLA \u7684\u5DE5\u5355" }, - cases_by_status: { title: "\u6309\u72B6\u6001\u5206\u5E03", description: "\u5DE5\u5355\u5728\u5404\u5904\u7406\u9636\u6BB5\u7684\u5206\u5E03" }, - cases_by_priority: { title: "\u6309\u4F18\u5148\u7EA7\u5206\u5E03", description: "\u672A\u5173\u95ED\u5DE5\u5355\u6309\u7D27\u6025\u7A0B\u5EA6\u7684\u5206\u5E03" }, - cases_by_origin: { title: "\u6309\u6765\u6E90\u5206\u5E03", description: "\u5DE5\u5355\u7684\u6765\u6E90\u6E20\u9053" }, - daily_case_volume: { title: "\u6BCF\u65E5\u5DE5\u5355\u91CF", description: "\u8FC7\u53BB 30 \u5929\u7684\u65B0\u5EFA\u5DE5\u5355" }, - sla_compliance_gauge: { title: "SLA \u8FBE\u6210\u7387", description: "\u672C\u671F SLA \u5185\u89E3\u51B3\u5DE5\u5355\u7684\u5360\u6BD4" }, - kb_deflection_rate: { title: "\u77E5\u8BC6\u5E93\u8F6C\u79FB\u7387", description: "\u5DF2\u5173\u95ED\u5DE5\u5355\u4E2D\u7531\u77E5\u8BC6\u6587\u7AE0\u89E3\u51B3\u7684\u5360\u6BD4" }, - kb_resolved_cases: { title: "\u77E5\u8BC6\u5E93\u89E3\u51B3\u6570", description: "\u5DF2\u5173\u8054\u89E3\u51B3\u6587\u7AE0\u7684\u5DF2\u5173\u95ED\u5DE5\u5355" }, - closed_cases_total: { title: "\u5DF2\u5173\u95ED\u5DE5\u5355", description: "\u8F6C\u79FB\u7387\u7684\u5206\u6BCD" }, - top_resolving_articles: { title: "\u89E3\u51B3\u5DE5\u5355\u6700\u591A\u7684\u6587\u7AE0", description: "\u6309\u89E3\u51B3\u7684\u5DF2\u5173\u95ED\u5DE5\u5355\u6570\u6392\u540D\u7684\u77E5\u8BC6\u6587\u7AE0" }, - my_open_cases_by_priority: { title: "\u6211\u7684\u672A\u5173\u95ED\u5DE5\u5355\uFF08\u6309\u4F18\u5148\u7EA7\uFF09", description: "\u4F60\u7684\u672A\u5173\u95ED\u5DE5\u5355\u53CA\u5176 SLA \u8FDD\u7EA6\u7387\uFF0C\u6309\u4F18\u5148\u7EA7\u7EC6\u5206" } - } - } - }, - // `title` / `subtitle` translate the page's `page:header`; `title` falls back - // to `label` when omitted, so it is authored only where the two differ. - // Header strings carrying `{field}` tokens keep the token spelling verbatim — - // the console substitutes on the raw key, so a translated token resolves to - // nothing and the header renders blank. - datasets: { - account_metrics: { - label: "\u5BA2\u6237\u6307\u6807", - description: "\u6309\u884C\u4E1A\u4E0E\u7C7B\u578B\u7EDF\u8BA1\u5BA2\u6237\u6570\u91CF\u7684\u8BED\u4E49\u5C42", - dimensions: { - industry: { - label: "\u884C\u4E1A" - }, - type: { - label: "\u7C7B\u578B" - }, - created_at: { - label: "\u521B\u5EFA\u65F6\u95F4" - } - }, - measures: { - account_count: { - label: "\u5BA2\u6237\u6570" - }, - annual_revenue_sum: { - label: "\u5E74\u8425\u6536" - } - } - }, - case_metrics: { - label: "\u5DE5\u5355\u6307\u6807", - description: "\u7EDF\u8BA1\u5DE5\u5355\u6570\u91CF\u3001\u89E3\u51B3\u65F6\u957F\u4E0E SLA \u7684\u8BED\u4E49\u5C42", - dimensions: { - created_at: { - label: "\u521B\u5EFA\u65F6\u95F4" - }, - origin: { - label: "\u6765\u6E90" - }, - priority: { - label: "\u4F18\u5148\u7EA7" - }, - resolved_article: { - label: "\u89E3\u51B3\u7528\u77E5\u8BC6\u6587\u7AE0" - }, - status: { - label: "\u72B6\u6001" - }, - type: { - label: "\u7C7B\u578B" - } - }, - measures: { - avg_resolution: { - label: "\u5E73\u5747\u89E3\u51B3\u65F6\u957F\uFF08\u5C0F\u65F6\uFF09" - }, - avg_sla_violated: { - label: "SLA \u8FDD\u7EA6\u7387" - }, - case_count: { - label: "\u5DE5\u5355\u6570" - }, - closed_count: { - label: "\u5DF2\u5173\u95ED\u5DE5\u5355" - }, - kb_deflection_rate: { - label: "\u77E5\u8BC6\u5E93\u81EA\u52A9\u89E3\u51B3\u7387" - }, - kb_resolved_count: { - label: "\u77E5\u8BC6\u5E93\u89E3\u51B3\u6570" - }, - sla_compliance_rate: { - label: "SLA \u8FBE\u6807\u7387" - }, - sla_met_count: { - label: "SLA \u8FBE\u6807\u5DE5\u5355" - } - } - }, - contact_metrics: { - label: "\u8054\u7CFB\u4EBA\u6307\u6807", - description: "\u7EDF\u8BA1\u8054\u7CFB\u4EBA\u6570\u91CF\u7684\u8BED\u4E49\u5C42", - measures: { - contact_count: { - label: "\u8054\u7CFB\u4EBA\u6570" - } - } - }, - event_metrics: { - label: "\u6D3B\u52A8\u6307\u6807", - description: "\u7EDF\u8BA1\u4F1A\u8BAE\u3001\u901A\u8BDD\u4E0E\u4E92\u52A8\u65B0\u8FD1\u5EA6\u7684\u8BED\u4E49\u5C42", - dimensions: { - owner: { - label: "\u8D1F\u8D23\u4EBA" - }, - related_to_type: { - label: "\u5173\u8054\u5BF9\u8C61" - }, - start_datetime: { - label: "\u6D3B\u52A8\u5468" - }, - status: { - label: "\u72B6\u6001" - }, - type: { - label: "\u6D3B\u52A8\u7C7B\u578B" - } - }, - measures: { - avg_minutes: { - label: "\u5E73\u5747\u65F6\u957F" - }, - event_count: { - label: "\u6D3B\u52A8\u6570" - }, - total_minutes: { - label: "\u603B\u5206\u949F\u6570" - } - } - }, - forecast_metrics: { - label: "\u9500\u552E\u9884\u6D4B\u6307\u6807", - description: "\u6309\u8D1F\u8D23\u4EBA\u7EDF\u8BA1\u914D\u989D\u3001\u8FBE\u6210\u7387\u4E0E\u7BA1\u9053\u8986\u76D6\u500D\u6570\u7684\u8BED\u4E49\u5C42", - dimensions: { - owner: { - label: "\u8D1F\u8D23\u4EBA" - }, - period: { - label: "\u5468\u671F\u7C7B\u578B" - }, - period_label: { - label: "\u5468\u671F" - }, - period_start: { - label: "\u5468\u671F\u5F00\u59CB" - } - }, - measures: { - attainment: { - label: "\u8FBE\u6210\u7387" - }, - closed_sum: { - label: "\u5DF2\u6210\u4EA4" - }, - commit_sum: { - label: "\u627F\u8BFA" - }, - pipeline_sum: { - label: "\u9500\u552E\u7BA1\u9053" - }, - quota_sum: { - label: "\u914D\u989D" - } - } - }, - lead_metrics: { - label: "\u7EBF\u7D22\u6307\u6807", - description: "\u7EDF\u8BA1\u7EBF\u7D22\u6570\u91CF\u7684\u8BED\u4E49\u5C42", - dimensions: { - created_at: { - label: "\u521B\u5EFA\u65F6\u95F4" - }, - last_contacted_date: { - label: "\u6700\u8FD1\u8054\u7CFB" - }, - lead_source: { - label: "\u6765\u6E90" - }, - status: { - label: "\u72B6\u6001" - } - }, - measures: { - lead_count: { - label: "\u7EBF\u7D22\u6570" - } - } - }, - opportunity_metrics: { - label: "\u5546\u673A\u6307\u6807", - description: "\u7EDF\u8BA1\u9500\u552E\u7BA1\u9053\u6570\u91CF\u4E0E\u91D1\u989D\u7684\u8BED\u4E49\u5C42", - dimensions: { - account_industry: { - label: "\u5BA2\u6237\u884C\u4E1A" - }, - close_date: { - label: "\u9884\u8BA1\u6210\u4EA4\u65E5" - }, - close_quarter: { - label: "\u6210\u4EA4\u5B63\u5EA6" - }, - forecast_category: { - label: "\u9884\u6D4B\u7C7B\u522B" - }, - lead_source: { - label: "\u7EBF\u7D22\u6765\u6E90" - }, - loss_reason: { - label: "\u5931\u5355\u539F\u56E0" - }, - owner: { - label: "\u8D1F\u8D23\u4EBA" - }, - stage: { - label: "\u9636\u6BB5" - }, - type: { - label: "\u5546\u673A\u7C7B\u578B" - }, - win_reason: { - label: "\u8D62\u5355\u539F\u56E0" - } - }, - measures: { - avg_amount: { - label: "\u5E73\u5747\u5355\u7B14\u91D1\u989D" - }, - avg_probability: { - label: "\u5E73\u5747\u8D62\u5355\u6982\u7387" - }, - decided_count: { - label: "\u5DF2\u5B9A\u5C40\u5546\u673A" - }, - lost_amount: { - label: "\u5931\u5355\u91D1\u989D" - }, - lost_count: { - label: "\u5931\u5355\u6570" - }, - opp_count: { - label: "\u5546\u673A\u6570" - }, - total_amount: { - label: "\u603B\u91D1\u989D" - }, - win_rate: { - label: "\u8D62\u5355\u7387" - }, - won_amount: { - label: "\u8D62\u5355\u91D1\u989D" - }, - won_count: { - label: "\u8D62\u5355\u6570" - } - } - }, - product_metrics: { - label: "\u4EA7\u54C1\u6307\u6807", - description: "\u7EDF\u8BA1\u4EA7\u54C1\u76EE\u5F55\u6570\u91CF\u4E0E\u6807\u4EF7\u7684\u8BED\u4E49\u5C42", - dimensions: { - category: { - label: "\u7C7B\u522B" - } - }, - measures: { - list_price_sum: { - label: "\u6807\u4EF7\u5408\u8BA1" - }, - product_count: { - label: "\u4EA7\u54C1\u6570" - } - } - }, - task_metrics: { - label: "\u4EFB\u52A1\u6307\u6807", - description: "\u7EDF\u8BA1\u4EFB\u52A1\u5DE5\u4F5C\u91CF\u4E0E\u5B8C\u6210\u60C5\u51B5\u7684\u8BED\u4E49\u5C42", - dimensions: { - due_date: { - label: "\u622A\u6B62\u65E5\u671F" - }, - is_completed: { - label: "\u5DF2\u5B8C\u6210" - }, - is_overdue: { - label: "\u5DF2\u903E\u671F" - }, - priority: { - label: "\u4F18\u5148\u7EA7" - }, - priority_rank: { - label: "\u7D27\u6025\u5EA6" - }, - status: { - label: "\u72B6\u6001" - }, - type: { - label: "\u7C7B\u578B" - } - }, - measures: { - avg_progress: { - label: "\u5E73\u5747\u8FDB\u5EA6" - }, - task_count: { - label: "\u4EFB\u52A1\u6570" - } - } - } - }, - pages: { - account_detail_page: { - label: "\u5BA2\u6237\u8BE6\u60C5", - description: "\u63D2\u69FD\u5F0F\u5BA2\u6237\u8BB0\u5F55\u9875\u2014\u2014\u81EA\u5B9A\u4E49\u9875\u5934 + \u5E38\u9A7B\u8BA8\u8BBA\u533A\u3002", - title: "{name}", - subtitle: "{industry} \xB7 {type}", - components: { - account_chatter: { label: "\u8BA8\u8BBA" } - } - }, - account_workbench: { - label: "\u5BA2\u6237\u5DE5\u4F5C\u53F0", - description: "\u9762\u5411\u9500\u552E\u56E2\u961F\u7684\u7CBE\u9009\u5BA2\u6237\u5217\u8868\uFF1A\u4EC5\u63D0\u4F9B\u5FEB\u6377\u7B5B\u9009\uFF0C\u4E0D\u542B\u89C6\u56FE\u7BA1\u7406\u3002" - }, - app_launcher_page: { - label: "\u5E94\u7528\u4E2D\u5FC3", - description: "\u8BBF\u95EE\u5168\u90E8\u5E94\u7528\u7684\u7EDF\u4E00\u5165\u53E3", - subtitle: "\u9009\u62E9\u4E00\u4E2A\u5E94\u7528\u5F00\u59CB\u4F7F\u7528", - components: { - app_search: { label: "\u641C\u7D22\u5E94\u7528" }, - app_grid: { label: "\u5E94\u7528\u7F51\u683C" } - } - }, - case_detail_page: { - label: "\u5DE5\u5355\u8BE6\u60C5", - description: "\u5BA2\u670D\u5DE5\u5355\u8BB0\u5F55\u9875\uFF1A\u5173\u952E\u4FE1\u606F\u3001SLA \u8FDB\u5EA6\u3001\u660E\u7EC6\u4E0E\u6D3B\u52A8\u65F6\u95F4\u7EBF\u3002", - title: "{case_number} \xB7 {subject}", - subtitle: "{crm_account}", - components: { - case_highlights: { label: "\u5173\u952E\u4FE1\u606F" }, - case_status_path: { label: "\u5DE5\u5355\u72B6\u6001\u8FDB\u5EA6" }, - case_details: { label: "\u5DE5\u5355\u660E\u7EC6" } - } - }, - lead_detail_page: { - label: "\u7EBF\u7D22\u8BE6\u60C5", - description: "\u5B8C\u6574\u7684\u7EBF\u7D22\u8BE6\u60C5\u9875\uFF0C\u5305\u542B\u5173\u952E\u4FE1\u606F\u3001\u660E\u7EC6\u4E0E\u76F8\u5173\u8BB0\u5F55\u3002", - title: "{first_name} {last_name}", - subtitle: "{company}", - components: { - lead_duplicate_alert_confirmed: { label: "\u5DF2\u786E\u8BA4\u91CD\u590D\u63D0\u9192" }, - lead_duplicate_alert_suspected: { label: "\u7591\u4F3C\u91CD\u590D\u63D0\u9192" }, - lead_highlights: { label: "\u5173\u952E\u4FE1\u606F" }, - lead_path: { label: "\u7EBF\u7D22\u72B6\u6001\u8FDB\u5EA6" }, - main_tabs: { label: "\u7EBF\u7D22\u4FE1\u606F\u6807\u7B7E\u9875" }, - lead_details: { label: "\u7EBF\u7D22\u660E\u7EC6" }, - related_accordion: { label: "\u76F8\u5173\u8BB0\u5F55" }, - related_tasks: { title: "\u5F85\u529E\u4EFB\u52A1", label: "\u4EFB\u52A1" }, - lead_activity: { label: "\u6D3B\u52A8\u65F6\u95F4\u7EBF" }, - lead_history: { label: "\u5B57\u6BB5\u5386\u53F2" } - } - }, - opportunity_detail_page: { - label: "\u5546\u673A\u8BE6\u60C5", - description: "\u5B8C\u6574\u7684\u5546\u673A\u8BE6\u60C5\u9875\uFF0C\u5305\u542B\u9636\u6BB5\u8FDB\u5EA6\u3001\u5173\u952E\u4FE1\u606F\u3001\u660E\u7EC6\u4E0E\u76F8\u5173\u5217\u8868\u3002", - title: "{name}", - subtitle: "{crm_account}", - components: { - opp_highlights: { label: "\u5173\u952E\u4FE1\u606F" }, - opp_stage_path: { label: "\u5546\u673A\u9636\u6BB5\u8FDB\u5EA6" }, - opp_details: { label: "\u5546\u673A\u660E\u7EC6" } - } - }, - sales_home_page: { - label: "\u9500\u552E\u4E3B\u9875", - description: "\u9500\u552E\u56E2\u961F\u4E3B\u9875\uFF0C\u6C47\u603B\u5173\u952E\u6307\u6807\u4E0E\u5FEB\u6377\u64CD\u4F5C", - title: "\u9500\u552E\u770B\u677F", - subtitle: "\u6B22\u8FCE\u56DE\u6765", - components: { - kpi_revenue_won: { - label: "\u8D62\u5355\u8425\u6536" - }, - kpi_deals_won: { - label: "\u8D62\u5355\u6570" - }, - kpi_pipeline_value: { - label: "\u9500\u552E\u7BA1\u9053\u91D1\u989D" - }, - kpi_open_leads: { - label: "\u5F00\u653E\u7EBF\u7D22" - }, - home_upcoming_events: { - label: "\u{1F4C5} \u5373\u5C06\u5F00\u59CB \xB7 \u6700\u8FD1\u4F18\u5148" - }, - quick_create: { title: "\u5FEB\u901F\u521B\u5EFA", label: "\u5FEB\u901F\u521B\u5EFA" }, - key_metrics: { title: "\u5173\u952E\u7EE9\u6548\u6307\u6807", label: "\u5173\u952E\u6307\u6807" }, - home_tabs: { label: "\u4E3B\u9875\u6807\u7B7E\u9875" }, - home_my_leads: { label: "\u6211\u7684\u7EBF\u7D22" }, - home_my_deals: { label: "\u6211\u7684\u8FDB\u884C\u4E2D\u5546\u673A" }, - home_my_tasks: { label: "\u6211\u7684\u5F85\u529E\u4EFB\u52A1" }, - ai_briefing: { - title: "\u8BE2\u95EE AI \u52A9\u624B", - label: "AI \u52A9\u624B\u4ECA\u65E5\u901F\u89C8" - }, - upcoming_events: { title: "\u5373\u5C06\u5F00\u59CB\u7684\u6D3B\u52A8", label: "\u5373\u5C06\u5F00\u59CB\u7684\u6D3B\u52A8" } - } - }, - utility_bar_page: { - label: "\u5DE5\u5177\u680F", - description: "\u60AC\u6D6E\u5DE5\u5177\u7684\u5FEB\u6377\u8BBF\u95EE\u680F", - components: { - notifications_panel: { label: "\u901A\u77E5" }, - quick_notes: { title: "\u5FEB\u901F\u7B14\u8BB0", label: "\u5FEB\u901F\u7B14\u8BB0" }, - quick_search: { label: "\u5FEB\u901F\u641C\u7D22" } - } - } - }, - // Screen-flow copy (#1210, #1975). Keyed `flows..label`, - // `screens..title` and `screens..fields..{label,placeholder}` - // — the keys `os lint`'s `i18n/missing-flow` names, read by the console's - // flow runner since @objectstack 17.7.0 (the spec's `flows` liveness row is - // `live` there). A screen with no authored `title` shows its flow's label in - // every locale, so each `screen_1.title` repeats the flow label. Since - // 18.0.0-next.0 three more surfaces are keys the engine reads in the run's - // locale, and `i18n/missing-flow` names each missing one: a select field's - // `options.` (worded as the object field's own option in this pack), - // an authored screen `description`, and a refusing `end` node's - // `refusals..message`. A translated description or message is a text - // slot like the one it translates, so a hole in it is `{{ }}`. - // The discount ceiling is interpolated from `QUOTE_DISCOUNT_CEILING`, never - // retyped: the number lives in `_thresholds.ts` alone (#1711). - flows: { - campaign_enrollment: { - label: "\u5C06\u6210\u5458\u52A0\u5165\u8425\u9500\u6D3B\u52A8", - screens: { - screen_1: { - title: "\u5C06\u6210\u5458\u52A0\u5165\u8425\u9500\u6D3B\u52A8", - fields: { - memberSource: { label: "\u52A0\u5165\u7684\u6210\u5458\u7C7B\u578B", options: { leads: "\u7EBF\u7D22", contacts: "\u8054\u7CFB\u4EBA" } }, - leadStatus: { label: "\u52A0\u5165\u4EE5\u4E0B\u72B6\u6001\u7684\u7EBF\u7D22", options: { new: "\u65B0\u5EFA", contacted: "\u5DF2\u8054\u7CFB", qualified: "\u5DF2\u786E\u8BA4" } }, - contactDepartment: { - label: "\u52A0\u5165\u4EE5\u4E0B\u90E8\u95E8\u7684\u8054\u7CFB\u4EBA", - options: { executive: "\u7BA1\u7406\u5C42", sales: "\u9500\u552E\u90E8", marketing: "\u5E02\u573A\u90E8", engineering: "\u5DE5\u7A0B\u90E8", support: "\u652F\u6301\u90E8", finance: "\u8D22\u52A1\u90E8", hr: "\u4EBA\u529B\u8D44\u6E90", operations: "\u8FD0\u8425\u90E8" } - } - } - } - } - }, - escalate_case: { - label: "\u5347\u7EA7\u5DE5\u5355", - screens: { screen_1: { title: "\u5347\u7EA7\u5DE5\u5355", fields: { reason: { label: "\u5347\u7EA7\u539F\u56E0" } } } } - }, - close_case: { - label: "\u5173\u95ED\u5DE5\u5355", - screens: { - screen_1: { - title: "\u5173\u95ED\u5DE5\u5355", - fields: { - resolution: { label: "\u89E3\u51B3\u65B9\u6848" }, - resolved_by_article: { label: "\u901A\u8FC7\u77E5\u8BC6\u6587\u7AE0\u89E3\u51B3\uFF08\u53EF\u9009\uFF09" } - } - } - } - }, - claim_case: { - label: "\u8BA4\u9886\u5DE5\u5355", - screens: { - screen_1: { - title: "\u8BA4\u9886\u5DE5\u5355", - fields: { - claimStatus: { - label: "\u5904\u7406\u72B6\u6001", - options: { in_progress: "\u5904\u7406\u4E2D", waiting_customer: "\u7B49\u5F85\u5BA2\u6237\u56DE\u590D", waiting_support: "\u7B49\u5F85\u652F\u6301\u56DE\u590D" } - } - } - } - } - }, - lead_conversion: { - label: "\u7EBF\u7D22\u8F6C\u5316\u6D41\u7A0B", - screens: { - screen_1: { - title: "\u7EBF\u7D22\u8F6C\u5316\u6D41\u7A0B", - // The duplicate warning's text is a variable the flow assigns; this - // key can only carry the hole that shows it. - description: "{{duplicateWarning}}", - fields: { - createOpportunity: { label: "\u662F\u5426\u521B\u5EFA\u5546\u673A\uFF1F" }, - opportunityName: { label: "\u5546\u673A\u540D\u79F0" }, - opportunityAmount: { label: "\u5546\u673A\u91D1\u989D" }, - closeDate: { label: "\u9884\u8BA1\u6210\u4EA4\u65E5\u671F" } - } - }, - refuse_confirmed_duplicate: { - title: "\u8F6C\u5316\u88AB\u62D2\u7EDD", - description: "\u8BE5\u7EBF\u7D22\u7684\u300C\u91CD\u590D\u72B6\u6001\u300D\u4E3A\u300C\u5DF2\u786E\u8BA4\u91CD\u590D\u300D\uFF1A\u5BA1\u6838\u4EBA\u5DF2\u5C06\u5176\u4E0E\u73B0\u6709\u8BB0\u5F55\u6BD4\u5BF9\uFF0C\u5E76\u8BB0\u5F55\u4E3A\u91CD\u590D\u3002\u8F6C\u5316\u4F1A\u4E3A\u540C\u4E00\u4E70\u5BB6\u518D\u521B\u5EFA\u4E00\u4E2A\u5BA2\u6237\u3001\u8054\u7CFB\u4EBA\u548C\u5546\u673A\u3002\u672C\u7EBF\u7D22\u7684\u300C\u91CD\u590D\u7EBF\u7D22\u7BA1\u7406\u300D\u90E8\u5206\u5217\u51FA\u4E86\u4FDD\u7559\u7684\u8BB0\u5F55\uFF1B\u8BF7\u6539\u4E3A\u4EE5\u91CD\u590D\u4E3A\u7531\u5C06\u6B64\u7EBF\u7D22\u8BBE\u4E3A\u300C\u672A\u901A\u8FC7\u300D\u3002\u53EA\u6709\u5BA1\u6838\u4EBA\u4FEE\u6539\u8BE5\u7ED3\u8BBA\u540E\u624D\u80FD\u91CD\u65B0\u8F6C\u5316\u3002" - }, - refuse_unapproved: { - title: "\u8F6C\u5316\u88AB\u62D2\u7EDD", - description: "\u8BE5\u7EBF\u7D22\u5C1A\u672A\u83B7\u51C6\u8F6C\u5316\u3002\u5FC5\u987B\u7531\u5BA1\u6279\u4EBA\u6279\u51C6\u540E\uFF0C\u624D\u80FD\u8F6C\u5316\u4E3A\u5BA2\u6237\u3001\u8054\u7CFB\u4EBA\u548C\u5546\u673A\uFF1B\u7EBF\u7D22\u4E0A\u7684\u300C\u8F6C\u5316\u5BA1\u6279\u300D\u5B57\u6BB5\u663E\u793A\u8BE5\u51B3\u5B9A\u4ECD\u5728\u5F85\u5BA1\u6279\u8FD8\u662F\u5DF2\u88AB\u9A73\u56DE\u3002\u5728\u6B64\u671F\u95F4\u8BF7\u7EE7\u7EED\u8DDF\u8FDB\u8BE5\u7EBF\u7D22\u2014\u2014\u5B83\u7684\u4EFB\u4F55\u5185\u5BB9\u90FD\u6CA1\u6709\u88AB\u51BB\u7ED3\u3002" - }, - refuse_no_match_key: { - title: "\u8F6C\u5316\u88AB\u62D2\u7EDD", - description: "\u8BE5\u7EBF\u7D22\u7684\u516C\u53F8\u6CA1\u6709\u5339\u914D\u952E\uFF0C\u56E0\u6B64\u8F6C\u5316\u65E0\u6CD5\u5224\u65AD\u5B83\u5C5E\u4E8E\u54EA\u4E2A\u5BA2\u6237\uFF0C\u4E5F\u4E0D\u4F1A\u53BB\u731C\u6D4B\uFF1A\u731C\u6D4B\u53EF\u80FD\u4F1A\u628A\u8054\u7CFB\u4EBA\u548C\u5546\u673A\u5F52\u5230\u53E6\u4E00\u4E2A\u5BA2\u6237\u540D\u4E0B\u3002\u4FDD\u5B58\u7EBF\u7D22\u7684\u300C\u516C\u53F8\u300D\u4F1A\u91CD\u65B0\u751F\u6210\u5339\u914D\u952E\uFF0C\u8BF7\u91CD\u65B0\u4FDD\u5B58\u540E\u518D\u8F6C\u5316\u3002\u5C1A\u672A\u521B\u5EFA\u4EFB\u4F55\u8BB0\u5F55\u3002" - } - } - }, - schedule_followup: { - label: "\u5B89\u6392\u8DDF\u8FDB", - screens: { - screen_1: { - title: "\u5B89\u6392\u8DDF\u8FDB", - fields: { - subject: { label: "\u4E0B\u4E00\u6B65\u505A\u4EC0\u4E48\uFF1F" }, - dueDate: { label: "\u622A\u6B62\u65E5\u671F" }, - activityType: { - label: "\u6D3B\u52A8\u7C7B\u578B", - options: { call: "\u7535\u8BDD", email: "\u90AE\u4EF6", meeting: "\u4F1A\u8BAE", follow_up: "\u8DDF\u8FDB", demo: "\u6F14\u793A", other: "\u5176\u4ED6" } - }, - priority: { label: "\u4F18\u5148\u7EA7", options: { low: "\u4F4E", normal: "\u666E\u901A", high: "\u9AD8", urgent: "\u7D27\u6025" } }, - notes: { label: "\u5907\u6CE8" } - } - } - } - }, - quote_generation: { - label: "\u4ECE\u5546\u673A\u751F\u6210\u62A5\u4EF7\u5355", - refusals: { refuse_held: { message: "\u9700\u5148\u5B8C\u6210\u7ACB\u9879\u5BA1\u6279\uFF1A\u8BF7\u52FE\u9009\u300C\u7533\u8BF7\u7ACB\u9879\u5BA1\u6279\u300D\u3002\u5C1A\u672A\u521B\u5EFA\u4EFB\u4F55\u5185\u5BB9\u3002" } }, - screens: { - screen_1: { - title: "\u4ECE\u5546\u673A\u751F\u6210\u62A5\u4EF7\u5355", - fields: { - quoteName: { label: "\u62A5\u4EF7\u540D\u79F0" }, - expirationDays: { label: "\u6709\u6548\u671F\uFF08\u5929\uFF09" }, - discount: { label: `\u6298\u6263 % (\u2264 ${QUOTE_DISCOUNT_CEILING})`, placeholder: `0-${QUOTE_DISCOUNT_CEILING}` } - } - } - } - } - } -}; - -// src/sales/translations/zh-CN/_shared.ts -var activityActions2 = { - log_call: { - label: "\u8BB0\u5F55\u901A\u8BDD", - successMessage: "\u901A\u8BDD\u8BB0\u5F55\u6210\u529F\uFF01", - params: { - subject: { label: "\u901A\u8BDD\u4E3B\u9898" }, - duration: { label: "\u65F6\u957F\uFF08\u5206\u949F\uFF09" }, - attendee_contacts: { label: "\u8054\u7CFB\u4EBA\u53C2\u4E0E\u8005" }, - attendee_users: { label: "\u5185\u90E8\u53C2\u4E0E\u8005" }, - notes: { label: "\u901A\u8BDD\u8BB0\u5F55" } - } - }, - log_meeting: { - label: "\u8BB0\u5F55\u4F1A\u8BAE", - successMessage: "\u4F1A\u8BAE\u8BB0\u5F55\u6210\u529F\uFF01", - params: { - subject: { label: "\u4F1A\u8BAE\u4E3B\u9898" }, - duration: { label: "\u65F6\u957F\uFF08\u5206\u949F\uFF09" }, - attendee_contacts: { label: "\u8054\u7CFB\u4EBA\u53C2\u4F1A\u4EBA" }, - attendee_users: { label: "\u5185\u90E8\u53C2\u4F1A\u4EBA" }, - notes: { label: "\u4F1A\u8BAE\u7EAA\u8981" } - } - }, - schedule_meeting: { - label: "\u5B89\u6392\u4F1A\u8BAE", - successMessage: "\u4F1A\u8BAE\u5DF2\u5B89\u6392\uFF01", - params: { - subject: { label: "\u4F1A\u8BAE\u4E3B\u9898" }, - start_date: { label: "\u5F00\u59CB\u65E5\u671F\uFF08UTC\uFF09" }, - start_time: { label: "\u5F00\u59CB\u65F6\u95F4\uFF08UTC\uFF09" }, - location: { label: "\u5730\u70B9" }, - duration: { label: "\u65F6\u957F\uFF08\u5206\u949F\uFF09" }, - attendee_contacts: { label: "\u8054\u7CFB\u4EBA\u53C2\u4F1A\u4EBA" }, - attendee_users: { label: "\u5185\u90E8\u53C2\u4F1A\u4EBA" }, - notes: { label: "\u4F1A\u8BAE\u8BAE\u7A0B" } - } - } -}; - -// src/sales/translations/zh-CN/objects.customer.ts -var customer2 = { - crm_account: { - label: "\u5BA2\u6237", - pluralLabel: "\u5BA2\u6237", - description: "\u4E0E\u6211\u4EEC\u6709\u4E1A\u52A1\u5F80\u6765\u7684\u516C\u53F8\u548C\u7EC4\u7EC7", - fields: { - account_number: { label: "\u5BA2\u6237\u7F16\u53F7" }, - registration_number: { - label: "\u767B\u8BB0\u8BC1\u4EF6\u53F7", - help: "\u5BF9\u65B9\u5728\u5176\u6240\u5C5E\u653F\u5E9C\u767B\u8BB0\u673A\u5173\u53D6\u5F97\u7684\u767B\u8BB0\u6807\u8BC6\u3002\u4E0D\u540C\u4E8E\u7531\u6211\u65B9\u53D1\u653E\u7684\u5BA2\u6237\u7F16\u53F7\u3002" - }, - commercial_capability: { - label: "\u5546\u52A1\u80FD\u529B", - help: "\u8BE5\u5BA2\u6237\u662F\u5426\u53EF\u4EE5\u627F\u63A5\u65B0\u4E1A\u52A1\u3002\u4EC5\u7ED3\u7B97\u7C7B\u5BA2\u6237\u4F9D\u7136\u53EF\u7528\u4E8E\u5F00\u7968\u4E0E\u6536\u4ED8\u6B3E\uFF0C\u4F46\u4E0D\u80FD\u5173\u8054\u65B0\u7684\u5546\u673A\u3002", - options: { full: "\u5B8C\u6574", settlement_only: "\u4EC5\u7ED3\u7B97" } - }, - incumbent_vendor: { label: "\u73B0\u6709\u4F9B\u5E94\u5546", help: "\u5F53\u524D\u627F\u63A5\u8BE5\u5BA2\u6237\u8FD9\u90E8\u5206\u652F\u51FA\u7684\u4F9B\u5E94\u5546\u3002" }, - annual_purchasing_budget: { label: "\u5E74\u5EA6\u91C7\u8D2D\u9884\u7B97", help: "\u8BE5\u5BA2\u6237\u672C\u5E74\u5EA6\u9884\u8BA1\u5411\u4F9B\u5E94\u5546\u652F\u51FA\u7684\u91D1\u989D\uFF0C\u800C\u975E\u5176\u81EA\u8EAB\u8425\u6536\u3002" }, - payment_cycle: { - label: "\u4ED8\u6B3E\u5468\u671F", - options: { prepaid: "\u9884\u4ED8", net_30: "30 \u5929", net_60: "60 \u5929", net_90: "90 \u5929" } - }, - approval_status: { - label: "\u5BA1\u6279\u72B6\u6001", - help: "\u8BE5\u5BA2\u6237\u7684\u5BA1\u6279\u8FDB\u5C55\u3002\u65B0\u5EFA\u5BA2\u6237\u521D\u59CB\u4E3A\u5F85\u5BA1\u6279\uFF0C\u5E76\u5728\u5BA1\u6279\u6536\u4EF6\u7BB1\u4E2D\u88C1\u5B9A\u3002", - options: { pending: "\u5F85\u5BA1\u6279", approved: "\u5DF2\u901A\u8FC7", rejected: "\u5DF2\u9A73\u56DE" } - }, - name: { label: "\u5BA2\u6237\u540D\u79F0", help: "\u516C\u53F8\u6216\u7EC4\u7EC7\u7684\u6CD5\u5B9A\u540D\u79F0" }, - type: { - label: "\u7C7B\u578B", - options: { prospect: "\u6F5C\u5728\u5BA2\u6237", customer: "\u6B63\u5F0F\u5BA2\u6237", partner: "\u5408\u4F5C\u4F19\u4F34", former: "\u524D\u5BA2\u6237" } - }, - industry: { - label: "\u884C\u4E1A", - options: { - technology: "\u79D1\u6280", - software: "\u8F6F\u4EF6 / SaaS", - finance: "\u91D1\u878D", - healthcare: "\u533B\u7597", - retail: "\u96F6\u552E", - manufacturing: "\u5236\u9020", - education: "\u6559\u80B2", - real_estate: "\u623F\u5730\u4EA7", - media: "\u4F20\u5A92\u5A31\u4E50", - logistics: "\u7269\u6D41", - hospitality: "\u9152\u5E97\u65C5\u6E38", - energy: "\u80FD\u6E90\u516C\u7528\u4E8B\u4E1A", - government: "\u653F\u5E9C", - nonprofit: "\u975E\u8425\u5229", - other: "\u5176\u4ED6" - } - }, - annual_revenue: { label: "\u5E74\u8425\u6536" }, - child_account_revenue: { label: "\u5B50\u516C\u53F8\u5E74\u8425\u6536\u5408\u8BA1", help: "\u672C\u5BA2\u6237\u76F4\u5C5E\u5B50\u516C\u53F8\u7684\u5E74\u8425\u6536\u5408\u8BA1\u3002" }, - number_of_employees: { label: "\u5458\u5DE5\u4EBA\u6570" }, - phone: { label: "\u7535\u8BDD" }, - website: { label: "\u7F51\u7AD9" }, - billing_address: { label: "\u8D26\u5355\u5730\u5740" }, - billing_country: { - label: "\u8D26\u5355\u56FD\u5BB6", - help: "\u7531\u8D26\u5355\u5730\u5740\u63A8\u5BFC\u2014\u2014\u6309\u5F55\u5165\u539F\u6837\u53BB\u9664\u9996\u5C3E\u7A7A\u683C\u5E76\u8F6C\u4E3A\u5927\u5199\u3002" - }, - territory: { - label: "\u9500\u552E\u533A\u57DF", - help: "\u7531\u8D26\u5355\u5730\u5740\u63A8\u5BFC\u2014\u2014\u533A\u57DF\u5171\u4EAB\u89C4\u5219\u636E\u6B64\u5339\u914D\u3002\u4E0D\u5C5E\u4E8E\u5DF2\u914D\u7F6E\u533A\u57DF\u7684\u5BA2\u6237\u4E3A\u201C\u5176\u4ED6\u201D\u3002", - options: { na: "\u5317\u7F8E", emea: "\u6B27\u6D32\u3001\u4E2D\u4E1C\u4E0E\u975E\u6D32", other: "\u5176\u4ED6" } - }, - office_location: { label: "\u529E\u516C\u5730\u70B9" }, - owner_id: { label: "\u5BA2\u6237\u8D1F\u8D23\u4EBA" }, - parent_account: { label: "\u6BCD\u516C\u53F8", help: "\u5C42\u7EA7\u7ED3\u6784\u4E2D\u7684\u6BCD\u516C\u53F8" }, - description: { label: "\u63CF\u8FF0" }, - is_active: { label: "\u662F\u5426\u6D3B\u8DC3" }, - last_activity_date: { label: "\u6700\u8FD1\u6D3B\u52A8\u65E5\u671F" }, - brand_color: { label: "\u54C1\u724C\u8272" }, - logo: { label: "\u516C\u53F8\u6807\u8BC6" }, - tier: { - label: "\u5BA2\u6237\u5206\u5C42", - options: { strategic: "\u6218\u7565\u5BA2\u6237", enterprise: "\u4F01\u4E1A\u5BA2\u6237", mid_market: "\u4E2D\u578B\u5BA2\u6237", smb: "\u4E2D\u5C0F\u5BA2\u6237" } - }, - segment: { - label: "\u5BA2\u6237\u7EC6\u5206", - options: { net_new: "\u5168\u65B0\u5BA2\u6237", growth: "\u589E\u957F\u5BA2\u6237", at_risk: "\u98CE\u9669\u5BA2\u6237", stable: "\u7A33\u5B9A\u5BA2\u6237" } - }, - health_score: { - label: "\u5065\u5EB7\u5EA6", - help: "\u5BA2\u6237\u6210\u529F\u7ECF\u7406\u7EF4\u62A4\u7684\u5065\u5EB7\u5EA6\u6307\u6807", - options: { healthy: "\u5065\u5EB7", watching: "\u5173\u6CE8", at_risk: "\u98CE\u9669", churning: "\u6D41\u5931\u4E2D" } - }, - name_normalized: { label: "\u5BA2\u6237\u540D\u79F0\uFF08\u89C4\u8303\u5316\uFF09", help: "\u7EBF\u7D22\u8F6C\u5316\u7684\u5339\u914D\u952E\uFF1A\u5BA2\u6237\u540D\u79F0\u8F6C\u5C0F\u5199\u3001\u53BB\u9664\u9996\u5C3E\u7A7A\u683C\u3001\u5185\u90E8\u8FDE\u7EED\u7A7A\u767D\u5408\u5E76\u4E3A\u4E00\u4E2A\u7A7A\u683C\u3002\u7531 account_protection \u94A9\u5B50\u7EF4\u62A4\u2014\u2014\u8BF7\u52FF\u76F4\u63A5\u7F16\u8F91\u3002" }, - display_title: { label: "\u663E\u793A\u540D\u79F0" } - }, - _views: { - all_accounts: { - label: "\u5168\u90E8\u5BA2\u6237", - description: "\u5BA2\u6237\u4E3B\u5217\u8868\uFF0C\u5305\u542B\u8425\u6536\u4E0E\u884C\u4E1A\u6458\u8981", - bulkActions: { - delete: { - label: "\u5220\u9664", - confirmLabel: "\u5220\u9664", - confirmText: "\u786E\u5B9A\u8981\u6C38\u4E45\u5220\u9664 {{count}} \u4E2A\u5BA2\u6237\u5417\uFF1F\u6B64\u64CD\u4F5C\u65E0\u6CD5\u64A4\u9500\u3002" - }, - transfer_owner: { - label: "\u8F6C\u79FB\u8D1F\u8D23\u4EBA", - confirmText: "\u786E\u5B9A\u8981\u8F6C\u79FB {{count}} \u4E2A\u5BA2\u6237\u7684\u8D1F\u8D23\u4EBA\u5417\uFF1F", - params: { - owner_id: { - label: "\u65B0\u8D1F\u8D23\u4EBA" - } - } - }, - update_tier: { - label: "\u66F4\u65B0\u5BA2\u6237\u7B49\u7EA7", - confirmText: "\u786E\u5B9A\u8981\u5C06 {{count}} \u4E2A\u5BA2\u6237\u7684\u7B49\u7EA7\u66F4\u65B0\u4E3A {{tier}} \u5417\uFF1F", - params: { - tier: { - label: "\u5BA2\u6237\u7B49\u7EA7" - } - } - } - } - }, - account_gallery: { label: "\u5BA2\u6237\u5361\u7247", description: "\u4F7F\u7528\u54C1\u724C\u8272\u9AD8\u4EAE\u7684\u5BA2\u6237\u5361\u7247\u89C6\u56FE" }, - account_map: { label: "\u5BA2\u6237\u5730\u56FE", description: "\u5BA2\u6237\u7684\u5730\u7406\u5206\u5E03" }, - enterprise_accounts: { label: "\u4F01\u4E1A\u5BA2\u6237", description: "\u5E74\u8425\u6536\u6700\u9AD8\u7684\u5927\u5BA2\u6237" }, - my_accounts: { label: "\u6211\u7684\u5BA2\u6237", description: "\u7531\u5F53\u524D\u7528\u6237\u8D1F\u8D23\u7684\u5BA2\u6237" }, - at_risk_accounts: { label: "\u26A0\uFE0F \u98CE\u9669\u5BA2\u6237" } - }, - _sections: { - basic: { label: "\u57FA\u672C\u4FE1\u606F" }, - financials: { label: "\u8D22\u52A1\u4FE1\u606F" }, - business_profile: { label: "\u4E1A\u52A1\u4FE1\u606F" }, - contact_info: { label: "\u8054\u7CFB\u4FE1\u606F" }, - ownership: { label: "\u5F52\u5C5E\u4E0E\u72B6\u6001" }, - branding: { label: "\u54C1\u724C" }, - system: { label: "\u7CFB\u7EDF" }, - // account.view.ts 表单区块名称 (#1100) - profile: { label: "\u8D44\u6599" }, - customer_success: { label: "\u5BA2\u6237\u6210\u529F" }, - locations: { label: "\u5730\u5740\u4FE1\u606F" }, - description: { label: "\u63CF\u8FF0" } - }, - _actions: { ...activityActions2 } - }, - crm_contact: { - label: "\u8054\u7CFB\u4EBA", - pluralLabel: "\u8054\u7CFB\u4EBA", - description: "\u5BA2\u6237\u4E0E\u5546\u673A\u7684\u5173\u952E\u4EBA\u7269\u8054\u7CFB\u4EBA", - fields: { - salutation: { - label: "\u79F0\u8C13", - options: { mr: "\u5148\u751F", ms: "\u5973\u58EB", mrs: "\u592B\u4EBA", dr: "\u535A\u58EB", prof: "\u6559\u6388" } - }, - first_name: { label: "\u540D" }, - last_name: { label: "\u59D3" }, - full_name: { label: "\u5168\u540D" }, - crm_account: { label: "\u6240\u5C5E\u5BA2\u6237" }, - email: { label: "\u90AE\u7BB1" }, - phone: { label: "\u7535\u8BDD" }, - mobile: { label: "\u624B\u673A" }, - title: { label: "\u804C\u4F4D" }, - department: { - label: "\u90E8\u95E8", - options: { - executive: "\u7BA1\u7406\u5C42", - sales: "\u9500\u552E\u90E8", - marketing: "\u5E02\u573A\u90E8", - engineering: "\u5DE5\u7A0B\u90E8", - support: "\u652F\u6301\u90E8", - finance: "\u8D22\u52A1\u90E8", - hr: "\u4EBA\u529B\u8D44\u6E90", - operations: "\u8FD0\u8425\u90E8" - } - }, - // 采购决策圈 (REQ-0004)。英文标签是 'Buying Function' 而非 'Buying Role'： - // 平台的 security-role-word 规则在对象声明上保留了英文 role 一词（ADR-0090 D3）。 - // 该规则只匹配英文，不读语言包，所以中文这里用本地读者真正在说的词。 - buying_function: { - label: "\u91C7\u8D2D\u89D2\u8272", - options: { - decision_maker: "\u51B3\u7B56\u8005", - economic_buyer: "\u9884\u7B97\u51B3\u7B56\u4EBA", - technical_evaluator: "\u6280\u672F\u8BC4\u4F30\u4EBA", - user: "\u4F7F\u7528\u8005", - influencer: "\u5F71\u54CD\u8005", - gatekeeper: "\u5B88\u95E8\u4EBA" - } - }, - attitude: { - label: "\u5BF9\u6211\u53F8\u6001\u5EA6", - options: { - champion: "\u62E5\u62A4\u8005", - supportive: "\u652F\u6301", - neutral: "\u4E2D\u7ACB", - skeptical: "\u5B58\u7591", - blocker: "\u53CD\u5BF9\u8005" - } - }, - relationship_strength: { - label: "\u4E0E\u9500\u552E\u5173\u7CFB\u5F3A\u5EA6", - options: { - distant: "\u758F\u8FDC", - acquaintance: "\u4E00\u822C\u8BA4\u8BC6", - working: "\u5DE5\u4F5C\u5F80\u6765", - strong: "\u5173\u7CFB\u7D27\u5BC6", - trusted_advisor: "\u53EF\u4FE1\u987E\u95EE" - } - }, - owner_id: { label: "\u8054\u7CFB\u4EBA\u8D1F\u8D23\u4EBA" }, - description: { label: "\u63CF\u8FF0" }, - is_primary: { label: "\u4E3B\u8981\u8054\u7CFB\u4EBA", help: "\u662F\u5426\u4E3A\u8BE5\u5BA2\u6237\u7684\u4E3B\u8981\u8054\u7CFB\u4EBA\uFF1F" }, - mailing_address: { label: "\u90AE\u5BC4\u5730\u5740" }, - lead_source: { - label: "\u7EBF\u7D22\u6765\u6E90", - options: { - web: "\u7F51\u7AD9", - referral: "\u63A8\u8350", - event: "\u6D3B\u52A8 / \u5C55\u4F1A", - webinar: "\u7EBF\u4E0A\u7814\u8BA8\u4F1A", - partner: "\u5408\u4F5C\u4F19\u4F34", - advertisement: "\u5E7F\u544A", - paid_search: "\u4ED8\u8D39\u641C\u7D22", - social: "\u793E\u4EA4\u5A92\u4F53", - content: "\u5185\u5BB9 / \u535A\u5BA2", - cold_call: "\u964C\u751F\u62DC\u8BBF", - email_campaign: "\u90AE\u4EF6\u8425\u9500", - other: "\u5176\u4ED6" - } - }, - do_not_call: { label: "\u7981\u6B62\u81F4\u7535" }, - email_opt_out: { label: "\u62D2\u7EDD\u90AE\u4EF6" }, - last_contacted_date: { label: "\u6700\u8FD1\u8054\u7CFB\u65F6\u95F4" }, - avatar: { label: "\u5934\u50CF" } - }, - _views: { - all_contacts: { label: "\u5168\u90E8\u8054\u7CFB\u4EBA" }, - contact_directory: { label: "\u8054\u7CFB\u4EBA\u76EE\u5F55" }, - primary_contacts: { label: "\u4E3B\u8981\u8054\u7CFB\u4EBA" } - }, - _actions: { - ...activityActions2, - mark_primary: { - label: "\u8BBE\u4E3A\u4E3B\u8981\u8054\u7CFB\u4EBA", - confirmText: "\u662F\u5426\u5C06\u6B64\u8054\u7CFB\u4EBA\u8BBE\u4E3A\u8BE5\u5BA2\u6237\u7684\u4E3B\u8981\u8054\u7CFB\u4EBA\uFF1F", - successMessage: "\u5DF2\u8BBE\u4E3A\u4E3B\u8981\u8054\u7CFB\u4EBA\uFF01" - }, - send_email: { - label: "\u53D1\u9001\u90AE\u4EF6", - params: { - subject: { label: "\u4E3B\u9898" }, - body: { label: "\u6B63\u6587" } - } - }, - add_contact_to_campaign: { - label: "\u52A0\u5165\u8425\u9500\u6D3B\u52A8", - successMessage: "\u8054\u7CFB\u4EBA\u5DF2\u52A0\u5165\u8425\u9500\u6D3B\u52A8\uFF01", - params: { - crm_campaign: { label: "\u8425\u9500\u6D3B\u52A8" } - } - } - }, - _sections: { - identity: { label: "\u8EAB\u4EFD\u4FE1\u606F" }, - account_info: { label: "\u5BA2\u6237\u4E0E\u804C\u52A1" }, - buying_centre: { label: "\u91C7\u8D2D\u51B3\u7B56\u5708" }, - contact_info: { label: "\u8054\u7CFB\u65B9\u5F0F" }, - mailing_address: { label: "\u90AE\u5BC4\u5730\u5740" }, - additional: { label: "\u9644\u52A0\u4FE1\u606F" }, - preferences: { label: "\u6C9F\u901A\u504F\u597D" }, - // contact.view.ts 表单区块名称 (#1100) - contact_details: { label: "\u8054\u7CFB\u4FE1\u606F" }, - comm_preferences: { label: "\u504F\u597D\u8BBE\u7F6E" } - } - } -}; - -// src/sales/translations/zh-CN/objects.pipeline.ts -var pipeline2 = { - crm_lead: { - _validations: { - disqualification_reason_required: { - message: "\u7EBF\u7D22\u6807\u8BB0\u4E3A\u4E0D\u5408\u683C\u65F6\u5FC5\u987B\u586B\u5199\u53D6\u6D88\u8D44\u683C\u539F\u56E0" - }, - duplicate_disqualification_requires_survivor: { - message: "\u4EE5\u91CD\u590D\u4E3A\u7531\u53D6\u6D88\u7EBF\u7D22\u8D44\u683C\u65F6\uFF0C\u5FC5\u987B\u6307\u660E\u4FDD\u7559\u7684\u8BB0\u5F55\u5E76\u5C06\u91CD\u590D\u72B6\u6001\u8BBE\u4E3A\u5DF2\u786E\u8BA4" - }, - email_required: { - message: "\u7535\u5B50\u90AE\u4EF6\u4E3A\u5FC5\u586B\u9879" - }, - lead_status_progression: { - message: "\u65E0\u6548\u7684\u7EBF\u7D22\u72B6\u6001\u6D41\u8F6C" - } - }, - label: "\u7EBF\u7D22", - pluralLabel: "\u7EBF\u7D22", - description: "\u5C1A\u672A\u786E\u8BA4\u7684\u6F5C\u5728\u5BA2\u6237", - fields: { - salutation: { - label: "\u79F0\u8C13", - options: { mr: "\u5148\u751F", ms: "\u5973\u58EB", mrs: "\u592B\u4EBA", dr: "\u535A\u58EB", prof: "\u6559\u6388" } - }, - first_name: { label: "\u540D" }, - last_name: { label: "\u59D3" }, - full_name: { label: "\u5168\u540D" }, - company: { label: "\u516C\u53F8" }, - title: { label: "\u804C\u4F4D" }, - email: { label: "\u90AE\u7BB1" }, - phone: { label: "\u7535\u8BDD" }, - industry: { - label: "\u884C\u4E1A", - options: { - technology: "\u79D1\u6280", - software: "\u8F6F\u4EF6 / SaaS", - finance: "\u91D1\u878D", - healthcare: "\u533B\u7597", - retail: "\u96F6\u552E", - manufacturing: "\u5236\u9020", - education: "\u6559\u80B2", - real_estate: "\u623F\u5730\u4EA7", - media: "\u4F20\u5A92\u5A31\u4E50", - logistics: "\u7269\u6D41", - hospitality: "\u9152\u5E97\u65C5\u6E38", - energy: "\u80FD\u6E90\u516C\u7528\u4E8B\u4E1A", - government: "\u653F\u5E9C", - nonprofit: "\u975E\u8425\u5229", - other: "\u5176\u4ED6" - } - }, - status: { - label: "\u72B6\u6001", - options: { - // 已确认 / 未通过 是同一个动作(线索确认)的正反两面;原先的 - // 已确认 / 不合格 出自两套说法,在状态条上并排时读起来不成对。 - new: "\u65B0\u5EFA", - contacted: "\u5DF2\u8054\u7CFB", - qualified: "\u5DF2\u786E\u8BA4", - unqualified: "\u672A\u901A\u8FC7", - converted: "\u5DF2\u8F6C\u5316" - } - }, - lead_source: { - label: "\u7EBF\u7D22\u6765\u6E90", - options: { - web: "\u7F51\u7AD9", - referral: "\u63A8\u8350", - event: "\u6D3B\u52A8 / \u5C55\u4F1A", - webinar: "\u7EBF\u4E0A\u7814\u8BA8\u4F1A", - partner: "\u5408\u4F5C\u4F19\u4F34", - advertisement: "\u5E7F\u544A", - paid_search: "\u4ED8\u8D39\u641C\u7D22", - social: "\u793E\u4EA4\u5A92\u4F53", - content: "\u5185\u5BB9 / \u535A\u5BA2", - cold_call: "\u964C\u751F\u62DC\u8BBF", - email_campaign: "\u90AE\u4EF6\u8425\u9500", - other: "\u5176\u4ED6" - } - }, - owner_id: { label: "\u7EBF\u7D22\u8D1F\u8D23\u4EBA" }, - is_converted: { label: "\u5DF2\u8F6C\u5316" }, - description: { label: "\u63CF\u8FF0" }, - mobile: { label: "\u624B\u673A" }, - website: { label: "\u7F51\u7AD9" }, - rating: { label: "\u7EBF\u7D22\u8BC4\u5206", help: "\u7EBF\u7D22\u8D28\u91CF\u8BC4\u5206\uFF081-5 \u661F\uFF09" }, - converted_account: { label: "\u8F6C\u5316\u5BA2\u6237" }, - converted_contact: { label: "\u8F6C\u5316\u8054\u7CFB\u4EBA" }, - converted_opportunity: { label: "\u8F6C\u5316\u5546\u673A" }, - converted_date: { label: "\u8F6C\u5316\u65E5\u671F" }, - address: { label: "\u5730\u5740" }, - annual_revenue: { label: "\u5E74\u8425\u6536" }, - number_of_employees: { label: "\u5458\u5DE5\u4EBA\u6570" }, - notes: { label: "\u5907\u6CE8", help: "\u672C\u7EBF\u7D22\u7684\u5DE5\u4F5C\u5907\u6CE8\u2014\u2014\u652F\u6301\u683C\u5F0F\u6392\u7248\u3002" }, - do_not_call: { label: "\u7981\u6B62\u81F4\u7535" }, - email_opt_out: { label: "\u62D2\u6536\u90AE\u4EF6" }, - disqualification_reason: { - // 状态里的 unqualified 译作「未通过」,所以这里跟着叫「未通过原因」 - // 而不是「取消资格原因」—— 两个字段在同一张表单上下相邻,用词必须成对。 - label: "\u672A\u901A\u8FC7\u539F\u56E0", - help: "\u72B6\u6001\u4E3A\u300C\u672A\u901A\u8FC7\u300D\u65F6\u5FC5\u586B", - options: { - not_a_fit: "\u9700\u6C42\u4E0D\u5339\u914D", - no_budget: "\u9884\u7B97\u4E0D\u8DB3", - wrong_persona: "\u8054\u7CFB\u4EBA\u89D2\u8272\u4E0D\u7B26", - unreachable: "\u65E0\u6CD5\u8054\u7CFB", - duplicate: "\u91CD\u590D\u7EBF\u7D22", - competitor: "\u9009\u62E9\u4E86\u7ADE\u4E89\u5BF9\u624B", - other: "\u5176\u4ED6" - } - }, - duplicate_of_type: { - help: "\u4FDD\u7559\u4E0B\u6765\u7684\u90A3\u6761\u8BB0\u5F55\u6240\u5C5E\u7684\u5BF9\u8C61\u7C7B\u578B\u3002", - label: "\u91CD\u590D\u4E8E", - // `erased` 是墓碑值，不是可选项：表单不提供它（见 - // `src/sales/views/lead.view.ts`），但幸存记录被删除后线索会带着它， - // 所以凡是读取记录的地方都需要标签，否则会显示原始值 `erased`。 - options: { crm_lead: "\u7EBF\u7D22", crm_contact: "\u8054\u7CFB\u4EBA", erased: "\u8BB0\u5F55\u5DF2\u5220\u9664" } - }, - duplicate_of_lead: { label: "\u91CD\u590D\u7684\u7EBF\u7D22" }, - duplicate_of_contact: { label: "\u91CD\u590D\u7684\u8054\u7CFB\u4EBA" }, - duplicate_status: { - help: "\u7591\u4F3C = \u5F55\u5165\u65F6\u81EA\u52A8\u6807\u8BB0\uFF1B\u5DF2\u786E\u8BA4 = \u4EBA\u5DE5\u6838\u5B9E\u8FC7\u5339\u914D\u3002", - // 疑似 = 录入时自动标记;已确认 = 人工核对后的判定。两者是同一 - // 判断的两个阶段,所以共用一个字段而不是各占一套链接字段。 - label: "\u91CD\u590D\u72B6\u6001", - options: { suspected: "\u7591\u4F3C\u91CD\u590D", confirmed: "\u5DF2\u786E\u8BA4\u91CD\u590D" } - }, - display_title: { label: "\u663E\u793A\u540D\u79F0" }, - company_normalized: { label: "\u516C\u53F8\u540D\u79F0\uFF08\u89C4\u8303\u5316\uFF09", help: "\u7EBF\u7D22\u8F6C\u5316\u7684\u5339\u914D\u952E\uFF1A\u516C\u53F8\u540D\u79F0\u8F6C\u5C0F\u5199\u3001\u53BB\u9664\u9996\u5C3E\u7A7A\u683C\u3001\u5185\u90E8\u8FDE\u7EED\u7A7A\u767D\u5408\u5E76\u4E3A\u4E00\u4E2A\u7A7A\u683C\u3002\u7531 lead_duplicate_check \u94A9\u5B50\u7EF4\u62A4\u2014\u2014\u8BF7\u52FF\u76F4\u63A5\u7F16\u8F91\u3002" }, - next_followup_date: { label: "\u4E0B\u6B21\u8DDF\u8FDB\u65E5\u671F" }, - last_contacted_date: { label: "\u6700\u8FD1\u8054\u7CFB\u65F6\u95F4" }, - need_type: { - label: "\u9700\u6C42\u7C7B\u578B", - help: "\u5BA2\u6237\u60F3\u8981\u4EC0\u4E48\u3002\u7EBF\u7D22\u5206\u6D3E\u3001\u4F18\u5148\u7EA7\u6392\u5E8F\u548C\u9700\u6C42\u5206\u6790\u90FD\u8BFB\u8FD9\u4E2A\u5B57\u6BB5\u3002", - options: { - new_implementation: "\u65B0\u5EFA\u5B9E\u65BD", - expansion: "\u6269\u5BB9\u589E\u8D2D", - replacement: "\u66FF\u6362\u8FC1\u79FB", - renewal: "\u7EED\u7EA6", - consulting: "\u54A8\u8BE2\u670D\u52A1", - support: "\u8FD0\u7EF4\u652F\u6301", - other: "\u5176\u4ED6" - } - }, - estimated_amount: { - label: "\u9884\u8BA1\u91D1\u989D", - help: "\u8D44\u683C\u5224\u5B9A\u4E4B\u524D\u5BF9\u8BE5\u9700\u6C42\u91D1\u989D\u7684\u4F30\u7B97\u3002\u8F6C\u5316\u65F6\u7528\u4E8E\u9884\u586B\u5546\u673A\u91D1\u989D\u3002" - }, - conversion_approval_status: { - label: "\u8F6C\u5316\u5BA1\u6279", - help: "\u8BE5\u7EBF\u7D22\u662F\u5426\u5DF2\u83B7\u51C6\u8F6C\u5316\u3002\u300C\u65E0\u9700\u5BA1\u6279\u300D\u8868\u793A\u4E0D\u8D70\u5BA1\u6279\u6D41\u7A0B\u2014\u2014\u8FD9\u662F\u4EA7\u54C1\u7684\u51FA\u5382\u9ED8\u8BA4\u503C\u3002", - options: { - not_required: "\u65E0\u9700\u5BA1\u6279", - pending: "\u5F85\u5BA1\u6279", - approved: "\u5BA1\u6279\u901A\u8FC7", - rejected: "\u5BA1\u6279\u9A73\u56DE" - } - } - }, - _views: { - all_leads: { - label: "\u5168\u90E8\u7EBF\u7D22", - emptyState: { title: "\u8FD8\u6CA1\u6709\u7EBF\u7D22", message: "\u521B\u5EFA\u7B2C\u4E00\u6761\u7EBF\u7D22\uFF0C\u4ECE\u8FD9\u91CC\u5F00\u59CB" } - }, - kanban_by_status: { label: "\u7EBF\u7D22\u6D41\u6C34\u7EBF" }, - calendar_by_created: { label: "\u7EBF\u7D22\u65E5\u5386" }, - gallery_view: { label: "\u7EBF\u7D22\u5361\u7247" }, - my_leads: { label: "\u6211\u7684\u7EBF\u7D22" }, - high_priority: { label: "\u9AD8\u4F18\u5148\u7EA7" }, - hot_leads: { label: "\u{1F525} \u9AD8\u70ED\u5EA6\u7EBF\u7D22" }, - suspected_duplicates: { - label: "\u7591\u4F3C\u91CD\u590D\u7EBF\u7D22", - emptyState: { title: "\u6CA1\u6709\u7591\u4F3C\u91CD\u590D", message: "\u65E0\u9700\u590D\u6838\u2014\u2014\u6BCF\u4E2A\u91CD\u590D\u5F55\u5165\u7684\u90AE\u7BB1\u90FD\u5DF2\u68C0\u67E5\u8FC7\u3002" } - } - }, - _sections: { - // Object-level section keys (lead.object.ts), used by record forms and - // by the detail page, whose sections reference these groups (#806) - address: { label: "\u5730\u5740" }, - identity: { label: "\u8EAB\u4EFD\u4FE1\u606F" }, - company_info: { label: "\u516C\u53F8\u4FE1\u606F" }, - contact_info: { label: "\u8054\u7CFB\u65B9\u5F0F" }, - qualification: { label: "\u8D44\u683C\u8BC4\u4F30" }, - assignment: { label: "\u5206\u914D" }, - additional: { label: "\u9644\u52A0\u4FE1\u606F" }, - preferences: { label: "\u6C9F\u901A\u504F\u597D" }, - conversion: { label: "\u8F6C\u5316" }, - duplicates: { label: "\u91CD\u590D\u7EBF\u7D22\u7BA1\u7406" }, - // lead.view.ts 表单区块名称 (#1100) —— 默认表单与每一个具名 formView - // 的区块名字都住在这里：那边新增一个表单，这里就补上它的区块名。 - contact_information: { label: "\u8054\u7CFB\u4FE1\u606F" }, - lead_classification: { label: "\u7EBF\u7D22\u5206\u7C7B" }, - company_information: { label: "\u516C\u53F8\u4FE1\u606F" }, - additional_information: { label: "\u9644\u52A0\u4FE1\u606F" }, - privacy: { label: "\u9690\u79C1" }, - general: { label: "\u5E38\u89C4\u4FE1\u606F" }, - details: { label: "\u8BE6\u60C5" }, - step_1_contact_details: { label: "\u7B2C\u4E00\u6B65\uFF1A\u8054\u7CFB\u65B9\u5F0F" }, - step_2_company_information: { label: "\u7B2C\u4E8C\u6B65\uFF1A\u516C\u53F8\u4FE1\u606F" }, - step_3_qualification: { label: "\u7B2C\u4E09\u6B65\uFF1A\u8D44\u8D28\u5BA1\u6838" }, - step_4_review_and_convert: { label: "\u7B2C\u56DB\u6B65\uFF1A\u5BA1\u6838\u5E76\u8F6C\u5316" }, - primary_information: { label: "\u4E3B\u8981\u4FE1\u606F" }, - extended_details: { label: "\u6269\u5C55\u4FE1\u606F" }, - quick_edit: { label: "\u5FEB\u901F\u7F16\u8F91" }, - update_lead_status: { label: "\u66F4\u65B0\u7EBF\u7D22\u72B6\u6001" }, - tell_us_about_yourself: { label: "\u8BF7\u4ECB\u7ECD\u4E00\u4E0B\u60A8\u81EA\u5DF1" }, - about_your_company: { label: "\u60A8\u7684\u516C\u53F8\u4FE1\u606F" }, - how_can_we_help: { label: "\u6211\u4EEC\u80FD\u5E2E\u60A8\u4EC0\u4E48\uFF1F" }, - lead_information: { label: "\u7EBF\u7D22\u4FE1\u606F" }, - address_information: { label: "\u5730\u5740\u4FE1\u606F" }, - privacy_preferences: { label: "\u9690\u79C1\u504F\u597D" } - }, - _actions: { - ...activityActions2, - convert_lead: { - label: "\u8F6C\u5316\u7EBF\u7D22", - successMessage: "\u7EBF\u7D22\u8F6C\u5316\u6210\u529F\uFF01" - }, - create_campaign: { - label: "\u52A0\u5165\u8425\u9500\u6D3B\u52A8", - successMessage: "\u5DF2\u5C06\u7EBF\u7D22\u52A0\u5165\u8425\u9500\u6D3B\u52A8\uFF01", - params: { - crm_campaign: { label: "\u8425\u9500\u6D3B\u52A8" } - } - }, - schedule_followup: { - label: "\u5B89\u6392\u8DDF\u8FDB", - successMessage: "\u8DDF\u8FDB\u4EFB\u52A1\u5DF2\u521B\u5EFA\u3002" - } - } - }, - crm_opportunity: { - _validations: { - amount_positive: { - message: "\u91D1\u989D\u5FC5\u987B\u5927\u4E8E\u96F6" - }, - close_date_future: { - message: "\u9664\u975E\u5546\u673A\u5DF2\u7ED3\u675F\uFF0C\u5426\u5219\u9884\u8BA1\u6210\u4EA4\u65E5\u4E0D\u5E94\u65E9\u4E8E\u4ECA\u5929" - }, - opportunity_stage_progression: { - message: "\u65E0\u6548\u7684\u5546\u673A\u9636\u6BB5\u6D41\u8F6C" - } - }, - label: "\u5546\u673A", - pluralLabel: "\u5546\u673A", - description: "\u9500\u552E\u6D41\u7A0B\u4E2D\u7684\u5546\u673A\u4E0E\u4EA4\u6613", - fields: { - name: { label: "\u5546\u673A\u540D\u79F0" }, - crm_account: { label: "\u6240\u5C5E\u5BA2\u6237" }, - primary_contact: { label: "\u4E3B\u8981\u8054\u7CFB\u4EBA" }, - owner_id: { label: "\u5546\u673A\u8D1F\u8D23\u4EBA" }, - amount: { label: "\u91D1\u989D" }, - expected_revenue: { label: "\u9884\u671F\u6536\u5165" }, - stage: { - label: "\u9636\u6BB5", - options: { - prospecting: "\u5BFB\u627E\u5BA2\u6237", - qualification: "\u8D44\u683C\u5BA1\u67E5", - needs_analysis: "\u9700\u6C42\u5206\u6790", - proposal: "\u63D0\u6848", - negotiation: "\u8C08\u5224", - closed_won: "\u6210\u4EA4", - closed_lost: "\u5931\u8D25" - } - }, - probability: { label: "\u6210\u4EA4\u6982\u7387 (%)" }, - close_date: { label: "\u9884\u8BA1\u6210\u4EA4\u65E5\u671F" }, - type: { - label: "\u7C7B\u578B", - options: { - new_business: "\u65B0\u4E1A\u52A1", - existing_upgrade: "\u8001\u5BA2\u6237\u5347\u7EA7", - existing_renewal: "\u8001\u5BA2\u6237\u7EED\u7EA6", - existing_expansion: "\u8001\u5BA2\u6237\u62D3\u5C55" - } - }, - forecast_category: { - label: "\u9884\u6D4B\u7C7B\u522B", - options: { - pipeline: "\u7BA1\u9053", - best_case: "\u6700\u4F73\u60C5\u51B5", - commit: "\u627F\u8BFA", - omitted: "\u5DF2\u6392\u9664", - closed: "\u5DF2\u5173\u95ED" - } - }, - description: { label: "\u63CF\u8FF0" }, - next_step: { label: "\u4E0B\u4E00\u6B65" }, - lead_source: { - label: "\u7EBF\u7D22\u6765\u6E90", - options: { - web: "\u7F51\u7AD9", - referral: "\u63A8\u8350", - event: "\u6D3B\u52A8 / \u5C55\u4F1A", - webinar: "\u7EBF\u4E0A\u7814\u8BA8\u4F1A", - partner: "\u5408\u4F5C\u4F19\u4F34", - advertisement: "\u5E7F\u544A", - paid_search: "\u4ED8\u8D39\u641C\u7D22", - social: "\u793E\u4EA4\u5A92\u4F53", - content: "\u5185\u5BB9 / \u535A\u5BA2", - cold_call: "\u964C\u751F\u62DC\u8BBF", - email_campaign: "\u90AE\u4EF6\u8425\u9500", - other: "\u5176\u4ED6" - } - }, - crm_campaign: { label: "\u8425\u9500\u6D3B\u52A8", help: "\u5E26\u6765\u6B64\u5546\u673A\u7684\u8425\u9500\u6D3B\u52A8" }, - days_in_stage: { label: "\u5F53\u524D\u9636\u6BB5\u5929\u6570" }, - stage_entry_date: { label: "\u8FDB\u5165\u5F53\u524D\u9636\u6BB5\u65E5\u671F", help: "\u672C\u5546\u673A\u8FDB\u5165\u5F53\u524D\u9636\u6BB5\u7684\u65E5\u671F\u3002" }, - is_private: { label: "\u79C1\u5BC6" }, - approval_status: { - label: "\u5BA1\u6279\u72B6\u6001", - options: { not_required: "\u65E0\u9700\u5BA1\u6279", pending: "\u5BA1\u6279\u4E2D", approved: "\u5DF2\u6279\u51C6", rejected: "\u5DF2\u9A73\u56DE" } - }, - approved_date: { label: "\u6279\u51C6\u65F6\u95F4" }, - win_reason: { - help: '\u8D62\u5355\u539F\u56E0\u3002\u5C06\u5546\u673A\u5173\u95ED\u4E3A"\u6210\u4EA4"\u65F6\u5FC5\u586B\u3002', - label: "\u8D62\u5355\u539F\u56E0", - options: { - better_product: "\u4EA7\u54C1\u66F4\u4F18", - better_price: "\u4EF7\u683C\u66F4\u4F18", - relationship: "\u5BA2\u6237\u5173\u7CFB", - better_support: "\u652F\u6301\u66F4\u597D", - best_fit: "\u6700\u4F73\u5951\u5408", - quote_accepted: "\u62A5\u4EF7\u88AB\u63A5\u53D7", - other: "\u5176\u4ED6" - } - }, - loss_reason: { - help: '\u4E22\u5355\u539F\u56E0\u3002\u5C06\u5546\u673A\u5173\u95ED\u4E3A"\u5931\u8D25"\u65F6\u5FC5\u586B\u3002', - label: "\u4E22\u5355\u539F\u56E0", - options: { - price: "\u4EF7\u683C\u8FC7\u9AD8", - competitor: "\u8F93\u7ED9\u7ADE\u4E89\u5BF9\u624B", - no_budget: "\u65E0\u9884\u7B97", - no_decision: "\u672A\u51B3\u7B56", - timing: "\u65F6\u673A\u4E0D\u5408\u9002", - features: "\u529F\u80FD\u7F3A\u5931", - other: "\u5176\u4ED6" - } - }, - loss_details: { label: "\u8D62/\u4E22\u5355\u8BE6\u60C5", help: "\u8D62\u5355\u6216\u4E22\u5355\u539F\u56E0\u7684\u8865\u5145\u8BF4\u660E\u3002" }, - // REQ-0006 — 资格评估、客户侧采购日程、商机叙述、业务线与状态变更审批。 - will_bid: { label: "\u662F\u5426\u6295\u6807", help: "\u6211\u65B9\u662F\u5426\u6253\u7B97\u6295\u6807\u3002\u7559\u7A7A\u8868\u793A\u5C1A\u672A\u51B3\u5B9A\u3002" }, - controllability: { label: "\u53EF\u63A7\u6027", options: { high: "\u9AD8", medium: "\u4E2D", low: "\u4F4E" } }, - priority: { label: "\u4F18\u5148\u7EA7", options: { high: "\u9AD8", medium: "\u4E2D", low: "\u4F4E" } }, - deal_level: { label: "\u5546\u673A\u7EA7\u522B", options: { strategic: "\u6218\u7565\u7EA7", key: "\u91CD\u70B9", standard: "\u666E\u901A" } }, - is_subcontracted: { label: "\u6D89\u53CA\u5206\u5305" }, - subcontracting_note: { label: "\u5206\u5305\u8BF4\u660E" }, - customer_initiation_date: { label: "\u5BA2\u6237\u7ACB\u9879\u65E5\u671F" }, - expected_tender_date: { label: "\u9884\u8BA1\u62DB\u6807\u65E5\u671F" }, - expected_signing_date: { label: "\u9884\u8BA1\u7B7E\u7EA6\u65E5\u671F" }, - expected_tender_amount: { label: "\u9884\u8BA1\u62DB\u6807\u91D1\u989D" }, - expected_signing_amount: { label: "\u9884\u8BA1\u7B7E\u7EA6\u91D1\u989D" }, - business_line: { - label: "\u4E1A\u52A1\u7EBF", - options: { product: "\u4EA7\u54C1", services: "\u4E13\u4E1A\u670D\u52A1", consulting: "\u54A8\u8BE2\u670D\u52A1", support: "\u8FD0\u7EF4\u652F\u6301", other: "\u5176\u4ED6" } - }, - customer_background: { label: "\u5BA2\u6237\u7B80\u4ECB" }, - project_background: { label: "\u9879\u76EE\u80CC\u666F" }, - risk_analysis: { label: "\u98CE\u9669\u5206\u6790" }, - payment_terms: { label: "\u4ED8\u6B3E\u6761\u6B3E" }, - requested_status: { label: "\u7533\u8BF7\u53D8\u66F4\u72B6\u6001", options: { closed_won: "\u8D62\u5355", closed_lost: "\u4E22\u5355" } }, - status_change_approval_status: { - label: "\u72B6\u6001\u53D8\u66F4\u5BA1\u6279", - options: { not_required: "\u65E0\u9700\u5BA1\u6279", pending: "\u5BA1\u6279\u4E2D", approved: "\u5DF2\u6279\u51C6", rejected: "\u5DF2\u9A73\u56DE" } - }, - // REQ-0006 第 11 步 — 立项审批。 - qualification_requested: { - label: "\u7533\u8BF7\u7ACB\u9879\u5BA1\u6279", - help: "\u52FE\u9009\u540E\u63D0\u4EA4\u7ACB\u9879\u5BA1\u6279\u3002\u5BA1\u6279\u88AB\u9A73\u56DE\u65F6\u4F1A\u81EA\u52A8\u53D6\u6D88\u52FE\u9009\uFF1B\u518D\u6B21\u52FE\u9009\u5373\u53EF\u91CD\u65B0\u7533\u8BF7\u3002" - }, - qualification_approval_status: { - label: "\u7ACB\u9879\u5BA1\u6279", - options: { not_required: "\u65E0\u9700\u5BA1\u6279", pending: "\u5BA1\u6279\u4E2D", approved: "\u5DF2\u6279\u51C6", rejected: "\u5DF2\u9A73\u56DE" } - } - }, - _views: { - tender_this_quarter: { - label: "\u672C\u5B63\u5EA6\u9884\u8BA1\u62DB\u6807", - emptyState: { - title: "\u672C\u5B63\u5EA6\u6682\u65E0\u9884\u8BA1\u62DB\u6807\u7684\u5546\u673A", - message: "\u672C\u6807\u7B7E\u9875\u5217\u51FA\u5BA2\u6237\u4FA7\u9884\u8BA1\u62DB\u6807\u65E5\u671F\u843D\u5728\u5F53\u524D\u5B63\u5EA6\u5185\u7684\u8FDB\u884C\u4E2D\u5546\u673A\u3002\u5728\u5546\u673A\u4E0A\u586B\u5199\u201C\u9884\u8BA1\u62DB\u6807\u65E5\u671F\u201D\u540E\uFF0C\u5B83\u5C31\u4F1A\u51FA\u73B0\u5728\u8FD9\u91CC\u3002" - } - }, - open_opportunities: { label: "\u8FDB\u884C\u4E2D\u5546\u673A" }, - all_opportunities: { label: "\u5168\u90E8\u5546\u673A" }, - pipeline_kanban: { label: "\u9500\u552E\u6D41\u6C34\u7EBF" }, - close_date_calendar: { label: "\u9884\u6D4B\u65E5\u5386" }, - deal_timeline: { label: "\u5546\u673A\u65F6\u95F4\u7EBF" }, - deal_gallery: { label: "\u5546\u673A\u5361\u7247" }, - my_open_deals: { label: "\u6211\u7684\u8FDB\u884C\u4E2D\u5546\u673A" }, - stale_opportunities: { label: "\u26A0\uFE0F \u505C\u6EDE\u5546\u673A \xB7 \u6309\u9636\u6BB5\u505C\u7559\u65F6\u95F4\u6392\u5E8F" }, - closing_this_quarter: { - label: "\u672C\u5B63\u5EA6\u5F85\u6210\u4EA4\u5546\u673A", - emptyState: { - title: "\u672C\u5B63\u5EA6\u6682\u65E0\u5F85\u6210\u4EA4\u5546\u673A", - message: "\u672C\u6807\u7B7E\u9875\u5217\u51FA\u9884\u8BA1\u6210\u4EA4\u65E5\u671F\u843D\u5728\u5F53\u524D\u5B63\u5EA6\u5185\u3001\u4E14\u5904\u4E8E\u627F\u8BFA\uFF08Commit\uFF09\u6216\u6700\u4F73\u53EF\u80FD\uFF08Best Case\uFF09\u7684\u8FDB\u884C\u4E2D\u5546\u673A\u3002\u5F53\u524D\u6CA1\u6709\u7B26\u5408\u6761\u4EF6\u7684\u8BB0\u5F55\u2014\u2014\u9884\u8BA1\u6210\u4EA4\u65E5\u671F\u66F4\u665A\u7684\u5546\u673A\u8BF7\u89C1\u201C\u8FDB\u884C\u4E2D\u5546\u673A\u201D\u6807\u7B7E\u9875\u3002" - } - } - }, - _sections: { - // Object-level section keys (opportunity.object.ts), used by record forms - // and by the detail page, whose sections reference these groups (#1452) - crm_forecast: { label: "\u9636\u6BB5\u4E0E\u9884\u6D4B" }, - basic: { label: "\u57FA\u672C\u4FE1\u606F" }, - financials: { label: "\u8D22\u52A1\u4FE1\u606F" }, - sales_process: { label: "\u9500\u552E\u6D41\u7A0B" }, - classification: { label: "\u5206\u7C7B" }, - campaign: { label: "\u8425\u9500\u6D3B\u52A8" }, - notes: { label: "\u5907\u6CE8\u4E0E\u4E0B\u4E00\u6B65" }, - qualification: { label: "\u8D44\u683C\u8BC4\u4F30" }, - narrative: { label: "\u5546\u673A\u53D9\u8FF0" }, - // opportunity.view.ts 表单区块名称 (#1100) - overview: { label: "\u6982\u89C8" }, - forecast: { label: "\u9884\u6D4B" }, - sales_strategy: { label: "\u9500\u552E\u7B56\u7565" }, - win_loss: { label: "\u8D62\u5355/\u8F93\u5355" } - }, - _actions: { - ...activityActions2, - clone_opportunity: { - label: "\u514B\u9686\u5546\u673A", - successMessage: "\u5546\u673A\u514B\u9686\u6210\u529F\uFF01" - }, - generate_quote: { - label: "\u751F\u6210\u62A5\u4EF7\u5355", - successMessage: "\u5DF2\u6839\u636E\u5546\u673A\u521B\u5EFA\u62A5\u4EF7\u5355\uFF01" - }, - mass_update_stage: { - label: "\u66F4\u65B0\u9636\u6BB5", - successMessage: "\u5546\u673A\u9636\u6BB5\u5DF2\u66F4\u65B0\uFF01", - params: { - stage: { - label: "\u65B0\u9636\u6BB5", - options: { - prospecting: "\u5BFB\u627E\u5BA2\u6237", - qualification: "\u8D44\u683C\u5BA1\u67E5", - needs_analysis: "\u9700\u6C42\u5206\u6790", - proposal: "\u63D0\u6848", - negotiation: "\u8C08\u5224", - closed_won: "\u6210\u4EA4", - closed_lost: "\u5931\u8D25" - } - } - } - } - } - }, - crm_opportunity_line_item: { - _validations: { - unit_price_positive: { - message: "\u9500\u552E\u4EF7\u683C\u4E0D\u80FD\u4E3A\u8D1F\u6570" - } - }, - label: "\u5546\u673A\u4EA7\u54C1\u660E\u7EC6", - pluralLabel: "\u5546\u673A\u4EA7\u54C1\u660E\u7EC6", - description: "\u5546\u673A\u4E0B\u6309\u4EA7\u54C1\u62C6\u5206\u7684\u62A5\u4EF7\u884C", - fields: { - crm_opportunity: { label: "\u5173\u8054\u5546\u673A" }, - crm_product: { label: "\u4EA7\u54C1" }, - description: { label: "\u63CF\u8FF0" }, - quantity: { label: "\u6570\u91CF" }, - list_price: { label: "\u6807\u4EF7", help: "\u81EA\u52A8\u53D6\u81EA\u4EA7\u54C1\u7684\u76EE\u5F55\u4EF7" }, - unit_price: { label: "\u9500\u552E\u5355\u4EF7", help: "\u534F\u5546\u540E\u7684\u5355\u4EF7\uFF08\u53EF\u4E0E\u76EE\u5F55\u4EF7\u4E0D\u540C\uFF09" }, - discount: { label: "\u6298\u6263\uFF08%\uFF09" }, - total_price: { label: "\u603B\u8BA1" }, - line_number: { label: "\u884C\u53F7" } - }, - _sections: { - basic: { label: "\u660E\u7EC6\u884C" }, - pricing: { label: "\u4EF7\u683C" } - } - }, - crm_forecast: { - _validations: { - period_end_after_start: { - message: "\u5468\u671F\u7ED3\u675F\u5FC5\u987B\u665A\u4E8E\u5468\u671F\u5F00\u59CB\u3002" - }, - period_end_matches_calendar_period: { - message: "\u5468\u671F\u7ED3\u675F\u5FC5\u987B\u662F\u8BE5\u5468\u671F\u7684\u6700\u540E\u4E00\u5929\u2014\u2014\u4F8B\u5982\u4EE5 2026-07-01 \u5F00\u59CB\u7684\u5B63\u5EA6\u5BF9\u5E94 2026-09-30\uFF0C2026 \u5E74 8 \u6708\u5BF9\u5E94 2026-08-31\u3002" - }, - period_start_first_of_period: { - message: "\u5468\u671F\u5F00\u59CB\u5FC5\u987B\u662F\u8BE5\u5468\u671F\u7684\u7B2C\u4E00\u5929\u2014\u2014\u4F8B\u5982 2026 \u5E74 8 \u6708\u5BF9\u5E94 2026-08-01\u3002" - }, - quarter_starts_on_quarter_boundary: { - message: "\u5B63\u5EA6\u9884\u6D4B\u5FC5\u987B\u4ECE\u5B63\u5EA6\u8FB9\u754C\u5F00\u59CB\u2014\u20141 \u6708 1 \u65E5\u30014 \u6708 1 \u65E5\u30017 \u6708 1 \u65E5\u6216 10 \u6708 1 \u65E5\u3002" - }, - snapshot_amounts_non_negative: { - message: "\u5FEB\u7167\u91D1\u989D\u4E0D\u80FD\u4E3A\u8D1F\u6570\u3002" - } - }, - label: "\u9500\u552E\u9884\u6D4B", - pluralLabel: "\u9500\u552E\u9884\u6D4B", - description: "\u6309\u9500\u552E\u8D1F\u8D23\u4EBA\u5B9A\u671F\u8BB0\u5F55\u7684\u7BA1\u9053\u5FEB\u7167\uFF0C\u7528\u4E8E\u6536\u5165\u9884\u6D4B", - fields: { - owner_id: { label: "\u8D1F\u8D23\u4EBA" }, - period: { label: "\u5468\u671F", options: { month: "\u6708\u5EA6", quarter: "\u5B63\u5EA6" } }, - period_start: { - label: "\u5468\u671F\u8D77\u59CB", - help: "\u5FC5\u987B\u662F\u6240\u5728\u5468\u671F\u7684\u7B2C\u4E00\u5929\u2014\u2014\u4F8B\u5982 2026 \u5E74 8 \u6708\u5BF9\u5E94 2026-08-01\u3002\u5B63\u5EA6\u9884\u6D4B\u8FD8\u5FC5\u987B\u843D\u5728\u5B63\u5EA6\u8FB9\u754C\u4E0A\uFF1A1 \u6708 1 \u65E5\u30014 \u6708 1 \u65E5\u30017 \u6708 1 \u65E5\u6216 10 \u6708 1 \u65E5\u3002" - }, - period_end: { - label: "\u5468\u671F\u622A\u6B62", - help: '\u901A\u5E38\u6839\u636E"\u5468\u671F"\u548C"\u5468\u671F\u8D77\u59CB"\u81EA\u52A8\u63A8\u7B97\u3002\u5982\u624B\u52A8\u586B\u5199\uFF0C\u5FC5\u987B\u662F\u8BE5\u5468\u671F\u7684\u6700\u540E\u4E00\u5929\u2014\u2014\u4F8B\u5982\u8D77\u59CB\u4E3A 2026-07-01 \u7684\u5B63\u5EA6\u5BF9\u5E94 2026-09-30\uFF0C2026 \u5E74 8 \u6708\u5BF9\u5E94 2026-08-31\u3002' - }, - period_label: { label: "\u5468\u671F\u6807\u7B7E", help: '\u6613\u8BFB\u7684\u5468\u671F\u6807\u7B7E\uFF0C\u4F8B\u5982"2026 \u5E74\u7B2C\u4E09\u5B63\u5EA6"\u6216"2026 \u5E74 8 \u6708"\u3002' }, - snapshot_date: { label: "\u5FEB\u7167\u65E5\u671F", help: "\u672C\u6B21\u5FEB\u7167\u7684\u91C7\u96C6\u65E5\u671F\u3002" }, - source: { - label: "\u6765\u6E90", - options: { scheduled: "\u5B9A\u65F6\u5FEB\u7167", ai: "AI \u6280\u80FD", manual: "\u624B\u5DE5\u5F55\u5165" } - }, - quota: { label: "\u914D\u989D" }, - pipeline_amount: { label: "\u7BA1\u9053\u91D1\u989D", help: "\u672C\u5468\u671F\u5185\u6240\u6709\u9884\u8BA1\u7ED3\u5355\u7684\u8FDB\u884C\u4E2D\u5546\u673A\u91D1\u989D\u5408\u8BA1\uFF08\u4E0D\u9650\u9636\u6BB5\uFF09\u3002" }, - best_case_amount: { label: "\u6700\u4F73\u60C5\u51B5", help: '\u9884\u6D4B\u7C7B\u522B\u4E3A"\u6700\u4F73\u60C5\u51B5"\u6216"\u627F\u8BFA"\u7684\u8FDB\u884C\u4E2D\u5546\u673A\u3002' }, - commit_amount: { label: "\u627F\u8BFA\u91D1\u989D", help: '\u9884\u6D4B\u7C7B\u522B\u4E3A"\u627F\u8BFA"\u7684\u8FDB\u884C\u4E2D\u5546\u673A\uFF08\u8D1F\u8D23\u4EBA\u5DF2\u627F\u8BFA\uFF09\u3002' }, - closed_amount: { label: "\u5DF2\u6210\u4EA4\u91D1\u989D", help: "\u672C\u5468\u671F\u5185\u5DF2\u8D62\u5355\u7684\u91D1\u989D\u3002" }, - expected_amount: { label: "\u9884\u671F\u91D1\u989D", help: "\u5DF2\u6210\u4EA4 + \u627F\u8BFA\u2014\u2014\u8D1F\u8D23\u4EBA\u5408\u7406\u9884\u671F\u80FD\u62FF\u4E0B\u7684\u91D1\u989D\u3002" }, - attainment_pct: { label: "\u8FBE\u6210\u7387\uFF08%\uFF09", help: "\u5DF2\u6210\u4EA4 \xF7 \u914D\u989D \xD7 100\u3002\u914D\u989D\u4E3A\u6B63\u6570\u4E4B\u524D\u663E\u793A 0%\u3002" }, - coverage_ratio: { label: "\u8986\u76D6\u500D\u6570", help: "\u7BA1\u9053\u91D1\u989D \xF7\uFF08\u914D\u989D \u2212 \u5DF2\u6210\u4EA4\uFF09\u2014\u2014\u5224\u65AD\u5269\u4F59\u7F3A\u53E3\u662F\u5426\u6709\u8DB3\u591F\u7BA1\u9053\u8986\u76D6\u3002\u914D\u989D\u5DF2\u8FBE\u6210\u65F6\u663E\u793A 0\u3002" }, - notes: { label: "\u5907\u6CE8" }, - display_title: { label: "\u663E\u793A\u540D\u79F0" }, - seed_key: { label: "\u79CD\u5B50\u6807\u8BC6", help: "\u6F14\u793A\u6570\u636E\u6807\u8BC6\u3002\u4EC5\u7531\u79CD\u5B50\u52A0\u8F7D\u5668\u5199\u5165\uFF1B\u771F\u5B9E\u5FEB\u7167\u4E0A\u59CB\u7EC8\u4E3A\u7A7A\u3002" } - }, - _views: { - all_forecasts: { label: "\u5168\u90E8\u9884\u6D4B" }, - this_quarter_forecasts: { - label: "\u672C\u5B63\u5EA6", - emptyState: { - title: "\u672C\u5B63\u5EA6\u5C1A\u65E0\u5FEB\u7167", - message: "\u5B63\u5EA6\u5FEB\u7167\u7531\u6BCF\u665A\u7684\u9884\u6D4B\u626B\u63CF\u4EFB\u52A1\u5199\u5165\u3002\u5728\u5B83\u4E3A\u5F53\u524D\u5B63\u5EA6\u9996\u6B21\u8DD1\u5B8C\u4E4B\u524D\uFF0C\u672C\u89C6\u56FE\u4E3A\u7A7A\u2014\u2014\u5DF2\u7ED3\u675F\u7684\u5B63\u5EA6\u8BF7\u89C1\u201C\u5168\u90E8\u201D\u6807\u7B7E\u9875\u3002" - } - }, - my_forecast: { label: "\u6211\u7684\u9884\u6D4B" } - }, - _sections: { - basic: { label: "\u5FEB\u7167" }, - amounts: { label: "\u91D1\u989D" }, - meta: { label: "\u6765\u6E90" }, - // forecast.view.ts 表单区块名称 (#1100) - snapshot: { label: "\u5FEB\u7167" }, - notes: { label: "\u5907\u6CE8" } - } - } -}; - -// src/sales/translations/zh-CN/objects.commerce.ts -var commerce2 = { - crm_quote: { - _validations: { - discount_within_ceiling: { - message: "\u6298\u6263\u4E0D\u80FD\u8D85\u8FC7 60%" - }, - expiration_after_quote: { - message: "\u5931\u6548\u65E5\u671F\u5FC5\u987B\u665A\u4E8E\u62A5\u4EF7\u65E5\u671F" - }, - quote_status_progression: { - message: "\u65E0\u6548\u7684\u62A5\u4EF7\u5355\u72B6\u6001\u6D41\u8F6C" - } - }, - label: "\u62A5\u4EF7\u5355", - pluralLabel: "\u62A5\u4EF7\u5355", - description: "\u53D1\u9001\u7ED9\u5BA2\u6237\u7684\u4EF7\u683C\u62A5\u4EF7", - fields: { - quote_number: { label: "\u62A5\u4EF7\u5355\u7F16\u53F7" }, - name: { label: "\u62A5\u4EF7\u540D\u79F0" }, - crm_account: { label: "\u6240\u5C5E\u5BA2\u6237" }, - crm_opportunity: { label: "\u5173\u8054\u5546\u673A" }, - status: { - label: "\u72B6\u6001", - options: { - draft: "\u8349\u7A3F", - in_review: "\u5BA1\u6838\u4E2D", - presented: "\u5DF2\u63D0\u4EA4", - accepted: "\u5DF2\u63A5\u53D7", - rejected: "\u5DF2\u62D2\u7EDD", - expired: "\u5DF2\u8FC7\u671F" - } - }, - total_price: { label: "\u603B\u91D1\u989D" }, - discount: { label: "\u6298\u6263 (%)" }, - expiration_date: { label: "\u5230\u671F\u65E5\u671F" }, - description: { label: "\u63CF\u8FF0" }, - crm_contact: { - label: "\u8054\u7CFB\u4EBA", - help: "\u62A5\u4EF7\u8FDB\u5165\u300C\u5DF2\u63D0\u4EA4\u300D\u6216\u300C\u5DF2\u63A5\u53D7\u300D\u540E\u5FC5\u586B \u2014\u2014 \u8D77\u8349\u7684\u5408\u540C\u4ECE\u8FD9\u91CC\u53D6\u4E3B\u8981\u8054\u7CFB\u4EBA\u3002" - }, - owner_id: { label: "\u62A5\u4EF7\u8D1F\u8D23\u4EBA" }, - quote_date: { label: "\u62A5\u4EF7\u65E5\u671F" }, - subtotal: { label: "\u5C0F\u8BA1" }, - discount_amount: { label: "\u6298\u6263\u91D1\u989D" }, - tax: { label: "\u7A0E\u989D" }, - shipping_handling: { label: "\u8FD0\u8D39\u53CA\u624B\u7EED\u8D39" }, - payment_terms: { - label: "\u4ED8\u6B3E\u6761\u6B3E", - options: { - net_15: "15 \u5929\u8D26\u671F", - net_30: "30 \u5929\u8D26\u671F", - net_60: "60 \u5929\u8D26\u671F", - net_90: "90 \u5929\u8D26\u671F", - due_on_receipt: "\u8D27\u5230\u4ED8\u6B3E" - } - }, - shipping_terms: { label: "\u8FD0\u8F93\u6761\u6B3E" }, - billing_address: { label: "\u8D26\u5355\u5730\u5740" }, - shipping_address: { label: "\u6536\u8D27\u5730\u5740" }, - internal_notes: { label: "\u5185\u90E8\u5907\u6CE8" }, - display_title: { label: "\u663E\u793A\u540D\u79F0" } - }, - _views: { - all_quotes: { label: "\u5168\u90E8\u62A5\u4EF7\u5355" }, - quote_pipeline: { label: "\u62A5\u4EF7\u6D41\u6C34\u7EBF" }, - quote_calendar: { label: "\u62A5\u4EF7\u65E5\u5386" } - }, - _sections: { - basic: { label: "\u62A5\u4EF7\u4FE1\u606F" }, - pricing: { label: "\u4EF7\u683C" }, - terms: { label: "\u6761\u6B3E\u4E0E\u6709\u6548\u671F" }, - address: { label: "\u5730\u5740" }, - system: { label: "\u7CFB\u7EDF" }, - // quote.view.ts 表单区块名称 (#1100) - quote: { label: "\u62A5\u4EF7\u5355" }, - totals: { label: "\u5408\u8BA1" }, - quote_terms: { label: "\u6761\u6B3E" }, - addresses_and_notes: { label: "\u5730\u5740\u4E0E\u5907\u6CE8" } - } - }, - crm_quote_line_item: { - _validations: { - discount_within_ceiling: { - message: "\u884C\u6298\u6263\u4E0D\u80FD\u8D85\u8FC7 60%" - }, - unit_price_positive: { - message: "\u9500\u552E\u4EF7\u683C\u4E0D\u80FD\u4E3A\u8D1F\u6570" - } - }, - label: "\u62A5\u4EF7\u5355\u660E\u7EC6", - pluralLabel: "\u62A5\u4EF7\u5355\u660E\u7EC6", - description: "\u62A5\u4EF7\u5355\u4E0B\u6309\u4EA7\u54C1\u62C6\u5206\u7684\u62A5\u4EF7\u884C", - fields: { - crm_quote: { label: "\u5173\u8054\u62A5\u4EF7\u5355" }, - crm_product: { label: "\u4EA7\u54C1" }, - description: { label: "\u63CF\u8FF0" }, - quantity: { label: "\u6570\u91CF" }, - list_price: { label: "\u6807\u4EF7" }, - unit_price: { label: "\u9500\u552E\u5355\u4EF7" }, - discount: { label: "\u6298\u6263\uFF08%\uFF09" }, - subtotal: { label: "\u5C0F\u8BA1" }, - total_price: { label: "\u603B\u8BA1" }, - line_number: { label: "\u884C\u53F7" } - }, - _sections: { - basic: { label: "\u660E\u7EC6\u884C" }, - pricing: { label: "\u4EF7\u683C" } - } - }, - crm_contract: { - _validations: { - end_after_start: { - message: "\u7ED3\u675F\u65E5\u671F\u5FC5\u987B\u665A\u4E8E\u5F00\u59CB\u65E5\u671F" - }, - contract_status_progression: { - message: "\u65E0\u6548\u7684\u5408\u540C\u72B6\u6001\u6D41\u8F6C" - } - }, - label: "\u5408\u540C", - pluralLabel: "\u5408\u540C", - description: "\u4E0E\u5BA2\u6237\u7B7E\u7F72\u7684\u6CD5\u5F8B\u5408\u540C", - fields: { - contract_number: { label: "\u5408\u540C\u7F16\u53F7" }, - crm_account: { label: "\u6240\u5C5E\u5BA2\u6237" }, - status: { - label: "\u72B6\u6001", - options: { - draft: "\u8349\u7A3F", - in_approval: "\u5BA1\u6279\u4E2D", - activated: "\u5DF2\u6FC0\u6D3B", - expired: "\u5DF2\u8FC7\u671F", - terminated: "\u5DF2\u7EC8\u6B62" - } - }, - start_date: { label: "\u5F00\u59CB\u65E5\u671F" }, - end_date: { label: "\u7ED3\u675F\u65E5\u671F" }, - contract_value: { label: "\u5408\u540C\u91D1\u989D" }, - description: { label: "\u63CF\u8FF0" }, - crm_contact: { label: "\u4E3B\u8981\u8054\u7CFB\u4EBA" }, - crm_opportunity: { label: "\u5173\u8054\u5546\u673A" }, - owner_id: { label: "\u5408\u540C\u8D1F\u8D23\u4EBA" }, - contract_term_months: { label: "\u5408\u540C\u671F\u9650\uFF08\u6708\uFF09" }, - billing_frequency: { - label: "\u8BA1\u8D39\u5468\u671F", - options: { monthly: "\u6309\u6708", quarterly: "\u6309\u5B63\u5EA6", annually: "\u6309\u5E74", one_time: "\u4E00\u6B21\u6027" } - }, - payment_terms: { - label: "\u4ED8\u6B3E\u6761\u6B3E", - options: { - net_15: "15 \u5929\u8D26\u671F", - net_30: "30 \u5929\u8D26\u671F", - net_60: "60 \u5929\u8D26\u671F", - net_90: "90 \u5929\u8D26\u671F", - due_on_receipt: "\u8D27\u5230\u4ED8\u6B3E" - } - }, - auto_renewal: { label: "\u81EA\u52A8\u7EED\u7EA6" }, - renewal_notice_days: { label: "\u7EED\u7EA6\u901A\u77E5\uFF08\u5929\uFF09" }, - contract_type: { - label: "\u5408\u540C\u7C7B\u578B", - options: { - subscription: "\u8BA2\u9605\u5408\u540C", - service: "\u670D\u52A1\u534F\u8BAE", - license: "\u6388\u6743\u8BB8\u53EF", - partnership: "\u5408\u4F5C\u534F\u8BAE", - nda: "\u4FDD\u5BC6\u534F\u8BAE", - msa: "\u4E3B\u670D\u52A1\u534F\u8BAE" - } - }, - signed_date: { label: "\u7B7E\u7F72\u65E5\u671F" }, - signed_by: { label: "\u7B7E\u7F72\u4EBA" }, - document_url: { label: "\u5408\u540C\u6587\u6863" }, - special_terms: { label: "\u7279\u6B8A\u6761\u6B3E" }, - billing_address: { label: "\u8D26\u5355\u5730\u5740" } - }, - _views: { - all_contracts: { label: "\u5168\u90E8\u5408\u540C" }, - renewal_calendar: { label: "\u7EED\u7EA6\u65E5\u5386" }, - contract_gantt: { label: "\u5408\u540C\u6761\u6B3E" }, - contract_timeline: { label: "\u5408\u540C\u65F6\u95F4\u7EBF" } - }, - _sections: { - basic: { label: "\u5408\u540C\u4FE1\u606F" }, - parties: { label: "\u7B7E\u7EA6\u65B9" }, - terms: { label: "\u6761\u6B3E\u4E0E\u65E5\u671F" }, - value: { label: "\u5408\u540C\u91D1\u989D" }, - status: { label: "\u72B6\u6001\u4E0E\u5BA1\u6279" }, - renewal: { label: "\u7EED\u7EA6" }, - // contract.view.ts 表单区块名称 (#1100) - contract_terms: { label: "\u6761\u6B3E" }, - signing_and_documents: { label: "\u7B7E\u7F72\u4E0E\u6587\u4EF6" }, - notes: { label: "\u5907\u6CE8" } - } - }, - crm_product: { - _validations: { - cost_less_than_price: { - message: "\u6210\u672C\u5E94\u4F4E\u4E8E\u6807\u4EF7" - }, - price_positive: { - message: "\u6807\u4EF7\u5FC5\u987B\u4E3A\u6B63\u6570" - } - }, - label: "\u4EA7\u54C1", - pluralLabel: "\u4EA7\u54C1", - description: "\u516C\u53F8\u63D0\u4F9B\u7684\u4EA7\u54C1\u4E0E\u670D\u52A1", - fields: { - product_code: { label: "\u4EA7\u54C1\u4EE3\u7801" }, - name: { label: "\u4EA7\u54C1\u540D\u79F0" }, - category: { - label: "\u4EA7\u54C1\u7C7B\u522B", - options: { - software: "\u8F6F\u4EF6", - hardware: "\u786C\u4EF6", - service: "\u670D\u52A1", - subscription: "\u8BA2\u9605", - support: "\u652F\u6301\u670D\u52A1" - } - }, - cost: { label: "\u6210\u672C" }, - is_active: { label: "\u662F\u5426\u542F\u7528" }, - description: { label: "\u63CF\u8FF0" }, - family: { - label: "\u4EA7\u54C1\u7CFB\u5217", - options: { - enterprise: "\u4F01\u4E1A\u7EA7\u65B9\u6848", - smb: "\u4E2D\u5C0F\u4F01\u4E1A\u65B9\u6848", - services: "\u4E13\u4E1A\u670D\u52A1", - cloud: "\u4E91\u670D\u52A1" - } - }, - list_price: { label: "\u6807\u4EF7" }, - sku: { label: "SKU" }, - product_manager: { label: "\u4EA7\u54C1\u7ECF\u7406" }, - image: { label: "\u4EA7\u54C1\u56FE\u7247" }, - datasheet: { label: "\u89C4\u683C\u4E66" }, - display_title: { label: "\u663E\u793A\u540D\u79F0" } - }, - _views: { - all_products: { label: "\u5168\u90E8\u4EA7\u54C1" }, - product_catalog: { label: "\u4EA7\u54C1\u76EE\u5F55" } - }, - _sections: { - basic: { label: "\u4EA7\u54C1\u4FE1\u606F" }, - pricing: { label: "\u4EF7\u683C" }, - metadata: { label: "\u8D44\u6E90" }, - // product.view.ts 表单区块名称 (#1100) - product_info: { label: "\u4EA7\u54C1\u4FE1\u606F" }, - pricing_info: { label: "\u5B9A\u4EF7" }, - media: { label: "\u5A92\u4F53" } - } - } -}; - -// src/sales/translations/zh-CN/objects.service.ts -var service2 = { - crm_case: { - _validations: { - resolution_required_for_closed: { - message: "\u5173\u95ED\u5DE5\u5355\u65F6\u5FC5\u987B\u586B\u5199\u89E3\u51B3\u65B9\u6848" - }, - escalation_reason_required: { - message: "\u5347\u7EA7\u5DE5\u5355\u65F6\u5FC5\u987B\u586B\u5199\u5347\u7EA7\u539F\u56E0" - }, - case_status_progression: { - message: "\u65E0\u6548\u7684\u72B6\u6001\u6D41\u8F6C" - } - }, - label: "\u5DE5\u5355", - pluralLabel: "\u5DE5\u5355", - description: "\u5BA2\u6237\u652F\u6301\u5DE5\u5355\u4E0E\u670D\u52A1\u8BF7\u6C42", - fields: { - case_number: { label: "\u5DE5\u5355\u7F16\u53F7" }, - subject: { label: "\u4E3B\u9898" }, - description: { label: "\u63CF\u8FF0" }, - crm_account: { label: "\u6240\u5C5E\u5BA2\u6237" }, - crm_contact: { label: "\u8054\u7CFB\u4EBA" }, - status: { - label: "\u72B6\u6001", - options: { - new: "\u65B0\u5EFA", - in_progress: "\u5904\u7406\u4E2D", - waiting_customer: "\u7B49\u5F85\u5BA2\u6237\u56DE\u590D", - waiting_support: "\u7B49\u5F85\u652F\u6301\u56DE\u590D", - escalated: "\u5DF2\u5347\u7EA7", - resolved: "\u5DF2\u89E3\u51B3", - closed: "\u5DF2\u5173\u95ED" - } - }, - priority: { - // `critical` MUST NOT render 紧急 — that word belongs to - // `crm_task.priority.urgent`, and the two vocabularies are different - // sets (case: low/medium/high/critical · task: low/normal/high/urgent). - // When both rendered 紧急 the screen showed one word for two values the - // model treats as distinct, which is how a case value ends up in a task - // predicate (`src/sales/views/task.view.ts` carries the tombstone of that - // crossing). Maintainer ruling 2026-08-31, #1342: case `critical` is - // 严重, task `urgent` keeps 紧急. en/es-ES/ja-JP already separate them - // (Critical/Urgent · Crítica/Urgente · 重大/緊急); zh-CN was the outlier. - label: "\u4F18\u5148\u7EA7", - options: { low: "\u4F4E", medium: "\u4E2D", high: "\u9AD8", critical: "\u4E25\u91CD" } - }, - type: { - label: "\u7C7B\u578B", - options: { - question: "\u54A8\u8BE2", - problem: "\u6545\u969C", - feature_request: "\u529F\u80FD\u9700\u6C42", - bug: "\u7F3A\u9677" - } - }, - owner_id: { label: "\u8D1F\u8D23\u4EBA" }, - origin: { - label: "\u5DE5\u5355\u6765\u6E90", - options: { email: "\u90AE\u4EF6", phone: "\u7535\u8BDD", web: "\u7F51\u7AD9", chat: "\u5728\u7EBF\u5BA2\u670D", social_media: "\u793E\u4EA4\u5A92\u4F53" } - }, - closed_date: { label: "\u5173\u95ED\u65E5\u671F" }, - first_response_date: { label: "\u9996\u6B21\u54CD\u5E94\u65E5\u671F" }, - resolution_time_hours: { label: "\u89E3\u51B3\u8017\u65F6\uFF08\u5C0F\u65F6\uFF09" }, - sla_due_date: { label: "SLA \u5230\u671F", help: "\u6309\u5DE5\u5355\u4F18\u5148\u7EA7\u4E0E\u6240\u5C5E\u5BA2\u6237\u7684\u5BA2\u6237\u5206\u5C42\u8BBE\u5B9A\uFF0C\u4EE5\u65E5\u5386\u5C0F\u65F6\u8BA1\uFF1A\u591C\u95F4\u3001\u5468\u672B\u4E0E\u8282\u5047\u65E5\u90FD\u8BA1\u5165\u3002" }, - is_sla_violated: { label: "SLA \u8FDD\u53CD" }, - is_escalated: { label: "\u5DF2\u5347\u7EA7" }, - escalation_reason: { label: "\u5347\u7EA7\u539F\u56E0" }, - resolution: { label: "\u89E3\u51B3\u65B9\u6848" }, - resolved_by_article: { label: "\u89E3\u51B3\u8BE5\u5DE5\u5355\u7684\u77E5\u8BC6\u6587\u7AE0", help: "\u89E3\u51B3\u6B64\u5DE5\u5355\u7684\u77E5\u8BC6\u5E93\u6587\u7AE0 \u2014\u2014 \u8F6C\u79FB\u7387\u7684\u7EDF\u8BA1\u53E3\u5F84\u3002" }, - internal_notes: { label: "\u5185\u90E8\u5907\u6CE8", help: "\u5185\u90E8\u5907\u6CE8\uFF0C\u5BA2\u6237\u4E0D\u53EF\u89C1" }, - is_closed: { label: "\u662F\u5426\u5173\u95ED" }, - display_title: { label: "\u663E\u793A\u540D\u79F0" }, - priority_rank: { label: "\u4F18\u5148\u7EA7\u6392\u5E8F" }, - escalated_date: { label: "\u5347\u7EA7\u65E5\u671F" } - }, - _views: { - all_cases: { label: "\u5168\u90E8\u5DE5\u5355" }, - case_workflow: { label: "\u670D\u52A1\u6D41\u8F6C" }, - sla_calendar: { label: "SLA \u65E5\u5386" }, - case_timeline: { label: "\u5DE5\u5355\u65F6\u95F4\u7EBF" }, - unassigned_triage: { - label: "\u672A\u5206\u6D3E \u2014 \u5F85\u5206\u8BCA", - emptyState: { - title: "\u6CA1\u6709\u5F85\u5206\u8BCA\u7684\u5DE5\u5355", - message: "\u6240\u6709\u5DE5\u5355\u90FD\u6709\u8D1F\u8D23\u4EBA\u3002\u5F53\u5DE5\u5355\u5230\u8FBE\u65F6\u6CA1\u6709\u8D1F\u8D23\u4EBA\uFF0C\u5C31\u4F1A\u51FA\u73B0\u5728\u8FD9\u91CC \u2014\u2014 \u901A\u5E38\u662F\u5728\u65E0\u4EBA\u62C5\u4EFB\u300C\u5BA2\u670D\u4E13\u5458\u300D\u804C\u4F4D\u671F\u95F4\u63D0\u4EA4\u7684\u7F51\u9875\u8F6C\u5DE5\u5355\u3002" - } - }, - escalated_cases: { label: "\u5DF2\u5347\u7EA7\u5DE5\u5355" }, - my_open_cases: { label: "\u6211\u7684\u5F85\u5904\u7406\u5DE5\u5355" }, - sla_at_risk: { label: "\u23F0 SLA \u98CE\u9669\u9884\u8B66" } - }, - _actions: { - ...activityActions2, - escalate_case: { - label: "\u5347\u7EA7\u5DE5\u5355", - confirmText: "\u6B64\u64CD\u4F5C\u4F1A\u5C06\u5DE5\u5355\u5347\u7EA7\u5230\u5347\u7EA7\u5904\u7406\u56E2\u961F\uFF0C\u662F\u5426\u7EE7\u7EED\uFF1F", - successMessage: "\u5DE5\u5355\u5347\u7EA7\u6210\u529F\uFF01" - }, - close_case: { - label: "\u5173\u95ED\u5DE5\u5355", - confirmText: "\u786E\u5B9A\u8981\u5173\u95ED\u6B64\u5DE5\u5355\u5417\uFF1F", - successMessage: "\u5DE5\u5355\u5DF2\u6210\u529F\u5173\u95ED\uFF01" - }, - claim_case: { - label: "\u8BA4\u9886\u5DE5\u5355", - successMessage: "\u5DE5\u5355\u5DF2\u8BA4\u9886\uFF0C\u73B0\u5728\u5F52\u4F60\u8D1F\u8D23\u3002" - } - }, - _sections: { - // case.view.ts 表单区块名称 (#1100)。 - case: { label: "\u5DE5\u5355" }, - how_can_we_help: { label: "\u6211\u4EEC\u80FD\u5E2E\u60A8\u4EC0\u4E48\uFF1F" }, - // Object-level section keys (case.object.ts), used by record forms and - // by the detail page, whose sections reference these groups (#970) - basic: { label: "\u5DE5\u5355\u4FE1\u606F" }, - origin: { label: "\u6765\u6E90\u4E0E\u8DEF\u7531" }, - sla: { label: "SLA \u4E0E\u4F18\u5148\u7EA7" }, - resolution: { label: "\u89E3\u51B3\u65B9\u6848" }, - escalation: { label: "\u5347\u7EA7" }, - system: { label: "\u7CFB\u7EDF" } - } - }, - crm_knowledge_article: { - _validations: { - published_requires_body: { - message: "\u6CA1\u6709\u6B63\u6587\u7684\u6587\u7AE0\u65E0\u6CD5\u53D1\u5E03\u3002" - }, - published_requires_summary: { - message: "\u5DF2\u53D1\u5E03\u7684\u6587\u7AE0\u5E94\u586B\u5199\u6458\u8981\uFF0C\u4F9B\u641C\u7D22\u7ED3\u679C\u4E0E AI \u5F15\u7528\u4F7F\u7528\u3002" - } - }, - label: "\u77E5\u8BC6\u6587\u7AE0", - pluralLabel: "\u77E5\u8BC6\u5E93", - description: "\u9762\u5411\u5BA2\u6237\u548C\u5750\u5E2D\u7684\u53EF\u590D\u7528\u95EE\u7B54\u4E0E\u64CD\u4F5C\u6307\u5357", - fields: { - article_number: { label: "\u6587\u7AE0\u7F16\u53F7" }, - title: { label: "\u6807\u9898" }, - summary: { label: "\u6458\u8981", help: "\u4E00\u6BB5\u8BDD\u6458\u8981\uFF0C\u663E\u793A\u5728\u641C\u7D22\u7ED3\u679C\u548C AI \u5F15\u7528\u4E2D\u3002" }, - body: { label: "\u6B63\u6587", help: "\u6587\u7AE0\u6B63\u6587\uFF08Markdown\uFF09\u3002" }, - category: { - label: "\u5206\u7C7B", - options: { - getting_started: "\u5165\u95E8\u6307\u5357", - how_to: "\u64CD\u4F5C\u6307\u5357", - troubleshooting: "\u6545\u969C\u6392\u67E5", - billing: "\u8D26\u52A1\u4E0E\u4EF7\u683C", - api: "API \u4E0E\u96C6\u6210", - release_notes: "\u7248\u672C\u8BF4\u660E", - policy: "\u653F\u7B56\u5236\u5EA6" - } - }, - tags: { - label: "\u6807\u7B7E", - options: { - auth: "\u8EAB\u4EFD\u8BA4\u8BC1", - sso: "\u5355\u70B9\u767B\u5F55", - mobile: "\u79FB\u52A8\u7AEF", - email: "\u90AE\u4EF6", - reports: "\u62A5\u8868", - performance: "\u6027\u80FD", - data_import: "\u6570\u636E\u5BFC\u5165", - webhooks: "Webhook" - } - }, - status: { - label: "\u72B6\u6001", - options: { draft: "\u8349\u7A3F", in_review: "\u5BA1\u6838\u4E2D", published: "\u5DF2\u53D1\u5E03", archived: "\u5DF2\u5F52\u6863" } - }, - audience: { label: "\u53D7\u4F17", options: { public: "\u516C\u5F00", internal: "\u4EC5\u5185\u90E8" }, help: "\u516C\u5F00\u6587\u7AE0\u5728\u5BA2\u6237\u95E8\u6237\u53EF\u89C1\uFF1B\u5185\u90E8\u6587\u7AE0\u4EC5\u5BA2\u670D\u53EF\u89C1\u3002" }, - language: { - label: "\u8BED\u8A00", - options: { en: "\u82F1\u8BED", zh_cn: "\u7B80\u4F53\u4E2D\u6587", es_es: "\u897F\u73ED\u7259\u8BED", ja_jp: "\u65E5\u8BED" } - }, - owner_id: { label: "\u8D1F\u8D23\u4EBA" }, - related_to_case: { label: "\u6765\u6E90\u5DE5\u5355", help: "\u672C\u6587\u6240\u4F9D\u636E\u7684\u5DE5\u5355\uFF08\u53EF\u9009\uFF09\u3002" }, - published_at: { label: "\u53D1\u5E03\u65F6\u95F4" }, - last_reviewed_at: { label: "\u6700\u8FD1\u590D\u6838" }, - helpful_count: { label: "\u6709\u7528", help: "\u7531 crm_article_feedback \u91CD\u65B0\u7EDF\u8BA1\u5F97\u51FA\uFF0C\u4E0D\u53EF\u624B\u5DE5\u586B\u5199\u3002" }, - not_helpful_count: { label: "\u6CA1\u7528", help: "\u7531 crm_article_feedback \u91CD\u65B0\u7EDF\u8BA1\u5F97\u51FA\uFF0C\u4E0D\u53EF\u624B\u5DE5\u586B\u5199\u3002" }, - display_title: { label: "\u663E\u793A\u540D\u79F0" } - }, - _views: { - all_articles: { label: "\u5168\u90E8\u6587\u7AE0" }, - published_articles: { label: "\u5DF2\u53D1\u5E03" }, - my_drafts: { label: "\u6211\u7684\u8349\u7A3F" } - }, - _sections: { - basic: { label: "\u6587\u7AE0\u4FE1\u606F" }, - content: { label: "\u5185\u5BB9" }, - taxonomy: { label: "\u5206\u7C7B" }, - metrics: { label: "\u4E92\u52A8\u6570\u636E" }, - engagement: { label: "\u4E92\u52A8\u6570\u636E" }, - // knowledge_article.view.ts 表单区块名称 (#1100) - article: { label: "\u6587\u7AE0" } - }, - _actions: { - mark_article_helpful: { - label: "\u6709\u7528", - successMessage: "\u5DF2\u8BB0\u5F55\u4E3A\u300C\u6709\u7528\u300D\uFF0C\u8C22\u8C22\u53CD\u9988\u3002" - }, - mark_article_not_helpful: { - label: "\u6CA1\u7528", - successMessage: "\u5DF2\u8BB0\u5F55\u4E3A\u300C\u6CA1\u7528\u300D\uFF0C\u8C22\u8C22\u53CD\u9988\u3002" - } - } - }, - crm_article_feedback: { - label: "\u6587\u7AE0\u53CD\u9988", - pluralLabel: "\u6587\u7AE0\u53CD\u9988", - description: "\u8BFB\u8005\u5BF9\u67D0\u7BC7\u77E5\u8BC6\u6587\u7AE0\u7684\u300C\u6709\u7528 / \u6CA1\u7528\u300D\u8BC4\u4EF7", - fields: { - feedback_number: { label: "\u53CD\u9988\u7F16\u53F7" }, - owner_id: { label: "\u8BFB\u8005" }, - crm_knowledge_article: { label: "\u6587\u7AE0", help: "\u672C\u6761\u53CD\u9988\u9488\u5BF9\u7684\u77E5\u8BC6\u6587\u7AE0\u3002" }, - verdict: { - label: "\u8BC4\u4EF7", - options: { helpful: "\u6709\u7528", not_helpful: "\u6CA1\u7528" } - }, - comment: { label: "\u5907\u6CE8", help: "\u53EF\u9009\u8BF4\u660E\uFF0C\u4F5C\u8005\u53EF\u89C1\u3002" } - }, - _sections: { - basic: { label: "\u53CD\u9988" } - } - } -}; - -// src/sales/translations/zh-CN/objects.activity.ts -var activity2 = { - crm_task: { - _validations: { - completed_date_required: { - message: "\u72B6\u6001\u4E3A\u5DF2\u5B8C\u6210\u65F6\u5FC5\u987B\u586B\u5199\u5B8C\u6210\u65E5\u671F" - }, - recurrence_fields_required: { - message: "\u91CD\u590D\u4EFB\u52A1\u5FC5\u987B\u586B\u5199\u91CD\u590D\u7C7B\u578B" - }, - related_to_required: { - message: "\u81F3\u5C11\u9700\u8981\u9009\u62E9\u4E00\u6761\u5173\u8054\u8BB0\u5F55" - } - }, - label: "\u4EFB\u52A1", - pluralLabel: "\u4EFB\u52A1", - description: "\u6D3B\u52A8\u4E0E\u5F85\u529E\u4E8B\u9879", - fields: { - subject: { label: "\u4E3B\u9898" }, - description: { label: "\u63CF\u8FF0" }, - status: { - label: "\u72B6\u6001", - options: { - not_started: "\u672A\u5F00\u59CB", - in_progress: "\u8FDB\u884C\u4E2D", - waiting: "\u7B49\u5F85\u4E2D", - completed: "\u5DF2\u5B8C\u6210", - deferred: "\u5DF2\u63A8\u8FDF" - } - }, - priority: { - // `urgent` KEEPS 紧急, and ⛔ nothing may re-point it at `crm_case`'s - // top value: the two vocabularies are different sets (task: - // low/normal/high/urgent · case: low/medium/high/critical), so the two - // zh-CN words must stay different or the screen stops distinguishing - // two values the model treats as distinct — the crossing - // `src/sales/views/task.view.ts` carries the tombstone of. Maintainer ruling - // 2026-08-31, #1342: 紧急 stays here (urgent is this object's literal - // word) and case `critical` moved to 严重. - label: "\u4F18\u5148\u7EA7", - options: { low: "\u4F4E", normal: "\u666E\u901A", high: "\u9AD8", urgent: "\u7D27\u6025" } - }, - due_date: { label: "\u622A\u6B62\u65E5\u671F" }, - type: { - label: "\u4EFB\u52A1\u7C7B\u578B", - options: { - call: "\u7535\u8BDD", - email: "\u90AE\u4EF6", - meeting: "\u4F1A\u8BAE", - follow_up: "\u8DDF\u8FDB", - demo: "\u6F14\u793A", - other: "\u5176\u4ED6" - } - }, - reminder_date: { label: "\u63D0\u9192\u65F6\u95F4" }, - completed_date: { label: "\u5B8C\u6210\u65E5\u671F" }, - owner_id: { label: "\u8D1F\u8D23\u4EBA" }, - related_to_type: { - label: "\u5173\u8054\u5BF9\u8C61\u7C7B\u578B", - options: { - crm_account: "\u5BA2\u6237", - crm_contact: "\u8054\u7CFB\u4EBA", - crm_opportunity: "\u5546\u673A", - crm_lead: "\u7EBF\u7D22", - crm_case: "\u5DE5\u5355" - } - }, - related_to_account: { label: "\u5173\u8054\u5BA2\u6237" }, - related_to_contact: { label: "\u5173\u8054\u8054\u7CFB\u4EBA" }, - related_to_opportunity: { label: "\u5173\u8054\u5546\u673A" }, - related_to_lead: { label: "\u5173\u8054\u7EBF\u7D22" }, - related_to_case: { label: "\u5173\u8054\u5DE5\u5355" }, - is_recurring: { label: "\u91CD\u590D\u4EFB\u52A1" }, - recurrence_type: { - label: "\u91CD\u590D\u7C7B\u578B", - options: { daily: "\u6BCF\u65E5", weekly: "\u6BCF\u5468", monthly: "\u6BCF\u6708", yearly: "\u6BCF\u5E74" } - }, - recurrence_interval: { label: "\u91CD\u590D\u95F4\u9694" }, - recurrence_end_date: { label: "\u91CD\u590D\u7ED3\u675F\u65E5\u671F" }, - is_completed: { label: "\u662F\u5426\u5B8C\u6210" }, - is_overdue: { label: "\u662F\u5426\u903E\u671F" }, - progress_percent: { label: "\u8FDB\u5EA6\uFF08%\uFF09" }, - priority_rank: { label: "\u4F18\u5148\u7EA7\u6392\u5E8F" }, - reminder_sent: { label: "\u63D0\u9192\u5DF2\u53D1\u9001" } - }, - _sections: { - basic: { label: "\u4EFB\u52A1\u4FE1\u606F" }, - scheduling: { label: "\u65E5\u7A0B\u5B89\u6392" }, - related: { label: "\u5173\u8054\u8BB0\u5F55" }, - recurrence: { label: "\u91CD\u590D\u89C4\u5219" }, - system: { label: "\u7CFB\u7EDF" }, - effort: { label: "\u8FDB\u5EA6\u4E0E\u5DE5\u65F6" }, - // task.view.ts 表单区块名称 (#1100) - task: { label: "\u4EFB\u52A1" }, - related_records: { label: "\u5173\u8054\u8BB0\u5F55" }, - recurrence_and_effort: { label: "\u91CD\u590D\u4E0E\u5DE5\u65F6" } - }, - _views: { - all_tasks: { label: "\u5168\u90E8\u4EFB\u52A1" }, - task_board: { label: "\u4EFB\u52A1\u770B\u677F" }, - task_calendar: { label: "\u4EFB\u52A1\u65E5\u7A0B" }, - task_gantt: { label: "\u6267\u884C\u8BA1\u5212" }, - task_timeline: { label: "\u5DE5\u65F6\u65F6\u95F4\u7EBF" }, - my_open_tasks: { label: "\u6211\u7684\u5F85\u529E\u4EFB\u52A1" }, - todays_tasks: { label: "\u{1F4C5} \u6211\u7684\u4F18\u5148\u4EFB\u52A1" }, - overdue_tasks: { label: "\u23F0 \u5F85\u529E\u4EFB\u52A1 \xB7 \u6309\u903E\u671F\u65F6\u957F\u6392\u5E8F" } - } - }, - crm_event: { - _validations: { - end_after_start: { - message: "\u7ED3\u675F\u65F6\u95F4\u5FC5\u987B\u665A\u4E8E\u5F00\u59CB\u65F6\u95F4" - }, - related_to_required: { - message: "\u81F3\u5C11\u9700\u8981\u9009\u62E9\u4E00\u6761\u5173\u8054\u8BB0\u5F55" - } - }, - label: "\u6D3B\u52A8", - pluralLabel: "\u6D3B\u52A8", - description: "\u4E0E\u5BA2\u6237\u7684\u4F1A\u8BAE\u3001\u901A\u8BDD\u53CA\u5176\u4ED6\u5DF2\u5B89\u6392\u7684\u4E92\u52A8", - fields: { - subject: { label: "\u4E3B\u9898" }, - description: { label: "\u63CF\u8FF0" }, - type: { - label: "\u6D3B\u52A8\u7C7B\u578B", - options: { - meeting: "\u4F1A\u8BAE", - call: "\u7535\u8BDD", - demo: "\u6F14\u793A", - webinar: "\u7EBF\u4E0A\u7814\u8BA8\u4F1A", - onsite_visit: "\u4E0A\u95E8\u62DC\u8BBF", - other: "\u5176\u4ED6" - } - }, - status: { - label: "\u72B6\u6001", - options: { - planned: "\u5DF2\u8BA1\u5212", - held: "\u5DF2\u4E3E\u884C", - cancelled: "\u5DF2\u53D6\u6D88", - no_show: "\u5BA2\u6237\u672A\u5230" - } - }, - owner_id: { label: "\u8D1F\u8D23\u4EBA" }, - start_datetime: { label: "\u5F00\u59CB\u65F6\u95F4" }, - end_datetime: { label: "\u7ED3\u675F\u65F6\u95F4" }, - all_day: { label: "\u5168\u5929\u6D3B\u52A8" }, - duration_minutes: { label: "\u65F6\u957F\uFF08\u5206\u949F\uFF09" }, - location: { label: "\u5730\u70B9", help: "\u4F1A\u8BAE\u5BA4\u3001\u5730\u5740\u6216\u4F1A\u8BAE\u94FE\u63A5" }, - related_to_type: { - label: "\u5173\u8054\u5BF9\u8C61\u7C7B\u578B", - options: { - crm_account: "\u5BA2\u6237", - crm_contact: "\u8054\u7CFB\u4EBA", - crm_opportunity: "\u5546\u673A", - crm_lead: "\u7EBF\u7D22", - crm_case: "\u5DE5\u5355" - } - }, - related_to_account: { label: "\u5173\u8054\u5BA2\u6237" }, - related_to_contact: { label: "\u5173\u8054\u8054\u7CFB\u4EBA" }, - related_to_opportunity: { label: "\u5173\u8054\u5546\u673A" }, - related_to_lead: { label: "\u5173\u8054\u7EBF\u7D22" }, - related_to_case: { label: "\u5173\u8054\u5DE5\u5355" }, - outcome_notes: { label: "\u4F1A\u540E\u7EAA\u8981", help: "\u8FBE\u6210\u4E86\u4EC0\u4E48\u5171\u8BC6\uFF0C\u4E0B\u4E00\u6B65\u505A\u4EC0\u4E48" } - }, - _sections: { - basic: { label: "\u6D3B\u52A8\u4FE1\u606F" }, - schedule: { label: "\u65E5\u7A0B\u5B89\u6392" }, - related: { label: "\u5173\u8054\u8BB0\u5F55" }, - outcome: { label: "\u7ED3\u679C" }, - // event.view.ts 表单区块名称 (#1100) - event: { label: "\u6D3B\u52A8" }, - related_records: { label: "\u5173\u8054\u8BB0\u5F55" } - }, - _views: { - all_events: { label: "\u5168\u90E8\u6D3B\u52A8" }, - event_calendar: { label: "\u6D3B\u52A8\u65E5\u5386" }, - event_timeline: { label: "\u56E2\u961F\u65E5\u7A0B" }, - my_events: { label: "\u6211\u7684\u65E5\u5386" }, - upcoming_events: { label: "\u{1F4C5} \u5373\u5C06\u5F00\u59CB \xB7 \u6309\u65F6\u95F4\u5347\u5E8F" }, - held_events: { label: "\u2705 \u4E92\u52A8\u5386\u53F2" } - } - }, - crm_event_attendee: { - _validations: { - attendee_resolves: { - message: "\u53C2\u4E0E\u8005\u5FC5\u987B\u586B\u5199\u5176\u53C2\u4E0E\u8005\u7C7B\u578B\u6240\u6307\u7684\u4E00\u65B9\u2014\u2014\u8054\u7CFB\u4EBA\u7C7B\u578B\u9700\u8981\u586B\u5199\u8054\u7CFB\u4EBA\uFF0C\u5916\u90E8\u7C7B\u578B\u9700\u8981\u586B\u5199\u5916\u90E8\u53C2\u4E0E\u8005\u59D3\u540D" - }, - attendee_type_exclusive: { - message: "\u53C2\u4E0E\u8005\u53EA\u80FD\u6307\u5B9A\u4E00\u65B9\u2014\u2014\u8BF7\u6E05\u7A7A\u5176\u53C2\u4E0E\u8005\u7C7B\u578B\u672A\u6307\u660E\u7684\u6240\u6709\u5B57\u6BB5" - } - }, - label: "\u6D3B\u52A8\u53C2\u4E0E\u8005", - pluralLabel: "\u6D3B\u52A8\u53C2\u4E0E\u8005", - description: "\u53D7\u9080\u53C2\u52A0\u6216\u5B9E\u9645\u51FA\u5E2D\u6D3B\u52A8\u7684\u4EBA\u5458", - fields: { - attendee_number: { label: "\u53C2\u4E0E\u8005\u7F16\u53F7" }, - crm_event: { label: "\u6D3B\u52A8" }, - attendee_type: { - label: "\u53C2\u4E0E\u8005\u7C7B\u578B", - options: { contact: "\u8054\u7CFB\u4EBA", lead: "\u7EBF\u7D22", user: "\u5185\u90E8\u7528\u6237", external: "\u5916\u90E8\u6765\u5BBE" } - }, - crm_contact: { label: "\u8054\u7CFB\u4EBA", help: "\u53C2\u4E0E\u8005\u662F\u5DF2\u6709\u5BA2\u6237\u8054\u7CFB\u4EBA\u65F6\u586B\u5199" }, - crm_lead: { label: "\u7EBF\u7D22", help: "\u53C2\u4E0E\u8005\u4ECD\u662F\u672A\u8F6C\u5316\u7EBF\u7D22\u65F6\u586B\u5199" }, - sys_user: { label: "\u5185\u90E8\u7528\u6237", help: "\u53C2\u4E0E\u8005\u662F\u540C\u4E8B\u65F6\u586B\u5199" }, - external_name: { label: "\u5916\u90E8\u53C2\u4E0E\u8005", help: "\u4E0D\u5728\u4EFB\u4F55 CRM \u5BF9\u8C61\u4E2D\u7684\u53C2\u4E0E\u8005\u59D3\u540D\u2014\u2014\u53C2\u4E0E\u8005\u7C7B\u578B\u4E3A\u300C\u5916\u90E8\u6765\u5BBE\u300D\u65F6\u586B\u5199" }, - response: { - label: "\u56DE\u590D", - options: { - no_response: "\u672A\u56DE\u590D", - accepted: "\u5DF2\u63A5\u53D7", - declined: "\u5DF2\u62D2\u7EDD", - tentative: "\u5F85\u5B9A" - } - }, - is_organizer: { label: "\u7EC4\u7EC7\u8005" }, - invited_date: { label: "\u9080\u8BF7\u65F6\u95F4" } - }, - _sections: { - basic: { label: "\u53C2\u4E0E\u8005" }, - response: { label: "\u9080\u8BF7" }, - // event_attendee.view.ts 表单区块名称 (#1100) - attendee: { label: "\u53C2\u4E0E\u8005" }, - invitation: { label: "\u9080\u8BF7" } - }, - _views: { - all_event_attendees: { label: "\u6D3B\u52A8\u53C2\u4E0E\u8005" } - } - } -}; - -// src/sales/translations/zh-CN/objects.marketing.ts -var marketing2 = { - crm_campaign: { - _validations: { - end_after_start: { - message: "\u7ED3\u675F\u65E5\u671F\u5FC5\u987B\u665A\u4E8E\u5F00\u59CB\u65E5\u671F" - }, - actual_cost_within_budget: { - message: "\u5B9E\u9645\u6210\u672C\u8D85\u51FA\u9884\u7B97\u6210\u672C" - } - }, - label: "\u8425\u9500\u6D3B\u52A8", - pluralLabel: "\u8425\u9500\u6D3B\u52A8", - description: "\u5E02\u573A\u8425\u9500\u6D3B\u52A8\u4E0E\u63A8\u5E7F", - fields: { - campaign_code: { label: "\u6D3B\u52A8\u4EE3\u7801" }, - name: { label: "\u6D3B\u52A8\u540D\u79F0" }, - type: { - label: "\u7C7B\u578B", - options: { - email: "\u90AE\u4EF6\u8425\u9500", - webinar: "\u7EBF\u4E0A\u7814\u8BA8\u4F1A", - trade_show: "\u5C55\u4F1A", - conference: "\u884C\u4E1A\u4F1A\u8BAE", - direct_mail: "\u76F4\u90AE", - social_media: "\u793E\u4EA4\u5A92\u4F53", - content: "\u5185\u5BB9\u8425\u9500", - partner: "\u4F19\u4F34\u8054\u5408\u8425\u9500" - } - }, - status: { - label: "\u72B6\u6001", - options: { - planning: "\u89C4\u5212\u4E2D", - in_progress: "\u8FDB\u884C\u4E2D", - completed: "\u5DF2\u5B8C\u6210", - aborted: "\u5DF2\u4E2D\u6B62" - } - }, - start_date: { label: "\u5F00\u59CB\u65E5\u671F" }, - end_date: { label: "\u7ED3\u675F\u65E5\u671F" }, - expected_revenue: { label: "\u9884\u671F\u6536\u5165" }, - description: { label: "\u63CF\u8FF0" }, - channel: { - label: "\u4E3B\u8981\u6E20\u9053", - options: { digital: "\u6570\u5B57\u6E20\u9053", social: "\u793E\u4EA4\u5A92\u4F53", email: "\u90AE\u4EF6", events: "\u7EBF\u4E0B\u6D3B\u52A8", partner: "\u5408\u4F5C\u4F19\u4F34" } - }, - budgeted_cost: { label: "\u9884\u7B97\u6210\u672C" }, - actual_cost: { label: "\u5B9E\u9645\u6210\u672C" }, - actual_revenue: { label: "\u5B9E\u9645\u6536\u5165" }, - target_size: { label: "\u76EE\u6807\u4EBA\u6570", help: "\u76EE\u6807\u7EBF\u7D22/\u8054\u7CFB\u4EBA\u6570\u91CF" }, - num_sent: { label: "\u53D1\u9001\u6570\u91CF" }, - num_responses: { label: "\u54CD\u5E94\u6570\u91CF" }, - num_leads: { label: "\u7EBF\u7D22\u6570\u91CF" }, - num_converted_leads: { label: "\u5DF2\u8F6C\u5316\u7EBF\u7D22\u6570" }, - num_opportunities: { label: "\u5DF2\u521B\u5EFA\u5546\u673A\u6570" }, - num_won_opportunities: { label: "\u5DF2\u8D62\u5F97\u5546\u673A" }, - response_rate: { label: "\u54CD\u5E94\u7387\uFF08%\uFF09" }, - roi: { label: "\u6295\u8D44\u56DE\u62A5\u7387\uFF08%\uFF09" }, - owner_id: { label: "\u6D3B\u52A8\u8D1F\u8D23\u4EBA" }, - landing_page_url: { label: "\u7740\u9646\u9875" }, - is_active: { label: "\u662F\u5426\u542F\u7528" }, - display_title: { label: "\u663E\u793A\u540D\u79F0" } - }, - _sections: { - basic: { label: "\u6D3B\u52A8\u4FE1\u606F" }, - schedule: { label: "\u65E5\u7A0B\u5B89\u6392" }, - budget: { label: "\u9884\u7B97\u4E0E\u6295\u8D44\u56DE\u62A5" }, - metrics: { label: "\u6548\u679C\u6570\u636E" }, - assignment: { label: "\u5F52\u5C5E" }, - assets: { label: "\u6D3B\u52A8\u7D20\u6750" } - }, - _views: { - all_campaigns: { label: "\u5168\u90E8\u8425\u9500\u6D3B\u52A8" }, - campaign_gantt: { label: "\u6D3B\u52A8\u6392\u671F" }, - campaign_calendar: { label: "\u6D3B\u52A8\u65E5\u5386" }, - campaign_timeline: { label: "\u8425\u9500\u65F6\u95F4\u7EBF" } - }, - _actions: { - enroll_leads: { - label: "\u6279\u91CF\u52A0\u5165\u6210\u5458", - successMessage: "\u7B26\u5408\u6761\u4EF6\u7684\u6210\u5458\u5DF2\u52A0\u5165\u8425\u9500\u6D3B\u52A8\u3002" - } - } - }, - crm_campaign_member: { - _validations: { - lead_or_contact_required: { - message: "\u8425\u9500\u6D3B\u52A8\u6210\u5458\u5FC5\u987B\u5173\u8054\u7EBF\u7D22\u6216\u8054\u7CFB\u4EBA\u4E4B\u4E00" - } - }, - // 「营销活动成员」, not 「活动成员」: this object's master is `crm_campaign` - // (营销活动), while 「活动」 is already this pack's label for `crm_event` and - // 「活动参与者」 its child `crm_event_attendee`. Dropping 「营销」 put a - // marketing object inside the calendar family's name space (#810). - label: "\u8425\u9500\u6D3B\u52A8\u6210\u5458", - pluralLabel: "\u8425\u9500\u6D3B\u52A8\u6210\u5458", - description: "\u8425\u9500\u6D3B\u52A8\u6240\u89E6\u8FBE\u7684\u7EBF\u7D22\u4E0E\u8054\u7CFB\u4EBA\u53CA\u5176\u54CD\u5E94\u72B6\u6001", - fields: { - member_number: { label: "\u6210\u5458\u7F16\u53F7" }, - crm_campaign: { label: "\u8425\u9500\u6D3B\u52A8" }, - crm_lead: { label: "\u7EBF\u7D22", help: "\u6210\u5458\u52A0\u5165\u65F6\u8EAB\u4EFD\u4E3A\u7EBF\u7D22\u7684\uFF0C\u8BB0\u5F55\u5728\u6B64" }, - crm_contact: { label: "\u8054\u7CFB\u4EBA", help: "\u6210\u5458\u4E3A\u5DF2\u6709\u8054\u7CFB\u4EBA\u7684\uFF0C\u8BB0\u5F55\u5728\u6B64" }, - status: { - label: "\u72B6\u6001", - options: { - sent: "\u5DF2\u53D1\u9001", - responded: "\u5DF2\u54CD\u5E94", - converted: "\u5DF2\u8F6C\u5316", - unsubscribed: "\u5DF2\u9000\u8BA2" - } - }, - added_date: { label: "\u52A0\u5165\u65F6\u95F4" }, - response_date: { label: "\u54CD\u5E94\u65F6\u95F4" }, - has_responded: { label: "\u5DF2\u54CD\u5E94" } - }, - _sections: { - basic: { label: "\u57FA\u672C\u4FE1\u606F" }, - response: { label: "\u54CD\u5E94\u8DDF\u8E2A" } - }, - _actions: { - mark_responded: { - label: "\u6807\u8BB0\u4E3A\u5DF2\u54CD\u5E94", - successMessage: "\u5DF2\u8BB0\u5F55\u8BE5\u8425\u9500\u6D3B\u52A8\u6210\u5458\u7684\u54CD\u5E94\u3002" - } - } - } -}; - -// src/sales/translations/zh-CN.ts -var zhCN2 = { - objects: { - crm_account: customer2.crm_account, - crm_contact: customer2.crm_contact, - crm_knowledge_article: service2.crm_knowledge_article, - crm_forecast: pipeline2.crm_forecast, - crm_lead: pipeline2.crm_lead, - crm_quote: commerce2.crm_quote, - crm_contract: commerce2.crm_contract, - crm_case: service2.crm_case, - crm_task: activity2.crm_task, - crm_campaign: marketing2.crm_campaign, - crm_product: commerce2.crm_product, - crm_opportunity: pipeline2.crm_opportunity, - crm_event: activity2.crm_event, - crm_event_attendee: activity2.crm_event_attendee, - crm_article_feedback: service2.crm_article_feedback, - crm_campaign_member: marketing2.crm_campaign_member, - crm_opportunity_line_item: pipeline2.crm_opportunity_line_item, - crm_quote_line_item: commerce2.crm_quote_line_item - }, - ...appSurface2 -}; - -// src/sales/translations/ja-JP/app.ts -var appSurface3 = { - apps: { - crm_enterprise: { - label: "HotCRM", - description: "\u55B6\u696D\u30FB\u30B5\u30FC\u30D3\u30B9\u30FB\u30DE\u30FC\u30B1\u30C6\u30A3\u30F3\u30B0\u5411\u3051\u9867\u5BA2\u95A2\u4FC2\u7BA1\u7406\u30B7\u30B9\u30C6\u30E0", - // Keyed by navigation-node `id` (a flat keyspace regardless of depth). - navigation: { - nav_home: { label: "\u30DB\u30FC\u30E0" }, - group_sales: { label: "\u55B6\u696D" }, - nav_lead: { label: "\u30EA\u30FC\u30C9" }, - nav_account: { label: "\u53D6\u5F15\u5148" }, - nav_account_workbench: { label: "\u53D6\u5F15\u5148\u30EF\u30FC\u30AF\u30D9\u30F3\u30C1" }, - nav_contact: { label: "\u53D6\u5F15\u5148\u8CAC\u4EFB\u8005" }, - nav_opportunity: { label: "\u5546\u8AC7" }, - nav_quote: { label: "\u898B\u7A4D" }, - nav_contract: { label: "\u5951\u7D04" }, - nav_product: { label: "\u88FD\u54C1" }, - nav_sales_dashboard: { label: "\u55B6\u696D\u5B9F\u7E3E" }, - group_work: { label: "\u30DE\u30A4\u30EF\u30FC\u30AF" }, - nav_my_tasks: { label: "\u79C1\u306E\u30BF\u30B9\u30AF" }, - nav_my_deals: { label: "\u79C1\u306E\u5546\u8AC7" }, - nav_my_leads: { label: "\u79C1\u306E\u30EA\u30FC\u30C9" }, - nav_my_cases: { label: "\u79C1\u306E\u30B1\u30FC\u30B9" }, - nav_my_calendar: { label: "\u30DE\u30A4\u30AB\u30EC\u30F3\u30C0\u30FC" }, - nav_approval_requests: { label: "\u53D7\u4FE1\u30C8\u30EC\u30A4" }, - group_activity: { label: "\u6D3B\u52D5" }, - nav_event: { label: "\u30A4\u30D9\u30F3\u30C8" }, - nav_activity_dashboard: { label: "\u55B6\u696D\u6D3B\u52D5" }, - group_marketing: { label: "\u30DE\u30FC\u30B1\u30C6\u30A3\u30F3\u30B0" }, - nav_campaign: { label: "\u30AD\u30E3\u30F3\u30DA\u30FC\u30F3" }, - group_service: { label: "\u30B5\u30FC\u30D3\u30B9" }, - nav_case: { label: "\u30B1\u30FC\u30B9" }, - nav_knowledge: { label: "\u30CA\u30EC\u30C3\u30B8\u30D9\u30FC\u30B9" }, - nav_service_dashboard: { label: "\u30B5\u30FC\u30D3\u30B9\u6982\u8981" }, - group_insights: { label: "\u30A4\u30F3\u30B5\u30A4\u30C8" }, - nav_crm_dashboard: { label: "CRM \u6982\u8981" }, - nav_forecast: { label: "\u30D5\u30A9\u30FC\u30AD\u30E3\u30B9\u30C8" }, - nav_report_pipeline_coverage: { label: "\u30D1\u30A4\u30D7\u30E9\u30A4\u30F3\u30AB\u30D0\u30EC\u30C3\u30B8" }, - nav_report_lead_inflow: { label: "\u30EA\u30FC\u30C9\u6D41\u5165" }, - nav_report_sla: { label: "SLA \u5B9F\u7E3E" } - } - } - }, - messages: { - "common.save": "\u4FDD\u5B58", - "common.cancel": "\u30AD\u30E3\u30F3\u30BB\u30EB", - "common.delete": "\u524A\u9664", - "common.edit": "\u7DE8\u96C6", - "common.create": "\u65B0\u898F\u4F5C\u6210", - "common.search": "\u691C\u7D22", - "common.filter": "\u30D5\u30A3\u30EB\u30BF\u30FC", - "common.export": "\u30A8\u30AF\u30B9\u30DD\u30FC\u30C8", - "common.back": "\u623B\u308B", - "common.confirm": "\u78BA\u8A8D", - "nav.sales": "\u55B6\u696D", - "nav.service": "\u30B5\u30FC\u30D3\u30B9", - "nav.marketing": "\u30DE\u30FC\u30B1\u30C6\u30A3\u30F3\u30B0", - "nav.products": "\u88FD\u54C1", - "nav.analytics": "\u30A2\u30CA\u30EA\u30C6\u30A3\u30AF\u30B9", - "success.saved": "\u30EC\u30B3\u30FC\u30C9\u3092\u4FDD\u5B58\u3057\u307E\u3057\u305F", - "success.converted": "\u30EA\u30FC\u30C9\u3092\u5909\u63DB\u3057\u307E\u3057\u305F", - "confirm.delete": "\u3053\u306E\u30EC\u30B3\u30FC\u30C9\u3092\u524A\u9664\u3057\u3066\u3082\u3088\u308D\u3057\u3044\u3067\u3059\u304B\uFF1F", - "confirm.convert_lead": "\u3053\u306E\u30EA\u30FC\u30C9\u3092\u53D6\u5F15\u5148\u30FB\u53D6\u5F15\u5148\u8CAC\u4EFB\u8005\u30FB\u5546\u8AC7\u306B\u5909\u63DB\u3057\u307E\u3059\u304B\uFF1F", - "error.required": "\u3053\u306E\u9805\u76EE\u306F\u5FC5\u9808\u3067\u3059", - "error.load_failed": "\u30C7\u30FC\u30BF\u306E\u8AAD\u307F\u8FBC\u307F\u306B\u5931\u6557\u3057\u307E\u3057\u305F" - }, - dashboards: { - sales_activity_dashboard: { - label: "\u55B6\u696D\u6D3B\u52D5", - description: "\u8AB0\u304C\u3069\u308C\u3060\u3051\u9867\u5BA2\u3068\u8A71\u3057\u3066\u3044\u308B\u304B\u3001\u3069\u306E\u53D6\u5F15\u5148\u304C\u6C88\u9ED9\u3057\u3066\u3044\u308B\u304B", - widgets: { - interactions_held: { title: "\u8A18\u9332\u6E08\u307F\u306E\u5BFE\u8A71", description: "\u5B9F\u969B\u306B\u884C\u308F\u308C\u305F\u96FB\u8A71\u3068\u4F1A\u8B70" }, - meetings_booked: { title: "\u8A2D\u5B9A\u6E08\u307F\u306E\u4F1A\u8B70", description: "\u30AB\u30EC\u30F3\u30C0\u30FC\u4E0A\u306B\u3042\u308A\u672A\u5B9F\u65BD\u306E\u4F1A\u8B70" }, - customer_minutes: { title: "\u9867\u5BA2\u63A5\u89E6\u6642\u9593\uFF08\u5206\uFF09", description: "\u9867\u5BA2\u3068\u5411\u304D\u5408\u3063\u305F\u7DCF\u6642\u9593" }, - tasks_completed: { title: "\u5B8C\u4E86\u30BF\u30B9\u30AF", description: "\u30AF\u30ED\u30FC\u30BA\u3057\u305F\u30D5\u30A9\u30ED\u30FC\u30A2\u30C3\u30D7" }, - activity_by_rep: { title: "\u62C5\u5F53\u8005\u5225\u306E\u6D3B\u52D5", description: "\u62C5\u5F53\u8005\u3054\u3068\u306E\u8A18\u9332\u6E08\u307F\u5BFE\u8A71\u6570" }, - activity_by_week: { title: "\u9031\u6B21\u306E\u6D3B\u52D5\u91CF", description: "\u9031\u3042\u305F\u308A\u306E\u5BFE\u8A71\u6570" }, - activity_mix: { title: "\u6D3B\u52D5\u306E\u5185\u8A33", description: "\u96FB\u8A71\u30FB\u4F1A\u8B70\u30FB\u30C7\u30E2\u306E\u6BD4\u7387" }, - activity_by_record_type: { title: "\u6D3B\u52D5\u306E\u5BFE\u8C61", description: "\u30D5\u30A1\u30CD\u30EB\u306E\u3069\u3053\u306B\u6CE8\u529B\u3057\u3066\u3044\u308B\u304B" }, - deal_activity: { title: "\u5546\u8AC7\u4E0A\u306E\u5BFE\u8A71", description: "\u5546\u8AC7\u306B\u7D10\u3065\u304F\u8A18\u9332\u6E08\u307F\u5BFE\u8A71" }, - open_deals_for_activity: { title: "\u30AA\u30FC\u30D7\u30F3\u5546\u8AC7", description: "\u9032\u884C\u4E2D\u306E\u5546\u8AC7\u6570" }, - quiet_accounts_30: { title: "30 \u65E5\u4EE5\u4E0A\u6C88\u9ED9", description: "1 \u304B\u6708\u9593\u5BFE\u8A71\u8A18\u9332\u306E\u306A\u3044\u30A2\u30AF\u30C6\u30A3\u30D6\u53D6\u5F15\u5148" }, - quiet_accounts_60: { title: "60 \u65E5\u4EE5\u4E0A\u6C88\u9ED9", description: "2 \u304B\u6708\u306E\u6C88\u9ED9 \u2014 \u30EA\u30B9\u30AF\u95BE\u5024" }, - quiet_accounts_90: { title: "90 \u65E5\u4EE5\u4E0A\u6C88\u9ED9", description: "\u56DB\u534A\u671F\u306B\u308F\u305F\u308A\u63A5\u89E6\u306A\u3057" } - } - }, - crm_overview_dashboard: { - label: "CRM \u6982\u8981", - description: "\u58F2\u4E0A\u6307\u6A19\u3001\u30D1\u30A4\u30D7\u30E9\u30A4\u30F3\u5206\u6790\u3001\u5546\u8AC7\u30A4\u30F3\u30B5\u30A4\u30C8", - widgets: { - total_revenue: { title: "\u7DCF\u58F2\u4E0A", description: "\u5F53\u671F\u306E\u6210\u7ACB\u6E08\u307F\u58F2\u4E0A" }, - active_deals: { title: "\u9032\u884C\u4E2D\u306E\u5546\u8AC7", description: "\u30D1\u30A4\u30D7\u30E9\u30A4\u30F3\u4E0A\u306E\u30AA\u30FC\u30D7\u30F3\u5546\u8AC7" }, - won_deals: { title: "\u6210\u7ACB\u5546\u8AC7\u6570", description: "\u5F53\u671F\u306B\u6210\u7ACB\u3057\u305F\u5546\u8AC7\u306E\u7DCF\u6570" }, - avg_deal_size: { title: "\u5E73\u5747\u5546\u8AC7\u898F\u6A21", description: "\u6210\u7ACB\u6E08\u307F\u5546\u8AC7\u306E\u5E73\u5747\u91D1\u984D" }, - revenue_trends: { title: "\u58F2\u4E0A\u30C8\u30EC\u30F3\u30C9", description: "\u904E\u53BB12\u304B\u6708\u306E\u6210\u7ACB\u6E08\u307F\u58F2\u4E0A" }, - lead_source: { title: "\u30EA\u30FC\u30C9\u30BD\u30FC\u30B9", description: "\u7372\u5F97\u30C1\u30E3\u30CD\u30EB\u5225\u306E\u30D1\u30A4\u30D7\u30E9\u30A4\u30F3\u91D1\u984D" }, - pipeline_by_stage: { title: "\u30B9\u30C6\u30FC\u30B8\u5225\u30D1\u30A4\u30D7\u30E9\u30A4\u30F3", description: "\u5404\u55B6\u696D\u30B9\u30C6\u30FC\u30B8\u306E\u30AA\u30FC\u30D7\u30F3\u5546\u8AC7\u91D1\u984D" }, - top_products: { title: "\u58F2\u308C\u7B4B\u88FD\u54C1", description: "\u88FD\u54C1\u30AB\u30C6\u30B4\u30EA\u5225\u306E\u5B9A\u4FA1\u30D9\u30FC\u30B9\u58F2\u4E0A" }, - pipeline_by_owner: { title: "\u62C5\u5F53\u8005\u5225\u30D1\u30A4\u30D7\u30E9\u30A4\u30F3", description: "\u55B6\u696D\u62C5\u5F53\u8005\u3054\u3068\u306E\u30AA\u30FC\u30D7\u30F3\u30D1\u30A4\u30D7\u30E9\u30A4\u30F3\u91D1\u984D\u3068\u5546\u8AC7\u6570" } - } - }, - executive_dashboard: { - label: "\u30A8\u30B0\u30BC\u30AF\u30C6\u30A3\u30D6\u6982\u8981", - description: "\u7D4C\u55B6\u5C64\u5411\u3051\u306E\u58F2\u4E0A\u30FB\u9867\u5BA2\u30FB\u30D1\u30A4\u30D7\u30E9\u30A4\u30F3\u306E\u4E3B\u8981KPI", - widgets: { - total_revenue_ytd: { title: "\u5E74\u5EA6\u7D2F\u8A08\u58F2\u4E0A", description: "\u672C\u5E74\u5EA6\u306E\u6210\u7ACB\u6E08\u307F\u58F2\u4E0A" }, - total_accounts: { title: "\u30A2\u30AF\u30C6\u30A3\u30D6\u53D6\u5F15\u5148", description: "\u5C11\u306A\u304F\u3068\u30821\u3064\u306E\u6709\u52B9\u306A\u95A2\u4FC2\u3092\u6301\u3064\u9867\u5BA2" }, - total_contacts: { title: "\u53D6\u5F15\u5148\u8CAC\u4EFB\u8005\u6570", description: "\u540D\u7C3F\u306B\u767B\u9332\u3055\u308C\u305F\u53D6\u5F15\u5148\u8CAC\u4EFB\u8005" }, - open_leads: { title: "\u30AA\u30FC\u30D7\u30F3\u30EA\u30FC\u30C9", description: "\u672A\u5909\u63DB\u306E\u30EA\u30FC\u30C9" }, - revenue_trend: { title: "\u58F2\u4E0A\u30C8\u30EC\u30F3\u30C9", description: "\u904E\u53BB12\u304B\u6708\u306E\u6210\u7ACB\u6E08\u307F\u58F2\u4E0A" }, - revenue_by_industry: { title: "\u696D\u7A2E\u5225\u58F2\u4E0A", description: "\u672C\u5E74\u5EA6\u306E\u6210\u7ACB\u6E08\u307F\u58F2\u4E0A\u3092\u696D\u7A2E\u5225\u306B\u5206\u985E" }, - pipeline_by_stage: { title: "\u30B9\u30C6\u30FC\u30B8\u5225\u30D1\u30A4\u30D7\u30E9\u30A4\u30F3", description: "\u5404\u55B6\u696D\u30B9\u30C6\u30FC\u30B8\u306E\u30AA\u30FC\u30D7\u30F3\u5546\u8AC7\u91D1\u984D" }, - new_accounts_by_month: { title: "\u65B0\u898F\u53D6\u5F15\u5148", description: "\u904E\u53BB6\u304B\u6708\u306E\u53D6\u5F15\u5148\u4F5C\u6210\u30DA\u30FC\u30B9" }, - accounts_by_industry: { title: "\u696D\u7A2E\u5225\u53D6\u5F15\u5148", description: "\u696D\u7A2E\u3054\u3068\u306E\u5E74\u9593\u58F2\u4E0A\u5408\u8A08\u3068\u53D6\u5F15\u5148\u6570" } - } - }, - sales_dashboard: { - label: "\u55B6\u696D\u5B9F\u7E3E", - description: "\u30D1\u30A4\u30D7\u30E9\u30A4\u30F3\u5206\u6790\u3001\u52DD\u7387\u30C8\u30EC\u30F3\u30C9\u3001\u62C5\u5F53\u8005\u5225\u30D1\u30D5\u30A9\u30FC\u30DE\u30F3\u30B9", - widgets: { - total_pipeline_value: { title: "\u30D1\u30A4\u30D7\u30E9\u30A4\u30F3\u5408\u8A08", description: "\u30AA\u30FC\u30D7\u30F3\u5546\u8AC7\u91D1\u984D\u306E\u5408\u8A08" }, - closed_won_qtd: { title: "\u4ECA\u56DB\u534A\u671F\u6210\u7ACB\u984D", description: "\u4ECA\u56DB\u534A\u671F\u306B\u6210\u7ACB\u3057\u305F\u58F2\u4E0A" }, - open_opportunities: { title: "\u30AA\u30FC\u30D7\u30F3\u5546\u8AC7", description: "\u9032\u884C\u4E2D\u306E\u30A2\u30AF\u30C6\u30A3\u30D6\u5546\u8AC7" }, - avg_deal_size: { title: "\u5E73\u5747\u5546\u8AC7\u898F\u6A21", description: "\u4ECA\u56DB\u534A\u671F\u306E\u6210\u7ACB\u6E08\u307F\u5546\u8AC7\u306E\u5E73\u5747\u91D1\u984D" }, - pipeline_by_stage: { title: "\u30B9\u30C6\u30FC\u30B8\u5225\u30D1\u30A4\u30D7\u30E9\u30A4\u30F3", description: "\u5404\u55B6\u696D\u30B9\u30C6\u30FC\u30B8\u306E\u30AA\u30FC\u30D7\u30F3\u5546\u8AC7\u91D1\u984D" }, - monthly_revenue_trend: { title: "\u6708\u6B21\u58F2\u4E0A\u30C8\u30EC\u30F3\u30C9", description: "\u904E\u53BB12\u304B\u6708\u306E\u6210\u7ACB\u6E08\u307F\u58F2\u4E0A" }, - pipeline_by_forecast_category: { title: "\u4E88\u6E2C\u30AB\u30C6\u30B4\u30EA\u5225\u30D1\u30A4\u30D7\u30E9\u30A4\u30F3", description: "\u58F2\u4E0A\u4E88\u6E2C\u30AB\u30C6\u30B4\u30EA\u5225\u306E\u30AA\u30FC\u30D7\u30F3\u30D1\u30A4\u30D7\u30E9\u30A4\u30F3\u91D1\u984D" }, - lead_source_breakdown: { title: "\u30EA\u30FC\u30C9\u30BD\u30FC\u30B9", description: "\u30D1\u30A4\u30D7\u30E9\u30A4\u30F3\u306E\u6D41\u5165\u5143" }, - open_pipeline_by_owner: { title: "\u62C5\u5F53\u8005\u5225\u30AA\u30FC\u30D7\u30F3\u30D1\u30A4\u30D7\u30E9\u30A4\u30F3", description: "\u55B6\u696D\u62C5\u5F53\u8005\u3054\u3068\u306E\u9032\u884C\u4E2D\u30D1\u30A4\u30D7\u30E9\u30A4\u30F3\u91D1\u984D\u30FB\u5546\u8AC7\u6570\u30FB\u5E73\u5747\u52DD\u7387" }, - quota_attainment_by_rep: { title: "\u62C5\u5F53\u8005\u5225\u30CE\u30EB\u30DE\u9054\u6210\u72B6\u6CC1", description: "\u4E88\u6E2C\u30B9\u30CA\u30C3\u30D7\u30B7\u30E7\u30C3\u30C8\u306B\u57FA\u3065\u304F\u62C5\u5F53\u8005\u5225\u306E\u4ECA\u56DB\u534A\u671F\u30CE\u30EB\u30DE\u30FB\u6210\u7D04\u53CE\u76CA\u30FB\u9054\u6210\u7387" }, - pipeline_stage_by_source: { title: "\u30B9\u30C6\u30FC\u30B8 \xD7 \u30EA\u30FC\u30C9\u30BD\u30FC\u30B9", description: "\u30B9\u30C6\u30FC\u30B8\u3068\u30BD\u30FC\u30B9\u5225\u306E\u9032\u884C\u4E2D\u5546\u8AC7\u91D1\u984D\u306E\u30AF\u30ED\u30B9\u96C6\u8A08" }, - win_rate_12m: { title: "\u52DD\u7387\uFF08\u76F4\u8FD112\u304B\u6708\uFF09", description: "\u76F4\u8FD112\u304B\u6708\u306B\u6C7A\u7740\u3057\u305F\u5546\u8AC7\u306E\u3046\u3061\u6210\u7ACB\u3057\u305F\u5272\u5408" }, - won_deals_12m: { title: "\u6210\u7ACB\u5546\u8AC7\u6570\uFF08\u76F4\u8FD112\u304B\u6708\uFF09", description: "\u52DD\u7387\u306E\u5206\u5B50" }, - lost_deals_12m: { title: "\u5931\u6CE8\u5546\u8AC7\u6570\uFF08\u76F4\u8FD112\u304B\u6708\uFF09", description: "\u52DD\u7387\u306E\u5206\u6BCD\u306E\u3082\u3046\u534A\u5206" }, - win_rate_by_owner: { title: "\u62C5\u5F53\u8005\u5225 \u53D7\u6CE8\uFF0F\u5931\u6CE8", description: "\u76F4\u8FD112\u304B\u6708\u306E\u62C5\u5F53\u8005\u3054\u3068\u306E\u6210\u7ACB\u6570\u30FB\u5931\u6CE8\u6570\u30FB\u52DD\u7387" }, - win_rate_by_lead_source: { title: "\u30EA\u30FC\u30C9\u30BD\u30FC\u30B9\u5225 \u53D7\u6CE8\uFF0F\u5931\u6CE8", description: "\u5B9F\u969B\u306B\u6210\u7ACB\u306B\u3064\u306A\u304C\u308B\u306E\u306F\u3069\u306E\u30BD\u30FC\u30B9\u304B \u2014 \u76F4\u8FD112\u304B\u6708" }, - loss_reason_breakdown: { title: "\u5931\u6CE8\u306E\u7406\u7531", description: "\u76F4\u8FD112\u304B\u6708\u306E\u5931\u6CE8\u5546\u8AC7\u3092\u7406\u7531\u5225\u306B\u96C6\u8A08" } - } - }, - service_dashboard: { - label: "\u30AB\u30B9\u30BF\u30DE\u30FC\u30B5\u30FC\u30D3\u30B9", - description: "\u30B1\u30FC\u30B9\u8CA0\u8377\u3001SLA\u5065\u5168\u6027\u3001\u89E3\u6C7A\u30D1\u30D5\u30A9\u30FC\u30DE\u30F3\u30B9", - widgets: { - open_cases: { title: "\u30AA\u30FC\u30D7\u30F3\u30B1\u30FC\u30B9", description: "\u307E\u3060\u30AF\u30ED\u30FC\u30BA\u3055\u308C\u3066\u3044\u306A\u3044\u30B1\u30FC\u30B9" }, - critical_cases: { title: "\u91CD\u5927\u30B1\u30FC\u30B9", description: "\u512A\u5148\u5EA6\u300C\u91CD\u5927\u300D\u306E\u30AA\u30FC\u30D7\u30F3\u30B1\u30FC\u30B9" }, - avg_resolution_time: { title: "\u5E73\u5747\u89E3\u6C7A\u6642\u9593", description: "\u30AF\u30ED\u30FC\u30BA\u307E\u3067\u306E\u5E73\u5747\u6642\u9593\uFF08\u6642\uFF09" }, - sla_violations: { title: "SLA \u9055\u53CD", description: "SLA \u3092\u8D85\u904E\u3057\u305F\u30B1\u30FC\u30B9" }, - cases_by_status: { title: "\u30B9\u30C6\u30FC\u30BF\u30B9\u5225\u30B1\u30FC\u30B9", description: "\u30D1\u30A4\u30D7\u30E9\u30A4\u30F3\u5168\u4F53\u306E\u30EF\u30FC\u30AF\u30ED\u30FC\u30C9\u5206\u5E03" }, - cases_by_priority: { title: "\u512A\u5148\u5EA6\u5225\u30B1\u30FC\u30B9", description: "\u7DCA\u6025\u5EA6\u5225\u306E\u30AA\u30FC\u30D7\u30F3\u30B1\u30FC\u30B9\u69CB\u6210" }, - cases_by_origin: { title: "\u767A\u751F\u6E90\u5225\u30B1\u30FC\u30B9", description: "\u30B1\u30FC\u30B9\u306E\u6D41\u5165\u30C1\u30E3\u30CD\u30EB" }, - daily_case_volume: { title: "\u65E5\u6B21\u30B1\u30FC\u30B9\u4EF6\u6570", description: "\u904E\u53BB30\u65E5\u9593\u306E\u65B0\u898F\u30B1\u30FC\u30B9" }, - sla_compliance_gauge: { title: "SLA \u9054\u6210\u7387", description: "\u5F53\u671F SLA \u5185\u306B\u89E3\u6C7A\u3057\u305F\u30B1\u30FC\u30B9\u306E\u5272\u5408" }, - kb_deflection_rate: { title: "\u30CA\u30EC\u30C3\u30B8\u89E3\u6C7A\u7387", description: "\u30AF\u30ED\u30FC\u30BA\u3057\u305F\u30B1\u30FC\u30B9\u306E\u3046\u3061\u30CA\u30EC\u30C3\u30B8\u8A18\u4E8B\u3067\u89E3\u6C7A\u3057\u305F\u5272\u5408" }, - kb_resolved_cases: { title: "\u30CA\u30EC\u30C3\u30B8\u3067\u89E3\u6C7A", description: "\u89E3\u6C7A\u3057\u305F\u8A18\u4E8B\u304C\u7D10\u3065\u304F\u30AF\u30ED\u30FC\u30BA\u6E08\u307F\u30B1\u30FC\u30B9" }, - closed_cases_total: { title: "\u30AF\u30ED\u30FC\u30BA\u6E08\u307F\u30B1\u30FC\u30B9", description: "\u30CA\u30EC\u30C3\u30B8\u89E3\u6C7A\u7387\u306E\u5206\u6BCD" }, - top_resolving_articles: { title: "\u89E3\u6C7A\u4EF6\u6570\u306E\u591A\u3044\u8A18\u4E8B", description: "\u89E3\u6C7A\u3057\u305F\u30AF\u30ED\u30FC\u30BA\u6E08\u307F\u30B1\u30FC\u30B9\u6570\u3067\u4E26\u3079\u305F\u30CA\u30EC\u30C3\u30B8\u8A18\u4E8B" }, - my_open_cases_by_priority: { title: "\u512A\u5148\u5EA6\u5225\u306E\u79C1\u306E\u30AA\u30FC\u30D7\u30F3\u30B1\u30FC\u30B9", description: "\u3042\u306A\u305F\u306E\u30AA\u30FC\u30D7\u30F3\u30B1\u30FC\u30B9\u3068\u305D\u306ESLA\u9055\u53CD\u7387\u3092\u512A\u5148\u5EA6\u5225\u306B\u96C6\u8A08" } - } - } - }, - // `title` / `subtitle` translate the page's `page:header`; `title` falls back - // to `label` when omitted, so it is authored only where the two differ. - // Header strings carrying `{field}` tokens keep the token spelling verbatim — - // the console substitutes on the raw key, so a translated token resolves to - // nothing and the header renders blank. - datasets: { - account_metrics: { - label: "\u53D6\u5F15\u5148\u6307\u6A19", - description: "\u696D\u7A2E\u30FB\u7A2E\u5225\u3054\u3068\u306B\u53D6\u5F15\u5148\u6570\u3092\u96C6\u8A08\u3059\u308B\u30BB\u30DE\u30F3\u30C6\u30A3\u30C3\u30AF\u30EC\u30A4\u30E4\u30FC", - dimensions: { - industry: { - label: "\u696D\u7A2E" - }, - type: { - label: "\u7A2E\u5225" - }, - created_at: { - label: "\u4F5C\u6210\u65E5" - } - }, - measures: { - account_count: { - label: "\u53D6\u5F15\u5148\u6570" - }, - annual_revenue_sum: { - label: "\u5E74\u9593\u58F2\u4E0A" - } - } - }, - case_metrics: { - label: "\u30B1\u30FC\u30B9\u6307\u6A19", - description: "\u30B1\u30FC\u30B9\u6570\u30FB\u89E3\u6C7A\u6642\u9593\u30FBSLA \u3092\u96C6\u8A08\u3059\u308B\u30BB\u30DE\u30F3\u30C6\u30A3\u30C3\u30AF\u30EC\u30A4\u30E4\u30FC", - dimensions: { - created_at: { - label: "\u4F5C\u6210\u65E5" - }, - origin: { - label: "\u767A\u751F\u5143" - }, - priority: { - label: "\u512A\u5148\u5EA6" - }, - resolved_article: { - label: "\u89E3\u6C7A\u306B\u4F7F\u7528\u3057\u305F\u30CA\u30EC\u30C3\u30B8\u8A18\u4E8B" - }, - status: { - label: "\u30B9\u30C6\u30FC\u30BF\u30B9" - }, - type: { - label: "\u7A2E\u5225" - } - }, - measures: { - avg_resolution: { - label: "\u5E73\u5747\u89E3\u6C7A\u6642\u9593\uFF08\u6642\u9593\uFF09" - }, - avg_sla_violated: { - label: "SLA \u9055\u53CD\u7387" - }, - case_count: { - label: "\u30B1\u30FC\u30B9\u6570" - }, - closed_count: { - label: "\u30AF\u30ED\u30FC\u30BA\u6E08\u307F\u30B1\u30FC\u30B9" - }, - kb_deflection_rate: { - label: "\u30CA\u30EC\u30C3\u30B8\u30D9\u30FC\u30B9\u81EA\u5DF1\u89E3\u6C7A\u7387" - }, - kb_resolved_count: { - label: "\u30CA\u30EC\u30C3\u30B8\u30D9\u30FC\u30B9\u3067\u89E3\u6C7A\u3057\u305F\u4EF6\u6570" - }, - sla_compliance_rate: { - label: "SLA \u9075\u5B88\u7387" - }, - sla_met_count: { - label: "SLA \u3092\u6E80\u305F\u3057\u305F\u30B1\u30FC\u30B9" - } - } - }, - contact_metrics: { - label: "\u53D6\u5F15\u5148\u8CAC\u4EFB\u8005\u6307\u6A19", - description: "\u53D6\u5F15\u5148\u8CAC\u4EFB\u8005\u6570\u3092\u96C6\u8A08\u3059\u308B\u30BB\u30DE\u30F3\u30C6\u30A3\u30C3\u30AF\u30EC\u30A4\u30E4\u30FC", - measures: { - contact_count: { - label: "\u53D6\u5F15\u5148\u8CAC\u4EFB\u8005\u6570" - } - } - }, - event_metrics: { - label: "\u6D3B\u52D5\u6307\u6A19", - description: "\u4F1A\u8B70\u30FB\u901A\u8A71\u30FB\u63A5\u89E6\u306E\u65B0\u3057\u3055\u3092\u96C6\u8A08\u3059\u308B\u30BB\u30DE\u30F3\u30C6\u30A3\u30C3\u30AF\u30EC\u30A4\u30E4\u30FC", - dimensions: { - owner: { - label: "\u6240\u6709\u8005" - }, - related_to_type: { - label: "\u95A2\u9023\u5148" - }, - start_datetime: { - label: "\u6D3B\u52D5\u9031" - }, - status: { - label: "\u30B9\u30C6\u30FC\u30BF\u30B9" - }, - type: { - label: "\u6D3B\u52D5\u7A2E\u5225" - } - }, - measures: { - avg_minutes: { - label: "\u5E73\u5747\u6240\u8981\u6642\u9593" - }, - event_count: { - label: "\u6D3B\u52D5\u4EF6\u6570" - }, - total_minutes: { - label: "\u5408\u8A08\u5206\u6570" - } - } - }, - forecast_metrics: { - label: "\u30D5\u30A9\u30FC\u30AD\u30E3\u30B9\u30C8\u6307\u6A19", - description: "\u62C5\u5F53\u8005\u3054\u3068\u306E\u76EE\u6A19\u30FB\u9054\u6210\u7387\u30FB\u30D1\u30A4\u30D7\u30E9\u30A4\u30F3\u30AB\u30D0\u30EC\u30C3\u30B8\u3092\u96C6\u8A08\u3059\u308B\u30BB\u30DE\u30F3\u30C6\u30A3\u30C3\u30AF\u30EC\u30A4\u30E4\u30FC", - dimensions: { - owner: { - label: "\u6240\u6709\u8005" - }, - period: { - label: "\u671F\u9593\u7A2E\u5225" - }, - period_label: { - label: "\u671F\u9593" - }, - period_start: { - label: "\u671F\u9593\u958B\u59CB" - } - }, - measures: { - attainment: { - label: "\u9054\u6210\u7387" - }, - closed_sum: { - label: "\u30AF\u30ED\u30FC\u30BA\u6E08\u307F" - }, - commit_sum: { - label: "\u30B3\u30DF\u30C3\u30C8" - }, - pipeline_sum: { - label: "\u30D1\u30A4\u30D7\u30E9\u30A4\u30F3" - }, - quota_sum: { - label: "\u76EE\u6A19" - } - } - }, - lead_metrics: { - label: "\u30EA\u30FC\u30C9\u6307\u6A19", - description: "\u30EA\u30FC\u30C9\u6570\u3092\u96C6\u8A08\u3059\u308B\u30BB\u30DE\u30F3\u30C6\u30A3\u30C3\u30AF\u30EC\u30A4\u30E4\u30FC", - dimensions: { - created_at: { - label: "\u4F5C\u6210\u65E5" - }, - last_contacted_date: { - label: "\u6700\u7D42\u63A5\u89E6\u65E5" - }, - lead_source: { - label: "\u30BD\u30FC\u30B9" - }, - status: { - label: "\u30B9\u30C6\u30FC\u30BF\u30B9" - } - }, - measures: { - lead_count: { - label: "\u30EA\u30FC\u30C9\u6570" - } - } - }, - opportunity_metrics: { - label: "\u5546\u8AC7\u6307\u6A19", - description: "\u55B6\u696D\u30D1\u30A4\u30D7\u30E9\u30A4\u30F3\u306E\u4EF6\u6570\u3068\u91D1\u984D\u3092\u96C6\u8A08\u3059\u308B\u30BB\u30DE\u30F3\u30C6\u30A3\u30C3\u30AF\u30EC\u30A4\u30E4\u30FC", - dimensions: { - account_industry: { - label: "\u53D6\u5F15\u5148\u306E\u696D\u7A2E" - }, - close_date: { - label: "\u5B8C\u4E86\u4E88\u5B9A\u65E5" - }, - close_quarter: { - label: "\u5B8C\u4E86\u56DB\u534A\u671F" - }, - forecast_category: { - label: "\u30D5\u30A9\u30FC\u30AD\u30E3\u30B9\u30C8\u533A\u5206" - }, - lead_source: { - label: "\u30EA\u30FC\u30C9\u30BD\u30FC\u30B9" - }, - loss_reason: { - label: "\u5931\u6CE8\u7406\u7531" - }, - owner: { - label: "\u6240\u6709\u8005" - }, - stage: { - label: "\u30B9\u30C6\u30FC\u30B8" - }, - type: { - label: "\u5546\u8AC7\u7A2E\u5225" - }, - win_reason: { - label: "\u53D7\u6CE8\u7406\u7531" - } - }, - measures: { - avg_amount: { - label: "\u5E73\u5747\u5546\u8AC7\u91D1\u984D" - }, - avg_probability: { - label: "\u5E73\u5747\u78BA\u5EA6" - }, - decided_count: { - label: "\u6C7A\u7740\u3057\u305F\u5546\u8AC7" - }, - lost_amount: { - label: "\u5931\u6CE8\u91D1\u984D" - }, - lost_count: { - label: "\u5931\u6CE8\u4EF6\u6570" - }, - opp_count: { - label: "\u5546\u8AC7\u6570" - }, - total_amount: { - label: "\u5408\u8A08\u91D1\u984D" - }, - win_rate: { - label: "\u53D7\u6CE8\u7387" - }, - won_amount: { - label: "\u53D7\u6CE8\u91D1\u984D" - }, - won_count: { - label: "\u53D7\u6CE8\u4EF6\u6570" - } - } - }, - product_metrics: { - label: "\u88FD\u54C1\u6307\u6A19", - description: "\u88FD\u54C1\u30AB\u30BF\u30ED\u30B0\u306E\u4EF6\u6570\u3068\u5B9A\u4FA1\u3092\u96C6\u8A08\u3059\u308B\u30BB\u30DE\u30F3\u30C6\u30A3\u30C3\u30AF\u30EC\u30A4\u30E4\u30FC", - dimensions: { - category: { - label: "\u30AB\u30C6\u30B4\u30EA" - } - }, - measures: { - list_price_sum: { - label: "\u5B9A\u4FA1\u5408\u8A08" - }, - product_count: { - label: "\u88FD\u54C1\u6570" - } - } - }, - task_metrics: { - label: "\u30BF\u30B9\u30AF\u6307\u6A19", - description: "\u30BF\u30B9\u30AF\u306E\u4F5C\u696D\u91CF\u3068\u5B8C\u4E86\u72B6\u6CC1\u3092\u96C6\u8A08\u3059\u308B\u30BB\u30DE\u30F3\u30C6\u30A3\u30C3\u30AF\u30EC\u30A4\u30E4\u30FC", - dimensions: { - due_date: { - label: "\u671F\u9650" - }, - is_completed: { - label: "\u5B8C\u4E86\u6E08\u307F" - }, - is_overdue: { - label: "\u671F\u9650\u8D85\u904E" - }, - priority: { - label: "\u512A\u5148\u5EA6" - }, - priority_rank: { - label: "\u7DCA\u6025\u5EA6" - }, - status: { - label: "\u30B9\u30C6\u30FC\u30BF\u30B9" - }, - type: { - label: "\u7A2E\u5225" - } - }, - measures: { - avg_progress: { - label: "\u5E73\u5747\u9032\u6357" - }, - task_count: { - label: "\u30BF\u30B9\u30AF\u6570" - } - } - } - }, - pages: { - account_detail_page: { - label: "\u53D6\u5F15\u5148\u8A73\u7D30", - description: "\u30B9\u30ED\u30C3\u30C8\u69CB\u6210\u306E\u53D6\u5F15\u5148\u30EC\u30B3\u30FC\u30C9\u30DA\u30FC\u30B8 \u2014 \u30AB\u30B9\u30BF\u30E0\u30D8\u30C3\u30C0\u30FC\u3068\u5E38\u8A2D\u306E\u30C7\u30A3\u30B9\u30AB\u30C3\u30B7\u30E7\u30F3\u30D5\u30A3\u30FC\u30C9\u3002", - title: "{name}", - subtitle: "{industry} \xB7 {type}", - components: { - account_chatter: { label: "\u30C7\u30A3\u30B9\u30AB\u30C3\u30B7\u30E7\u30F3" } - } - }, - account_workbench: { - label: "\u53D6\u5F15\u5148\u30EF\u30FC\u30AF\u30D9\u30F3\u30C1", - description: "\u55B6\u696D\u30C1\u30FC\u30E0\u5411\u3051\u306B\u53B3\u9078\u3057\u305F\u53D6\u5F15\u5148\u30EA\u30B9\u30C8\u3002\u30AF\u30A4\u30C3\u30AF\u30D5\u30A3\u30EB\u30BF\u30FC\u306E\u307F\u3067\u3001\u30D3\u30E5\u30FC\u7BA1\u7406\u306F\u884C\u3044\u307E\u305B\u3093\u3002" - }, - app_launcher_page: { - label: "\u30A2\u30D7\u30EA\u30E9\u30F3\u30C1\u30E3\u30FC", - description: "\u3059\u3079\u3066\u306E\u30A2\u30D7\u30EA\u30B1\u30FC\u30B7\u30E7\u30F3\u306B\u30A2\u30AF\u30BB\u30B9\u3059\u308B\u305F\u3081\u306E\u7D71\u5408\u30CF\u30D6", - subtitle: "\u958B\u59CB\u3059\u308B\u30A2\u30D7\u30EA\u3092\u9078\u629E\u3057\u3066\u304F\u3060\u3055\u3044", - components: { - app_search: { label: "\u30A2\u30D7\u30EA\u3092\u691C\u7D22" }, - app_grid: { label: "\u30A2\u30D7\u30EA\u30B0\u30EA\u30C3\u30C9" } - } - }, - case_detail_page: { - label: "\u30B1\u30FC\u30B9\u8A73\u7D30", - description: "\u30B5\u30FC\u30D3\u30B9\u62C5\u5F53\u8005\u5411\u3051\u306E\u30B1\u30FC\u30B9\u30EC\u30B3\u30FC\u30C9\u30DA\u30FC\u30B8\uFF1A\u30CF\u30A4\u30E9\u30A4\u30C8\u3001SLA \u30D1\u30B9\u3001\u8A73\u7D30\u3001\u6D3B\u52D5\u30BF\u30A4\u30E0\u30E9\u30A4\u30F3\u3002", - title: "{case_number} \xB7 {subject}", - subtitle: "{crm_account}", - components: { - case_highlights: { label: "\u91CD\u8981\u60C5\u5831" }, - case_status_path: { label: "\u30B1\u30FC\u30B9\u30B9\u30C6\u30FC\u30BF\u30B9\u306E\u9032\u6357" }, - case_details: { label: "\u30B1\u30FC\u30B9\u8A73\u7D30\u60C5\u5831" } - } - }, - lead_detail_page: { - label: "\u30EA\u30FC\u30C9\u8A73\u7D30", - description: "\u30CF\u30A4\u30E9\u30A4\u30C8\u30FB\u8A73\u7D30\u30FB\u95A2\u9023\u60C5\u5831\u3092\u5099\u3048\u305F\u30EA\u30FC\u30C9\u306E\u7DCF\u5408\u8A73\u7D30\u30DA\u30FC\u30B8\u3002", - title: "{first_name} {last_name}", - subtitle: "{company}", - components: { - lead_duplicate_alert_confirmed: { label: "\u91CD\u8907\u78BA\u5B9A\u306E\u8B66\u544A" }, - lead_duplicate_alert_suspected: { label: "\u91CD\u8907\u306E\u7591\u3044\u306E\u8B66\u544A" }, - lead_highlights: { label: "\u91CD\u8981\u60C5\u5831" }, - lead_path: { label: "\u30EA\u30FC\u30C9\u30B9\u30C6\u30FC\u30BF\u30B9\u306E\u9032\u6357" }, - main_tabs: { label: "\u30EA\u30FC\u30C9\u60C5\u5831\u30BF\u30D6" }, - lead_details: { label: "\u30EA\u30FC\u30C9\u8A73\u7D30\u60C5\u5831" }, - related_accordion: { label: "\u95A2\u9023\u30EC\u30B3\u30FC\u30C9" }, - related_tasks: { title: "\u672A\u5B8C\u4E86\u306E\u30BF\u30B9\u30AF", label: "\u30BF\u30B9\u30AF" }, - lead_activity: { label: "\u6D3B\u52D5\u30BF\u30A4\u30E0\u30E9\u30A4\u30F3" }, - lead_history: { label: "\u9805\u76EE\u5C65\u6B74" } - } - }, - opportunity_detail_page: { - label: "\u5546\u8AC7\u8A73\u7D30", - description: "\u30B9\u30C6\u30FC\u30B8\u30D1\u30B9\u30FB\u30CF\u30A4\u30E9\u30A4\u30C8\u30FB\u8A73\u7D30\u30FB\u95A2\u9023\u30EA\u30B9\u30C8\u3092\u5099\u3048\u305F\u5546\u8AC7\u306E\u7DCF\u5408\u8A73\u7D30\u30DA\u30FC\u30B8\u3002", - title: "{name}", - subtitle: "{crm_account}", - components: { - opp_highlights: { label: "\u91CD\u8981\u60C5\u5831" }, - opp_stage_path: { label: "\u5546\u8AC7\u30B9\u30C6\u30FC\u30B8\u306E\u9032\u6357" }, - opp_details: { label: "\u5546\u8AC7\u8A73\u7D30\u60C5\u5831" } - } - }, - sales_home_page: { - label: "\u55B6\u696D\u30DB\u30FC\u30E0", - description: "\u4E3B\u8981\u6307\u6A19\u3068\u30AF\u30A4\u30C3\u30AF\u30A2\u30AF\u30B7\u30E7\u30F3\u3092\u307E\u3068\u3081\u305F\u55B6\u696D\u30C1\u30FC\u30E0\u306E\u30DB\u30FC\u30E0\u30DA\u30FC\u30B8", - title: "\u55B6\u696D\u30C0\u30C3\u30B7\u30E5\u30DC\u30FC\u30C9", - subtitle: "\u304A\u304B\u3048\u308A\u306A\u3055\u3044", - components: { - kpi_revenue_won: { - label: "\u53D7\u6CE8\u58F2\u4E0A" - }, - kpi_deals_won: { - label: "\u53D7\u6CE8\u4EF6\u6570" - }, - kpi_pipeline_value: { - label: "\u30D1\u30A4\u30D7\u30E9\u30A4\u30F3\u91D1\u984D" - }, - kpi_open_leads: { - label: "\u30AA\u30FC\u30D7\u30F3\u30EA\u30FC\u30C9" - }, - home_upcoming_events: { - label: "\u{1F4C5} \u958B\u50AC\u4E88\u5B9A \xB7 \u76F4\u8FD1\u9806" - }, - quick_create: { title: "\u30AF\u30A4\u30C3\u30AF\u4F5C\u6210", label: "\u30AF\u30A4\u30C3\u30AF\u4F5C\u6210" }, - key_metrics: { title: "\u4E3B\u8981\u696D\u7E3E\u8A55\u4FA1\u6307\u6A19", label: "\u4E3B\u8981\u6307\u6A19" }, - home_tabs: { label: "\u30DB\u30FC\u30E0\u30BF\u30D6" }, - home_my_leads: { label: "\u79C1\u306E\u30EA\u30FC\u30C9" }, - home_my_deals: { label: "\u79C1\u306E\u30AA\u30FC\u30D7\u30F3\u5546\u8AC7" }, - home_my_tasks: { label: "\u79C1\u306E\u30AA\u30FC\u30D7\u30F3\u30BF\u30B9\u30AF" }, - ai_briefing: { - title: "AI \u30A2\u30B7\u30B9\u30BF\u30F3\u30C8\u306B\u8CEA\u554F", - label: "\u4ECA\u65E5\u306E AI \u30A2\u30B7\u30B9\u30BF\u30F3\u30C8" - }, - upcoming_events: { title: "\u4ECA\u5F8C\u306E\u4E88\u5B9A", label: "\u4ECA\u5F8C\u306E\u4E88\u5B9A" } - } - }, - utility_bar_page: { - label: "\u30E6\u30FC\u30C6\u30A3\u30EA\u30C6\u30A3\u30D0\u30FC", - description: "\u30D5\u30ED\u30FC\u30C6\u30A3\u30F3\u30B0\u30C4\u30FC\u30EB\u3078\u306E\u30AF\u30A4\u30C3\u30AF\u30A2\u30AF\u30BB\u30B9\u30D0\u30FC", - components: { - notifications_panel: { label: "\u901A\u77E5" }, - quick_notes: { title: "\u30AF\u30A4\u30C3\u30AF\u30E1\u30E2", label: "\u30AF\u30A4\u30C3\u30AF\u30E1\u30E2" }, - quick_search: { label: "\u30AF\u30A4\u30C3\u30AF\u691C\u7D22" } - } - } - }, - // Screen-flow copy (#1210, #1975). Keyed `flows..label`, - // `screens..title` and `screens..fields..{label,placeholder}` - // — the keys `os lint`'s `i18n/missing-flow` names, read by the console's - // flow runner since @objectstack 17.7.0 (the spec's `flows` liveness row is - // `live` there). A screen with no authored `title` shows its flow's label in - // every locale, so each `screen_1.title` repeats the flow label. Since - // 18.0.0-next.0 three more surfaces are keys the engine reads in the run's - // locale, and `i18n/missing-flow` names each missing one: a select field's - // `options.` (worded as the object field's own option in this pack), - // an authored screen `description`, and a refusing `end` node's - // `refusals..message`. A translated description or message is a text - // slot like the one it translates, so a hole in it is `{{ }}`. - // The discount ceiling is interpolated from `QUOTE_DISCOUNT_CEILING`, never - // retyped: the number lives in `_thresholds.ts` alone (#1711). - flows: { - campaign_enrollment: { - label: "\u30AD\u30E3\u30F3\u30DA\u30FC\u30F3\u306B\u30E1\u30F3\u30D0\u30FC\u3092\u767B\u9332", - screens: { - screen_1: { - title: "\u30AD\u30E3\u30F3\u30DA\u30FC\u30F3\u306B\u30E1\u30F3\u30D0\u30FC\u3092\u767B\u9332", - fields: { - memberSource: { label: "\u767B\u9332\u3059\u308B\u30E1\u30F3\u30D0\u30FC\u306E\u7A2E\u985E", options: { leads: "\u30EA\u30FC\u30C9", contacts: "\u53D6\u5F15\u5148\u8CAC\u4EFB\u8005" } }, - leadStatus: { label: "\u767B\u9332\u3059\u308B\u30EA\u30FC\u30C9\u306E\u30B9\u30C6\u30FC\u30BF\u30B9", options: { new: "\u65B0\u898F", contacted: "\u30B3\u30F3\u30BF\u30AF\u30C8\u6E08\u307F", qualified: "\u9069\u683C" } }, - contactDepartment: { - label: "\u767B\u9332\u3059\u308B\u53D6\u5F15\u5148\u8CAC\u4EFB\u8005\u306E\u90E8\u9580", - options: { executive: "\u7D4C\u55B6\u5C64", sales: "\u55B6\u696D\u90E8", marketing: "\u30DE\u30FC\u30B1\u30C6\u30A3\u30F3\u30B0\u90E8", engineering: "\u30A8\u30F3\u30B8\u30CB\u30A2\u30EA\u30F3\u30B0\u90E8", support: "\u30B5\u30DD\u30FC\u30C8\u90E8", finance: "\u7D4C\u7406\u90E8", hr: "\u4EBA\u4E8B\u90E8", operations: "\u30AA\u30DA\u30EC\u30FC\u30B7\u30E7\u30F3\u90E8" } - } - } - } - } - }, - escalate_case: { - label: "\u30B1\u30FC\u30B9\u3092\u30A8\u30B9\u30AB\u30EC\u30FC\u30C8", - screens: { screen_1: { title: "\u30B1\u30FC\u30B9\u3092\u30A8\u30B9\u30AB\u30EC\u30FC\u30C8", fields: { reason: { label: "\u30A8\u30B9\u30AB\u30EC\u30FC\u30B7\u30E7\u30F3\u7406\u7531" } } } } - }, - close_case: { - label: "\u30B1\u30FC\u30B9\u3092\u30AF\u30ED\u30FC\u30BA", - screens: { - screen_1: { - title: "\u30B1\u30FC\u30B9\u3092\u30AF\u30ED\u30FC\u30BA", - fields: { - resolution: { label: "\u89E3\u6C7A\u5185\u5BB9" }, - resolved_by_article: { label: "\u89E3\u6C7A\u306B\u4F7F\u3063\u305F\u30CA\u30EC\u30C3\u30B8\u8A18\u4E8B\uFF08\u4EFB\u610F\uFF09" } - } - } - } - }, - claim_case: { - label: "\u30B1\u30FC\u30B9\u3092\u5F15\u304D\u53D7\u3051\u308B", - screens: { - screen_1: { - title: "\u30B1\u30FC\u30B9\u3092\u5F15\u304D\u53D7\u3051\u308B", - fields: { - claimStatus: { - label: "\u5BFE\u5FDC\u72B6\u6CC1", - options: { in_progress: "\u5BFE\u5FDC\u4E2D", waiting_customer: "\u9867\u5BA2\u306E\u56DE\u7B54\u5F85\u3061", waiting_support: "\u30B5\u30DD\u30FC\u30C8\u306E\u56DE\u7B54\u5F85\u3061" } - } - } - } - } - }, - lead_conversion: { - label: "\u30EA\u30FC\u30C9\u5909\u63DB\u30D7\u30ED\u30BB\u30B9", - screens: { - screen_1: { - title: "\u30EA\u30FC\u30C9\u5909\u63DB\u30D7\u30ED\u30BB\u30B9", - // The duplicate warning's text is a variable the flow assigns; this - // key can only carry the hole that shows it. - description: "{{duplicateWarning}}", - fields: { - createOpportunity: { label: "\u5546\u8AC7\u3092\u4F5C\u6210\u3057\u307E\u3059\u304B\uFF1F" }, - opportunityName: { label: "\u5546\u8AC7\u540D" }, - opportunityAmount: { label: "\u5546\u8AC7\u91D1\u984D" }, - closeDate: { label: "\u5B8C\u4E86\u4E88\u5B9A\u65E5" } - } - }, - refuse_confirmed_duplicate: { - title: "\u5909\u63DB\u306F\u62D2\u5426\u3055\u308C\u307E\u3057\u305F", - description: "\u3053\u306E\u30EA\u30FC\u30C9\u306E\u91CD\u8907\u30B9\u30C6\u30FC\u30BF\u30B9\u306F\u300C\u91CD\u8907\u78BA\u5B9A\u300D\u3067\u3059\u3002\u30EC\u30D3\u30E5\u30FC\u62C5\u5F53\u8005\u304C\u65E2\u5B58\u306E\u30EC\u30B3\u30FC\u30C9\u3068\u7167\u5408\u3057\u3001\u91CD\u8907\u3067\u3042\u308B\u3068\u8A18\u9332\u3057\u307E\u3057\u305F\u3002\u5909\u63DB\u3059\u308B\u3068\u3001\u540C\u3058\u8CFC\u5165\u8005\u306B\u5BFE\u3057\u3066\u53D6\u5F15\u5148\u30FB\u53D6\u5F15\u5148\u8CAC\u4EFB\u8005\u30FB\u5546\u8AC7\u304C\u3082\u3046 1 \u4EF6\u305A\u3064\u4F5C\u6210\u3055\u308C\u307E\u3059\u3002\u6B8B\u3059\u30EC\u30B3\u30FC\u30C9\u306F\u3053\u306E\u30EA\u30FC\u30C9\u306E\u300C\u91CD\u8907\u7BA1\u7406\u300D\u30BB\u30AF\u30B7\u30E7\u30F3\u306B\u8868\u793A\u3055\u308C\u3066\u3044\u307E\u3059\u3002\u4EE3\u308F\u308A\u306B\u3001\u3053\u306E\u30EA\u30FC\u30C9\u3092\u91CD\u8907\u3068\u3057\u3066\u4E0D\u9069\u683C\u306B\u3057\u3066\u304F\u3060\u3055\u3044\u3002\u5909\u63DB\u3092\u518D\u3073\u53EF\u80FD\u306B\u3067\u304D\u308B\u306E\u306F\u3001\u305D\u306E\u5224\u5B9A\u3092\u898B\u76F4\u3059\u30EC\u30D3\u30E5\u30FC\u62C5\u5F53\u8005\u3060\u3051\u3067\u3059\u3002" - }, - refuse_unapproved: { - title: "\u5909\u63DB\u306F\u62D2\u5426\u3055\u308C\u307E\u3057\u305F", - description: "\u3053\u306E\u30EA\u30FC\u30C9\u306F\u307E\u3060\u5909\u63DB\u306E\u627F\u8A8D\u3092\u5F97\u3066\u3044\u307E\u305B\u3093\u3002\u53D6\u5F15\u5148\u30FB\u53D6\u5F15\u5148\u8CAC\u4EFB\u8005\u30FB\u5546\u8AC7\u306B\u5909\u63DB\u3059\u308B\u306B\u306F\u3001\u5148\u306B\u627F\u8A8D\u8005\u306E\u627F\u8A8D\u304C\u5FC5\u8981\u3067\u3059\u3002\u30EA\u30FC\u30C9\u306E\u300C\u30B3\u30F3\u30D0\u30FC\u30B8\u30E7\u30F3\u627F\u8A8D\u300D\u9805\u76EE\u3067\u3001\u5224\u65AD\u304C\u307E\u3060\u627F\u8A8D\u5F85\u3061\u304B\u3001\u5374\u4E0B\u3055\u308C\u305F\u304B\u3092\u78BA\u8A8D\u3067\u304D\u307E\u3059\u3002\u305D\u308C\u307E\u3067\u306E\u9593\u3082\u30EA\u30FC\u30C9\u3078\u306E\u5BFE\u5FDC\u306F\u7D9A\u3051\u3066\u304F\u3060\u3055\u3044\u3002\u51CD\u7D50\u3055\u308C\u308B\u3082\u306E\u306F\u3042\u308A\u307E\u305B\u3093\u3002" - }, - refuse_no_match_key: { - title: "\u5909\u63DB\u306F\u62D2\u5426\u3055\u308C\u307E\u3057\u305F", - description: "\u3053\u306E\u30EA\u30FC\u30C9\u306E\u4F1A\u793E\u540D\u306B\u306F\u7167\u5408\u30AD\u30FC\u304C\u306A\u3044\u305F\u3081\u3001\u5909\u63DB\u3067\u306F\u3069\u306E\u53D6\u5F15\u5148\u306B\u5C5E\u3059\u308B\u304B\u3092\u5224\u65AD\u3067\u304D\u305A\u3001\u63A8\u6E2C\u3082\u3057\u307E\u305B\u3093\u3002\u63A8\u6E2C\u3059\u308B\u3068\u3001\u53D6\u5F15\u5148\u8CAC\u4EFB\u8005\u3068\u5546\u8AC7\u304C\u5225\u306E\u9867\u5BA2\u306E\u4E0B\u306B\u767B\u9332\u3055\u308C\u308B\u304A\u305D\u308C\u304C\u3042\u308A\u307E\u3059\u3002\u30EA\u30FC\u30C9\u306E\u300C\u4F1A\u793E\u540D\u300D\u3092\u4FDD\u5B58\u3059\u308B\u3068\u30AD\u30FC\u304C\u518D\u4F5C\u6210\u3055\u308C\u308B\u306E\u3067\u3001\u3082\u3046\u4E00\u5EA6\u4FDD\u5B58\u3057\u3066\u304B\u3089\u5909\u63DB\u3057\u3066\u304F\u3060\u3055\u3044\u3002\u4F55\u3082\u4F5C\u6210\u3055\u308C\u3066\u3044\u307E\u305B\u3093\u3002" - } - } - }, - schedule_followup: { - label: "\u30D5\u30A9\u30ED\u30FC\u30A2\u30C3\u30D7\u3092\u8A2D\u5B9A", - screens: { - screen_1: { - title: "\u30D5\u30A9\u30ED\u30FC\u30A2\u30C3\u30D7\u3092\u8A2D\u5B9A", - fields: { - subject: { label: "\u6B21\u306E\u30B9\u30C6\u30C3\u30D7\u306F\uFF1F" }, - dueDate: { label: "\u671F\u9650" }, - activityType: { - label: "\u6D3B\u52D5\u7A2E\u5225", - options: { call: "\u96FB\u8A71", email: "\u30E1\u30FC\u30EB", meeting: "\u4F1A\u8B70", follow_up: "\u30D5\u30A9\u30ED\u30FC\u30A2\u30C3\u30D7", demo: "\u30C7\u30E2", other: "\u305D\u306E\u4ED6" } - }, - priority: { label: "\u512A\u5148\u5EA6", options: { low: "\u4F4E", normal: "\u901A\u5E38", high: "\u9AD8", urgent: "\u7DCA\u6025" } }, - notes: { label: "\u30E1\u30E2" } - } - } - } - }, - quote_generation: { - label: "\u5546\u8AC7\u304B\u3089\u898B\u7A4D\u3092\u4F5C\u6210", - refusals: { refuse_held: { message: "\u5148\u306B\u6848\u4EF6\u5316\u627F\u8A8D\u304C\u5FC5\u8981\u3067\u3059\u3002\u300C\u6848\u4EF6\u5316\u627F\u8A8D\u3092\u7533\u8ACB\u300D\u306B\u30C1\u30A7\u30C3\u30AF\u3092\u5165\u308C\u3066\u304F\u3060\u3055\u3044\u3002\u4F55\u3082\u4F5C\u6210\u3055\u308C\u3066\u3044\u307E\u305B\u3093\u3002" } }, - screens: { - screen_1: { - title: "\u5546\u8AC7\u304B\u3089\u898B\u7A4D\u3092\u4F5C\u6210", - fields: { - quoteName: { label: "\u898B\u7A4D\u540D" }, - expirationDays: { label: "\u6709\u52B9\u671F\u9593\uFF08\u65E5\uFF09" }, - discount: { label: `\u5272\u5F15\u7387 % (\u2264 ${QUOTE_DISCOUNT_CEILING})`, placeholder: `0-${QUOTE_DISCOUNT_CEILING}` } - } - } - } - } - } -}; - -// src/sales/translations/ja-JP/_shared.ts -var activityActions3 = { - log_call: { - label: "\u96FB\u8A71\u3092\u8A18\u9332", - successMessage: "\u96FB\u8A71\u3092\u8A18\u9332\u3057\u307E\u3057\u305F\uFF01", - params: { - subject: { label: "\u96FB\u8A71\u306E\u4EF6\u540D" }, - duration: { label: "\u6240\u8981\u6642\u9593\uFF08\u5206\uFF09" }, - attendee_contacts: { label: "\u53D6\u5F15\u5148\u8CAC\u4EFB\u8005\u306E\u53C2\u52A0\u8005" }, - attendee_users: { label: "\u793E\u5185\u53C2\u52A0\u8005" }, - notes: { label: "\u901A\u8A71\u30E1\u30E2" } - } - }, - log_meeting: { - label: "\u4F1A\u8B70\u3092\u8A18\u9332", - successMessage: "\u4F1A\u8B70\u3092\u8A18\u9332\u3057\u307E\u3057\u305F\uFF01", - params: { - subject: { label: "\u4F1A\u8B70\u306E\u4EF6\u540D" }, - duration: { label: "\u6240\u8981\u6642\u9593\uFF08\u5206\uFF09" }, - attendee_contacts: { label: "\u53D6\u5F15\u5148\u8CAC\u4EFB\u8005\u306E\u53C2\u52A0\u8005" }, - attendee_users: { label: "\u793E\u5185\u53C2\u52A0\u8005" }, - notes: { label: "\u8B70\u4E8B\u30E1\u30E2" } - } - }, - schedule_meeting: { - label: "\u4F1A\u8B70\u3092\u8A2D\u5B9A", - successMessage: "\u4F1A\u8B70\u3092\u8A2D\u5B9A\u3057\u307E\u3057\u305F\uFF01", - params: { - subject: { label: "\u4F1A\u8B70\u306E\u4EF6\u540D" }, - start_date: { label: "\u958B\u59CB\u65E5 (UTC)" }, - start_time: { label: "\u958B\u59CB\u6642\u523B (UTC)" }, - location: { label: "\u5834\u6240" }, - duration: { label: "\u6240\u8981\u6642\u9593\uFF08\u5206\uFF09" }, - attendee_contacts: { label: "\u53D6\u5F15\u5148\u8CAC\u4EFB\u8005\u306E\u53C2\u52A0\u8005" }, - attendee_users: { label: "\u793E\u5185\u53C2\u52A0\u8005" }, - notes: { label: "\u30A2\u30B8\u30A7\u30F3\u30C0" } - } - } -}; -var salutationOptions = { mr: "Mr.", ms: "Ms.", mrs: "Mrs.", dr: "\u535A\u58EB", prof: "\u6559\u6388" }; -var industryOptions = { - technology: "\u30C6\u30AF\u30CE\u30ED\u30B8\u30FC", - software: "\u30BD\u30D5\u30C8\u30A6\u30A7\u30A2 / SaaS", - finance: "\u91D1\u878D", - healthcare: "\u30D8\u30EB\u30B9\u30B1\u30A2", - retail: "\u5C0F\u58F2", - manufacturing: "\u88FD\u9020", - education: "\u6559\u80B2", - real_estate: "\u4E0D\u52D5\u7523", - media: "\u30E1\u30C7\u30A3\u30A2\u30FB\u30A8\u30F3\u30BF\u30E1", - logistics: "\u7269\u6D41", - hospitality: "\u30DB\u30B9\u30D4\u30BF\u30EA\u30C6\u30A3", - energy: "\u30A8\u30CD\u30EB\u30AE\u30FC\u30FB\u516C\u76CA", - government: "\u653F\u5E9C\u30FB\u884C\u653F", - nonprofit: "\u975E\u55B6\u5229", - other: "\u305D\u306E\u4ED6" -}; -var leadSourceOptions = { - web: "\u30A6\u30A7\u30D6", - referral: "\u7D39\u4ECB", - event: "\u30A4\u30D9\u30F3\u30C8\u30FB\u5C55\u793A\u4F1A", - webinar: "\u30A6\u30A7\u30D3\u30CA\u30FC", - partner: "\u30D1\u30FC\u30C8\u30CA\u30FC", - advertisement: "\u5E83\u544A", - paid_search: "\u6709\u6599\u691C\u7D22", - social: "\u30BD\u30FC\u30B7\u30E3\u30EB\u30E1\u30C7\u30A3\u30A2", - content: "\u30B3\u30F3\u30C6\u30F3\u30C4\u30FB\u30D6\u30ED\u30B0", - cold_call: "\u30B3\u30FC\u30EB\u30C9\u30B3\u30FC\u30EB", - email_campaign: "\u30E1\u30FC\u30EB\u30AD\u30E3\u30F3\u30DA\u30FC\u30F3", - other: "\u305D\u306E\u4ED6" -}; - -// src/sales/translations/ja-JP/objects.customer.ts -var customer3 = { - crm_account: { - label: "\u53D6\u5F15\u5148", - pluralLabel: "\u53D6\u5F15\u5148", - description: "\u5F53\u793E\u3068\u53D6\u5F15\u306E\u3042\u308B\u4F01\u696D\u30FB\u7D44\u7E54", - fields: { - account_number: { label: "\u53D6\u5F15\u5148\u756A\u53F7" }, - registration_number: { - label: "\u767B\u8A18\u756A\u53F7", - help: "\u53D6\u5F15\u5148\u304C\u81EA\u56FD\u306E\u767B\u8A18\u6A5F\u95A2\u304B\u3089\u4EA4\u4ED8\u3055\u308C\u305F\u767B\u8A18\u4E0A\u306E\u8B58\u5225\u756A\u53F7\u3002\u5F53\u793E\u304C\u63A1\u756A\u3059\u308B\u53D6\u5F15\u5148\u756A\u53F7\u3068\u306F\u7570\u306A\u308A\u307E\u3059\u3002" - }, - commercial_capability: { - label: "\u5546\u8AC7\u53EF\u5426\u533A\u5206", - help: "\u3053\u306E\u53D6\u5F15\u5148\u306B\u5BFE\u3057\u3066\u65B0\u898F\u306E\u5546\u8AC7\u3092\u958B\u59CB\u3067\u304D\u308B\u304B\u3069\u3046\u304B\u3002\u6C7A\u6E08\u306E\u307F\u306E\u53D6\u5F15\u5148\u306F\u8ACB\u6C42\u30FB\u5165\u91D1\u306B\u306F\u5F15\u304D\u7D9A\u304D\u5229\u7528\u3067\u304D\u307E\u3059\u304C\u3001\u65B0\u898F\u5546\u8AC7\u3092\u95A2\u9023\u4ED8\u3051\u308B\u3053\u3068\u306F\u3067\u304D\u307E\u305B\u3093\u3002", - options: { full: "\u5236\u9650\u306A\u3057", settlement_only: "\u6C7A\u6E08\u306E\u307F" } - }, - incumbent_vendor: { label: "\u73FE\u884C\u30D9\u30F3\u30C0\u30FC", help: "\u5F53\u793E\u304C\u72D9\u3063\u3066\u3044\u308B\u652F\u51FA\u3092\u73FE\u5728\u53D7\u6CE8\u3057\u3066\u3044\u308B\u30D9\u30F3\u30C0\u30FC\u3002" }, - annual_purchasing_budget: { label: "\u5E74\u9593\u8ABF\u9054\u4E88\u7B97", help: "\u3053\u306E\u53D6\u5F15\u5148\u304C\u4ECA\u5E74\u5EA6\u30D9\u30F3\u30C0\u30FC\u306B\u652F\u51FA\u3059\u308B\u898B\u8FBC\u307F\u984D\u3067\u3042\u308A\u3001\u81EA\u793E\u306E\u58F2\u4E0A\u9AD8\u3067\u306F\u3042\u308A\u307E\u305B\u3093\u3002" }, - payment_cycle: { - label: "\u652F\u6255\u30B5\u30A4\u30AF\u30EB", - options: { prepaid: "\u524D\u6255\u3044", net_30: "30\u65E5", net_60: "60\u65E5", net_90: "90\u65E5" } - }, - approval_status: { - label: "\u627F\u8A8D\u30B9\u30C6\u30FC\u30BF\u30B9", - help: "\u3053\u306E\u53D6\u5F15\u5148\u306E\u627F\u8A8D\u72B6\u6CC1\u3002\u65B0\u898F\u53D6\u5F15\u5148\u306F\u627F\u8A8D\u5F85\u3061\u3067\u4F5C\u6210\u3055\u308C\u3001\u627F\u8A8D\u30C8\u30EC\u30A4\u3067\u5224\u65AD\u3055\u308C\u307E\u3059\u3002", - options: { pending: "\u627F\u8A8D\u5F85\u3061", approved: "\u627F\u8A8D\u6E08\u307F", rejected: "\u5374\u4E0B" } - }, - name: { label: "\u53D6\u5F15\u5148\u540D", help: "\u4F1A\u793E\u307E\u305F\u306F\u7D44\u7E54\u306E\u6B63\u5F0F\u540D\u79F0" }, - name_normalized: { - label: "\u53D6\u5F15\u5148\u540D\uFF08\u6B63\u898F\u5316\uFF09", - help: "\u30EA\u30FC\u30C9\u5909\u63DB\u306E\u7167\u5408\u30AD\u30FC\u3002\u53D6\u5F15\u5148\u540D\u3092\u5C0F\u6587\u5B57\u5316\u3057\u3001\u524D\u5F8C\u306E\u7A7A\u767D\u3092\u9664\u53BB\u3057\u3066\u3001\u5185\u90E8\u306E\u9023\u7D9A\u3059\u308B\u7A7A\u767D\u3092 1 \u3064\u306B\u307E\u3068\u3081\u305F\u3082\u306E\u3002account_protection \u30D5\u30C3\u30AF\u304C\u81EA\u52D5\u3067\u7DAD\u6301\u3057\u307E\u3059 \u2014 \u76F4\u63A5\u7DE8\u96C6\u3057\u306A\u3044\u3067\u304F\u3060\u3055\u3044\u3002" - }, - display_title: { label: "\u8868\u793A\u540D" }, - type: { - label: "\u30BF\u30A4\u30D7", - options: { prospect: "\u898B\u8FBC\u307F\u5BA2", customer: "\u9867\u5BA2", partner: "\u30D1\u30FC\u30C8\u30CA\u30FC", former: "\u904E\u53BB\u306E\u53D6\u5F15\u5148" } - }, - industry: { - label: "\u696D\u7A2E", - options: { ...industryOptions } - }, - annual_revenue: { label: "\u5E74\u9593\u58F2\u4E0A" }, - child_account_revenue: { label: "\u5B50\u4F1A\u793E\u5E74\u9593\u58F2\u4E0A\u5408\u8A08", help: "\u76F4\u5C5E\u306E\u5B50\u53D6\u5F15\u5148\u306E\u5E74\u9593\u58F2\u4E0A\u306E\u5408\u8A08\u3002" }, - number_of_employees: { label: "\u5F93\u696D\u54E1\u6570" }, - phone: { label: "\u96FB\u8A71\u756A\u53F7" }, - website: { label: "Web\u30B5\u30A4\u30C8" }, - billing_address: { label: "\u8ACB\u6C42\u5148\u4F4F\u6240" }, - billing_country: { - label: "\u8ACB\u6C42\u5148\u56FD", - help: "\u8ACB\u6C42\u5148\u4F4F\u6240\u304B\u3089\u5C0E\u51FA \u2014 \u5165\u529B\u3055\u308C\u305F\u56FD\u540D\u3092\u305D\u306E\u307E\u307E\u3001\u524D\u5F8C\u306E\u7A7A\u767D\u3092\u9664\u53BB\u3057\u5927\u6587\u5B57\u5316\u3057\u305F\u5024\u3002" - }, - territory: { - label: "\u30C6\u30EA\u30C8\u30EA\u30FC", - help: "\u8ACB\u6C42\u5148\u4F4F\u6240\u304B\u3089\u5C0E\u51FA \u2014 \u30C6\u30EA\u30C8\u30EA\u30FC\u5171\u6709\u30EB\u30FC\u30EB\u304C\u7167\u5408\u3059\u308B\u55B6\u696D\u30C6\u30EA\u30C8\u30EA\u30FC\u3002\u62C5\u5F53\u30C1\u30FC\u30E0\u306E\u306A\u3044\u30C6\u30EA\u30C8\u30EA\u30FC\u306E\u53D6\u5F15\u5148\u306F\u300C\u305D\u306E\u4ED6\u300D\u3002", - options: { na: "\u5317\u7C73", emea: "EMEA", other: "\u305D\u306E\u4ED6" } - }, - office_location: { label: "\u30AA\u30D5\u30A3\u30B9\u6240\u5728\u5730" }, - owner_id: { label: "\u53D6\u5F15\u5148\u6240\u6709\u8005" }, - parent_account: { label: "\u89AA\u53D6\u5F15\u5148", help: "\u968E\u5C64\u69CB\u9020\u306B\u304A\u3051\u308B\u89AA\u4F1A\u793E" }, - description: { label: "\u8AAC\u660E" }, - is_active: { label: "\u6709\u52B9" }, - last_activity_date: { label: "\u6700\u7D42\u6D3B\u52D5\u65E5" }, - brand_color: { label: "\u30D6\u30E9\u30F3\u30C9\u30AB\u30E9\u30FC" }, - logo: { label: "\u4F1A\u793E\u30ED\u30B4" }, - tier: { - label: "\u9867\u5BA2\u30E9\u30F3\u30AF", - options: { - strategic: "\u6226\u7565\u9867\u5BA2", - enterprise: "\u30A8\u30F3\u30BF\u30FC\u30D7\u30E9\u30A4\u30BA", - mid_market: "\u30DF\u30C3\u30C9\u30DE\u30FC\u30B1\u30C3\u30C8", - smb: "\u4E2D\u5C0F\u4F01\u696D" - } - }, - segment: { - label: "\u9867\u5BA2\u30BB\u30B0\u30E1\u30F3\u30C8", - options: { net_new: "\u65B0\u898F\u7372\u5F97", growth: "\u6210\u9577", at_risk: "\u30EA\u30B9\u30AF\u3042\u308A", stable: "\u5B89\u5B9A" } - }, - health_score: { - label: "\u30D8\u30EB\u30B9\u30B9\u30B3\u30A2", - help: "\u30AB\u30B9\u30BF\u30DE\u30FC\u30B5\u30AF\u30BB\u30B9\u62C5\u5F53\uFF08CSM\uFF09\u304C\u7BA1\u7406\u3059\u308B\u5065\u5168\u6027\u306E\u6307\u6A19", - options: { healthy: "\u826F\u597D", watching: "\u8981\u89B3\u5BDF", at_risk: "\u30EA\u30B9\u30AF\u3042\u308A", churning: "\u89E3\u7D04\u9032\u884C\u4E2D" } - } - }, - _views: { - all_accounts: { - label: "\u5168\u53D6\u5F15\u5148", - description: "\u58F2\u4E0A\u3068\u696D\u7A2E\u3092\u542B\u3080\u53D6\u5F15\u5148\u306E\u4E00\u89A7", - bulkActions: { - delete: { - label: "\u524A\u9664", - confirmLabel: "\u524A\u9664", - confirmText: "{{count}} \u4EF6\u306E\u53D6\u5F15\u5148\u3092\u5B8C\u5168\u306B\u524A\u9664\u3057\u307E\u3059\u304B\uFF1F\u3053\u306E\u64CD\u4F5C\u306F\u53D6\u308A\u6D88\u305B\u307E\u305B\u3093\u3002" - }, - transfer_owner: { - label: "\u6240\u6709\u8005\u306E\u5909\u66F4", - confirmText: "{{count}} \u4EF6\u306E\u53D6\u5F15\u5148\u306E\u6240\u6709\u8005\u3092\u5909\u66F4\u3057\u307E\u3059\u304B\uFF1F", - params: { - owner_id: { - label: "\u65B0\u3057\u3044\u6240\u6709\u8005" - } - } - }, - update_tier: { - label: "\u9867\u5BA2\u30E9\u30F3\u30AF\u306E\u66F4\u65B0", - confirmText: "{{count}} \u4EF6\u306E\u53D6\u5F15\u5148\u306E\u9867\u5BA2\u30E9\u30F3\u30AF\u3092 {{tier}} \u306B\u66F4\u65B0\u3057\u307E\u3059\u304B\uFF1F", - params: { - tier: { - label: "\u9867\u5BA2\u30E9\u30F3\u30AF" - } - } - } - } - }, - account_gallery: { label: "\u53D6\u5F15\u5148\u30AB\u30FC\u30C9", description: "\u30D6\u30E9\u30F3\u30C9\u30AB\u30E9\u30FC\u4ED8\u304D\u306E\u30AB\u30FC\u30C9\u30D3\u30E5\u30FC" }, - account_map: { label: "\u53D6\u5F15\u5148\u30DE\u30C3\u30D7", description: "\u53D6\u5F15\u5148\u306E\u5730\u7406\u7684\u5206\u5E03" }, - enterprise_accounts: { label: "\u30A8\u30F3\u30BF\u30FC\u30D7\u30E9\u30A4\u30BA\u53D6\u5F15\u5148", description: "\u5E74\u5546\u6700\u4E0A\u4F4D\u306E\u4E3B\u8981\u9867\u5BA2" }, - my_accounts: { label: "\u79C1\u306E\u53D6\u5F15\u5148", description: "\u81EA\u5206\u304C\u6240\u6709\u3059\u308B\u53D6\u5F15\u5148" }, - at_risk_accounts: { label: "\u26A0\uFE0F \u30EA\u30B9\u30AF\u306E\u3042\u308B\u53D6\u5F15\u5148" } - }, - _sections: { - basic: { label: "\u57FA\u672C\u60C5\u5831" }, - financials: { label: "\u8CA1\u52D9\u60C5\u5831" }, - business_profile: { label: "\u30D3\u30B8\u30CD\u30B9\u60C5\u5831" }, - contact_info: { label: "\u9023\u7D61\u5148\u60C5\u5831" }, - ownership: { label: "\u6240\u6709\u8005\u30FB\u30B9\u30C6\u30FC\u30BF\u30B9" }, - branding: { label: "\u30D6\u30E9\u30F3\u30C7\u30A3\u30F3\u30B0" }, - system: { label: "\u30B7\u30B9\u30C6\u30E0" }, - // account.view.ts のフォームセクション名 (#1100) - profile: { label: "\u30D7\u30ED\u30D5\u30A3\u30FC\u30EB" }, - customer_success: { label: "\u30AB\u30B9\u30BF\u30DE\u30FC\u30B5\u30AF\u30BB\u30B9" }, - locations: { label: "\u6240\u5728\u5730" }, - description: { label: "\u8AAC\u660E" } - }, - _actions: { ...activityActions3 } - }, - crm_contact: { - label: "\u53D6\u5F15\u5148\u8CAC\u4EFB\u8005", - pluralLabel: "\u53D6\u5F15\u5148\u8CAC\u4EFB\u8005", - description: "\u53D6\u5F15\u5148\u306B\u6240\u5C5E\u3059\u308B\u62C5\u5F53\u8005", - fields: { - salutation: { label: "\u656C\u79F0", options: { ...salutationOptions } }, - first_name: { label: "\u540D" }, - last_name: { label: "\u59D3" }, - full_name: { label: "\u6C0F\u540D" }, - crm_account: { label: "\u53D6\u5F15\u5148" }, - email: { label: "\u30E1\u30FC\u30EB" }, - phone: { label: "\u96FB\u8A71" }, - mobile: { label: "\u643A\u5E2F\u96FB\u8A71" }, - title: { label: "\u5F79\u8077" }, - department: { - label: "\u90E8\u9580", - options: { - executive: "\u7D4C\u55B6\u5C64", - sales: "\u55B6\u696D\u90E8", - marketing: "\u30DE\u30FC\u30B1\u30C6\u30A3\u30F3\u30B0\u90E8", - engineering: "\u30A8\u30F3\u30B8\u30CB\u30A2\u30EA\u30F3\u30B0\u90E8", - support: "\u30B5\u30DD\u30FC\u30C8\u90E8", - finance: "\u7D4C\u7406\u90E8", - hr: "\u4EBA\u4E8B\u90E8", - operations: "\u30AA\u30DA\u30EC\u30FC\u30B7\u30E7\u30F3\u90E8" - } - }, - // バイイングセンター (REQ-0004) — 意思決定のマップ。英語ラベルは - // 'Buying Role' ではなく 'Buying Function'：security-role-word ルールが - // 宣言側で英単語 role を予約している (ADR-0090 D3)。同ルールは英語のみを - // 読み言語パックには及ばないため、ここでは日本語として自然な語を使う。 - buying_function: { - label: "\u8CFC\u8CB7\u5F79\u5272", - options: { - decision_maker: "\u6C7A\u88C1\u8005", - economic_buyer: "\u4E88\u7B97\u6C7A\u88C1\u8005", - technical_evaluator: "\u6280\u8853\u8A55\u4FA1\u8005", - user: "\u5229\u7528\u8005", - influencer: "\u5F71\u97FF\u8005", - gatekeeper: "\u30B2\u30FC\u30C8\u30AD\u30FC\u30D1\u30FC" - } - }, - attitude: { - label: "\u81EA\u793E\u3078\u306E\u614B\u5EA6", - options: { - champion: "\u63A8\u9032\u8005", - supportive: "\u597D\u610F\u7684", - neutral: "\u4E2D\u7ACB", - skeptical: "\u61D0\u7591\u7684", - blocker: "\u53CD\u5BFE\u8005" - } - }, - relationship_strength: { - label: "\u95A2\u4FC2\u306E\u5F37\u3055", - options: { - distant: "\u758E\u9060", - acquaintance: "\u9854\u898B\u77E5\u308A", - working: "\u696D\u52D9\u4E0A\u306E\u95A2\u4FC2", - strong: "\u5F37\u3044", - trusted_advisor: "\u4FE1\u983C\u3055\u308C\u308B\u30A2\u30C9\u30D0\u30A4\u30B6\u30FC" - } - }, - owner_id: { label: "\u53D6\u5F15\u5148\u8CAC\u4EFB\u8005\u306E\u6240\u6709\u8005" }, - description: { label: "\u8AAC\u660E" }, - is_primary: { label: "\u4E3B\u62C5\u5F53\u8005", help: "\u3053\u306E\u53D6\u5F15\u5148\u306E\u4E3B\u62C5\u5F53\u8005\u304B\u3069\u3046\u304B" }, - avatar: { label: "\u30D7\u30ED\u30D5\u30A3\u30FC\u30EB\u753B\u50CF" }, - mailing_address: { label: "\u90F5\u9001\u5148\u4F4F\u6240" }, - lead_source: { label: "\u30EA\u30FC\u30C9\u30BD\u30FC\u30B9", options: { ...leadSourceOptions } }, - do_not_call: { label: "\u96FB\u8A71\u62D2\u5426" }, - email_opt_out: { label: "\u30E1\u30FC\u30EB\u914D\u4FE1\u505C\u6B62" }, - last_contacted_date: { label: "\u6700\u7D42\u63A5\u89E6\u65E5\u6642" } - }, - _views: { - all_contacts: { label: "\u5168\u53D6\u5F15\u5148\u8CAC\u4EFB\u8005" }, - contact_directory: { label: "\u8CAC\u4EFB\u8005\u30C7\u30A3\u30EC\u30AF\u30C8\u30EA" }, - primary_contacts: { label: "\u4E3B\u62C5\u5F53\u8005" } - }, - _sections: { - identity: { label: "\u57FA\u672C\u60C5\u5831" }, - account_info: { label: "\u53D6\u5F15\u5148\u30FB\u5F79\u8077" }, - buying_centre: { label: "\u30D0\u30A4\u30A4\u30F3\u30B0\u30BB\u30F3\u30BF\u30FC" }, - contact_info: { label: "\u9023\u7D61\u5148\u60C5\u5831" }, - mailing_address: { label: "\u90F5\u9001\u5148\u4F4F\u6240" }, - additional: { label: "\u305D\u306E\u4ED6\u306E\u60C5\u5831" }, - preferences: { label: "\u30B3\u30DF\u30E5\u30CB\u30B1\u30FC\u30B7\u30E7\u30F3\u8A2D\u5B9A" }, - // contact.view.ts のフォームセクション名 (#1100) - contact_details: { label: "\u9023\u7D61\u5148\u60C5\u5831" }, - comm_preferences: { label: "\u8A2D\u5B9A" } - }, - _actions: { - ...activityActions3, - mark_primary: { - label: "\u4E3B\u62C5\u5F53\u8005\u306B\u8A2D\u5B9A", - confirmText: "\u3053\u306E\u8CAC\u4EFB\u8005\u3092\u53D6\u5F15\u5148\u306E\u4E3B\u62C5\u5F53\u8005\u306B\u8A2D\u5B9A\u3057\u307E\u3059\u304B\uFF1F", - successMessage: "\u4E3B\u62C5\u5F53\u8005\u306B\u8A2D\u5B9A\u3057\u307E\u3057\u305F\uFF01" - }, - send_email: { - label: "\u30E1\u30FC\u30EB\u9001\u4FE1", - params: { - subject: { label: "\u4EF6\u540D" }, - body: { label: "\u672C\u6587" } - } - }, - add_contact_to_campaign: { - label: "\u30AD\u30E3\u30F3\u30DA\u30FC\u30F3\u306B\u8FFD\u52A0", - successMessage: "\u53D6\u5F15\u5148\u8CAC\u4EFB\u8005\u3092\u30AD\u30E3\u30F3\u30DA\u30FC\u30F3\u306B\u8FFD\u52A0\u3057\u307E\u3057\u305F\uFF01", - params: { - crm_campaign: { label: "\u30AD\u30E3\u30F3\u30DA\u30FC\u30F3" } - } - } - } - } -}; - -// src/sales/translations/ja-JP/objects.pipeline.ts -var opportunityStageOptions = { - prospecting: "\u898B\u8FBC\u307F\u8ABF\u67FB", - qualification: "\u9078\u5B9A", - needs_analysis: "\u30CB\u30FC\u30BA\u5206\u6790", - proposal: "\u63D0\u6848", - negotiation: "\u4EA4\u6E09", - closed_won: "\u6210\u7ACB", - closed_lost: "\u4E0D\u6210\u7ACB" -}; -var pipeline3 = { - crm_lead: { - _validations: { - disqualification_reason_required: { - message: "\u30EA\u30FC\u30C9\u3092\u300C\u5BFE\u8C61\u5916\u300D\u306B\u3059\u308B\u5834\u5408\u306F\u5931\u683C\u7406\u7531\u304C\u5FC5\u8981\u3067\u3059" - }, - duplicate_disqualification_requires_survivor: { - message: "\u91CD\u8907\u3092\u7406\u7531\u306B\u30EA\u30FC\u30C9\u3092\u5931\u683C\u3068\u3059\u308B\u5834\u5408\u306F\u3001\u6B8B\u3059\u30EC\u30B3\u30FC\u30C9\u3092\u6307\u5B9A\u3057\u3001\u91CD\u8907\u30B9\u30C6\u30FC\u30BF\u30B9\u3092\u300C\u78BA\u8A8D\u6E08\u307F\u300D\u306B\u3059\u308B\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059" - }, - email_required: { - message: "\u30E1\u30FC\u30EB\u30A2\u30C9\u30EC\u30B9\u306F\u5FC5\u9808\u3067\u3059" - }, - lead_status_progression: { - message: "\u7121\u52B9\u306A\u30EA\u30FC\u30C9\u30B9\u30C6\u30FC\u30BF\u30B9\u9077\u79FB\u3067\u3059" - } - }, - label: "\u30EA\u30FC\u30C9", - pluralLabel: "\u30EA\u30FC\u30C9", - description: "\u307E\u3060\u9069\u683C\u5224\u5B9A\u3092\u53D7\u3051\u3066\u3044\u306A\u3044\u898B\u8FBC\u307F\u5BA2", - fields: { - salutation: { label: "\u656C\u79F0", options: { ...salutationOptions } }, - first_name: { label: "\u540D" }, - last_name: { label: "\u59D3" }, - full_name: { label: "\u6C0F\u540D" }, - display_title: { label: "\u8868\u793A\u540D" }, - company: { label: "\u4F1A\u793E\u540D" }, - company_normalized: { - label: "\u4F1A\u793E\u540D\uFF08\u6B63\u898F\u5316\uFF09", - help: "\u30EA\u30FC\u30C9\u5909\u63DB\u306E\u7167\u5408\u30AD\u30FC\u3002\u4F1A\u793E\u540D\u3092\u5C0F\u6587\u5B57\u5316\u3057\u3001\u524D\u5F8C\u306E\u7A7A\u767D\u3092\u9664\u53BB\u3057\u3066\u3001\u5185\u90E8\u306E\u9023\u7D9A\u3059\u308B\u7A7A\u767D\u3092 1 \u3064\u306B\u307E\u3068\u3081\u305F\u3082\u306E\u3002lead_duplicate_check \u30D5\u30C3\u30AF\u304C\u81EA\u52D5\u3067\u7DAD\u6301\u3057\u307E\u3059 \u2014 \u76F4\u63A5\u7DE8\u96C6\u3057\u306A\u3044\u3067\u304F\u3060\u3055\u3044\u3002" - }, - title: { label: "\u5F79\u8077" }, - email: { label: "\u30E1\u30FC\u30EB" }, - phone: { label: "\u96FB\u8A71" }, - industry: { - label: "\u696D\u7A2E", - options: { ...industryOptions } - }, - status: { - label: "\u30B9\u30C6\u30FC\u30BF\u30B9", - options: { - new: "\u65B0\u898F", - contacted: "\u30B3\u30F3\u30BF\u30AF\u30C8\u6E08\u307F", - qualified: "\u9069\u683C", - unqualified: "\u4E0D\u9069\u683C", - converted: "\u5909\u63DB\u6E08\u307F" - } - }, - lead_source: { label: "\u30EA\u30FC\u30C9\u30BD\u30FC\u30B9", options: { ...leadSourceOptions } }, - owner_id: { label: "\u30EA\u30FC\u30C9\u6240\u6709\u8005" }, - is_converted: { label: "\u5909\u63DB\u6E08\u307F" }, - description: { label: "\u8AAC\u660E" }, - mobile: { label: "\u643A\u5E2F\u96FB\u8A71" }, - website: { label: "Web\u30B5\u30A4\u30C8" }, - rating: { label: "\u30EA\u30FC\u30C9\u30B9\u30B3\u30A2", help: "\u30EA\u30FC\u30C9\u306E\u54C1\u8CEA\u30B9\u30B3\u30A2\uFF081\u301C5 \u6BB5\u968E\uFF09" }, - converted_account: { label: "\u5909\u63DB\u5F8C\u306E\u53D6\u5F15\u5148" }, - converted_contact: { label: "\u5909\u63DB\u5F8C\u306E\u53D6\u5F15\u5148\u8CAC\u4EFB\u8005" }, - converted_opportunity: { label: "\u5909\u63DB\u5F8C\u306E\u5546\u8AC7" }, - converted_date: { label: "\u5909\u63DB\u65E5" }, - address: { label: "\u4F4F\u6240" }, - annual_revenue: { label: "\u5E74\u9593\u58F2\u4E0A" }, - number_of_employees: { label: "\u5F93\u696D\u54E1\u6570" }, - notes: { label: "\u30E1\u30E2", help: "\u3053\u306E\u30EA\u30FC\u30C9\u306B\u95A2\u3059\u308B\u4F5C\u696D\u30E1\u30E2 \u2014 \u66F8\u5F0F\u8A2D\u5B9A\u306B\u5BFE\u5FDC\u3002" }, - do_not_call: { label: "\u96FB\u8A71\u62D2\u5426" }, - email_opt_out: { label: "\u30E1\u30FC\u30EB\u914D\u4FE1\u505C\u6B62" }, - next_followup_date: { label: "\u6B21\u56DE\u30D5\u30A9\u30ED\u30FC\u30A2\u30C3\u30D7\u65E5" }, - last_contacted_date: { label: "\u6700\u7D42\u63A5\u89E6\u65E5\u6642" }, - need_type: { - label: "\u30CB\u30FC\u30BA\u7A2E\u5225", - help: "\u3053\u306E\u898B\u8FBC\u5BA2\u304C\u4F55\u3092\u6C42\u3081\u3066\u3044\u308B\u304B\u3002\u5272\u308A\u5F53\u3066\u30FB\u512A\u5148\u9806\u4F4D\u4ED8\u3051\u30FB\u9700\u8981\u5206\u6790\u304C\u3053\u306E\u9805\u76EE\u3092\u53C2\u7167\u3057\u307E\u3059\u3002", - options: { - new_implementation: "\u65B0\u898F\u5C0E\u5165", - expansion: "\u62E1\u5F35\u30FB\u8FFD\u52A0", - replacement: "\u5165\u308C\u66FF\u3048\u30FB\u79FB\u884C", - renewal: "\u66F4\u65B0", - consulting: "\u30B3\u30F3\u30B5\u30EB\u30C6\u30A3\u30F3\u30B0", - support: "\u4FDD\u5B88\u30FB\u30B5\u30DD\u30FC\u30C8", - other: "\u305D\u306E\u4ED6" - } - }, - estimated_amount: { - label: "\u4E88\u60F3\u91D1\u984D", - help: "\u30AF\u30AA\u30EA\u30D5\u30A3\u30B1\u30FC\u30B7\u30E7\u30F3\u524D\u306E\u9700\u8981\u91D1\u984D\u306E\u898B\u7A4D\u308A\u3002\u30B3\u30F3\u30D0\u30FC\u30B8\u30E7\u30F3\u6642\u306B\u5546\u8AC7\u91D1\u984D\u3078\u521D\u671F\u5024\u3068\u3057\u3066\u5165\u308A\u307E\u3059\u3002" - }, - conversion_approval_status: { - label: "\u30B3\u30F3\u30D0\u30FC\u30B8\u30E7\u30F3\u627F\u8A8D", - help: "\u3053\u306E\u898B\u8FBC\u5BA2\u304C\u30B3\u30F3\u30D0\u30FC\u30B8\u30E7\u30F3\u306E\u627F\u8A8D\u3092\u5F97\u3066\u3044\u308B\u304B\u3002\u300C\u627F\u8A8D\u4E0D\u8981\u300D\u306F\u627F\u8A8D\u3092\u6C42\u3081\u306A\u3044\u72B6\u614B\u3067\u3001\u51FA\u8377\u6642\u306E\u65E2\u5B9A\u5024\u3067\u3059\u3002", - options: { - not_required: "\u627F\u8A8D\u4E0D\u8981", - pending: "\u627F\u8A8D\u5F85\u3061", - approved: "\u627F\u8A8D\u6E08\u307F", - rejected: "\u5374\u4E0B" - } - }, - disqualification_reason: { - label: "\u4E0D\u9069\u683C\u7406\u7531", - help: "\u30B9\u30C6\u30FC\u30BF\u30B9\u304C\u300C\u4E0D\u9069\u683C\u300D\u306E\u5834\u5408\u306F\u5FC5\u9808", - options: { - not_a_fit: "\u30CB\u30FC\u30BA\u304C\u5408\u308F\u306A\u3044", - no_budget: "\u4E88\u7B97\u306A\u3057", - wrong_persona: "\u62C5\u5F53\u8005\u304C\u7570\u306A\u308B", - unreachable: "\u9023\u7D61\u4E0D\u80FD", - duplicate: "\u91CD\u8907\u30EA\u30FC\u30C9", - competitor: "\u7AF6\u5408\u4ED6\u793E\u306B\u6C7A\u5B9A", - other: "\u305D\u306E\u4ED6" - } - }, - duplicate_of_type: { - label: "\u91CD\u8907\u5BFE\u8C61", - help: "\u91CD\u8907\u5143\u3068\u3057\u3066\u6B8B\u308B\u30EC\u30B3\u30FC\u30C9\u304C\u5C5E\u3059\u308B\u30AA\u30D6\u30B8\u30A7\u30AF\u30C8\u306E\u7A2E\u5225\u3002", - // `erased` は墓碑値であり選択肢ではない。フォームには表示しない - // （`src/sales/views/lead.view.ts` を参照）が、残存レコードが削除された - // リードはこの値を保持するため、レコードを読む場所ではラベルが要る。 - options: { crm_lead: "\u30EA\u30FC\u30C9", crm_contact: "\u53D6\u5F15\u5148\u8CAC\u4EFB\u8005", erased: "\u524A\u9664\u6E08\u307F\u30EC\u30B3\u30FC\u30C9" } - }, - duplicate_of_lead: { label: "\u91CD\u8907\u3059\u308B\u30EA\u30FC\u30C9" }, - duplicate_of_contact: { label: "\u91CD\u8907\u3059\u308B\u53D6\u5F15\u5148\u8CAC\u4EFB\u8005" }, - duplicate_status: { - label: "\u91CD\u8907\u30B9\u30C6\u30FC\u30BF\u30B9", - help: "\u300C\u91CD\u8907\u306E\u7591\u3044\u300D= \u767B\u9332\u6642\u306B\u81EA\u52D5\u3067\u4ED8\u4E0E\u3002\u300C\u91CD\u8907\u78BA\u5B9A\u300D= \u62C5\u5F53\u8005\u304C\u4E00\u81F4\u3092\u78BA\u8A8D\u6E08\u307F\u3002", - options: { suspected: "\u91CD\u8907\u306E\u7591\u3044", confirmed: "\u91CD\u8907\u78BA\u5B9A" } - } - }, - _views: { - all_leads: { - label: "\u5168\u30EA\u30FC\u30C9", - emptyState: { title: "\u30EA\u30FC\u30C9\u304C\u307E\u3060\u3042\u308A\u307E\u305B\u3093", message: "\u6700\u521D\u306E\u30EA\u30FC\u30C9\u3092\u4F5C\u6210\u3057\u3066\u59CB\u3081\u307E\u3057\u3087\u3046" } - }, - kanban_by_status: { label: "\u30EA\u30FC\u30C9\u30D1\u30A4\u30D7\u30E9\u30A4\u30F3" }, - calendar_by_created: { label: "\u30EA\u30FC\u30C9\u30AB\u30EC\u30F3\u30C0\u30FC" }, - gallery_view: { label: "\u30EA\u30FC\u30C9\u30AB\u30FC\u30C9" }, - my_leads: { label: "\u79C1\u306E\u30EA\u30FC\u30C9" }, - high_priority: { label: "\u512A\u5148\u5EA6\u9AD8" }, - hot_leads: { label: "\u{1F525} \u30DB\u30C3\u30C8\u30EA\u30FC\u30C9" }, - suspected_duplicates: { - label: "\u91CD\u8907\u306E\u7591\u3044\u304C\u3042\u308B\u30EA\u30FC\u30C9", - emptyState: { - title: "\u91CD\u8907\u306E\u7591\u3044\u306F\u3042\u308A\u307E\u305B\u3093", - message: "\u78BA\u8A8D\u306F\u4E0D\u8981\u3067\u3059 \u2014 \u518D\u767B\u9332\u3055\u308C\u305F\u30E1\u30FC\u30EB\u30A2\u30C9\u30EC\u30B9\u306F\u3059\u3079\u3066\u30C1\u30A7\u30C3\u30AF\u6E08\u307F\u3067\u3059\u3002" - } - } - }, - _sections: { - // オブジェクト定義のセクションキー（lead.object.ts）— 入力フォームと、 - // これらのグループを参照する詳細ページのセクション（#806）で使用 - address: { label: "\u4F4F\u6240" }, - identity: { label: "\u57FA\u672C\u60C5\u5831" }, - company_info: { label: "\u4F1A\u793E\u60C5\u5831" }, - contact_info: { label: "\u9023\u7D61\u5148\u60C5\u5831" }, - qualification: { label: "\u9069\u683C\u5224\u5B9A" }, - assignment: { label: "\u62C5\u5F53\u8005" }, - additional: { label: "\u305D\u306E\u4ED6\u306E\u60C5\u5831" }, - preferences: { label: "\u30B3\u30DF\u30E5\u30CB\u30B1\u30FC\u30B7\u30E7\u30F3\u8A2D\u5B9A" }, - conversion: { label: "\u5909\u63DB" }, - duplicates: { label: "\u91CD\u8907\u7BA1\u7406" }, - // lead.view.ts のフォームセクション名 (#1100) — デフォルトフォームと - // 名前付き formView すべてのセクション名がここに集まる。あちらにフォームを - // 追加したら、そのセクション名をここに追加する。 - contact_information: { label: "\u9023\u7D61\u5148\u60C5\u5831" }, - lead_classification: { label: "\u30EA\u30FC\u30C9\u5206\u985E" }, - company_information: { label: "\u4F1A\u793E\u60C5\u5831" }, - additional_information: { label: "\u8FFD\u52A0\u60C5\u5831" }, - privacy: { label: "\u30D7\u30E9\u30A4\u30D0\u30B7\u30FC" }, - general: { label: "\u4E00\u822C" }, - details: { label: "\u8A73\u7D30" }, - step_1_contact_details: { label: "\u30B9\u30C6\u30C3\u30D71\uFF1A\u9023\u7D61\u5148\u60C5\u5831" }, - step_2_company_information: { label: "\u30B9\u30C6\u30C3\u30D72\uFF1A\u4F1A\u793E\u60C5\u5831" }, - step_3_qualification: { label: "\u30B9\u30C6\u30C3\u30D73\uFF1A\u8CC7\u683C\u8A55\u4FA1" }, - step_4_review_and_convert: { label: "\u30B9\u30C6\u30C3\u30D74\uFF1A\u78BA\u8A8D\u3068\u5909\u63DB" }, - primary_information: { label: "\u4E3B\u8981\u60C5\u5831" }, - extended_details: { label: "\u8A73\u7D30\u60C5\u5831" }, - quick_edit: { label: "\u30AF\u30A4\u30C3\u30AF\u7DE8\u96C6" }, - update_lead_status: { label: "\u30EA\u30FC\u30C9\u30B9\u30C6\u30FC\u30BF\u30B9\u3092\u66F4\u65B0" }, - tell_us_about_yourself: { label: "\u3042\u306A\u305F\u306B\u3064\u3044\u3066\u6559\u3048\u3066\u304F\u3060\u3055\u3044" }, - about_your_company: { label: "\u8CB4\u793E\u306B\u3064\u3044\u3066" }, - how_can_we_help: { label: "\u3069\u306E\u3088\u3046\u306A\u3054\u7528\u4EF6\u3067\u3057\u3087\u3046\u304B\uFF1F" }, - lead_information: { label: "\u30EA\u30FC\u30C9\u60C5\u5831" }, - address_information: { label: "\u4F4F\u6240\u60C5\u5831" }, - privacy_preferences: { label: "\u30D7\u30E9\u30A4\u30D0\u30B7\u30FC\u8A2D\u5B9A" } - }, - _actions: { - ...activityActions3, - convert_lead: { - label: "\u30EA\u30FC\u30C9\u5909\u63DB", - successMessage: "\u30EA\u30FC\u30C9\u306E\u5909\u63DB\u306B\u6210\u529F\u3057\u307E\u3057\u305F\uFF01" - }, - create_campaign: { - label: "\u30AD\u30E3\u30F3\u30DA\u30FC\u30F3\u306B\u8FFD\u52A0", - successMessage: "\u30AD\u30E3\u30F3\u30DA\u30FC\u30F3\u306B\u8FFD\u52A0\u3057\u307E\u3057\u305F\uFF01", - params: { - crm_campaign: { label: "\u30AD\u30E3\u30F3\u30DA\u30FC\u30F3" } - } - }, - schedule_followup: { - label: "\u30D5\u30A9\u30ED\u30FC\u30A2\u30C3\u30D7\u3092\u8A2D\u5B9A", - successMessage: "\u30D5\u30A9\u30ED\u30FC\u30A2\u30C3\u30D7\u3092\u8A2D\u5B9A\u3057\u307E\u3057\u305F\u3002" - } - } - }, - crm_opportunity: { - _validations: { - amount_positive: { - message: "\u91D1\u984D\u306F 0 \u3088\u308A\u5927\u304D\u3044\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059" - }, - close_date_future: { - message: "\u5546\u8AC7\u304C\u30AF\u30ED\u30FC\u30BA\u3057\u3066\u3044\u308B\u5834\u5408\u3092\u9664\u304D\u3001\u5B8C\u4E86\u4E88\u5B9A\u65E5\u3092\u904E\u53BB\u306B\u8A2D\u5B9A\u3059\u308B\u3053\u3068\u306F\u3067\u304D\u307E\u305B\u3093" - }, - opportunity_stage_progression: { - message: "\u7121\u52B9\u306A\u5546\u8AC7\u30B9\u30C6\u30FC\u30B8\u9077\u79FB\u3067\u3059" - } - }, - label: "\u5546\u8AC7", - pluralLabel: "\u5546\u8AC7", - description: "\u30D1\u30A4\u30D7\u30E9\u30A4\u30F3\u4E0A\u306E\u5546\u8AC7\u30FB\u6848\u4EF6", - fields: { - name: { label: "\u5546\u8AC7\u540D" }, - crm_account: { label: "\u53D6\u5F15\u5148" }, - primary_contact: { label: "\u4E3B\u62C5\u5F53\u8005" }, - owner_id: { label: "\u5546\u8AC7\u6240\u6709\u8005" }, - amount: { label: "\u91D1\u984D" }, - expected_revenue: { label: "\u671F\u5F85\u53CE\u76CA" }, - stage: { - label: "\u30B9\u30C6\u30FC\u30B8", - options: { ...opportunityStageOptions } - }, - probability: { label: "\u78BA\u5EA6 (%)" }, - close_date: { label: "\u5B8C\u4E86\u4E88\u5B9A\u65E5" }, - type: { - label: "\u30BF\u30A4\u30D7", - options: { - new_business: "\u65B0\u898F\u30D3\u30B8\u30CD\u30B9", - existing_upgrade: "\u65E2\u5B58\u9867\u5BA2 - \u30A2\u30C3\u30D7\u30B0\u30EC\u30FC\u30C9", - existing_renewal: "\u65E2\u5B58\u9867\u5BA2 - \u66F4\u65B0", - existing_expansion: "\u65E2\u5B58\u9867\u5BA2 - \u62E1\u5927" - } - }, - forecast_category: { - label: "\u58F2\u4E0A\u4E88\u6E2C\u30AB\u30C6\u30B4\u30EA", - options: { - pipeline: "\u30D1\u30A4\u30D7\u30E9\u30A4\u30F3", - best_case: "\u30D9\u30B9\u30C8\u30B1\u30FC\u30B9", - commit: "\u30B3\u30DF\u30C3\u30C8", - omitted: "\u9664\u5916", - closed: "\u5B8C\u4E86" - } - }, - description: { label: "\u8AAC\u660E" }, - next_step: { label: "\u6B21\u306E\u30B9\u30C6\u30C3\u30D7" }, - lead_source: { label: "\u30EA\u30FC\u30C9\u30BD\u30FC\u30B9", options: { ...leadSourceOptions } }, - crm_campaign: { label: "\u30AD\u30E3\u30F3\u30DA\u30FC\u30F3", help: "\u3053\u306E\u5546\u8AC7\u3092\u751F\u307F\u51FA\u3057\u305F\u30DE\u30FC\u30B1\u30C6\u30A3\u30F3\u30B0\u30AD\u30E3\u30F3\u30DA\u30FC\u30F3" }, - days_in_stage: { label: "\u73FE\u30B9\u30C6\u30FC\u30B8\u6EDE\u5728\u65E5\u6570" }, - stage_entry_date: { label: "\u30B9\u30C6\u30FC\u30B8\u958B\u59CB\u65E5", help: "\u3053\u306E\u5546\u8AC7\u304C\u73FE\u5728\u306E\u30B9\u30C6\u30FC\u30B8\u306B\u5165\u3063\u305F\u65E5\u3002" }, - is_private: { label: "\u975E\u516C\u958B" }, - approval_status: { - label: "\u627F\u8A8D\u30B9\u30C6\u30FC\u30BF\u30B9", - options: { not_required: "\u627F\u8A8D\u4E0D\u8981", pending: "\u627F\u8A8D\u5F85\u3061", approved: "\u627F\u8A8D\u6E08\u307F", rejected: "\u5374\u4E0B" } - }, - approved_date: { label: "\u627F\u8A8D\u65E5" }, - // #593 — 商談クローズ時に必須。失注理由は営業ダッシュボードの - // 内訳ウィジェットにも出るため、保存値がそのまま画面に出てはいけない。 - win_reason: { - label: "\u53D7\u6CE8\u7406\u7531", - help: "\u53D7\u6CE8\u306B\u81F3\u3063\u305F\u7406\u7531\u3002\u5546\u8AC7\u3092\u300C\u6210\u7ACB\u300D\u3067\u30AF\u30ED\u30FC\u30BA\u3059\u308B\u969B\u306B\u5FC5\u9808\u3067\u3059\u3002", - options: { - better_product: "\u88FD\u54C1\u304C\u512A\u308C\u3066\u3044\u308B", - better_price: "\u4FA1\u683C\u304C\u512A\u308C\u3066\u3044\u308B", - relationship: "\u65E2\u5B58\u306E\u95A2\u4FC2", - better_support: "\u30B5\u30DD\u30FC\u30C8\u304C\u512A\u308C\u3066\u3044\u308B", - best_fit: "\u6700\u9069\u306A\u6A5F\u80FD\u30FB\u9069\u5408\u6027", - quote_accepted: "\u898B\u7A4D\u627F\u8A8D", - other: "\u305D\u306E\u4ED6" - } - }, - loss_reason: { - label: "\u5931\u6CE8\u7406\u7531", - help: "\u5931\u6CE8\u3057\u305F\u7406\u7531\u3002\u5546\u8AC7\u3092\u300C\u4E0D\u6210\u7ACB\u300D\u3067\u30AF\u30ED\u30FC\u30BA\u3059\u308B\u969B\u306B\u5FC5\u9808\u3067\u3059\u3002", - options: { - price: "\u4FA1\u683C\u304C\u9AD8\u3059\u304E\u308B", - competitor: "\u7AF6\u5408\u4ED6\u793E\u306B\u6557\u5317", - no_budget: "\u4E88\u7B97\u306A\u3057", - no_decision: "\u610F\u601D\u6C7A\u5B9A\u306A\u3057", - timing: "\u30BF\u30A4\u30DF\u30F3\u30B0\u4E0D\u9069", - features: "\u6A5F\u80FD\u4E0D\u8DB3", - other: "\u305D\u306E\u4ED6" - } - }, - loss_details: { label: "\u53D7\u6CE8\u30FB\u5931\u6CE8\u306E\u8A73\u7D30", help: "\u53D7\u6CE8\u30FB\u5931\u6CE8\u7406\u7531\u306E\u88DC\u8DB3\u8AAC\u660E\uFF08\u81EA\u7531\u8A18\u8FF0\uFF09\u3002" }, - // REQ-0006 — 適格判定、顧客側の調達スケジュール、商談の経緯、事業区分、ステータス変更承認。 - will_bid: { label: "\u5165\u672D\u4E88\u5B9A", help: "\u5165\u672D\u3059\u308B\u610F\u5411\u304C\u3042\u308B\u304B\u3069\u3046\u304B\u3002\u672A\u8A2D\u5B9A\u306F\u5224\u65AD\u304C\u4FDD\u7559\u4E2D\u3067\u3042\u308B\u3053\u3068\u3092\u793A\u3057\u307E\u3059\u3002" }, - controllability: { label: "\u30B3\u30F3\u30C8\u30ED\u30FC\u30EB\u5EA6", options: { high: "\u9AD8", medium: "\u4E2D", low: "\u4F4E" } }, - priority: { label: "\u512A\u5148\u5EA6", options: { high: "\u9AD8", medium: "\u4E2D", low: "\u4F4E" } }, - deal_level: { label: "\u5546\u8AC7\u30E9\u30F3\u30AF", options: { strategic: "\u6226\u7565", key: "\u91CD\u70B9", standard: "\u6A19\u6E96" } }, - is_subcontracted: { label: "\u5916\u6CE8\u3042\u308A" }, - subcontracting_note: { label: "\u5916\u6CE8\u30E1\u30E2" }, - customer_initiation_date: { label: "\u9867\u5BA2\u306E\u6848\u4EF6\u5316\u65E5" }, - expected_tender_date: { label: "\u5165\u672D\u4E88\u5B9A\u65E5" }, - expected_signing_date: { label: "\u5951\u7D04\u7DE0\u7D50\u4E88\u5B9A\u65E5" }, - expected_tender_amount: { label: "\u5165\u672D\u4E88\u5B9A\u91D1\u984D" }, - expected_signing_amount: { label: "\u5951\u7D04\u4E88\u5B9A\u91D1\u984D" }, - business_line: { - label: "\u4E8B\u696D\u533A\u5206", - options: { - product: "\u88FD\u54C1", - services: "\u30D7\u30ED\u30D5\u30A7\u30C3\u30B7\u30E7\u30CA\u30EB\u30B5\u30FC\u30D3\u30B9", - consulting: "\u30B3\u30F3\u30B5\u30EB\u30C6\u30A3\u30F3\u30B0", - support: "\u4FDD\u5B88\u30FB\u30B5\u30DD\u30FC\u30C8", - other: "\u305D\u306E\u4ED6" - } - }, - customer_background: { label: "\u9867\u5BA2\u6982\u8981" }, - project_background: { label: "\u30D7\u30ED\u30B8\u30A7\u30AF\u30C8\u80CC\u666F" }, - risk_analysis: { label: "\u30EA\u30B9\u30AF\u5206\u6790" }, - payment_terms: { label: "\u652F\u6255\u6761\u4EF6" }, - requested_status: { label: "\u7533\u8ACB\u30B9\u30C6\u30FC\u30BF\u30B9", options: { closed_won: "\u53D7\u6CE8", closed_lost: "\u5931\u6CE8" } }, - status_change_approval_status: { - label: "\u30B9\u30C6\u30FC\u30BF\u30B9\u5909\u66F4\u627F\u8A8D", - options: { not_required: "\u627F\u8A8D\u4E0D\u8981", pending: "\u627F\u8A8D\u5F85\u3061", approved: "\u627F\u8A8D\u6E08\u307F", rejected: "\u5374\u4E0B" } - }, - // REQ-0006 ステップ 11 — 案件化（立项）承認。 - qualification_requested: { - label: "\u6848\u4EF6\u5316\u627F\u8A8D\u3092\u7533\u8ACB", - help: "\u30C1\u30A7\u30C3\u30AF\u3059\u308B\u3068\u3053\u306E\u5546\u8AC7\u3092\u6848\u4EF6\u5316\u627F\u8A8D\u306B\u56DE\u3057\u307E\u3059\u3002\u5374\u4E0B\u3055\u308C\u308B\u3068\u30C1\u30A7\u30C3\u30AF\u304C\u5916\u308C\u307E\u3059\u3002\u518D\u5EA6\u30C1\u30A7\u30C3\u30AF\u3059\u308B\u3068\u6539\u3081\u3066\u7533\u8ACB\u3067\u304D\u307E\u3059\u3002" - }, - qualification_approval_status: { - label: "\u6848\u4EF6\u5316\u627F\u8A8D", - options: { not_required: "\u627F\u8A8D\u4E0D\u8981", pending: "\u627F\u8A8D\u5F85\u3061", approved: "\u627F\u8A8D\u6E08\u307F", rejected: "\u5374\u4E0B" } - } - }, - _views: { - tender_this_quarter: { - label: "\u4ECA\u56DB\u534A\u671F\u306B\u5165\u672D\u4E88\u5B9A", - emptyState: { - title: "\u4ECA\u56DB\u534A\u671F\u306B\u5165\u672D\u4E88\u5B9A\u306E\u5546\u8AC7\u306F\u3042\u308A\u307E\u305B\u3093", - message: "\u3053\u306E\u30BF\u30D6\u306B\u306F\u3001\u9867\u5BA2\u5074\u306E\u5165\u672D\u4E88\u5B9A\u65E5\u304C\u4ECA\u56DB\u534A\u671F\u5185\u306B\u3042\u308B\u30AA\u30FC\u30D7\u30F3\u5546\u8AC7\u304C\u8868\u793A\u3055\u308C\u307E\u3059\u3002\u5546\u8AC7\u306B\u300C\u5165\u672D\u4E88\u5B9A\u65E5\u300D\u3092\u5165\u529B\u3059\u308B\u3068\u3001\u3053\u3053\u306B\u8868\u793A\u3055\u308C\u307E\u3059\u3002" - } - }, - open_opportunities: { label: "\u9032\u884C\u4E2D\u306E\u5546\u8AC7" }, - all_opportunities: { label: "\u5168\u5546\u8AC7" }, - pipeline_kanban: { label: "\u30BB\u30FC\u30EB\u30B9\u30D1\u30A4\u30D7\u30E9\u30A4\u30F3" }, - close_date_calendar: { label: "\u4E88\u6E2C\u30AB\u30EC\u30F3\u30C0\u30FC" }, - deal_timeline: { label: "\u5546\u8AC7\u30BF\u30A4\u30E0\u30E9\u30A4\u30F3" }, - deal_gallery: { label: "\u5546\u8AC7\u30AB\u30FC\u30C9" }, - my_open_deals: { label: "\u79C1\u306E\u30AA\u30FC\u30D7\u30F3\u5546\u8AC7" }, - stale_opportunities: { label: "\u26A0\uFE0F \u505C\u6EDE\u5546\u8AC7 \xB7 \u30B9\u30C6\u30FC\u30B8\u6EDE\u5728\u304C\u9577\u3044\u9806" }, - closing_this_quarter: { - label: "\u4ECA\u56DB\u534A\u671F\u306B\u30AF\u30ED\u30FC\u30BA\u4E88\u5B9A", - emptyState: { - title: "\u4ECA\u56DB\u534A\u671F\u306B\u30AF\u30ED\u30FC\u30BA\u4E88\u5B9A\u306E\u5546\u8AC7\u306F\u3042\u308A\u307E\u305B\u3093", - message: "\u3053\u306E\u30BF\u30D6\u306B\u306F\u3001\u5B8C\u4E86\u4E88\u5B9A\u65E5\u304C\u4ECA\u56DB\u534A\u671F\u5185\u306B\u3042\u308B\u30B3\u30DF\u30C3\u30C8\uFF0F\u30D9\u30B9\u30C8\u30B1\u30FC\u30B9\u306E\u30AA\u30FC\u30D7\u30F3\u5546\u8AC7\u304C\u8868\u793A\u3055\u308C\u307E\u3059\u3002\u73FE\u5728\u8A72\u5F53\u3059\u308B\u5546\u8AC7\u306F\u3042\u308A\u307E\u305B\u3093\u3002\u305D\u308C\u4EE5\u964D\u306B\u30AF\u30ED\u30FC\u30BA\u3059\u308B\u5546\u8AC7\u306F\u300C\u30AA\u30FC\u30D7\u30F3\u5546\u8AC7\u300D\u30BF\u30D6\u306B\u3042\u308A\u307E\u3059\u3002" - } - } - }, - _sections: { - // オブジェクト定義のセクションキー（opportunity.object.ts）— 入力フォームと、 - // これらのグループを参照する詳細ページのセクション（#1452）で使用 - crm_forecast: { label: "\u30B9\u30C6\u30FC\u30B8\u30FB\u58F2\u4E0A\u4E88\u6E2C" }, - basic: { label: "\u57FA\u672C\u60C5\u5831" }, - financials: { label: "\u8CA1\u52D9\u60C5\u5831" }, - sales_process: { label: "\u55B6\u696D\u30D7\u30ED\u30BB\u30B9" }, - classification: { label: "\u5206\u985E" }, - campaign: { label: "\u30AD\u30E3\u30F3\u30DA\u30FC\u30F3" }, - notes: { label: "\u30E1\u30E2\u30FB\u6B21\u306E\u30B9\u30C6\u30C3\u30D7" }, - qualification: { label: "\u9069\u683C\u5224\u5B9A" }, - narrative: { label: "\u5546\u8AC7\u306E\u7D4C\u7DEF" }, - // opportunity.view.ts のフォームセクション名 (#1100) - overview: { label: "\u6982\u8981" }, - forecast: { label: "\u4E88\u6E2C" }, - sales_strategy: { label: "\u55B6\u696D\u6226\u7565" }, - win_loss: { label: "\u53D7\u6CE8\uFF0F\u5931\u6CE8" } - }, - _actions: { - ...activityActions3, - clone_opportunity: { - label: "\u5546\u8AC7\u3092\u8907\u88FD", - successMessage: "\u5546\u8AC7\u3092\u8907\u88FD\u3057\u307E\u3057\u305F\uFF01" - }, - mass_update_stage: { - label: "\u30B9\u30C6\u30FC\u30B8\u66F4\u65B0", - successMessage: "\u5546\u8AC7\u30B9\u30C6\u30FC\u30B8\u3092\u66F4\u65B0\u3057\u307E\u3057\u305F\uFF01", - params: { - stage: { - label: "\u65B0\u3057\u3044\u30B9\u30C6\u30FC\u30B8", - options: { ...opportunityStageOptions } - } - } - }, - generate_quote: { - label: "\u898B\u7A4D\u3092\u4F5C\u6210", - successMessage: "\u5546\u8AC7\u304B\u3089\u898B\u7A4D\u3092\u4F5C\u6210\u3057\u307E\u3057\u305F\uFF01" - } - } - }, - crm_opportunity_line_item: { - _validations: { - unit_price_positive: { - message: "\u8CA9\u58F2\u4FA1\u683C\u3092\u8CA0\u306E\u5024\u306B\u3059\u308B\u3053\u3068\u306F\u3067\u304D\u307E\u305B\u3093" - } - }, - label: "\u5546\u8AC7\u5546\u54C1\u660E\u7D30", - pluralLabel: "\u5546\u8AC7\u5546\u54C1\u660E\u7D30", - description: "\u5546\u8AC7\u914D\u4E0B\u306E\u88FD\u54C1\u5225\u4FA1\u683C\u660E\u7D30\u884C", - fields: { - crm_opportunity: { label: "\u5546\u8AC7" }, - crm_product: { label: "\u88FD\u54C1" }, - description: { label: "\u8AAC\u660E" }, - quantity: { label: "\u6570\u91CF" }, - list_price: { label: "\u5B9A\u4FA1", help: "\u88FD\u54C1\u306E\u30AB\u30BF\u30ED\u30B0\u4FA1\u683C\u304B\u3089\u81EA\u52D5\u5165\u529B\u3055\u308C\u307E\u3059" }, - unit_price: { label: "\u8CA9\u58F2\u4FA1\u683C", help: "\u4EA4\u6E09\u5F8C\u306E\u5358\u4FA1\uFF08\u5B9A\u4FA1\u3068\u7570\u306A\u308B\u5834\u5408\u304C\u3042\u308A\u307E\u3059\uFF09" }, - discount: { label: "\u5272\u5F15\u7387\uFF08%\uFF09" }, - total_price: { label: "\u5408\u8A08" }, - line_number: { label: "\u884C\u756A\u53F7" } - }, - _sections: { - basic: { label: "\u660E\u7D30\u884C" }, - pricing: { label: "\u4FA1\u683C" } - } - }, - crm_forecast: { - _validations: { - period_end_after_start: { - message: "\u671F\u9593\u7D42\u4E86\u306F\u671F\u9593\u958B\u59CB\u3088\u308A\u5F8C\u3067\u3042\u308B\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059\u3002" - }, - period_end_matches_calendar_period: { - message: "\u671F\u9593\u7D42\u4E86\u306F\u305D\u306E\u671F\u9593\u306E\u6700\u7D42\u65E5\u3067\u3042\u308B\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059\u3002\u4F8B\uFF1A2026-07-01 \u958B\u59CB\u306E\u56DB\u534A\u671F\u306A\u3089 2026-09-30\u30012026 \u5E74 8 \u6708\u306A\u3089 2026-08-31\u3002" - }, - period_start_first_of_period: { - message: "\u671F\u9593\u958B\u59CB\u306F\u305D\u306E\u671F\u9593\u306E\u521D\u65E5\u3067\u3042\u308B\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059\u3002\u4F8B\uFF1A2026 \u5E74 8 \u6708\u306A\u3089 2026-08-01\u3002" - }, - quarter_starts_on_quarter_boundary: { - message: "\u56DB\u534A\u671F\u30D5\u30A9\u30FC\u30AD\u30E3\u30B9\u30C8\u306F\u56DB\u534A\u671F\u306E\u5883\u754C\uFF081 \u6708 1 \u65E5\u30014 \u6708 1 \u65E5\u30017 \u6708 1 \u65E5\u300110 \u6708 1 \u65E5\uFF09\u304B\u3089\u958B\u59CB\u3059\u308B\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059\u3002" - }, - snapshot_amounts_non_negative: { - message: "\u30B9\u30CA\u30C3\u30D7\u30B7\u30E7\u30C3\u30C8\u91D1\u984D\u306F\u8CA0\u306E\u5024\u306B\u3067\u304D\u307E\u305B\u3093\u3002" - } - }, - label: "\u30D5\u30A9\u30FC\u30AD\u30E3\u30B9\u30C8", - pluralLabel: "\u30D5\u30A9\u30FC\u30AD\u30E3\u30B9\u30C8", - description: "\u62C5\u5F53\u8005\u3054\u3068\u306E\u5B9A\u671F\u30D1\u30A4\u30D7\u30E9\u30A4\u30F3\u30B9\u30CA\u30C3\u30D7\u30B7\u30E7\u30C3\u30C8\u3067\u53CE\u76CA\u4E88\u6E2C\u306B\u4F7F\u7528", - fields: { - owner_id: { label: "\u62C5\u5F53\u8005" }, - period: { label: "\u671F\u9593", options: { month: "\u6708\u6B21", quarter: "\u56DB\u534A\u671F" } }, - period_start: { - label: "\u671F\u9593\u958B\u59CB", - help: "\u671F\u9593\u306E\u521D\u65E5\u3067\u3042\u308B\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059 \u2014 \u4F8B: 2026 \u5E74 8 \u6708\u306A\u3089 2026-08-01\u3002\u56DB\u534A\u671F\u306E\u30D5\u30A9\u30FC\u30AD\u30E3\u30B9\u30C8\u306F\u3055\u3089\u306B\u56DB\u534A\u671F\u306E\u5883\u754C\uFF081 \u6708 1 \u65E5\u30FB4 \u6708 1 \u65E5\u30FB7 \u6708 1 \u65E5\u30FB10 \u6708 1 \u65E5\uFF09\u3067\u958B\u59CB\u3059\u308B\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059\u3002" - }, - period_end: { - label: "\u671F\u9593\u7D42\u4E86", - help: "\u901A\u5E38\u306F\u300C\u671F\u9593\u300D\u3068\u300C\u671F\u9593\u958B\u59CB\u300D\u304B\u3089\u81EA\u52D5\u7684\u306B\u7B97\u51FA\u3055\u308C\u307E\u3059\u3002\u624B\u52D5\u3067\u5165\u529B\u3059\u308B\u5834\u5408\u306F\u3001\u305D\u306E\u671F\u9593\u306E\u6700\u7D42\u65E5\u3067\u3042\u308B\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059 \u2014 \u4F8B: 2026-07-01 \u958B\u59CB\u306E\u56DB\u534A\u671F\u306A\u3089 2026-09-30\u30012026 \u5E74 8 \u6708\u306A\u3089 2026-08-31\u3002" - }, - period_label: { - label: "\u671F\u9593", - help: "\u300C2026 \u5E74\u7B2C 3 \u56DB\u534A\u671F\u300D\u300C2026 \u5E74 8 \u6708\u300D\u306E\u3088\u3046\u306A\u8AAD\u307F\u3084\u3059\u3044\u671F\u9593\u30E9\u30D9\u30EB\u3002" - }, - display_title: { label: "\u8868\u793A\u540D" }, - snapshot_date: { label: "\u30B9\u30CA\u30C3\u30D7\u30B7\u30E7\u30C3\u30C8\u65E5", help: "\u3053\u306E\u30B9\u30CA\u30C3\u30D7\u30B7\u30E7\u30C3\u30C8\u3092\u53D6\u5F97\u3057\u305F\u65E5\u3002" }, - source: { - label: "\u30BD\u30FC\u30B9", - options: { scheduled: "\u5B9A\u671F\u30B9\u30CA\u30C3\u30D7\u30B7\u30E7\u30C3\u30C8", ai: "AI \u30B9\u30AD\u30EB", manual: "\u624B\u52D5\u5165\u529B" } - }, - quota: { label: "\u30AF\u30A9\u30FC\u30BF" }, - pipeline_amount: { - label: "\u30D1\u30A4\u30D7\u30E9\u30A4\u30F3", - help: "\u3053\u306E\u671F\u9593\u306B\u30AF\u30ED\u30FC\u30BA\u4E88\u5B9A\u306E\u30AA\u30FC\u30D7\u30F3\u5546\u8AC7\u306E\u5408\u8A08\u91D1\u984D\uFF08\u30B9\u30C6\u30FC\u30B8\u3092\u554F\u308F\u306A\u3044\uFF09\u3002" - }, - best_case_amount: { - label: "\u30D9\u30B9\u30C8\u30B1\u30FC\u30B9", - help: "\u58F2\u4E0A\u4E88\u6E2C\u30AB\u30C6\u30B4\u30EA\u304C\u300C\u30D9\u30B9\u30C8\u30B1\u30FC\u30B9\u300D\u307E\u305F\u306F\u300C\u30B3\u30DF\u30C3\u30C8\u300D\u306E\u30AA\u30FC\u30D7\u30F3\u5546\u8AC7\u3002" - }, - commit_amount: { - label: "\u30B3\u30DF\u30C3\u30C8", - help: "\u58F2\u4E0A\u4E88\u6E2C\u30AB\u30C6\u30B4\u30EA\u304C\u300C\u30B3\u30DF\u30C3\u30C8\u300D\u306E\u30AA\u30FC\u30D7\u30F3\u5546\u8AC7\uFF08\u62C5\u5F53\u8005\u304C\u30B3\u30DF\u30C3\u30C8\u6E08\u307F\uFF09\u3002" - }, - closed_amount: { label: "\u30AF\u30ED\u30FC\u30BA", help: "\u3053\u306E\u671F\u9593\u306B\u3059\u3067\u306B\u6210\u7ACB\u3057\u305F\u91D1\u984D\u3002" }, - expected_amount: { - label: "\u4E88\u60F3", - help: "\u30AF\u30ED\u30FC\u30BA + \u30B3\u30DF\u30C3\u30C8 \u2014 \u62C5\u5F53\u8005\u304C\u7121\u7406\u306A\u304F\u7740\u5730\u3092\u898B\u8FBC\u3081\u308B\u91D1\u984D\u3002" - }, - attainment_pct: { - label: "\u9054\u6210\u7387 %", - help: "\u30AF\u30ED\u30FC\u30BA \xF7 \u30AF\u30A9\u30FC\u30BF \xD7 100\u3002\u30AF\u30A9\u30FC\u30BF\u304C\u6B63\u306E\u5024\u306B\u306A\u308B\u307E\u3067\u306F 0% \u3068\u8868\u793A\u3055\u308C\u307E\u3059\u3002" - }, - coverage_ratio: { - label: "\u30AB\u30D0\u30EC\u30C3\u30B8", - help: "\u30D1\u30A4\u30D7\u30E9\u30A4\u30F3 \xF7\uFF08\u30AF\u30A9\u30FC\u30BF \u2212 \u30AF\u30ED\u30FC\u30BA\uFF09\u2014 \u6B8B\u308A\u306E\u5DEE\u5206\u3092\u57CB\u3081\u308B\u30D1\u30A4\u30D7\u30E9\u30A4\u30F3\u304C\u5341\u5206\u304B\u3069\u3046\u304B\u3002\u30AF\u30A9\u30FC\u30BF\u9054\u6210\u6E08\u307F\u306E\u5834\u5408\u306F 0 \u3068\u8868\u793A\u3055\u308C\u307E\u3059\u3002" - }, - notes: { label: "\u30E1\u30E2" }, - seed_key: { - label: "\u30B7\u30FC\u30C9\u30AD\u30FC", - help: "\u30C7\u30E2\u30C7\u30FC\u30BF\u306E\u8B58\u5225\u5B50\u3002\u30B7\u30FC\u30C9\u30ED\u30FC\u30C0\u30FC\u3060\u3051\u304C\u66F8\u304D\u8FBC\u307F\u3001\u5B9F\u969B\u306E\u30B9\u30CA\u30C3\u30D7\u30B7\u30E7\u30C3\u30C8\u3067\u306F\u5E38\u306B\u7A7A\u3067\u3059\u3002" - } - }, - _views: { - all_forecasts: { label: "\u3059\u3079\u3066\u306E\u30D5\u30A9\u30FC\u30AD\u30E3\u30B9\u30C8" }, - this_quarter_forecasts: { - label: "\u4ECA\u56DB\u534A\u671F", - emptyState: { - title: "\u4ECA\u56DB\u534A\u671F\u306E\u30B9\u30CA\u30C3\u30D7\u30B7\u30E7\u30C3\u30C8\u306F\u307E\u3060\u3042\u308A\u307E\u305B\u3093", - message: "\u56DB\u534A\u671F\u30B9\u30CA\u30C3\u30D7\u30B7\u30E7\u30C3\u30C8\u306F\u591C\u9593\u306E\u30D5\u30A9\u30FC\u30AD\u30E3\u30B9\u30C8\u96C6\u8A08\u304C\u66F8\u304D\u8FBC\u307F\u307E\u3059\u3002\u4ECA\u56DB\u534A\u671F\u5206\u304C\u4E00\u5EA6\u5B9F\u884C\u3055\u308C\u308B\u307E\u3067\u3053\u306E\u30D3\u30E5\u30FC\u306F\u7A7A\u3067\u3059\u3002\u78BA\u5B9A\u6E08\u307F\u306E\u56DB\u534A\u671F\u306F\u300C\u3059\u3079\u3066\u300D\u30BF\u30D6\u306B\u3042\u308A\u307E\u3059\u3002" - } - }, - my_forecast: { label: "\u81EA\u5206\u306E\u30D5\u30A9\u30FC\u30AD\u30E3\u30B9\u30C8" } - }, - _sections: { - basic: { label: "\u30B9\u30CA\u30C3\u30D7\u30B7\u30E7\u30C3\u30C8" }, - amounts: { label: "\u91D1\u984D" }, - meta: { label: "\u30BD\u30FC\u30B9" }, - // forecast.view.ts のフォームセクション名 (#1100) - snapshot: { label: "\u30B9\u30CA\u30C3\u30D7\u30B7\u30E7\u30C3\u30C8" }, - notes: { label: "\u30E1\u30E2" } - } - } -}; - -// src/sales/translations/ja-JP/objects.commerce.ts -var paymentTermsOptions = { - net_15: "15 \u65E5\u4EE5\u5185\u6255\u3044", - net_30: "30 \u65E5\u4EE5\u5185\u6255\u3044", - net_60: "60 \u65E5\u4EE5\u5185\u6255\u3044", - net_90: "90 \u65E5\u4EE5\u5185\u6255\u3044", - due_on_receipt: "\u8ACB\u6C42\u66F8\u53D7\u9818\u6642\u6255\u3044" -}; -var commerce3 = { - crm_quote: { - _validations: { - discount_within_ceiling: { - message: "\u5272\u5F15\u7387\u306F 60% \u3092\u8D85\u3048\u3089\u308C\u307E\u305B\u3093" - }, - expiration_after_quote: { - message: "\u6709\u52B9\u671F\u9650\u306F\u898B\u7A4D\u65E5\u3088\u308A\u5F8C\u3067\u3042\u308B\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059" - }, - quote_status_progression: { - message: "\u7121\u52B9\u306A\u898B\u7A4D\u30B9\u30C6\u30FC\u30BF\u30B9\u9077\u79FB\u3067\u3059" - } - }, - label: "\u898B\u7A4D", - pluralLabel: "\u898B\u7A4D", - description: "\u9867\u5BA2\u306B\u63D0\u793A\u3059\u308B\u4FA1\u683C\u898B\u7A4D", - fields: { - quote_number: { label: "\u898B\u7A4D\u756A\u53F7" }, - name: { label: "\u898B\u7A4D\u540D" }, - display_title: { label: "\u8868\u793A\u540D" }, - crm_account: { label: "\u53D6\u5F15\u5148" }, - crm_contact: { - label: "\u53D6\u5F15\u5148\u8CAC\u4EFB\u8005", - help: "\u898B\u7A4D\u304C\u300C\u63D0\u793A\u6E08\u307F\u300D\u307E\u305F\u306F\u300C\u627F\u8A8D\u6E08\u307F\u300D\u306B\u306A\u3063\u305F\u6642\u70B9\u3067\u5FC5\u9808\u3067\u3059\u3002\u4F5C\u6210\u3055\u308C\u308B\u5951\u7D04\u306E\u4E3B\u62C5\u5F53\u8005\u306F\u3053\u3053\u304B\u3089\u5F15\u304D\u7D99\u304C\u308C\u307E\u3059\u3002" - }, - crm_opportunity: { label: "\u5546\u8AC7" }, - owner_id: { label: "\u898B\u7A4D\u62C5\u5F53\u8005" }, - status: { - label: "\u30B9\u30C6\u30FC\u30BF\u30B9", - options: { - draft: "\u4E0B\u66F8\u304D", - in_review: "\u30EC\u30D3\u30E5\u30FC\u4E2D", - presented: "\u63D0\u793A\u6E08\u307F", - accepted: "\u627F\u8A8D\u6E08\u307F", - rejected: "\u5374\u4E0B", - expired: "\u671F\u9650\u5207\u308C" - } - }, - quote_date: { label: "\u898B\u7A4D\u65E5" }, - expiration_date: { label: "\u6709\u52B9\u671F\u9650" }, - subtotal: { label: "\u5C0F\u8A08" }, - discount: { label: "\u5272\u5F15\u7387(%)" }, - discount_amount: { label: "\u5272\u5F15\u984D" }, - tax: { label: "\u7A0E\u984D" }, - shipping_handling: { label: "\u914D\u9001\u30FB\u624B\u6570\u6599" }, - total_price: { label: "\u5408\u8A08\u91D1\u984D" }, - payment_terms: { label: "\u652F\u6255\u6761\u4EF6", options: { ...paymentTermsOptions } }, - shipping_terms: { label: "\u914D\u9001\u6761\u4EF6" }, - billing_address: { label: "\u8ACB\u6C42\u5148\u4F4F\u6240" }, - shipping_address: { label: "\u914D\u9001\u5148\u4F4F\u6240" }, - description: { label: "\u8AAC\u660E" }, - internal_notes: { label: "\u5185\u90E8\u30E1\u30E2" } - }, - _views: { - all_quotes: { label: "\u5168\u898B\u7A4D" }, - quote_pipeline: { label: "\u898B\u7A4D\u30D1\u30A4\u30D7\u30E9\u30A4\u30F3" }, - quote_calendar: { label: "\u898B\u7A4D\u30AB\u30EC\u30F3\u30C0\u30FC" } - }, - _sections: { - basic: { label: "\u898B\u7A4D\u60C5\u5831" }, - pricing: { label: "\u4FA1\u683C" }, - terms: { label: "\u6761\u4EF6\u30FB\u6709\u52B9\u671F\u9650" }, - address: { label: "\u4F4F\u6240" }, - system: { label: "\u30B7\u30B9\u30C6\u30E0" }, - // quote.view.ts のフォームセクション名 (#1100) - quote: { label: "\u898B\u7A4D\u66F8" }, - totals: { label: "\u5408\u8A08" }, - quote_terms: { label: "\u5951\u7D04\u6761\u4EF6" }, - addresses_and_notes: { label: "\u4F4F\u6240\u3068\u5099\u8003" } - } - }, - crm_quote_line_item: { - _validations: { - discount_within_ceiling: { - message: "\u660E\u7D30\u306E\u5272\u5F15\u7387\u306F 60% \u3092\u8D85\u3048\u3089\u308C\u307E\u305B\u3093" - }, - unit_price_positive: { - message: "\u8CA9\u58F2\u4FA1\u683C\u3092\u8CA0\u306E\u5024\u306B\u3059\u308B\u3053\u3068\u306F\u3067\u304D\u307E\u305B\u3093" - } - }, - label: "\u898B\u7A4D\u660E\u7D30", - pluralLabel: "\u898B\u7A4D\u660E\u7D30", - description: "\u898B\u7A4D\u914D\u4E0B\u306E\u88FD\u54C1\u5225\u4FA1\u683C\u660E\u7D30\u884C", - fields: { - crm_quote: { label: "\u898B\u7A4D" }, - crm_product: { label: "\u88FD\u54C1" }, - description: { label: "\u8AAC\u660E" }, - quantity: { label: "\u6570\u91CF" }, - list_price: { label: "\u5B9A\u4FA1" }, - unit_price: { label: "\u8CA9\u58F2\u4FA1\u683C" }, - discount: { label: "\u5272\u5F15\u7387\uFF08%\uFF09" }, - subtotal: { label: "\u5C0F\u8A08" }, - total_price: { label: "\u5408\u8A08" }, - line_number: { label: "\u884C\u756A\u53F7" } - }, - _sections: { - basic: { label: "\u660E\u7D30\u884C" }, - pricing: { label: "\u4FA1\u683C" } - } - }, - crm_contract: { - _validations: { - end_after_start: { - message: "\u7D42\u4E86\u65E5\u306F\u958B\u59CB\u65E5\u3088\u308A\u5F8C\u3067\u3042\u308B\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059" - }, - contract_status_progression: { - message: "\u7121\u52B9\u306A\u5951\u7D04\u30B9\u30C6\u30FC\u30BF\u30B9\u9077\u79FB\u3067\u3059" - } - }, - label: "\u5951\u7D04", - pluralLabel: "\u5951\u7D04", - description: "\u9867\u5BA2\u3068\u7DE0\u7D50\u3057\u305F\u6CD5\u7684\u306A\u5951\u7D04\u30FB\u5408\u610F", - fields: { - contract_number: { label: "\u5951\u7D04\u756A\u53F7" }, - crm_account: { label: "\u53D6\u5F15\u5148" }, - crm_contact: { label: "\u4E3B\u62C5\u5F53\u8005" }, - crm_opportunity: { label: "\u95A2\u9023\u5546\u8AC7" }, - owner_id: { label: "\u5951\u7D04\u62C5\u5F53\u8005" }, - status: { - label: "\u30B9\u30C6\u30FC\u30BF\u30B9", - options: { - draft: "\u4E0B\u66F8\u304D", - in_approval: "\u627F\u8A8D\u4E2D", - activated: "\u6709\u52B9", - expired: "\u671F\u9650\u5207\u308C", - terminated: "\u89E3\u7D04" - } - }, - contract_term_months: { label: "\u5951\u7D04\u671F\u9593\uFF08\u6708\uFF09" }, - start_date: { label: "\u958B\u59CB\u65E5" }, - end_date: { label: "\u7D42\u4E86\u65E5" }, - contract_value: { label: "\u5951\u7D04\u91D1\u984D" }, - billing_frequency: { - label: "\u8ACB\u6C42\u983B\u5EA6", - options: { monthly: "\u6708\u6B21", quarterly: "\u56DB\u534A\u671F", annually: "\u5E74\u6B21", one_time: "\u4E00\u62EC" } - }, - payment_terms: { label: "\u652F\u6255\u6761\u4EF6", options: { ...paymentTermsOptions } }, - auto_renewal: { label: "\u81EA\u52D5\u66F4\u65B0" }, - renewal_notice_days: { label: "\u66F4\u65B0\u901A\u77E5\uFF08\u65E5\uFF09" }, - contract_type: { - label: "\u5951\u7D04\u7A2E\u5225", - options: { - subscription: "\u30B5\u30D6\u30B9\u30AF\u30EA\u30D7\u30B7\u30E7\u30F3\u5951\u7D04", - service: "\u30B5\u30FC\u30D3\u30B9\u5951\u7D04", - license: "\u30E9\u30A4\u30BB\u30F3\u30B9\u5951\u7D04", - partnership: "\u30D1\u30FC\u30C8\u30CA\u30FC\u30B7\u30C3\u30D7\u5951\u7D04", - nda: "\u79D8\u5BC6\u4FDD\u6301\u5951\u7D04 (NDA)", - msa: "\u57FA\u672C\u5951\u7D04 (MSA)" - } - }, - signed_date: { label: "\u7F72\u540D\u65E5" }, - signed_by: { label: "\u7F72\u540D\u8005" }, - document_url: { label: "\u5951\u7D04\u66F8\u985E" }, - special_terms: { label: "\u7279\u7D04\u4E8B\u9805" }, - description: { label: "\u8AAC\u660E" }, - billing_address: { label: "\u8ACB\u6C42\u5148\u4F4F\u6240" } - }, - _views: { - all_contracts: { label: "\u5168\u5951\u7D04" }, - renewal_calendar: { label: "\u66F4\u65B0\u30AB\u30EC\u30F3\u30C0\u30FC" }, - contract_gantt: { label: "\u5951\u7D04\u671F\u9593" }, - contract_timeline: { label: "\u5951\u7D04\u30BF\u30A4\u30E0\u30E9\u30A4\u30F3" } - }, - _sections: { - basic: { label: "\u5951\u7D04\u60C5\u5831" }, - parties: { label: "\u5951\u7D04\u5F53\u4E8B\u8005" }, - terms: { label: "\u5951\u7D04\u6761\u4EF6\u30FB\u671F\u9593" }, - value: { label: "\u5951\u7D04\u91D1\u984D" }, - status: { label: "\u30B9\u30C6\u30FC\u30BF\u30B9\u30FB\u627F\u8A8D" }, - renewal: { label: "\u66F4\u65B0" }, - // contract.view.ts のフォームセクション名 (#1100) - contract_terms: { label: "\u5951\u7D04\u6761\u4EF6" }, - signing_and_documents: { label: "\u7F72\u540D\u3068\u66F8\u985E" }, - notes: { label: "\u5099\u8003" } - } - }, - crm_product: { - _validations: { - cost_less_than_price: { - message: "\u539F\u4FA1\u306F\u5B9A\u4FA1\u3088\u308A\u4F4E\u304F\u3057\u3066\u304F\u3060\u3055\u3044" - }, - price_positive: { - message: "\u5B9A\u4FA1\u306F\u6B63\u306E\u5024\u3067\u3042\u308B\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059" - } - }, - label: "\u88FD\u54C1", - pluralLabel: "\u88FD\u54C1", - description: "\u81EA\u793E\u304C\u63D0\u4F9B\u3059\u308B\u88FD\u54C1\u30FB\u30B5\u30FC\u30D3\u30B9", - fields: { - product_code: { label: "\u88FD\u54C1\u30B3\u30FC\u30C9" }, - name: { label: "\u88FD\u54C1\u540D" }, - display_title: { label: "\u8868\u793A\u540D" }, - description: { label: "\u8AAC\u660E" }, - category: { - label: "\u30AB\u30C6\u30B4\u30EA", - options: { - software: "\u30BD\u30D5\u30C8\u30A6\u30A7\u30A2", - hardware: "\u30CF\u30FC\u30C9\u30A6\u30A7\u30A2", - service: "\u30B5\u30FC\u30D3\u30B9", - subscription: "\u30B5\u30D6\u30B9\u30AF\u30EA\u30D7\u30B7\u30E7\u30F3", - support: "\u30B5\u30DD\u30FC\u30C8" - } - }, - family: { - label: "\u88FD\u54C1\u30D5\u30A1\u30DF\u30EA", - options: { - enterprise: "\u30A8\u30F3\u30BF\u30FC\u30D7\u30E9\u30A4\u30BA\u5411\u3051\u30BD\u30EA\u30E5\u30FC\u30B7\u30E7\u30F3", - smb: "\u4E2D\u5C0F\u4F01\u696D\u5411\u3051\u30BD\u30EA\u30E5\u30FC\u30B7\u30E7\u30F3", - services: "\u30D7\u30ED\u30D5\u30A7\u30C3\u30B7\u30E7\u30CA\u30EB\u30B5\u30FC\u30D3\u30B9", - cloud: "\u30AF\u30E9\u30A6\u30C9\u30B5\u30FC\u30D3\u30B9" - } - }, - list_price: { label: "\u5B9A\u4FA1" }, - cost: { label: "\u30B3\u30B9\u30C8" }, - sku: { label: "SKU" }, - is_active: { label: "\u6709\u52B9" }, - product_manager: { label: "\u30D7\u30ED\u30C0\u30AF\u30C8\u30DE\u30CD\u30FC\u30B8\u30E3\u30FC" }, - image: { label: "\u88FD\u54C1\u753B\u50CF" }, - datasheet: { label: "\u30C7\u30FC\u30BF\u30B7\u30FC\u30C8" } - }, - _views: { - all_products: { label: "\u5168\u88FD\u54C1" }, - product_catalog: { label: "\u88FD\u54C1\u30AB\u30BF\u30ED\u30B0" } - }, - _sections: { - basic: { label: "\u88FD\u54C1\u60C5\u5831" }, - pricing: { label: "\u4FA1\u683C" }, - metadata: { label: "\u95A2\u9023\u8CC7\u6599" }, - // product.view.ts のフォームセクション名 (#1100) - product_info: { label: "\u88FD\u54C1\u60C5\u5831" }, - pricing_info: { label: "\u4FA1\u683C" }, - media: { label: "\u30E1\u30C7\u30A3\u30A2" } - } - } -}; - -// src/sales/translations/ja-JP/objects.service.ts -var service3 = { - crm_case: { - _validations: { - resolution_required_for_closed: { - message: "\u30B1\u30FC\u30B9\u3092\u30AF\u30ED\u30FC\u30BA\u3059\u308B\u306B\u306F\u89E3\u6C7A\u5185\u5BB9\u304C\u5FC5\u8981\u3067\u3059" - }, - escalation_reason_required: { - message: "\u30B1\u30FC\u30B9\u3092\u30A8\u30B9\u30AB\u30EC\u30FC\u30B7\u30E7\u30F3\u3059\u308B\u306B\u306F\u7406\u7531\u304C\u5FC5\u8981\u3067\u3059" - }, - case_status_progression: { - message: "\u7121\u52B9\u306A\u30B9\u30C6\u30FC\u30BF\u30B9\u9077\u79FB\u3067\u3059" - } - }, - label: "\u30B1\u30FC\u30B9", - pluralLabel: "\u30B1\u30FC\u30B9", - description: "\u30AB\u30B9\u30BF\u30DE\u30FC\u30B5\u30DD\u30FC\u30C8\u306E\u30B1\u30FC\u30B9\u3068\u30B5\u30FC\u30D3\u30B9\u4F9D\u983C", - fields: { - case_number: { label: "\u30B1\u30FC\u30B9\u756A\u53F7" }, - subject: { label: "\u4EF6\u540D" }, - display_title: { label: "\u8868\u793A\u540D" }, - description: { label: "\u8AAC\u660E" }, - crm_account: { label: "\u53D6\u5F15\u5148" }, - crm_contact: { label: "\u53D6\u5F15\u5148\u8CAC\u4EFB\u8005" }, - status: { - label: "\u30B9\u30C6\u30FC\u30BF\u30B9", - options: { - new: "\u65B0\u898F", - in_progress: "\u5BFE\u5FDC\u4E2D", - waiting_customer: "\u9867\u5BA2\u306E\u56DE\u7B54\u5F85\u3061", - waiting_support: "\u30B5\u30DD\u30FC\u30C8\u306E\u56DE\u7B54\u5F85\u3061", - escalated: "\u30A8\u30B9\u30AB\u30EC\u30FC\u30B7\u30E7\u30F3\u6E08", - resolved: "\u89E3\u6C7A\u6E08", - closed: "\u30AF\u30ED\u30FC\u30BA\u6E08" - } - }, - priority: { - label: "\u512A\u5148\u5EA6", - options: { low: "\u4F4E", medium: "\u4E2D", high: "\u9AD8", critical: "\u91CD\u5927" } - }, - priority_rank: { label: "\u512A\u5148\u5EA6\u30E9\u30F3\u30AF" }, - type: { - label: "\u30B1\u30FC\u30B9\u7A2E\u5225", - options: { - question: "\u554F\u3044\u5408\u308F\u305B", - problem: "\u4E0D\u5177\u5408", - feature_request: "\u6A5F\u80FD\u8981\u671B", - bug: "\u30D0\u30B0" - } - }, - origin: { - label: "\u30B1\u30FC\u30B9\u767A\u751F\u5143", - options: { email: "\u30E1\u30FC\u30EB", phone: "\u96FB\u8A71", web: "\u30A6\u30A7\u30D6", chat: "\u30C1\u30E3\u30C3\u30C8", social_media: "\u30BD\u30FC\u30B7\u30E3\u30EB\u30E1\u30C7\u30A3\u30A2" } - }, - owner_id: { label: "\u30B1\u30FC\u30B9\u62C5\u5F53\u8005" }, - closed_date: { label: "\u30AF\u30ED\u30FC\u30BA\u65E5" }, - first_response_date: { label: "\u521D\u56DE\u5FDC\u7B54\u65E5" }, - resolution_time_hours: { label: "\u89E3\u6C7A\u6642\u9593\uFF08\u6642\u9593\uFF09" }, - sla_due_date: { label: "SLA\u671F\u9650", help: "\u30B1\u30FC\u30B9\u306E\u512A\u5148\u5EA6\u3068\u53D6\u5F15\u5148\u306E\u9867\u5BA2\u30E9\u30F3\u30AF\u304B\u3089\u8A2D\u5B9A\u3055\u308C\u3001\u66A6\u6642\u9593\u3067\u6570\u3048\u307E\u3059\u3002\u591C\u9593\u30FB\u9031\u672B\u30FB\u795D\u65E5\u3082\u3059\u3079\u3066\u542B\u307E\u308C\u307E\u3059\u3002" }, - is_sla_violated: { label: "SLA\u9055\u53CD" }, - is_escalated: { label: "\u30A8\u30B9\u30AB\u30EC\u30FC\u30B7\u30E7\u30F3\u6E08" }, - escalated_date: { label: "\u30A8\u30B9\u30AB\u30EC\u30FC\u30B7\u30E7\u30F3\u65E5" }, - escalation_reason: { label: "\u30A8\u30B9\u30AB\u30EC\u30FC\u30B7\u30E7\u30F3\u7406\u7531" }, - resolution: { label: "\u89E3\u6C7A\u5185\u5BB9" }, - resolved_by_article: { label: "\u89E3\u6C7A\u3057\u305F\u30CA\u30EC\u30C3\u30B8\u8A18\u4E8B", help: "\u3053\u306E\u30B1\u30FC\u30B9\u3092\u89E3\u6C7A\u3057\u305F\u30CA\u30EC\u30C3\u30B8\u8A18\u4E8B \u2014 \u9038\u3089\u3057\u7387\u306E\u6307\u6A19\u3002" }, - internal_notes: { label: "\u5185\u90E8\u30E1\u30E2", help: "\u9867\u5BA2\u306B\u306F\u8868\u793A\u3055\u308C\u306A\u3044\u793E\u5185\u5411\u3051\u30E1\u30E2" }, - is_closed: { label: "\u30AF\u30ED\u30FC\u30BA\u6E08" } - }, - _views: { - all_cases: { label: "\u5168\u30B1\u30FC\u30B9" }, - case_workflow: { label: "\u30B5\u30FC\u30D3\u30B9\u30D5\u30ED\u30FC" }, - sla_calendar: { label: "SLA \u30AB\u30EC\u30F3\u30C0\u30FC" }, - case_timeline: { label: "\u30B1\u30FC\u30B9\u30BF\u30A4\u30E0\u30E9\u30A4\u30F3" }, - unassigned_triage: { - label: "\u672A\u5272\u308A\u5F53\u3066 \u2014 \u30C8\u30EA\u30A2\u30FC\u30B8", - emptyState: { - title: "\u30C8\u30EA\u30A2\u30FC\u30B8\u5F85\u3061\u306F\u3042\u308A\u307E\u305B\u3093", - message: "\u3059\u3079\u3066\u306E\u30B1\u30FC\u30B9\u306B\u6240\u6709\u8005\u304C\u3044\u307E\u3059\u3002\u6240\u6709\u8005\u306E\u306A\u3044\u30B1\u30FC\u30B9\u306F\u3053\u3053\u306B\u8868\u793A\u3055\u308C\u307E\u3059 \u2014 \u901A\u5E38\u306F\u3001\u30B5\u30FC\u30D3\u30B9\u30A8\u30FC\u30B8\u30A7\u30F3\u30C8\u306E\u8077\u4F4D\u3092\u8AB0\u3082\u4FDD\u6301\u3057\u3066\u3044\u306A\u3044\u9593\u306B\u5C4A\u3044\u305F Web-to-Case \u306E\u9001\u4FE1\u3067\u3059\u3002" - } - }, - escalated_cases: { label: "\u30A8\u30B9\u30AB\u30EC\u30FC\u30C8\u3057\u305F\u30B1\u30FC\u30B9" }, - my_open_cases: { label: "\u79C1\u306E\u30AA\u30FC\u30D7\u30F3\u30B1\u30FC\u30B9" }, - sla_at_risk: { label: "\u23F0 SLA \u30EA\u30B9\u30AF\u3042\u308A" } - }, - _sections: { - // case.view.ts のフォームセクション名 (#1100)。 - case: { label: "\u30B1\u30FC\u30B9" }, - how_can_we_help: { label: "\u3069\u306E\u3088\u3046\u306A\u3054\u7528\u4EF6\u3067\u3057\u3087\u3046\u304B\uFF1F" }, - // オブジェクト定義のセクションキー（case.object.ts）— 入力フォームと、 - // これらのグループを参照する詳細ページのセクション（#970）で使用 - basic: { label: "\u30B1\u30FC\u30B9\u60C5\u5831" }, - origin: { label: "\u767A\u751F\u5143\u30FB\u632F\u308A\u5206\u3051" }, - sla: { label: "SLA\u30FB\u512A\u5148\u5EA6" }, - resolution: { label: "\u89E3\u6C7A" }, - escalation: { label: "\u30A8\u30B9\u30AB\u30EC\u30FC\u30B7\u30E7\u30F3" }, - system: { label: "\u30B7\u30B9\u30C6\u30E0" } - }, - _actions: { - ...activityActions3, - escalate_case: { - label: "\u30B1\u30FC\u30B9\u3092\u30A8\u30B9\u30AB\u30EC\u30FC\u30C8", - confirmText: "\u3053\u306E\u30B1\u30FC\u30B9\u3092\u30A8\u30B9\u30AB\u30EC\u30FC\u30B7\u30E7\u30F3\u30C1\u30FC\u30E0\u3078\u5F15\u304D\u7D99\u304E\u307E\u3059\u3002\u7D9A\u884C\u3057\u307E\u3059\u304B\uFF1F", - successMessage: "\u30B1\u30FC\u30B9\u3092\u30A8\u30B9\u30AB\u30EC\u30FC\u30C8\u3057\u307E\u3057\u305F\uFF01" - }, - close_case: { - label: "\u30B1\u30FC\u30B9\u3092\u30AF\u30ED\u30FC\u30BA", - confirmText: "\u3053\u306E\u30B1\u30FC\u30B9\u3092\u30AF\u30ED\u30FC\u30BA\u3057\u3066\u3082\u3088\u308D\u3057\u3044\u3067\u3059\u304B\uFF1F", - successMessage: "\u30B1\u30FC\u30B9\u3092\u30AF\u30ED\u30FC\u30BA\u3057\u307E\u3057\u305F\uFF01" - }, - claim_case: { - label: "\u30B1\u30FC\u30B9\u3092\u5F15\u304D\u53D7\u3051\u308B", - successMessage: "\u30B1\u30FC\u30B9\u3092\u5F15\u304D\u53D7\u3051\u307E\u3057\u305F\u3002\u62C5\u5F53\u8005\u306F\u3042\u306A\u305F\u3067\u3059\u3002" - } - } - }, - crm_knowledge_article: { - _validations: { - published_requires_body: { - message: "\u672C\u6587\u306E\u306A\u3044\u8A18\u4E8B\u306F\u516C\u958B\u3067\u304D\u307E\u305B\u3093\u3002" - }, - published_requires_summary: { - message: "\u516C\u958B\u6E08\u307F\u306E\u8A18\u4E8B\u306B\u306F\u3001\u691C\u7D22\u7D50\u679C\u3068 AI \u306E\u5F15\u7528\u306E\u305F\u3081\u306B\u6982\u8981\u3092\u8A18\u8F09\u3057\u3066\u304F\u3060\u3055\u3044\u3002" - } - }, - label: "\u30CA\u30EC\u30C3\u30B8\u8A18\u4E8B", - pluralLabel: "\u30CA\u30EC\u30C3\u30B8\u30D9\u30FC\u30B9", - description: "\u9867\u5BA2\u3068\u30A8\u30FC\u30B8\u30A7\u30F3\u30C8\u304C\u518D\u5229\u7528\u3067\u304D\u308B\u56DE\u7B54\u3068\u30CF\u30A6\u30C4\u30FC\u30AC\u30A4\u30C9", - fields: { - article_number: { label: "\u8A18\u4E8B\u756A\u53F7" }, - title: { label: "\u30BF\u30A4\u30C8\u30EB" }, - display_title: { label: "\u8868\u793A\u540D" }, - summary: { label: "\u8981\u7D04", help: "\u691C\u7D22\u7D50\u679C\u3084 AI \u306E\u5F15\u7528\u306B\u8868\u793A\u3055\u308C\u308B 1 \u6BB5\u843D\u306E\u8981\u7D04\u3002" }, - body: { label: "\u672C\u6587", help: "\u8A18\u4E8B\u306E\u672C\u6587\uFF08Markdown\uFF09\u3002" }, - category: { - label: "\u30AB\u30C6\u30B4\u30EA", - options: { - getting_started: "\u306F\u3058\u3081\u306B", - how_to: "\u30CF\u30A6\u30C4\u30FC", - troubleshooting: "\u30C8\u30E9\u30D6\u30EB\u30B7\u30E5\u30FC\u30C6\u30A3\u30F3\u30B0", - billing: "\u8ACB\u6C42\u3068\u6599\u91D1", - api: "API \u3068\u9023\u643A", - release_notes: "\u30EA\u30EA\u30FC\u30B9\u30CE\u30FC\u30C8", - policy: "\u30DD\u30EA\u30B7\u30FC" - } - }, - tags: { - label: "\u30BF\u30B0", - options: { - auth: "\u8A8D\u8A3C", - sso: "SSO", - mobile: "\u30E2\u30D0\u30A4\u30EB", - email: "\u30E1\u30FC\u30EB", - reports: "\u30EC\u30DD\u30FC\u30C8", - performance: "\u30D1\u30D5\u30A9\u30FC\u30DE\u30F3\u30B9", - data_import: "\u30C7\u30FC\u30BF\u30A4\u30F3\u30DD\u30FC\u30C8", - webhooks: "Webhook" - } - }, - status: { - label: "\u30B9\u30C6\u30FC\u30BF\u30B9", - options: { draft: "\u4E0B\u66F8\u304D", in_review: "\u30EC\u30D3\u30E5\u30FC\u4E2D", published: "\u516C\u958B\u6E08\u307F", archived: "\u30A2\u30FC\u30AB\u30A4\u30D6" } - }, - audience: { - label: "\u5BFE\u8C61", - help: "\u516C\u958B\u8A18\u4E8B\u306F\u30AB\u30B9\u30BF\u30DE\u30FC\u30DD\u30FC\u30BF\u30EB\u306B\u8868\u793A\u3055\u308C\u3001\u793E\u5185\u8A18\u4E8B\u306F\u30A8\u30FC\u30B8\u30A7\u30F3\u30C8\u306E\u307F\u304C\u95B2\u89A7\u3067\u304D\u307E\u3059\u3002", - options: { public: "\u516C\u958B", internal: "\u793E\u5185" } - }, - language: { - label: "\u8A00\u8A9E", - options: { en: "\u82F1\u8A9E", zh_cn: "\u7C21\u4F53\u5B57\u4E2D\u56FD\u8A9E", es_es: "\u30B9\u30DA\u30A4\u30F3\u8A9E", ja_jp: "\u65E5\u672C\u8A9E" } - }, - owner_id: { label: "\u6240\u6709\u8005" }, - related_to_case: { label: "\u5143\u306E\u30B1\u30FC\u30B9", help: "\u3053\u306E\u8A18\u4E8B\u306E\u5143\u306B\u306A\u3063\u305F\u30B1\u30FC\u30B9\uFF08\u4EFB\u610F\uFF09\u3002" }, - published_at: { label: "\u516C\u958B\u65E5\u6642" }, - last_reviewed_at: { label: "\u6700\u7D42\u30EC\u30D3\u30E5\u30FC" }, - helpful_count: { label: "\u5F79\u306B\u7ACB\u3063\u305F", help: "crm_article_feedback \u304B\u3089\u518D\u96C6\u8A08\u3055\u308C\u307E\u3059\u3002\u624B\u5165\u529B\u306F\u3067\u304D\u307E\u305B\u3093\u3002" }, - not_helpful_count: { label: "\u5F79\u306B\u7ACB\u305F\u306A\u304B\u3063\u305F", help: "crm_article_feedback \u304B\u3089\u518D\u96C6\u8A08\u3055\u308C\u307E\u3059\u3002\u624B\u5165\u529B\u306F\u3067\u304D\u307E\u305B\u3093\u3002" } - }, - _views: { - all_articles: { label: "\u3059\u3079\u3066\u306E\u8A18\u4E8B" }, - published_articles: { label: "\u516C\u958B\u6E08\u307F" }, - my_drafts: { label: "\u81EA\u5206\u306E\u4E0B\u66F8\u304D" } - }, - _sections: { - basic: { label: "\u8A18\u4E8B\u60C5\u5831" }, - content: { label: "\u30B3\u30F3\u30C6\u30F3\u30C4" }, - taxonomy: { label: "\u5206\u985E" }, - metrics: { label: "\u5229\u7528\u72B6\u6CC1" }, - engagement: { label: "\u5229\u7528\u72B6\u6CC1" }, - // knowledge_article.view.ts のフォームセクション名 (#1100) - article: { label: "\u8A18\u4E8B" } - }, - _actions: { - mark_article_helpful: { - label: "\u5F79\u306B\u7ACB\u3063\u305F", - successMessage: "\u300C\u5F79\u306B\u7ACB\u3063\u305F\u300D\u3068\u3057\u3066\u8A18\u9332\u3057\u307E\u3057\u305F\u3002\u3042\u308A\u304C\u3068\u3046\u3054\u3056\u3044\u307E\u3059\u3002" - }, - mark_article_not_helpful: { - label: "\u5F79\u306B\u7ACB\u305F\u306A\u304B\u3063\u305F", - successMessage: "\u300C\u5F79\u306B\u7ACB\u305F\u306A\u304B\u3063\u305F\u300D\u3068\u3057\u3066\u8A18\u9332\u3057\u307E\u3057\u305F\u3002\u3042\u308A\u304C\u3068\u3046\u3054\u3056\u3044\u307E\u3059\u3002" - } - } - }, - crm_article_feedback: { - label: "\u8A18\u4E8B\u30D5\u30A3\u30FC\u30C9\u30D0\u30C3\u30AF", - pluralLabel: "\u8A18\u4E8B\u30D5\u30A3\u30FC\u30C9\u30D0\u30C3\u30AF", - description: "\u30CA\u30EC\u30C3\u30B8\u8A18\u4E8B\u306B\u5BFE\u3059\u308B\u8AAD\u8005\u306E\u300C\u5F79\u306B\u7ACB\u3063\u305F / \u5F79\u306B\u7ACB\u305F\u306A\u304B\u3063\u305F\u300D\u8A55\u4FA1", - fields: { - feedback_number: { label: "\u30D5\u30A3\u30FC\u30C9\u30D0\u30C3\u30AF\u756A\u53F7" }, - owner_id: { label: "\u8AAD\u8005" }, - crm_knowledge_article: { label: "\u8A18\u4E8B", help: "\u3053\u306E\u30D5\u30A3\u30FC\u30C9\u30D0\u30C3\u30AF\u306E\u5BFE\u8C61\u3068\u306A\u308B\u30CA\u30EC\u30C3\u30B8\u8A18\u4E8B\u3002" }, - verdict: { - label: "\u8A55\u4FA1", - options: { helpful: "\u5F79\u306B\u7ACB\u3063\u305F", not_helpful: "\u5F79\u306B\u7ACB\u305F\u306A\u304B\u3063\u305F" } - }, - comment: { label: "\u30B3\u30E1\u30F3\u30C8", help: "\u8A55\u4FA1\u306E\u7406\u7531\uFF08\u4EFB\u610F\uFF09 \u2014 \u8A18\u4E8B\u306E\u4F5C\u6210\u8005\u304C\u8AAD\u307F\u307E\u3059\u3002" } - }, - _sections: { - basic: { label: "\u30D5\u30A3\u30FC\u30C9\u30D0\u30C3\u30AF" } - } - } -}; - -// src/sales/translations/ja-JP/objects.activity.ts -var relatedToTypeOptions = { - crm_account: "\u53D6\u5F15\u5148", - crm_contact: "\u53D6\u5F15\u5148\u8CAC\u4EFB\u8005", - crm_opportunity: "\u5546\u8AC7", - crm_lead: "\u30EA\u30FC\u30C9", - crm_case: "\u30B1\u30FC\u30B9" -}; -var activity3 = { - crm_task: { - _validations: { - completed_date_required: { - message: "\u30B9\u30C6\u30FC\u30BF\u30B9\u304C\u300C\u5B8C\u4E86\u300D\u306E\u5834\u5408\u306F\u5B8C\u4E86\u65E5\u304C\u5FC5\u8981\u3067\u3059" - }, - recurrence_fields_required: { - message: "\u7E70\u308A\u8FD4\u3057\u30BF\u30B9\u30AF\u306B\u306F\u7E70\u308A\u8FD4\u3057\u7A2E\u5225\u304C\u5FC5\u8981\u3067\u3059" - }, - related_to_required: { - message: "\u95A2\u9023\u30EC\u30B3\u30FC\u30C9\u3092\u5C11\u306A\u304F\u3068\u3082 1 \u4EF6\u9078\u629E\u3057\u3066\u304F\u3060\u3055\u3044" - } - }, - label: "\u30BF\u30B9\u30AF", - pluralLabel: "\u30BF\u30B9\u30AF", - description: "\u6D3B\u52D5\u3068 ToDo", - fields: { - subject: { label: "\u4EF6\u540D" }, - description: { label: "\u8AAC\u660E" }, - status: { - label: "\u30B9\u30C6\u30FC\u30BF\u30B9", - options: { - not_started: "\u672A\u7740\u624B", - in_progress: "\u9032\u884C\u4E2D", - waiting: "\u5F85\u6A5F\u4E2D", - completed: "\u5B8C\u4E86", - deferred: "\u4FDD\u7559" - } - }, - priority: { - label: "\u512A\u5148\u5EA6", - options: { low: "\u4F4E", normal: "\u901A\u5E38", high: "\u9AD8", urgent: "\u7DCA\u6025" } - }, - priority_rank: { label: "\u512A\u5148\u5EA6\u30E9\u30F3\u30AF" }, - type: { - label: "\u30BF\u30B9\u30AF\u7A2E\u5225", - options: { - call: "\u96FB\u8A71", - email: "\u30E1\u30FC\u30EB", - meeting: "\u4F1A\u8B70", - follow_up: "\u30D5\u30A9\u30ED\u30FC\u30A2\u30C3\u30D7", - demo: "\u30C7\u30E2", - other: "\u305D\u306E\u4ED6" - } - }, - due_date: { label: "\u671F\u9650" }, - reminder_date: { label: "\u30EA\u30DE\u30A4\u30F3\u30C0\u30FC\u65E5\u6642" }, - reminder_sent: { label: "\u30EA\u30DE\u30A4\u30F3\u30C0\u30FC\u9001\u4FE1\u6E08\u307F" }, - completed_date: { label: "\u5B8C\u4E86\u65E5" }, - owner_id: { label: "\u62C5\u5F53\u8005" }, - related_to_type: { - label: "\u95A2\u9023\u30AA\u30D6\u30B8\u30A7\u30AF\u30C8\u7A2E\u5225", - options: { ...relatedToTypeOptions } - }, - related_to_account: { label: "\u95A2\u9023\u53D6\u5F15\u5148" }, - related_to_contact: { label: "\u95A2\u9023\u53D6\u5F15\u5148\u8CAC\u4EFB\u8005" }, - related_to_opportunity: { label: "\u95A2\u9023\u5546\u8AC7" }, - related_to_lead: { label: "\u95A2\u9023\u30EA\u30FC\u30C9" }, - related_to_case: { label: "\u95A2\u9023\u30B1\u30FC\u30B9" }, - is_recurring: { label: "\u7E70\u308A\u8FD4\u3057\u30BF\u30B9\u30AF" }, - recurrence_type: { - label: "\u7E70\u308A\u8FD4\u3057\u7A2E\u5225", - options: { daily: "\u6BCE\u65E5", weekly: "\u6BCE\u9031", monthly: "\u6BCE\u6708", yearly: "\u6BCE\u5E74" } - }, - recurrence_interval: { label: "\u7E70\u308A\u8FD4\u3057\u9593\u9694" }, - recurrence_end_date: { label: "\u7E70\u308A\u8FD4\u3057\u7D42\u4E86\u65E5" }, - is_completed: { label: "\u5B8C\u4E86\u6E08" }, - is_overdue: { label: "\u671F\u9650\u8D85\u904E" }, - progress_percent: { label: "\u9032\u6357\uFF08%\uFF09" } - }, - _views: { - all_tasks: { label: "\u5168\u30BF\u30B9\u30AF" }, - task_board: { label: "\u30BF\u30B9\u30AF\u30DC\u30FC\u30C9" }, - task_calendar: { label: "\u30BF\u30B9\u30AF\u30AB\u30EC\u30F3\u30C0\u30FC" }, - task_gantt: { label: "\u5B9F\u884C\u8A08\u753B" }, - task_timeline: { label: "\u5DE5\u6570\u30BF\u30A4\u30E0\u30E9\u30A4\u30F3" }, - my_open_tasks: { label: "\u79C1\u306E\u30AA\u30FC\u30D7\u30F3\u30BF\u30B9\u30AF" }, - todays_tasks: { label: "\u{1F4C5} \u79C1\u306E\u512A\u5148\u30BF\u30B9\u30AF" }, - overdue_tasks: { label: "\u23F0 \u30AA\u30FC\u30D7\u30F3\u30BF\u30B9\u30AF \xB7 \u671F\u9650\u8D85\u904E\u304C\u9577\u3044\u9806" } - }, - _sections: { - basic: { label: "\u30BF\u30B9\u30AF\u60C5\u5831" }, - scheduling: { label: "\u30B9\u30B1\u30B8\u30E5\u30FC\u30EB" }, - related: { label: "\u95A2\u9023\u30EC\u30B3\u30FC\u30C9" }, - recurrence: { label: "\u7E70\u308A\u8FD4\u3057" }, - effort: { label: "\u9032\u6357\u30FB\u5DE5\u6570" }, - system: { label: "\u30B7\u30B9\u30C6\u30E0" }, - // task.view.ts のフォームセクション名 (#1100) - task: { label: "\u30BF\u30B9\u30AF" }, - related_records: { label: "\u95A2\u9023\u30EC\u30B3\u30FC\u30C9" }, - recurrence_and_effort: { label: "\u7E70\u308A\u8FD4\u3057\u3068\u5DE5\u6570" } - } - }, - crm_event: { - _validations: { - end_after_start: { - message: "\u7D42\u4E86\u6642\u523B\u306F\u958B\u59CB\u6642\u523B\u3088\u308A\u5F8C\u3067\u3042\u308B\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059" - }, - related_to_required: { - message: "\u95A2\u9023\u30EC\u30B3\u30FC\u30C9\u3092\u5C11\u306A\u304F\u3068\u3082 1 \u4EF6\u9078\u629E\u3057\u3066\u304F\u3060\u3055\u3044" - } - }, - label: "\u30A4\u30D9\u30F3\u30C8", - pluralLabel: "\u30A4\u30D9\u30F3\u30C8", - description: "\u9867\u5BA2\u3068\u306E\u4F1A\u8B70\u30FB\u96FB\u8A71\u306A\u3069\u306E\u4E88\u5B9A\u3055\u308C\u305F\u5BFE\u8A71", - fields: { - subject: { label: "\u4EF6\u540D" }, - description: { label: "\u8AAC\u660E" }, - type: { - label: "\u30A4\u30D9\u30F3\u30C8\u7A2E\u5225", - options: { - meeting: "\u4F1A\u8B70", - call: "\u96FB\u8A71", - demo: "\u30C7\u30E2", - webinar: "\u30A6\u30A7\u30D3\u30CA\u30FC", - onsite_visit: "\u8A2A\u554F", - other: "\u305D\u306E\u4ED6" - } - }, - status: { - label: "\u30B9\u30C6\u30FC\u30BF\u30B9", - options: { - planned: "\u4E88\u5B9A", - held: "\u5B9F\u65BD\u6E08\u307F", - cancelled: "\u30AD\u30E3\u30F3\u30BB\u30EB", - no_show: "\u7121\u65AD\u6B20\u5E2D" - } - }, - owner_id: { label: "\u62C5\u5F53\u8005" }, - start_datetime: { label: "\u958B\u59CB" }, - end_datetime: { label: "\u7D42\u4E86" }, - all_day: { label: "\u7D42\u65E5\u30A4\u30D9\u30F3\u30C8" }, - duration_minutes: { label: "\u6240\u8981\u6642\u9593\uFF08\u5206\uFF09" }, - location: { label: "\u5834\u6240", help: "\u4F1A\u8B70\u5BA4\u30FB\u4F4F\u6240\u30FB\u4F1A\u8B70\u30EA\u30F3\u30AF" }, - related_to_type: { - label: "\u95A2\u9023\u30EC\u30B3\u30FC\u30C9\u7A2E\u5225", - options: { ...relatedToTypeOptions } - }, - related_to_account: { label: "\u95A2\u9023\u53D6\u5F15\u5148" }, - related_to_contact: { label: "\u95A2\u9023\u53D6\u5F15\u5148\u8CAC\u4EFB\u8005" }, - related_to_opportunity: { label: "\u95A2\u9023\u5546\u8AC7" }, - related_to_lead: { label: "\u95A2\u9023\u30EA\u30FC\u30C9" }, - related_to_case: { label: "\u95A2\u9023\u30B1\u30FC\u30B9" }, - outcome_notes: { label: "\u7D50\u679C\u30E1\u30E2", help: "\u5408\u610F\u4E8B\u9805\u3068\u6B21\u306E\u30A2\u30AF\u30B7\u30E7\u30F3" } - }, - _views: { - all_events: { label: "\u3059\u3079\u3066\u306E\u30A4\u30D9\u30F3\u30C8" }, - event_calendar: { label: "\u30A4\u30D9\u30F3\u30C8\u30AB\u30EC\u30F3\u30C0\u30FC" }, - event_timeline: { label: "\u30C1\u30FC\u30E0\u30B9\u30B1\u30B8\u30E5\u30FC\u30EB" }, - my_events: { label: "\u30DE\u30A4\u30AB\u30EC\u30F3\u30C0\u30FC" }, - upcoming_events: { label: "\u{1F4C5} \u958B\u50AC\u4E88\u5B9A \xB7 \u76F4\u8FD1\u9806" }, - held_events: { label: "\u2705 \u5BFE\u8A71\u5C65\u6B74" } - }, - _sections: { - basic: { label: "\u30A4\u30D9\u30F3\u30C8\u60C5\u5831" }, - schedule: { label: "\u30B9\u30B1\u30B8\u30E5\u30FC\u30EB" }, - related: { label: "\u95A2\u9023\u30EC\u30B3\u30FC\u30C9" }, - outcome: { label: "\u5B9F\u65BD\u7D50\u679C" }, - // event.view.ts のフォームセクション名 (#1100) - event: { label: "\u30A4\u30D9\u30F3\u30C8" }, - related_records: { label: "\u95A2\u9023\u30EC\u30B3\u30FC\u30C9" } - } - }, - crm_event_attendee: { - _validations: { - attendee_resolves: { - message: "\u53C2\u52A0\u8005\u306F\u53C2\u52A0\u8005\u7A2E\u5225\u304C\u793A\u3059\u76F8\u624B\u3092\u6307\u5B9A\u3059\u308B\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059\u3002\u53D6\u5F15\u5148\u8CAC\u4EFB\u8005\u306E\u5834\u5408\u306F\u53D6\u5F15\u5148\u8CAC\u4EFB\u8005\u3092\u3001\u793E\u5916\u306E\u5834\u5408\u306F\u793E\u5916\u53C2\u52A0\u8005\u540D\u3092\u5165\u529B\u3057\u3066\u304F\u3060\u3055\u3044" - }, - attendee_type_exclusive: { - message: "\u53C2\u52A0\u8005\u304C\u6307\u5B9A\u3067\u304D\u308B\u76F8\u624B\u306F 1 \u3064\u3060\u3051\u3067\u3059\u3002\u53C2\u52A0\u8005\u7A2E\u5225\u304C\u793A\u3055\u306A\u3044\u9805\u76EE\u306F\u3059\u3079\u3066\u7A7A\u306B\u3057\u3066\u304F\u3060\u3055\u3044" - } - }, - label: "\u30A4\u30D9\u30F3\u30C8\u53C2\u52A0\u8005", - pluralLabel: "\u30A4\u30D9\u30F3\u30C8\u53C2\u52A0\u8005", - description: "\u30A4\u30D9\u30F3\u30C8\u306B\u62DB\u5F85\u3055\u308C\u305F\u3001\u307E\u305F\u306F\u51FA\u5E2D\u3057\u305F\u4EBA", - fields: { - attendee_number: { label: "\u53C2\u52A0\u8005\u756A\u53F7" }, - crm_event: { label: "\u30A4\u30D9\u30F3\u30C8" }, - attendee_type: { - label: "\u53C2\u52A0\u8005\u7A2E\u5225", - options: { contact: "\u53D6\u5F15\u5148\u8CAC\u4EFB\u8005", lead: "\u30EA\u30FC\u30C9", user: "\u793E\u5185\u30E6\u30FC\u30B6\u30FC", external: "\u793E\u5916\u30B2\u30B9\u30C8" } - }, - crm_contact: { label: "\u53D6\u5F15\u5148\u8CAC\u4EFB\u8005", help: "\u53C2\u52A0\u8005\u304C\u65E2\u5B58\u306E\u53D6\u5F15\u5148\u8CAC\u4EFB\u8005\u3067\u3042\u308B\u5834\u5408\u306B\u8A2D\u5B9A\u3057\u307E\u3059" }, - crm_lead: { label: "\u30EA\u30FC\u30C9", help: "\u53C2\u52A0\u8005\u304C\u307E\u3060\u5909\u63DB\u3055\u308C\u3066\u3044\u306A\u3044\u30EA\u30FC\u30C9\u3067\u3042\u308B\u5834\u5408\u306B\u8A2D\u5B9A\u3057\u307E\u3059" }, - sys_user: { label: "\u793E\u5185\u30E6\u30FC\u30B6\u30FC", help: "\u53C2\u52A0\u8005\u304C\u793E\u5185\u306E\u540C\u50DA\u3067\u3042\u308B\u5834\u5408\u306B\u8A2D\u5B9A\u3057\u307E\u3059" }, - external_name: { label: "\u793E\u5916\u53C2\u52A0\u8005", help: "CRM \u306E\u3069\u306E\u30AA\u30D6\u30B8\u30A7\u30AF\u30C8\u306B\u3082\u5B58\u5728\u3057\u306A\u3044\u53C2\u52A0\u8005\u306E\u6C0F\u540D \u2014 \u53C2\u52A0\u8005\u7A2E\u5225\u304C\u300C\u793E\u5916\u30B2\u30B9\u30C8\u300D\u306E\u3068\u304D\u306B\u8A2D\u5B9A\u3057\u307E\u3059" }, - response: { - label: "\u56DE\u7B54", - options: { - no_response: "\u672A\u56DE\u7B54", - accepted: "\u627F\u8AFE", - declined: "\u8F9E\u9000", - tentative: "\u4EEE\u627F\u8AFE" - } - }, - is_organizer: { label: "\u4E3B\u50AC\u8005" }, - invited_date: { label: "\u62DB\u5F85\u65E5\u6642" } - }, - _views: { - all_event_attendees: { label: "\u30A4\u30D9\u30F3\u30C8\u53C2\u52A0\u8005" } - }, - _sections: { - basic: { label: "\u53C2\u52A0\u8005" }, - response: { label: "\u62DB\u5F85" }, - // event_attendee.view.ts のフォームセクション名 (#1100) - attendee: { label: "\u53C2\u52A0\u8005" }, - invitation: { label: "\u62DB\u5F85" } - } - } -}; - -// src/sales/translations/ja-JP/objects.marketing.ts -var marketing3 = { - crm_campaign: { - _validations: { - end_after_start: { - message: "\u7D42\u4E86\u65E5\u306F\u958B\u59CB\u65E5\u3088\u308A\u5F8C\u3067\u3042\u308B\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059" - }, - actual_cost_within_budget: { - message: "\u5B9F\u7E3E\u30B3\u30B9\u30C8\u304C\u4E88\u7B97\u30B3\u30B9\u30C8\u3092\u8D85\u3048\u3066\u3044\u307E\u3059" - } - }, - label: "\u30AD\u30E3\u30F3\u30DA\u30FC\u30F3", - pluralLabel: "\u30AD\u30E3\u30F3\u30DA\u30FC\u30F3", - description: "\u30DE\u30FC\u30B1\u30C6\u30A3\u30F3\u30B0\u30AD\u30E3\u30F3\u30DA\u30FC\u30F3\u3068\u65BD\u7B56", - fields: { - campaign_code: { label: "\u30AD\u30E3\u30F3\u30DA\u30FC\u30F3\u30B3\u30FC\u30C9" }, - name: { label: "\u30AD\u30E3\u30F3\u30DA\u30FC\u30F3\u540D" }, - display_title: { label: "\u8868\u793A\u540D" }, - description: { label: "\u8AAC\u660E" }, - type: { - label: "\u30AD\u30E3\u30F3\u30DA\u30FC\u30F3\u7A2E\u5225", - options: { - email: "\u30E1\u30FC\u30EB", - webinar: "\u30A6\u30A7\u30D3\u30CA\u30FC", - trade_show: "\u5C55\u793A\u4F1A", - conference: "\u30AB\u30F3\u30D5\u30A1\u30EC\u30F3\u30B9", - direct_mail: "\u30C0\u30A4\u30EC\u30AF\u30C8\u30E1\u30FC\u30EB", - social_media: "\u30BD\u30FC\u30B7\u30E3\u30EB\u30E1\u30C7\u30A3\u30A2", - content: "\u30B3\u30F3\u30C6\u30F3\u30C4\u30DE\u30FC\u30B1\u30C6\u30A3\u30F3\u30B0", - partner: "\u30D1\u30FC\u30C8\u30CA\u30FC\u30DE\u30FC\u30B1\u30C6\u30A3\u30F3\u30B0" - } - }, - channel: { - label: "\u4E3B\u8981\u30C1\u30E3\u30CD\u30EB", - options: { - digital: "\u30C7\u30B8\u30BF\u30EB", - social: "\u30BD\u30FC\u30B7\u30E3\u30EB", - email: "\u30E1\u30FC\u30EB", - events: "\u30A4\u30D9\u30F3\u30C8", - partner: "\u30D1\u30FC\u30C8\u30CA\u30FC" - } - }, - status: { - label: "\u30B9\u30C6\u30FC\u30BF\u30B9", - options: { - planning: "\u8A08\u753B\u4E2D", - in_progress: "\u5B9F\u65BD\u4E2D", - completed: "\u5B8C\u4E86", - aborted: "\u4E2D\u6B62" - } - }, - start_date: { label: "\u958B\u59CB\u65E5" }, - end_date: { label: "\u7D42\u4E86\u65E5" }, - budgeted_cost: { label: "\u4E88\u7B97\u30B3\u30B9\u30C8" }, - actual_cost: { label: "\u5B9F\u30B3\u30B9\u30C8" }, - expected_revenue: { label: "\u4E88\u6E2C\u58F2\u4E0A" }, - actual_revenue: { label: "\u5B9F\u53CE\u76CA" }, - target_size: { label: "\u30BF\u30FC\u30B2\u30C3\u30C8\u898F\u6A21", help: "\u5BFE\u8C61\u3068\u3059\u308B\u30EA\u30FC\u30C9\u30FB\u53D6\u5F15\u5148\u8CAC\u4EFB\u8005\u306E\u76EE\u6A19\u4EF6\u6570" }, - num_sent: { label: "\u9001\u4FE1\u6570" }, - num_responses: { label: "\u5FDC\u7B54\u6570" }, - num_leads: { label: "\u30EA\u30FC\u30C9\u6570" }, - num_converted_leads: { label: "\u5909\u63DB\u6E08\u30EA\u30FC\u30C9\u6570" }, - num_opportunities: { label: "\u4F5C\u6210\u6E08\u5546\u8AC7\u6570" }, - num_won_opportunities: { label: "\u53D7\u6CE8\u5546\u8AC7" }, - response_rate: { label: "\u5FDC\u7B54\u7387\uFF08%\uFF09" }, - roi: { label: "ROI\uFF08%\uFF09" }, - owner_id: { label: "\u30AD\u30E3\u30F3\u30DA\u30FC\u30F3\u62C5\u5F53\u8005" }, - landing_page_url: { label: "\u30E9\u30F3\u30C7\u30A3\u30F3\u30B0\u30DA\u30FC\u30B8" }, - is_active: { label: "\u6709\u52B9" } - }, - _views: { - all_campaigns: { label: "\u5168\u30AD\u30E3\u30F3\u30DA\u30FC\u30F3" }, - campaign_gantt: { label: "\u30AD\u30E3\u30F3\u30DA\u30FC\u30F3\u65E5\u7A0B" }, - campaign_calendar: { label: "\u30AD\u30E3\u30F3\u30DA\u30FC\u30F3\u30AB\u30EC\u30F3\u30C0\u30FC" }, - campaign_timeline: { label: "\u30DE\u30FC\u30B1\u30C6\u30A3\u30F3\u30B0\u30BF\u30A4\u30E0\u30E9\u30A4\u30F3" } - }, - _sections: { - basic: { label: "\u30AD\u30E3\u30F3\u30DA\u30FC\u30F3\u60C5\u5831" }, - schedule: { label: "\u30B9\u30B1\u30B8\u30E5\u30FC\u30EB" }, - budget: { label: "\u4E88\u7B97\u30FBROI" }, - metrics: { label: "\u5B9F\u7E3E" }, - assignment: { label: "\u62C5\u5F53\u8005" }, - assets: { label: "\u30AD\u30E3\u30F3\u30DA\u30FC\u30F3\u30A2\u30BB\u30C3\u30C8" } - }, - _actions: { - enroll_leads: { - label: "\u30E1\u30F3\u30D0\u30FC\u3092\u4E00\u62EC\u767B\u9332", - successMessage: "\u5BFE\u8C61\u30E1\u30F3\u30D0\u30FC\u3092\u30AD\u30E3\u30F3\u30DA\u30FC\u30F3\u306B\u767B\u9332\u3057\u307E\u3057\u305F\u3002" - } - } - }, - crm_campaign_member: { - _validations: { - lead_or_contact_required: { - message: "\u30AD\u30E3\u30F3\u30DA\u30FC\u30F3\u30E1\u30F3\u30D0\u30FC\u306F\u30EA\u30FC\u30C9\u307E\u305F\u306F\u53D6\u5F15\u5148\u8CAC\u4EFB\u8005\u306E\u3044\u305A\u308C\u304B\u3092\u53C2\u7167\u3059\u308B\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059" - } - }, - label: "\u30AD\u30E3\u30F3\u30DA\u30FC\u30F3\u30E1\u30F3\u30D0\u30FC", - pluralLabel: "\u30AD\u30E3\u30F3\u30DA\u30FC\u30F3\u30E1\u30F3\u30D0\u30FC", - description: "\u30AD\u30E3\u30F3\u30DA\u30FC\u30F3\u306E\u5BFE\u8C61\u3068\u306A\u3063\u305F\u30EA\u30FC\u30C9\u30FB\u53D6\u5F15\u5148\u8CAC\u4EFB\u8005\u3068\u305D\u306E\u53CD\u5FDC\u72B6\u6CC1", - fields: { - member_number: { label: "\u30E1\u30F3\u30D0\u30FC\u756A\u53F7" }, - crm_campaign: { label: "\u30AD\u30E3\u30F3\u30DA\u30FC\u30F3" }, - crm_lead: { label: "\u30EA\u30FC\u30C9", help: "\u767B\u9332\u6642\u70B9\u3067\u30EA\u30FC\u30C9\u3060\u3063\u305F\u30E1\u30F3\u30D0\u30FC\u306B\u8A2D\u5B9A\u3055\u308C\u307E\u3059" }, - crm_contact: { label: "\u53D6\u5F15\u5148\u8CAC\u4EFB\u8005", help: "\u65E2\u5B58\u306E\u53D6\u5F15\u5148\u8CAC\u4EFB\u8005\u3067\u3042\u308B\u30E1\u30F3\u30D0\u30FC\u306B\u8A2D\u5B9A\u3055\u308C\u307E\u3059" }, - status: { - label: "\u30B9\u30C6\u30FC\u30BF\u30B9", - options: { - sent: "\u9001\u4FE1\u6E08", - responded: "\u5FDC\u7B54\u6E08", - converted: "\u5909\u63DB\u6E08", - unsubscribed: "\u914D\u4FE1\u505C\u6B62" - } - }, - added_date: { label: "\u8FFD\u52A0\u65E5\u6642" }, - response_date: { label: "\u5FDC\u7B54\u65E5\u6642" }, - has_responded: { label: "\u5FDC\u7B54\u6E08" } - }, - _sections: { - basic: { label: "\u57FA\u672C\u60C5\u5831" }, - response: { label: "\u53CD\u5FDC\u30C8\u30E9\u30C3\u30AD\u30F3\u30B0" } - }, - _actions: { - mark_responded: { - label: "\u5FDC\u7B54\u6E08\u306B\u3059\u308B", - successMessage: "\u3053\u306E\u30AD\u30E3\u30F3\u30DA\u30FC\u30F3\u30E1\u30F3\u30D0\u30FC\u306E\u5FDC\u7B54\u3092\u8A18\u9332\u3057\u307E\u3057\u305F\u3002" - } - } - } -}; - -// src/sales/translations/ja-JP.ts -var jaJP2 = { - objects: { - crm_account: customer3.crm_account, - crm_contact: customer3.crm_contact, - crm_knowledge_article: service3.crm_knowledge_article, - crm_forecast: pipeline3.crm_forecast, - crm_lead: pipeline3.crm_lead, - crm_opportunity: pipeline3.crm_opportunity, - crm_case: service3.crm_case, - crm_contract: commerce3.crm_contract, - crm_product: commerce3.crm_product, - crm_quote: commerce3.crm_quote, - crm_task: activity3.crm_task, - crm_campaign: marketing3.crm_campaign, - crm_event: activity3.crm_event, - crm_event_attendee: activity3.crm_event_attendee, - crm_article_feedback: service3.crm_article_feedback, - crm_campaign_member: marketing3.crm_campaign_member, - crm_opportunity_line_item: pipeline3.crm_opportunity_line_item, - crm_quote_line_item: commerce3.crm_quote_line_item - }, - ...appSurface3 -}; - -// src/sales/translations/es-ES/app.ts -var appSurface4 = { - apps: { - crm_enterprise: { - label: "HotCRM", - description: "Gesti\xF3n de relaciones con clientes para ventas, servicio y marketing", - // Indexado por el `id` del nodo de navegación (espacio de nombres plano, - // sea cual sea la profundidad del nodo). - navigation: { - group_activity: { label: "Actividad" }, - nav_event: { label: "Eventos" }, - nav_activity_dashboard: { label: "Actividad de Ventas" }, - nav_my_calendar: { label: "Mi Calendario" }, - nav_home: { label: "Inicio" }, - group_sales: { label: "Ventas" }, - nav_lead: { label: "Prospectos" }, - nav_account: { label: "Cuentas" }, - nav_account_workbench: { label: "Mesa de Trabajo de Cuentas" }, - nav_contact: { label: "Contactos" }, - nav_opportunity: { label: "Oportunidades" }, - nav_quote: { label: "Cotizaciones" }, - nav_contract: { label: "Contratos" }, - nav_product: { label: "Productos" }, - nav_sales_dashboard: { label: "Rendimiento de Ventas" }, - group_work: { label: "Mi Trabajo" }, - nav_my_tasks: { label: "Mis Tareas" }, - nav_my_deals: { label: "Mis Negocios" }, - nav_my_leads: { label: "Mis Prospectos" }, - nav_my_cases: { label: "Mis Casos" }, - nav_approval_requests: { label: "Bandeja de Entrada" }, - group_service: { label: "Servicio" }, - nav_case: { label: "Casos" }, - nav_knowledge: { label: "Conocimiento" }, - nav_service_dashboard: { label: "Resumen de Servicio" }, - group_marketing: { label: "Marketing" }, - nav_campaign: { label: "Campa\xF1as" }, - group_insights: { label: "An\xE1lisis" }, - nav_crm_dashboard: { label: "Resumen CRM" }, - nav_forecast: { label: "Previsiones" }, - nav_report_pipeline_coverage: { label: "Cobertura del Pipeline" }, - nav_report_lead_inflow: { label: "Entrada de Prospectos" }, - nav_report_sla: { label: "Cumplimiento de SLA" } - } - } - }, - messages: { - "common.save": "Guardar", - "common.cancel": "Cancelar", - "common.delete": "Eliminar", - "common.edit": "Editar", - "common.create": "Crear", - "common.search": "Buscar", - "common.filter": "Filtrar", - "common.export": "Exportar", - "common.back": "Volver", - "common.confirm": "Confirmar", - "nav.sales": "Ventas", - "nav.service": "Servicio", - "nav.marketing": "Marketing", - "nav.products": "Productos", - "nav.analytics": "Anal\xEDtica", - "success.saved": "Registro guardado exitosamente", - "success.converted": "Prospecto convertido exitosamente", - "confirm.delete": "\xBFEst\xE1 seguro de que desea eliminar este registro?", - "confirm.convert_lead": "\xBFConvertir este prospecto en cuenta, contacto y oportunidad?", - "error.required": "Este campo es obligatorio", - "error.load_failed": "Error al cargar los datos" - }, - dashboards: { - sales_activity_dashboard: { - label: "Actividad de ventas", - description: "Qui\xE9n habla con los clientes, con qu\xE9 frecuencia y qu\xE9 cuentas se han quedado en silencio", - widgets: { - interactions_held: { title: "Interacciones registradas", description: "Llamadas y reuniones que realmente ocurrieron" }, - meetings_booked: { title: "Reuniones agendadas", description: "Reuniones en el calendario que a\xFAn no ocurren" }, - customer_minutes: { title: "Minutos con clientes", description: "Tiempo total frente a clientes" }, - tasks_completed: { title: "Tareas completadas", description: "Seguimientos cerrados \u2014 la otra mitad de la actividad" }, - activity_by_rep: { title: "Actividad por representante", description: "Interacciones registradas por responsable" }, - activity_by_week: { title: "Volumen de actividad por semana", description: "Interacciones por semana" }, - activity_mix: { title: "Composici\xF3n de la actividad", description: "Llamadas vs reuniones vs demostraciones" }, - activity_by_record_type: { title: "D\xF3nde cae la actividad", description: "Qu\xE9 parte del embudo recibe atenci\xF3n" }, - deal_activity: { title: "Interacciones en oportunidades", description: "Interacciones vinculadas a una oportunidad" }, - open_deals_for_activity: { title: "Oportunidades abiertas", description: "Oportunidades a\xFAn en juego" }, - quiet_accounts_30: { title: "Silencio 30+ d\xEDas", description: "Cuentas activas sin interacci\xF3n en un mes" }, - quiet_accounts_60: { title: "Silencio 60+ d\xEDas", description: "Dos meses de silencio \u2014 el umbral de riesgo" }, - quiet_accounts_90: { title: "Silencio 90+ d\xEDas", description: "Un trimestre sin contacto" } - } - }, - crm_overview_dashboard: { - label: "Resumen CRM", - description: "M\xE9tricas de ingresos, anal\xEDtica de pipeline e informaci\xF3n de oportunidades", - widgets: { - total_revenue: { title: "Ingresos totales", description: "Ingresos cerrados ganados en este per\xEDodo" }, - active_deals: { title: "Negocios activos", description: "Oportunidades abiertas en el pipeline" }, - won_deals: { title: "Negocios ganados", description: "Negocios cerrados ganados en este per\xEDodo" }, - avg_deal_size: { title: "Tama\xF1o medio del negocio", description: "Valor medio de los negocios cerrados ganados" }, - revenue_trends: { title: "Tendencia de ingresos", description: "Ingresos cerrados ganados de los \xFAltimos 12 meses" }, - lead_source: { title: "Origen del prospecto", description: "Valor del pipeline por canal de adquisici\xF3n" }, - pipeline_by_stage: { title: "Pipeline por etapa", description: "Valor de oportunidades abiertas en cada etapa de venta" }, - top_products: { title: "Productos principales", description: "Ingresos a precio de lista por categor\xEDa de producto" }, - pipeline_by_owner: { title: "Pipeline por responsable", description: "Valor del pipeline abierto y n\xFAmero de negocios por comercial" } - } - }, - executive_dashboard: { - label: "Vista ejecutiva", - description: "KPI de alto nivel sobre ingresos, clientes y pipeline para la direcci\xF3n", - widgets: { - total_revenue_ytd: { title: "Ingresos totales (YTD)", description: "Ingresos cerrados ganados en lo que va del a\xF1o" }, - total_accounts: { title: "Cuentas activas", description: "Clientes con al menos una relaci\xF3n activa" }, - total_contacts: { title: "Total de contactos", description: "Personas en nuestra agenda" }, - open_leads: { title: "Prospectos abiertos", description: "Prospectos sin convertir en el embudo" }, - revenue_trend: { title: "Tendencia de ingresos", description: "Ingresos cerrados ganados de los \xFAltimos 12 meses" }, - revenue_by_industry: { title: "Ingresos por industria", description: "Ingresos YTD ganados separados por industria del cliente" }, - pipeline_by_stage: { title: "Pipeline por etapa", description: "Valor de oportunidades abiertas en cada etapa de venta" }, - new_accounts_by_month: { title: "Cuentas nuevas", description: "Ritmo de creaci\xF3n de cuentas en los \xFAltimos 6 meses" }, - accounts_by_industry: { title: "Cuentas por sector", description: "Ingreso anual total y n\xFAmero de cuentas por sector" } - } - }, - sales_dashboard: { - label: "Rendimiento de ventas", - description: "Anal\xEDtica de pipeline, tendencias de tasa de \xE9xito y rendimiento de los representantes", - widgets: { - total_pipeline_value: { title: "Pipeline total", description: "Suma del valor de las oportunidades abiertas" }, - closed_won_qtd: { title: "Cerrado ganado (trimestre)", description: "Ingresos cerrados este trimestre" }, - open_opportunities: { title: "Oportunidades abiertas", description: "Negocios activos en curso" }, - avg_deal_size: { title: "Tama\xF1o medio del negocio", description: "Valor medio de los negocios cerrados ganados este trimestre" }, - pipeline_by_stage: { title: "Pipeline por etapa", description: "Valor de oportunidades abiertas en cada etapa de venta" }, - monthly_revenue_trend: { title: "Tendencia mensual de ingresos", description: "Ingresos cerrados ganados de los \xFAltimos 12 meses" }, - pipeline_by_forecast_category: { title: "Pipeline por categor\xEDa de pron\xF3stico", description: "Pipeline abierto agrupado por categor\xEDa de pron\xF3stico de ventas" }, - lead_source_breakdown: { title: "Origen del prospecto", description: "De d\xF3nde proviene nuestro pipeline" }, - open_pipeline_by_owner: { title: "Pipeline abierto por responsable", description: "Valor del pipeline en curso, n\xFAmero de negocios y probabilidad media de cierre por comercial" }, - quota_attainment_by_rep: { title: "Cumplimiento de cuota por representante", description: "Cuota del trimestre actual, ingresos cerrados y cumplimiento por representante, seg\xFAn instant\xE1neas de pron\xF3stico" }, - pipeline_stage_by_source: { title: "Pipeline por Etapa \xD7 Origen", description: "Tabla cruzada del importe de oportunidades abiertas por etapa y origen" }, - win_rate_12m: { title: "Tasa de \xE9xito (12M)", description: "Negocios ganados como porcentaje de todos los negocios resueltos en los \xFAltimos 12 meses" }, - won_deals_12m: { title: "Negocios ganados (12M)", description: "El numerador de la tasa de \xE9xito" }, - lost_deals_12m: { title: "Negocios perdidos (12M)", description: "La otra mitad del denominador de la tasa de \xE9xito" }, - win_rate_by_owner: { title: "Ganados / perdidos por representante", description: "Negocios ganados, negocios perdidos y tasa de \xE9xito por representante \u2014 \xFAltimos 12 meses" }, - win_rate_by_lead_source: { title: "Ganados / perdidos por origen del prospecto", description: "Qu\xE9 or\xEDgenes producen negocios que realmente se cierran \u2014 \xFAltimos 12 meses" }, - loss_reason_breakdown: { title: "Por qu\xE9 perdemos", description: "Negocios perdidos por motivo \u2014 \xFAltimos 12 meses" } - } - }, - service_dashboard: { - label: "Servicio al cliente", - description: "Carga de casos, salud del SLA y rendimiento de resoluci\xF3n", - widgets: { - open_cases: { title: "Casos abiertos", description: "Casos que a\xFAn no se han cerrado" }, - critical_cases: { title: "Casos cr\xEDticos", description: "Casos abiertos marcados como prioridad cr\xEDtica" }, - avg_resolution_time: { title: "Tiempo medio de resoluci\xF3n", description: "Tiempo medio hasta el cierre, en horas" }, - sla_violations: { title: "Incumplimientos de SLA", description: "Casos que incumplieron su SLA" }, - cases_by_status: { title: "Casos por estado", description: "Distribuci\xF3n de la carga a lo largo del pipeline" }, - cases_by_priority: { title: "Casos por prioridad", description: "Mezcla de casos abiertos por urgencia" }, - cases_by_origin: { title: "Casos por origen", description: "De d\xF3nde provienen nuestros casos" }, - daily_case_volume: { title: "Volumen diario de casos", description: "Casos nuevos creados en los \xFAltimos 30 d\xEDas" }, - sla_compliance_gauge: { title: "Cumplimiento de SLA", description: "Porcentaje de casos resueltos dentro del SLA en este per\xEDodo" }, - kb_deflection_rate: { title: "Tasa de Desv\xEDo por KB", description: "Proporci\xF3n de casos cerrados resueltos con un art\xEDculo de la base de conocimiento" }, - kb_resolved_cases: { title: "Resueltos por KB", description: "Casos cerrados que se\xF1alan el art\xEDculo que los resolvi\xF3" }, - closed_cases_total: { title: "Casos Cerrados", description: "El denominador de la tasa de desv\xEDo" }, - top_resolving_articles: { title: "Art\xEDculos que M\xE1s Resuelven", description: "Art\xEDculos de la base de conocimiento ordenados por los casos cerrados que resolvieron" }, - my_open_cases_by_priority: { title: "Mis casos abiertos por prioridad", description: "Tus casos abiertos y su tasa de incumplimiento de SLA, desglosados por prioridad" } - } - } - }, - // `title` / `subtitle` son las propiedades del componente `page:header`. - // Los marcadores `{…}` se sustituyen sobre la cadena TRADUCIDA, así que el - // token debe conservarse tal cual: traducido, no resuelve y se ve vacío. - datasets: { - account_metrics: { - label: "M\xE9tricas de cuentas", - description: "Capa sem\xE1ntica para el recuento de cuentas por sector y tipo", - dimensions: { - industry: { - label: "Sector" - }, - type: { - label: "Tipo" - }, - created_at: { - label: "Creado" - } - }, - measures: { - account_count: { - label: "Cuentas" - }, - annual_revenue_sum: { - label: "Ingresos anuales" - } - } - }, - case_metrics: { - label: "M\xE9tricas de casos", - description: "Capa sem\xE1ntica para el recuento de casos, el tiempo de resoluci\xF3n y el SLA", - dimensions: { - created_at: { - label: "Creado" - }, - origin: { - label: "Origen" - }, - priority: { - label: "Prioridad" - }, - resolved_article: { - label: "Art\xEDculo de resoluci\xF3n" - }, - status: { - label: "Estado" - }, - type: { - label: "Tipo" - } - }, - measures: { - avg_resolution: { - label: "Resoluci\xF3n media (h)" - }, - avg_sla_violated: { - label: "Tasa de incumplimiento del SLA" - }, - case_count: { - label: "Casos" - }, - closed_count: { - label: "Casos cerrados" - }, - kb_deflection_rate: { - label: "Tasa de desv\xEDo por base de conocimiento" - }, - kb_resolved_count: { - label: "Resueltos por base de conocimiento" - }, - sla_compliance_rate: { - label: "Tasa de cumplimiento del SLA" - }, - sla_met_count: { - label: "Casos dentro del SLA" - } - } - }, - contact_metrics: { - label: "M\xE9tricas de contactos", - description: "Capa sem\xE1ntica para el recuento de contactos", - measures: { - contact_count: { - label: "Contactos" - } - } - }, - event_metrics: { - label: "M\xE9tricas de actividad", - description: "Capa sem\xE1ntica para reuniones, llamadas y recencia de interacci\xF3n", - dimensions: { - owner: { - label: "Propietario" - }, - related_to_type: { - label: "Relacionado con" - }, - start_datetime: { - label: "Semana de actividad" - }, - status: { - label: "Estado" - }, - type: { - label: "Tipo de actividad" - } - }, - measures: { - avg_minutes: { - label: "Duraci\xF3n media" - }, - event_count: { - label: "Actividades" - }, - total_minutes: { - label: "Minutos" - } - } - }, - forecast_metrics: { - label: "M\xE9tricas de previsi\xF3n", - description: "Capa sem\xE1ntica para cuota, cumplimiento y cobertura de pipeline por propietario", - dimensions: { - owner: { - label: "Propietario" - }, - period: { - label: "Tipo de periodo" - }, - period_label: { - label: "Periodo" - }, - period_start: { - label: "Inicio del periodo" - } - }, - measures: { - attainment: { - label: "Cumplimiento" - }, - closed_sum: { - label: "Cerrado" - }, - commit_sum: { - label: "Comprometido" - }, - pipeline_sum: { - label: "Pipeline" - }, - quota_sum: { - label: "Cuota" - } - } - }, - lead_metrics: { - label: "M\xE9tricas de prospectos", - description: "Capa sem\xE1ntica para el recuento de prospectos", - dimensions: { - created_at: { - label: "Creado" - }, - last_contacted_date: { - label: "\xDAltimo contacto" - }, - lead_source: { - label: "Origen" - }, - status: { - label: "Estado" - } - }, - measures: { - lead_count: { - label: "Prospectos" - } - } - }, - opportunity_metrics: { - label: "M\xE9tricas de oportunidades", - description: "Capa sem\xE1ntica para el recuento y los importes del pipeline de ventas", - dimensions: { - account_industry: { - label: "Sector de la cuenta" - }, - close_date: { - label: "Fecha de cierre" - }, - close_quarter: { - label: "Trimestre de cierre" - }, - forecast_category: { - label: "Categor\xEDa de previsi\xF3n" - }, - lead_source: { - label: "Origen del prospecto" - }, - loss_reason: { - label: "Motivo de p\xE9rdida" - }, - owner: { - label: "Propietario" - }, - stage: { - label: "Etapa" - }, - type: { - label: "Tipo de negocio" - }, - win_reason: { - label: "Motivo de ganancia" - } - }, - measures: { - avg_amount: { - label: "Tama\xF1o medio del negocio" - }, - avg_probability: { - label: "Probabilidad media" - }, - decided_count: { - label: "Negocios resueltos" - }, - lost_amount: { - label: "Ingresos perdidos" - }, - lost_count: { - label: "Negocios perdidos" - }, - opp_count: { - label: "Oportunidades" - }, - total_amount: { - label: "Importe total" - }, - win_rate: { - label: "Tasa de ganancia" - }, - won_amount: { - label: "Ingresos ganados" - }, - won_count: { - label: "Negocios ganados" - } - } - }, - product_metrics: { - label: "M\xE9tricas de productos", - description: "Capa sem\xE1ntica para el recuento del cat\xE1logo y el precio de lista", - dimensions: { - category: { - label: "Categor\xEDa" - } - }, - measures: { - list_price_sum: { - label: "Precio de lista total" - }, - product_count: { - label: "Productos" - } - } - }, - task_metrics: { - label: "M\xE9tricas de tareas", - description: "Capa sem\xE1ntica para la carga de trabajo y la finalizaci\xF3n de tareas", - dimensions: { - due_date: { - label: "Fecha de vencimiento" - }, - is_completed: { - label: "Completada" - }, - is_overdue: { - label: "Vencida" - }, - priority: { - label: "Prioridad" - }, - priority_rank: { - label: "Urgencia" - }, - status: { - label: "Estado" - }, - type: { - label: "Tipo" - } - }, - measures: { - avg_progress: { - label: "Progreso medio" - }, - task_count: { - label: "Tareas" - } - } - } - }, - pages: { - account_detail_page: { - label: "Detalle de Cuenta", - description: "P\xE1gina de registro de cuenta por slots: cabecera personalizada + feed de discusi\xF3n permanente.", - title: "{name}", - subtitle: "{industry} \xB7 {type}", - components: { - account_chatter: { label: "Discusi\xF3n" } - } - }, - account_workbench: { - label: "Mesa de Trabajo de Cuentas", - description: "Lista de cuentas curada para el equipo comercial: solo filtros r\xE1pidos, sin gesti\xF3n de vistas." - }, - app_launcher_page: { - label: "Lanzador de Aplicaciones", - description: "Punto de acceso central a todas las aplicaciones", - subtitle: "Seleccione una aplicaci\xF3n para empezar", - components: { - app_search: { label: "Buscar Aplicaciones" }, - app_grid: { label: "Cuadr\xEDcula de Aplicaciones" } - } - }, - case_detail_page: { - label: "Detalle de Caso", - description: "P\xE1gina de caso para el agente de servicio: datos destacados, progreso del SLA, detalles y cronolog\xEDa de actividad.", - title: "{case_number} \xB7 {subject}", - subtitle: "{crm_account}", - components: { - case_highlights: { label: "Informaci\xF3n Clave" }, - case_status_path: { label: "Progreso del Estado del Caso" }, - case_details: { label: "Detalles del Caso" } - } - }, - lead_detail_page: { - label: "Detalle de Prospecto", - description: "P\xE1gina completa de detalle del prospecto, con datos destacados, detalles e informaci\xF3n relacionada", - title: "{first_name} {last_name}", - subtitle: "{company}", - components: { - lead_duplicate_alert_confirmed: { label: "Aviso de duplicado confirmado" }, - lead_duplicate_alert_suspected: { label: "Aviso de duplicado sospechoso" }, - lead_highlights: { label: "Informaci\xF3n Clave" }, - lead_path: { label: "Progreso del Estado del Prospecto" }, - main_tabs: { label: "Pesta\xF1as de Informaci\xF3n del Prospecto" }, - lead_details: { label: "Detalles del Prospecto" }, - related_accordion: { label: "Registros Relacionados" }, - related_tasks: { title: "Tareas Abiertas", label: "Tareas" }, - lead_activity: { label: "Cronolog\xEDa de Actividad" }, - lead_history: { label: "Historial de Campos" } - } - }, - opportunity_detail_page: { - label: "Detalle de Oportunidad", - description: "P\xE1gina completa de detalle de la oportunidad, con recorrido de etapas, datos destacados, detalles y listas relacionadas", - title: "{name}", - subtitle: "{crm_account}", - components: { - opp_highlights: { label: "Informaci\xF3n Clave" }, - opp_stage_path: { label: "Progreso de Etapa de la Oportunidad" }, - opp_details: { label: "Detalles de la Oportunidad" } - } - }, - sales_home_page: { - label: "Inicio de Ventas", - description: "P\xE1gina de inicio del equipo comercial con m\xE9tricas clave y acciones r\xE1pidas", - title: "Panel de Ventas", - subtitle: "Bienvenido de nuevo", - components: { - kpi_revenue_won: { - label: "Ingresos (ganados)" - }, - kpi_deals_won: { - label: "Negocios ganados" - }, - kpi_pipeline_value: { - label: "Valor del pipeline" - }, - kpi_open_leads: { - label: "Prospectos abiertos" - }, - home_upcoming_events: { - label: "\u{1F4C5} Pr\xF3ximos \xB7 M\xE1s cercanos primero" - }, - quick_create: { title: "Creaci\xF3n R\xE1pida", label: "Creaci\xF3n R\xE1pida" }, - key_metrics: { title: "Indicadores Clave de Rendimiento", label: "M\xE9tricas Clave" }, - home_tabs: { label: "Pesta\xF1as de Inicio" }, - home_my_leads: { label: "Mis Prospectos" }, - home_my_deals: { label: "Mis Negocios Abiertos" }, - home_my_tasks: { label: "Mis Tareas Abiertas" }, - ai_briefing: { - title: "Preg\xFAntale al Asistente de IA", - label: "Hoy con el Asistente de IA" - }, - upcoming_events: { title: "Pr\xF3ximos Eventos", label: "Pr\xF3ximos Eventos" } - } - }, - utility_bar_page: { - label: "Barra de Utilidades", - description: "Barra de acceso r\xE1pido con herramientas flotantes", - components: { - notifications_panel: { label: "Notificaciones" }, - quick_notes: { title: "Notas R\xE1pidas", label: "Notas R\xE1pidas" }, - quick_search: { label: "B\xFAsqueda R\xE1pida" } - } - } - }, - // Screen-flow copy (#1210, #1975). Keyed `flows..label`, - // `screens..title` and `screens..fields..{label,placeholder}` - // — the keys `os lint`'s `i18n/missing-flow` names, read by the console's - // flow runner since @objectstack 17.7.0 (the spec's `flows` liveness row is - // `live` there). A screen with no authored `title` shows its flow's label in - // every locale, so each `screen_1.title` repeats the flow label. Since - // 18.0.0-next.0 three more surfaces are keys the engine reads in the run's - // locale, and `i18n/missing-flow` names each missing one: a select field's - // `options.` (worded as the object field's own option in this pack), - // an authored screen `description`, and a refusing `end` node's - // `refusals..message`. A translated description or message is a text - // slot like the one it translates, so a hole in it is `{{ }}`. - // The discount ceiling is interpolated from `QUOTE_DISCOUNT_CEILING`, never - // retyped: the number lives in `_thresholds.ts` alone (#1711). - flows: { - campaign_enrollment: { - label: "Inscribir miembros en la campa\xF1a", - screens: { - screen_1: { - title: "Inscribir miembros en la campa\xF1a", - fields: { - memberSource: { label: "Tipo de miembro a inscribir", options: { leads: "Prospectos", contacts: "Contactos" } }, - leadStatus: { label: "Inscribir prospectos con estado", options: { new: "Nuevo", contacted: "Contactado", qualified: "Calificado" } }, - contactDepartment: { - label: "Inscribir contactos del departamento", - options: { executive: "Ejecutivo", sales: "Ventas", marketing: "Marketing", engineering: "Ingenier\xEDa", support: "Soporte", finance: "Finanzas", hr: "Recursos Humanos", operations: "Operaciones" } - } - } - } - } - }, - escalate_case: { - label: "Escalar Caso", - screens: { screen_1: { title: "Escalar Caso", fields: { reason: { label: "Motivo de Escalaci\xF3n" } } } } - }, - close_case: { - label: "Cerrar Caso", - screens: { - screen_1: { - title: "Cerrar Caso", - fields: { - resolution: { label: "Resoluci\xF3n" }, - resolved_by_article: { label: "Resuelto con art\xEDculo (opcional)" } - } - } - } - }, - claim_case: { - label: "Tomar Caso", - screens: { - screen_1: { - title: "Tomar Caso", - fields: { - claimStatus: { - label: "Estado de trabajo", - options: { in_progress: "En Curso", waiting_customer: "Esperando al Cliente", waiting_support: "Esperando a Soporte" } - } - } - } - } - }, - lead_conversion: { - label: "Proceso de conversi\xF3n de prospecto", - screens: { - screen_1: { - title: "Proceso de conversi\xF3n de prospecto", - // The duplicate warning's text is a variable the flow assigns; this - // key can only carry the hole that shows it. - description: "{{duplicateWarning}}", - fields: { - createOpportunity: { label: "\xBFCrear oportunidad?" }, - opportunityName: { label: "Nombre de Oportunidad" }, - opportunityAmount: { label: "Monto de la Oportunidad" }, - closeDate: { label: "Fecha de Cierre" } - } - }, - refuse_confirmed_duplicate: { - title: "Conversi\xF3n rechazada", - description: "El Estado del Duplicado de este prospecto es Confirmado: un revisor lo compar\xF3 con un registro existente y registr\xF3 que lo repite. Convertirlo crear\xEDa una segunda cuenta, contacto y oportunidad para el mismo comprador. La secci\xF3n Gesti\xF3n de Duplicados de este prospecto indica el registro que se conserva; descalifique este prospecto como duplicado. Solo un revisor que cambie ese veredicto vuelve a habilitar la conversi\xF3n." - }, - refuse_unapproved: { - title: "Conversi\xF3n rechazada", - description: "Este prospecto no ha sido aprobado para la conversi\xF3n. Un aprobador debe darle el visto bueno antes de que pueda convertirse en una cuenta, un contacto y una oportunidad; el campo Aprobaci\xF3n de Conversi\xF3n del prospecto muestra si la decisi\xF3n sigue pendiente o fue rechazada. Mientras tanto, siga trabajando el prospecto: nada de \xE9l queda bloqueado." - }, - refuse_no_match_key: { - title: "Conversi\xF3n rechazada", - description: "La empresa de este prospecto no tiene clave de coincidencia, as\xED que la conversi\xF3n no puede saber a qu\xE9 cuenta pertenece y no lo va a adivinar: una suposici\xF3n podr\xEDa archivar el contacto y la oportunidad bajo otro cliente. Guardar la Empresa del prospecto reconstruye la clave, as\xED que gu\xE1rdela de nuevo y luego convi\xE9rtalo. No se ha creado nada." - } - } - }, - schedule_followup: { - label: "Programar Seguimiento", - screens: { - screen_1: { - title: "Programar Seguimiento", - fields: { - subject: { label: "\xBFCu\xE1l es el siguiente paso?" }, - dueDate: { label: "Fecha L\xEDmite" }, - activityType: { - label: "Tipo de Actividad", - options: { call: "Llamada", email: "Email", meeting: "Reuni\xF3n", follow_up: "Seguimiento", demo: "Demostraci\xF3n", other: "Otro" } - }, - priority: { label: "Prioridad", options: { low: "Baja", normal: "Normal", high: "Alta", urgent: "Urgente" } }, - notes: { label: "Notas" } - } - } - } - }, - quote_generation: { - label: "Generar cotizaci\xF3n desde la oportunidad", - refusals: { refuse_held: { message: "Primero va la aprobaci\xF3n de calificaci\xF3n: marque Solicitar Aprobaci\xF3n de Calificaci\xF3n. No se cre\xF3 nada." } }, - screens: { - screen_1: { - title: "Generar cotizaci\xF3n desde la oportunidad", - fields: { - quoteName: { label: "Nombre de Cotizaci\xF3n" }, - expirationDays: { label: "V\xE1lida por (d\xEDas)" }, - discount: { label: `Descuento % (\u2264 ${QUOTE_DISCOUNT_CEILING})`, placeholder: `0-${QUOTE_DISCOUNT_CEILING}` } - } - } - } - } - } -}; - -// src/sales/translations/es-ES/_shared.ts -var activityActions4 = { - log_call: { - label: "Registrar llamada", - successMessage: "\xA1Llamada registrada exitosamente!", - params: { - subject: { label: "Asunto de la llamada" }, - duration: { label: "Duraci\xF3n (minutos)" }, - attendee_contacts: { label: "Contactos participantes" }, - attendee_users: { label: "Participantes internos" }, - notes: { label: "Notas de la llamada" } - } - }, - log_meeting: { - label: "Registrar reuni\xF3n", - successMessage: "\xA1Reuni\xF3n registrada exitosamente!", - params: { - subject: { label: "Asunto de la reuni\xF3n" }, - duration: { label: "Duraci\xF3n (minutos)" }, - attendee_contacts: { label: "Contactos participantes" }, - attendee_users: { label: "Participantes internos" }, - notes: { label: "Notas de la reuni\xF3n" } - } - }, - schedule_meeting: { - label: "Programar reuni\xF3n", - successMessage: "\xA1Reuni\xF3n programada!", - params: { - subject: { label: "Asunto de la reuni\xF3n" }, - start_date: { label: "Fecha de inicio (UTC)" }, - start_time: { label: "Hora de inicio (UTC)" }, - location: { label: "Ubicaci\xF3n" }, - duration: { label: "Duraci\xF3n (minutos)" }, - attendee_contacts: { label: "Contactos participantes" }, - attendee_users: { label: "Participantes internos" }, - notes: { label: "Agenda" } - } - } -}; - -// src/sales/translations/es-ES/objects.customer.ts -var customer4 = { - crm_account: { - label: "Cuenta", - pluralLabel: "Cuentas", - description: "Empresas y organizaciones con las que mantenemos relaci\xF3n comercial", - fields: { - account_number: { label: "N\xFAmero de Cuenta" }, - registration_number: { - label: "N\xFAmero de Registro", - help: "La identidad registrada de la contraparte, emitida por su propio registro gubernamental. No es el N\xFAmero de Cuenta, que emitimos nosotros." - }, - commercial_capability: { - label: "Capacidad Comercial", - help: "Si se puede abrir nuevo negocio con esta cuenta. Las cuentas de Solo Liquidaci\xF3n siguen siendo utilizables para facturaci\xF3n y pagos, pero no se les puede vincular ninguna oportunidad nueva.", - options: { full: "Completa", settlement_only: "Solo Liquidaci\xF3n" } - }, - incumbent_vendor: { label: "Proveedor Actual", help: "El proveedor que actualmente atiende el gasto que perseguimos en esta cuenta." }, - annual_purchasing_budget: { label: "Presupuesto Anual de Compras", help: "Lo que esta cuenta espera gastar con proveedores este a\xF1o, no sus propios ingresos." }, - payment_cycle: { - label: "Ciclo de Pago", - options: { prepaid: "Prepago", net_30: "30 d\xEDas", net_60: "60 d\xEDas", net_90: "90 d\xEDas" } - }, - approval_status: { - label: "Estado de Aprobaci\xF3n", - help: "En qu\xE9 punto de su aprobaci\xF3n est\xE1 esta cuenta. Una cuenta nueva comienza Pendiente y se decide en la bandeja de aprobaciones.", - options: { pending: "Pendiente", approved: "Aprobada", rejected: "Rechazada" } - }, - name: { label: "Nombre de Cuenta", help: "Nombre legal de la empresa u organizaci\xF3n" }, - name_normalized: { - label: "Nombre de Cuenta (Normalizado)", - help: "Clave de coincidencia para la conversi\xF3n de prospectos: el Nombre de Cuenta en min\xFAsculas, sin espacios sobrantes y con los espacios internos reducidos a uno. Lo mantiene el hook account_protection \u2014 nunca lo edite directamente." - }, - display_title: { label: "T\xEDtulo Mostrado" }, - type: { - label: "Tipo", - // `former` is 'Former Customer' in account.object.ts; the `en` bundle - // had truncated it to 'Former', and translating that truncation gave - // a bare 'Anterior' — an adjective with no noun, next to three option - // labels that are all nouns. - options: { prospect: "Prospecto", customer: "Cliente", partner: "Socio", former: "Cliente Anterior" } - }, - industry: { - label: "Industria", - options: { - technology: "Tecnolog\xEDa", - software: "Software / SaaS", - finance: "Finanzas", - healthcare: "Salud", - retail: "Comercio", - manufacturing: "Manufactura", - education: "Educaci\xF3n", - real_estate: "Inmobiliaria", - media: "Medios y Entretenimiento", - logistics: "Log\xEDstica", - hospitality: "Hosteler\xEDa", - energy: "Energ\xEDa y Servicios P\xFAblicos", - government: "Gobierno", - nonprofit: "Sin \xC1nimo de Lucro", - other: "Otro" - } - }, - annual_revenue: { label: "Ingresos Anuales" }, - child_account_revenue: { label: "Ingresos de Cuentas Hijas", help: "Suma de los ingresos anuales de las cuentas hijas directas." }, - number_of_employees: { label: "N\xFAmero de Empleados" }, - phone: { label: "Tel\xE9fono" }, - website: { label: "Sitio Web" }, - billing_address: { label: "Direcci\xF3n de Facturaci\xF3n" }, - billing_country: { - label: "Pa\xEDs de Facturaci\xF3n", - help: "Derivado de la Direcci\xF3n de Facturaci\xF3n \u2014 el pa\xEDs tal como se introdujo, sin espacios y en may\xFAsculas." - }, - territory: { - label: "Territorio", - help: "Derivado de la Direcci\xF3n de Facturaci\xF3n \u2014 el territorio de ventas que usan las reglas de compartici\xF3n. Las cuentas fuera de los territorios con equipo asignado son Otro.", - options: { na: "Norteam\xE9rica", emea: "EMEA", other: "Otro" } - }, - office_location: { label: "Ubicaci\xF3n de Oficina" }, - owner_id: { label: "Propietario de Cuenta" }, - parent_account: { label: "Cuenta Matriz", help: "Empresa matriz en la jerarqu\xEDa" }, - description: { label: "Descripci\xF3n" }, - is_active: { label: "Activo" }, - last_activity_date: { label: "Fecha de \xDAltima Actividad" }, - brand_color: { label: "Color de Marca" }, - logo: { label: "Logo de la Empresa" }, - tier: { - label: "Nivel de Cliente", - options: { - strategic: "Estrat\xE9gico", - enterprise: "Gran Empresa", - mid_market: "Mediana Empresa", - smb: "PYME" - } - }, - segment: { - label: "Segmento", - options: { - net_new: "Cliente Nuevo", - growth: "Crecimiento", - at_risk: "En Riesgo", - stable: "Estable" - } - }, - health_score: { - label: "\xCDndice de Salud", - help: "Indicador de salud mantenido por el CSM", - options: { - healthy: "Saludable", - watching: "En Observaci\xF3n", - at_risk: "En Riesgo", - churning: "En Fuga" - } - } - }, - _views: { - all_accounts: { - label: "Todas las Cuentas", - description: "Lista maestra de cuentas con ingresos e industria", - bulkActions: { - delete: { - label: "Eliminar", - confirmLabel: "Eliminar", - confirmText: "\xBFEliminar permanentemente {{count}} cuenta(s)? Esta acci\xF3n no se puede deshacer." - }, - transfer_owner: { - label: "Transferir propietario", - confirmText: "\xBFTransferir la propiedad de {{count}} cuenta(s)?", - params: { - owner_id: { - label: "Nuevo propietario" - } - } - }, - update_tier: { - label: "Actualizar nivel", - confirmText: "\xBFActualizar el nivel de {{count}} cuenta(s) a {{tier}}?", - params: { - tier: { - label: "Nivel de cliente" - } - } - } - } - }, - account_gallery: { label: "Galer\xEDa de Cuentas", description: "Vista de tarjetas con colores de marca" }, - account_map: { label: "Mapa de Cuentas", description: "Distribuci\xF3n geogr\xE1fica de cuentas" }, - enterprise_accounts: { label: "Cuentas Empresariales", description: "Cuentas con mayores ingresos anuales" }, - my_accounts: { label: "Mis Cuentas", description: "Cuentas asignadas al usuario actual" }, - at_risk_accounts: { label: "\u26A0\uFE0F Cuentas en Riesgo" } - }, - _sections: { - basic: { label: "Informaci\xF3n B\xE1sica" }, - financials: { label: "Datos Financieros" }, - business_profile: { label: "Perfil de Negocio" }, - contact_info: { label: "Informaci\xF3n de Contacto" }, - ownership: { label: "Propiedad y Estado" }, - branding: { label: "Identidad de Marca" }, - system: { label: "Sistema" }, - // Nombres de sección del formulario en account.view.ts (#1100) - profile: { label: "Perfil" }, - customer_success: { label: "\xC9xito del Cliente" }, - locations: { label: "Ubicaciones" }, - description: { label: "Descripci\xF3n" } - }, - _actions: { ...activityActions4 } - }, - crm_contact: { - label: "Contacto", - pluralLabel: "Contactos", - description: "Personas asociadas a las cuentas", - fields: { - // Mismo juego de valores que `crm_lead.salutation` — tradúzcanse igual. - salutation: { - label: "T\xEDtulo", - options: { mr: "Sr.", ms: "Srta.", mrs: "Sra.", dr: "Dr.", prof: "Prof." } - }, - first_name: { label: "Nombre" }, - last_name: { label: "Apellido" }, - full_name: { label: "Nombre Completo" }, - crm_account: { label: "Cuenta" }, - email: { label: "Correo Electr\xF3nico" }, - phone: { label: "Tel\xE9fono" }, - mobile: { label: "M\xF3vil" }, - title: { label: "Cargo" }, - department: { - label: "Departamento", - options: { - executive: "Ejecutivo", - sales: "Ventas", - marketing: "Marketing", - engineering: "Ingenier\xEDa", - support: "Soporte", - finance: "Finanzas", - hr: "Recursos Humanos", - operations: "Operaciones" - } - }, - // Centro de compra (REQ-0004) — el mapa de la decisión. La etiqueta - // inglesa es 'Buying Function' y no 'Buying Role': la regla - // security-role-word reserva la palabra inglesa `role` en las - // declaraciones (ADR-0090 D3). Esa regla sólo lee inglés y no alcanza - // los paquetes de idioma, así que aquí va el término natural. - buying_function: { - label: "Rol de Compra", - options: { - decision_maker: "Decisor", - economic_buyer: "Comprador Econ\xF3mico", - technical_evaluator: "Evaluador T\xE9cnico", - user: "Usuario", - influencer: "Influenciador", - gatekeeper: "Guardi\xE1n" - } - }, - attitude: { - label: "Actitud hacia Nosotros", - options: { - champion: "Defensor", - supportive: "Favorable", - neutral: "Neutral", - skeptical: "Esc\xE9ptico", - blocker: "Bloqueador" - } - }, - relationship_strength: { - label: "Fuerza de la Relaci\xF3n", - options: { - distant: "Distante", - acquaintance: "Conocido", - working: "Relaci\xF3n de Trabajo", - strong: "Fuerte", - trusted_advisor: "Asesor de Confianza" - } - }, - owner_id: { label: "Propietario de Contacto" }, - description: { label: "Descripci\xF3n" }, - is_primary: { label: "Contacto Principal", help: "\xBFEs este el contacto principal de la cuenta?" }, - avatar: { label: "Foto de Perfil" }, - mailing_address: { label: "Direcci\xF3n de Correo" }, - // Juego compartido con `crm_lead.lead_source` y - // `crm_opportunity.lead_source` — los tres deben coincidir literalmente. - lead_source: { - label: "Origen del Prospecto", - options: { - web: "Web", - referral: "Referencia", - event: "Evento / Feria", - webinar: "Seminario Web", - partner: "Socio", - advertisement: "Publicidad", - paid_search: "B\xFAsqueda de Pago", - social: "Redes Sociales", - content: "Contenido / Blog", - cold_call: "Llamada en Fr\xEDo", - email_campaign: "Campa\xF1a de Email", - other: "Otro" - } - }, - do_not_call: { label: "No Llamar" }, - email_opt_out: { label: "Excluir de Correos" }, - last_contacted_date: { label: "\xDAltimo contacto" } - }, - _views: { - all_contacts: { label: "Todos los Contactos" }, - contact_directory: { label: "Directorio de Contactos" }, - primary_contacts: { label: "Contactos Principales" } - }, - _sections: { - identity: { label: "Identidad" }, - account_info: { label: "Cuenta y Cargo" }, - buying_centre: { label: "Centro de Compra" }, - contact_info: { label: "Informaci\xF3n de Contacto" }, - mailing_address: { label: "Direcci\xF3n de Correo" }, - additional: { label: "Informaci\xF3n Adicional" }, - preferences: { label: "Preferencias de Comunicaci\xF3n" }, - // Nombres de sección del formulario en contact.view.ts (#1100) - contact_details: { label: "Informaci\xF3n de Contacto" }, - comm_preferences: { label: "Preferencias" } - }, - _actions: { - ...activityActions4, - mark_primary: { - label: "Marcar como Principal", - confirmText: "\xBFEstablecer este contacto como contacto principal de la cuenta?", - successMessage: "\xA1Establecido como contacto principal!" - }, - send_email: { - label: "Enviar Correo", - params: { - subject: { label: "Asunto" }, - body: { label: "Cuerpo" } - } - }, - add_contact_to_campaign: { - label: "A\xF1adir a Campa\xF1a", - successMessage: "\xA1Contactos a\xF1adidos a la campa\xF1a!", - params: { - crm_campaign: { label: "Campa\xF1a" } - } - } - } - } -}; - -// src/sales/translations/es-ES/objects.pipeline.ts -var pipeline4 = { - crm_lead: { - _validations: { - disqualification_reason_required: { - message: "El motivo de descalificaci\xF3n es obligatorio cuando un prospecto no est\xE1 cualificado" - }, - duplicate_disqualification_requires_survivor: { - message: "Descalificar un prospecto como duplicado exige nombrar el registro superviviente y marcar el estado de duplicado como Confirmado" - }, - email_required: { - message: "El correo electr\xF3nico es obligatorio" - }, - lead_status_progression: { - message: "Transici\xF3n de estado de prospecto no v\xE1lida" - } - }, - label: "Prospecto", - pluralLabel: "Prospectos", - description: "Clientes potenciales todav\xEDa sin calificar", - fields: { - first_name: { label: "Nombre" }, - last_name: { label: "Apellido" }, - company: { label: "Empresa" }, - company_normalized: { - label: "Empresa (Normalizado)", - help: "Clave de coincidencia para la conversi\xF3n de prospectos: la Empresa en min\xFAsculas, sin espacios sobrantes y con los espacios internos reducidos a uno. Lo mantiene el hook lead_duplicate_check \u2014 nunca lo edite directamente." - }, - display_title: { label: "T\xEDtulo Mostrado" }, - title: { label: "Cargo" }, - email: { label: "Correo Electr\xF3nico" }, - phone: { label: "Tel\xE9fono" }, - status: { - label: "Estado", - options: { - new: "Nuevo", - contacted: "Contactado", - qualified: "Calificado", - unqualified: "No Calificado", - converted: "Convertido" - } - }, - lead_source: { - label: "Origen del Prospecto", - options: { - web: "Web", - referral: "Referencia", - event: "Evento / Feria", - webinar: "Seminario Web", - partner: "Socio", - advertisement: "Publicidad", - paid_search: "B\xFAsqueda de Pago", - social: "Redes Sociales", - content: "Contenido / Blog", - cold_call: "Llamada en Fr\xEDo", - email_campaign: "Campa\xF1a de Email", - other: "Otro" - } - }, - owner_id: { label: "Propietario" }, - is_converted: { label: "Convertido" }, - description: { label: "Descripci\xF3n" }, - // Mismo juego de valores que `crm_contact.salutation` — tradúzcanse igual. - salutation: { - label: "Tratamiento", - options: { mr: "Sr.", ms: "Srta.", mrs: "Sra.", dr: "Dr.", prof: "Prof." } - }, - full_name: { label: "Nombre Completo" }, - // Los 15 valores son los mismos que en `crm_account.industry` — deben - // coincidir literalmente entre ambas pantallas. - industry: { - label: "Industria", - options: { - technology: "Tecnolog\xEDa", - software: "Software / SaaS", - finance: "Finanzas", - healthcare: "Salud", - retail: "Comercio", - manufacturing: "Manufactura", - education: "Educaci\xF3n", - real_estate: "Inmobiliaria", - media: "Medios y Entretenimiento", - logistics: "Log\xEDstica", - hospitality: "Hosteler\xEDa", - energy: "Energ\xEDa y Servicios P\xFAblicos", - government: "Gobierno", - nonprofit: "Sin \xC1nimo de Lucro", - other: "Otro" - } - }, - mobile: { label: "M\xF3vil" }, - website: { label: "Sitio Web" }, - rating: { label: "Puntuaci\xF3n de Prospecto", help: "Puntuaci\xF3n de calidad del prospecto (1-5 estrellas)" }, - next_followup_date: { label: "Pr\xF3xima Fecha de Seguimiento" }, - last_contacted_date: { label: "\xDAltimo Contacto" }, - need_type: { - label: "Tipo de Necesidad", - help: "Qu\xE9 est\xE1 pidiendo este prospecto. La asignaci\xF3n, la priorizaci\xF3n y los informes de demanda leen este campo.", - options: { - new_implementation: "Nueva Implantaci\xF3n", - expansion: "Ampliaci\xF3n", - replacement: "Sustituci\xF3n", - renewal: "Renovaci\xF3n", - consulting: "Consultor\xEDa", - support: "Soporte y Mantenimiento", - other: "Otro" - } - }, - estimated_amount: { - label: "Importe Estimado", - help: "Valor estimado de esta necesidad, antes de la cualificaci\xF3n. Precarga el importe de la oportunidad al convertir." - }, - conversion_approval_status: { - label: "Aprobaci\xF3n de Conversi\xF3n", - help: "Si este prospecto tiene el visto bueno para convertirse. \xABNo Requerida\xBB significa que no se pide aprobaci\xF3n: es el valor predeterminado de f\xE1brica.", - options: { - not_required: "No Requerida", - pending: "Pendiente", - approved: "Aprobada", - rejected: "Rechazada" - } - }, - converted_account: { label: "Cuenta Convertida" }, - converted_contact: { label: "Contacto Convertido" }, - converted_opportunity: { label: "Oportunidad Convertida" }, - converted_date: { label: "Fecha de Conversi\xF3n" }, - address: { label: "Direcci\xF3n" }, - annual_revenue: { label: "Ingresos Anuales" }, - number_of_employees: { label: "N\xFAmero de Empleados" }, - notes: { label: "Notas", help: "Notas de trabajo sobre este cliente potencial: admite formato." }, - do_not_call: { label: "No Llamar" }, - email_opt_out: { label: "Excluir de Correos" }, - disqualification_reason: { - label: "Motivo de No Calificaci\xF3n", - help: "Obligatorio cuando el estado es No Calificado", - options: { - not_a_fit: "No Encaja", - no_budget: "Sin Presupuesto", - wrong_persona: "Perfil Incorrecto", - unreachable: "Ilocalizable", - duplicate: "Duplicado", - competitor: "Competidor", - other: "Otro" - } - }, - duplicate_of_type: { - label: "Duplicado De", - help: "Qu\xE9 objeto contiene el registro superviviente que este prospecto repite.", - // `erased` es una lápida, no una opción: el formulario no la ofrece - // (ver `src/sales/views/lead.view.ts`), pero un prospecto cuyo superviviente - // fue eliminado la lleva, así que necesita etiqueta allí donde el - // registro se LEE; sin traducir se mostraría el valor crudo `erased`. - options: { crm_lead: "Prospecto", crm_contact: "Contacto", erased: "Registro Eliminado" } - }, - duplicate_of_lead: { label: "Prospecto Duplicado" }, - duplicate_of_contact: { label: "Contacto Duplicado" }, - duplicate_status: { - label: "Estado del Duplicado", - help: "Sospechoso = marcado autom\xE1ticamente en la captura. Confirmado = una persona verific\xF3 la coincidencia.", - options: { suspected: "Sospechoso", confirmed: "Confirmado" } - } - }, - _views: { - all_leads: { - label: "Todos los Prospectos", - emptyState: { title: "Todav\xEDa no hay prospectos", message: "Empiece creando su primer prospecto" } - }, - kanban_by_status: { label: "Pipeline de Prospectos" }, - calendar_by_created: { label: "Calendario de Prospectos" }, - gallery_view: { label: "Galer\xEDa de Prospectos" }, - my_leads: { label: "Mis Prospectos" }, - high_priority: { label: "Alta Prioridad" }, - hot_leads: { label: "\u{1F525} Prospectos Calientes" }, - suspected_duplicates: { - label: "Duplicados Sospechosos", - emptyState: { - title: "Sin duplicados sospechosos", - message: "Nada que revisar: se han comprobado todos los correos recapturados." - } - } - }, - _sections: { - // Claves de sección del objeto (lead.object.ts) que usan los - // formularios de registro y la página de detalle, cuyas secciones - // hacen referencia a estos grupos (#806). - address: { label: "Direcci\xF3n" }, - identity: { label: "Identidad" }, - company_info: { label: "Informaci\xF3n de la Empresa" }, - contact_info: { label: "Informaci\xF3n de Contacto" }, - qualification: { label: "Calificaci\xF3n" }, - assignment: { label: "Asignaci\xF3n" }, - conversion: { label: "Conversi\xF3n" }, - additional: { label: "Informaci\xF3n Adicional" }, - preferences: { label: "Preferencias de Comunicaci\xF3n" }, - duplicates: { label: "Gesti\xF3n de Duplicados" }, - // Nombres de sección del formulario en lead.view.ts (#1100) — aquí - // viven las secciones del formulario por defecto y las de cada formView - // con nombre: si se añade un formulario allí, se añaden aquí sus - // nombres de sección. - contact_information: { label: "Informaci\xF3n de Contacto" }, - lead_classification: { label: "Clasificaci\xF3n del Lead" }, - company_information: { label: "Informaci\xF3n de la Empresa" }, - additional_information: { label: "Informaci\xF3n Adicional" }, - privacy: { label: "Privacidad" }, - general: { label: "General" }, - details: { label: "Detalles" }, - step_1_contact_details: { label: "Paso 1: Datos de Contacto" }, - step_2_company_information: { label: "Paso 2: Informaci\xF3n de la Empresa" }, - step_3_qualification: { label: "Paso 3: Calificaci\xF3n" }, - step_4_review_and_convert: { label: "Paso 4: Revisar y Convertir" }, - primary_information: { label: "Informaci\xF3n Principal" }, - extended_details: { label: "Detalles Ampliados" }, - quick_edit: { label: "Edici\xF3n R\xE1pida" }, - update_lead_status: { label: "Actualizar Estado del Lead" }, - tell_us_about_yourself: { label: "Cu\xE9ntanos sobre ti" }, - about_your_company: { label: "Sobre tu empresa" }, - how_can_we_help: { label: "\xBFC\xF3mo podemos ayudarte?" }, - lead_information: { label: "Informaci\xF3n del Lead" }, - address_information: { label: "Informaci\xF3n de Direcci\xF3n" }, - privacy_preferences: { label: "Preferencias de Privacidad" } - }, - _actions: { - ...activityActions4, - convert_lead: { - label: "Convertir Prospecto", - successMessage: "\xA1Prospecto convertido con \xE9xito!" - }, - create_campaign: { - label: "Agregar a Campa\xF1a", - successMessage: "\xA1Prospecto agregado a la campa\xF1a!", - params: { - crm_campaign: { label: "Campa\xF1a" } - } - }, - schedule_followup: { - label: "Programar Seguimiento", - successMessage: "Seguimiento programado." - } - } - }, - crm_opportunity: { - _validations: { - amount_positive: { - message: "El importe debe ser mayor que cero" - }, - close_date_future: { - message: "La fecha de cierre no deber\xEDa estar en el pasado salvo que la oportunidad est\xE9 cerrada" - }, - opportunity_stage_progression: { - message: "Transici\xF3n de etapa de oportunidad no v\xE1lida" - } - }, - label: "Oportunidad", - pluralLabel: "Oportunidades", - description: "Oportunidades de venta y negocios en el pipeline", - fields: { - name: { label: "Nombre de Oportunidad" }, - crm_account: { label: "Cuenta" }, - primary_contact: { label: "Contacto Principal" }, - owner_id: { label: "Propietario de Oportunidad" }, - amount: { label: "Monto" }, - expected_revenue: { label: "Ingreso Esperado" }, - stage: { - label: "Etapa", - options: { - prospecting: "Prospecci\xF3n", - qualification: "Calificaci\xF3n", - needs_analysis: "An\xE1lisis de Necesidades", - proposal: "Propuesta", - negotiation: "Negociaci\xF3n", - closed_won: "Cerrada Ganada", - closed_lost: "Cerrada Perdida" - } - }, - probability: { label: "Probabilidad (%)" }, - close_date: { label: "Fecha de Cierre" }, - type: { - label: "Tipo", - options: { - new_business: "Nuevo Negocio", - existing_upgrade: "Cliente Existente - Mejora", - existing_renewal: "Cliente Existente - Renovaci\xF3n", - existing_expansion: "Cliente Existente - Expansi\xF3n" - } - }, - forecast_category: { - label: "Categor\xEDa de Pron\xF3stico", - options: { - pipeline: "Pipeline", - best_case: "Mejor Caso", - commit: "Compromiso", - omitted: "Omitida", - closed: "Cerrada" - } - }, - description: { label: "Descripci\xF3n" }, - next_step: { label: "Pr\xF3ximo Paso" }, - lead_source: { - label: "Origen del Prospecto", - options: { - web: "Web", - referral: "Referencia", - event: "Evento / Feria", - webinar: "Seminario Web", - partner: "Socio", - advertisement: "Publicidad", - paid_search: "B\xFAsqueda de Pago", - social: "Redes Sociales", - content: "Contenido / Blog", - cold_call: "Llamada en Fr\xEDo", - email_campaign: "Campa\xF1a de Email", - other: "Otro" - } - }, - crm_campaign: { label: "Campa\xF1a", help: "Campa\xF1a de marketing que gener\xF3 esta oportunidad" }, - days_in_stage: { label: "D\xEDas en Etapa Actual" }, - stage_entry_date: { label: "Fecha de Entrada a la Etapa", help: "Fecha en la que esta oportunidad entr\xF3 en su etapa actual." }, - is_private: { label: "Privado" }, - approval_status: { - label: "Estado de Aprobaci\xF3n", - options: { - not_required: "No Requerida", - pending: "Pendiente", - approved: "Aprobada", - rejected: "Rechazada" - } - }, - approved_date: { label: "Fecha de Aprobaci\xF3n" }, - // #593 — obligatorias al cerrar la oportunidad, y el desglose de - // motivos de pérdida las muestra en el panel de ventas, así que el - // valor almacenado nunca debe llegar crudo al selector. - win_reason: { - label: "Motivo de Ganancia", - help: "Por qu\xE9 se gan\xF3 este negocio. Obligatorio para cerrar una oportunidad como Ganada.", - options: { - better_product: "Mejor Producto", - better_price: "Mejor Precio", - relationship: "Relaci\xF3n Existente", - better_support: "Mejor Soporte", - best_fit: "Mejor Ajuste / Funcionalidades", - quote_accepted: "Cotizaci\xF3n Aceptada", - other: "Otro" - } - }, - loss_reason: { - label: "Motivo de P\xE9rdida", - help: "Por qu\xE9 se perdi\xF3 este negocio. Obligatorio para cerrar una oportunidad como Perdida.", - options: { - price: "Precio Demasiado Alto", - competitor: "Perdida ante Competidor", - no_budget: "Sin Presupuesto", - no_decision: "Sin Decisi\xF3n", - timing: "Momento Inadecuado", - features: "Funcionalidades Faltantes", - other: "Otro" - } - }, - loss_details: { - label: "Detalles de Ganancia/P\xE9rdida", - help: "Contexto en texto libre detr\xE1s del motivo de ganancia o p\xE9rdida." - }, - // REQ-0006 — calificación, calendario de compra del cliente, narrativa - // del negocio, línea de negocio y aprobación del cambio de estado. - will_bid: { - label: "Presentaremos Oferta", - help: "Si tenemos intenci\xF3n de presentar oferta. Sin valor significa que la decisi\xF3n sigue abierta." - }, - controllability: { label: "Controlabilidad", options: { high: "Alta", medium: "Media", low: "Baja" } }, - priority: { label: "Prioridad", options: { high: "Alta", medium: "Media", low: "Baja" } }, - deal_level: { label: "Nivel del Negocio", options: { strategic: "Estrat\xE9gico", key: "Clave", standard: "Est\xE1ndar" } }, - is_subcontracted: { label: "Incluye Subcontrataci\xF3n" }, - subcontracting_note: { label: "Nota de Subcontrataci\xF3n" }, - customer_initiation_date: { label: "Fecha de Inicio del Proyecto (Cliente)" }, - expected_tender_date: { label: "Fecha Prevista de Licitaci\xF3n" }, - expected_signing_date: { label: "Fecha Prevista de Firma" }, - expected_tender_amount: { label: "Importe Previsto de Licitaci\xF3n" }, - expected_signing_amount: { label: "Importe Previsto de Firma" }, - business_line: { - label: "L\xEDnea de Negocio", - options: { - product: "Producto", - services: "Servicios Profesionales", - consulting: "Consultor\xEDa", - support: "Soporte y Mantenimiento", - other: "Otro" - } - }, - customer_background: { label: "Antecedentes del Cliente" }, - project_background: { label: "Antecedentes del Proyecto" }, - risk_analysis: { label: "An\xE1lisis de Riesgos" }, - payment_terms: { label: "Condiciones de Pago" }, - requested_status: { label: "Estado Solicitado", options: { closed_won: "Ganada", closed_lost: "Perdida" } }, - status_change_approval_status: { - label: "Aprobaci\xF3n del Cambio de Estado", - options: { - not_required: "No Requerida", - pending: "Pendiente", - approved: "Aprobada", - rejected: "Rechazada" - } - }, - // REQ-0006 paso 11 — la aprobación de calificación (立项). - qualification_requested: { - label: "Solicitar Aprobaci\xF3n de Calificaci\xF3n", - help: "M\xE1rquelo para enviar este negocio a aprobaci\xF3n de calificaci\xF3n. Un rechazo lo desmarca; vuelva a marcarlo para solicitarla de nuevo." - }, - qualification_approval_status: { - label: "Aprobaci\xF3n de Calificaci\xF3n", - options: { - not_required: "No Requerida", - pending: "Pendiente", - approved: "Aprobada", - rejected: "Rechazada" - } - } - }, - _views: { - tender_this_quarter: { - label: "Licitaciones de Este Trimestre", - emptyState: { - title: "No hay licitaciones previstas este trimestre", - message: "Esta pesta\xF1a muestra los negocios abiertos cuya fecha de licitaci\xF3n del cliente cae dentro del trimestre actual. Registra la Fecha Prevista de Licitaci\xF3n en un negocio para verlo aqu\xED." - } - }, - open_opportunities: { label: "Oportunidades Abiertas" }, - all_opportunities: { label: "Todas las Oportunidades" }, - pipeline_kanban: { label: "Pipeline de Ventas" }, - close_date_calendar: { label: "Calendario de Pron\xF3stico" }, - deal_timeline: { label: "L\xEDnea de Tiempo" }, - deal_gallery: { label: "Galer\xEDa de Negocios" }, - my_open_deals: { label: "Mis Negocios Abiertos" }, - closing_this_quarter: { - label: "Cierres de Este Trimestre", - emptyState: { - title: "No hay negocios que cierren este trimestre", - message: "Esta pesta\xF1a muestra los negocios abiertos en categor\xEDa Compromiso o Mejor Caso cuya fecha de cierre cae dentro del trimestre actual. Ahora mismo no hay ninguno; los negocios que cierran m\xE1s adelante est\xE1n en la pesta\xF1a Negocios Abiertos." - } - }, - stale_opportunities: { label: "\u26A0\uFE0F Oportunidades Estancadas \xB7 M\xE1s Tiempo en Etapa Primero" } - }, - _sections: { - // Claves de sección del objeto (opportunity.object.ts) que usan los - // formularios de registro y la página de detalle, cuyas secciones - // hacen referencia a estos grupos (#1452). - // - // `crm_forecast` es la clave del grupo de campos («Forecast & Metrics» - // en inglés). Esta traducción es anterior a #1452, cuando una sección - // de la página de detalle con el mismo nombre se titulaba «Stage & - // Forecast»; desde entonces solo la lee el grupo. - crm_forecast: { label: "Etapa y Previsi\xF3n" }, - basic: { label: "Informaci\xF3n B\xE1sica" }, - financials: { label: "Datos Financieros" }, - sales_process: { label: "Proceso de Venta" }, - classification: { label: "Clasificaci\xF3n" }, - campaign: { label: "Campa\xF1as" }, - notes: { label: "Notas y Pr\xF3ximos Pasos" }, - qualification: { label: "Calificaci\xF3n" }, - narrative: { label: "Narrativa del Negocio" }, - // Nombres de sección del formulario en opportunity.view.ts (#1100) - overview: { label: "Resumen" }, - forecast: { label: "Previsi\xF3n" }, - sales_strategy: { label: "Estrategia de Ventas" }, - win_loss: { label: "Ganada / Perdida" } - }, - _actions: { - ...activityActions4, - clone_opportunity: { - label: "Clonar Oportunidad", - successMessage: "\xA1Oportunidad clonada con \xE9xito!" - }, - mass_update_stage: { - label: "Actualizar Etapa", - successMessage: "\xA1Etapa de oportunidad actualizada!", - params: { - // Mismos valores que `fields.stage` — deben coincidir literalmente. - stage: { - label: "Nueva Etapa", - options: { - prospecting: "Prospecci\xF3n", - qualification: "Calificaci\xF3n", - needs_analysis: "An\xE1lisis de Necesidades", - proposal: "Propuesta", - negotiation: "Negociaci\xF3n", - closed_won: "Cerrada Ganada", - closed_lost: "Cerrada Perdida" - } - } - } - }, - generate_quote: { - label: "Generar Cotizaci\xF3n", - successMessage: "\xA1Cotizaci\xF3n creada desde la oportunidad!" - } - } - }, - crm_opportunity_line_item: { - _validations: { - unit_price_positive: { - message: "El precio de venta no puede ser negativo" - } - }, - label: "L\xEDnea de Oportunidad", - pluralLabel: "L\xEDneas de Oportunidad", - description: "L\xEDneas de precio por producto dentro de una oportunidad", - fields: { - crm_opportunity: { label: "Oportunidad" }, - crm_product: { label: "Producto" }, - description: { label: "Descripci\xF3n" }, - quantity: { label: "Cantidad" }, - list_price: { label: "Precio de Lista", help: "Se rellena autom\xE1ticamente desde el Precio de Lista del producto." }, - unit_price: { label: "Precio de Venta", help: "Precio unitario negociado (puede diferir del precio de lista)" }, - discount: { label: "Descuento (%)" }, - total_price: { label: "Total" }, - line_number: { label: "N\xBA de L\xEDnea" } - }, - _sections: { - basic: { label: "L\xEDnea" }, - pricing: { label: "Precios" } - } - }, - crm_forecast: { - _validations: { - period_end_after_start: { - message: "El fin del periodo debe ser posterior a su inicio." - }, - period_end_matches_calendar_period: { - message: "El fin del periodo debe ser el \xFAltimo d\xEDa del periodo: p. ej. 2026-09-30 para un trimestre que empieza el 2026-07-01, o 2026-08-31 para agosto de 2026." - }, - period_start_first_of_period: { - message: "El inicio del periodo debe ser el primer d\xEDa del periodo: p. ej. 2026-08-01 para agosto de 2026." - }, - quarter_starts_on_quarter_boundary: { - message: "Una previsi\xF3n trimestral debe comenzar en un l\xEDmite de trimestre: 1 de enero, 1 de abril, 1 de julio o 1 de octubre." - }, - snapshot_amounts_non_negative: { - message: "Los importes de la instant\xE1nea no pueden ser negativos." - } - }, - label: "Previsi\xF3n", - pluralLabel: "Previsiones", - description: "Instant\xE1nea peri\xF3dica del pipeline por propietario para previsi\xF3n de ingresos", - fields: { - owner_id: { label: "Propietario" }, - period: { label: "Periodo", options: { month: "Mes", quarter: "Trimestre" } }, - period_start: { - label: "Inicio del periodo", - help: "Debe ser el primer d\xEDa del periodo \u2014 p. ej. 2026-08-01 para agosto de 2026. Adem\xE1s, una previsi\xF3n trimestral debe comenzar en un l\xEDmite de trimestre: 1 de enero, 1 de abril, 1 de julio o 1 de octubre." - }, - period_end: { - label: "Fin del periodo", - help: "Normalmente se calcula autom\xE1ticamente a partir de Periodo e Inicio del periodo. Si se introduce a mano, debe ser el \xFAltimo d\xEDa de ese periodo \u2014 p. ej. 2026-09-30 para un trimestre que empieza el 2026-07-01, o 2026-08-31 para agosto de 2026." - }, - period_label: { label: "Periodo", help: "Etiqueta legible, p. ej. \xABT3 2026\xBB o \xABAgo 2026\xBB." }, - display_title: { label: "T\xEDtulo Mostrado" }, - snapshot_date: { label: "Fecha de instant\xE1nea", help: "El d\xEDa en que se captur\xF3 esta instant\xE1nea." }, - source: { - label: "Origen", - options: { scheduled: "Instant\xE1nea programada", ai: "Skill de IA", manual: "Entrada manual" } - }, - quota: { label: "Cuota" }, - pipeline_amount: { label: "Pipeline", help: "Suma de todas las oportunidades abiertas que cierran en este periodo (en cualquier etapa)." }, - best_case_amount: { label: "Mejor caso", help: "Oportunidades abiertas en la categor\xEDa de pron\xF3stico Mejor caso o Compromiso." }, - commit_amount: { label: "Compromiso", help: "Oportunidades abiertas en la categor\xEDa de pron\xF3stico Compromiso (comprometidas por el propietario)." }, - closed_amount: { label: "Cerrado", help: "Importe ya cerrado ganado en este periodo." }, - expected_amount: { label: "Esperado", help: "Cerrado + Compromiso: lo que el propietario espera razonablemente cerrar." }, - attainment_pct: { label: "Cumplimiento %", help: "Cerrado \xF7 Cuota \xD7 100. Muestra 0 % hasta que se fija una cuota positiva." }, - coverage_ratio: { label: "Cobertura", help: "Pipeline \xF7 (Cuota \u2212 Cerrado): si queda pipeline suficiente para cubrir la diferencia. Muestra 0 cuando ya se ha alcanzado la cuota." }, - notes: { label: "Notas" }, - seed_key: { - label: "Clave de semilla", - help: "Identidad del juego de datos de demostraci\xF3n. Solo la escribe el cargador de semillas; est\xE1 vac\xEDa en cualquier instant\xE1nea real." - } - }, - _views: { - all_forecasts: { label: "Todas las previsiones" }, - this_quarter_forecasts: { - label: "Este trimestre", - emptyState: { - title: "A\xFAn no hay instant\xE1neas de este trimestre", - message: "Las instant\xE1neas trimestrales las escribe el barrido nocturno de previsiones. Hasta que se ejecute una vez para el trimestre actual, esta vista est\xE1 vac\xEDa; los trimestres cerrados est\xE1n en la pesta\xF1a Todas." - } - }, - my_forecast: { label: "Mi previsi\xF3n" } - }, - _sections: { - basic: { label: "Instant\xE1nea" }, - amounts: { label: "Importes" }, - meta: { label: "Origen" }, - // Nombres de sección del formulario en forecast.view.ts (#1100) - snapshot: { label: "Instant\xE1nea" }, - notes: { label: "Notas" } - } - } -}; - -// src/sales/translations/es-ES/objects.commerce.ts -var commerce4 = { - crm_quote: { - _validations: { - discount_within_ceiling: { - message: "El descuento no puede superar el 60 %" - }, - expiration_after_quote: { - message: "La fecha de vencimiento debe ser posterior a la de la cotizaci\xF3n" - }, - quote_status_progression: { - message: "Transici\xF3n de estado de cotizaci\xF3n no v\xE1lida" - } - }, - label: "Cotizaci\xF3n", - pluralLabel: "Cotizaciones", - description: "Cotizaciones de precios para clientes", - fields: { - quote_number: { label: "N\xFAmero de Cotizaci\xF3n" }, - display_title: { label: "T\xEDtulo Mostrado" }, - name: { label: "Nombre de Cotizaci\xF3n" }, - crm_account: { label: "Cuenta" }, - crm_contact: { - label: "Contacto", - help: "Obligatorio en cuanto la cotizaci\xF3n pasa a Presentada o Aceptada: el contrato generado toma de aqu\xED su Contacto principal." - }, - crm_opportunity: { label: "Oportunidad" }, - owner_id: { label: "Propietario de Cotizaci\xF3n" }, - status: { - label: "Estado", - options: { - draft: "Borrador", - in_review: "En Revisi\xF3n", - presented: "Presentada", - accepted: "Aceptada", - rejected: "Rechazada", - expired: "Expirada" - } - }, - quote_date: { label: "Fecha de Cotizaci\xF3n" }, - expiration_date: { label: "Fecha de Expiraci\xF3n" }, - subtotal: { label: "Subtotal" }, - discount: { label: "Descuento %" }, - discount_amount: { label: "Monto de Descuento" }, - tax: { label: "Impuesto" }, - shipping_handling: { label: "Env\xEDo y Manipulaci\xF3n" }, - total_price: { label: "Precio Total" }, - // Mismo juego de valores que `crm_contract.payment_terms` — tradúzcanse igual. - payment_terms: { - label: "T\xE9rminos de Pago", - options: { - net_15: "Neto 15", - net_30: "Neto 30", - net_60: "Neto 60", - net_90: "Neto 90", - due_on_receipt: "Pago a la Recepci\xF3n" - } - }, - shipping_terms: { label: "T\xE9rminos de Env\xEDo" }, - billing_address: { label: "Direcci\xF3n de Facturaci\xF3n" }, - shipping_address: { label: "Direcci\xF3n de Env\xEDo" }, - description: { label: "Descripci\xF3n" }, - internal_notes: { label: "Notas Internas" } - }, - _views: { - all_quotes: { label: "Todas las Cotizaciones" }, - quote_pipeline: { label: "Pipeline de Cotizaciones" }, - quote_calendar: { label: "Calendario de Cotizaciones" } - }, - _sections: { - basic: { label: "Informaci\xF3n de la Cotizaci\xF3n" }, - pricing: { label: "Precios" }, - terms: { label: "T\xE9rminos y Vigencia" }, - address: { label: "Direcciones" }, - system: { label: "Sistema" }, - // Nombres de sección del formulario en quote.view.ts (#1100) - quote: { label: "Cotizaci\xF3n" }, - totals: { label: "Totales" }, - quote_terms: { label: "T\xE9rminos" }, - addresses_and_notes: { label: "Direcciones y Notas" } - } - }, - crm_quote_line_item: { - _validations: { - discount_within_ceiling: { - message: "El descuento de l\xEDnea no puede superar el 60 %" - }, - unit_price_positive: { - message: "El precio de venta no puede ser negativo" - } - }, - label: "L\xEDnea de Cotizaci\xF3n", - pluralLabel: "L\xEDneas de Cotizaci\xF3n", - description: "L\xEDneas de precio por producto dentro de una cotizaci\xF3n", - fields: { - crm_quote: { label: "Cotizaci\xF3n" }, - crm_product: { label: "Producto" }, - description: { label: "Descripci\xF3n" }, - quantity: { label: "Cantidad" }, - list_price: { label: "Precio de Lista" }, - unit_price: { label: "Precio de Venta" }, - discount: { label: "Descuento (%)" }, - subtotal: { label: "Subtotal" }, - total_price: { label: "Total" }, - line_number: { label: "N\xBA de L\xEDnea" } - }, - _sections: { - basic: { label: "L\xEDnea" }, - pricing: { label: "Precios" } - } - }, - crm_contract: { - _validations: { - end_after_start: { - message: "La fecha de fin debe ser posterior a la de inicio" - }, - contract_status_progression: { - message: "Transici\xF3n de estado de contrato no v\xE1lida" - } - }, - label: "Contrato", - pluralLabel: "Contratos", - description: "Contratos y acuerdos legales", - fields: { - contract_number: { label: "N\xFAmero de Contrato" }, - crm_account: { label: "Cuenta" }, - crm_contact: { label: "Contacto Principal" }, - crm_opportunity: { label: "Oportunidad Relacionada" }, - owner_id: { label: "Propietario del Contrato" }, - status: { - label: "Estado", - options: { - draft: "Borrador", - in_approval: "En Aprobaci\xF3n", - activated: "Activado", - expired: "Expirado", - terminated: "Rescindido" - } - }, - contract_term_months: { label: "Plazo del Contrato (Meses)" }, - start_date: { label: "Fecha de Inicio" }, - end_date: { label: "Fecha de Fin" }, - contract_value: { label: "Valor del Contrato" }, - billing_frequency: { - label: "Frecuencia de Facturaci\xF3n", - options: { monthly: "Mensual", quarterly: "Trimestral", annually: "Anual", one_time: "Pago \xDAnico" } - }, - // Mismo juego de valores que `crm_quote.payment_terms` — tradúzcanse igual. - payment_terms: { - label: "T\xE9rminos de Pago", - options: { - net_15: "Neto 15", - net_30: "Neto 30", - net_60: "Neto 60", - net_90: "Neto 90", - due_on_receipt: "Pago a la Recepci\xF3n" - } - }, - auto_renewal: { label: "Renovaci\xF3n Autom\xE1tica" }, - renewal_notice_days: { label: "Aviso de Renovaci\xF3n (D\xEDas)" }, - contract_type: { - label: "Tipo de Contrato", - options: { - subscription: "Suscripci\xF3n", - service: "Acuerdo de Servicio", - license: "Licencia", - partnership: "Asociaci\xF3n", - nda: "Acuerdo de Confidencialidad (NDA)", - msa: "Acuerdo Marco de Servicios (MSA)" - } - }, - signed_date: { label: "Fecha de Firma" }, - signed_by: { label: "Firmado Por" }, - document_url: { label: "Documento de Contrato" }, - special_terms: { label: "T\xE9rminos Especiales" }, - description: { label: "Descripci\xF3n" }, - billing_address: { label: "Direcci\xF3n de Facturaci\xF3n" } - }, - _views: { - all_contracts: { label: "Todos los Contratos" }, - renewal_calendar: { label: "Calendario de Renovaci\xF3n" }, - contract_gantt: { label: "Plazos del Contrato" }, - contract_timeline: { label: "L\xEDnea de Tiempo" } - }, - _sections: { - basic: { label: "Informaci\xF3n del Contrato" }, - parties: { label: "Partes" }, - terms: { label: "T\xE9rminos y Fechas" }, - value: { label: "Valor del Contrato" }, - status: { label: "Estado y Aprobaci\xF3n" }, - renewal: { label: "Renovaci\xF3n" }, - // Nombres de sección del formulario en contract.view.ts (#1100) - contract_terms: { label: "T\xE9rminos" }, - signing_and_documents: { label: "Firma y Documentos" }, - notes: { label: "Notas" } - } - }, - crm_product: { - _validations: { - cost_less_than_price: { - message: "El coste deber\xEDa ser inferior al precio de lista" - }, - price_positive: { - message: "El precio de lista debe ser positivo" - } - }, - label: "Producto", - pluralLabel: "Productos", - description: "Productos y servicios que ofrece la empresa", - fields: { - product_code: { label: "C\xF3digo de Producto" }, - display_title: { label: "T\xEDtulo Mostrado" }, - name: { label: "Nombre de Producto" }, - description: { label: "Descripci\xF3n" }, - category: { - label: "Categor\xEDa", - options: { - software: "Software", - hardware: "Hardware", - service: "Servicio", - subscription: "Suscripci\xF3n", - support: "Soporte" - } - }, - family: { - label: "Familia de Producto", - options: { - enterprise: "Soluciones para Gran Empresa", - smb: "Soluciones para PYMEs", - services: "Servicios Profesionales", - cloud: "Servicios en la Nube" - } - }, - list_price: { label: "Precio de Lista" }, - cost: { label: "Costo" }, - sku: { label: "SKU" }, - is_active: { label: "Activo" }, - product_manager: { label: "Gerente de Producto" }, - image: { label: "Imagen de Producto" }, - datasheet: { label: "Ficha T\xE9cnica" } - }, - _views: { - all_products: { label: "Todos los Productos" }, - product_catalog: { label: "Cat\xE1logo de Productos" } - }, - _sections: { - basic: { label: "Informaci\xF3n del Producto" }, - pricing: { label: "Precios" }, - metadata: { label: "Recursos" }, - // Nombres de sección del formulario en product.view.ts (#1100) - product_info: { label: "Informaci\xF3n del Producto" }, - pricing_info: { label: "Precios" }, - media: { label: "Multimedia" } - } - } -}; - -// src/sales/translations/es-ES/objects.service.ts -var service4 = { - crm_case: { - _validations: { - resolution_required_for_closed: { - message: "La resoluci\xF3n es obligatoria al cerrar un caso" - }, - escalation_reason_required: { - message: "El motivo de escalado es obligatorio al escalar un caso" - }, - case_status_progression: { - message: "Transici\xF3n de estado no v\xE1lida" - } - }, - label: "Caso", - pluralLabel: "Casos", - description: "Casos de soporte y solicitudes de servicio de clientes", - fields: { - case_number: { label: "N\xFAmero de Caso" }, - display_title: { label: "T\xEDtulo Mostrado" }, - subject: { label: "Asunto" }, - description: { label: "Descripci\xF3n" }, - crm_account: { label: "Cuenta" }, - crm_contact: { label: "Contacto" }, - status: { - label: "Estado", - options: { - new: "Nuevo", - in_progress: "En Curso", - waiting_customer: "Esperando al Cliente", - waiting_support: "Esperando a Soporte", - escalated: "Escalado", - resolved: "Resuelto", - closed: "Cerrado" - } - }, - priority: { - label: "Prioridad", - options: { low: "Baja", medium: "Media", high: "Alta", critical: "Cr\xEDtica" } - }, - priority_rank: { label: "Rango de Prioridad" }, - type: { - label: "Tipo de Caso", - options: { - question: "Consulta", - problem: "Problema", - feature_request: "Solicitud de Funcionalidad", - bug: "Error" - } - }, - // `email` y `chat` se dejan como préstamos: son el término habitual en - // español de negocios y concuerdan con `crm_campaign.channel`. - origin: { - label: "Origen del Caso", - options: { email: "Email", phone: "Tel\xE9fono", web: "Web", chat: "Chat", social_media: "Redes Sociales" } - }, - owner_id: { label: "Propietario del Caso" }, - closed_date: { label: "Fecha de Cierre" }, - first_response_date: { label: "Fecha de Primera Respuesta" }, - resolution_time_hours: { label: "Tiempo de Resoluci\xF3n (Horas)" }, - sla_due_date: { label: "Fecha L\xEDmite SLA", help: "Se fija seg\xFAn la prioridad del caso y el Nivel de Cliente de la cuenta, en horas naturales: las noches, los fines de semana y los festivos cuentan." }, - is_sla_violated: { label: "SLA Incumplido" }, - is_escalated: { label: "Escalado" }, - escalated_date: { label: "Fecha de Escalaci\xF3n" }, - escalation_reason: { label: "Motivo de Escalaci\xF3n" }, - resolution: { label: "Resoluci\xF3n" }, - resolved_by_article: { label: "Resuelto por Art\xEDculo", help: "Art\xEDculo de la base de conocimiento que resolvi\xF3 este caso \u2014 la se\xF1al de desv\xEDo." }, - internal_notes: { label: "Notas Internas", help: "Notas internas no visibles para el cliente" }, - is_closed: { label: "Est\xE1 Cerrado" } - }, - _views: { - all_cases: { label: "Todos los Casos" }, - case_workflow: { label: "Flujo de Servicio" }, - sla_calendar: { label: "Calendario SLA" }, - case_timeline: { label: "L\xEDnea de Tiempo de Casos" }, - unassigned_triage: { - label: "Sin asignar \u2014 triaje", - emptyState: { - title: "Nada pendiente de triaje", - message: "Todos los casos tienen propietario. Los casos aparecen aqu\xED cuando llegan sin propietario \u2014 normalmente un env\xEDo web-a-caso recibido mientras nadie ocupaba el puesto de Agente de Servicio." - } - }, - escalated_cases: { label: "Casos Escalados" }, - my_open_cases: { label: "Mis Casos Abiertos" }, - sla_at_risk: { label: "\u23F0 SLA en Riesgo" } - }, - _sections: { - // Nombres de sección del formulario en case.view.ts (#1100). - case: { label: "Caso" }, - how_can_we_help: { label: "\xBFC\xF3mo podemos ayudarte?" }, - // Claves de sección del objeto (case.object.ts) que usan los - // formularios de registro y la página de detalle, cuyas secciones - // hacen referencia a estos grupos (#970). - basic: { label: "Informaci\xF3n del Caso" }, - origin: { label: "Origen y Asignaci\xF3n" }, - sla: { label: "SLA y Prioridad" }, - resolution: { label: "Resoluci\xF3n" }, - escalation: { label: "Escalaci\xF3n" }, - system: { label: "Sistema" } - }, - _actions: { - ...activityActions4, - escalate_case: { - label: "Escalar Caso", - confirmText: "Esto enviar\xE1 el caso al equipo de escalaci\xF3n. \xBFContinuar?", - successMessage: "\xA1Caso escalado con \xE9xito!" - }, - close_case: { - label: "Cerrar Caso", - confirmText: "\xBFEst\xE1 seguro de querer cerrar este caso?", - successMessage: "\xA1Caso cerrado con \xE9xito!" - }, - claim_case: { - label: "Tomar Caso", - successMessage: "Caso tomado: ahora es suyo." - } - } - }, - crm_knowledge_article: { - _validations: { - published_requires_body: { - message: "No se pueden publicar art\xEDculos sin cuerpo." - }, - published_requires_summary: { - message: "Los art\xEDculos publicados deben tener un resumen para los resultados de b\xFAsqueda y las citas de IA." - } - }, - label: "Art\xEDculo de Conocimiento", - pluralLabel: "Base de Conocimiento", - description: "Respuestas y gu\xEDas reutilizables para clientes y agentes", - fields: { - article_number: { label: "N.\xBA Art\xEDculo" }, - display_title: { label: "T\xEDtulo Mostrado" }, - title: { label: "T\xEDtulo" }, - summary: { label: "Resumen", help: "Resumen de un p\xE1rrafo que se muestra en los resultados de b\xFAsqueda y en las citas de la IA." }, - body: { label: "Contenido", help: "Contenido completo del art\xEDculo (Markdown)." }, - category: { - label: "Categor\xEDa", - options: { - getting_started: "Primeros pasos", - how_to: "C\xF3mo hacerlo", - troubleshooting: "Resoluci\xF3n de problemas", - billing: "Facturaci\xF3n", - api: "API e Integraciones", - release_notes: "Notas de versi\xF3n", - policy: "Pol\xEDticas" - } - }, - tags: { - label: "Etiquetas", - options: { - auth: "Autenticaci\xF3n", - sso: "SSO", - mobile: "M\xF3vil", - email: "Correo", - reports: "Informes", - performance: "Rendimiento", - data_import: "Importaci\xF3n de datos", - webhooks: "Webhooks" - } - }, - status: { - label: "Estado", - options: { draft: "Borrador", in_review: "En revisi\xF3n", published: "Publicado", archived: "Archivado" } - }, - audience: { - label: "Audiencia", - help: "Los art\xEDculos p\xFAblicos son visibles en el portal de clientes; los internos solo los ven los agentes.", - options: { public: "P\xFAblico", internal: "Interno" } - }, - language: { - label: "Idioma", - options: { en: "Ingl\xE9s", zh_cn: "Chino simplificado", es_es: "Espa\xF1ol", ja_jp: "Japon\xE9s" } - }, - owner_id: { label: "Propietario" }, - related_to_case: { label: "Caso de origen", help: "Caso a partir del cual se redact\xF3 este art\xEDculo (opcional)." }, - published_at: { label: "Publicado el" }, - last_reviewed_at: { label: "\xDAltima revisi\xF3n" }, - helpful_count: { label: "\xDAtil", help: "Recontado desde crm_article_feedback \u2014 nunca se escribe a mano." }, - not_helpful_count: { label: "No \xFAtil", help: "Recontado desde crm_article_feedback \u2014 nunca se escribe a mano." } - }, - _views: { - all_articles: { label: "Todos los art\xEDculos" }, - published_articles: { label: "Publicados" }, - my_drafts: { label: "Mis borradores" } - }, - _sections: { - basic: { label: "Informaci\xF3n del Art\xEDculo" }, - content: { label: "Contenido" }, - taxonomy: { label: "Categorizaci\xF3n" }, - metrics: { label: "Interacci\xF3n" }, - engagement: { label: "Interacci\xF3n" }, - // Nombre de sección del formulario en knowledge_article.view.ts (#1100) - article: { label: "Art\xEDculo" } - }, - _actions: { - mark_article_helpful: { - label: "\xDAtil", - successMessage: "Gracias \u2014 registrado como \xFAtil." - }, - mark_article_not_helpful: { - label: "No \xFAtil", - successMessage: "Gracias \u2014 registrado como no \xFAtil." - } - } - }, - crm_article_feedback: { - label: "Opini\xF3n sobre el Art\xEDculo", - pluralLabel: "Opiniones sobre Art\xEDculos", - description: "El veredicto \xFAtil / no \xFAtil de un lector sobre un art\xEDculo de la base de conocimiento", - fields: { - feedback_number: { label: "N.\xBA de Opini\xF3n" }, - owner_id: { label: "Lector" }, - crm_knowledge_article: { label: "Art\xEDculo", help: "Art\xEDculo de la base de conocimiento al que se refiere esta opini\xF3n." }, - verdict: { - label: "Veredicto", - options: { helpful: "\xDAtil", not_helpful: "No \xFAtil" } - }, - comment: { label: "Comentario", help: "Nota opcional que explica el veredicto \u2014 la lee el autor del art\xEDculo." } - }, - _sections: { - basic: { label: "Opini\xF3n" } - } - } -}; - -// src/sales/translations/es-ES/objects.activity.ts -var activity4 = { - crm_task: { - _validations: { - completed_date_required: { - message: "La fecha de finalizaci\xF3n es obligatoria cuando el estado es Completada" - }, - recurrence_fields_required: { - message: "El tipo de recurrencia es obligatorio para las tareas recurrentes" - }, - related_to_required: { - message: "Debe seleccionarse al menos un registro relacionado" - } - }, - label: "Tarea", - pluralLabel: "Tareas", - description: "Actividades y tareas pendientes", - fields: { - subject: { label: "Asunto" }, - description: { label: "Descripci\xF3n" }, - status: { - label: "Estado", - options: { - not_started: "No Iniciada", - in_progress: "En Curso", - waiting: "En Espera", - completed: "Completada", - deferred: "Aplazada" - } - }, - priority: { - label: "Prioridad", - options: { low: "Baja", normal: "Normal", high: "Alta", urgent: "Urgente" } - }, - priority_rank: { label: "Rango de Prioridad" }, - type: { - label: "Tipo de Tarea", - options: { - call: "Llamada", - email: "Email", - meeting: "Reuni\xF3n", - follow_up: "Seguimiento", - demo: "Demostraci\xF3n", - other: "Otro" - } - }, - due_date: { label: "Fecha L\xEDmite" }, - reminder_date: { label: "Fecha/Hora de Recordatorio" }, - reminder_sent: { label: "Recordatorio Enviado" }, - completed_date: { label: "Fecha de Finalizaci\xF3n" }, - owner_id: { label: "Asignado A" }, - // Los valores son nombres de objeto: se reutilizan las etiquetas ya - // traducidas de cada objeto en este mismo paquete (igual que - // `crm_event.related_to_type`). - related_to_type: { - label: "Tipo de Objeto Relacionado", - options: { - crm_account: "Cuenta", - crm_contact: "Contacto", - crm_opportunity: "Oportunidad", - crm_lead: "Prospecto", - crm_case: "Caso" - } - }, - related_to_account: { label: "Cuenta Relacionada" }, - related_to_contact: { label: "Contacto Relacionado" }, - related_to_opportunity: { label: "Oportunidad Relacionada" }, - related_to_lead: { label: "Prospecto Relacionado" }, - related_to_case: { label: "Caso Relacionado" }, - is_recurring: { label: "Tarea Recurrente" }, - recurrence_type: { - label: "Tipo de Recurrencia", - options: { daily: "Diaria", weekly: "Semanal", monthly: "Mensual", yearly: "Anual" } - }, - recurrence_interval: { label: "Intervalo de Recurrencia" }, - recurrence_end_date: { label: "Fecha Fin de Recurrencia" }, - is_completed: { label: "Est\xE1 Completado" }, - is_overdue: { label: "Est\xE1 Vencido" }, - progress_percent: { label: "Progreso (%)" } - }, - _views: { - all_tasks: { label: "Todas las Tareas" }, - task_board: { label: "Tablero de Tareas" }, - task_calendar: { label: "Calendario de Tareas" }, - task_gantt: { label: "Plan de Ejecuci\xF3n" }, - task_timeline: { label: "L\xEDnea de Tiempo" }, - my_open_tasks: { label: "Mis Tareas Abiertas" }, - todays_tasks: { label: "\u{1F4C5} Mis Tareas Prioritarias" }, - overdue_tasks: { label: "\u23F0 Tareas Abiertas \xB7 M\xE1s Vencidas Primero" } - }, - _sections: { - basic: { label: "Informaci\xF3n de la Tarea" }, - scheduling: { label: "Programaci\xF3n" }, - related: { label: "Registros Relacionados" }, - recurrence: { label: "Recurrencia" }, - effort: { label: "Progreso y Esfuerzo" }, - system: { label: "Sistema" }, - // Nombres de sección del formulario en task.view.ts (#1100) - task: { label: "Tarea" }, - related_records: { label: "Registros Relacionados" }, - recurrence_and_effort: { label: "Recurrencia y Esfuerzo" } - } - }, - crm_event: { - _validations: { - end_after_start: { - message: "La hora de fin debe ser posterior a la de inicio" - }, - related_to_required: { - message: "Debe seleccionarse al menos un registro relacionado" - } - }, - label: "Evento", - pluralLabel: "Eventos", - description: "Reuniones, llamadas y otras interacciones programadas con clientes", - fields: { - subject: { label: "Asunto" }, - description: { label: "Descripci\xF3n" }, - type: { - label: "Tipo de evento", - options: { - meeting: "Reuni\xF3n", - call: "Llamada", - demo: "Demostraci\xF3n", - webinar: "Seminario web", - onsite_visit: "Visita presencial", - other: "Otro" - } - }, - status: { - label: "Estado", - options: { - planned: "Planificado", - held: "Realizado", - cancelled: "Cancelado", - no_show: "No asisti\xF3" - } - }, - owner_id: { label: "Asignado a" }, - start_datetime: { label: "Inicio" }, - end_datetime: { label: "Fin" }, - all_day: { label: "Evento de todo el d\xEDa" }, - duration_minutes: { label: "Duraci\xF3n (minutos)" }, - location: { label: "Ubicaci\xF3n", help: "Sala, direcci\xF3n o enlace de la reuni\xF3n" }, - related_to_type: { - label: "Tipo de registro relacionado", - options: { - crm_account: "Cuenta", - crm_contact: "Contacto", - crm_opportunity: "Oportunidad", - crm_lead: "Prospecto", - crm_case: "Caso" - } - }, - related_to_account: { label: "Cuenta relacionada" }, - related_to_contact: { label: "Contacto relacionado" }, - related_to_opportunity: { label: "Oportunidad relacionada" }, - related_to_lead: { label: "Prospecto relacionado" }, - related_to_case: { label: "Caso relacionado" }, - outcome_notes: { label: "Notas de resultado", help: "Qu\xE9 se acord\xF3 y qu\xE9 sigue" } - }, - _views: { - all_events: { label: "Todos los eventos" }, - event_calendar: { label: "Calendario de eventos" }, - event_timeline: { label: "Agenda del equipo" }, - my_events: { label: "Mi calendario" }, - upcoming_events: { label: "\u{1F4C5} Pr\xF3ximos \xB7 M\xE1s cercanos primero" }, - held_events: { label: "\u2705 Historial de interacciones" } - }, - _sections: { - basic: { label: "Informaci\xF3n del Evento" }, - schedule: { label: "Programaci\xF3n" }, - related: { label: "Registros Relacionados" }, - outcome: { label: "Resultado" }, - // Nombres de sección del formulario en event.view.ts (#1100) - event: { label: "Evento" }, - related_records: { label: "Registros Relacionados" } - } - }, - crm_event_attendee: { - _validations: { - attendee_resolves: { - message: "Un asistente debe indicar la parte que nombra su tipo: el tipo Contacto requiere un contacto y el tipo Externo requiere un nombre de asistente externo" - }, - attendee_type_exclusive: { - message: "Un asistente nombra exactamente una parte: borre las columnas que su tipo de asistente no nombra" - } - }, - label: "Asistente al evento", - pluralLabel: "Asistentes al evento", - description: "Persona invitada o presente en un evento", - fields: { - attendee_number: { label: "N\xFAmero de asistente" }, - crm_event: { label: "Evento" }, - attendee_type: { - label: "Tipo de asistente", - options: { contact: "Contacto", lead: "Prospecto", user: "Usuario", external: "Externo" } - }, - crm_contact: { label: "Contacto", help: "Se rellena cuando el asistente es un contacto de cliente ya existente" }, - crm_lead: { label: "Prospecto", help: "Se rellena cuando el asistente sigue siendo un prospecto sin convertir" }, - sys_user: { label: "Usuario", help: "Se rellena cuando el asistente es un compa\xF1ero de la empresa" }, - external_name: { label: "Asistente externo", help: "Nombre de un asistente que no est\xE1 en ning\xFAn objeto del CRM: se rellena cuando el tipo de asistente es Externo" }, - response: { - label: "Respuesta", - options: { - no_response: "Sin respuesta", - accepted: "Aceptado", - declined: "Rechazado", - tentative: "Tentativo" - } - }, - is_organizer: { label: "Organizador" }, - invited_date: { label: "Invitado el" } - }, - _views: { - all_event_attendees: { label: "Asistentes al evento" } - }, - _sections: { - // El inglés es «Attendee» / «Invitation», no el par - // «Basic Information» / «Response Tracking» de crm_campaign_member. - basic: { label: "Asistente" }, - response: { label: "Invitaci\xF3n" }, - // Nombres de sección del formulario en event_attendee.view.ts (#1100) - attendee: { label: "Asistente" }, - invitation: { label: "Invitaci\xF3n" } - } - } -}; - -// src/sales/translations/es-ES/objects.marketing.ts -var marketing4 = { - crm_campaign: { - _validations: { - end_after_start: { - message: "La fecha de fin debe ser posterior a la de inicio" - }, - actual_cost_within_budget: { - message: "El coste real supera el coste presupuestado" - } - }, - label: "Campa\xF1a", - pluralLabel: "Campa\xF1as", - description: "Campa\xF1as e iniciativas de marketing", - fields: { - campaign_code: { label: "C\xF3digo de Campa\xF1a" }, - display_title: { label: "T\xEDtulo Mostrado" }, - name: { label: "Nombre de Campa\xF1a" }, - description: { label: "Descripci\xF3n" }, - type: { - label: "Tipo de Campa\xF1a", - options: { - email: "Email", - webinar: "Seminario Web", - trade_show: "Feria Comercial", - conference: "Conferencia", - direct_mail: "Correo Postal", - social_media: "Redes Sociales", - content: "Marketing de Contenidos", - partner: "Marketing con Socios" - } - }, - channel: { - label: "Canal Principal", - options: { - digital: "Digital", - social: "Redes Sociales", - email: "Email", - events: "Eventos", - partner: "Socios" - } - }, - status: { - label: "Estado", - options: { - planning: "Planificaci\xF3n", - in_progress: "En Curso", - completed: "Completada", - aborted: "Cancelada" - } - }, - start_date: { label: "Fecha de Inicio" }, - end_date: { label: "Fecha de Fin" }, - budgeted_cost: { label: "Costo Presupuestado" }, - actual_cost: { label: "Costo Real" }, - expected_revenue: { label: "Ingresos Previstos" }, - actual_revenue: { label: "Ingresos Reales" }, - target_size: { label: "Tama\xF1o Objetivo", help: "N\xFAmero objetivo de prospectos/contactos" }, - num_sent: { label: "Cantidad Enviada" }, - num_responses: { label: "N\xFAmero de Respuestas" }, - num_leads: { label: "N\xFAmero de Prospectos" }, - num_converted_leads: { label: "Prospectos Convertidos" }, - num_opportunities: { label: "Oportunidades Creadas" }, - num_won_opportunities: { label: "Oportunidades Ganadas" }, - response_rate: { label: "Tasa de Respuesta %" }, - roi: { label: "ROI %" }, - owner_id: { label: "Propietario de Campa\xF1a" }, - landing_page_url: { label: "P\xE1gina de Aterrizaje" }, - is_active: { label: "Activo" } - }, - _views: { - all_campaigns: { label: "Todas las Campa\xF1as" }, - campaign_gantt: { label: "Programaci\xF3n de Campa\xF1as" }, - campaign_calendar: { label: "Calendario de Campa\xF1as" }, - campaign_timeline: { label: "L\xEDnea de Tiempo de Marketing" } - }, - _sections: { - basic: { label: "Informaci\xF3n de Campa\xF1a" }, - schedule: { label: "Programaci\xF3n" }, - budget: { label: "Presupuesto y ROI" }, - metrics: { label: "Rendimiento" }, - // El inglés de este grupo es «Ownership», no «Assignment»: agrupa al - // propietario de la campaña, igual que `crm_account.ownership`. - assignment: { label: "Propiedad" }, - assets: { label: "Recursos de Campa\xF1a" } - }, - _actions: { - enroll_leads: { - label: "Inscribir Miembros", - successMessage: "Miembros elegibles inscritos en la campa\xF1a." - } - } - }, - crm_campaign_member: { - _validations: { - lead_or_contact_required: { - message: "Un miembro de campa\xF1a debe referenciar un prospecto o un contacto" - } - }, - label: "Miembro de Campa\xF1a", - pluralLabel: "Miembros de Campa\xF1a", - description: "Prospectos y contactos alcanzados por una campa\xF1a, con su estado de respuesta", - fields: { - member_number: { label: "N\xFAmero de Miembro" }, - crm_campaign: { label: "Campa\xF1a" }, - crm_lead: { label: "Prospecto", help: "Se rellena cuando el miembro era un Prospecto en el momento de la inscripci\xF3n" }, - crm_contact: { label: "Contacto", help: "Se rellena cuando el miembro es un Contacto existente" }, - status: { - label: "Estado", - options: { - sent: "Enviado", - responded: "Respondido", - converted: "Convertido", - unsubscribed: "Dado de Baja" - } - }, - added_date: { label: "Fecha de Alta" }, - response_date: { label: "Fecha de Respuesta" }, - has_responded: { label: "Ha Respondido" } - }, - _sections: { - basic: { label: "Informaci\xF3n B\xE1sica" }, - response: { label: "Seguimiento de Respuesta" } - }, - _actions: { - mark_responded: { - label: "Marcar como Respondido", - successMessage: "Respuesta registrada en este miembro de campa\xF1a." - } - } - } -}; - -// src/sales/translations/es-ES.ts -var esES2 = { - objects: { - crm_account: customer4.crm_account, - crm_contact: customer4.crm_contact, - crm_knowledge_article: service4.crm_knowledge_article, - crm_forecast: pipeline4.crm_forecast, - crm_lead: pipeline4.crm_lead, - crm_opportunity: pipeline4.crm_opportunity, - crm_case: service4.crm_case, - crm_contract: commerce4.crm_contract, - crm_product: commerce4.crm_product, - crm_quote: commerce4.crm_quote, - crm_task: activity4.crm_task, - crm_campaign: marketing4.crm_campaign, - crm_event: activity4.crm_event, - crm_event_attendee: activity4.crm_event_attendee, - crm_article_feedback: service4.crm_article_feedback, - crm_campaign_member: marketing4.crm_campaign_member, - crm_opportunity_line_item: pipeline4.crm_opportunity_line_item, - crm_quote_line_item: commerce4.crm_quote_line_item - }, - ...appSurface4 -}; - -// src/sales/translations/crm.translation.ts -var CrmTranslations = { - en: en2, - "zh-CN": zhCN2, - "ja-JP": jaJP2, - "es-ES": esES2 -}; - -// src/sales/views/index.ts -var views_exports = {}; -__export(views_exports, { - AccountViews: () => AccountViews, - ContactViews: () => ContactViews, - EventAttendeeViews: () => EventAttendeeViews, - EventViews: () => EventViews, - ForecastViews: () => ForecastViews, - LeadViews: () => LeadViews, - OpportunityViews: () => OpportunityViews, - TaskViews: () => TaskViews -}); - -// src/sales/views/lead.view.ts -import { P as P24 } from "@objectstack/spec"; -import { defineView as defineView3 } from "@objectstack/spec/ui"; -var DUPLICATE_LINK_FIELDS = [ - { - field: "duplicate_of_type", - required: true, - // The picker offers the AUTHORABLE half of the vocabulary only (#1164). - // `crm_lead.duplicate_of_type` also accepts `erased`, a tombstone - // `lead_duplicate_check` stamps when the engine's reference cleanup nulls - // the pointer — "confirmed duplicate of a record that has since been - // erased". Nobody authors that: it is an observation about a deletion that - // already happened, and offering it would let a reviewer close a lead as a - // duplicate of nothing while satisfying every rule that exists to stop - // exactly that. Narrowing here rather than deleting the value is the point - // — the record can still SAY it, and the field keeps its label in all four - // locales, so a tombstoned lead reads as "Erased Record" on the detail page - // instead of as a raw enum nobody can explain. - // - // Spread from `_picklists.ts` rather than retyped: the authorable set is - // the source both lists derive from, so a future object type added there - // reaches this picker automatically and the tombstone never can. - options: [...DUPLICATE_OF_TYPE_AUTHORABLE_OPTIONS], - visibleOn: P24`has(record.disqualification_reason) && record.disqualification_reason == "duplicate"` - }, - { - field: "duplicate_of_lead", - required: true, - visibleOn: P24`has(record.duplicate_of_type) && record.duplicate_of_type == "crm_lead"` - }, - { - field: "duplicate_of_contact", - required: true, - visibleOn: P24`has(record.duplicate_of_type) && record.duplicate_of_type == "crm_contact"` - }, - { - field: "duplicate_status", - required: true, - visibleOn: P24`has(record.disqualification_reason) && record.disqualification_reason == "duplicate"`, - helpText: "Confirmed means a human checked the two records and they are the same person." - } -]; -var LeadViews = defineView3({ - /** - * Default List View - Grid with Advanced Features - */ - list: { - type: "grid", - name: "all_leads", - label: "All Leads", - userActions: { editInline: true }, - data: { - provider: "object", - object: "crm_lead" - }, - // Column Configuration with Enhanced Features - columns: [ - { - // One name column, not two. Splitting first/last spent 300px to say - // what "Alice Martinez" says in one, and hung the record link off the - // given name alone — so opening a person meant aiming at their first - // name specifically. - field: "full_name", - label: "Name", - width: 200, - sortable: true, - link: true - // Primary navigation link - }, - { - field: "company", - label: "Company", - width: 200, - sortable: true - }, - { - field: "email", - label: "Email", - width: 200 - }, - { - field: "status", - label: "Status", - width: 120, - sortable: true - }, - { - field: "rating", - label: "Score", - width: 100, - align: "center" - }, - { - field: "lead_source", - label: "Source", - width: 120 - }, - // REQ-0005 acceptance 1: what the prospect wants and what it is worth, - // on the roster a rep opens every morning. Columns are also what the - // list's own filter and grouping controls offer, which is what makes the - // two FILTERABLE and GROUPABLE here rather than only readable — the same - // reading `contact.view.ts` records for the buying-centre columns. - // `need_type` is single-valued for exactly that reason (see - // `_picklists.ts`): a grouped list answers with one aggregate per raw - // stored value, so a multi-valued column would group by the combination. - { - field: "need_type", - label: "Need Type", - width: 160, - sortable: true - }, - { - field: "estimated_amount", - label: "Est. Amount", - width: 130, - align: "right", - sortable: true - }, - { - field: "owner_id", - label: "Owner", - width: 150 - } - ], - sort: [ - { field: "created_at", order: "desc" } - ], - // A row click opens the record page. There is deliberately no - // `navigation.view` here: measured in the browser on console 17.3.0 - // (#1716), the key is not resolved as a form-view name. The navigation - // hook reads it into the SECOND argument of `onNavigate` — the slot that - // otherwise carries the literal mode string, `r(t, d ?? 'view')` — so it - // named nothing and selected nothing. The record page here is rendered by - // `lead_detail_page` (`src/sales/pages/lead_detail.page.ts`), not by a named - // form view, and clicking a row behaved identically with the key present, - // with it absent, and on a list that never declared it. `detail_form` - // below stays: it is this file's one TABBED layout example, and it was - // already reachable by no path. - navigation: { - mode: "page" - }, - // `convert_lead` / `schedule_followup` declare `locations: ['list_item']` - // and are auto-injected into the menu. Do not add strings here: the legacy - // rowActions surface only dispatches defined stack actions. - // Built-in `exportOptions` covers CSV export; no export action needed. - bulkActions: ["create_campaign"], - // Features - pagination: { pageSize: 25, pageSizeOptions: [10, 25, 50, 100] }, - rowHeight: "medium", - exportOptions: { formats: ["csv", "xlsx"] }, - // Empty State - emptyState: { - title: "No Leads Yet", - message: "Get started by creating your first lead", - icon: "user-plus" - } - }, - /** - * Default Form View - SIMPLE Layout - * Basic sectioned form with collapsible sections and column layouts - */ - form: { - type: "simple", - sections: [ - { - name: "contact_information", - label: "Contact Information", - collapsible: true, - collapsed: false, - columns: 2, - // 2-column layout - fields: [ - { - field: "salutation" - }, - { - field: "first_name", - required: true - }, - { - field: "last_name", - required: true, - span: "full" - }, - "company", - "title", - "email", - "phone", - "mobile", - "website" - ] - }, - { - name: "lead_classification", - label: "Lead Classification", - collapsible: true, - collapsed: false, - columns: 3, - // 3-column layout - fields: [ - { - field: "status", - required: true - }, - { - field: "rating", - widget: "star_rating" - // Custom widget - }, - "lead_source", - "industry", - // Offered, ⛔ not `required` (#2097): an insert that leaves it empty is - // stamped to the creator by the platform (see `lead.hook.ts`), so a - // rep's new lead is theirs without a pick, and a manager can still - // choose another owner. `required` blocked that save client-side. - "owner_id", - // `disqualification_reason` is enforced by the - // `disqualification_reason_required` validation on crm_lead, so every - // form that lets a user pick "Unqualified" must also offer the reason - // — otherwise the save fails with an error the form gives you no way - // to clear. Hidden until it applies. - { - field: "disqualification_reason", - required: true, - visibleOn: P24`has(record.status) && record.status == "unqualified"` - }, - // REQ-0005 step 6: 「填写…需求类型…预计金额」. A rep types these at - // intake, so they need an authoring surface — and this form IS the - // create dialog (`RecordFormPage` and `useActionModal` both resolve - // `view.form ?? view.formViews?.default`, see `case.view.ts`). - // - // ⚠️ Named rather than reached through a group reference, and the - // AGENTS.md ladder's rung 3 asks for the reason in writing. Both - // fields declare `group: 'qualification'` on the object, so every - // DERIVED surface — the page synthesizer, an auto-derived form — - // already carries them from `fieldGroups` alone with nothing authored. - // This form is not one of those: it authors `sections`, and an - // authored `sections` array wins outright over the auto-derived path. - // The rung-2 fix, a `{ group: 'qualification' }` section, cannot be - // used HERE specifically: this section is a CURATED cross-group set, - // not a mirror of that group. It already names four of the group's - // members with per-field overrides a group reference cannot carry - // (`status` required, `rating`'s star widget, and - // `disqualification_reason`'s `required` + `visibleOn` directly - // above), and it borrows `industry` and `owner_id` from two other - // groups. Adding a group reference beside it would render those four - // a second time and pull in `next_followup_date` / - // `last_contacted_date`, which are machine-written and deliberately - // absent from every form. ⇒ The customer need is real, the group - // reference genuinely cannot express it, and the two lines below are - // what that leaves. - "need_type", - "estimated_amount", - ...DUPLICATE_LINK_FIELDS - ] - }, - { - name: "company_information", - label: "Company Information", - collapsible: true, - collapsed: true, - // Collapsed by default - columns: 2, - fields: [ - "annual_revenue", - "number_of_employees" - ] - }, - { - name: "address", - label: "Address", - collapsible: true, - collapsed: true, - columns: 2, - // `crm_lead` stores the location in one composite `Field.address`; - // the discrete street/city/state/postal_code/country columns this - // section used to list do not exist on the object, so the whole - // section rendered blank. - fields: [ - { - field: "address", - span: "full" - } - ] - }, - { - name: "additional_information", - label: "Additional Information", - collapsible: true, - collapsed: true, - columns: 1, - // Single column for text areas - fields: [ - "description", - "notes" - ] - }, - { - name: "privacy", - label: "Privacy", - collapsible: true, - collapsed: true, - columns: 2, - fields: [ - "do_not_call", - "email_opt_out" - ] - } - ] - }, - /** - * Additional Named List Views - */ - listViews: { - // Declaration order IS tab order in the console. These three working - // queues used to sit AFTER the kanban / calendar / gallery views, which - // pushed all of them into the "3 more" overflow menu — so the one screen - // a rep opens this list for was the one they had to go hunting for, while - // three presentation modes held the front row. - /** - * My Leads — a rep's own queue, hottest first. - */ - my_leads: { - name: "my_leads", - type: "grid", - label: "My Leads", - userActions: { editInline: true }, - data: { - provider: "object", - object: "crm_lead" - }, - columns: ["full_name", "company", "email", "status", "rating"], - filter: [ - { field: "owner_id", operator: "equals", value: "{current_user_id}" } - ], - sort: [ - { field: "rating", order: "desc" }, - { field: "created_at", order: "desc" } - ] - }, - /** - * Hot Leads — the working queue for the leads routing declared HOT. - * - * "Hot" is defined in exactly ONE place: the `lead_assignment` flow's - * `check_hot` decision (edge `e2`, `record.rating >= 4`). Crossing that - * line is what stamps the 1-day follow-up SLA and fires the "Hot lead — - * assign within 24h" alert at the owner, so this queue must hold precisely - * the leads that alert is about. (An earlier comment here credited a - * flagging workflow that has never existed in this repo — dead name - * removed, the routing flow is the producer.) - * - * The cut was `rating >= 4.5` (#766). `rating` is a WHOLE-star field — - * `lead.hook.ts` rounds its computed score ("round to WHOLE stars"), the - * `star_rating` widget offers nothing finer, and the one seeded 4.5 was - * deleted for the same reason (#591) — so `>= 4.5` meant `== 5` on every - * row that can actually exist. A 4-star lead was routed hot, alerted on, - * and then missing from the queue its owner was sent to. - * - * Sharing the population with "High Priority" is the deliberate cost of - * having one definition of hot, not an oversight: both views now show - * rating >= 4, still New or Contacted. What differs is what they are FOR. - * Hot Leads is the work order — sorted by next-follow-up (the SLA that - * routing just stamped), with phone, email and owner on the row so it can - * be dialled top to bottom. High Priority is the scan list — score-tinted - * rows and lead source, no SLA column, no time ordering. A 5-star-only - * queue, if it is ever a real need, gets its own view under its own name - * instead of squatting on "Hot". - * - * `test/hot-lead-threshold-parity.test.ts` derives this threshold and the - * flow's from the metadata and fails if they drift apart again. - */ - hot_leads: { - name: "hot_leads", - type: "grid", - label: "\u{1F525} Hot Leads", - userActions: { editInline: true }, - data: { provider: "object", object: "crm_lead" }, - columns: ["full_name", "company", "phone", "email", "rating", "next_followup_date", "owner_id"], - // Same rating cut as the `lead_assignment` hot branch, scoped to the - // statuses still worth working. (Operator-only filters; the view runtime - // does not resolve date template strings.) - filter: [ - { field: "rating", operator: "greater_than_or_equal", value: 4 }, - { field: "status", operator: "in", value: ["new", "contacted"] } - ], - sort: [{ field: "next_followup_date", order: "asc" }] - }, - /** - * High Priority Leads - */ - high_priority: { - name: "high_priority", - type: "grid", - label: "High Priority", - userActions: { editInline: true }, - data: { - provider: "object", - object: "crm_lead" - }, - columns: ["full_name", "company", "email", "status", "rating", "lead_source"], - filter: [ - { field: "rating", operator: "greater_than_or_equal", value: 4 }, - { field: "status", operator: "in", value: ["new", "contacted"] } - ], - rowColor: { - field: "rating", - colors: { - "5": "green", - "4": "orange" - } - } - }, - /** - * Suspected Duplicates — the review queue behind the intake flag (#598). - * - * `lead_duplicate_check` marks a re-captured email `suspected` and links it - * to the record it repeats. Without a place to SEE that set, the flag would - * be a column nobody reads: the reviewer opens this queue, compares the two - * records, and either clears the flag or disqualifies the lead as a - * confirmed duplicate. `confirmed` rows drop out of the queue, so it drains. - */ - suspected_duplicates: { - name: "suspected_duplicates", - type: "grid", - label: "Suspected Duplicates", - userActions: { editInline: true }, - data: { provider: "object", object: "crm_lead" }, - columns: [ - "full_name", - "company", - "email", - "duplicate_of_type", - "duplicate_of_lead", - "duplicate_of_contact", - "status", - "owner_id" - ], - filter: [ - { field: "duplicate_status", operator: "equals", value: "suspected" } - ], - // Oldest suspicion first: an unreviewed duplicate is a second rep working - // the same person, so the queue is worked front to back. - sort: [{ field: "created_at", order: "asc" }], - emptyState: { - title: "No Suspected Duplicates", - message: "Nothing to review \u2014 every re-captured email has been checked.", - icon: "copy" - } - }, - /** - * Kanban Board View - */ - kanban_by_status: { - name: "kanban_by_status", - type: "kanban", - label: "Lead Pipeline", - data: { - provider: "object", - object: "crm_lead" - }, - columns: ["first_name", "last_name", "company", "email"], - kanban: { - groupByField: "status", - summarizeField: "annual_revenue", - columns: ["first_name", "last_name", "company", "rating"] - }, - navigation: { - mode: "drawer", - // Open in drawer instead of new page - width: "600px" - } - }, - /** - * Calendar View - */ - calendar_by_created: { - name: "calendar_by_created", - type: "calendar", - label: "Lead Calendar", - data: { - provider: "object", - object: "crm_lead" - }, - columns: ["first_name", "last_name", "company"], - calendar: { - startDateField: "created_at", - titleField: "company", - colorField: "status" - } - }, - /** - * Gallery/Card View - */ - gallery_view: { - name: "gallery_view", - type: "gallery", - label: "Lead Cards", - data: { - provider: "object", - object: "crm_lead" - }, - columns: ["first_name", "last_name", "company", "email", "status"], - gallery: { - cardSize: "medium", - titleField: "company", - visibleFields: ["first_name", "last_name", "email", "phone", "status", "rating"] - } - } - }, - /** - * Additional Named Form Views - Demonstrating All 6 Layout Types - * - * One example per layout type. The SIMPLE one is the default `form` - * above, so this block carries the other five, plus the public and the - * conditional-visibility examples. Every layout is demonstrated exactly - * once across the file: each entry below is the only example of its own. - */ - formViews: { - /** - * 2. TABBED Layout - * Organize complex forms with tabs - */ - detail_form: { - type: "tabbed", - sections: [ - { - name: "general", - label: "General", - columns: 2, - fields: [ - "salutation", - "first_name", - "last_name", - "company", - "title", - "email", - "phone", - "mobile" - ] - }, - { - name: "qualification", - label: "Qualification", - columns: 2, - fields: [ - { field: "status", required: true }, - { field: "rating", widget: "star_rating" }, - "lead_source", - "industry", - "annual_revenue", - "number_of_employees", - // See the default form: `unqualified` requires a reason. - { - field: "disqualification_reason", - required: true, - visibleOn: P24`has(record.status) && record.status == "unqualified"` - }, - ...DUPLICATE_LINK_FIELDS - ] - }, - { - name: "address", - label: "Address", - columns: 2, - // Single composite `Field.address` — see the note on the default - // form's Address section. - fields: [ - { field: "address", span: "full" } - ] - }, - { - name: "details", - label: "Details", - columns: 1, - fields: [ - "description", - "notes", - "do_not_call", - "email_opt_out" - ] - } - ] - }, - /** - * 3. WIZARD Layout - * Step-by-step guided process - */ - lead_conversion_wizard: { - type: "wizard", - data: { - provider: "object", - object: "crm_lead" - }, - sections: [ - { - name: "step_1_contact_details", - label: "Step 1: Contact Details", - columns: 2, - fields: [ - { field: "first_name", required: true, readonly: true }, - { field: "last_name", required: true, readonly: true }, - { field: "email", readonly: true, span: "full" }, - "phone", - "mobile" - ] - }, - { - name: "step_2_company_information", - label: "Step 2: Company Information", - columns: 2, - fields: [ - { field: "company", required: true, readonly: true }, - "title", - "industry", - "annual_revenue", - "number_of_employees", - "website" - ] - }, - { - name: "step_3_qualification", - label: "Step 3: Qualification", - columns: 2, - fields: [ - { field: "status", required: true }, - // See the default form: `unqualified` requires a reason. The status - // is editable in this step, so the wizard can land there too. - { - field: "disqualification_reason", - required: true, - visibleOn: P24`has(record.status) && record.status == "unqualified"` - }, - ...DUPLICATE_LINK_FIELDS, - { field: "rating", widget: "star_rating" }, - "lead_source", - { - field: "owner_id", - // Conditional visibility. `!= null` on top of `has(...)`: strict - // CEL aborts on `dyn < int`, which `has()` alone allows. - visibleOn: P24`has(record.rating) && record.rating != null && record.rating >= 4` - } - ] - }, - { - name: "step_4_review_and_convert", - label: "Step 4: Review & Convert", - columns: 1, - fields: [ - { - field: "description", - helpText: "Review all information before converting to Account and Contact" - } - ] - } - ] - }, - /** - * 4. SPLIT Layout - * Master-detail split view - */ - split_edit: { - type: "split", - data: { - provider: "object", - object: "crm_lead" - }, - sections: [ - { - name: "primary_information", - label: "Primary Information", - columns: 1, - fields: [ - "first_name", - "last_name", - "company", - "email", - { field: "status", required: true }, - "owner_id", - // See the default form: `unqualified` requires a reason. - { - field: "disqualification_reason", - required: true, - visibleOn: P24`has(record.status) && record.status == "unqualified"` - }, - ...DUPLICATE_LINK_FIELDS - ] - }, - { - name: "extended_details", - label: "Extended Details", - columns: 2, - fields: [ - "phone", - "mobile", - "title", - "industry", - "lead_source", - { field: "rating", widget: "star_rating" }, - "annual_revenue", - "number_of_employees" - ] - } - ] - }, - /** - * 5. DRAWER Layout - * Side panel form (typically opened from list view) - */ - quick_edit_drawer: { - type: "drawer", - data: { - provider: "object", - object: "crm_lead" - }, - sections: [ - { - name: "quick_edit", - label: "Quick Edit", - columns: 1, - // Drawers typically use single column - fields: [ - { field: "first_name", required: true }, - { field: "last_name", required: true }, - "company", - "email", - "phone", - { field: "status", required: true }, - { field: "rating", widget: "star_rating" }, - "lead_source", - { - field: "owner_id", - // Only show owner after initial contact. A record with no status - // yet has not been contacted, so `!isBlank` keeps the blank case - // on the "hidden" side rather than letting `null != "new"` show it. - visibleOn: P24`has(record.status) && !isBlank(record.status) && record.status != "new"` - }, - // See the default form: `unqualified` requires a reason. - { - field: "disqualification_reason", - required: true, - visibleOn: P24`has(record.status) && record.status == "unqualified"` - }, - ...DUPLICATE_LINK_FIELDS - ] - } - ] - }, - /** - * 6. MODAL Layout - * Dialog-based form for quick actions - */ - status_update_modal: { - type: "modal", - data: { - provider: "object", - object: "crm_lead" - }, - sections: [ - { - name: "update_lead_status", - label: "Update Lead Status", - columns: 1, - fields: [ - { field: "first_name", readonly: true }, - { field: "last_name", readonly: true }, - { field: "company", readonly: true }, - { - field: "status", - required: true, - helpText: "Select the new status for this lead" - }, - { - field: "rating", - widget: "star_rating", - // Only show rating for qualified leads - visibleOn: P24`has(record.status) && record.status == "qualified"` - }, - // The reason picklist, not just free-text notes: it is what the - // `disqualification_reason_required` validation checks, and this - // modal is the main place a rep flips a lead to Unqualified. - { - field: "disqualification_reason", - required: true, - visibleOn: P24`has(record.status) && record.status == "unqualified"` - }, - ...DUPLICATE_LINK_FIELDS, - { - field: "notes", - placeholder: "Add notes about this status change", - // Free-text context alongside the reason - visibleOn: P24`has(record.status) && record.status == "unqualified"` - } - ] - } - ] - }, - /** - * 7. PUBLIC / ANONYMOUS — "Web-to-Lead" - * - * Airtable-style public form hosted at `/forms/contact-us`. Embeddable - * via iframe on a marketing site. Guests can ONLY submit (insert) — the - * `guest_portal` profile denies read/edit/delete on `crm_lead`. - * - * Fields not on the form (status, lead_source, owner_id, rating) are stamped - * by the `lead_automation` hook in `lead.hook.ts` after a guest submission. - */ - web_to_lead: { - type: "simple", - data: { - provider: "object", - object: "crm_lead" - }, - sections: [ - { - name: "tell_us_about_yourself", - label: "Tell us about yourself", - columns: 2, - fields: [ - { field: "first_name", required: true }, - { field: "last_name", required: true }, - { field: "email", required: true, span: "full" }, - "phone", - "title" - ] - }, - { - name: "about_your_company", - label: "About your company", - columns: 2, - fields: [ - { field: "company", required: true, span: "full" }, - "website", - "industry", - "number_of_employees", - "annual_revenue" - ] - }, - { - name: "how_can_we_help", - label: "How can we help?", - columns: 1, - fields: [ - { - field: "description", - required: true, - placeholder: "Briefly describe what you are looking for...", - helpText: "A sales representative will get back to you within one business day." - } - ] - } - ], - sharing: { - enabled: true, - allowAnonymous: true, - publicLink: "/forms/contact-us" - } - }, - /** - * Advanced Example: Conditional Field Visibility & Dependencies - */ - advanced_conditional: { - type: "simple", - data: { - provider: "object", - object: "crm_lead" - }, - sections: [ - { - name: "lead_information", - label: "Lead Information", - columns: 2, - fields: [ - "first_name", - "last_name", - "company", - "email", - "status", - "lead_source", - { - field: "rating", - widget: "star_rating", - // Only show after first contact — see the drawer form's note on - // why blank stays on the "hidden" side. - visibleOn: P24`has(record.status) && !isBlank(record.status) && record.status != "new"` - }, - { - field: "industry", - dependsOn: "company" - // Industry options depend on company - }, - { - field: "annual_revenue", - // Only for qualified leads - visibleOn: P24`has(record.rating) && record.rating != null && record.rating >= 3` - }, - { - field: "number_of_employees", - visibleOn: P24`has(record.rating) && record.rating != null && record.rating >= 3` - }, - { - field: "owner_id", - required: true, - visibleOn: P24`has(record.status) && (record.status == "contacted" || record.status == "qualified")` - }, - // See the default form: `unqualified` requires a reason. - { - field: "disqualification_reason", - required: true, - visibleOn: P24`has(record.status) && record.status == "unqualified"` - }, - ...DUPLICATE_LINK_FIELDS, - { - field: "notes", - span: "full", - required: true, - // Require explanation for unqualified - visibleOn: P24`has(record.status) && record.status == "unqualified"` - } - ] - }, - { - name: "address_information", - label: "Address Information", - collapsible: true, - collapsed: true, - columns: 2, - // Single composite `Field.address` — the discrete street/city/state/ - // postal_code/country columns do not exist on crm_lead. - fields: [ - { field: "address", span: "full" } - ] - }, - { - name: "privacy_preferences", - label: "Privacy Preferences", - collapsible: true, - collapsed: true, - columns: 2, - fields: [ - { - field: "do_not_call", - helpText: "Check if this lead has requested not to be called" - }, - { - field: "email_opt_out", - helpText: "Check if this lead has opted out of email communications" - } - ] - } - ] - } - } -}); - -// src/sales/views/account.view.ts -import { defineView as defineView4 } from "@objectstack/spec/ui"; -var AccountViews = defineView4({ - list: { - type: "grid", - name: "all_accounts", - label: "All Accounts", - userActions: { editInline: true }, - data: { provider: "object", object: "crm_account" }, - columns: [ - { field: "name", width: 240, sortable: true, link: true, pinned: "left" }, - { field: "industry", width: 140, sortable: true }, - { field: "type", width: 130 }, - { field: "annual_revenue", width: 160, align: "right", summary: "sum" }, - { field: "number_of_employees", width: 130, align: "right", summary: "avg" }, - { field: "health_score", width: 140 } - ], - sort: [{ field: "annual_revenue", order: "desc" }], - rowColor: { field: "is_active", colors: { true: "green", false: "slate" } }, - selection: { type: "multiple" }, - pagination: { pageSize: 50, pageSizeOptions: [25, 50, 100] }, - exportOptions: { formats: ["csv", "xlsx"] }, - compactToolbar: true, - bulkActionDefs: [ - { - name: "update_tier", - label: "Update Tier", - icon: "tag", - operation: "update", - params: [ - { - name: "tier", - label: "Customer Tier", - type: "select", - required: true, - options: [ - { label: "Strategic", value: "strategic" }, - { label: "Enterprise", value: "enterprise" }, - { label: "Mid-Market", value: "mid_market" }, - { label: "SMB", value: "smb" } - ] - } - ], - confirmText: "Update tier on {{count}} account(s) to {{tier}}?" - }, - { - name: "transfer_owner", - label: "Transfer Owner", - icon: "user-check", - operation: "update", - params: [ - { - name: "owner_id", - label: "New Owner", - type: "lookup", - // The platform registers `sys_user` — `user` matches no object and - // rendered an empty picker. - object: "sys_user", - required: true - } - ], - confirmText: "Transfer ownership of {{count}} account(s)?" - }, - { - name: "delete", - label: "Delete", - icon: "trash-2", - variant: "danger", - operation: "delete", - confirmText: "Permanently delete {{count}} account(s)? This cannot be undone.", - confirmLabel: "Delete" - } - ], - appearance: { - showDescription: true, - allowedVisualizations: ["grid", "gallery", "map"] - } - }, - listViews: { - /** Branded account cards */ - account_gallery: { - name: "account_gallery", - type: "gallery", - label: "Account Cards", - data: { provider: "object", object: "crm_account" }, - // `logo` rides in the projection for the same reason the timeline view - // carries its date fields: the list data source projects the configured - // columns, and `coverField` reads off that projection. - columns: ["name", "industry", "annual_revenue", "phone", "logo"], - gallery: { - // The card art this view was named for. "Branded account cards" had a - // brand COLOUR and no brand IMAGE — `crm_account.logo` is the object's - // only image field and nothing displayed it, so every card drew the - // same blank cover. `coverFit` is left unstated: the schema's default - // is the crop these cards want, and materialising a default rewrites - // "the author said nothing" into "the author asked for this". - coverField: "logo", - cardSize: "medium", - titleField: "name", - visibleFields: ["industry", "annual_revenue", "number_of_employees", "phone", "website", "owner_id"] - } - }, - /** - * Geospatial distribution. - * - * The `map` block is what BINDS the view to a coordinate source. Without it - * the renderer falls back to literal default field names, which resolve on - * `crm_account` only by luck — the view draws no marker while authoring - * reports success (`view/layout-without-binding`). `office_location` is the - * object's `Field.location(...)`, which is the one field on `crm_account` - * carrying coordinates; `billing_address` is an `address` field and is a - * postal shape, not a coordinate one, so it stays a column rather than the - * binding. `titleField` names the marker label — `name`, not the object's - * `nameField` (`display_title`), because the map's own `columns` show - * `name` and the two should agree. - */ - account_map: { - name: "account_map", - type: "map", - label: "Accounts by Location", - data: { provider: "object", object: "crm_account" }, - columns: ["name", "industry", "office_location", "billing_address"], - map: { locationField: "office_location", titleField: "name" } - }, - /** Tier accounts: Enterprise (>= $10M ARR) */ - enterprise_accounts: { - name: "enterprise_accounts", - type: "grid", - label: "Enterprise Accounts", - userActions: { editInline: true }, - data: { provider: "object", object: "crm_account" }, - columns: ["name", "industry", "annual_revenue", "number_of_employees", "owner_id"], - filter: [{ field: "annual_revenue", operator: "greater_than_or_equal", value: 1e7 }], - sort: [{ field: "annual_revenue", order: "desc" }], - // ADR-0047 end-user quick filters (Airtable "User filters", Elements: - // dropdowns). `element: 'dropdown'`, deliberately — on an object list - // the view SWITCHER owns the tab bar (it builds one entry per `list` / - // `listViews` descriptor), so a quick-filter block shaped as tabs is - // dropped there: the console logs `defines userFilters (element: - // "tabs"), which are ignored on an object list view (ADR-0047 "views" - // mode — the view switcher owns the tab bar here)` and renders nothing. - // Dropdowns sit beside the switcher and are unaffected. - // `owner_id` is the platform ownership lookup (#548) — it renders as a - // record-picker dropdown. - // NOTE: requires @objectstack/spec > 9.2.0 (ADR-0047 UserFiltersSchema); - // on older specs defineStack strips this block — harmless no-op. - ...{ - userFilters: { - element: "dropdown", - fields: [ - { field: "industry", showCount: true }, - { field: "type" }, - { field: "owner_id" } - ] - } - // typed via spread-as-any until @objectstack/spec ships ADR-0047 - // (UserFiltersSchema is in framework main, > 9.2.0) - } - }, - my_accounts: { - name: "my_accounts", - type: "grid", - label: "My Accounts", - userActions: { editInline: true }, - data: { provider: "object", object: "crm_account" }, - columns: ["name", "industry", "annual_revenue", "phone", "last_activity_date"], - filter: [{ field: "owner_id", operator: "equals", value: "{current_user_id}" }], - sort: [{ field: "last_activity_date", order: "desc" }] - }, - // The `renewals_due` view is gone with the fields it was built on (#1181): - // both its `is_not_null` filter and its sort key were - // `crm_account.next_renewal_date`, so the view could not outlive the field. - // Nothing is lost — `crm_contract` ships the renewals queue that the daily - // sweep actually acts on (`renewal_calendar`, over `end_date`). - /** At-risk customers — CSM action queue */ - at_risk_accounts: { - name: "at_risk_accounts", - type: "grid", - label: "\u26A0\uFE0F At-Risk Accounts", - userActions: { editInline: true }, - data: { provider: "object", object: "crm_account" }, - columns: ["name", "tier", "health_score", "segment", "last_activity_date"], - filter: [ - { field: "type", operator: "equals", value: "customer" }, - { field: "health_score", operator: "in", value: ["at_risk", "churning"] } - ], - sort: [{ field: "health_score", order: "desc" }] - } - }, - form: { - type: "tabbed", - sections: [ - { - name: "profile", - label: "Profile", - columns: 2, - fields: [ - { field: "name", required: true, span: "full" }, - "account_number", - // `type` (prospect / customer / partner …) drives the Renewals and - // At-Risk views' `type = customer` filter — with no form field it - // could never be set, so those views matched nothing. - "type", - "industry", - "phone", - "website", - "owner_id", - "parent_account", - "is_active", - "brand_color", - // The other half of the `branding` group. Without a form field there - // is no upload control anywhere in the app, so the logo the gallery - // cards now cover with could never have been set. Full span: an - // image drop target in a half-width cell is a thumbnail-sized one. - { field: "logo", span: "full" } - ] - }, - { - // `child_account_revenue` is a roll-up the engine maintains, so it is - // read-only on the form by construction — it is here because a hierarchy - // nobody can see the effect of is the decoration this field replaced. - name: "financials", - label: "Financials", - columns: 2, - fields: ["annual_revenue", "number_of_employees", "child_account_revenue"] - }, - { - // The customer-success fields the at_risk_accounts view lists and - // filters on. They existed on the object but no form offered them, so - // the CS working queue stayed permanently empty. (`renewal_owner` and - // `next_renewal_date` were removed from this section with the fields - // themselves — #1181.) - name: "customer_success", - label: "Customer Success", - columns: 2, - fields: ["tier", "segment", "health_score"] - }, - { - name: "locations", - label: "Locations", - columns: 1, - // `billing_country` and `territory` are readonly and derived, but both - // are on the form on purpose: an admin asking "why does the NA team not - // see this account?" reads the answer off the record instead of - // guessing at the address blob (#621). `territory` is what the rules - // actually match (#639) and `billing_country` is the input it was - // classified from, so the two together show the whole derivation — - // including the case the picklist alone cannot explain, an account - // sitting in `Other` because its country was typed in a spelling the - // mapping does not know. - fields: ["billing_address", "billing_country", "territory", "office_location"] - }, - { - name: "description", - label: "Description", - columns: 1, - fields: ["description"] - } - ] - } -}); - -// src/sales/views/contact.view.ts -import { defineView as defineView5 } from "@objectstack/spec/ui"; -var ContactViews = defineView5({ - list: { - type: "grid", - name: "all_contacts", - label: "All Contacts", - userActions: { editInline: true }, - data: { provider: "object", object: "crm_contact" }, - columns: [ - { field: "avatar", width: 64, align: "center" }, - { field: "first_name", width: 140, sortable: true, link: true }, - { field: "last_name", width: 140, sortable: true }, - { field: "crm_account", width: 200 }, - { field: "title", width: 180 }, - { field: "department", width: 140 }, - // REQ-0004 acceptance 2: the three buying-centre attributes are columns - // on the landing roster, which is already grouped by account with the - // groups collapsed — so expanding one account reads as a MAP (who - // decides, who is on our side) instead of a directory. Columns are also - // what the list's own filter and grouping controls offer. - { field: "buying_function", width: 160 }, - { field: "attitude", width: 140 }, - { field: "relationship_strength", width: 180 }, - { field: "email", width: 220 }, - { field: "phone", width: 150 }, - { field: "owner_id", width: 150 } - ], - sort: [{ field: "last_name", order: "asc" }], - grouping: { fields: [{ field: "crm_account", order: "asc", collapsed: true }] }, - selection: { type: "multiple" }, - // The selection-bar entry point for campaigning at existing customers - // (#597), mirroring `bulkActions: ['create_campaign']` on the lead grid. - // The bare-string form fans the action out once per selected row; do not - // add strings for `mark_primary` / `send_email`, which declare - // `locations: ['list_item']` and are auto-injected into the row menu. - bulkActions: ["add_contact_to_campaign"], - pagination: { pageSize: 50, pageSizeOptions: [25, 50, 100] }, - exportOptions: { formats: ["csv", "xlsx"] }, - appearance: { - showDescription: true, - allowedVisualizations: ["grid", "gallery"] - } - }, - listViews: { - /** People directory */ - contact_directory: { - name: "contact_directory", - type: "gallery", - label: "People Directory", - data: { provider: "object", object: "crm_contact" }, - columns: ["first_name", "last_name", "title", "email"], - gallery: { - coverField: "avatar", - coverFit: "cover", - cardSize: "small", - titleField: "last_name", - visibleFields: ["first_name", "title", "department", "email", "phone", "crm_account"] - } - }, - primary_contacts: { - name: "primary_contacts", - type: "grid", - label: "Primary Contacts", - userActions: { editInline: true }, - data: { provider: "object", object: "crm_contact" }, - columns: ["first_name", "last_name", "crm_account", "title", "email", "phone"], - filter: [{ field: "is_primary", operator: "equals", value: true }], - sort: [{ field: "crm_account", order: "asc" }] - } - }, - form: { - type: "tabbed", - sections: [ - { - name: "identity", - label: "Identity", - columns: 2, - fields: [ - "salutation", - { field: "first_name", required: true }, - { field: "last_name", required: true, span: "full" }, - { field: "crm_account", required: true }, - "title", - "department", - "owner_id" - ] - }, - { - // REQ-0004 acceptance 1: the buying-centre group is rendered FROM - // `fieldGroups`, with no per-field enumeration authored anywhere. - // - // This form authors `sections`, and an authored `sections` array wins - // outright over the renderer's `fieldGroups` auto-derivation (the - // mechanism is written up at length in `case.view.ts`), so a group - // declared on the object alone would reach the SYNTHESIZED detail - // page and never this form — which is also the create dialog. The - // group-reference form is rung 2 of the AGENTS.md ladder, for exactly - // this "partial arrangement is genuinely needed" case: `group:` - // inherits the object's `buying_centre` members (every field pointing - // at it, in declaration order) and its presentation, so adding a - // fourth attribute to the group later reaches this form by itself. - // - // ⛔ `group:` is mutually exclusive with `fields:` and with every key - // the group itself declares (`name`, `label`, `description`, - // `visibleWhen`, `collapsible`/`collapsed: true`) — `columns` is not - // one of those, because the group declares nothing about layout. - group: "buying_centre", - columns: 2 - }, - { - // Named `contact_details`, not `contact_info` — `contact_info` is - // already a distinct fieldGroup key on `crm_contact` ("Contact - // Information"), and reusing it here would make this section's - // translated heading follow that group's wording instead of its own - // "Contact Info". - name: "contact_details", - label: "Contact Info", - columns: 2, - fields: ["email", "phone", "mobile", "avatar"] - }, - { - // Named `mailing_address` — deliberately the SAME key as the - // `mailing_address` fieldGroup on `crm_contact`, which is the opposite - // call from the two sections either side of it and for the same - // reason. Reusing a group key makes the section's translated heading - // follow that group's wording; `contact_details` and - // `comm_preferences` wanted their own shorter wording, so they had to - // avoid the collision. This section wants exactly the group's wording - // ("Mailing Address"), which every locale already carries under - // `objects.crm_contact._sections.mailing_address`, so the collision is - // the feature: one heading, one translation, four locales, no new row. - // - // Why the section exists at all: an authored `sections` array wins - // outright over the renderer's `fieldGroups` auto-derivation (the - // mechanism is written up at length in `case.view.ts`), and this form - // is also the CREATE dialog. Without this section the address was - // readable on the SYNTHESIZED detail page — which does derive from - // `fieldGroups` — while no form in the app could enter or edit it, - // even though `contact_import.mapping.ts` writes it from the shipped - // CSV template. This tab is the authoring half of the import path. - name: "mailing_address", - label: "Mailing Address", - columns: 2, - fields: [ - // One structured `address` field; full width, so its parts lay out - // as a unit rather than in half a grid column. - { field: "mailing_address", span: "full" } - ] - }, - { - // Named `comm_preferences`, not `preferences` — `preferences` is - // already a distinct fieldGroup key on `crm_contact` ("Communication - // Preferences"), and reusing it here would make this section's - // translated heading follow that group's wording instead of its own - // "Preferences". - name: "comm_preferences", - label: "Preferences", - columns: 2, - fields: ["lead_source", "is_primary", "do_not_call", "email_opt_out"] - } - ] - } -}); - -// src/sales/views/opportunity.view.ts -import { defineView as defineView6 } from "@objectstack/spec/ui"; -var OpportunityViews = defineView6({ - // The landing view is OPEN deals, not every deal ever recorded. - // - // Sorted by close_date ascending and unfiltered, "All Opportunities" opened - // on settled history: the first screen was 7 closed-won and 4 closed-lost - // records, and a rep had to scroll past months of finished business to reach - // anything they could still act on. The full unfiltered list is still one - // click away on the "All Opportunities" tab. - list: { - type: "grid", - name: "open_opportunities", - label: "Open Deals", - userActions: { editInline: true }, - data: { provider: "object", object: "crm_opportunity" }, - filter: [ - { field: "stage", operator: "not_in", value: ["closed_won", "closed_lost"] } - ], - columns: [ - { field: "name", width: 220, sortable: true, link: true }, - { field: "crm_account", label: "Account", width: 180 }, - { field: "stage", width: 140, sortable: true }, - { field: "amount", width: 140, align: "right", sortable: true, summary: "sum" }, - { field: "probability", width: 110, align: "right" }, - { field: "expected_revenue", width: 160, align: "right", summary: "sum" }, - { field: "close_date", width: 140, sortable: true } - ], - sort: [{ field: "close_date", order: "asc" }], - rowColor: { - field: "stage", - colors: { - prospecting: "slate", - qualification: "sky", - // Teal sits between the cool qualification blue and the warm proposal - // amber, keeping the cool→warm funnel ramp readable. NOT the gold - // `#FFD700` this option carries in `_picklists.ts`: gold is one hue - // step from proposal's amber, so the two adjacent stages would tint - // rows the same. - // - // Values are colour NAMES, not hex: objectui's `useRowColor` resolves - // only a name from its own vocabulary (or a full `bg-*` class) and - // turns a hex into no colour at all — so until 17.6.0's lint said so, - // this map tinted nothing. - needs_analysis: "teal", - proposal: "amber", - negotiation: "purple", - closed_won: "green", - closed_lost: "red" - } - }, - pagination: { pageSize: 25, pageSizeOptions: [25, 50, 100] }, - selection: { type: "multiple" }, - showRecordCount: true, - exportOptions: { formats: ["csv", "xlsx"] }, - appearance: { - showDescription: true, - allowedVisualizations: ["grid", "kanban", "calendar", "timeline", "gallery"] - }, - // Binds the 'calendar' entry above: the same forecast dates the dedicated - // `close_date_calendar` view shows, on the field this list sorts by. - // `close_date` is required + notNull on crm_opportunity. - calendar: { - startDateField: "close_date", - titleField: "name", - colorField: "stage" - }, - // List-level entry points: generate_quote reaches the row menu via its - // own `locations: ['list_item']`. Built-in `exportOptions` covers CSV - // export. - // - // `mass_update_stage` is wired as an AGGREGATE bulk def, not as a bare - // `bulkActions: ['mass_update_stage']` string (#508). The two forms are - // different dispatch contracts, and only this one moves a whole selection: - // - // - bare string → per-record fan-out: the action is dispatched ONCE PER - // selected row with `recordId` set. N requests, N stage moves. - // - aggregate def → ONE dispatch for the whole selection, carrying every - // id in the builtin `params._selectedIds` and no `recordId`. One - // request, N stage moves, one audit entry. - // - // Aggregate is the right shape here because the body already loops over the - // selection itself, and because the run is all-or-nothing: a partial result - // rejects instead of leaving the bar reporting per-row success it cannot - // honour (see the body in `src/sales/actions/opportunity.actions.ts`). - // - // `execution: 'aggregate'` is REQUIRED on an `operation: 'custom'` def and - // is not boilerplate: a custom def without it has no dispatcher, so the - // button ticks green once per row and does nothing at all. The spec refuses - // that shape at parse time (#4457) — which is also what makes this - // declaration safe to trust rather than merely present. - // - // History: this list carried the bare-string form until #588 removed it as - // a silent no-op, and the removal was read as "the platform cannot deliver - // a selection" for two release candidates. It could: the channel is - // `params._selectedIds`, the underscore is load-bearing, and nothing was - // injecting it precisely BECAUSE this declaration was gone - // (objectstack-ai/objectstack#5568, closed works-as-declared). - // - // The def deliberately carries only the three keys that choose the dispatch - // contract. Label, icon, params (the New Stage picker) and `visible` are - // promoted from the action itself by the renderer, so the dialog and the - // toolbar button cannot drift apart — and the label stays i18n-resolved, - // which an inline `label:` here would not be. - bulkActionDefs: [ - { name: "mass_update_stage", operation: "custom", execution: "aggregate" } - ] - }, - listViews: { - /** - * All Opportunities — the unfiltered book, including closed business. - * - * Demoted from the landing view (see the note on `list` above) but kept - * whole: reporting, audits and win/loss reviews all need the closed rows, - * and a manager reaches this in one click. - */ - all_opportunities: { - name: "all_opportunities", - type: "grid", - label: "All Opportunities", - userActions: { editInline: true }, - data: { provider: "object", object: "crm_opportunity" }, - columns: [ - { field: "name", width: 220, sortable: true, link: true }, - { field: "crm_account", label: "Account", width: 180 }, - { field: "stage", width: 140, sortable: true }, - { field: "amount", width: 140, align: "right", sortable: true, summary: "sum" }, - { field: "probability", width: 110, align: "right" }, - { field: "expected_revenue", width: 160, align: "right", summary: "sum" }, - { field: "close_date", width: 140, sortable: true }, - { field: "owner_id", width: 150 } - ], - sort: [{ field: "close_date", order: "desc" }], - showRecordCount: true - }, - /** Drag-and-drop sales pipeline */ - pipeline_kanban: { - name: "pipeline_kanban", - type: "kanban", - label: "Sales Pipeline", - data: { provider: "object", object: "crm_opportunity" }, - columns: ["name", "crm_account", "amount", "close_date", "owner_id"], - kanban: { - groupByField: "stage", - summarizeField: "amount", - columns: ["name", "crm_account", "amount", "close_date"] - }, - // The board is the active working pipeline. Closed business remains in - // the full book and the dashboard, while excluding it here keeps all - // five active stages visible at a presentation-friendly width. - filter: [{ field: "stage", operator: "not_in", value: ["closed_won", "closed_lost"] }], - sort: [{ field: "close_date", order: "asc" }], - navigation: { mode: "drawer", width: "640px" } - }, - /** Close-date forecasting calendar */ - close_date_calendar: { - name: "close_date_calendar", - type: "calendar", - label: "Forecast Calendar", - data: { provider: "object", object: "crm_opportunity" }, - columns: ["name", "amount", "stage", "owner_id"], - calendar: { - startDateField: "close_date", - titleField: "name", - colorField: "stage" - } - }, - /** Chronological deal flow */ - deal_timeline: { - name: "deal_timeline", - type: "timeline", - label: "Deal Timeline", - data: { provider: "object", object: "crm_opportunity" }, - columns: ["name", "crm_account", "amount"], - timeline: { - // `created_at`, the platform's own creation stamp — the object's - // duplicate `created_date` was removed in #575 B2 because nothing ever - // wrote it, so this timeline started every bar at null. Same spelling - // as the lead activity calendar. - startDateField: "created_at", - endDateField: "close_date", - titleField: "name", - groupByField: "owner_id", - colorField: "stage", - scale: "month" - } - }, - /** Executive review cards */ - deal_gallery: { - name: "deal_gallery", - type: "gallery", - label: "Deal Cards", - data: { provider: "object", object: "crm_opportunity" }, - columns: ["name", "crm_account", "amount", "stage", "close_date"], - gallery: { - cardSize: "medium", - titleField: "name", - visibleFields: ["crm_account", "amount", "stage", "probability", "close_date", "owner_id"] - } - }, - /** Personal pipeline */ - my_open_deals: { - name: "my_open_deals", - type: "grid", - label: "My Open Deals", - userActions: { editInline: true }, - data: { provider: "object", object: "crm_opportunity" }, - columns: ["name", "crm_account", "stage", "amount", "close_date"], - // "Open" has to exclude BOTH closed stages. Excluding only closed_won - // meant a rep's own queue opened on their lost deals, sorted to the top - // by close_date — the least actionable rows in the system. - filter: [ - { field: "owner_id", operator: "equals", value: "{current_user_id}" }, - { field: "stage", operator: "not_in", value: ["closed_won", "closed_lost"] } - ], - sort: [{ field: "close_date", order: "asc" }] - }, - /** Stale Opportunities — still-open deals, longest-parked first */ - stale_opportunities: { - name: "stale_opportunities", - type: "grid", - // Honest label: this view does not apply the 14-day cut its automation - // twin (`opportunity_stagnation`, STALE_THRESHOLD_DAYS = 14) uses, and - // does not claim to. Two independent reasons were recorded for that; one - // still holds and one has expired, so they are separated here. - // - // STILL TRUE — `days_in_stage` is a FORMULA (#489), evaluated in JS after - // the query, so the data engine can neither filter nor sort on it. Any - // filter phrased in terms of `days_in_stage` remains impossible. - // - // EXPIRED (#744) — the second reason said the list data path resolves no - // date macros, so `stage_entry_date < {14_days_ago}` would ship the token - // as a literal and invert the comparison lexicographically ('2026-…' sorts - // below '{', so every row matched). That was measured on @objectstack - // 16.1.0 and stopped being true at 17.0.0-rc.0, when `resolveFilterTokens()` - // was wired into the ObjectQL read path (objectql #3582). `{14_days_ago}` - // is a first-class vocabulary member — it matches the parameterised - // grammar `DATE_MACRO_PARAM_RE`, `{N_(minutes|hours|days|weeks|months| - // years)_(ago|from_now)}` — and it reaches the driver already substituted - // for an ISO date. Measured on 17.0.0-rc.2, RE-MEASURED 2026-09-03 on - // 17.2.0 (#1467), RE-RUN on 17.3.0 (#1676, after the PR #1577 bump) and - // RE-RUN again on 17.4.0 (#1883, after the PR #1814 bump; not yet on - // 17.5.0), unchanged at every taking: over four rows parked - // 30d / 15d / 13d / 1d, `stage_entry_date < {14_days_ago}` returned the - // 30d and 15d rows — the same two the equivalent day-start literal - // returns, and not all four, which is what an unsubstituted token would - // have matched. It is the same seam - // `closing_this_quarter` — the very next view in this file — relies on, - // pinned against a real engine in - // `test/forecast-current-quarter-view.test.ts`. - // - // Correcting that half of the comment does not decide anything about the - // filter, and is deliberately not a licence to change it: expressing the - // cut as `stage_entry_date <= {14_days_ago}` would drop `days_in_stage` - // from the question entirely and change which rows this view returns — - // hiding today's 13-day-old deals from a manager's queue. That is a - // BEHAVIOUR change with its own issue (#770), where the open question is - // whether this queue should be a cut or a ranking at all — this label - // promises a ranking and honours it. `stale_articles` in - // `src/views/knowledge_article.view.ts` carried the same expired premise - // and was corrected in the same pass (#769); that tab was then DELETED - // outright (#781, the review queue ruled out of the product), so it is no - // longer a comparison available in this tree — the surviving precedent - // for "ranking, not cut" is this view. Nothing below was touched. - // - // As shipped: operator-only filter, ordered by the stored - // `stage_entry_date` ascending — longest-parked on top, which is the - // queue a manager works. The `days_in_stage` column puts the - // `opportunity_stagnation` threshold in plain sight on every row. - label: "\u26A0\uFE0F Stale Opportunities \xB7 Longest in Stage First", - userActions: { editInline: true }, - data: { provider: "object", object: "crm_opportunity" }, - columns: ["name", "crm_account", "stage", "amount", "stage_entry_date", "days_in_stage", "close_date", "owner_id"], - filter: [ - { field: "stage", operator: "not_in", value: ["closed_won", "closed_lost"] } - ], - sort: [{ field: "stage_entry_date", order: "asc" }, { field: "close_date", order: "asc" }] - }, - /** - * Tender expected this quarter — REQ-0006 acceptance 2 in one view. - * - * The point of the view is the predicate: it windows - * `expected_tender_date`, the CUSTOMER's procurement calendar, and touches - * `close_date` nowhere — which is what "reportable independently of - * `close_date`" means and what a single forecast date could never express. - * - * Same inclusive `{current_quarter_*}` bounds as `closing_this_quarter` - * below, exact for the same measured reason: both bounds are date macros - * resolved server-side, and `expected_tender_date` is a `Field.date()` - * stored as `YYYY-MM-DD` TEXT, so the inclusive upper bound drops no rows. - */ - tender_this_quarter: { - name: "tender_this_quarter", - type: "grid", - label: "Tender This Quarter", - userActions: { editInline: true }, - data: { provider: "object", object: "crm_opportunity" }, - columns: ["name", "crm_account", "expected_tender_date", "expected_tender_amount", "expected_signing_date", "stage", "owner_id"], - filter: [ - { field: "stage", operator: "not_in", value: ["closed_won", "closed_lost"] }, - { field: "expected_tender_date", operator: "greater_than_or_equal", value: "{current_quarter_start}" }, - { field: "expected_tender_date", operator: "less_than_or_equal", value: "{current_quarter_end}" } - ], - sort: [{ field: "expected_tender_date", order: "asc" }], - // Empty is the legitimate state on a fresh install: no seed row carries - // a customer-side tender date, so this tab opens on nothing until a rep - // records one. Unexplained, that reads as broken. - emptyState: { - title: "No Tenders Expected This Quarter", - message: "This tab lists open deals whose customer-side tender date falls inside the current quarter. Record Expected Tender Date on a deal to see it here.", - icon: "calendar-clock" - } - }, - /** Closing this quarter (commit + best_case) — sales-manager forecast */ - closing_this_quarter: { - name: "closing_this_quarter", - type: "grid", - label: "Closing This Quarter", - userActions: { editInline: true }, - data: { provider: "object", object: "crm_opportunity" }, - columns: ["name", "crm_account", "amount", "forecast_category", "probability", "close_date", "owner_id"], - // The `close_date` window is what makes the label true (#743). Without - // it this view returned EVERY open commit/best-case deal whenever it - // closed — a deal slated for next March sat under a heading that said - // "Closing This Quarter", and summing the Amount column gave a number - // that was not this quarter's commit. - // - // Both bounds are date macros resolved server-side: `resolveFilterTokens()` - // was wired into the ObjectQL read path in 17.0.0-rc.0 (objectql #3582, - // covering find/findOne/count/aggregate ahead of the middleware chain), - // so a saved-view filter value reaches the driver already substituted. - // Measured on 17.0.0-rc.2, RE-MEASURED 2026-09-03 on 17.2.0 (#1467), - // RE-RUN on 17.3.0 (#1676, after the PR #1577 bump) and RE-RUN again on - // 17.4.0 (#1883, after the PR #1814 bump), unchanged at - // every taking — see the runtime block in - // `test/forecast-current-quarter-view.test.ts`, which is that - // re-measurement (not yet re-run on 17.5.0). - // - // The upper bound is INCLUSIVE against `{current_quarter_end}` rather - // than half-open against `{next_quarter_start}`, and that choice is - // deliberate: a `*_end` token resolves to the period's last calendar DAY - // (2026-09-30), which on a `datetime` column would stop at midnight and - // silently drop that day's rows — the spec says to use the half-open - // form there. `close_date` is `Field.date()`, stored as `YYYY-MM-DD` - // TEXT on both sides of the comparison, so the inclusive bound is exact. - // That is the same field-type property `metadata-references.test.ts` - // relies on for why the CRM/Sales/Executive dashboards may window - // `close_date` at all (#460). Both forms were measured to return the - // identical row set here; the inclusive one reads as what it means. - filter: [ - { field: "forecast_category", operator: "in", value: ["commit", "best_case"] }, - { field: "stage", operator: "not_in", value: ["closed_won", "closed_lost"] }, - { field: "close_date", operator: "greater_than_or_equal", value: "{current_quarter_start}" }, - { field: "close_date", operator: "less_than_or_equal", value: "{current_quarter_end}" } - ], - sort: [{ field: "close_date", order: "asc" }], - // Scoping the list makes "empty" a state a real user meets, so it needs - // copy. Unlike the forecast view's (#745, where the sweep owns the - // window and a fresh install is ALWAYS empty until it runs), the seeds - // here do produce rows for most of a quarter — six seeded deals qualify - // on forecast_category + stage, at `daysFromNow` offsets 11/14/24/30/38/45. - // But every one of those offsets is relative to the INSTALL day, so once - // fewer than 11 days remain in the quarter all six land in the next one - // and a freshly seeded demo opens this tab on nothing. A real org meets - // the same state whenever a quarter's commit slips out. Empty is - // legitimate here; unexplained, it reads as broken. - emptyState: { - title: "No Deals Closing This Quarter", - message: "This tab lists open commit and best-case deals with a close date inside the current quarter. Nothing matches right now \u2014 deals closing later are on the Open Deals tab.", - icon: "calendar-check" - } - } - }, - form: { - type: "tabbed", - sections: [ - { - name: "overview", - label: "Overview", - columns: 2, - fields: [ - { field: "name", required: true, span: "full" }, - { field: "crm_account", required: true }, - "primary_contact", - { field: "stage", required: true }, - { field: "amount", required: true }, - "probability", - "close_date", - "owner_id" - ] - }, - { - name: "forecast", - label: "Forecast", - columns: 2, - fields: [ - "expected_revenue", - "forecast_category", - "type", - "lead_source", - "crm_campaign", - "stage_entry_date", - "days_in_stage", - "is_private", - // REQ-0006 step 8 — the customer's own procurement calendar. Named - // here (AGENTS.md ladder rung 3), and the reason in writing: - // `tender_this_quarter` filters on `expected_tender_date`, and a - // filtered field no form offers is a view that can never match a - // deal a rep created through the UI (`test/metadata-references - // .test.ts`). The fields declare `group: 'sales_process'`, so every - // DERIVED surface — the record page's Details tab — already carries - // them; this form authors `sections`, which win outright over - // derivation. A `{ group: 'sales_process' }` reference cannot stand - // in: it would render `stage`, `probability` and `close_date` - // (curated in Overview, `stage` `required`) and `stage_entry_date` - // (above) a second time, and pull the approval verdict columns and - // the inert-by-default `requested_status` into the create dialog. - "customer_initiation_date", - "expected_tender_date", - "expected_tender_amount", - "expected_signing_date", - "expected_signing_amount" - ] - }, - // REQ-0006 acceptance 1, FROM `fieldGroups` (AGENTS.md ladder rung 2), - // the way `contact.view.ts` references REQ-0004's buying centre: this - // form authors `sections`, which win outright over the renderer's - // `fieldGroups` derivation, so a group declared on the object alone - // never reaches this form — the Edit and New dialog. A group reference - // enumerates nothing; members, label and icon come from the object. - // - // ⚠️ Measured on the 17.6.0 console: the tabbed dialog renders NO tab - // for a `{ group }` section — this one, and the contact form's buying - // centre on `main` alike. That is the platform's to fix, and these two - // lines are the contract-correct form waiting for it (AGENTS.md: a - // platform defect is waited for, never routed around). Until then every - // REQ-0006 field is edited through the Details tab's edit mode — which - // offers no markdown editor, the reason the narrative fields are - // textareas (see the note above `customer_background`). - { group: "qualification", columns: 2 }, - { group: "narrative", columns: 1 }, - { - name: "sales_strategy", - label: "Sales Strategy", - columns: 1, - // `competitors` sat here until #1061 retired it — this form section was - // the field's ONLY surface anywhere in the app (nothing read it back). - fields: ["next_step"] - }, - { - // Win/loss capture at close time. The fields existed on the object for - // reporting but no form offered them, so every closed deal lost its - // why-we-won / why-we-lost data. - name: "win_loss", - label: "Win / Loss", - collapsible: true, - collapsed: true, - columns: 2, - fields: ["win_reason", "loss_reason", { field: "loss_details", span: "full" }] - } - ] - } -}); - -// src/sales/views/task.view.ts -import { defineView as defineView7 } from "@objectstack/spec/ui"; -var TaskViews = defineView7({ - list: { - type: "grid", - name: "all_tasks", - label: "All Tasks", - userActions: { editInline: true }, - data: { provider: "object", object: "crm_task" }, - // NO `progress_percent` column here (#1214 item 5). The default grid used - // to render completion THREE times on one row — 是否完成 (tick), 状态, and - // 进度(%) — and the percent was the one that carried nothing. - // - // ⚠️ The card justified the removal as "every seeded row is 0%". That is - // FALSE as stated and was re-measured before deleting: two of the seven - // seeded tasks carry 100. What is TRUE is the claim underneath it — nobody - // maintains a percent per task — and the seed shows it more sharply than - // the card did: - // · every value that exists is 100, and every one of those rows is - // `status: 'completed'` (`service.seed.ts` mirrors what the hook would - // stamp, since hooks do not run over seeds); - // · `task_completion` stamps 100 on the completed transition and writes - // the field at no other time; - // · both `in_progress` rows sit at 0 — the one status where a percent - // could say something a status cannot, and it says nothing. - // ⇒ On this grid the column is `status` re-rendered at LOWER resolution: it - // cannot tell `not_started` from `in_progress` (both 0), while the `status` - // column beside it can. Dropping it loses no fact this row does not already - // carry twice. - // - // ⛔ The FIELD stays, and so does every other reader — this is one column - // on one view, not a retirement: `task_gantt` fills its bars from - // `gantt.progressField`, `task_board` and `my_open_tasks` show it (neither - // carries `status` AND `is_completed`, so there it is not a third spelling), - // `avg_progress` in `task.dataset.ts` aggregates it, and the Effort section - // of this file's form still lets a user author one. - // - // ⛔ `is_completed` STAYS, and is not the second half of this cleanup: it is - // not an independent shadow that can contradict `status` — `task_completion` - // recomputes it from status on every insert and update - // (`input.is_completed = effStatus === 'completed'`), which is precisely the - // "render completion from status" the card asks for, already done at the - // data layer. It is also this list's first sort key and its completion - // control. - columns: [ - { field: "is_completed", width: 60, align: "center" }, - { field: "subject", width: 280, sortable: true, link: true }, - { field: "status", width: 130, sortable: true }, - { field: "priority", width: 110, sortable: true }, - { field: "due_date", width: 140, sortable: true }, - { field: "owner_id", width: 150 }, - { field: "is_overdue", width: 100, align: "center" } - ], - sort: [ - { field: "is_completed", order: "asc" }, - { field: "due_date", order: "asc" } - ], - rowColor: { - // Task priority is low/normal/high/urgent — the previous critical/medium - // keys were Case values, so urgent and normal rows got no color at all. - // Colors mirror the option colors on crm_task.priority. - field: "priority", - colors: { urgent: "red", high: "orange", normal: "green", low: "slate" } - }, - selection: { type: "multiple" }, - pagination: { pageSize: 50 }, - appearance: { - showDescription: true, - allowedVisualizations: ["grid", "kanban", "calendar", "gantt", "timeline"] - }, - // Binds the 'calendar' entry above: the same schedule the dedicated - // `task_calendar` view shows, on the field this list sorts by. `due_date` - // is optional — an undated task stays off the calendar instead of being - // dropped on today by a guessed field. - calendar: { - startDateField: "due_date", - titleField: "subject", - colorField: "priority" - } - }, - listViews: { - /** Work board */ - task_board: { - name: "task_board", - type: "kanban", - label: "Task Board", - data: { provider: "object", object: "crm_task" }, - columns: ["subject", "priority", "due_date", "owner_id"], - kanban: { - groupByField: "status", - columns: ["subject", "priority", "due_date", "progress_percent"] - }, - filter: [{ field: "is_completed", operator: "equals", value: false }], - navigation: { mode: "drawer", width: "520px" } - }, - /** Schedule view */ - task_calendar: { - name: "task_calendar", - type: "calendar", - label: "Task Schedule", - data: { provider: "object", object: "crm_task" }, - columns: ["subject", "priority", "owner_id"], - calendar: { - startDateField: "due_date", - titleField: "subject", - colorField: "priority" - } - }, - /** Execution plan */ - task_gantt: { - name: "task_gantt", - type: "gantt", - label: "Execution Plan", - data: { provider: "object", object: "crm_task" }, - columns: ["subject", "owner_id", "progress_percent"], - gantt: { - startDateField: "reminder_date", - endDateField: "due_date", - titleField: "subject", - progressField: "progress_percent" - } - }, - /** Worklog timeline */ - task_timeline: { - name: "task_timeline", - type: "timeline", - label: "Worklog Timeline", - data: { provider: "object", object: "crm_task" }, - columns: ["subject", "status"], - timeline: { - startDateField: "reminder_date", - endDateField: "due_date", - titleField: "subject", - groupByField: "owner_id", - colorField: "status", - scale: "week" - } - }, - my_open_tasks: { - name: "my_open_tasks", - type: "grid", - label: "My Open Tasks", - userActions: { editInline: true }, - data: { provider: "object", object: "crm_task" }, - columns: ["subject", "priority", "due_date", "progress_percent"], - filter: [ - { field: "owner_id", operator: "equals", value: "{current_user_id}" }, - { field: "is_completed", operator: "equals", value: false } - ], - sort: [{ field: "due_date", order: "asc" }] - }, - /** My open priority tasks — daily morning queue */ - todays_tasks: { - name: "todays_tasks", - type: "grid", - label: "\u{1F4C5} My Priority Tasks", - userActions: { editInline: true }, - data: { provider: "object", object: "crm_task" }, - columns: ["subject", "priority", "status", "due_date", "related_to_type", "owner_id"], - // Operator-only filter — priority and status, no tokens — and the reason - // recorded here for that has expired (#782). Two claims stood here; both - // were wrong already on 17.0.0-rc.2 — the version this repo pinned AT - // THE TIME they were measured, not the current pin — in different - // ways. "Wrong" is about those two - // retired claims, not about the engine: nothing in this block reports - // broken platform behaviour. - // - // ⚠️ READ THE VERSION ON EACH READING BELOW. They were taken at - // several different pins and are labelled individually; a reading - // labelled 17.2.0 was taken there and has NOT been re-taken on any later - // pin unless it says so. - // - // `{current_user_id}` DOES interpolate. `resolveFilterTokens()` was wired - // into the ObjectQL READ path at 17.0.0-rc.0 (objectql #3582) ahead of - // the middleware chain, covering `find` / `findOne` / `count` / - // `aggregate` — saved-view filters included. `my_open_tasks`, the view - // directly above, ships that exact token. Measured in #784 with two probes - // that separate the three possible outcomes: `owner_id = - // {current_org_id}` returned 0 rows (the filter is not being dropped) - // while `owner_id = {current_user_id}` returned every seeded task (not a - // literal-string compare either — the literal matches no owner at all). - // RE-MEASURED 2026-09-03 on 17.2.0 (#1467), unchanged: both probes - // reported exactly those results there. NOT re-run on 17.3.0 (#1676) — - // the two-probe result is a 17.2.0 reading, and the seam it rests on - // (`resolveFilterTokens()` on the read path) was re-confirmed on 17.4.0 - // by `test/flow-filter-today-token.test.ts` (not yet re-run on 17.5.0). - // - // `{TODAY()}` is not a spelling of anything and never was. The vocabulary - // is `{today}` / `{yesterday}` / `{tomorrow}` / `{now}`, the period - // tokens, and the parameterised `{N_days_ago}` family. - // - // ⚠️ WHAT CHANGED between rc.2 and 17.4.0 — the one reading in - // this block that did NOT survive re-measurement, and the reason the - // version qualifiers here are load-bearing rather than bookkeeping. On - // rc.2 `{TODAY()}` was not REJECTED either: the placeholder grammar was - // `/^\$?\{([a-zA-Z0-9_]+)\}$/`, parentheses fell outside it, - // `classifyFilterToken('{TODAY()}')` returned null, and the string - // reached the driver verbatim and compared as text. From 17.2.0 on — - // re-confirmed on 17.3.0 (#1676) and again on 17.4.0 - // (#1883) by the PREMISE case in - // `test/flow-filter-today-token.test.ts`, which drives a real engine — - // that is FALSE: `FILTER_TOKEN_WRAPPED_RE` in `@objectstack/spec/data` - // now reads `/^\$?\{([^{}]+)\}$/`, which DOES match `TODAY()`, so it - // classifies as `kind: 'unknown'` and `resolveFilterTokens()` throws - // `UnknownFilterTokenError` (`FILTER_TOKEN_UNKNOWN`, HTTP 400) — the same - // envelope `{TODAY}` gets. The change landed at 17.0.0-rc.6 and this repo - // already pins it elsewhere: `test/flow-filter-today-token.test.ts` - // (#1107). That is also why the `src/*/flows` sweeps that still spell - // `{TODAY()}` work — `interpolateFilter()` resolves it before ObjectQL - // sees the filter at all. - // - // Measured on rc.2 over a four-row `crm_task` fixture (due 30d ago / 1d - // ago / today / in 7d), and RE-MEASURED 2026-09-03 on 17.2.0 (#1467) - // over the same fixture — three rows unchanged, the fourth not. ⛔ The - // row COUNTS below are a 17.2.0 reading and were NOT re-taken on 17.3.0 - // (#1676); what WAS re-confirmed there is the throw/resolve verdict in - // the right-hand column, by `test/flow-filter-today-token.test.ts`: - // - // rc.2 17.2.0 - // due_date < '{today}' -> 2 rows (past-due) 2 rows - // due_date <= '{today}' -> 3 rows 3 rows - // due_date < '{TODAY}' -> throws throws - // due_date < '{TODAY()}' -> ALL 4 rows throws - // - // (Both throws are `UnknownFilterTokenError`, `FILTER_TOKEN_UNKNOWN`.) - // - // So the #744 lexicographic inversion ('2026-…' sorts below '{') is NOT - // still live on this path, and ⛔ nothing here should carry a workaround - // for it: on rc.2 it reached every spelling the grammar could not see, - // and the 17.2.0 grammar sees them all. The author-time guard in - // `test/metadata-references.test.ts` — it scans the broader - // `/\{([^{}]+)\}/` and rejects any token neither path resolves — still - // earns its keep, by failing at authoring time rather than as a 400 in a - // user's face, and by covering the analytics path the engine gate does - // not. - // - // Correcting the comment is not a licence to change the filter. Whether - // this view should carry a date bound at all — and whether a label - // reading "My Priority Tasks" over a filter with no owner condition is - // the right name — are BEHAVIOUR decisions on #770's line for the task - // views, not this one's. - // - // The sort below is due_date-MAJOR, not priority-major: `priority_rank - // desc` only breaks ties inside a single due date, so a high task due - // tomorrow outranks an urgent one due next week. Measured on rc.2 with - // the shipped sort over four rows — soon/urgent, soon/high, later/urgent, - // later/high, in that order. What stood here said the sort "puts urgent - // at top", which is what the OTHER key order would do. - filter: [ - { field: "status", operator: "in", value: ["not_started", "in_progress"] }, - { field: "priority", operator: "in", value: ["high", "urgent"] } - ], - sort: [{ field: "due_date", order: "asc" }, { field: "priority_rank", order: "desc" }] - }, - /** Overdue / open tasks across the team — sorted oldest-due first */ - overdue_tasks: { - name: "overdue_tasks", - type: "grid", - // Honest label. Two independent reasons were recorded for it; one still - // holds and one has expired (#782), so they are separated here. - // - // STILL TRUE — `is_overdue` is a WRITE-TIME snapshot. `task.hook.ts:68` - // stamps it in `beforeSave` off that moment's clock (`effDue < todayStr` - // and not completed) and nothing re-stamps it afterwards, so a task that - // was on time when it was last saved still reads `is_overdue = false` the - // day after its due date passes. A filter on that column would hand back - // the wrong rows, and it would go wrong silently. - // - // EXPIRED — the other reason said the view layer cannot resolve - // `due_date < {TODAY()}`, and that only `{current_user_id}` interpolates. - // Both halves were wrong already on 17.0.0-rc.2 — the version this repo - // pinned AT THE TIME they were measured, not the current pin — and the - // file said the opposite of - // itself: the note on `todays_tasks` above asserted that - // `{current_user_id}` does NOT interpolate. It does. - // That comment carries the measurements with their versions, INCLUDING - // the one that moved: `{TODAY()}` is REJECTED from 17.2.0 on - // (`FILTER_TOKEN_UNKNOWN`, re-confirmed on 17.3.0 and again on - // 17.4.0 by - // `test/flow-filter-today-token.test.ts`) where on rc.2 it shipped to - // the driver as text, so "cannot resolve `{TODAY()}`" is wrong on the - // current pin for a different reason than it was wrong on rc.2. The - // canonical `{today}` resolves on the read path either way, so a - // strictly past-due filter IS expressible: `due_date < '{today}'` - // selected exactly the past-due rows out of four on rc.2, and did again - // on 17.2.0 (RE-MEASURED 2026-09-03; that row count was not re-taken on - // 17.3.0, where the token's resolution is re-confirmed by the test file - // named above). - // - // So the honest statement is narrower than the one that stood here: this - // view CAN be given a strictly past-due cut through `{today}`, and is not - // given one. Adding it is a BEHAVIOUR change, not a comment correction — - // it would drop today's due-today work out of the queue and turn an - // "Open Tasks" backlog into a strict overdue list, which is the - // cut-versus-ranking question already open on #770 for the task views. - // That also retires the follow-up this comment used to end on: an hourly - // flow re-stamping `is_overdue` was proposed as the ONLY route to a - // truly-overdue gauge, because the filter route was believed closed. - // There are two routes now, and choosing between them belongs to #770. - // - // As shipped: the open-task backlog ordered most-overdue-first (oldest - // due date on top), which is the actionable queue a manager works. - label: "\u23F0 Open Tasks \xB7 Most Overdue First", - userActions: { editInline: true }, - data: { provider: "object", object: "crm_task" }, - columns: ["subject", "priority", "status", "due_date", "owner_id"], - filter: [ - { field: "is_completed", operator: "equals", value: false } - ], - sort: [{ field: "due_date", order: "asc" }] - } - }, - form: { - type: "simple", - sections: [ - { - name: "task", - label: "Task", - columns: 2, - // `type` (call / email / meeting / demo) is what makes an activity - // history readable and is the first thing a rep reaches for after the - // subject — it was missing entirely. `description` captures what was - // actually said on the call. `progress_percent` moved to the Effort - // section: a task being filed is 0% by definition, so a percentage - // slider on the create form is noise. - fields: [ - { field: "subject", required: true, span: "full" }, - { field: "type", required: false }, - { field: "status", required: true }, - "priority", - "due_date", - "owner_id", - "reminder_date", - { field: "description", span: "full" } - ] - }, - { - name: "related_records", - label: "Related Records", - collapsible: true, - columns: 2, - fields: [ - "related_to_account", - "related_to_contact", - "related_to_opportunity", - "related_to_lead", - "related_to_case" - ] - }, - { - name: "recurrence_and_effort", - label: "Recurrence & Effort", - collapsible: true, - collapsed: true, - columns: 2, - fields: [ - "is_recurring", - "recurrence_type", - "recurrence_interval", - "recurrence_end_date", - "progress_percent" - ] - } - ] - } -}); - -// src/sales/views/event.view.ts -import { defineView as defineView8 } from "@objectstack/spec/ui"; -var EventViews = defineView8({ - list: { - type: "grid", - name: "all_events", - label: "All Events", - userActions: { editInline: true }, - data: { provider: "object", object: "crm_event" }, - columns: [ - { field: "subject", width: 280, sortable: true, link: true }, - { field: "type", width: 120, sortable: true }, - { field: "status", width: 120, sortable: true }, - { field: "start_datetime", width: 180, sortable: true }, - { field: "duration_minutes", width: 120, align: "right" }, - { field: "location", width: 180 }, - { field: "owner_id", width: 150 } - ], - sort: [{ field: "start_datetime", order: "desc" }], - rowColor: { - // Mirrors the option colors on crm_event.status. - field: "status", - colors: { planned: "blue", held: "green", cancelled: "slate", no_show: "orange" } - }, - selection: { type: "multiple" }, - pagination: { pageSize: 50 }, - appearance: { - showDescription: true, - allowedVisualizations: ["grid", "calendar", "timeline", "kanban"] - }, - // Binds the 'calendar' entry above: the same span the dedicated - // `event_calendar` view shows. `start_datetime` is required + notNull; - // `end_datetime` is optional, so an event without one stays a single point - // in time rather than borrowing a neighbour's end. - calendar: { - startDateField: "start_datetime", - endDateField: "end_datetime", - titleField: "subject", - colorField: "type" - } - }, - listViews: { - /** The calendar the issue asks for — start → end, coloured by kind. */ - event_calendar: { - name: "event_calendar", - type: "calendar", - label: "Event Calendar", - data: { provider: "object", object: "crm_event" }, - columns: ["subject", "type", "owner_id"], - calendar: { - startDateField: "start_datetime", - endDateField: "end_datetime", - titleField: "subject", - colorField: "type" - } - }, - /** Who is booked when — one lane per rep. */ - event_timeline: { - name: "event_timeline", - type: "timeline", - label: "Team Schedule", - data: { provider: "object", object: "crm_event" }, - columns: ["subject", "status"], - timeline: { - startDateField: "start_datetime", - endDateField: "end_datetime", - titleField: "subject", - groupByField: "owner_id", - colorField: "type", - scale: "day" - } - }, - my_events: { - name: "my_events", - type: "calendar", - label: "My Calendar", - data: { provider: "object", object: "crm_event" }, - columns: ["subject", "type", "location"], - // `{current_user_id}` is the one token the list-view data path really - // interpolates (see crm.app.ts's "My Work" note). - filter: [{ field: "owner_id", operator: "equals", value: "{current_user_id}" }], - calendar: { - startDateField: "start_datetime", - endDateField: "end_datetime", - titleField: "subject", - colorField: "type" - } - }, - /** Booked, not yet held — soonest first. */ - upcoming_events: { - name: "upcoming_events", - type: "grid", - label: "\u{1F4C5} Upcoming \xB7 Soonest First", - userActions: { editInline: true }, - data: { provider: "object", object: "crm_event" }, - columns: ["subject", "type", "start_datetime", "location", "related_to_type", "owner_id"], - filter: [{ field: "status", operator: "equals", value: "planned" }], - sort: [{ field: "start_datetime", order: "asc" }] - }, - /** What actually happened — the interaction history the CRM could not show. */ - held_events: { - name: "held_events", - type: "grid", - label: "\u2705 Interaction History", - userActions: { editInline: true }, - data: { provider: "object", object: "crm_event" }, - columns: ["subject", "type", "start_datetime", "duration_minutes", "related_to_type", "owner_id"], - filter: [{ field: "status", operator: "equals", value: "held" }], - sort: [{ field: "start_datetime", order: "desc" }] - } - }, - form: { - type: "simple", - sections: [ - { - name: "event", - label: "Event", - columns: 2, - fields: [ - { field: "subject", required: true, span: "full" }, - { field: "type", required: true }, - { field: "status", required: true }, - "owner_id", - "location", - { field: "description", span: "full" } - ] - }, - { - name: "schedule", - label: "Schedule", - columns: 2, - fields: [ - { field: "start_datetime", required: true }, - "end_datetime", - "all_day", - "duration_minutes" - ] - }, - { - name: "related_records", - label: "Related Records", - collapsible: true, - columns: 2, - fields: [ - "related_to_account", - "related_to_contact", - "related_to_opportunity", - "related_to_lead", - "related_to_case" - ] - }, - { - name: "outcome", - label: "Outcome", - collapsible: true, - collapsed: true, - columns: 1, - fields: ["outcome_notes"] - } - ] - } -}); - -// src/sales/views/event_attendee.view.ts -import { defineView as defineView9 } from "@objectstack/spec/ui"; -var EventAttendeeViews = defineView9({ - list: { - type: "grid", - name: "all_event_attendees", - label: "Event Attendees", - userActions: { editInline: true }, - data: { provider: "object", object: "crm_event_attendee" }, - columns: [ - { field: "attendee_type", width: 120, sortable: true }, - { field: "crm_contact", width: 200 }, - { field: "crm_lead", width: 200 }, - { field: "sys_user", width: 200 }, - { field: "external_name", width: 200 }, - { field: "response", width: 140, sortable: true }, - { field: "is_organizer", width: 100, align: "center" } - ], - sort: [{ field: "is_organizer", order: "desc" }], - rowColor: { - // Mirrors the option colors on crm_event_attendee.response. - field: "response", - colors: { accepted: "green", declined: "red", tentative: "orange", no_response: "slate" } - }, - pagination: { pageSize: 25 } - }, - form: { - type: "simple", - sections: [ - { - name: "attendee", - label: "Attendee", - columns: 2, - fields: [ - { field: "crm_event", required: true }, - { field: "attendee_type", required: true }, - "crm_contact", - "crm_lead", - "sys_user", - "external_name" - ] - }, - { - name: "invitation", - label: "Invitation", - columns: 2, - fields: ["response", "is_organizer", "invited_date"] - } - ] - } -}); - -// src/sales/views/forecast.view.ts -import { defineView as defineView10 } from "@objectstack/spec/ui"; -var ForecastViews = defineView10({ - list: { - type: "grid", - name: "all_forecasts", - label: "All Forecasts", - userActions: { editInline: true }, - data: { provider: "object", object: "crm_forecast" }, - columns: [ - { field: "owner_id", width: 160, pinned: "left", link: true }, - { field: "period_label", width: 130, sortable: true }, - { field: "period_start", width: 130, sortable: true }, - { field: "snapshot_date", width: 130, sortable: true }, - { field: "quota", width: 130, align: "right", summary: "sum" }, - { field: "closed_amount", width: 140, align: "right", summary: "sum" }, - { field: "commit_amount", width: 140, align: "right", summary: "sum" }, - { field: "best_case_amount", width: 140, align: "right", summary: "sum" }, - { field: "pipeline_amount", width: 140, align: "right", summary: "sum" }, - // No total here: a formula has no stored column to aggregate, so the spec refuses `sum` on a `formula` field (#1980). - { field: "expected_amount", width: 140, align: "right" }, - { field: "attainment_pct", width: 130, align: "right" }, - { field: "coverage_ratio", width: 130, align: "right" }, - { field: "source", width: 130 } - ], - sort: [ - { field: "period_start", order: "desc" }, - { field: "owner_id", order: "asc" } - ], - grouping: { fields: [{ field: "period_label", order: "desc" }] }, - pagination: { pageSize: 50 }, - appearance: { allowedVisualizations: ["grid"] } - }, - listViews: { - this_quarter_forecasts: { - name: "this_quarter_forecasts", - type: "grid", - // The label promises the CURRENT quarter, and the filter delivers it. - // - // The restriction was dropped in #515 on the measurement that "the list - // data path resolves no date macro". That measurement was taken on - // @objectstack 16.1.0 and has since expired: `resolveFilterTokens()` was - // wired into the ObjectQL READ path in 17.0.0-rc.0 (objectql - // `feat(filters): evaluate {filter-token} placeholders server-side`, - // #3582) — `find`/`findOne`/`count`/`aggregate`, ahead of the middleware - // chain, which is the one gate every server-side read passes through, - // saved-view filters included. Measured rather than inferred; - // `test/forecast-current-quarter-view.test.ts` runs THIS filter through a - // real engine and pins the three-way outcome (one quarter selected, not - // zero and not all of them). First taken on 17.0.0-rc.2, RE-RUN - // 2026-09-03 on 17.2.0 (#1467), RE-RUN on 17.3.0 (#1676, after the PR - // #1577 bump) and RE-RUN again on 17.4.0 (#1883, after the PR #1814 - // bump), green all four times. Not yet re-run on 17.5.0; the test is - // what re-takes the reading on each new pin. - // - // Both halves of the key are load-bearing, same as the quota-attainment - // widget in `src/sales/dashboards/sales.dashboard.ts`: `period: 'quarter'` - // alone returns every quarter ever snapshotted (the #730 defect), and - // `period_start` alone merges the quarter row with the MONTH row that - // opens the same quarter — Q3 and July both start on the 1st. - // - // The old `{this_quarter_start}` spelling is not merely unresolved now, - // it is rejected: the resolver throws `Unresolvable filter placeholder` - // and names `{current_quarter_start}` as the fix, so the silent-empty - // failure mode that removal was reacting to is no longer reachable. - label: "This Quarter", - userActions: { editInline: true }, - data: { provider: "object", object: "crm_forecast" }, - columns: ["owner_id", "quota", "closed_amount", "commit_amount", "best_case_amount", "pipeline_amount", "attainment_pct", "coverage_ratio"], - filter: [ - { field: "period", operator: "equals", value: "quarter" }, - { field: "period_start", operator: "equals", value: "{current_quarter_start}" } - ], - // One sort key, because the filter pins `period_start` to a single value - // — the `period_start desc` key that ranked quarters against each other - // existed only to float the current quarter to the top of an unscoped - // list, and is provably inert now that the list holds one quarter. - // - // The tiebreaker is NOT `attainment_pct desc`, which is a FORMULA — the - // engine computes it in JS after the query, so the data engine never saw - // that sort key and the ordering within a quarter was arbitrary (same - // class of defect as #489's `days_in_stage` filter). `closed_amount` is - // the stored numerator behind attainment and ranks the same direction. - sort: [ - { field: "closed_amount", order: "desc" } - ], - // Empty is the honest state, and it needs to say so. The seeds ship no - // current-quarter row on purpose (#702 — the sweep owns that window, and - // two producers in one window is what left a phantom ownerless - // duplicate), so on a fresh install this view is empty until the 03:00 - // `forecast_snapshot` sweep has run once. That is the same trade the - // quota-attainment widget already takes; without this copy the user - // cannot tell it apart from a broken view. - emptyState: { - title: "This Quarter Has No Snapshots Yet", - message: "Quarterly snapshots are written by the nightly forecast sweep. Until it has run once for the current quarter this view is empty \u2014 settled quarters are on the All tab.", - icon: "calendar" - } - }, - my_forecast: { - name: "my_forecast", - type: "grid", - label: "My Forecast", - userActions: { editInline: true }, - data: { provider: "object", object: "crm_forecast" }, - columns: ["period_label", "snapshot_date", "quota", "closed_amount", "commit_amount", "pipeline_amount", "attainment_pct"], - // `{current_user_id}` is the only user token the view runtime resolves - // (`{current_user}` silently never matches). - filter: [{ field: "owner_id", operator: "equals", value: "{current_user_id}" }], - sort: [{ field: "period_start", order: "desc" }] - } - }, - form: { - type: "simple", - sections: [ - { - name: "snapshot", - label: "Snapshot", - columns: 2, - fields: ["owner_id", "period", "period_start", "period_end", "period_label", "snapshot_date", "source"] - }, - { - name: "amounts", - label: "Amounts", - columns: 2, - fields: ["quota", "closed_amount", "commit_amount", "best_case_amount", "pipeline_amount", "expected_amount", "attainment_pct", "coverage_ratio"] - }, - { - name: "notes", - label: "Notes", - columns: 1, - fields: ["notes"] - } - ] - } -}); - -// src/revenue/views/index.ts -var views_exports2 = {}; -__export(views_exports2, { - ContractViews: () => ContractViews, - ProductViews: () => ProductViews, - QuoteViews: () => QuoteViews -}); - -// src/revenue/views/contract.view.ts -import { defineView as defineView11 } from "@objectstack/spec/ui"; -var ContractViews = defineView11({ - list: { - type: "grid", - name: "all_contracts", - label: "All Contracts", - userActions: { editInline: true }, - data: { provider: "object", object: "crm_contract" }, - columns: [ - { field: "contract_number", width: 150, link: true, pinned: "left" }, - { field: "crm_account", width: 200 }, - { field: "crm_opportunity", width: 200 }, - { field: "status", width: 130, sortable: true }, - { field: "contract_value", width: 140, align: "right", summary: "sum" }, - { field: "contract_term_months", width: 130, align: "right" }, - { field: "start_date", width: 130, sortable: true }, - { field: "end_date", width: 130, sortable: true }, - { field: "auto_renewal", width: 110, align: "center" }, - { field: "owner_id", width: 150 } - ], - sort: [{ field: "end_date", order: "asc" }], - pagination: { pageSize: 25 }, - selection: { type: "multiple" }, - appearance: { - allowedVisualizations: ["grid", "calendar", "gantt", "timeline"] - }, - // Binds the 'calendar' entry above: renewal dates, same as the dedicated - // `renewal_calendar` view and the field this list sorts by. A contract - // calendar answers "what renews when" — the start -> end term SPAN is - // already carried by `contract_gantt` and `contract_timeline`, which is - // why `end_date` is the start of the event here rather than an end. - calendar: { - startDateField: "end_date", - titleField: "contract_number", - colorField: "status" - } - }, - listViews: { - /** Renewal calendar (highlights upcoming end dates) */ - renewal_calendar: { - name: "renewal_calendar", - type: "calendar", - label: "Renewal Calendar", - data: { provider: "object", object: "crm_contract" }, - columns: ["contract_number", "crm_account", "status"], - calendar: { - startDateField: "end_date", - titleField: "contract_number", - colorField: "status" - } - }, - /** Contract terms gantt */ - contract_gantt: { - name: "contract_gantt", - type: "gantt", - label: "Contract Terms", - data: { provider: "object", object: "crm_contract" }, - columns: ["contract_number", "crm_account", "contract_value"], - gantt: { - startDateField: "start_date", - endDateField: "end_date", - titleField: "contract_number" - } - }, - /** Chronological timeline */ - contract_timeline: { - name: "contract_timeline", - type: "timeline", - label: "Contract Timeline", - data: { provider: "object", object: "crm_contract" }, - columns: ["contract_number", "crm_account"], - timeline: { - startDateField: "start_date", - endDateField: "end_date", - titleField: "contract_number", - groupByField: "crm_account", - colorField: "status", - scale: "quarter" - } - } - }, - form: { - type: "tabbed", - sections: [ - { - name: "parties", - label: "Parties", - columns: 2, - fields: ["contract_number", "crm_account", "crm_contact", "crm_opportunity", "owner_id", "status"] - }, - { - // Named `contract_terms`, not `terms` — `terms` is already a distinct - // fieldGroup key on `crm_contract` ("Terms & Dates"), and reusing it - // here would make this section's translated heading follow that - // group's wording instead of its own "Terms". - name: "contract_terms", - label: "Terms", - columns: 2, - fields: [ - "contract_term_months", - "start_date", - "end_date", - "contract_value", - "billing_frequency", - "payment_terms", - "auto_renewal", - "renewal_notice_days" - ] - }, - { - name: "signing_and_documents", - label: "Signing & Documents", - columns: 2, - fields: ["signed_date", "signed_by", "document_url"] - }, - { - // The contract's two markdown bodies, together and in the order a - // reader needs them — the question #1826 asked this form to answer. - // They are not redundant, and `content/docs/revenue/contracts.mdx` - // already rules which is which: **Description** is the plain summary - // of what this contract is (declared on the `basic` group, listed - // there under "Contract Information"), while **Special Terms** is - // where every free-text TERM goes — the doc sends renewal - // instructions, an unlisted billing cadence and an unlisted payment - // arrangement to Special Terms by name, three separate times. - // Description was the one field in that inventory no form offered, so - // the summary a reader was told the record carries could not be - // written. One column, because both are long-form. - name: "notes", - label: "Notes", - columns: 1, - fields: ["description", "special_terms", "billing_address"] - } - ] - } -}); - -// src/revenue/views/product.view.ts -import { defineView as defineView12 } from "@objectstack/spec/ui"; -var ProductViews = defineView12({ - list: { - type: "grid", - name: "all_products", - label: "All Products", - userActions: { editInline: true }, - data: { provider: "object", object: "crm_product" }, - columns: [ - { field: "product_code", width: 140, link: true, pinned: "left" }, - { field: "name", width: 240, sortable: true }, - { field: "category", width: 140 }, - { field: "family", width: 140 }, - { field: "sku", width: 140 }, - { field: "list_price", width: 130, align: "right", summary: "avg" }, - { field: "cost", width: 130, align: "right" }, - { field: "is_active", width: 100, align: "center" } - ], - sort: [{ field: "name", order: "asc" }], - grouping: { fields: [{ field: "category", order: "asc" }] }, - pagination: { pageSize: 50 }, - selection: { type: "multiple" }, - appearance: { - allowedVisualizations: ["grid", "gallery"] - } - }, - listViews: { - /** Visual catalog */ - product_catalog: { - name: "product_catalog", - type: "gallery", - label: "Product Catalog", - data: { provider: "object", object: "crm_product" }, - columns: ["name", "category", "list_price"], - gallery: { - coverField: "image", - coverFit: "cover", - cardSize: "medium", - titleField: "name", - visibleFields: ["product_code", "category", "family", "list_price", "sku"] - } - } - }, - form: { - type: "simple", - sections: [ - { - name: "product_info", - label: "Product Info", - columns: 2, - fields: [ - "product_code", - { field: "name", required: true, span: "full" }, - "category", - "family", - "sku", - "product_manager", - "is_active" - ] - }, - { - name: "pricing_info", - label: "Pricing", - columns: 2, - fields: ["list_price", "cost"] - }, - { - name: "media", - label: "Media", - columns: 1, - fields: ["image", "datasheet", "description"] - } - ] - } -}); - -// src/revenue/views/quote.view.ts -import { defineView as defineView13 } from "@objectstack/spec/ui"; -var QuoteViews = defineView13({ - list: { - type: "grid", - name: "all_quotes", - label: "All Quotes", - userActions: { editInline: true }, - data: { provider: "object", object: "crm_quote" }, - columns: [ - { field: "quote_number", width: 140, link: true, pinned: "left" }, - { field: "crm_account", width: 200 }, - { field: "crm_opportunity", width: 200 }, - { field: "status", width: 130, sortable: true }, - { field: "quote_date", width: 130, sortable: true }, - { field: "expiration_date", width: 140, sortable: true }, - { field: "subtotal", width: 130, align: "right", summary: "sum" }, - { field: "discount", width: 110, align: "right" }, - { field: "tax", width: 110, align: "right", summary: "sum" }, - { field: "total_price", width: 140, align: "right", summary: "sum" }, - { field: "owner_id", width: 150 } - ], - sort: [{ field: "quote_date", order: "desc" }], - pagination: { pageSize: 25 }, - selection: { type: "multiple" }, - appearance: { - allowedVisualizations: ["grid", "kanban", "calendar"] - }, - // Binds the 'calendar' entry above: the same span the dedicated - // `quote_calendar` view shows. `quote_date` and `expiration_date` are both - // required + notNull on crm_quote, so every quote lands on a real window. - calendar: { - startDateField: "quote_date", - endDateField: "expiration_date", - titleField: "quote_number", - colorField: "status" - } - }, - listViews: { - /** Quote workflow board */ - quote_pipeline: { - name: "quote_pipeline", - type: "kanban", - label: "Quote Pipeline", - data: { provider: "object", object: "crm_quote" }, - columns: ["quote_number", "crm_account", "total_price", "expiration_date"], - kanban: { - groupByField: "status", - summarizeField: "total_price", - columns: ["quote_number", "crm_account", "total_price", "expiration_date"] - } - }, - /** Quote-date calendar */ - quote_calendar: { - name: "quote_calendar", - type: "calendar", - label: "Quote Calendar", - data: { provider: "object", object: "crm_quote" }, - columns: ["quote_number", "crm_account", "total_price"], - calendar: { - startDateField: "quote_date", - endDateField: "expiration_date", - titleField: "quote_number", - colorField: "status" - } - } - }, - form: { - type: "tabbed", - sections: [ - { - name: "quote", - label: "Quote", - columns: 2, - // `name` is required on crm_quote with no default — omitting it made - // quote creation through this form impossible. - fields: [{ field: "name", required: true, span: "full" }, "quote_number", "crm_account", "crm_contact", "crm_opportunity", "owner_id", "status", "quote_date", "expiration_date"] - }, - { - name: "totals", - label: "Totals", - columns: 2, - fields: ["subtotal", "discount", "discount_amount", "tax", "shipping_handling", "total_price"] - }, - { - // Named `quote_terms`, not `terms` — `terms` is already a distinct - // fieldGroup key on `crm_quote` ("Terms & Validity"), and reusing it - // here would make this section's translated heading follow that - // group's wording instead of its own "Terms". - name: "quote_terms", - label: "Terms", - columns: 2, - fields: ["payment_terms", "shipping_terms"] - }, - { - name: "addresses_and_notes", - label: "Addresses & Notes", - columns: 1, - fields: ["billing_address", "shipping_address", "internal_notes"] - } - ] - } -}); - -// src/marketing/views/index.ts -var views_exports3 = {}; -__export(views_exports3, { - CampaignViews: () => CampaignViews -}); - -// src/marketing/views/campaign.view.ts -import { defineView as defineView14 } from "@objectstack/spec/ui"; -var CampaignViews = defineView14({ - list: { - type: "grid", - name: "all_campaigns", - label: "All Campaigns", - userActions: { editInline: true }, - data: { provider: "object", object: "crm_campaign" }, - columns: [ - { field: "name", width: 240, sortable: true, link: true, pinned: "left" }, - { field: "channel", width: 130 }, - { field: "status", width: 130, sortable: true }, - { field: "start_date", width: 130, sortable: true }, - { field: "end_date", width: 130, sortable: true }, - { field: "budgeted_cost", width: 140, align: "right", summary: "sum" }, - { field: "expected_revenue", width: 160, align: "right", summary: "sum" } - ], - sort: [{ field: "start_date", order: "asc" }], - pagination: { pageSize: 25 }, - selection: { type: "multiple" }, - appearance: { - showDescription: true, - allowedVisualizations: ["grid", "gantt", "calendar", "timeline"] - }, - // Binds the 'calendar' entry above: the switcher opens the same schedule - // the dedicated `campaign_calendar` view shows. Both dates are required + - // notNull on crm_campaign, so every campaign spans a truthful range. - calendar: { - startDateField: "start_date", - endDateField: "end_date", - titleField: "name", - colorField: "channel" - } - }, - listViews: { - /** Campaign schedule */ - campaign_gantt: { - name: "campaign_gantt", - type: "gantt", - label: "Campaign Schedule", - data: { provider: "object", object: "crm_campaign" }, - columns: ["name", "channel"], - gantt: { - startDateField: "start_date", - endDateField: "end_date", - titleField: "name" - } - }, - /** Launch calendar */ - campaign_calendar: { - name: "campaign_calendar", - type: "calendar", - label: "Launch Calendar", - data: { provider: "object", object: "crm_campaign" }, - columns: ["name", "channel", "status"], - calendar: { - startDateField: "start_date", - endDateField: "end_date", - titleField: "name", - colorField: "channel" - } - }, - /** Marketing timeline */ - campaign_timeline: { - name: "campaign_timeline", - type: "timeline", - label: "Marketing Timeline", - data: { provider: "object", object: "crm_campaign" }, - // The list data source projects configured columns. Keep the date - // fields in that projection so the timeline renderer can bucket and - // order campaigns from the same schedule data as the calendar/Gantt. - columns: ["name", "channel", "start_date", "end_date"], - timeline: { - startDateField: "start_date", - endDateField: "end_date", - titleField: "name", - groupByField: "channel", - colorField: "status", - scale: "month" - } - } - }, - form: { - type: "tabbed", - sections: [ - { - // Every form section here carries a `name` matching the object's - // fieldGroup key, so the heading resolves through - // `objects.crm_campaign._sections..label` in all four packs. A - // nameless section has no key a bundle can carry and renders its - // English label in every locale — the platform warns about exactly this - // during `objectstack validate`, and this form was carrying four of - // those warnings before the #597 restructure gave it a reason to move. - name: "basic", - label: "Campaign Information", - columns: 2, - fields: [ - { field: "name", required: true, span: "full" }, - "campaign_code", - "type", - "channel", - { field: "status", required: true }, - "owner_id", - "is_active", - "landing_page_url", - // The markdown body of the campaign brief. Declared on the `basic` - // group and filled by seven of the seed campaigns, but omitted from - // this enumeration — so the only surface that could show it did not, - // and a marketer could neither read nor write the brief they wrote. - { field: "description", span: "full" } - ] - }, - { - name: "schedule", - label: "Schedule", - columns: 2, - fields: ["start_date", "end_date"] - }, - { - /** - * Budget & ROI — a SECTION OF ITS OWN, deliberately (#597). - * - * `budgeted_cost` and `actual_cost` are the only two campaign numbers - * that are manual-entry by design: nothing on the platform knows what a - * trade-show booth cost. They used to sit seventh and eighth in a - * seven-field "Schedule & Budget" row, below the dates and beside two - * revenue figures one of which the metric hooks own — so the two fields - * a marketer must type were the least visible things on the form, and - * `actual_cost` in particular went untyped. - * - * That is not a cosmetic complaint: `roi` divides by `actual_cost`, and - * its formula answers a flat `0.0` for any campaign where that field is - * blank. An empty cost field renders as 0% ROI on every campaign — the - * one number the whole Performance section exists to produce, reading - * as a real measurement rather than as missing input. - * - * So the costs get their own heading, and `roi` is displayed HERE with - * them rather than at the bottom of Performance, where its dependency - * on two fields three sections away was invisible. The heading matches - * the object's `budget` fieldGroup, so the form and the detail page - * agree on what this group is called. - */ - name: "budget", - label: "Budget & ROI", - columns: 2, - fields: ["budgeted_cost", "actual_cost", "expected_revenue", "actual_revenue", "roi"] - }, - { - name: "metrics", - label: "Performance", - columns: 2, - fields: [ - "target_size", - "num_sent", - "num_responses", - "num_leads", - "num_converted_leads", - "num_opportunities", - "num_won_opportunities", - "response_rate" - ] - } - ] - } -}); - -// src/sales/pages/index.ts -var pages_exports = {}; -__export(pages_exports, { - AccountDetailPage: () => AccountDetailPage, - AccountWorkbenchPage: () => AccountWorkbenchPage, - AppLauncherPage: () => AppLauncherPage, - LeadDetailPage: () => LeadDetailPage, - OpportunityDetailPage: () => OpportunityDetailPage, - SalesHomePage: () => SalesHomePage, - UtilityBarPage: () => UtilityBarPage -}); - -// src/sales/pages/lead_detail.page.ts -import { P as P25 } from "@objectstack/spec"; -var LeadDetailPage = { - name: "lead_detail_page", - label: "Lead Detail", - description: "Comprehensive lead detail page with highlights, details, and related information", - type: "record", - object: "crm_lead", - // Template defines the overall layout structure. We use `full-width` - // (single column) because the previous `header-sidebar-main` layout - // sandwiched the highlights strip into a cramped sidebar with no other - // meaningful sidebar content — Salesforce Lightning record pages - // similarly default to a stacked column for medium-density objects. - template: "full-width", - kind: "full", - // Page-level state variables - variables: [ - { - name: "showHistory", - type: "boolean", - defaultValue: false - }, - { - name: "activeTab", - type: "string", - defaultValue: "details" - } - ], - // Regions correspond to slots in the template - regions: [ - { - name: "header", - width: "full", - components: [ - // Title + subtitle + icon, with record-level actions rendered - // inline in the header's action slot via the first-class - // `actions` property (no sibling node, no visual offset hack). - { - type: "page:header", - id: "lead_header", - label: "Lead Information", - properties: { - title: "{first_name} {last_name}", - subtitle: "{company}", - // `icon` removed from `page:header` in @objectstack/spec 17.0.0 - // (#6946, ADR-0087 D2) — deleted, not renamed. See the full note on - // `account_detail.page.ts`; nothing ever drew it. - // `breadcrumb` retired from `page:header` in @objectstack/spec 17.6.0 - // (#20785, `page-header-breadcrumb-removed`) — deleted: no renderer - // ever drew a trail for it; the app shell's own trail is unchanged. - // Convert is the outcome; scheduling the next touch is the daily - // act. Both belong in the header — the follow-up used to be four - // clicks deep in the Related tab. - // - // The three activity actions are listed EXPLICITLY (#592): a custom - // record page replaces the synthesized header, so an object-scoped - // action that is not named here is unreachable from the record — - // only the list-row ⋮ menu can fire it. Logging the call you just - // made is the single most frequent thing a rep does on a lead, and - // it was two navigations away. - // - // Action IDs, not `ActionDef` objects: `PageHeaderProps.actions` is - // `z.array(z.string())` ("Action IDs to show in header") in - // @objectstack/spec 17.3.0, and this repo authors against the - // protocol (#1653). Each id is the `name` of a crm_lead-scoped - // action — `convert_lead` / `schedule_followup` in - // `src/sales/actions/lead.actions.ts`, the activity trio in - // `src/sales/actions/activity-actions.ts`. - actions: [ - "convert_lead", - "schedule_followup", - "log_call", - "log_meeting", - "schedule_meeting" - ] - } - }, - // Duplicate banners — ONE PER VERDICT (#1207 · widened by #1289 · - // split by #1628). - // - // `lead_duplicate_check` (lead.hook.ts, job 2) already writes - // `duplicate_status: 'suspected'` and links the record the lead repeats - // — the flag existed, and this page never read it. A rep opened a - // flagged lead, saw a page identical to a clean one, and converted it - // into a second account, contact and opportunity. These banners and the - // `duplicates` section on the Details tab are the record-page half of - // that fix — the banner is the alarm, the section is the link to - // compare against; the conversion screen carries the other half. - // - // ## Why there are TWO of them (#1628) - // - // #1207 shipped one banner gated on `== "suspected"`, which left the - // STRONGER state silent. #1289 widened the predicate to every verdict - // and, being one component, had to pick copy that named NEITHER state: - // a `record:alert` carries a single `visible` and a single title/body - // pair, and `pickLocalized` picks by LANGUAGE, not by row — so naming - // one verdict would have mislabelled every lead in the other. - // - // That was correct for one banner, and it is why one banner is not - // enough. Since #1288 the two verdicts have OPPOSITE next steps: - // - // suspected — the intake hook's guess. Conversion PROCEEDS; the rep - // should compare against the linked record first. - // confirmed — a reviewer's verdict. Conversion is REFUSED outright - // (`lead-conversion.flow.ts`, `refuse_confirmed_duplicate`). - // - // One sentence cannot state either without being false for the other, - // so it stated neither, and the rep had to scroll to the Duplicate - // Status chip to learn which situation they were in. A banner that - // announces something is wrong but not what to do is not doing the one - // job a banner has. Two components, two predicates, two next steps. - // - // ⚠️ Two sibling `record:alert` nodes really do BOTH render: a region - // renders as `components.map((node, i) => )` — read out of the shipped console bundle at the - // `.objectui-sha` pin — so each is mounted separately and evaluates its - // own `visible` against the same row. Their `id`s are their React keys, - // which is why the two ids differ rather than sharing one. - // - // ⚠️ `visible` is the ONE record component whose PROPS carry a real row - // predicate: `record-alert.tsx` evaluates `properties.visible` through - // `toPredicateInput` + `useCondition` against the row - // (`usePredicateRecordContext`), the same pipeline as an action button. - // A node-level `visibleWhen` is a different gate one tier up, - // evaluated by `SchemaRenderer`, and the two compose as AND. Measured - // on the 17.6.0 pin (#1887), that tier binds the page's row as - // `record` too (objectui#5454): this same predicate, moved there, - // gated correctly in both directions. `visible` stays because it is - // the gate `record:alert` declares in its own props. - // - // ⚠️ `has()` is load-bearing, and this surface is the WORST of the four - // this repo measures (cf. `test/view-predicate-dialect.test.ts`): the - // renderer's call site is FAIL-SOFT — an unevaluable predicate answers - // SHOWN. So a bare `record.duplicate_status == "suspected"` would abort - // with `No such key` on every clean lead whose driver omits the column - // (`driver-memory` / `driver-mongodb`; `driver-sql` returns it as null) - // and put a duplicate warning on leads that are not duplicates. The - // guard is what makes the predicate answer `false` instead of faulting. - // Pinned on the real engine in `test/lead-duplicate-visibility.test.ts`. - // - // ⛔ And the guard is NOT the whole predicate — `has()` ALONE is wrong - // here, in either shape. It is TRUE for a key that is PRESENT AND NULL, - // which is precisely what `driver-sql` hands back for a clean lead - // (measured: `has(record.duplicate_status)` against - // `{ duplicate_status: null }` answers `{ ok: true, value: true }`), so - // the guard needs a comparison beside it or the banner cries wolf on - // every clean lead. #1289, covering both verdicts at once, spelled that - // comparison `&& … != null`. A per-verdict banner spells it with the - // EQUALITY, which is strictly narrower and subsumes it: measured on - // this engine, `null == "suspected"` is a clean `false`, not a fault, - // and the two spellings agree on every record shape a driver can - // produce. Both halves of the shape #1289 ruled for are intact — the - // `has()` guard verbatim, and a comparison that makes "set" mean set — - // and the comparison got STRICTER, which is the point of the split. The - // same spelling already ships one file over, on this same field: the - // conversion flow's `e21` / `e25` edges (#1288) read - // `has(vars.leadRecord.duplicate_status) && … == "suspected"`. - // - // ⛔ Neither half may be simplified away. Both are pinned, shape by - // shape, including the reverse pin that the unguarded tail really does - // fault. - // - // `P` — an explicit `{ dialect: 'cel' }` envelope — is not decoration - // either: `ExpressionEvaluator.evaluateCondition` routes ONLY the - // envelope to `@objectstack/formula`'s CEL engine, where `has()` is a - // real function; a bare string takes the legacy JS path, whose - // `FormulaFunctions` has no CEL `has()`, so the guard would itself be - // the fault that fails soft to visible. - // - // `title` / `body` carry inline locale maps rather than plain strings: - // this renderer resolves both through `pickLocalized(…, language)` - // (the same capability `opportunity_detail.page.ts` records under - // #972), and `body` has no other channel — the i18n extractor's - // per-component copy keys (`PAGE_COMPONENT_COPY_KEYS`, read on 17.6.0) - // are title/description/label/placeholder/emptyText, so a plain-string - // `body` would ship English to all four locales. Keeping both halves of one banner's copy in one - // place beats splitting `title` into the locale packs. - // - // ⭐ Each banner's copy NAMES ITS OWN VERDICT, in the vocabulary the - // `duplicate_status` chip below publishes, and never the other one — - // pinned against the option labels read out of the locale packs in - // `test/lead-duplicate-visibility.test.ts`, so renaming an option - // re-aims the assertion rather than retiring it. - { - type: "record:alert", - id: "lead_duplicate_alert_suspected", - label: "Suspected Duplicate Alert", - properties: { - // `warning`, not `error`: conversion still PROCEEDS on this - // verdict, and the renderer maps `error` to `role="alert"` / - // `aria-live="assertive"` — an interruption this state has not - // earned. - severity: "warning", - visible: P25`has(record.duplicate_status) && record.duplicate_status == "suspected"`, - title: { - en: "Suspected duplicate \u2014 compare before you convert", - "zh-CN": "\u7591\u4F3C\u91CD\u590D\u2014\u2014\u8F6C\u6362\u524D\u8BF7\u5148\u6BD4\u5BF9", - "ja-JP": "\u91CD\u8907\u306E\u7591\u3044 \u2014 \u5909\u63DB\u3059\u308B\u524D\u306B\u7167\u5408\u3057\u3066\u304F\u3060\u3055\u3044", - "es-ES": "Duplicado Sospechoso: compare antes de convertir" - }, - body: { - en: "Intake matched this lead to a record this app already has. Duplicate Management below links that record \u2014 open it and compare. You can still convert this lead: this is the match intake guessed at, not a reviewer's decision. But if it is the same buyer, disqualify it instead, because converting creates a second account, contact and opportunity for them.", - "zh-CN": "\u5F55\u5165\u65F6\u53D1\u73B0\u8BE5\u7EBF\u7D22\u4E0E\u7CFB\u7EDF\u4E2D\u5DF2\u6709\u8BB0\u5F55\u5339\u914D\u3002\u4E0B\u65B9\u300C\u91CD\u590D\u7EBF\u7D22\u7BA1\u7406\u300D\u4E2D\u662F\u5B83\u91CD\u590D\u7684\u90A3\u6761\u8BB0\u5F55\uFF0C\u8BF7\u5148\u6253\u5F00\u6BD4\u5BF9\u3002\u8BE5\u7EBF\u7D22\u4ECD\u7136\u53EF\u4EE5\u8F6C\u6362\uFF1A\u8FD9\u662F\u5F55\u5165\u65F6\u7684\u81EA\u52A8\u5224\u65AD\uFF0C\u4E0D\u662F\u5BA1\u6838\u4EBA\u7684\u7ED3\u8BBA\u3002\u4F46\u82E5\u786E\u5C5E\u540C\u4E00\u5BA2\u6237\uFF0C\u8BF7\u6539\u4E3A\u53D6\u6D88\u8D44\u683C\u2014\u2014\u8F6C\u6362\u4F1A\u4E3A\u540C\u4E00\u5BA2\u6237\u518D\u521B\u5EFA\u4E00\u5957\u5BA2\u6237\u3001\u8054\u7CFB\u4EBA\u548C\u5546\u673A\u3002", - "ja-JP": "\u767B\u9332\u6642\u306B\u3001\u3053\u306E\u30EA\u30FC\u30C9\u304C\u65E2\u5B58\u30EC\u30B3\u30FC\u30C9\u3068\u4E00\u81F4\u3057\u307E\u3057\u305F\u3002\u4E0B\u306E\u300C\u91CD\u8907\u7BA1\u7406\u300D\u306B\u91CD\u8907\u5148\u306E\u30EC\u30B3\u30FC\u30C9\u304C\u3042\u308A\u307E\u3059\u3002\u307E\u305A\u958B\u3044\u3066\u7167\u5408\u3057\u3066\u304F\u3060\u3055\u3044\u3002\u3053\u306E\u30EA\u30FC\u30C9\u306F\u307E\u3060\u5909\u63DB\u3067\u304D\u307E\u3059\u3002\u3053\u308C\u306F\u767B\u9332\u6642\u306E\u81EA\u52D5\u5224\u5B9A\u3067\u3042\u308A\u3001\u62C5\u5F53\u8005\u306E\u7D50\u8AD6\u3067\u306F\u3042\u308A\u307E\u305B\u3093\u3002\u305F\u3060\u3057\u540C\u3058\u76F8\u624B\u3067\u3042\u308C\u3070\u3001\u5909\u63DB\u305B\u305A\u4E0D\u9069\u683C\u306B\u3057\u3066\u304F\u3060\u3055\u3044\u3002\u5909\u63DB\u3059\u308B\u3068\u540C\u3058\u76F8\u624B\u306B\u53D6\u5F15\u5148\u30FB\u53D6\u5F15\u5148\u8CAC\u4EFB\u8005\u30FB\u5546\u8AC7\u304C\u3082\u3046\u4E00\u7D44\u4F5C\u6210\u3055\u308C\u307E\u3059\u3002", - "es-ES": "La captura encontr\xF3 que este prospecto coincide con un registro que ya existe. Gesti\xF3n de Duplicados, m\xE1s abajo, enlaza ese registro: \xE1bralo y comp\xE1relo. Todav\xEDa puede convertir este prospecto, porque se trata de una coincidencia autom\xE1tica de la captura y no del veredicto de una persona. Pero si es el mismo comprador, descalif\xEDquelo en su lugar: convertirlo crea una segunda cuenta, contacto y oportunidad para \xE9l." - } - } - }, - { - type: "record:alert", - id: "lead_duplicate_alert_confirmed", - label: "Confirmed Duplicate Alert", - properties: { - // `error`, and the level is the message: this is the state on which - // the app REFUSES the rep's next click, and the renderer gives - // `error` `role="alert"` / `aria-live="assertive"` rather than the - // polite `role="status"` every other level gets. ⛔ The severity is - // presentation only — what the app refuses was ruled by #1288 and - // shipped by PR #1555, and nothing here changes it. - severity: "error", - visible: P25`has(record.duplicate_status) && record.duplicate_status == "confirmed"`, - title: { - en: "Confirmed duplicate \u2014 conversion will be refused", - "zh-CN": "\u5DF2\u786E\u8BA4\u91CD\u590D\u2014\u2014\u8F6C\u6362\u5C06\u88AB\u62D2\u7EDD", - "ja-JP": "\u91CD\u8907\u78BA\u5B9A \u2014 \u5909\u63DB\u306F\u62D2\u5426\u3055\u308C\u307E\u3059", - "es-ES": "Duplicado Confirmado: la conversi\xF3n ser\xE1 rechazada" - }, - body: { - // ⭐ The only place a rep learns the Convert button will refuse - // them BEFORE they press it — until this banner, the refusal - // dialog was the first they heard of it. - en: "A reviewer checked this lead and recorded that it repeats a record this app already has, so Convert Lead refuses it \u2014 this banner is the only warning you get before you press the button. Disqualify this lead instead, naming the surviving record from Duplicate Management below. If the verdict is wrong, a reviewer revises Duplicate Status; there is no override here.", - "zh-CN": "\u5BA1\u6838\u4EBA\u5DF2\u6838\u5B9E\u8BE5\u7EBF\u7D22\u4E0E\u7CFB\u7EDF\u4E2D\u5DF2\u6709\u8BB0\u5F55\u91CD\u590D\uFF0C\u56E0\u6B64\u300C\u8F6C\u6362\u7EBF\u7D22\u300D\u4F1A\u62D2\u7EDD\u6267\u884C\u2014\u2014\u672C\u63D0\u793A\u662F\u4F60\u6309\u4E0B\u6309\u94AE\u524D\u552F\u4E00\u7684\u9884\u8B66\u3002\u8BF7\u6539\u4E3A\u53D6\u6D88\u8BE5\u7EBF\u7D22\u7684\u8D44\u683C\uFF0C\u5E76\u5728\u4E0B\u65B9\u300C\u91CD\u590D\u7EBF\u7D22\u7BA1\u7406\u300D\u4E2D\u6CE8\u660E\u4FDD\u7559\u7684\u90A3\u6761\u8BB0\u5F55\u3002\u82E5\u5224\u5B9A\u6709\u8BEF\uFF0C\u5E94\u7531\u5BA1\u6838\u4EBA\u4FEE\u6539\u300C\u91CD\u590D\u72B6\u6001\u300D\uFF0C\u6B64\u5904\u4E0D\u63D0\u4F9B\u5F3A\u5236\u8F6C\u6362\u7684\u5165\u53E3\u3002", - "ja-JP": "\u62C5\u5F53\u8005\u304C\u78BA\u8A8D\u3057\u3001\u3053\u306E\u30EA\u30FC\u30C9\u306F\u65E2\u5B58\u30EC\u30B3\u30FC\u30C9\u306E\u91CD\u8907\u3067\u3042\u308B\u3068\u8A18\u9332\u3055\u308C\u307E\u3057\u305F\u3002\u305D\u306E\u305F\u3081\u300C\u30EA\u30FC\u30C9\u5909\u63DB\u300D\u306F\u62D2\u5426\u3055\u308C\u307E\u3059\u3002\u3053\u306E\u901A\u77E5\u304C\u3001\u30DC\u30BF\u30F3\u3092\u62BC\u3059\u524D\u306B\u5F97\u3089\u308C\u308B\u552F\u4E00\u306E\u8B66\u544A\u3067\u3059\u3002\u3053\u306E\u30EA\u30FC\u30C9\u306F\u4E0D\u9069\u683C\u306B\u3057\u305F\u3046\u3048\u3067\u3001\u4E0B\u306E\u300C\u91CD\u8907\u7BA1\u7406\u300D\u3067\u6B8B\u3059\u30EC\u30B3\u30FC\u30C9\u3092\u660E\u8A18\u3057\u3066\u304F\u3060\u3055\u3044\u3002\u5224\u5B9A\u304C\u8AA4\u3063\u3066\u3044\u308B\u5834\u5408\u306F\u62C5\u5F53\u8005\u304C\u300C\u91CD\u8907\u30B9\u30C6\u30FC\u30BF\u30B9\u300D\u3092\u4FEE\u6B63\u3057\u307E\u3059\u3002\u3053\u3053\u306B\u5F37\u5236\u5909\u63DB\u306E\u624B\u6BB5\u306F\u3042\u308A\u307E\u305B\u3093\u3002", - "es-ES": "Una persona verific\xF3 que este prospecto repite un registro que ya existe, por lo que Convertir Prospecto lo rechazar\xE1: este aviso es la \xFAnica advertencia antes de pulsar el bot\xF3n. Descalifique el prospecto e indique el registro que sobrevive desde Gesti\xF3n de Duplicados, m\xE1s abajo. Si el veredicto es incorrecto, una persona debe cambiar el Estado del Duplicado; aqu\xED no hay forma de forzar la conversi\xF3n." - } - } - }, - // Salesforce-style Highlights Panel: a horizontal strip of the - // most-important key facts directly under the header. Pulled out - // of the sidebar so it can use the full page width. - { - type: "record:highlights", - id: "lead_highlights", - label: "Key Information", - properties: { - fields: ["status", "rating", "lead_source", "owner_id", "email", "phone"] - } - }, - { - type: "record:path", - id: "lead_path", - label: "Lead Status Path", - properties: { - statusField: "status", - // `converted` is the terminal WIN state and must be on the path — - // without it the strip reads as if "Unqualified" were the goal, and - // a converted lead had no stage to light up at all. - stages: [ - { value: "new", label: "New" }, - { value: "contacted", label: "Contacted" }, - { value: "qualified", label: "Qualified" }, - { value: "converted", label: "Converted" }, - { value: "unqualified", label: "Unqualified" } - ] - } - } - ] - }, - { - name: "main", - width: "large", - components: [ - { - type: "page:tabs", - id: "main_tabs", - label: "Lead Information Tabs", - properties: { - // `type` → `tabStyle` (@objectstack/spec 17.0.0, #6776, ADR-0087 - // D2). Same three values; see the full note on `home.page.ts`. - tabStyle: "line", - position: "top", - items: [ - { - label: "Details", - icon: "info-circle", - children: [ - { - type: "record:details", - id: "lead_details", - label: "Lead Details", - properties: { - columns: "2", - // `layout` was REMOVED from `record:details` in - // @objectstack/spec 17.0.0 (#6946, ADR-0087 D2) and is - // deleted with no successor: its `auto` | `custom` - // semantics were never implemented. - // - // Every section is a GROUP REFERENCE (#806, maintainer - // ruling C, decision batch #21, 2026-09-03). `{ group }` - // names one of crm_lead's `fieldGroups`, and the renderer - // derives that section's members, label, icon and collapse - // state from the object (`deriveFieldGroupLayout`, - // ADR-0085 §5). Membership has ONE declaration site — the - // `group:` on each field in lead.object.ts — and this page - // curates only the ORDER, so a field added to a group shows - // up here with no edit to this file. ⛔ Do not enumerate - // `fields:` again, and do not restate a key the group owns - // (`name` / `label` / `icon` / `collapsible` / - // `defaultCollapsed`) beside `group`: the spec refuses both. - // - // ⛔ `sections` stays load-bearing. Omitting it renders an - // EMPTY Details tab, not a `fieldGroups` fallback (#806 R28 - // on 17.2.0, #1521); derivation is per section, through - // `group:`, never page-level. - // - // Measured on @objectstack/console 17.6.0 (#806 R70, - // headless Chromium, with a control leg; on 17.4.0 R61 - // measured this form crashing the component). What a - // group section does there is the renderer's, not ours: - // - it lays out its own column count (the page-level - // `columns` above does not reach it); - // - a group whose members are all empty renders nothing - // (`duplicates` on a clean lead), unless the section - // says `hideEmpty: false`; - // - members the highlights strip registered are dropped, - // so `assignment` (only `owner_id`) renders nothing on - // this page — the owner is in the strip; - // - a group declared `collapse: 'collapsed'` starts - // collapsed; changing that is a `fieldGroups` decision - // in lead.object.ts, not a key on this page. - // - // `hideEmpty: false` (#2003, the #1211 reasoning) sits on - // the groups whose every member a rep types and the - // create form asks for: `contact_info` (`mobile` and - // `website` once the strip takes `email` and `phone`), - // `address`, and `additional` (revenue, headcount, - // description, notes). Without it all three vanish on a - // fresh lead, so a rep cannot see what is left to fill. - // Not on `assignment`: its derived list is empty, and the - // renderer draws nothing for an empty list whatever - // `hideEmpty` says. Not on `duplicates`: the - // `lead_duplicate_check` hook writes it. - sections: [ - { group: "identity" }, - { group: "company_info" }, - { group: "contact_info", hideEmpty: false }, - // Do Not Call / Email Opt Out, right under the numbers - // a rep is about to dial (#806). - { group: "preferences" }, - { group: "qualification" }, - { group: "assignment" }, - { group: "address", hideEmpty: false }, - { group: "conversion" }, - // The LINK half of the duplicate banners (#1207): the - // group carries both survivor lookups, because - // `lead_duplicate_check` matches contacts before leads. - // On a clean lead every member is empty, so the section - // renders nothing. ⚠️ Not the highlights strip: - // `record:highlights` caps `fields` at 7 and holds 6. - { group: "duplicates" }, - // Description and Notes — kept last, where the page's - // Description section always sat. - { group: "additional", hideEmpty: false } - ] - } - } - ] - }, - { - label: "Related", - icon: "link", - children: [ - { - type: "page:accordion", - id: "related_accordion", - label: "Related Records", - properties: { - allowMultiple: true, - items: [ - { - label: "Tasks", - icon: "list-checks", - collapsed: false, - children: [ - { - type: "record:related_list", - id: "related_tasks", - label: "Tasks", - properties: { - objectName: "crm_task", - // crm_task links back through the polymorphic - // `related_to_lead` lookup; there is no `lead_id` - // column, so the old binding matched nothing and - // this list read "0" no matter how many follow-ups - // the rep had filed. - relationshipField: "related_to_lead", - columns: ["subject", "status", "priority", "due_date", "owner_id"], - sort: [ - { field: "due_date", order: "asc" } - ], - limit: 10, - title: "Open Tasks", - filter: [{ field: "status", operator: "not_equals", value: "completed" }], - showViewAll: true - } - } - ] - } - ] - } - } - ] - }, - { - label: "Activity", - icon: "clock", - children: [ - { - type: "record:activity", - id: "lead_activity", - label: "Activity Timeline", - properties: { - // `types` is keyed on FEED ITEM KIND, never on object name - // (#1209). The old `['crm_task']` was not one of the kinds - // the prop accepts, and nothing anywhere enforced that: the - // page schema's `properties` is an open bag - // (`z.record(z.string(), z.unknown())`) so the value was - // stored verbatim, and the renderer's own sanitiser drops - // members it does not recognise and then reads the EMPTY - // remainder as "no filter authored" — measured on the - // shipped bundle, `types: ['crm_task']`, `types: []` and - // omitting `types` all render the same unfiltered stream. - // That is why the tab showed `Created Lead` / `Updated - // Lead` audit rows, which the History tab already covers. - // - // What this component can actually show is `sys_activity` - // scoped to the record, through the renderer's own - // type map — measured, not inferred: - // - // sys_activity.type feed kind written by - // created/updated/… field_change platform audit - // system system platform - // completed task log_call / - // log_meeting / - // send_email - // scheduled (dropped) schedule_meeting - // - // So `task` is the kind that carries a rep's logged - // interactions, and it is the only reachable one worth - // filtering to. `event` is NOT added: it is a legal kind - // the prop accepts but no `sys_activity.type` maps to it, - // so it would be a declared value enforced by nothing. - // `scheduled` rows fall out of the map upstream — a - // platform gap, not something to work around here. - types: ["task"], - limit: 20, - // Load-bearing, not cosmetic: the renderer strips every - // `task` item BEFORE the `types` filter runs unless this is - // true, and `task` items are exactly the `completed` rows. - // `types: ['task']` with the old `showCompleted: false` - // renders an empty tab. - showCompleted: true - } - } - ] - }, - { - label: "History", - icon: "history", - children: [ - { - // `record:history` is the platform's own audit feed over the - // fields marked `trackHistory` (status / rating). Ownership - // moved to the platform's `owner_id` in #548, which carries no - // `trackHistory` flag — transfers land in the compliance audit - // log, not on this feed. - // The hand-rolled version queried an object named - // `field_history`, which this app does not define, so the - // tab could only ever render empty. - type: "record:history", - id: "lead_history", - label: "Field History", - properties: { - limit: 25 - } - } - ] - } - ] - } - } - ] - } - ], - // Make this the default page for leads - isDefault: true, - // ARIA accessibility - aria: { - ariaLabel: "Lead Detail Page", - ariaDescribedBy: "Detailed view of lead information with related records and activity" - } -}; - -// src/sales/pages/opportunity_detail.page.ts -var OpportunityDetailPage = { - name: "opportunity_detail_page", - label: "Opportunity Detail", - description: "Comprehensive opportunity detail page with path, highlights, details, and related lists", - type: "record", - object: "crm_opportunity", - template: "full-width", - kind: "full", - variables: [ - { name: "activeTab", type: "string", defaultValue: "details" } - ], - regions: [ - { - name: "header", - width: "full", - components: [ - { - type: "page:header", - id: "opp_header", - label: "Opportunity Information", - properties: { - title: "{name}", - // The lookup field is `crm_account` — `{account}` matched nothing - // and the subtitle rendered blank. - subtitle: "{crm_account}", - // `icon` removed from `page:header` in @objectstack/spec 17.0.0 - // (#6946, ADR-0087 D2) — deleted, not renamed. See the full note on - // `account_detail.page.ts`; nothing ever drew it. - // `breadcrumb` retired from `page:header` in @objectstack/spec 17.6.0 - // (#20785, `page-header-breadcrumb-removed`) — deleted: no renderer - // ever drew a trail for it; the app shell's own trail is unchanged. - // generate_quote is the CPQ entry point (opportunity → quote); a - // custom record page replaces the default header, so the action - // must be listed here explicitly or it is unreachable. The same - // sentence is why the three activity actions are named here (#592): - // without them a rep can log a call on the deal only from the list - // row's ⋮ menu, never from the deal itself. - // - // Action IDs, not `ActionDef` objects: `PageHeaderProps.actions` is - // `z.array(z.string())` ("Action IDs to show in header") in - // @objectstack/spec 17.3.0, and this repo authors against the - // protocol (#1653). Each id is the `name` of a - // crm_opportunity-scoped action — `generate_quote` / - // `clone_opportunity` in `src/sales/actions/opportunity.actions.ts`, the - // activity trio in `src/sales/actions/activity-actions.ts`. - actions: [ - "generate_quote", - "clone_opportunity", - "log_call", - "log_meeting", - "schedule_meeting" - ] - } - }, - { - type: "record:highlights", - id: "opp_highlights", - label: "Key Information", - properties: { - fields: ["amount", "close_date", "probability", "expected_revenue", "owner_id", "crm_account"] - } - }, - { - type: "record:path", - id: "opp_stage_path", - label: "Opportunity Stage Path", - properties: { - statusField: "stage", - // Every canonical value of `stage` must appear here, in funnel - // order — the path is the only place a rep reads "where is this - // deal". `needs_analysis` was missing, so a deal sitting in that - // stage lit up NO step at all and the strip read as if the deal - // had skipped from Qualification to Proposal. The two terminal - // stages stay last (won before lost), matching lead_detail's - // converted/unqualified tail. - stages: [ - { value: "prospecting", label: "Prospecting" }, - { value: "qualification", label: "Qualification" }, - { value: "needs_analysis", label: "Needs Analysis" }, - { value: "proposal", label: "Proposal" }, - { value: "negotiation", label: "Negotiation" }, - { value: "closed_won", label: "Closed Won" }, - { value: "closed_lost", label: "Closed Lost" } - ] - } - } - ] - }, - { - name: "main", - width: "large", - components: [ - { - type: "page:tabs", - id: "opp_main_tabs", - properties: { - // `type` → `tabStyle` (@objectstack/spec 17.0.0, #6776, ADR-0087 - // D2). Same three values; see the full note on `home.page.ts`. - tabStyle: "line", - position: "top", - items: [ - { - // Tab item `key` → `value` (#1269): `value` is the stable - // `?tab=` URL token the renderer reads, `key` is read by - // nothing. See the full note on `case_detail.page.ts`. - value: "details", - label: "Details", - children: [ - { - type: "record:details", - id: "opp_details", - label: "Opportunity Details", - properties: { - // `columns` is a STRING enum ('1'|'2'|'3'|'4') in - // @objectstack/spec 17. `layout` is gone (removed in spec - // 17.0.0, #6946 / ADR-0087 D2). - columns: "2", - // Every section references one of crm_opportunity's - // `fieldGroups` (#1452, the #806 class ruling C): the - // renderer derives members, label, icon and collapse state - // from the object, so this page curates only the order. - // The full note — what a group section does on 17.6.0 and - // what may not sit beside `group` — is on - // `lead_detail.page.ts`. - // - // The highlights strip still wins (#1211): the renderer - // drops every field `record:highlights` registered, and the - // record title, from the derived members. So `basic` shows - // `primary_contact` only, and `financials` (`amount`, - // `expected_revenue`, both in the strip) renders nothing - // here — it stays referenced so that a field added to the - // group reaches this tab without an edit to this file. - // - // `hideEmpty: false` keeps an ALL-empty section on screen - // (#1211). The platform default (objectui#8603 ruling A) - // renders such a section as nothing at all, so on a deal - // with only its required fields the deal's type and - // source (`classification`), its campaign (`campaign`) - // and its description and next step (`notes`) vanished — - // the very fields a seller fills in later. Kept, they - // show as labelled empty rows to fill. Measured on - // 17.6.0 on such a deal: 2 sections render without it, 5 - // with it. Not on `basic` (its only member outside the - // title and the strip is `primary_contact`), nor on - // `financials`: both members sit in the strip, the - // derived list is empty, and the renderer draws nothing - // for an empty list whatever `hideEmpty` says. - // - // `qualification` and `narrative` (REQ-0006) sit right - // after `sales_process`, the order the object declares - // them in, and both keep `hideEmpty: false` on the same - // reasoning: every member is a judgement or a piece of - // prose the seller is expected to write (bid / no-bid, - // controllability, priority, deal level, subcontracting; - // the four narrative fields), none sits in the strip, and - // no deal that predates REQ-0006 carries any of them — so - // without the key both sections vanish on every existing - // deal, which is exactly where a seller would fill them. - sections: [ - { group: "basic" }, - { group: "financials" }, - { group: "classification", hideEmpty: false }, - { group: "campaign", hideEmpty: false }, - { group: "sales_process" }, - { group: "qualification", hideEmpty: false }, - { group: "narrative", hideEmpty: false }, - { group: "crm_forecast" }, - { group: "notes", hideEmpty: false } - ] - } - } - ] - }, - { - value: "related", - label: "Related", - children: [ - { - type: "page:accordion", - id: "opp_related_accordion", - properties: { - items: [ - { - // Accordion item `key` is DELETED, not renamed to - // `value` — the opposite verdict to the tab items - // above, because this renderer overwrites `value` with - // `panel-`. See the full note on - // `case_detail.page.ts`. - label: "Quotes", - // OPEN on arrival (#1214 item 6). All three panels - // used to start shut, so the Related tab opened on - // three closed bars whose headers already carried the - // counts — the click bought the user nothing the page - // had not already told them. - // - // `collapsed: false` is the whole mechanism, and it is - // needed even though the schema DEFAULTS it to false: - // the renderer opens the panels it finds by strict - // identity — `items.filter(i => i.collapsed === false)` - // — so an item that simply omits the key is - // `undefined`, not `false`, and stays shut. Measured - // on the @objectstack/console 17.3.0 bundle — the pin - // at that taking, ⛔ NOT re-taken on 17.4.0 - // (#1814, #1807) or 17.5.0 — - // and the component's own designer text says the same - // ("collapsed: false opens a panel by default"). - // - // ⚠️ ONLY the first panel, and that is the renderer's - // choice rather than a preference: with `allowMultiple` - // absent (it defaults false) the accordion mounts as - // `type="single"` and takes `defaultValue={open[0]}` — - // one panel, the first in declaration order. Marking - // Products or Open Tasks too would change nothing on - // screen. Opening more than one means declaring - // `allowMultiple: true`, which changes the interaction - // model (panels stop closing each other) and is not - // this card's ask. - // - // ⛔ NOT "default-open the sections that have rows", - // which the card asked for first: that is not - // expressible here. `collapsed` is a static boolean on - // a strict item shape (`label` / `icon` / `collapsed` / - // `children` — nothing else parses), the page is - // authored metadata evaluated before any row is read, - // and the related lists below fetch their own rows - // after mount. Reported rather than worked around; ⛔ - // the component is not this repo's to change. - collapsed: false, - children: [ - { - type: "record:related_list", - id: "opp_quotes", - properties: { - objectName: "crm_quote", - relationshipField: "crm_opportunity", - columns: ["quote_number", "name", "status", "total_price", "expiration_date"], - limit: 10 - } - } - ] - }, - { - label: "Products", - children: [ - { - type: "record:related_list", - id: "opp_products", - properties: { - objectName: "crm_opportunity_line_item", - relationshipField: "crm_opportunity", - columns: ["crm_product", "quantity", "unit_price", "total_price"], - limit: 10, - // The entry point that was missing (#1731). Every - // OTHER surface already treated line items as - // live — three profiles grant `allowCreate`, the - // docs describe the amount rolling up from them, - // and `billing-handoff.flow.ts`'s - // `load_line_items` reads them on every won deal - // — while nothing in the app could create one: - // no action, no list view, no navigation entry, - // no seed. A rep who wanted to itemise a deal had - // to type the Amount by hand. Declared surface and - // reachable surface now coincide again. - // - // What `add` writes is the whole reason a picker - // is sufficient here. It creates a row carrying - // exactly two authored keys — - // `{ [relationshipField]: , - // [linkField]: }` — and - // nothing else. On this object that would leave - // `quantity` and `unit_price` unset, and both are - // `required` + `storage.notNull`, so the insert - // would be refused. It is not, because the two - // gaps are already filled by machinery that - // predates this list: - // - // quantity -> the field's own `defaultValue: 1` - // unit_price -> `_line-item-price-fill.ts`, which - // on `beforeInsert` stamps - // `list_price` from the chosen - // product and defaults the - // negotiated `unit_price` to it - // discount -> the field's own `defaultValue: 0` - // total_price-> the formula over the three above - // - // and `crm_product.list_price` is itself `required` - // + `notNull`, so the hook can never fail to find a - // source. Measured end-to-end, not reasoned: - // `test/opportunity-line-item-add-picker.test.ts` - // inserts the picker's exact two-key shape and - // asserts the complete priced row, with an ablation - // that unbinds the hook and shows the same insert - // rejected as "Sales Price is required" — so the - // assertion cannot pass vacuously. - // - // ⛔ Do not add a `label`. The button falls back to - // the platform's own localized "Add"; the - // translation bundles reach a page component through - // `pages..components.`, which carries - // `label`/`title`/`description` for the COMPONENT - // and has no route to a nested `add.label`. A - // hand-authored string here would ship English into - // the zh-CN / es-ES / ja-JP bundles with no key to - // translate it under. - // - // `valueField` and `labelField` are both omitted on - // purpose rather than restated: `valueField` - // defaults to `id`, which is what the `crm_product` - // lookup stores, and `labelField` defaults to the - // picked object's own title field — `crm_product` - // declares `nameField: 'display_title'` (ADR-0079), - // so the picker labels rows "PRD-0001 - Widget" and - // keeps ONE source of truth for a product's title. - // That formula title is searchable only because the - // object also declares `searchableFields`, which it - // already does for exactly this reason. - add: { - picker: { - object: "crm_product", - // A retired product must not be sellable onto a - // new deal. `product.hook.ts`'s `beforeDelete` - // defines retirement as precisely this flag - // ("Set is_active=false to retire instead"), - // so the catalog's own retirement mechanism is - // what scopes the picker. All 13 seeded - // products carry `is_active: true`, so this - // narrows without emptying. - filter: [{ field: "is_active", operator: "equals", value: true }] - }, - linkField: "crm_product" - } - } - } - ] - }, - { - label: "Open Tasks", - children: [ - { - type: "record:related_list", - id: "opp_tasks", - properties: { - objectName: "crm_task", - relationshipField: "related_to_opportunity", - columns: ["subject", "status", "priority", "due_date", "owner_id"], - filter: [{ field: "status", operator: "not_equals", value: "completed" }], - limit: 10 - } - } - ] - } - ] - } - } - ] - }, - { - value: "activity", - label: "Activity", - children: [ - { - type: "record:activity", - id: "opp_activity", - /** - * `filters` is deleted with nothing put in its place, and - * that is the whole finding (#1269). - * - * It used to read `['all', 'tasks', 'meetings', 'calls', - * 'emails']` — a vocabulary that exists nowhere in the - * contract. `RecordActivityProps` has exactly two filter - * channels and neither takes that list: - * - * `types` — an array of FEED ITEM KINDS - * (`comment` | `field_change` | `task` | - * `event` | `email` | `call` | …). Not - * these values: `all` is not a kind and - * `meetings` is not one either (the kind - * is `event`), and all five are plural - * where the enum is singular. - * `filterMode` — ONE default for the panel's dropdown, - * from `all` | `comments_only` | - * `changes_only` | `tasks_only`. The - * dropdown's option list is the renderer's, - * not authorable. - * - * So the list was reaching for a third thing — "offer these - * filter chips" — that the component does not expose. What - * it wanted is already delivered: `showFilterToggle` - * defaults on, so the panel renders its filter dropdown, and - * `filterMode` defaults to `all`, so it opens unfiltered. - * Neither is restated here, because materializing a default - * turns "the author said nothing" into "the author asked for - * the default" — a different fact, and the one a later - * liveness audit reads. - * - * Mapping it onto `types` instead was considered and - * rejected: #1209 corrected exactly that mistake one page - * over (the lead timeline's `types: ['crm_task']`), and the - * renderer sanitises out-of-enum members then reads the - * EMPTY remainder as "no filter authored" — so a bad `types` - * is indistinguishable from no `types` on screen while - * claiming otherwise in source. A `types` here would also - * be a NEW restriction nobody asked for: it would drop - * comments and field changes from a timeline that shows them - * today. - */ - properties: { - limit: 25, - // Load-bearing (#2071): a call or meeting logged on the - // deal is a `sys_activity` row of type `completed` (the - // `task` feed kind), and the renderer drops every such - // row unless this is true — so a rep's logged call never - // reached this tab. The deal's other `completed` writers - // are its own won / lost milestones - // (`opportunity.object.ts`), which belong here too. - // Completed crm_task rows do NOT arrive: their audit rows - // are keyed to the task, and this feed reads only rows - // keyed to the deal. Nor is this the `types` restriction - // the note above refuses: it adds rows and filters none. - showCompleted: true - } - } - ] - } - ] - } - } - ] - }, - { - name: "aside", - width: "small", - components: [ - { - type: "record:reference_rail", - id: "opp_reference_rail", - properties: { - /** - * No entry declares a `title` — deliberately (#972). - * - * The rail resolves a card's heading as - * `entry.title || i18n.objectLabel({ name: objectName, … })`, so a - * literal `title` does not merely provide a default: it WINS, and - * the locale bundle is never consulted. The three literals that - * used to sit here (`Quotes` / `Products` / `Open Tasks`) therefore - * printed English into every one of the four locales this app - * ships, on top of `objects..label` already being translated - * in all of them. Dropping them hands the heading back to the - * translation bundle — the single source of truth for what an - * object is called — so a locale added later is covered for free. - * - * A translated literal is not available as an alternative: unlike - * `record:alert`, whose `title` is run through the inline - * translation-map resolver, the rail renders `entry.title` as a - * raw React child. An `{ en, 'zh-CN' }` map here would not be - * resolved — it would be handed to React as an object. - * - * The third card losing the word "Open" is a correction, not a - * casualty. A rail entry has no filter at all — the rail queries - * `{ $filter: { [relationshipField]: parentId }, $top: limit }` and - * reads nothing else — so that card always counted and listed this - * deal's tasks whatever their status. The heading claimed a filter - * the component cannot apply. The genuinely filtered view is the - * `opp_tasks` related list on the *Related* tab above, which does - * carry `status neq completed`. - * - * Pinned by `test/metadata-references.test.ts` (entries resolve, - * no literal titles) and `test/i18n-references.test.ts` (every - * rail object has a `label` in every locale, so the fallback - * lands on a translation rather than on a humanized object name). - */ - entries: [ - { - objectName: "crm_quote", - relationshipField: "crm_opportunity", - limit: 3 - }, - { - objectName: "crm_opportunity_line_item", - relationshipField: "crm_opportunity", - limit: 3 - }, - { - objectName: "crm_task", - relationshipField: "related_to_opportunity", - limit: 3 - } - ] - } - } - ] - } - ], - isDefault: true, - aria: { - ariaLabel: "Opportunity Detail Page", - ariaDescribedBy: "Detailed view of opportunity information with related records and activity" - } -}; - -// src/sales/pages/account_detail.page.ts -var AccountDetailPage = { - name: "account_detail_page", - label: "Account Detail", - description: "Slotted account record page \u2014 custom header + persistent discussion feed.", - type: "record", - object: "crm_account", - kind: "slotted", - regions: [], - slots: { - header: { - type: "page:header", - id: "account_header_slotted", - label: "Account Header (slotted)", - properties: { - title: "{name}", - subtitle: "{industry} \xB7 {type}", - // `icon` and `eyebrow` are GONE, and for two different reasons — both - // measured against the contract rather than inferred from the warning - // text (#1269). - // - // `icon` was REMOVED from `page:header` in @objectstack/spec 17.0.0 - // (#6946, ADR-0087 D2). It is deleted rather than renamed because no - // renderer ever read it: objectui resolves `icon` per header ACTION - // (`action.icon`) and never off the header's own props bag, and the - // component registry never published it as an input — which is what put - // the key in objectui's `UNPUBLISHED_EXEMPTIONS` as a "spec declares it, - // NO renderer read point" entry. The header's own identity comes from - // the record chrome (`recordChrome`, on by default). - // - // `eyebrow` was never declared by anything. It is not in - // `PageHeaderProps`, it has no alias or tombstone there, and the string - // "eyebrow" does not occur anywhere in objectui — no schema, no - // registry input, no renderer. So the ACCOUNT kicker this page's - // docblock used to promise has never reached a screen: the props bag is - // `z.record(z.string(), z.unknown())`, so the key was carried into the - // artifact and dropped at render. Deleting it changes nothing a user - // sees; it only stops the source claiming a kicker exists. - // `breadcrumb` retired from `page:header` in @objectstack/spec 17.6.0 - // (#20785, `page-header-breadcrumb-removed`) — deleted: no renderer - // ever drew a trail for it; the app shell's own trail is unchanged. - // Overriding the `header` slot REPLACES the synthesized header, actions - // and all — so this slot has to re-state every action it wants to keep. - // Before #592 it named none, which is why an account record showed no - // activity buttons at all while the list row's ⋮ menu showed three. - // - // Action IDs, not `ActionDef` objects: `PageHeaderProps.actions` is - // `z.array(z.string())` ("Action IDs to show in header") in - // @objectstack/spec 17.3.0, and this repo authors against the protocol - // (#1653). Each id is the `name` of a crm_account-scoped action in - // `src/sales/actions/activity-actions.ts`. - actions: ["log_call", "log_meeting", "schedule_meeting"] - } - }, - discussion: { - type: "record:chatter", - id: "account_chatter", - label: "Discussion", - /** - * One `feed`, for one reason: `showCompleted` (#2071). - * - * This feed IS the account's activity timeline — the slotted page - * synthesizes no Activity tab, so the panel's "All Activity" stream is - * where an account's `sys_activity` rows surface. A call or meeting - * logged on the account is a row of type `completed` (the `task` feed - * kind), and the timeline drops every such row unless - * `feed.showCompleted` is true — so Log a Call / Log a Meeting on an - * account wrote a row that appeared nowhere on the account. - * - * Authoring a `feed` costs two more keys, and they are stated rather - * than left out. `RecordChatterRenderer` builds `{ position: 'bottom', - * collapsible: false, feed: { enableReactions: true, enableThreading: - * true, showCommentInput: true }, ...schema }` — one shallow spread — so - * a `feed` of our own REPLACES that default object wholesale, and - * `RecordActivityTimeline` reads `enableReactions ?? false` and - * `enableThreading ?? false` off what is left. Without the two keys - * below, reactions and threading would silently switch off. - * `showCommentInput` needs no restating: the timeline reads it as - * `!== false`. - * - * `feed.enableMentions` needs none either: the renderer reads it as - * `!== false` too. And the older note still holds (#1269): - * `enableComments` and a top-level `enableReactions` / `enableMentions` - * are not `record:chatter` keys — `RecordChatterProps` declares - * `position`, `width`, `collapsible`, `defaultCollapsed`, `feed` and - * `aria`, nothing else. - */ - properties: { - feed: { - showCompleted: true, - enableReactions: true, - enableThreading: true - } - } - } - } -}; - -// src/sales/pages/account_workbench.page.ts -var AccountWorkbenchPage = { - name: "account_workbench", - label: "Account Workbench", - description: "Curated account list for the sales team: quick filters only, no view management.", - type: "list", - object: "crm_account", - kind: "full", - template: "default", - isDefault: false, - // Interface pages carry no regions — the list surface is generated from - // `interfaceConfig` (ADR-0047), not composed from components. - regions: [], - interfaceConfig: { - source: "crm_account", - sourceView: "all_accounts", - ...{ - userFilters: { - element: "dropdown", - fields: [ - { field: "industry", showCount: true }, - { field: "type" }, - { field: "owner_id" } - ] - } - // typed via spread-as-any until @objectstack/spec ships ADR-0047 - // (UserFiltersSchema is in framework main, > 9.2.0) - }, - appearance: { - showDescription: true, - allowedVisualizations: ["grid"] - }, - userActions: { - sort: true, - search: true, - filter: false, - rowHeight: false, - addRecordForm: false - }, - showRecordCount: true - } -}; - -// src/sales/pages/home.page.ts -var embeddedListView = (id, objectName, views, viewKey) => { - const view = views.listViews?.[viewKey]; - if (!view) throw new Error(`home.page.ts: no saved view "${viewKey}" on ${objectName}`); - return { - type: "list-view", - id, - label: view.label, - properties: { - objectName, - viewType: "grid", - columns: view.columns, - filter: view.filter, - sort: view.sort - } - }; -}; -var SalesHomePage = { - name: "sales_home_page", - label: "Sales Home", - description: "Sales team home page with key metrics and quick actions", - type: "home", - template: "three-column", - kind: "full", - variables: [ - { - name: "selectedPeriod", - type: "string", - defaultValue: "this_month" - } - ], - regions: [ - { - name: "header", - width: "full", - components: [ - { - type: "page:header", - id: "home_header", - label: "Sales Home Header", - properties: { - title: "Sales Dashboard", - // Was `Welcome back, {current_user.first_name}`, which rendered as - // "Welcome back, " — the name was never going to arrive, because - // that one string mixes three vocabularies that do not compose: - // - // 1. `subtitle` is an `I18nLabel` (`ComponentPropsMap`, - // `@objectstack/spec/ui`) — a display string or an inline - // locale map, resolved by `resolveI18nLabel`. The field has no - // token pass and no expression pass of its own. - // 2. Braces DO resolve in a page header, but the vocabulary is the - // BOUND RECORD's own fields — `case_detail.page.ts` records the - // measurement, where `{account}` matched no field and the - // subtitle rendered blank until it was spelled `{crm_account}`. - // A `type: 'home'` page has no record, so no brace token can - // ever resolve here. - // 3. `current_user.first_name` is a CEL path, and CEL is written - // bare, never inside `{…}`. The one resolvable brace token in - // the filter vocabulary is `{current_user_id}` on its own. - // - // A greeting that names the user is not expressible on a - // translatable label, so the label now says the part that is true - // in every locale and the four bundles carry the translations - // (`pages.sales_home_page.subtitle`). Personalising it would need a - // component that takes user data — no shipped component does - // (`user:profile` and its neighbours are `emptyProps` rows), so - // this is a static greeting rather than a widened accept surface. - subtitle: "Welcome back" - // `icon` removed from `page:header` in @objectstack/spec 17.0.0 - // (#6946, ADR-0087 D2) — deleted, not renamed. See the full note on - // `account_detail.page.ts`; nothing ever drew it. - // `breadcrumb` retired from `page:header` in @objectstack/spec 17.6.0 - // (#20785, `page-header-breadcrumb-removed`) — deleted: no renderer - // ever drew a trail for it; the app shell's own trail is unchanged. - } - } - ] - }, - { - name: "left_sidebar", - width: "small", - components: [ - { - type: "page:card", - id: "quick_create", - label: "Quick Create", - properties: { - title: "Quick Create", - bordered: true, - children: [ - { - type: "nav:menu", - id: "create_menu", - properties: {} - } - ] - } - } - // There is no `Recent Items` card here any more, and re-adding one - // needs a data source that does not exist yet. - // - // It shipped as a `page:card` with a title and no body: a bordered box - // with the words "Recent Items" and nothing under them, on the landing - // page of every `sales_rep` / `sales_manager`. "Recent" is per-user - // access history across objects, and the platform publishes no source - // for it on 17.1.0 — `ComponentPropsMap` has no recent-records - // component, and the two that sound like one (`record:activity`, - // `record:history`) both read the page's BOUND RECORD, which a home - // page does not have. Binding it to one object's list view instead - // would have made the title lie, which is the defect #771 exists to - // prevent, so the card is removed rather than filled with something - // that is not recency. Recorded as #1217; when the platform ships a - // recent-records source, this is where the card goes back. - ] - }, - { - name: "main", - width: "large", - components: [ - { - type: "page:card", - id: "key_metrics", - label: "Key Metrics", - properties: { - title: "Key Performance Indicators", - bordered: false, - // `record:highlights` needs a bound record and real fields; a home - // page has neither, and the four names it listed (total_revenue, - // deals_won, …) exist on no object — the card rendered blank. - // `object-metric` widgets aggregate live data instead. - children: [ - { - type: "object-metric", - id: "kpi_revenue_won", - properties: { - objectName: "crm_opportunity", - label: "Revenue (Won)", - icon: "dollar-sign", - aggregate: { field: "amount", function: "sum" }, - filter: [{ field: "stage", operator: "equals", value: "closed_won" }] - } - }, - { - type: "object-metric", - id: "kpi_deals_won", - properties: { - objectName: "crm_opportunity", - label: "Deals Won", - icon: "trophy", - aggregate: { field: "id", function: "count" }, - filter: [{ field: "stage", operator: "equals", value: "closed_won" }] - } - }, - { - type: "object-metric", - id: "kpi_pipeline_value", - properties: { - objectName: "crm_opportunity", - label: "Pipeline Value", - icon: "briefcase", - aggregate: { field: "amount", function: "sum" }, - filter: [{ field: "stage", operator: "not_in", value: ["closed_won", "closed_lost"] }] - } - }, - { - type: "object-metric", - id: "kpi_open_leads", - properties: { - objectName: "crm_lead", - label: "Open Leads", - icon: "user-plus", - aggregate: { field: "id", function: "count" }, - filter: [{ field: "is_converted", operator: "equals", value: false }] - } - } - ] - } - }, - { - type: "page:tabs", - id: "home_tabs", - label: "Home Tabs", - properties: { - /** - * `type` → `tabStyle` (@objectstack/spec 17.0.0, #6776, ADR-0087 - * D2). The concept and the value vocabulary (`line` | `card` | - * `pill`) are unchanged; only the spelling moved, because a props - * key named `type` collides with the page component's own dispatch - * key: objectui's `SchemaRenderer` hoists `properties` onto the node - * but deliberately skips `type` and `id` (or the inner value would - * shadow which renderer to dispatch to), and `sdui-parser` lists - * `type` in `BASE_PROPS`, so a manifest input by that name is never - * validated at all. - * - * Renaming is behaviour-preserving on this page and on the three - * record pages: the renderer resolves - * `schema?.properties?.type || schema?.tabStyle || 'line'`, so it - * has been honouring the retired spelling as a back-compat read all - * along and picks up the canonical one through the same hoist. - */ - tabStyle: "card", - position: "top", - items: [ - { - label: "My Leads", - icon: "user-plus", - children: [embeddedListView("home_my_leads", "crm_lead", LeadViews, "my_leads")] - }, - { - // Was "My Opportunities", which promises every deal I own; the - // view behind it is the open-pipeline one (the nav's My Work > - // My Deals opens the same `my_open_deals`). The tab name now - // says what the panel shows. - label: "My Open Deals", - icon: "dollar-sign", - children: [embeddedListView("home_my_deals", "crm_opportunity", OpportunityViews, "my_open_deals")] - }, - { - // Same correction: `my_open_tasks` excludes completed tasks. - label: "My Open Tasks", - icon: "list-checks", - children: [embeddedListView("home_my_tasks", "crm_task", TaskViews, "my_open_tasks")] - } - ] - } - } - ] - }, - { - name: "right_sidebar", - width: "medium", - components: [ - { - type: "page:card", - id: "ai_briefing", - // The assistant is the PLATFORM's (`ask`), not an app-owned persona: - // HotCRM contributes skills, the agent lives in the cloud side - // (maintainer ruling on #612, 2026-08-04). The retired `sales_copilot` - // agent (#512, ADR-0063 §2) must not be named in live UI copy — and - // the entry point is the assistant panel the platform opens from the - // right edge of every page, which is the wording - // `content/docs/ai-copilot/index.mdx` landed in #611/PR #1001. - label: "Today with the AI Assistant", - properties: { - title: "Ask the AI Assistant", - bordered: true, - // The paragraph is an `element:text` child (#1581). It used to be - // `properties.description`, which `page:card` does not declare, so - // the card rendered as a title over nothing. `content` is not on - // the locale pack's page-component face, so the four languages - // live here as an inline locale map, the spec's route for page - // prose. The #1002 persona guard in - // `test/metadata-references.test.ts` reads this child. - children: [ - { - type: "element:text", - id: "ai_briefing_text", - properties: { - content: { - en: 'Open the assistant panel from the right edge of the page and ask "what should I focus on today?" \u2014 it sees your live pipeline, schema, and accounts.', - "zh-CN": '\u4ECE\u9875\u9762\u53F3\u4FA7\u6253\u5F00\u52A9\u624B\u9762\u677F\uFF0C\u8BE2\u95EE"\u6211\u4ECA\u5929\u5E94\u8BE5\u5173\u6CE8\u4EC0\u4E48\uFF1F"\u2014\u2014\u5B83\u53EF\u4EE5\u5B9E\u65F6\u67E5\u770B\u60A8\u7684\u9500\u552E\u7BA1\u9053\u3001\u67B6\u6784\u4E0E\u5BA2\u6237\u4FE1\u606F\u3002', - "es-ES": 'Abra el panel del asistente desde el borde derecho de la p\xE1gina y pregunte "\xBFen qu\xE9 deber\xEDa concentrarme hoy?" \u2014 ve su flujo de ventas, esquema y cuentas en tiempo real.', - "ja-JP": "\u30DA\u30FC\u30B8\u53F3\u7AEF\u304B\u3089\u30A2\u30B7\u30B9\u30BF\u30F3\u30C8\u30D1\u30CD\u30EB\u3092\u958B\u304D\u3001\u300C\u4ECA\u65E5\u306F\u4F55\u306B\u96C6\u4E2D\u3059\u3079\u304D\u304B\uFF1F\u300D\u3068\u5C0B\u306D\u3066\u304F\u3060\u3055\u3044 \u2014 \u30EA\u30A2\u30EB\u30BF\u30A4\u30E0\u306E\u30D1\u30A4\u30D7\u30E9\u30A4\u30F3\u3001\u30B9\u30AD\u30FC\u30DE\u3001\u53D6\u5F15\u5148\u60C5\u5831\u3092\u628A\u63E1\u3057\u3066\u3044\u307E\u3059\u3002" - } - } - } - ] - } - }, - { - type: "page:card", - id: "upcoming_events", - // Was `Calendar` / "Today's Schedule" over an empty bordered box — - // the card declared no body, so the renderer had nothing to draw. - // - // It is bound to `crm_event`'s saved `upcoming_events` view, read off - // the view exactly like the tabs above, and the name now matches what - // the panel shows. "Today's Schedule" is NOT what any existing view - // says: `my_events` is scoped to the current user but carries no date - // filter, no sort and no date column (27 seeded rows, mostly `held` - // interactions from the past), while `upcoming_events` is - // `status: 'planned'` sorted by `start_datetime` ascending with the - // date on the row. Narrowing either one to today would mean retyping - // a filter in this page — the second definition the helper above - // exists to prevent — so the title says "upcoming" instead of - // promising a day this page cannot compute. - label: "Upcoming Events", - properties: { - title: "Upcoming Events", - bordered: true, - children: [embeddedListView("home_upcoming_events", "crm_event", EventViews, "upcoming_events")] - } - } - ] - } - ], - isDefault: true, - aria: { - ariaLabel: "Sales Home Page", - ariaDescribedBy: "Sales team home page with metrics, leads, and quick actions" - } -}; - -// src/sales/pages/app_launcher.page.ts -var AppLauncherPage = { - name: "app_launcher_page", - label: "App Launcher", - description: "Central hub for accessing all applications", - type: "app", - template: "centered", - kind: "full", - regions: [ - { - name: "header", - width: "full", - components: [ - { - type: "global:search", - id: "app_search", - label: "Search Apps", - properties: {} - } - ] - }, - { - name: "main", - width: "large", - components: [ - { - type: "page:header", - id: "launcher_header", - label: "App Launcher Header", - properties: { - title: "App Launcher", - subtitle: "Select an app to get started" - // `icon` removed from `page:header` in @objectstack/spec 17.0.0 - // (#6946, ADR-0087 D2) — deleted, not renamed. See the full note on - // `account_detail.page.ts`; nothing ever drew it. - // `breadcrumb` retired from `page:header` in @objectstack/spec 17.6.0 - // (#20785, `page-header-breadcrumb-removed`) — deleted: no renderer - // ever drew a trail for it; the app shell's own trail is unchanged. - } - }, - { - type: "app:launcher", - id: "app_grid", - label: "Application Grid", - properties: {} - } - ] - } - ], - isDefault: false, - aria: { - ariaLabel: "App Launcher Page", - ariaDescribedBy: "Central application launcher for accessing all apps" - } -}; - -// src/sales/pages/utility_bar.page.ts -var UtilityBarPage = { - name: "utility_bar_page", - label: "Utility Bar", - description: "Quick access utility bar with floating tools", - type: "utility", - template: "utility-bar", - kind: "full", - regions: [ - { - name: "utilities", - width: "full", - components: [ - { - type: "global:notifications", - id: "notifications_panel", - label: "Notifications", - properties: {} - }, - { - type: "page:card", - id: "quick_notes", - label: "Quick Notes", - properties: { - title: "Quick Notes", - bordered: true - } - }, - { - type: "global:search", - id: "quick_search", - label: "Quick Search", - properties: {} - } - ] - } - ], - isDefault: false, - aria: { - ariaLabel: "Utility Bar", - ariaDescribedBy: "Quick access utility bar with floating tools and notifications" - } -}; - -// src/sales/email-templates/index.ts -var email_templates_exports = {}; -__export(email_templates_exports, { - SalesEmailTemplates: () => SalesEmailTemplates -}); - -// src/sales/email-templates/en.ts -var en3 = { - "crm.account_approved": { - label: "Account Approved", - subject: "Account approved: {{name}}", - bodyHtml: "

This account has been signed off and is now established data.

" - }, - "crm.account_rejected": { - label: "Account Not Approved", - subject: "Account not approved: {{name}}", - bodyHtml: "

This account was not signed off. Correct its details and ask for another review.

" - }, - "crm.contact_welcome": { - label: "New Contact", - subject: "New contact: {{first_name}} {{last_name}}", - bodyHtml: "

{{first_name}} {{last_name}} was added as a contact. Reach out to welcome them.

" - }, - "crm.deal_stalled": { - label: "Stalled Deal", - subject: "Stalled deal: {{name}}", - bodyHtml: "

Opportunity {{name}} has sat in {{stage}} for {{days_in_stage}} days. Time to advance or re-qualify it.

" - }, - "crm.large_deal_won": { - label: "Large Deal Won", - subject: "Large deal won: {{name}}", - bodyHtml: "

{{name}} closed at {{amount}}. Congratulations to the team.

" - }, - "crm.lead_conversion_approved": { - label: "Lead Approved for Conversion", - subject: "Lead approved for conversion: {{first_name}} {{last_name}}", - bodyHtml: "

This lead has been signed off. You can convert it into an account, contact and opportunity.

" - }, - "crm.lead_conversion_rejected": { - label: "Lead Not Approved", - subject: "Lead not approved: {{first_name}} {{last_name}}", - bodyHtml: "

Conversion of this lead was not approved. Keep working it, or disqualify it with a reason.

" - }, - "crm.lead_converted": { - label: "Lead Converted", - subject: "Lead converted: {{first_name}} {{last_name}}", - bodyHtml: "

Lead {{first_name}} {{last_name}} was converted into an account and contact.

" - }, - "crm.lead_routing_hot": { - label: "Hot Lead Routing", - subject: "Hot lead \u2014 assign within 24h: {{first_name}} {{last_name}}", - bodyHtml: "

{{first_name}} {{last_name}} from {{company}} (rating {{rating}}) needs an owner today.

" - }, - "crm.lead_routing_new": { - label: "New Lead Routing", - subject: "New lead to assign: {{first_name}} {{last_name}}", - bodyHtml: "

{{first_name}} {{last_name}} from {{company}} is awaiting assignment.

" - }, - "crm.opportunity_approved": { - label: "Deal Approved", - subject: "Deal approved: {{name}}", - bodyHtml: "

Your opportunity {{name}} has been approved.

" - }, - "crm.opportunity_rejected": { - label: "Deal Rejected", - subject: "Deal rejected: {{name}}", - bodyHtml: "

Your opportunity {{name}} was not approved. Review and revise before resubmitting.

" - }, - "crm.task_reminder": { - label: "Task Reminder", - subject: "Task reminder: {{subject}}", - bodyHtml: '

Your task "{{subject}}" is due (reminder set for {{reminder_date}}).

' - }, - "crm.urgent_task": { - label: "Urgent Task", - subject: "Urgent task: {{subject}}", - bodyHtml: '

An urgent task "{{subject}}" was assigned to you and needs attention.

' - } -}; - -// src/sales/email-templates/zh-CN.ts -var zhCN3 = { - "crm.account_approved": { - label: "\u5BA2\u6237\u5BA1\u6279\u901A\u8FC7", - subject: "\u5BA2\u6237\u5DF2\u5BA1\u6279\u901A\u8FC7\uFF1A{{name}}", - bodyHtml: "

\u8BE5\u5BA2\u6237\u5DF2\u5BA1\u6279\u901A\u8FC7\uFF0C\u73B0\u4E3A\u6B63\u5F0F\u6570\u636E\u3002

" - }, - "crm.account_rejected": { - label: "\u5BA2\u6237\u5BA1\u6279\u672A\u901A\u8FC7", - subject: "\u5BA2\u6237\u672A\u901A\u8FC7\u5BA1\u6279\uFF1A{{name}}", - bodyHtml: "

\u8BE5\u5BA2\u6237\u672A\u901A\u8FC7\u5BA1\u6279\u3002\u8BF7\u4FEE\u6B63\u5176\u4FE1\u606F\u540E\u518D\u6B21\u63D0\u4EA4\u5BA1\u6838\u3002

" - }, - "crm.contact_welcome": { - label: "\u65B0\u8054\u7CFB\u4EBA", - subject: "\u65B0\u8054\u7CFB\u4EBA\uFF1A{{first_name}} {{last_name}}", - bodyHtml: "

{{first_name}} {{last_name}} \u5DF2\u6DFB\u52A0\u4E3A\u8054\u7CFB\u4EBA\u3002\u8BF7\u4E3B\u52A8\u8054\u7CFB\u5E76\u8868\u793A\u6B22\u8FCE\u3002

" - }, - "crm.deal_stalled": { - label: "\u5546\u673A\u505C\u6EDE", - subject: "\u505C\u6EDE\u5546\u673A\uFF1A{{name}}", - bodyHtml: "

\u5546\u673A {{name}} \u5DF2\u5728\u201C{{stage}}\u201D\u9636\u6BB5\u505C\u7559 {{days_in_stage}} \u5929\u3002\u8BF7\u63A8\u8FDB\u6216\u91CD\u65B0\u8BC4\u4F30\u3002

" - }, - "crm.large_deal_won": { - label: "\u5927\u989D\u5546\u673A\u8D62\u5355", - subject: "\u5927\u989D\u5546\u673A\u8D62\u5355\uFF1A{{name}}", - bodyHtml: "

{{name}} \u4EE5 {{amount}} \u6210\u4EA4\u3002\u606D\u559C\u56E2\u961F\u3002

" - }, - "crm.lead_conversion_approved": { - label: "\u7EBF\u7D22\u8F6C\u6362\u5DF2\u6279\u51C6", - subject: "\u7EBF\u7D22\u8F6C\u6362\u5DF2\u6279\u51C6\uFF1A{{first_name}} {{last_name}}", - bodyHtml: "

\u8BE5\u7EBF\u7D22\u5DF2\u5BA1\u6279\u901A\u8FC7\u3002\u60A8\u53EF\u4EE5\u5C06\u5176\u8F6C\u6362\u4E3A\u5BA2\u6237\u3001\u8054\u7CFB\u4EBA\u548C\u5546\u673A\u3002

" - }, - "crm.lead_conversion_rejected": { - label: "\u7EBF\u7D22\u8F6C\u6362\u672A\u6279\u51C6", - subject: "\u7EBF\u7D22\u672A\u901A\u8FC7\u5BA1\u6279\uFF1A{{first_name}} {{last_name}}", - bodyHtml: "

\u8BE5\u7EBF\u7D22\u7684\u8F6C\u6362\u672A\u83B7\u6279\u51C6\u3002\u8BF7\u7EE7\u7EED\u8DDF\u8FDB\uFF0C\u6216\u6CE8\u660E\u539F\u56E0\u5C06\u5176\u53D6\u6D88\u8D44\u683C\u3002

" - }, - "crm.lead_converted": { - label: "\u7EBF\u7D22\u5DF2\u8F6C\u6362", - subject: "\u7EBF\u7D22\u5DF2\u8F6C\u6362\uFF1A{{first_name}} {{last_name}}", - bodyHtml: "

\u7EBF\u7D22 {{first_name}} {{last_name}} \u5DF2\u8F6C\u6362\u4E3A\u5BA2\u6237\u548C\u8054\u7CFB\u4EBA\u3002

" - }, - "crm.lead_routing_hot": { - label: "\u70ED\u95E8\u7EBF\u7D22\u5206\u914D", - subject: "\u70ED\u95E8\u7EBF\u7D22 \u2014 24 \u5C0F\u65F6\u5185\u5206\u914D\uFF1A{{first_name}} {{last_name}}", - bodyHtml: "

\u6765\u81EA {{company}} \u7684 {{first_name}} {{last_name}}\uFF08\u8BC4\u5206 {{rating}}\uFF09\u9700\u8981\u4ECA\u5929\u5C31\u6307\u5B9A\u8D1F\u8D23\u4EBA\u3002

" - }, - "crm.lead_routing_new": { - label: "\u65B0\u7EBF\u7D22\u5206\u914D", - subject: "\u5F85\u5206\u914D\u65B0\u7EBF\u7D22\uFF1A{{first_name}} {{last_name}}", - bodyHtml: "

\u6765\u81EA {{company}} \u7684 {{first_name}} {{last_name}} \u6B63\u5728\u7B49\u5F85\u5206\u914D\u3002

" - }, - "crm.opportunity_approved": { - label: "\u5546\u673A\u5BA1\u6279\u901A\u8FC7", - subject: "\u5546\u673A\u5DF2\u6279\u51C6\uFF1A{{name}}", - bodyHtml: "

\u60A8\u7684\u5546\u673A {{name}} \u5DF2\u83B7\u6279\u51C6\u3002

" - }, - "crm.opportunity_rejected": { - label: "\u5546\u673A\u5BA1\u6279\u672A\u901A\u8FC7", - subject: "\u5546\u673A\u672A\u6279\u51C6\uFF1A{{name}}", - bodyHtml: "

\u60A8\u7684\u5546\u673A {{name}} \u672A\u83B7\u6279\u51C6\u3002\u8BF7\u68C0\u67E5\u5E76\u4FEE\u6539\u540E\u91CD\u65B0\u63D0\u4EA4\u3002

" - }, - "crm.task_reminder": { - label: "\u4EFB\u52A1\u63D0\u9192", - subject: "\u4EFB\u52A1\u63D0\u9192\uFF1A{{subject}}", - bodyHtml: "

\u60A8\u7684\u4EFB\u52A1\u201C{{subject}}\u201D\u5DF2\u5230\u671F\uFF08\u63D0\u9192\u65F6\u95F4 {{reminder_date}}\uFF09\u3002

" - }, - "crm.urgent_task": { - label: "\u7D27\u6025\u4EFB\u52A1", - subject: "\u7D27\u6025\u4EFB\u52A1\uFF1A{{subject}}", - bodyHtml: "

\u4E00\u9879\u7D27\u6025\u4EFB\u52A1\u201C{{subject}}\u201D\u5DF2\u5206\u914D\u7ED9\u60A8\uFF0C\u9700\u8981\u5C3D\u5FEB\u5904\u7406\u3002

" - } -}; - -// src/sales/email-templates/ja-JP.ts -var jaJP3 = { - "crm.account_approved": { - label: "\u30A2\u30AB\u30A6\u30F3\u30C8\u627F\u8A8D\u6E08\u307F", - subject: "\u30A2\u30AB\u30A6\u30F3\u30C8\u304C\u627F\u8A8D\u3055\u308C\u307E\u3057\u305F: {{name}}", - bodyHtml: "

\u3053\u306E\u30A2\u30AB\u30A6\u30F3\u30C8\u306F\u627F\u8A8D\u3055\u308C\u3001\u6B63\u5F0F\u306A\u30C7\u30FC\u30BF\u306B\u306A\u308A\u307E\u3057\u305F\u3002

" - }, - "crm.account_rejected": { - label: "\u30A2\u30AB\u30A6\u30F3\u30C8\u672A\u627F\u8A8D", - subject: "\u30A2\u30AB\u30A6\u30F3\u30C8\u304C\u627F\u8A8D\u3055\u308C\u307E\u305B\u3093\u3067\u3057\u305F: {{name}}", - bodyHtml: "

\u3053\u306E\u30A2\u30AB\u30A6\u30F3\u30C8\u306F\u627F\u8A8D\u3055\u308C\u307E\u305B\u3093\u3067\u3057\u305F\u3002\u5185\u5BB9\u3092\u4FEE\u6B63\u306E\u3046\u3048\u3001\u518D\u5EA6\u627F\u8A8D\u3092\u4F9D\u983C\u3057\u3066\u304F\u3060\u3055\u3044\u3002

" - }, - "crm.contact_welcome": { - label: "\u65B0\u898F\u53D6\u5F15\u5148\u8CAC\u4EFB\u8005", - subject: "\u65B0\u3057\u3044\u53D6\u5F15\u5148\u8CAC\u4EFB\u8005: {{first_name}} {{last_name}}", - bodyHtml: "

{{first_name}} {{last_name}} \u304C\u53D6\u5F15\u5148\u8CAC\u4EFB\u8005\u3068\u3057\u3066\u8FFD\u52A0\u3055\u308C\u307E\u3057\u305F\u3002\u3054\u6328\u62F6\u306E\u9023\u7D61\u3092\u3057\u3066\u304F\u3060\u3055\u3044\u3002

" - }, - "crm.deal_stalled": { - label: "\u505C\u6EDE\u4E2D\u306E\u5546\u8AC7", - subject: "\u505C\u6EDE\u4E2D\u306E\u5546\u8AC7: {{name}}", - bodyHtml: "

\u5546\u8AC7 {{name}} \u306F\u300C{{stage}}\u300D\u306B {{days_in_stage}} \u65E5\u9593\u7559\u307E\u3063\u3066\u3044\u307E\u3059\u3002\u6B21\u306E\u6BB5\u968E\u306B\u9032\u3081\u308B\u304B\u3001\u518D\u8A55\u4FA1\u3057\u3066\u304F\u3060\u3055\u3044\u3002

" - }, - "crm.large_deal_won": { - label: "\u5927\u578B\u5546\u8AC7\u306E\u53D7\u6CE8", - subject: "\u5927\u578B\u5546\u8AC7\u3092\u53D7\u6CE8: {{name}}", - bodyHtml: "

{{name}} \u304C {{amount}} \u3067\u6210\u7D04\u3057\u307E\u3057\u305F\u3002\u30C1\u30FC\u30E0\u306E\u7686\u3055\u3093\u3001\u304A\u3081\u3067\u3068\u3046\u3054\u3056\u3044\u307E\u3059\u3002

" - }, - "crm.lead_conversion_approved": { - label: "\u30EA\u30FC\u30C9\u5909\u63DB\u306E\u627F\u8A8D", - subject: "\u30EA\u30FC\u30C9\u306E\u5909\u63DB\u304C\u627F\u8A8D\u3055\u308C\u307E\u3057\u305F: {{first_name}} {{last_name}}", - bodyHtml: "

\u3053\u306E\u30EA\u30FC\u30C9\u306F\u627F\u8A8D\u3055\u308C\u307E\u3057\u305F\u3002\u53D6\u5F15\u5148\u3001\u53D6\u5F15\u5148\u8CAC\u4EFB\u8005\u3001\u5546\u8AC7\u306B\u5909\u63DB\u3067\u304D\u307E\u3059\u3002

" - }, - "crm.lead_conversion_rejected": { - label: "\u30EA\u30FC\u30C9\u672A\u627F\u8A8D", - subject: "\u30EA\u30FC\u30C9\u304C\u627F\u8A8D\u3055\u308C\u307E\u305B\u3093\u3067\u3057\u305F: {{first_name}} {{last_name}}", - bodyHtml: "

\u3053\u306E\u30EA\u30FC\u30C9\u306E\u5909\u63DB\u306F\u627F\u8A8D\u3055\u308C\u307E\u305B\u3093\u3067\u3057\u305F\u3002\u5F15\u304D\u7D9A\u304D\u5BFE\u5FDC\u3059\u308B\u304B\u3001\u7406\u7531\u3092\u4ED8\u3051\u3066\u5BFE\u8C61\u5916\u306B\u3057\u3066\u304F\u3060\u3055\u3044\u3002

" - }, - "crm.lead_converted": { - label: "\u30EA\u30FC\u30C9\u5909\u63DB\u6E08\u307F", - subject: "\u30EA\u30FC\u30C9\u3092\u5909\u63DB\u3057\u307E\u3057\u305F: {{first_name}} {{last_name}}", - bodyHtml: "

\u30EA\u30FC\u30C9 {{first_name}} {{last_name}} \u3092\u53D6\u5F15\u5148\u3068\u53D6\u5F15\u5148\u8CAC\u4EFB\u8005\u306B\u5909\u63DB\u3057\u307E\u3057\u305F\u3002

" - }, - "crm.lead_routing_hot": { - label: "\u30DB\u30C3\u30C8\u30EA\u30FC\u30C9\u306E\u5272\u308A\u5F53\u3066", - subject: "\u30DB\u30C3\u30C8\u30EA\u30FC\u30C9 \u2014 24 \u6642\u9593\u4EE5\u5185\u306B\u5272\u308A\u5F53\u3066: {{first_name}} {{last_name}}", - bodyHtml: "

{{company}} \u306E {{first_name}} {{last_name}}\uFF08\u8A55\u4FA1 {{rating}}\uFF09\u306B\u672C\u65E5\u4E2D\u306B\u62C5\u5F53\u8005\u3092\u5272\u308A\u5F53\u3066\u3066\u304F\u3060\u3055\u3044\u3002

" - }, - "crm.lead_routing_new": { - label: "\u65B0\u898F\u30EA\u30FC\u30C9\u306E\u5272\u308A\u5F53\u3066", - subject: "\u5272\u308A\u5F53\u3066\u5F85\u3061\u306E\u65B0\u898F\u30EA\u30FC\u30C9: {{first_name}} {{last_name}}", - bodyHtml: "

{{company}} \u306E {{first_name}} {{last_name}} \u304C\u5272\u308A\u5F53\u3066\u3092\u5F85\u3063\u3066\u3044\u307E\u3059\u3002

" - }, - "crm.opportunity_approved": { - label: "\u5546\u8AC7\u627F\u8A8D\u6E08\u307F", - subject: "\u5546\u8AC7\u304C\u627F\u8A8D\u3055\u308C\u307E\u3057\u305F: {{name}}", - bodyHtml: "

\u5546\u8AC7 {{name}} \u304C\u627F\u8A8D\u3055\u308C\u307E\u3057\u305F\u3002

" - }, - "crm.opportunity_rejected": { - label: "\u5546\u8AC7\u672A\u627F\u8A8D", - subject: "\u5546\u8AC7\u304C\u627F\u8A8D\u3055\u308C\u307E\u305B\u3093\u3067\u3057\u305F: {{name}}", - bodyHtml: "

\u5546\u8AC7 {{name}} \u306F\u627F\u8A8D\u3055\u308C\u307E\u305B\u3093\u3067\u3057\u305F\u3002\u5185\u5BB9\u3092\u78BA\u8A8D\u30FB\u4FEE\u6B63\u306E\u3046\u3048\u3001\u518D\u7533\u8ACB\u3057\u3066\u304F\u3060\u3055\u3044\u3002

" - }, - "crm.task_reminder": { - label: "ToDo \u30EA\u30DE\u30A4\u30F3\u30C0\u30FC", - subject: "ToDo \u306E\u30EA\u30DE\u30A4\u30F3\u30C0\u30FC: {{subject}}", - bodyHtml: "

ToDo\u300C{{subject}}\u300D\u304C\u671F\u9650\u3092\u8FCE\u3048\u307E\u3057\u305F\uFF08\u30EA\u30DE\u30A4\u30F3\u30C0\u30FC\u8A2D\u5B9A: {{reminder_date}}\uFF09\u3002

" - }, - "crm.urgent_task": { - label: "\u7DCA\u6025 ToDo", - subject: "\u7DCA\u6025\u306E ToDo: {{subject}}", - bodyHtml: "

\u7DCA\u6025\u306E ToDo\u300C{{subject}}\u300D\u304C\u5272\u308A\u5F53\u3066\u3089\u308C\u307E\u3057\u305F\u3002\u5BFE\u5FDC\u3092\u304A\u9858\u3044\u3057\u307E\u3059\u3002

" - } -}; - -// src/sales/email-templates/es-ES.ts -var esES3 = { - "crm.account_approved": { - label: "Cuenta aprobada", - subject: "Cuenta aprobada: {{name}}", - bodyHtml: "

Esta cuenta ha sido aprobada y ya es un dato consolidado.

" - }, - "crm.account_rejected": { - label: "Cuenta no aprobada", - subject: "Cuenta no aprobada: {{name}}", - bodyHtml: "

Esta cuenta no fue aprobada. Corrige sus datos y solicita otra revisi\xF3n.

" - }, - "crm.contact_welcome": { - label: "Nuevo contacto", - subject: "Nuevo contacto: {{first_name}} {{last_name}}", - bodyHtml: "

{{first_name}} {{last_name}} se ha a\xF1adido como contacto. Ponte en contacto para darle la bienvenida.

" - }, - "crm.deal_stalled": { - label: "Oportunidad estancada", - subject: "Oportunidad estancada: {{name}}", - bodyHtml: "

La oportunidad {{name}} lleva {{days_in_stage}} d\xEDas en {{stage}}. Es hora de avanzarla o volver a cualificarla.

" - }, - "crm.large_deal_won": { - label: "Gran operaci\xF3n ganada", - subject: "Gran operaci\xF3n ganada: {{name}}", - bodyHtml: "

{{name}} se cerr\xF3 por {{amount}}. Enhorabuena al equipo.

" - }, - "crm.lead_conversion_approved": { - label: "Cliente potencial aprobado para conversi\xF3n", - subject: "Cliente potencial aprobado para conversi\xF3n: {{first_name}} {{last_name}}", - bodyHtml: "

Este cliente potencial ha sido aprobado. Puedes convertirlo en cuenta, contacto y oportunidad.

" - }, - "crm.lead_conversion_rejected": { - label: "Cliente potencial no aprobado", - subject: "Cliente potencial no aprobado: {{first_name}} {{last_name}}", - bodyHtml: "

La conversi\xF3n de este cliente potencial no fue aprobada. Sigue trabaj\xE1ndolo o descalif\xEDcalo indicando un motivo.

" - }, - "crm.lead_converted": { - label: "Cliente potencial convertido", - subject: "Cliente potencial convertido: {{first_name}} {{last_name}}", - bodyHtml: "

El cliente potencial {{first_name}} {{last_name}} se convirti\xF3 en cuenta y contacto.

" - }, - "crm.lead_routing_hot": { - label: "Asignaci\xF3n de cliente potencial caliente", - subject: "Cliente potencial caliente \u2014 asignar en 24 h: {{first_name}} {{last_name}}", - bodyHtml: "

{{first_name}} {{last_name}} de {{company}} (puntuaci\xF3n {{rating}}) necesita propietario hoy.

" - }, - "crm.lead_routing_new": { - label: "Asignaci\xF3n de cliente potencial", - subject: "Nuevo cliente potencial por asignar: {{first_name}} {{last_name}}", - bodyHtml: "

{{first_name}} {{last_name}} de {{company}} est\xE1 pendiente de asignaci\xF3n.

" - }, - "crm.opportunity_approved": { - label: "Oportunidad aprobada", - subject: "Oportunidad aprobada: {{name}}", - bodyHtml: "

Tu oportunidad {{name}} ha sido aprobada.

" - }, - "crm.opportunity_rejected": { - label: "Oportunidad rechazada", - subject: "Oportunidad rechazada: {{name}}", - bodyHtml: "

Tu oportunidad {{name}} no fue aprobada. Rev\xEDsala y corr\xEDgela antes de volver a enviarla.

" - }, - "crm.task_reminder": { - label: "Recordatorio de tarea", - subject: "Recordatorio de tarea: {{subject}}", - bodyHtml: '

Tu tarea "{{subject}}" vence (recordatorio fijado para {{reminder_date}}).

' - }, - "crm.urgent_task": { - label: "Tarea urgente", - subject: "Tarea urgente: {{subject}}", - bodyHtml: '

Se te ha asignado una tarea urgente "{{subject}}" que requiere atenci\xF3n.

' - } -}; - -// src/sales/email-templates/crm.email-template.ts -var SalesEmailTemplates = bundle({ - "en-US": en3, - "zh-CN": zhCN3, - "ja-JP": jaJP3, - "es-ES": esES3 -}); - -// src/revenue/email-templates/index.ts -var email_templates_exports2 = {}; -__export(email_templates_exports2, { - RevenueEmailTemplates: () => RevenueEmailTemplates -}); - -// src/revenue/email-templates/en.ts -var en4 = { - "crm.contract_expired": { - label: "Contract Expired", - subject: "Contract expired: {{contract_number}}", - bodyHtml: "

Contract {{contract_number}} reached its end date and has been marked expired.

" - }, - "crm.contract_renewal": { - label: "Contract Renewal Due", - subject: "Contract renewal due: {{contract_number}}", - bodyHtml: "

Contract {{contract_number}} ends on {{end_date}}. Start the renewal conversation now.

" - }, - "crm.quote_created": { - label: "Quote Created", - subject: "Quote created: {{quote_name}}", - bodyHtml: "

Your quote {{quote_name}} has been created from this opportunity.

" - } -}; - -// src/revenue/email-templates/zh-CN.ts -var zhCN4 = { - "crm.contract_expired": { - label: "\u5408\u540C\u5DF2\u5230\u671F", - subject: "\u5408\u540C\u5DF2\u5230\u671F\uFF1A{{contract_number}}", - bodyHtml: "

\u5408\u540C {{contract_number}} \u5DF2\u5230\u8FBE\u7ED3\u675F\u65E5\u671F\uFF0C\u5E76\u5DF2\u6807\u8BB0\u4E3A\u5230\u671F\u3002

" - }, - "crm.contract_renewal": { - label: "\u5408\u540C\u7EED\u7EA6\u63D0\u9192", - subject: "\u5408\u540C\u5F85\u7EED\u7EA6\uFF1A{{contract_number}}", - bodyHtml: "

\u5408\u540C {{contract_number}} \u5C06\u4E8E {{end_date}} \u7ED3\u675F\u3002\u8BF7\u7ACB\u5373\u542F\u52A8\u7EED\u7EA6\u6C9F\u901A\u3002

" - }, - "crm.quote_created": { - label: "\u62A5\u4EF7\u5355\u5DF2\u521B\u5EFA", - subject: "\u62A5\u4EF7\u5355\u5DF2\u521B\u5EFA\uFF1A{{quote_name}}", - bodyHtml: "

\u60A8\u7684\u62A5\u4EF7\u5355 {{quote_name}} \u5DF2\u4ECE\u8BE5\u5546\u673A\u521B\u5EFA\u3002

" - } -}; - -// src/revenue/email-templates/ja-JP.ts -var jaJP4 = { - "crm.contract_expired": { - label: "\u5951\u7D04\u306E\u6E80\u4E86", - subject: "\u5951\u7D04\u304C\u6E80\u4E86\u3057\u307E\u3057\u305F: {{contract_number}}", - bodyHtml: "

\u5951\u7D04 {{contract_number}} \u306F\u7D42\u4E86\u65E5\u306B\u9054\u3057\u3001\u6E80\u4E86\u3068\u3057\u3066\u8A18\u9332\u3055\u308C\u307E\u3057\u305F\u3002

" - }, - "crm.contract_renewal": { - label: "\u5951\u7D04\u66F4\u65B0\u306E\u6642\u671F", - subject: "\u5951\u7D04\u306E\u66F4\u65B0\u6642\u671F\u3067\u3059: {{contract_number}}", - bodyHtml: "

\u5951\u7D04 {{contract_number}} \u306F {{end_date}} \u306B\u7D42\u4E86\u3057\u307E\u3059\u3002\u66F4\u65B0\u306E\u76F8\u8AC7\u3092\u59CB\u3081\u3066\u304F\u3060\u3055\u3044\u3002

" - }, - "crm.quote_created": { - label: "\u898B\u7A4D\u306E\u4F5C\u6210", - subject: "\u898B\u7A4D\u3092\u4F5C\u6210\u3057\u307E\u3057\u305F: {{quote_name}}", - bodyHtml: "

\u3053\u306E\u5546\u8AC7\u304B\u3089\u898B\u7A4D {{quote_name}} \u304C\u4F5C\u6210\u3055\u308C\u307E\u3057\u305F\u3002

" - } -}; - -// src/revenue/email-templates/es-ES.ts -var esES4 = { - "crm.contract_expired": { - label: "Contrato vencido", - subject: "Contrato vencido: {{contract_number}}", - bodyHtml: "

El contrato {{contract_number}} alcanz\xF3 su fecha de fin y se ha marcado como vencido.

" - }, - "crm.contract_renewal": { - label: "Renovaci\xF3n de contrato pendiente", - subject: "Renovaci\xF3n de contrato pendiente: {{contract_number}}", - bodyHtml: "

El contrato {{contract_number}} finaliza el {{end_date}}. Inicia ya la conversaci\xF3n de renovaci\xF3n.

" - }, - "crm.quote_created": { - label: "Presupuesto creado", - subject: "Presupuesto creado: {{quote_name}}", - bodyHtml: "

Tu presupuesto {{quote_name}} se ha creado a partir de esta oportunidad.

" - } -}; - -// src/revenue/email-templates/crm.email-template.ts -var RevenueEmailTemplates = bundle({ - "en-US": en4, - "zh-CN": zhCN4, - "ja-JP": jaJP4, - "es-ES": esES4 -}); - -// src/sales/profiles/tenant-admin.profile.ts -var TenantAdminProfile = { - name: "tenant_admin", - label: "Tenant Administrator", - // Derived, never transcribed — see the note above. Spread rather than - // aliased so the two sets are independent values in the built artifact. - objects: { ...SystemAdminProfile.objects }, - systemPermissions: [ - "view_setup", - // The one substitution this profile exists for: org-scoped member - // management instead of platform-wide user management. - "manage_org_users", - // Org-bounded by the driver's tenant predicate — see the audit above. - "view_all_data", - "modify_all_data", - "manage_sharing" - ] -}; - -// src/sales/objects/account.hook.ts -var accountHook = { - name: "account_protection", - object: "crm_account", - events: ["beforeInsert", "beforeUpdate", "beforeDelete"], - priority: 200, - description: "Validate account fields and protect customer accounts with opportunities or activated contracts from deletion.", - handler: async (ctx) => { - function refuse(message, code, status, userMessage = message) { - const err = new Error(message); - err.code = code; - err.status = status; - err.userMessage = userMessage; - return err; - } - const { event, input } = ctx; - if (event === "beforeInsert" || event === "beforeUpdate") { - if (typeof input.website === "string" && input.website.length > 0) { - if (!/^https?:\/\//i.test(input.website)) { - throw refuse("Website must start with http:// or https://", "VALIDATION_FAILED", 400); - } - } - if (typeof input.annual_revenue === "number" && input.annual_revenue < 0) { - throw refuse("Annual Revenue must be greater than or equal to 0", "VALIDATION_FAILED", 400); - } - if ("billing_address" in input || event === "beforeInsert") { - const address = input.billing_address; - const country = address !== null && typeof address === "object" && !Array.isArray(address) ? address.country : void 0; - const normalized = typeof country === "string" ? country.trim().replace(/\s+/g, " ").toUpperCase() : ""; - if ("billing_address" in input) { - input.billing_country = normalized === "" ? null : normalized; - } - const TERRITORY_BY_COUNTRY = { - "US": "na", - "CA": "na", - "MX": "na", - "GB": "emea", - "DE": "emea", - "FR": "emea", - "IT": "emea", - "ES": "emea", - "UNITED STATES": "na", - "UNITED STATES OF AMERICA": "na", - "USA": "na", - "CANADA": "na", - "MEXICO": "na", - "UK": "emea", - "UNITED KINGDOM": "emea", - "GREAT BRITAIN": "emea", - "GERMANY": "emea", - "FRANCE": "emea", - "ITALY": "emea", - "SPAIN": "emea" - }; - input.territory = TERRITORY_BY_COUNTRY[normalized] || "other"; - } - if ("name" in input) { - const rawName = input.name; - const normalizedName = typeof rawName === "string" ? rawName.trim().toLowerCase().replace(/\s+/g, " ") : ""; - input.name_normalized = normalizedName === "" ? null : normalizedName; - } - } - if (event === "beforeUpdate" && ctx.user?.id && ctx.dispatch?.mode !== "per-row") { - const prev = ctx.previous ?? {}; - const ownerChanged = typeof input.owner_id !== "undefined" && input.owner_id !== prev.owner_id; - const typeChanged = typeof input.type !== "undefined" && input.type !== prev.type; - if (ownerChanged || typeChanged) { - input.last_activity_date = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10); - } - } - if (event === "beforeDelete") { - const previous = ctx.previous; - if (!previous || previous.type !== "customer") return; - const api = ctx.api; - if (!api) return; - const opportunities2 = await api.object("crm_opportunity").count({ - where: { crm_account: previous.id } - }); - if (opportunities2 > 0) { - throw refuse( - opportunities2 === 1 ? "Cannot delete customer account: 1 opportunity, open or closed, still references it. Delete the opportunity first, or mark the account inactive to retire it instead." : `Cannot delete customer account: ${opportunities2} opportunities, open or closed, still reference it. Delete the opportunities first, or mark the account inactive to retire it instead.`, - "DELETE_RESTRICTED", - 409 - ); - } - const activeContracts = await api.object("crm_contract").count({ - where: { crm_account: previous.id, status: "activated" } - }); - if (activeContracts > 0) { - throw refuse( - activeContracts === 1 ? "Cannot delete customer account: 1 activated contract still references it. Terminate or reassign it first." : `Cannot delete customer account: ${activeContracts} activated contracts still reference it. Terminate or reassign them first.`, - "DELETE_RESTRICTED", - 409 - ); - } - } - } -}; -var account_hook_default = accountHook; - -// src/sales/objects/contact.hook.ts -var contactHook = { - name: "contact_integrity", - object: "crm_contact", - events: ["beforeInsert", "beforeUpdate", "beforeDelete"], - priority: 200, - description: "Dedupe contacts by email and protect referenced contacts from deletion.", - handler: async (ctx) => { - function refuse(message, code, status, userMessage = message) { - const err = new Error(message); - err.code = code; - err.status = status; - err.userMessage = userMessage; - return err; - } - const { event, input } = ctx; - const api = ctx.api; - if ((event === "beforeInsert" || event === "beforeUpdate") && api) { - const email = typeof input.email === "string" ? input.email.toLowerCase() : ""; - if (email) { - input.email = email; - const organizationId = [ - ctx.user?.organizationId, - ctx.session?.organizationId, - input.organization_id, - ctx.previous?.organization_id - ].find((candidate) => typeof candidate === "string" && candidate !== ""); - if (organizationId || ctx.user?.id) { - const dup = await api.object("crm_contact").findOne({ - where: organizationId ? { organization_id: organizationId, email } : { email } - }); - const dupRow = dup; - const dupId = dupRow?.id; - const selfId = ctx.previous?.id ?? input.id; - if (dup && dupId !== selfId) { - const dupName = [dupRow?.first_name, dupRow?.last_name].filter((part) => typeof part === "string" && part.trim() !== "").join(" "); - throw refuse( - dupName ? `Another contact (${dupName}) with email ${email} already exists.` : `Another contact with email ${email} already exists.`, - "DUPLICATE_VALUE", - 409 - ); - } - } - } - } - if (event === "beforeDelete" && api) { - const id = ctx.previous?.id; - if (!id) return; - const [openOpps, openQuotes, activeContracts] = await Promise.all([ - api.object("crm_opportunity").count({ - where: { primary_contact: id, stage: { $nin: ["closed_won", "closed_lost"] } } - }), - api.object("crm_quote").count({ - where: { crm_contact: id, status: { $nin: ["rejected", "expired"] } } - }), - api.object("crm_contract").count({ - where: { crm_contact: id, status: "activated" } - }) - ]); - const total = openOpps + openQuotes + activeContracts; - if (total > 0) { - const name = [ctx.previous?.first_name, ctx.previous?.last_name].filter((part) => typeof part === "string" && part.trim() !== "").join(" "); - const subject = name ? `Contact ${name}` : "This contact"; - throw refuse( - `${subject} is still referenced by ${openOpps} open opportunity(ies), ${openQuotes} active quote(s), ${activeContracts} active contract(s), so it cannot be deleted \u2014 and neither can its account, because deleting an account deletes its contacts. Close or reassign the opportunities and quotes first, and give each contract another primary contact: a contract keeps its primary contact even after it ends.`, - "DELETE_RESTRICTED", - 409 - ); - } - } - } -}; -var contact_hook_default = contactHook; - -// src/sales/objects/event.hook.ts -var eventScheduleDerive = { - name: "event_schedule_derive", - object: "crm_event", - events: ["beforeInsert", "beforeUpdate"], - priority: 200, - description: "Keep start/end/duration coherent: derive whichever of end_datetime or duration_minutes was not supplied.", - handler: async (ctx) => { - if (ctx.event === "beforeUpdate" && ctx.dispatch?.mode === "per-row") return; - const { input } = ctx; - const previous = ctx.previous; - const effective = (key) => input[key] !== void 0 && input[key] !== null ? input[key] : previous?.[key]; - const start = effective("start_datetime"); - const end = effective("end_datetime"); - const durationRaw = effective("duration_minutes"); - const startMs = typeof start === "string" || start instanceof Date ? new Date(start).getTime() : NaN; - const endMs = typeof end === "string" || end instanceof Date ? new Date(end).getTime() : NaN; - const duration = typeof durationRaw === "number" && isFinite(durationRaw) ? durationRaw : NaN; - const allDay = effective("all_day") === true; - if (!isNaN(startMs) && !isNaN(endMs)) { - if (!allDay) input.duration_minutes = Math.max(0, Math.round((endMs - startMs) / 6e4)); - } else if (!isNaN(startMs) && isNaN(endMs) && !isNaN(duration) && duration > 0) { - input.end_datetime = new Date(startMs + duration * 6e4).toISOString(); - } - const status = effective("status"); - if (status === "cancelled" || status === "no_show") input.duration_minutes = 0; - } -}; -var eventActivityBubble = { - name: "event_activity_bubble", - object: "crm_event", - events: ["afterInsert", "afterUpdate"], - priority: 800, - async: true, - onError: "log", - runAs: "system", - description: "A held event stamps interaction recency on the related account (walking up from contact/opportunity/case), lead and contact, and the first-response time on a related case.", - handler: async (ctx) => { - const { input } = ctx; - const previous = ctx.previous; - const api = ctx.api; - if (!api) return; - const r = { ...previous ?? {}, ...input }; - if (r.status !== "held") return; - if (previous && previous.status === "held") return; - const nowIso = (/* @__PURE__ */ new Date()).toISOString(); - const today = nowIso.slice(0, 10); - const idOf = (key) => typeof r[key] === "string" && r[key].length > 0 ? r[key] : void 0; - const org = idOf("organization_id"); - const inOrg = org ? { organization_id: org } : {}; - const accountIds = /* @__PURE__ */ new Set(); - const contactIds = /* @__PURE__ */ new Set(); - const leadIds = /* @__PURE__ */ new Set(); - const direct = idOf("related_to_account"); - if (direct) accountIds.add(direct); - const contactId = idOf("related_to_contact"); - if (contactId) contactIds.add(contactId); - const leadId = idOf("related_to_lead"); - if (leadId) leadIds.add(leadId); - const parentLookups = [ - ["related_to_contact", "crm_contact"], - ["related_to_opportunity", "crm_opportunity"], - ["related_to_case", "crm_case"] - ]; - for (const [field, object] of parentLookups) { - const id = idOf(field); - if (!id) continue; - try { - const raw = await api.object(object).find({ - where: { id, ...inOrg }, - fields: ["crm_account"], - top: 1 - }); - const rows = Array.isArray(raw) ? raw : raw?.records ?? []; - const parent = rows.length ? rows[0].crm_account : void 0; - if (typeof parent === "string" && parent.length > 0) accountIds.add(parent); - } catch { - } - } - const targets = [ - ["crm_account", accountIds, { last_activity_date: today }], - ["crm_contact", contactIds, { last_contacted_date: nowIso }], - ["crm_lead", leadIds, { last_contacted_date: nowIso }] - ]; - for (const [object, ids, doc] of targets) { - let inside = [...ids]; - if (org && inside.length > 0) { - try { - const raw = await api.object(object).find({ where: { id: { $in: inside }, ...inOrg }, fields: ["id"], top: inside.length }); - inside = (Array.isArray(raw) ? raw : raw?.records ?? []).map((row) => String(row.id)); - } catch { - inside = []; - } - } - for (const id of inside) { - try { - await api.object(object).update({ ...doc, id }, { where: { id } }); - } catch { - } - } - } - const responseCaseId = idOf("related_to_case"); - if (responseCaseId) { - try { - const raw = await api.object("crm_case").find({ - where: { id: responseCaseId, ...inOrg }, - fields: ["first_response_date"], - top: 1 - }); - const rows = Array.isArray(raw) ? raw : raw?.records ?? []; - if (rows.length > 0 && !rows[0].first_response_date) { - await api.object("crm_case").update( - { id: responseCaseId, first_response_date: nowIso }, - { where: { id: responseCaseId } } - ); - } - } catch { - } - } - } -}; -var eventDoNotCallGuard = { - name: "event_do_not_call_guard", - object: "crm_event", - events: ["beforeInsert", "beforeUpdate"], - priority: 150, - description: "Refuse to book a planned Call event against a lead/contact flagged Do Not Call.", - handler: async (ctx) => { - function refuse(message, code, status, userMessage = message) { - const err = new Error(message); - err.code = code; - err.status = status; - err.userMessage = userMessage; - return err; - } - const { input } = ctx; - const previous = ctx.previous; - const api = ctx.api; - if (!api) return; - const effective = (key) => input[key] !== void 0 && input[key] !== null ? input[key] : previous?.[key]; - if (effective("type") !== "call") return; - if (effective("status") !== "planned") return; - const leadId = effective("related_to_lead"); - const contactId = effective("related_to_contact"); - const targets = []; - if (typeof leadId === "string" && leadId) { - targets.push({ object: "crm_lead", id: leadId, label: "lead" }); - } - if (typeof contactId === "string" && contactId) { - targets.push({ object: "crm_contact", id: contactId, label: "contact" }); - } - for (const t of targets) { - const raw = await api.object(t.object).find({ - where: { id: t.id }, - fields: ["id", "do_not_call"], - top: 1 - }); - const rows = Array.isArray(raw) ? raw : raw?.records ?? []; - const person = rows[0]; - if (person?.do_not_call === true) { - throw refuse( - `This ${t.label} is flagged Do Not Call, so a call cannot be scheduled against them. Log the call as held if it already happened, book a meeting instead, or clear Do Not Call on the record first.`, - "FORBIDDEN", - 403 - ); - } - } - } -}; -var event_hook_default = [eventScheduleDerive, eventDoNotCallGuard, eventActivityBubble]; - -// src/sales/objects/forecast.hook.ts -var forecastDerive = { - name: "forecast_derive_period", - object: "crm_forecast", - events: ["beforeInsert", "beforeUpdate"], - priority: 200, - description: "Derive period_start, period_end and period_label from period (+ snapshot_date).", - handler: async (ctx) => { - if (ctx.event === "beforeUpdate" && ctx.dispatch?.mode === "per-row") return; - const pad = (n) => String(n).padStart(2, "0"); - const isoDate = (d) => `${d.getUTCFullYear()}-${pad(d.getUTCMonth() + 1)}-${pad(d.getUTCDate())}`; - const MONTHS = ["Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"]; - const endOfMonth = (start) => new Date(Date.UTC(start.getUTCFullYear(), start.getUTCMonth() + 1, 0)); - const endOfQuarter = (start) => new Date(Date.UTC(start.getUTCFullYear(), start.getUTCMonth() + 3, 0)); - const startOfPeriod = (period2, d) => new Date(Date.UTC( - d.getUTCFullYear(), - period2 === "quarter" ? Math.floor(d.getUTCMonth() / 3) * 3 : d.getUTCMonth(), - 1 - )); - const labelFor = (period2, start) => { - if (period2 === "quarter") { - const q = Math.floor(start.getUTCMonth() / 3) + 1; - return `Q${q} ${start.getUTCFullYear()}`; - } - return `${MONTHS[start.getUTCMonth()]} ${start.getUTCFullYear()}`; - }; - const { input } = ctx; - const previous = ctx.previous; - const period = typeof input.period === "string" && input.period || typeof previous?.period === "string" && previous.period || "month"; - let startStr = typeof input.period_start === "string" && input.period_start || typeof previous?.period_start === "string" && previous.period_start || void 0; - if (!startStr) { - const anchorStr = typeof input.snapshot_date === "string" && input.snapshot_date || typeof previous?.snapshot_date === "string" && previous.snapshot_date || isoDate(/* @__PURE__ */ new Date()); - const anchor = /* @__PURE__ */ new Date(`${anchorStr.slice(0, 10)}T00:00:00Z`); - if (!Number.isNaN(anchor.getTime())) { - startStr = isoDate(startOfPeriod(period, anchor)); - input.period_start = startStr; - } - } - if (startStr) { - const start = /* @__PURE__ */ new Date(`${startStr}T00:00:00Z`); - if (!Number.isNaN(start.getTime())) { - const end = period === "quarter" ? endOfQuarter(start) : endOfMonth(start); - if (!input.period_end) input.period_end = isoDate(end); - if (!input.period_label) input.period_label = labelFor(period, start); - } - } - if (!input.snapshot_date && !previous?.snapshot_date) { - input.snapshot_date = isoDate(/* @__PURE__ */ new Date()); - } - } -}; -var forecast_hook_default = forecastDerive; - -// src/sales/objects/lead.hook.ts -var leadAutoAssignHook = { - name: "lead_auto_assign", - object: "crm_lead", - events: ["beforeInsert"], - priority: 250, - description: "Assign ownerless new leads to the least-loaded sales rep.", - handler: async (ctx) => { - const { input } = ctx; - if (typeof input.owner_id === "string" && input.owner_id) return; - const api = ctx.api; - if (!api) return; - try { - const holders = await api.object("sys_user_position").find({ - where: { position: "sales_rep" }, - fields: ["user_id"], - top: 1e3 - }); - const repIds = Array.from( - new Set( - (holders ?? []).map((r) => typeof r.user_id === "string" ? r.user_id : "").filter(Boolean) - ) - ); - if (repIds.length === 0) return; - let best; - let bestCount = Infinity; - for (const repId of repIds) { - const openCount = await api.object("crm_lead").count({ - where: { owner_id: repId, is_converted: false } - }); - if (openCount < bestCount) { - bestCount = openCount; - best = repId; - } - } - if (best) input.owner_id = best; - } catch { - } - } -}; -var leadHook = { - name: "lead_automation", - object: "crm_lead", - events: ["beforeInsert", "beforeUpdate", "afterUpdate"], - priority: 200, - description: "Score new leads, lock converted leads, and create follow-up task on qualification.", - handler: async (ctx) => { - function refuse(message, code, status, userMessage = message) { - const err = new Error(message); - err.code = code; - err.status = status; - err.userMessage = userMessage; - return err; - } - const { event, input } = ctx; - const HIGH_VALUE_INDUSTRIES = /* @__PURE__ */ new Set(["technology", "finance", "healthcare"]); - const SENIOR_TITLE_PATTERN = /\b(ceo|cto|cfo|cio|coo|founder|vp|vice president|director|head of)\b/i; - function computeRating(input2) { - let score = 0; - const email = typeof input2.email === "string" ? input2.email : ""; - const phone = typeof input2.phone === "string" ? input2.phone : ""; - const title = typeof input2.title === "string" ? input2.title : ""; - const industry = typeof input2.industry === "string" ? input2.industry : ""; - const employees = typeof input2.number_of_employees === "number" ? input2.number_of_employees : 0; - const revenue = typeof input2.annual_revenue === "number" ? input2.annual_revenue : 0; - if (email && !/(gmail|yahoo|hotmail|outlook|qq|163)\.com$/i.test(email)) score += 1; - if (phone.length > 0) score += 0.5; - if (SENIOR_TITLE_PATTERN.test(title)) score += 1.5; - if (HIGH_VALUE_INDUSTRIES.has(industry)) score += 1; - if (employees >= 200) score += 0.5; - if (revenue >= 1e7) score += 0.5; - const clamped = Math.max(1, Math.min(5, score)); - return Math.round(clamped); - } - if (event === "beforeInsert") { - const isGuestSubmission = !ctx.user?.id && !ctx.session?.isSystem; - if (isGuestSubmission) { - if (!input.lead_source) input.lead_source = "web"; - if (!input.status) input.status = "new"; - input.is_converted = false; - input.converted_account = null; - input.converted_contact = null; - input.converted_opportunity = null; - input.converted_date = null; - input.owner_id = null; - input.duplicate_of_type = null; - input.duplicate_of_lead = null; - input.duplicate_of_contact = null; - input.duplicate_status = null; - } - if (typeof input.rating !== "number") { - input.rating = computeRating(input); - } - } - if (event === "beforeUpdate") { - const previous = ctx.previous; - const wasConverted = previous?.is_converted === true || previous?.status === "converted"; - const isConverting = !wasConverted && (input.is_converted === true || input.status === "converted"); - const verdict = previous?.conversion_approval_status; - if (isConverting && (verdict === "pending" || verdict === "rejected")) { - const person = [previous?.first_name, previous?.last_name].filter((part) => typeof part === "string" && part.trim() !== "").join(" "); - const company = typeof previous?.company === "string" ? previous.company.trim() : ""; - const label = [person, company].filter(Boolean).join(" - "); - const state = verdict === "rejected" ? "was rejected" : "is still awaiting approval"; - throw refuse( - `Cannot convert ${label ? `lead ${label}` : "this lead"}: its conversion ${state}. Conversion opens once an approver signs it off \u2014 the Conversion Approval field on the lead shows where it stands.`, - "RECORD_LOCKED", - 409 - ); - } - } - if (event === "beforeUpdate" && ctx.user?.id) { - const previous = ctx.previous; - const wasConverted = previous?.is_converted === true || previous?.status === "converted"; - if (wasConverted) { - const ALLOWED = /* @__PURE__ */ new Set([ - "description", - "notes", - // Framework-managed / system columns (cf. opportunity.hook.ts). - "id", - "owner_id", - "created_at", - "updated_at", - "created_by", - "updated_by", - "space_id", - "organization_id", - "org_id", - "version" - ]); - const violating = Object.keys(input).filter( - (k) => !ALLOWED.has(k) && input[k] !== previous?.[k] - ); - if (violating.length > 0) { - const REFERENCE_FIELDS = /* @__PURE__ */ new Set([ - "converted_account", - "converted_contact", - "converted_opportunity", - "duplicate_of_lead", - "duplicate_of_contact" - ]); - const isReferenceCleanup = violating.every( - (k) => REFERENCE_FIELDS.has(k) && input[k] === null && previous?.[k] != null - ); - if (isReferenceCleanup) return; - const person = [previous?.first_name, previous?.last_name].filter((part) => typeof part === "string" && part.trim() !== "").join(" "); - const company = typeof previous?.company === "string" ? previous.company.trim() : ""; - const label = [person, company].filter(Boolean).join(" - "); - throw refuse( - `Cannot edit ${label ? `converted lead ${label}` : "a converted lead"} (attempted: ${violating.join(", ")}). Make changes on the converted records instead.`, - "RECORD_LOCKED", - 409 - ); - } - } - } - if (event === "afterUpdate") { - const previous = ctx.previous; - const becameQualified = input.status === "qualified" && previous?.status !== "qualified"; - if (!becameQualified) return; - const api = ctx.api; - if (!api) return; - const leadId = typeof input.id === "string" && input.id || typeof previous?.id === "string" && previous.id || void 0; - const ownerId = typeof input.owner_id === "string" && input.owner_id || typeof previous?.owner_id === "string" && previous.owner_id || ctx.user?.id; - const dueDate = /* @__PURE__ */ new Date(); - dueDate.setUTCDate(dueDate.getUTCDate() + 2); - const person = [ - typeof input.first_name === "string" && input.first_name || previous?.first_name, - typeof input.last_name === "string" && input.last_name || previous?.last_name - ].filter((part) => typeof part === "string" && part.trim() !== "").join(" "); - const company = typeof input.company === "string" && input.company.trim() || typeof previous?.company === "string" && previous.company.trim() || ""; - const label = [person, company].filter(Boolean).join(" - "); - const titled = label ? `Follow up with qualified lead: ${label}` : "Follow up with qualified lead"; - try { - await api.object("crm_task").insert({ - subject: titled.length > 255 ? `${titled.slice(0, 254)}\u2026` : titled, - status: "not_started", - priority: "high", - type: "follow_up", - due_date: dueDate.toISOString().slice(0, 10), - // Unlike `lead_auto_assign` above, this is a SEPARATE insert on - // `ctx.api` — a new operation carrying the caller's context, so the - // #3004 transfer guard does apply to it. When the qualifier is the - // lead's own rep (`owner_id` == caller) it is not a transfer at all; - // a manager qualifying a rep's lead holds `allowTransfer`. Any other - // caller is denied and the catch below drops the task rather than - // landing it on the wrong desk. - owner_id: ownerId, - related_to_type: "crm_lead", - related_to_lead: leadId - }); - } catch { - } - } - } -}; -var leadDuplicateCheckHook = { - name: "lead_duplicate_check", - object: "crm_lead", - events: ["beforeInsert", "beforeUpdate"], - priority: 300, - description: "Normalize lead email and company match key; flag a re-captured address as a suspected duplicate of the record it repeats.", - handler: async (ctx) => { - const { event, input } = ctx; - const SCAN_LIMIT = 50; - const isBlank = (value) => value === void 0 || value === null || typeof value === "string" && value.trim() === ""; - if (typeof input.email === "string") { - input.email = input.email.trim().toLowerCase(); - } - const email = typeof input.email === "string" ? input.email : ""; - if ("company" in input) { - const rawCompany = input.company; - const normalizedCompany = typeof rawCompany === "string" ? rawCompany.trim().toLowerCase().replace(/\s+/g, " ") : ""; - input.company_normalized = normalizedCompany === "" ? null : normalizedCompany; - } - if (event === "beforeUpdate" && ctx.dispatch?.mode !== "per-row") { - const previous = ctx.previous; - const LINK_OF_TYPE = { - crm_lead: "duplicate_of_lead", - crm_contact: "duplicate_of_contact" - }; - const restated = "duplicate_of_type" in input && !isBlank(input.duplicate_of_type); - const declared = previous?.duplicate_of_type; - const link = typeof declared === "string" ? LINK_OF_TYPE[declared] : void 0; - if (!restated && link && link in input && isBlank(input[link])) { - if (!("duplicate_status" in input) && previous?.duplicate_status === "confirmed") { - input.duplicate_of_type = "erased"; - } else { - input.duplicate_of_type = null; - input.duplicate_status = null; - } - } - } - if (event !== "beforeInsert" || !email) return; - if (!isBlank(input.duplicate_status) || !isBlank(input.duplicate_of_type)) return; - const api = ctx.api; - if (!api) return; - const original = (rows) => { - let best; - let bestKey = Infinity; - for (const row of rows) { - const id = typeof row.id === "string" ? row.id : ""; - if (!id) continue; - const raw = row.created_at; - const parsed = typeof raw === "string" || typeof raw === "number" || raw instanceof Date ? new Date(raw).getTime() : Number.NaN; - const key = Number.isFinite(parsed) ? parsed : Infinity; - if (best === void 0 || key < bestKey) { - best = id; - bestKey = key; - } - } - return best; - }; - try { - const contacts2 = await api.object("crm_contact").find({ - where: { email }, - fields: ["id", "created_at"], - top: SCAN_LIMIT - }); - const contactId = original(contacts2 ?? []); - if (contactId) { - input.duplicate_of_type = "crm_contact"; - input.duplicate_of_contact = contactId; - input.duplicate_status = "suspected"; - return; - } - const leads2 = await api.object("crm_lead").find({ - where: { email, is_converted: false }, - fields: ["id", "created_at"], - top: SCAN_LIMIT - }); - const leadId = original(leads2 ?? []); - if (leadId) { - input.duplicate_of_type = "crm_lead"; - input.duplicate_of_lead = leadId; - input.duplicate_status = "suspected"; - } - } catch { - } - } -}; -var lead_hook_default = [leadAutoAssignHook, leadHook, leadDuplicateCheckHook]; - -// src/sales/objects/lead.campaign-metrics.hook.ts -var campaignLeadConversionRefresh = { - name: "campaign_lead_conversion_refresh", - object: "crm_lead", - events: ["afterUpdate"], - priority: 810, - async: true, - onError: "log", - runAs: "system", - description: "Promote campaign members of a converting lead and recompute campaign metrics.", - handler: async (ctx) => { - const api = ctx.api; - if (!api) return; - const { input } = ctx; - const previous = ctx.previous; - if (input?.is_converted !== true) return; - if (previous?.is_converted === true) return; - const leadId = typeof input?.id === "string" && input.id || (typeof previous?.id === "string" ? previous.id : ""); - if (!leadId) return; - const memberships = await api.object("crm_campaign_member").find({ - where: { crm_lead: leadId }, - fields: ["id", "crm_campaign", "status"], - top: 500 - }); - for (const m of memberships) { - const memberId = typeof m.id === "string" ? m.id : ""; - if (!memberId) continue; - if (m.status !== "sent" && m.status !== "responded") continue; - await api.object("crm_campaign_member").update( - { id: memberId, status: "converted" }, - { where: { id: memberId } } - ); - } - const campaignIds = Array.from(new Set( - memberships.map((m) => typeof m.crm_campaign === "string" ? m.crm_campaign : "").filter(Boolean) - )); - for (const id of campaignIds) { - const memberRows = await api.object("crm_campaign_member").find({ - where: { crm_campaign: id }, - fields: ["crm_lead", "status"], - top: 5e3 - }); - const leadIds = Array.from(new Set( - memberRows.map((r) => typeof r.crm_lead === "string" ? r.crm_lead : "").filter(Boolean) - )); - const convertedLeads = leadIds.length > 0 ? await api.object("crm_lead").count({ where: { id: { $in: leadIds }, is_converted: true } }) : 0; - const numOpportunities = await api.object("crm_opportunity").count({ where: { crm_campaign: id } }); - const numWon = await api.object("crm_opportunity").count({ where: { crm_campaign: id, stage: "closed_won" } }); - const wonRows = await api.object("crm_opportunity").find({ - where: { crm_campaign: id, stage: "closed_won" }, - fields: ["amount"], - top: 5e3 - }); - const actualRevenue = wonRows.reduce( - (sum, row) => sum + (typeof row.amount === "number" ? row.amount : Number(row.amount) || 0), - 0 - ); - await api.object("crm_campaign").update({ - id, - num_sent: memberRows.length, - num_responses: memberRows.filter((r) => r.status === "responded" || r.status === "converted").length, - num_leads: leadIds.length, - num_converted_leads: convertedLeads, - num_opportunities: numOpportunities, - num_won_opportunities: numWon, - actual_revenue: actualRevenue - }, { where: { id } }); - } - } -}; -var lead_campaign_metrics_hook_default = [campaignLeadConversionRefresh]; - -// src/sales/objects/opportunity.hook.ts -var opportunityValidationHook = { - name: "opportunity_lifecycle", - object: "crm_opportunity", - events: ["beforeInsert", "beforeUpdate"], - priority: 200, - description: "Recompute expected_revenue, freeze closed opportunities except narrative fields.", - handler: async (ctx) => { - function refuse(message, code, status, userMessage = message) { - const err = new Error(message); - err.code = code; - err.status = status; - err.userMessage = userMessage; - return err; - } - const STAGE_PROBABILITY = { - prospecting: 10, - qualification: 25, - needs_analysis: 40, - proposal: 60, - negotiation: 80, - closed_won: 100, - closed_lost: 0 - }; - const NARRATIVE_FIELDS = /* @__PURE__ */ new Set(["description", "next_step", "notes"]); - const SYSTEM_FIELDS = /* @__PURE__ */ new Set([ - "id", - "owner_id", - "created_at", - "updated_at", - "created_by", - "updated_by", - "space_id", - "organization_id", - "org_id", - "version" - ]); - const APPROVAL_FIELDS = /* @__PURE__ */ new Set([ - "approval_status", - "approved_date", - "status_change_approval_status", - "requested_status", - "qualification_approval_status", - "qualification_requested" - ]); - const STAGE_FORECAST = { - prospecting: "pipeline", - qualification: "pipeline", - needs_analysis: "best_case", - proposal: "commit", - negotiation: "commit", - closed_won: "closed", - closed_lost: "omitted" - }; - const { event, input } = ctx; - const previous = ctx.previous; - if (event === "beforeUpdate" && previous && ctx.user?.id) { - const qualification = input.qualification_approval_status ?? previous.qualification_approval_status; - if (qualification === "pending" || qualification === "rejected") { - const held = []; - if (typeof input.stage === "string" && input.stage !== previous.stage) held.push("Stage"); - if (typeof input.requested_status === "string" && input.requested_status !== "" && input.requested_status !== previous.requested_status) { - held.push("Requested Status"); - } - if (held.length > 0) { - throw refuse( - `This deal needs qualification approval first: tick Request Qualification Approval. ${held.join(" and ")} can change once it is approved.`, - "RECORD_LOCKED", - 409 - ); - } - } - } - if (event === "beforeUpdate" && previous && ctx.user?.id) { - const gate = input.status_change_approval_status ?? previous.status_change_approval_status; - const next = input.stage; - const closing = (next === "closed_won" || next === "closed_lost") && next !== previous.stage; - if (closing && (gate === "pending" || gate === "rejected")) { - throw refuse( - "This deal's status change needs approval: set Requested Status (and the win/loss reason) instead. The stage takes effect when the request is approved.", - "RECORD_LOCKED", - 409 - ); - } - } - if (event === "beforeUpdate" && previous && ctx.user?.id) { - const prevStage = previous.stage; - const isClosed = prevStage === "closed_won" || prevStage === "closed_lost"; - if (isClosed) { - const violating = Object.keys(input).filter( - (k) => !NARRATIVE_FIELDS.has(k) && !SYSTEM_FIELDS.has(k) && !APPROVAL_FIELDS.has(k) && input[k] !== previous[k] - ); - if (violating.length > 0) { - const REFERENCE_FIELDS = /* @__PURE__ */ new Set(["crm_account", "primary_contact", "crm_campaign"]); - const isReferenceCleanup = violating.every( - (k) => REFERENCE_FIELDS.has(k) && input[k] === null && previous?.[k] != null - ); - if (isReferenceCleanup) return; - const name = typeof previous.name === "string" ? previous.name.trim() : ""; - const subject = name ? `Opportunity ${name}` : "Opportunity"; - throw refuse( - `${subject} is closed (${prevStage}); only ${[...NARRATIVE_FIELDS].join(", ")} may be edited. Attempted: ${violating.join(", ")}.`, - "RECORD_LOCKED", - 409 - ); - } - } - } - if (ctx.event === "beforeUpdate" && ctx.dispatch?.mode === "per-row") return; - const amount = typeof input.amount === "number" ? input.amount : typeof previous?.amount === "number" ? previous.amount : void 0; - const stage = typeof input.stage === "string" ? input.stage : typeof previous?.stage === "string" ? previous.stage : void 0; - if (typeof amount === "number" && stage && STAGE_PROBABILITY[stage] !== void 0) { - input.expected_revenue = Math.round(amount * STAGE_PROBABILITY[stage]) / 100; - } - if (stage && STAGE_PROBABILITY[stage] !== void 0) { - input.probability = STAGE_PROBABILITY[stage]; - } - if (stage && STAGE_FORECAST[stage] !== void 0) { - const stageChanged = event === "beforeInsert" || typeof input.stage === "string" && input.stage !== previous?.stage; - if (stageChanged) input.forecast_category = STAGE_FORECAST[stage]; - } - if (event === "beforeInsert" && !input.stage_entry_date) { - input.stage_entry_date = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10); - } - if (event === "beforeUpdate" && previous) { - if (input.stage === "closed_won" && previous.stage !== "closed_won" && !input.close_date) { - input.close_date = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10); - } - if (typeof input.stage === "string" && input.stage !== previous.stage) { - input.stage_entry_date = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10); - } - } - } -}; -var opportunityWonHook = { - name: "opportunity_promote_account", - object: "crm_opportunity", - events: ["afterUpdate"], - priority: 800, - async: true, - onError: "log", - runAs: "system", - description: "On closed_won: promote linked account to customer and create activation task.", - handler: async (ctx) => { - const { input } = ctx; - const previous = ctx.previous; - const becameWon = input.stage === "closed_won" && previous?.stage !== "closed_won"; - if (!becameWon) return; - const api = ctx.api; - if (!api) return; - const accountId = typeof input.crm_account === "string" && input.crm_account || typeof previous?.crm_account === "string" && previous.crm_account || void 0; - if (!accountId) return; - const account = await api.object("crm_account").findOne({ where: { id: accountId } }); - if (account && account.type !== "customer") { - await api.object("crm_account").update( - { id: accountId, type: "customer" }, - { where: { id: accountId } } - ); - } - const oppId = typeof input.id === "string" && input.id || previous?.id; - const ownerId = typeof input.owner_id === "string" && input.owner_id || typeof previous?.owner_id === "string" && previous.owner_id || ctx.user?.id; - const due = /* @__PURE__ */ new Date(); - due.setUTCDate(due.getUTCDate() + 3); - const oppName = typeof input.name === "string" && input.name.trim() || typeof previous?.name === "string" && previous.name.trim() || ""; - const titled = oppName ? `Activate new customer for opportunity ${oppName}` : "Activate new customer"; - await api.object("crm_task").insert({ - subject: titled.length > 255 ? `${titled.slice(0, 254)}\u2026` : titled, - status: "not_started", - priority: "high", - type: "follow_up", - due_date: due.toISOString().slice(0, 10), - owner_id: ownerId, - related_to_type: "crm_opportunity", - related_to_opportunity: oppId, - related_to_account: accountId - }); - } -}; -var opportunityAccountCapabilityHook = { - name: "opportunity_account_capability", - object: "crm_opportunity", - events: ["beforeInsert"], - priority: 150, - runAs: "system", - description: "Refuse a NEW opportunity linked to an account whose commercial capability is settlement only.", - handler: async (ctx) => { - function refuse(message, code, status, userMessage = message) { - const err = new Error(message); - err.code = code; - err.status = status; - err.userMessage = userMessage; - return err; - } - const api = ctx.api; - if (!api) return; - const accountId = ctx.input.crm_account; - if (typeof accountId !== "string" || accountId === "") return; - const org = ctx.input.organization_id; - const account = await api.object("crm_account").findOne({ - where: { id: accountId, ...typeof org === "string" && org ? { organization_id: org } : {} }, - fields: ["commercial_capability"] - }); - if (!account || account.commercial_capability !== "settlement_only") return; - throw refuse( - "Cannot open an opportunity against this account: its Commercial Capability is Settlement Only, so it is available for billing and payment but no new business may be booked against it. Pick a different account, or have the account reclassified to Full first.", - "VALIDATION_FAILED", - 400 - ); - } -}; -var opportunity_hook_default = [ - opportunityAccountCapabilityHook, - opportunityValidationHook, - opportunityWonHook -]; - -// src/sales/objects/opportunity.campaign-metrics.hook.ts -var campaignAttributionRefresh = { - name: "campaign_attribution_refresh", - object: "crm_opportunity", - events: ["afterInsert", "afterUpdate", "afterDelete"], - priority: 810, - async: true, - onError: "log", - runAs: "system", - description: "Recompute campaign metrics when an opportunity\u2019s campaign attribution changes.", - handler: async (ctx) => { - const api = ctx.api; - if (!api) return; - const { input } = ctx; - const previous = ctx.previous; - const campaignIds = Array.from(new Set([ - typeof input?.crm_campaign === "string" ? input.crm_campaign : "", - typeof previous?.crm_campaign === "string" ? previous.crm_campaign : "" - ].filter(Boolean))); - for (const id of campaignIds) { - const memberRows = await api.object("crm_campaign_member").find({ - where: { crm_campaign: id }, - fields: ["crm_lead", "status"], - top: 5e3 - }); - const leadIds = Array.from(new Set( - memberRows.map((r) => typeof r.crm_lead === "string" ? r.crm_lead : "").filter(Boolean) - )); - const convertedLeads = leadIds.length > 0 ? await api.object("crm_lead").count({ where: { id: { $in: leadIds }, is_converted: true } }) : 0; - const numOpportunities = await api.object("crm_opportunity").count({ where: { crm_campaign: id } }); - const numWon = await api.object("crm_opportunity").count({ where: { crm_campaign: id, stage: "closed_won" } }); - const wonRows = await api.object("crm_opportunity").find({ - where: { crm_campaign: id, stage: "closed_won" }, - fields: ["amount"], - top: 5e3 - }); - const actualRevenue = wonRows.reduce( - (sum, row) => sum + (typeof row.amount === "number" ? row.amount : Number(row.amount) || 0), - 0 - ); - await api.object("crm_campaign").update({ - id, - num_sent: memberRows.length, - num_responses: memberRows.filter((r) => r.status === "responded" || r.status === "converted").length, - num_leads: leadIds.length, - num_converted_leads: convertedLeads, - num_opportunities: numOpportunities, - num_won_opportunities: numWon, - actual_revenue: actualRevenue - }, { where: { id } }); - } - } -}; -var opportunity_campaign_metrics_hook_default = [campaignAttributionRefresh]; - -// src/sales/objects/task.hook.ts -var taskValidation = { - name: "task_completion", - object: "crm_task", - events: ["beforeInsert", "beforeUpdate"], - priority: 200, - description: "Stamp completed/overdue flags + dates on completion and validate reminder timing.", - handler: async (ctx) => { - if (ctx.event === "beforeUpdate" && ctx.dispatch?.mode === "per-row") return; - function refuse(message, code, status, userMessage = message) { - const err = new Error(message); - err.code = code; - err.status = status; - err.userMessage = userMessage; - return err; - } - const { input } = ctx; - const previous = ctx.previous; - if (!previous && input.reminder_sent == null) { - input.reminder_sent = false; - } - const effPriority = typeof input.priority === "string" && input.priority || typeof previous?.priority === "string" && previous.priority || void 0; - if (effPriority) { - const rank = { low: 1, normal: 2, high: 3, urgent: 4 }; - input.priority_rank = rank[effPriority] ?? 0; - } - if (input.status === "completed" && previous?.status !== "completed") { - if (!input.completed_date || !ctx.session?.isSystem) { - input.completed_date = (/* @__PURE__ */ new Date()).toISOString(); - } - if (typeof input.progress_percent !== "number") input.progress_percent = 100; - } - const effStatus = typeof input.status === "string" && input.status || typeof previous?.status === "string" && previous.status || void 0; - if (typeof effStatus === "string") input.is_completed = effStatus === "completed"; - const effDue = typeof input.due_date === "string" && input.due_date || typeof previous?.due_date === "string" && previous.due_date || void 0; - const todayStr = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10); - input.is_overdue = !!effDue && effDue.slice(0, 10) < todayStr && input.is_completed !== true; - const reminder = typeof input.reminder_date === "string" && input.reminder_date || typeof previous?.reminder_date === "string" && previous.reminder_date || void 0; - const due = typeof input.due_date === "string" && input.due_date || typeof previous?.due_date === "string" && previous.due_date || void 0; - if (reminder && due && reminder.slice(0, 10) > due.slice(0, 10)) { - throw refuse( - `Reminder (${reminder}) is after the due date (${due}); reminders should fire before the deadline.`, - "VALIDATION_FAILED", - 400 - ); - } - } -}; -var taskRecurrence = { - name: "task_recurrence", - object: "crm_task", - events: ["afterUpdate"], - priority: 700, - async: true, - onError: "log", - description: "On completion of a recurring task, spawn the next occurrence (dates advanced by recurrence_type \xD7 interval).", - handler: async (ctx) => { - function advanceDate(d, type2, interval2) { - const next = new Date(d); - if (type2 === "daily") { - next.setUTCDate(next.getUTCDate() + interval2); - return next; - } - if (type2 === "weekly") { - next.setUTCDate(next.getUTCDate() + 7 * interval2); - return next; - } - const months = type2 === "monthly" ? interval2 : type2 === "yearly" ? 12 * interval2 : 0; - if (months === 0) return next; - const day = next.getUTCDate(); - next.setUTCDate(1); - next.setUTCMonth(next.getUTCMonth() + months); - const lastDayOfTargetMonth = new Date(Date.UTC( - next.getUTCFullYear(), - next.getUTCMonth() + 1, - 0 - )).getUTCDate(); - next.setUTCDate(Math.min(day, lastDayOfTargetMonth)); - return next; - } - const { input } = ctx; - const previous = ctx.previous; - const api = ctx.api; - if (!api) return; - const nowDone = input.status === "completed" || input.is_completed === true; - const wasDone = previous?.status === "completed" || previous?.is_completed === true; - if (!nowDone || wasDone) return; - const r = { ...previous ?? {}, ...input }; - if (r.is_recurring !== true) return; - const type = typeof r.recurrence_type === "string" ? r.recurrence_type : void 0; - if (!type || !["daily", "weekly", "monthly", "yearly"].includes(type)) return; - const interval = Number(r.recurrence_interval) > 0 ? Number(r.recurrence_interval) : 1; - const baseDue = r.due_date ? new Date(r.due_date) : /* @__PURE__ */ new Date(); - if (isNaN(baseDue.getTime())) return; - const nextDue = advanceDate(baseDue, type, interval); - if (r.recurrence_end_date) { - const end = new Date(r.recurrence_end_date); - if (!isNaN(end.getTime()) && nextDue > end) return; - } - const doc = { - subject: r.subject, - description: r.description ?? null, - priority: r.priority, - type: r.type ?? null, - owner_id: r.owner_id ?? null, - status: "not_started", - is_completed: false, - reminder_sent: false, - due_date: nextDue.toISOString().slice(0, 10), - is_recurring: true, - recurrence_type: type, - recurrence_interval: interval, - recurrence_end_date: r.recurrence_end_date ?? null, - related_to_type: r.related_to_type ?? null, - related_to_account: r.related_to_account ?? null, - related_to_contact: r.related_to_contact ?? null, - related_to_opportunity: r.related_to_opportunity ?? null, - related_to_lead: r.related_to_lead ?? null, - related_to_case: r.related_to_case ?? null - }; - if (r.reminder_date) { - const baseRem = new Date(r.reminder_date); - if (!isNaN(baseRem.getTime())) doc.reminder_date = advanceDate(baseRem, type, interval).toISOString(); - } - try { - await api.object("crm_task").insert(doc); - } catch { - } - } -}; -var taskBubble = { - name: "task_activity_bubble", - object: "crm_task", - events: ["afterUpdate"], - priority: 800, - async: true, - onError: "log", - runAs: "system", - description: "A completed task stamps interaction recency on the related account (walking up from contact/opportunity/case), lead and contact.", - handler: async (ctx) => { - const { input } = ctx; - const previous = ctx.previous; - const api = ctx.api; - if (!api) return; - const nowDone = input.status === "completed" || input.is_completed === true; - const wasDone = previous?.status === "completed" || previous?.is_completed === true; - if (!nowDone || wasDone) return; - const r = { ...previous ?? {}, ...input }; - const nowIso = (/* @__PURE__ */ new Date()).toISOString(); - const today = nowIso.slice(0, 10); - const idOf = (key) => typeof r[key] === "string" && r[key].length > 0 ? r[key] : void 0; - const org = idOf("organization_id"); - const inOrg = org ? { organization_id: org } : {}; - const accountIds = /* @__PURE__ */ new Set(); - const contactIds = /* @__PURE__ */ new Set(); - const leadIds = /* @__PURE__ */ new Set(); - const direct = idOf("related_to_account"); - if (direct) accountIds.add(direct); - const contactId = idOf("related_to_contact"); - if (contactId) contactIds.add(contactId); - const leadId = idOf("related_to_lead"); - if (leadId) leadIds.add(leadId); - const parentLookups = [ - ["related_to_contact", "crm_contact"], - ["related_to_opportunity", "crm_opportunity"], - ["related_to_case", "crm_case"] - ]; - for (const [field, object] of parentLookups) { - const id = idOf(field); - if (!id) continue; - try { - const raw = await api.object(object).find({ - where: { id, ...inOrg }, - fields: ["crm_account"], - top: 1 - }); - const rows = Array.isArray(raw) ? raw : raw?.records ?? []; - const parent = rows.length ? rows[0].crm_account : void 0; - if (typeof parent === "string" && parent.length > 0) accountIds.add(parent); - } catch { - } - } - const targets = [ - ["crm_account", accountIds, { last_activity_date: today }], - ["crm_contact", contactIds, { last_contacted_date: nowIso }], - ["crm_lead", leadIds, { last_contacted_date: nowIso }] - ]; - for (const [object, ids, doc] of targets) { - let inside = [...ids]; - if (org && inside.length > 0) { - try { - const raw = await api.object(object).find({ where: { id: { $in: inside }, ...inOrg }, fields: ["id"], top: inside.length }); - inside = (Array.isArray(raw) ? raw : raw?.records ?? []).map((row) => String(row.id)); - } catch { - inside = []; - } - } - for (const id of inside) { - try { - await api.object(object).update({ ...doc, id }, { where: { id } }); - } catch { - } - } - } - } -}; -var taskDoNotCallGuard = { - name: "task_do_not_call_guard", - object: "crm_task", - events: ["beforeInsert", "beforeUpdate"], - priority: 150, - description: "Refuse to schedule an open Call task against a lead/contact flagged Do Not Call.", - handler: async (ctx) => { - function refuse(message, code, status, userMessage = message) { - const err = new Error(message); - err.code = code; - err.status = status; - err.userMessage = userMessage; - return err; - } - const { input } = ctx; - const previous = ctx.previous; - const api = ctx.api; - if (!api) return; - const effective = (key) => input[key] !== void 0 && input[key] !== null ? input[key] : previous?.[key]; - if (effective("type") !== "call") return; - if (effective("status") === "completed") return; - const leadId = effective("related_to_lead"); - const contactId = effective("related_to_contact"); - const targets = []; - if (typeof leadId === "string" && leadId) { - targets.push({ object: "crm_lead", id: leadId, label: "lead" }); - } - if (typeof contactId === "string" && contactId) { - targets.push({ object: "crm_contact", id: contactId, label: "contact" }); - } - for (const t of targets) { - const raw = await api.object(t.object).find({ - where: { id: t.id }, - fields: ["id", "do_not_call"], - top: 1 - }); - const rows = Array.isArray(raw) ? raw : raw?.records ?? []; - const person = rows[0]; - if (person?.do_not_call === true) { - throw refuse( - `This ${t.label} is flagged Do Not Call, so a Call task cannot be scheduled against them. Log a completed call if one already happened, choose a non-phone activity type, or clear Do Not Call on the record first.`, - "FORBIDDEN", - 403 - ); - } - } - } -}; -var task_hook_default = [taskValidation, taskDoNotCallGuard, taskRecurrence, taskBubble]; - -// src/revenue/objects/contract.hook.ts -var contractValidation = { - name: "contract_validation", - object: "crm_contract", - events: ["beforeInsert", "beforeUpdate"], - priority: 200, - description: "Enforce contract term math and prevent shrinking end_date once activated.", - handler: async (ctx) => { - function refuse(message, code, status, userMessage = message) { - const err = new Error(message); - err.code = code; - err.status = status; - err.userMessage = userMessage; - return err; - } - const { event, input, previous } = ctx; - function monthsBetween(startISO, endISO) { - const s = new Date(startISO); - const e = new Date(endISO); - return (e.getUTCFullYear() - s.getUTCFullYear()) * 12 + (e.getUTCMonth() - s.getUTCMonth()) + // Unchanged intent: has the end day-of-month reached the start's yet? - // If not, the last month is not complete and does not count. - (e.getUTCDate() >= s.getUTCDate() ? 0 : -1); - } - const startDate = [input.start_date, previous?.start_date].find((v) => typeof v === "string" && v !== ""); - const endDate = [input.end_date, previous?.end_date].find((v) => typeof v === "string" && v !== ""); - const term = [input.contract_term_months, previous?.contract_term_months].find((v) => typeof v === "number" && !!v); - if (startDate && endDate && term) { - const calc = monthsBetween(startDate, endDate); - if (Math.abs(calc - term) > 1) { - throw refuse( - `Contract term (${term} months) does not match date range (${calc} months from ${startDate} to ${endDate}).`, - "VALIDATION_FAILED", - 400 - ); - } - } - if (event === "beforeUpdate" && previous?.status === "activated") { - if (typeof input.end_date === "string" && typeof previous.end_date === "string" && input.end_date < previous.end_date) { - throw refuse( - `Cannot shrink end_date (${previous.end_date} \u2192 ${input.end_date}) after activation. Use a termination/amendment workflow instead.`, - "RECORD_LOCKED", - 409 - ); - } - } - } -}; -var contractActivation = { - name: "contract_on_activation", - object: "crm_contract", - events: ["afterUpdate"], - priority: 800, - async: true, - onError: "log", - description: "On activation: stamp signed_date, promote account.", - handler: async (ctx) => { - const { input, previous } = ctx; - if (input.status !== "activated" || previous?.status === "activated") return; - const api = ctx.api; - if (!api) return; - const id = [input.id, previous?.id].find((v) => typeof v === "string" && v !== ""); - const accountId = [input.crm_account, previous?.crm_account].find((v) => typeof v === "string" && v !== ""); - if (id && !input.signed_date && !previous?.signed_date) { - await api.object("crm_contract").update( - { id, signed_date: (/* @__PURE__ */ new Date()).toISOString().slice(0, 10) }, - { where: { id } } - ); - } - if (accountId) { - const account = await api.object("crm_account").findOne({ where: { id: accountId } }); - if (account && account.type !== "customer") { - await api.object("crm_account").update( - { id: accountId, type: "customer" }, - { where: { id: accountId } } - ); - } - } - } -}; -var contract_hook_default = [contractValidation, contractActivation]; - -// src/revenue/objects/_line-item-price-fill.ts -function createLineItemPriceFill(objectName, hookName) { - return { - name: hookName, - object: objectName, - events: ["beforeInsert", "beforeUpdate"], - priority: 100, - description: "Default list_price / unit_price from the chosen product.", - handler: async (ctx) => { - const { event, input } = ctx; - const api = ctx.api; - if (!api) return; - const productId = typeof input.crm_product === "string" ? input.crm_product : void 0; - if (!productId) return; - const product = await api.object("crm_product").findOne({ - where: { id: productId }, - fields: ["id", "list_price"] - }); - const listPrice = product && typeof product.list_price === "number" ? product.list_price : void 0; - if (listPrice === void 0) return; - input.list_price = listPrice; - if (event === "beforeInsert" && input.unit_price == null) { - input.unit_price = listPrice; - } - } - }; -} -function createLineItemNumbering(objectName, hookName) { - return { - name: hookName, - object: objectName, - events: ["beforeInsert", "beforeUpdate"], - priority: 110, - runAs: "system", - description: "Assign line_number = (max under the parent) + 1.", - handler: async (ctx) => { - const { event, input } = ctx; - const prev = ctx.previous; - const api = ctx.api; - if (!api) return; - if (!ctx.user?.id && typeof input.line_number === "number") return; - if (event === "beforeUpdate" && (ctx.dispatch?.mode === "per-row" || typeof prev?.line_number === "number")) return; - const parentKey = ctx.object === "crm_quote_line_item" ? "crm_quote" : "crm_opportunity"; - const parentId = input[parentKey] ?? prev?.[parentKey]; - if (typeof parentId !== "string" || !parentId) return; - const siblings = await api.object(ctx.object).find({ - where: { [parentKey]: parentId }, - fields: ["line_number"], - top: 5e3 - }); - let max = 0; - for (const s of siblings) { - if (typeof s.line_number === "number" && s.line_number > max) max = s.line_number; - } - const offset = event === "beforeInsert" && ctx.dispatch?.mode === "per-row" ? ctx.dispatch.index : 0; - input.line_number = max + 1 + offset; - } - }; -} - -// src/revenue/objects/opportunity_line_item.hook.ts -var opportunityLineItemPriceFill = createLineItemPriceFill( - "crm_opportunity_line_item", - "opportunity_line_item_price_fill" -); -var opportunityLineItemNumbering = createLineItemNumbering( - "crm_opportunity_line_item", - "opportunity_line_item_line_number" -); -var opportunityAmountRollup = { - name: "opportunity_amount_rollup", - object: "crm_opportunity_line_item", - events: ["afterInsert", "afterUpdate", "afterDelete"], - priority: 300, - async: true, - onError: "log", - description: "Recompute parent opportunity.amount from the sum of its line items.", - handler: async (ctx) => { - const api = ctx.api; - if (!api) return; - const { input, previous } = ctx; - const num = (v) => typeof v === "number" ? v : 0; - const oppIds = /* @__PURE__ */ new Set(); - for (const v of [input?.crm_opportunity, previous?.crm_opportunity]) { - if (typeof v === "string" && v) oppIds.add(v); - } - if (oppIds.size === 0) return; - for (const oppId of oppIds) { - const opp = await api.object("crm_opportunity").findOne({ - where: { id: oppId }, - fields: ["id", "stage"] - }); - const stage = opp && typeof opp.stage === "string" ? opp.stage : void 0; - if (stage === "closed_won" || stage === "closed_lost") continue; - const lines = await api.object("crm_opportunity_line_item").find({ - where: { crm_opportunity: oppId }, - fields: ["quantity", "unit_price", "discount"], - top: 5e3 - }); - if (!lines || lines.length === 0) continue; - let sum = 0; - for (const l of lines) sum += num(l.quantity) * num(l.unit_price) * (1 - num(l.discount) / 100); - sum = Math.round(sum * 100) / 100; - if (sum > 0) { - await api.object("crm_opportunity").update( - { id: oppId, amount: sum }, - { where: { id: oppId } } - ); - } - } - } -}; -var opportunity_line_item_hook_default = [opportunityLineItemPriceFill, opportunityLineItemNumbering, opportunityAmountRollup]; - -// src/revenue/objects/product.hook.ts -var productHook = { - name: "product_catalog", - object: "crm_product", - events: ["beforeInsert", "beforeUpdate", "beforeDelete"], - priority: 200, - description: "Pricing sanity, SKU normalization, and protect referenced products from deletion.", - handler: async (ctx) => { - function refuse(message, code, status, userMessage = message) { - const err = new Error(message); - err.code = code; - err.status = status; - err.userMessage = userMessage; - return err; - } - const { event, input, previous } = ctx; - if (event === "beforeInsert" || event === "beforeUpdate") { - const listPrice = [input.list_price, previous?.list_price].find((v) => typeof v === "number"); - const cost = [input.cost, previous?.cost].find((v) => typeof v === "number"); - if (typeof listPrice === "number" && typeof cost === "number" && listPrice < cost) { - throw refuse( - `List Price (${listPrice}) must be greater than or equal to Cost (${cost}).`, - "VALIDATION_FAILED", - 400 - ); - } - if (typeof input.sku === "string") { - input.sku = input.sku.toUpperCase(); - } - } - if (event === "beforeDelete") { - const api = ctx.api; - const id = previous?.id; - if (!api || !id) return; - const [oppRefs, quoteRefs] = await Promise.all([ - api.object("crm_opportunity_line_item").count({ where: { crm_product: id } }).catch(() => 0), - api.object("crm_quote_line_item").count({ where: { crm_product: id } }).catch(() => 0) - ]); - if (oppRefs + quoteRefs > 0) { - throw refuse( - `Cannot delete product: referenced by ${oppRefs} opportunity(ies) and ${quoteRefs} quote(s). Set is_active=false to retire instead.`, - "DELETE_RESTRICTED", - 409 - ); - } - } - } -}; -var product_hook_default = productHook; - -// src/revenue/objects/quote.hook.ts -var quoteValidation = { - name: "quote_workflow", - // ⚠️ Two objects, deliberately (#2060): the freeze below is ONE freeze — the - // quote's and its lines' — so it lives in one place, judged by one user/system - // boundary and carried by one envelope, rather than a second copy of both on - // the line. `test/package-ownership.test.ts` reads every name in the list. - object: ["crm_quote", "crm_quote_line_item"], - events: ["beforeInsert", "beforeUpdate"], - priority: 200, - description: "Default expiration date; freeze accepted/expired quotes and their lines.", - handler: async (ctx) => { - function refuse(message, code, status, userMessage = message) { - const err = new Error(message); - err.code = code; - err.status = status; - err.userMessage = userMessage; - return err; - } - const { event, input, previous } = ctx; - if (ctx.object === "crm_quote_line_item") { - const changed = Object.keys(input).some((k) => !["id", "updated_at", "updated_by", "line_number"].includes(k) && input[k] !== previous?.[k]); - for (const id of /* @__PURE__ */ new Set([input.crm_quote, previous?.crm_quote])) { - const q = changed && ctx.user?.id && typeof id === "string" && id ? await ctx.api?.object("crm_quote").findOne({ where: { id }, fields: ["quote_number", "name", "status"] }) : null; - if (q?.status === "accepted" || q?.status === "expired") { - throw refuse(`Quote ${String(q.quote_number)} - ${String(q.name)} is ${q.status}, so its line items can no longer be added or changed.`, "RECORD_LOCKED", 409); - } - } - return; - } - function subject() { - const label = [previous?.quote_number, previous?.name].map((v) => typeof v === "string" ? v.trim() : "").filter(Boolean).join(" - "); - return label ? `Quote ${label}` : "Quote"; - } - function addDays(iso, days) { - const d = new Date(iso); - d.setUTCDate(d.getUTCDate() + days); - return d.toISOString().slice(0, 10); - } - if (event === "beforeInsert" && !input.expiration_date) { - const base = typeof input.quote_date === "string" ? input.quote_date : (/* @__PURE__ */ new Date()).toISOString().slice(0, 10); - input.expiration_date = addDays(base, 30); - } - if (event === "beforeUpdate" && previous && ctx.user?.id) { - const frozen = previous.status === "accepted" || previous.status === "expired"; - if (frozen) { - const allowed = /* @__PURE__ */ new Set(["internal_notes"]); - const SYSTEM_FIELDS = /* @__PURE__ */ new Set([ - "id", - "owner_id", - "created_at", - "updated_at", - "created_by", - "updated_by", - "space_id", - "organization_id", - "org_id", - "version" - ]); - const violating = Object.keys(input).filter( - (k) => !allowed.has(k) && !SYSTEM_FIELDS.has(k) && input[k] !== previous[k] - ); - if (violating.length > 0) { - const REFERENCE_FIELDS = /* @__PURE__ */ new Set(["crm_account", "crm_contact", "crm_opportunity"]); - const isReferenceCleanup = violating.every( - (k) => REFERENCE_FIELDS.has(k) && input[k] === null && previous?.[k] != null - ); - if (isReferenceCleanup) return; - const what = `${subject()} is ${previous.status}`; - throw refuse(`${what}; only internal_notes may be edited. Attempted: ${violating.join(", ")}.`, "RECORD_LOCKED", 409); - } - } - if (input.status === "accepted" && previous.status !== "accepted") { - const dealId = [input.crm_opportunity, previous.crm_opportunity].find((v) => typeof v === "string" && v); - const deal = dealId ? await ctx.api?.object("crm_opportunity").findOne({ - where: { id: dealId }, - fields: ["stage", "approval_status", "status_change_approval_status", "qualification_approval_status"] - }).catch(() => null) : null; - const held = deal && !String(deal.stage).startsWith("closed_") ? [["approval_status", "Approval Status"], ["status_change_approval_status", "Status Change Approval"], ["qualification_approval_status", "Qualification Approval"]].filter(([f]) => deal[f] === "pending" || deal[f] === "rejected" && f !== "approval_status").map(([f, label]) => `${label} is ${deal[f] === "pending" ? "Pending" : "Rejected"}`) : []; - if (held.length > 0) { - const what = `${subject()} cannot be accepted while its opportunity is held by an approval`; - throw refuse(`${what} (${held.join("; ")}): accepting it would close that deal as won. Accept it once the approval is granted.`, "RECORD_LOCKED", 409); - } - } - } - } -}; -var quoteAcceptedContractDraft = { - name: "quote_accepted_contract_draft", - object: "crm_quote", - events: ["afterUpdate"], - priority: 800, - async: true, - onError: "log", - runAs: "system", - description: "Draft the accepted quote\u2019s contract.", - handler: async (ctx) => { - const { input, previous } = ctx; - if (input.status !== "accepted" || previous?.status === "accepted") return; - const api = ctx.api; - if (!api) return; - function addMonths(iso, months) { - const d = new Date(iso); - d.setUTCMonth(d.getUTCMonth() + months); - return d.toISOString().slice(0, 10); - } - const pickId = (...candidates) => candidates.find((c) => typeof c === "string" && c !== ""); - const accountId = pickId(input.crm_account, previous?.crm_account); - const contactId = pickId(input.crm_contact, previous?.crm_contact); - const opportunityId = pickId(input.crm_opportunity, previous?.crm_opportunity); - const ownerId = pickId(input.owner_id, previous?.owner_id, ctx.user?.id); - const totalPrice = [input.total_price, previous?.total_price].find((v) => typeof v === "number") ?? 0; - const paymentTerms = pickId(input.payment_terms, previous?.payment_terms); - const today = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10); - const DRAFT_CONTRACT_DEFAULTS = { - contract_term_months: 12, - contract_type: "subscription", - start_date: today - }; - const trimmed = (v) => typeof v === "string" ? v.trim() : ""; - const quoteLabel = [trimmed(previous?.quote_number), [input.name, previous?.name].map(trimmed).find(Boolean)].filter(Boolean).join(" - "); - const contract = { - ...DRAFT_CONTRACT_DEFAULTS, - status: "draft", - end_date: addMonths(DRAFT_CONTRACT_DEFAULTS.start_date, DRAFT_CONTRACT_DEFAULTS.contract_term_months), - contract_value: totalPrice, - description: quoteLabel ? `Auto-drafted from accepted quote ${quoteLabel}` : "Auto-drafted from an accepted quote" - }; - if (accountId) contract.crm_account = accountId; - if (contactId) contract.crm_contact = contactId; - if (opportunityId) contract.crm_opportunity = opportunityId; - if (ownerId) contract.owner_id = ownerId; - if (paymentTerms) contract.payment_terms = paymentTerms; - try { - await api.object("crm_contract").insert(contract); - } catch (err) { - throw new Error(`could not draft the contract for quote ${quoteLabel}: ${err.message}`); - } - } -}; -var quoteAccepted = { - name: "quote_on_accepted", - object: "crm_quote", - events: ["afterUpdate"], - priority: 800, - async: true, - onError: "log", - description: "Close-win the accepted quote\u2019s opportunity.", - handler: async (ctx) => { - const { input, previous } = ctx; - if (input.status !== "accepted" || previous?.status === "accepted") return; - const api = ctx.api; - const id = [input.crm_opportunity, previous?.crm_opportunity].find((v) => typeof v === "string" && v !== ""); - if (!api || !id) return; - try { - const opp = await api.object("crm_opportunity").findOne({ where: { id } }); - if (opp && !String(opp.stage).startsWith("closed_")) { - const won = { id, stage: "closed_won", close_date: (/* @__PURE__ */ new Date()).toISOString().slice(0, 10) }; - await api.object("crm_opportunity").update({ ...won, ...opp.win_reason ? {} : { win_reason: "quote_accepted" } }, { where: { id } }); - } - } catch (err) { - throw new Error(`could not close-won the opportunity of quote ${String(previous?.quote_number)}: ${err.message}`); - } - } -}; -var quote_hook_default = [quoteValidation, quoteAcceptedContractDraft, quoteAccepted]; - -// src/revenue/objects/quote_line_item.hook.ts -var quoteLineItemPriceFill = createLineItemPriceFill( - "crm_quote_line_item", - "quote_line_item_price_fill" -); -var quoteLineItemNumbering = createLineItemNumbering( - "crm_quote_line_item", - "quote_line_item_line_number" -); -var quoteTotalRollup = { - name: "quote_total_rollup", - object: "crm_quote_line_item", - events: ["afterInsert", "afterUpdate", "afterDelete"], - priority: 300, - async: true, - onError: "log", - description: "Recompute parent quote subtotal/discount/total from its line items.", - handler: async (ctx) => { - const api = ctx.api; - if (!api) return; - const { input, previous } = ctx; - const num = (v) => typeof v === "number" ? v : 0; - const quoteIds = /* @__PURE__ */ new Set(); - for (const v of [input?.crm_quote, previous?.crm_quote]) { - if (typeof v === "string" && v) quoteIds.add(v); - } - if (quoteIds.size === 0) return; - for (const quoteId of quoteIds) { - const quote = await api.object("crm_quote").findOne({ - where: { id: quoteId }, - fields: ["id", "status", "discount", "tax", "shipping_handling"] - }); - if (!quote) continue; - const status = typeof quote.status === "string" ? quote.status : void 0; - if (status === "accepted" || status === "expired") continue; - const lines = await api.object("crm_quote_line_item").find({ - where: { crm_quote: quoteId }, - fields: ["quantity", "unit_price", "discount"], - top: 5e3 - }); - if (!lines || lines.length === 0) continue; - let subtotal = 0; - for (const l of lines) subtotal += num(l.quantity) * num(l.unit_price) * (1 - num(l.discount) / 100); - subtotal = Math.round(subtotal * 100) / 100; - const discountAmount = Math.round(subtotal * (num(quote.discount) / 100) * 100) / 100; - const total = Math.round((subtotal - discountAmount + num(quote.tax) + num(quote.shipping_handling)) * 100) / 100; - await api.object("crm_quote").update( - { id: quoteId, subtotal, discount_amount: discountAmount, total_price: total }, - { where: { id: quoteId } } - ); - } - } -}; -var quote_line_item_hook_default = [quoteLineItemPriceFill, quoteLineItemNumbering, quoteTotalRollup]; - -// src/marketing/objects/campaign.hook.ts -var campaignValidation = { - name: "campaign_validation", - object: "crm_campaign", - events: ["beforeInsert", "beforeUpdate"], - priority: 200, - description: "Validate campaign date range and required fields per status.", - handler: async (ctx) => { - function refuse(message, code, status2, userMessage = message) { - const err = new Error(message); - err.code = code; - err.status = status2; - err.userMessage = userMessage; - return err; - } - const { input } = ctx; - const previous = ctx.previous; - const start = typeof input.start_date === "string" && input.start_date || typeof previous?.start_date === "string" && previous.start_date || void 0; - const end = typeof input.end_date === "string" && input.end_date || typeof previous?.end_date === "string" && previous.end_date || void 0; - if (start && end && start > end) { - throw refuse(`Campaign start_date (${start}) must not be after end_date (${end}).`, "VALIDATION_FAILED", 400); - } - const status = typeof input.status === "string" && input.status || typeof previous?.status === "string" && previous.status || void 0; - if (status === "in_progress" && (!start || !end)) { - throw refuse("Campaign cannot move to in_progress without both start_date and end_date.", "VALIDATION_FAILED", 400); - } - } -}; -var campaignMetricsRefresh = { - name: "campaign_metrics_refresh", - object: "crm_campaign", - events: ["afterUpdate"], - priority: 800, - async: true, - onError: "log", - description: "Recompute the campaign metric block whenever the campaign status moves.", - handler: async (ctx) => { - const { input } = ctx; - const previous = ctx.previous; - if (typeof input.status !== "string") return; - if (previous && input.status === previous.status) return; - const api = ctx.api; - if (!api) return; - const campaignId = typeof input.id === "string" && input.id || (typeof previous?.id === "string" ? previous.id : ""); - if (!campaignId) return; - for (const id of [campaignId]) { - const memberRows = await api.object("crm_campaign_member").find({ - where: { crm_campaign: id }, - fields: ["crm_lead", "status"], - top: 5e3 - }); - const leadIds = Array.from(new Set( - memberRows.map((r) => typeof r.crm_lead === "string" ? r.crm_lead : "").filter(Boolean) - )); - const convertedLeads = leadIds.length > 0 ? await api.object("crm_lead").count({ where: { id: { $in: leadIds }, is_converted: true } }) : 0; - const numOpportunities = await api.object("crm_opportunity").count({ where: { crm_campaign: id } }); - const numWon = await api.object("crm_opportunity").count({ where: { crm_campaign: id, stage: "closed_won" } }); - const wonRows = await api.object("crm_opportunity").find({ - where: { crm_campaign: id, stage: "closed_won" }, - fields: ["amount"], - top: 5e3 - }); - const actualRevenue = wonRows.reduce( - (sum, row) => sum + (typeof row.amount === "number" ? row.amount : Number(row.amount) || 0), - 0 - ); - await api.object("crm_campaign").update({ - id, - num_sent: memberRows.length, - num_responses: memberRows.filter((r) => r.status === "responded" || r.status === "converted").length, - num_leads: leadIds.length, - num_converted_leads: convertedLeads, - num_opportunities: numOpportunities, - num_won_opportunities: numWon, - actual_revenue: actualRevenue - }, { where: { id } }); - } - } -}; -var CAMPAIGN_METRIC_FIELDS = [ - "num_sent", - "num_responses", - "num_leads", - "num_converted_leads", - "num_opportunities", - "num_won_opportunities", - "actual_revenue" -]; -var CAMPAIGN_METRIC_WRITE_KEYS = ["id", ...CAMPAIGN_METRIC_FIELDS]; -var campaign_hook_default = [campaignValidation, campaignMetricsRefresh]; - -// src/marketing/objects/campaign_member.hook.ts -var campaignMemberLifecycle = { - name: "campaign_member_lifecycle", - object: "crm_campaign_member", - events: ["beforeInsert", "beforeUpdate"], - priority: 200, - description: "Keep has_responded / response_date in lockstep with the member status.", - handler: async (ctx) => { - if (ctx.event === "beforeUpdate" && ctx.dispatch?.mode === "per-row") return; - const { input } = ctx; - const previous = ctx.previous; - const status = typeof input.status === "string" && input.status || (typeof previous?.status === "string" ? previous.status : void 0); - if (!status) return; - const responded = status === "responded" || status === "converted"; - const priorStatus = typeof previous?.status === "string" ? previous.status : ""; - const wasResponded = priorStatus === "responded" || priorStatus === "converted"; - if (responded) { - input.has_responded = true; - const existing = input.response_date ?? previous?.response_date; - if (!wasResponded && (existing === void 0 || existing === null || existing === "")) { - input.response_date = (/* @__PURE__ */ new Date()).toISOString(); - } - return; - } - if (wasResponded && typeof input.status === "string") { - input.has_responded = false; - input.response_date = null; - return; - } - if (ctx.event === "beforeInsert" && input.has_responded === void 0) { - input.has_responded = false; - } - } -}; -var campaignMemberOptOutSync = { - name: "campaign_member_optout_sync", - object: "crm_campaign_member", - events: ["afterInsert", "afterUpdate"], - priority: 300, - async: true, - onError: "log", - runAs: "system", - description: "Sync an unsubscribed member back to the lead/contact email_opt_out flag.", - handler: async (ctx) => { - const api = ctx.api; - if (!api) return; - const { input } = ctx; - const previous = ctx.previous; - if (input?.status !== "unsubscribed") return; - if (previous?.status === "unsubscribed") return; - const leadId = typeof input?.crm_lead === "string" && input.crm_lead || (typeof previous?.crm_lead === "string" ? previous.crm_lead : void 0); - const contactId = typeof input?.crm_contact === "string" && input.crm_contact || (typeof previous?.crm_contact === "string" ? previous.crm_contact : void 0); - if (leadId) { - await api.object("crm_lead").update( - { id: leadId, email_opt_out: true }, - { where: { id: leadId } } - ); - } - if (contactId) { - await api.object("crm_contact").update( - { id: contactId, email_opt_out: true }, - { where: { id: contactId } } - ); - } - } -}; -var campaignMemberMetricsRefresh = { - name: "campaign_member_metrics_refresh", - object: "crm_campaign_member", - events: ["afterInsert", "afterUpdate", "afterDelete"], - priority: 800, - async: true, - onError: "log", - runAs: "system", - description: "Recompute the campaign metric block live whenever its membership changes.", - handler: async (ctx) => { - const api = ctx.api; - if (!api) return; - const { input } = ctx; - const previous = ctx.previous; - const campaignIds = Array.from(new Set([ - typeof input?.crm_campaign === "string" ? input.crm_campaign : "", - typeof previous?.crm_campaign === "string" ? previous.crm_campaign : "" - ].filter(Boolean))); - for (const id of campaignIds) { - const memberRows = await api.object("crm_campaign_member").find({ - where: { crm_campaign: id }, - fields: ["crm_lead", "status"], - top: 5e3 - }); - const leadIds = Array.from(new Set( - memberRows.map((r) => typeof r.crm_lead === "string" ? r.crm_lead : "").filter(Boolean) - )); - const convertedLeads = leadIds.length > 0 ? await api.object("crm_lead").count({ where: { id: { $in: leadIds }, is_converted: true } }) : 0; - const numOpportunities = await api.object("crm_opportunity").count({ where: { crm_campaign: id } }); - const numWon = await api.object("crm_opportunity").count({ where: { crm_campaign: id, stage: "closed_won" } }); - const wonRows = await api.object("crm_opportunity").find({ - where: { crm_campaign: id, stage: "closed_won" }, - fields: ["amount"], - top: 5e3 - }); - const actualRevenue = wonRows.reduce( - (sum, row) => sum + (typeof row.amount === "number" ? row.amount : Number(row.amount) || 0), - 0 - ); - await api.object("crm_campaign").update({ - id, - num_sent: memberRows.length, - num_responses: memberRows.filter((r) => r.status === "responded" || r.status === "converted").length, - num_leads: leadIds.length, - num_converted_leads: convertedLeads, - num_opportunities: numOpportunities, - num_won_opportunities: numWon, - actual_revenue: actualRevenue - }, { where: { id } }); - } - } -}; -var campaign_member_hook_default = [ - campaignMemberLifecycle, - campaignMemberOptOutSync, - campaignMemberMetricsRefresh -]; - -// src/sales/flows/lead-conversion.flow.ts -import { P as P26, cel as cel6 } from "@objectstack/spec"; -var LeadConversionFlow = { - name: "lead_conversion", - label: "Lead Conversion Process", - description: "Automated flow to convert qualified leads to accounts, contacts, and opportunities", - type: "screen", - status: "active", - variables: [ - // Named `recordId` to match the console's flow-action invocation contract: - // POST /automation/:name/trigger sends { recordId, objectName } and the - // dispatcher exposes them as params.recordId / params.crmLeadId. A custom - // name like `leadId` never gets seeded (16.x runtime). - { name: "recordId", type: "text", isInput: true, isOutput: false }, - // THE authority for the conversion default. `defaultValue` is what makes - // declared mean BOUND: the engine seeds every declared variable that - // carries one before the run starts, so `createOpportunity` is bound on - // every path — including the one where the screen runner posts back only - // the fields the user touched. The screen field below derives its prefill - // from this line rather than restating `false`. - // - // Measured on 17.0.0 GA, by running flows (not by reading the engine): - // · declared + nothing supplied → bound to `false`; ablating this key - // from the declaration re-fails the read with `No such key: - // createOpportunity`, so the default is what binds it; - // · seeded BEFORE the start condition is evaluated, so a start condition - // could read it too; - // · a caller-supplied `context.params.createOpportunity` WINS — the - // boundary is `!== undefined`, so an explicit `false`/`null` is a - // supplied answer, and only absence falls through to this default. - // ⛔ Never seed this with an assignment node instead: an assignment is - // unconditional and clobbers a caller-supplied value. All of the above is - // pinned in `test/flow-variable-conditions.test.ts`. - { name: "createOpportunity", type: "boolean", isInput: true, isOutput: false, defaultValue: false }, - { name: "opportunityName", type: "text", isInput: true, isOutput: false }, - { name: "opportunityAmount", type: "text", isInput: true, isOutput: false }, - // The conversion's close date, collected on the screen below - // instead of stamped inside `create_opportunity`. Declared with NO - // `defaultValue`, and that is measured rather than chosen: the engine - // binds a DECLARATION's default raw — `seedDeclaredVariables` does a plain - // `variables.set(name, defaultValue)` with no `interpolate` call — so - // `{TODAY() + 90}` written here would bind that string verbatim and - // `create_opportunity` would post the braces into a date column. Measured - // on 17.3.0 by running a probe flow, not by reading the engine. The screen - // field is therefore the only layer that can carry the expression, which - // is where the +90 lives and why this line is deliberately bare. - { name: "closeDate", type: "date", isInput: true, isOutput: false } - ], - nodes: [ - { id: "start", type: "start", label: "Start", config: { objectName: "crm_lead" } }, - { - id: "screen_1", - type: "screen", - label: "Conversion Details", - config: { - // The suspected-duplicate warning. `lead_duplicate_check` flags a - // re-captured email at intake and links the record the lead repeats; - // the rep about to CONVERT is the last moment that flag is worth - // anything, and without it the duplicate becomes a second account, - // contact and opportunity. - // - // ⛔ Not on `convert_lead`'s `confirmText`: that string is static and - // unconditional, so it would warn identically on every clean lead — the - // cry-wolf that makes a confirm dialog furniture. This screen is where - // the conversion decision is actually taken, and the one surface that - // can say something TRUE about THIS lead. - // - // Mechanism: the executor renders `config.description` — a text slot, - // written as a `{{ }}` hole since 18.0.0-next.0 — into the `ScreenSpec` - // it puts on the wire, and `FlowRunner.tsx` renders it — - // `{screen.description && …}`. A hole over `null` - // renders the empty string, which the executor's `renderTextSlot` - // turns into no description at all (read in the installed - // 18.0.0-next.0 `service-automation`; on the 17.1.0 bundles it was - // measured as `interp` mapping null to `undefined`), so the clean-lead - // branch below (which assigns `null`) renders NO description rather - // than an empty paragraph. That is why the conditionality lives in an - // assignment and not in the copy: a screen `description` has no - // `visibleWhen`. - description: "{{duplicateWarning}}", - // `visibleWhen` on a screen field is BARE CEL over the screen's own - // field names — not the CEL value envelopes the rest of this flow uses - // for filters and `update_record` fields, evaluated on the server. The - // client re-evaluates the predicate against the values collected so far, - // which is why it cannot be a server-evaluated envelope. - fields: [ - // ⛔ NEVER `required` on a boolean screen field. A checkbox has no - // unanswered state — clear IS an answer, and "convert this lead - // WITHOUT an opportunity" is the commonest path. `required: true` - // blocks on both sides of the wire: the client counts the untouched - // box as an unanswered field and disables Submit, and from - // 17.0.0-rc.2 the SERVER enforces the screen's declared contract too, - // refusing the resume with `INVALID_SCREEN_INPUT: Screen field - // "createOpportunity" is required` — so a runner that posts only what - // the user touched cannot convert a lead at all. The variable's - // declared `defaultValue` is what supplies the answer. - // - // DERIVED, not restated. The envelope reads the flow variable - // `createOpportunity`, so the literal `false` is written exactly once in this - // file — on the declaration — and the widget prefill cannot drift from - // the value the engine binds. - // - // A screen field's `defaultValue` is a CEL value envelope evaluated - // before the descriptor goes on the wire, so the client receives the - // value, never the envelope: boolean `false`, which is what the - // 17.0.0 GA template was measured to send. (`visibleWhen` below is the - // opposite case: forwarded raw, never evaluated on the server. Same - // node, two different dialects.) - { name: "createOpportunity", label: "Create Opportunity?", type: "boolean", defaultValue: cel6`createOpportunity` }, - // PREFILLED FROM THE LEAD (REQ-0005 acceptance 2). Both defaults are - // CEL envelopes over `leadRecord`, which `get_lead` bound before this - // screen was reached — the fetch sits AHEAD of the screen for the - // duplicate warning, and these two ride the same ordering. - // - // ⚠️ Each envelope is evaluated before the descriptor goes on the - // wire, so `estimated_amount` arrives as a NUMBER. `company` is - // required on a lead; `estimated_amount` is not, so its read is - // guarded: a lead with no estimate is served `null` where 17.x served - // nothing (the migration entry: a field's `defaultValue` seeds the - // field with null), and an ABSENT column on a sparse datasource no - // longer fails the run at this screen. - // - // ⛔ The amount is prefilled, never copied silently. `estimated_amount` - // is a pre-qualification guess and `crm_opportunity.amount` is a - // number a rep defends in a forecast; conversion is the moment a human - // turns one into the other, so the figure is shown in an editable box - // and the rep confirms it. Writing it straight into - // `create_opportunity` would put an unreviewed estimate into the - // forecast and leave the two fields looking like copies of each other. - // - // `required` on the amount mirrors the column, for the reason given - // at `closeDate` below: `crm_opportunity.amount` is `required` + - // `notNull`, and without this a ticked box with no amount reached - // `create_opportunity` after the account and contact were written, - // leaving the lead half-converted (#2060 item 2). Visible-only, so - // an unticked box still converts with no amount. - { name: "opportunityName", label: "Opportunity Name", type: "text", required: true, defaultValue: cel6`leadRecord.company`, visibleWhen: "createOpportunity == true" }, - { name: "opportunityAmount", label: "Opportunity Amount", type: "currency", required: true, defaultValue: cel6`has(leadRecord.estimated_amount) ? leadRecord.estimated_amount : null`, visibleWhen: "createOpportunity == true" }, - // The close date, DEFAULTED AND VISIBLE. `close_date` is what files - // an opportunity into a forecast PERIOD, so ⛔ never stamp it silently - // inside `create_opportunity`: a hidden +90 days files every converted - // deal a quarter out and moves the forecast where nobody can see it. - // - // The +90 is written HERE and nowhere else, and here the layer is - // FORCED rather than preferred. A screen field's `defaultValue` is - // evaluated before the descriptor goes on the wire and a flow - // variable's default is bound raw (see the declaration above), so this - // is the only place the expression can be written at all. - // `isoDate(daysFromNow(90))` writes the `YYYY-MM-DD` string 90 days out - // on the UTC calendar — what 17.3.0's `{TODAY() + 90}` was measured to - // send — and the value the rep sees is the value - // `create_opportunity` writes. - // - // `required` mirrors the column — `crm_opportunity.close_date` is - // `required` + `notNull` — and it is what keeps the refusal at the - // SCREEN boundary. Measured both ways against a real ObjectQL engine: - // WITHOUT it, a submission carrying no date reaches - // `create_opportunity` and fails there with `Close Date is required`, - // by which point the account and the contact have already been - // written and the lead is left half-converted; WITH it the resume is - // refused before any node runs, nothing is written, and the message - // names the field. That path is not hypothetical — a rep who CLEARS - // the prefilled date posts the key empty, and `isPresent('')` is - // false. A hidden `required` never fires: the server contract skips it - // when `visibleWhen` evaluates false, and so does the console, which - // is the untouched-checkbox path this screen has always had to keep - // working. - { name: "closeDate", label: "Close Date", type: "date", required: true, defaultValue: cel6`isoDate(daysFromNow(90))`, visibleWhen: "createOpportunity == true" } - ] - } - }, - { - // ⛔ This fetch must stay AHEAD of the screen: the duplicate warning - // reads `leadRecord`, and a screen that suspends before the fetch has - // nothing to read. The fetch itself never depended on the screen — - // `recordId` is an input variable, seeded before the run starts. - id: "get_lead", - type: "get_record", - label: "Get Lead Record", - config: { objectName: "crm_lead", filter: { id: cel6`recordId` }, outputVariable: "leadRecord" } - }, - { - // Branching is on edges `e21` / `e22` / `e25` — see `decision_account`. - // Three ways out, because `duplicate_status` carries two different KINDS - // of fact and they get different answers: the machine's `suspected` guess - // warns and lets the rep decide (`e21`), a person's `confirmed` verdict - // refuses outright (`e25`), and everything else converts silently (`e22`). - id: "decision_duplicate", - type: "decision", - label: "Duplicate Verdict?" - }, - { - // The warning names the record the way the UI names a person — by the - // email address the two records share — and NOT by - // `duplicate_of_lead` / `duplicate_of_contact`, which hold ids. That is - // the house rule `test/record-id-not-in-prose.test.ts` states for every - // sentence a user reads: "the id goes in the relationship field that - // exists to carry it, or nowhere". The link itself is on the lead's - // record page (`lead_detail.page.ts`), where it can be clicked. - // - // "flagged at intake" is the app's own published definition of this - // value, not a guess about provenance: `duplicate_status`'s help text - // reads "Suspected = flagged automatically at intake" in all four - // locales, and `lead_duplicate_check` is insert-only by design. - // - // This warning's TEXT is English-only: it is the value of a variable, - // and no locale pack reaches a variable — the screen's translated - // `description` can only carry the `{{duplicateWarning}}` hole that - // shows it. The screens' own headings and bodies are keyed in the packs - // (`flows.lead_conversion` in `src/sales/translations//app.ts`), - // and the banner on the record page carries the warning in all four. - id: "warn_duplicate", - type: "assignment", - label: "Compose Duplicate Warning", - config: { - assignments: { - duplicateWarning: cel6`'Suspected duplicate — intake flagged this lead as repeating an existing record with this email address (' + leadRecord.email + '). Converting creates a second account, contact and opportunity for the same buyer; compare the linked record on the lead page before you continue.'` - } - } - }, - { - // The other branch assigns `null`, which is what makes the warning - // CONDITIONAL: the description hole renders it as no description at - // all (see `screen_1`). Same shape as `no_opportunity` below — both branches - // write the variable so no downstream read ever meets an unset one. - id: "no_duplicate_warning", - type: "assignment", - label: "No Duplicate Warning", - config: { assignments: { duplicateWarning: null } } - }, - { - // The REFUSAL. A `confirmed` duplicate is a person's verdict, and the app - // stops converting on it — the rule AGENTS.md states as "interception - // stands on a person's judgement". `suspected` keeps the warn-and-allow - // above: a machine's guess stays advisory, because `lead_duplicate_check` - // matches on email EQUALITY and a shared inbox (`info@`, a switchboard - // address) false-positives by construction. ⛔ Do not block on the guess — - // it would need an override flag to stay usable, and an override flag is - // the one shape this exhibit must not demonstrate. - // - // ## Why the refusal is HERE and not on `convert_lead`'s predicate - // - // A refusal must NAME the verdict and the surviving record, and measured - // against `@objectstack/spec` 17.2.0 the action predicates cannot: - // `visible` and `disabled` are each a bare boolean/CEL envelope with - // nowhere to put a sentence, so `visible` hides a button that cannot then - // explain itself and `disabled` greys one out with no reason attached. - // `errorMessage` on the Action is a single static string — what the - // console toasts on a FAILED run — and cannot say anything about THIS - // lead. A screen node's `description` is a text slot rendered per run - // and shown by `FlowRunner` as the dialog body. - // - // The flow is also the only choke point covering every door: the - // record-header button, the list-row button and the `action_convert_lead` - // AI tool all dispatch `POST /automation/lead_conversion/trigger`, while - // `visible` / `disabled` are console-side and say nothing to the other - // two. - // - // ## What the rep sees, measured on the shipped console bundle - // - // A run that PAUSES returns `{ success: true, silent: true }` to the - // action framework (`RecordDetailView`'s flow handler), and `silent` - // suppresses the success toast — so `convert_lead`'s - // `successMessage: 'Lead converted successfully!'` does NOT fire behind - // this dialog. Submitting it resumes into `end`; nothing is created and - // the lead is untouched on either path, because every write in this flow - // is downstream of `screen_1`. - // - // ## What the copy may claim - // - // ⛔ NOT the shared email address, which is what `warn_duplicate` above - // uses. That claim is safe for `suspected` because only - // `lead_duplicate_check` writes it and it matches on email; `confirmed` - // is written by a PERSON, and the lead form lets a reviewer point - // `duplicate_of_type` + its lookup at any record they like. So the - // refusal names the survivor through the relationship fields that exist - // to carry it (`test/record-id-not-in-prose.test.ts`: "the id goes in the - // relationship field that exists to carry it, or nowhere"), naming the - // `duplicates` field group by its shipped label, "Duplicate Management". - // That sentence also stays true on the `erased` tombstone, where the - // verdict survives its pointer (`lead.hook.ts`, job 1c). - // - // ⛔ Never transcribe the vocabulary of `duplicate_of_type` into this - // sentence ("an existing Lead" / "an existing Contact"). Those labels are - // locale-pack facts with one source of truth, the rep can see them on the - // section this line points at, and a hand-copied machine list in prose is - // the drift AGENTS.md documentation rule 5 forbids. - // - // The title and the body are translated in the packs - // (`flows.lead_conversion.screens.refuse_confirmed_duplicate`). - id: "refuse_confirmed_duplicate", - type: "screen", - label: "Conversion Refused", - config: { - title: "Conversion refused", - description: "This lead's Duplicate Status is Confirmed: a reviewer compared it against an existing record and recorded that it repeats one. Converting would create a second account, contact and opportunity for the same buyer. The Duplicate Management section on this lead names the surviving record; disqualify this lead as a duplicate instead. Only a reviewer revising that verdict reopens conversion.", - // A message-only screen: no fields, so the pause has to be asked for. - // `waitForInput` is what turns a field-less screen from a server-side - // pass-through into the dialog the rep reads (the executor's - // `shouldPause`), and without it this node would fall through to `end` - // in silence — a refusal nobody is told about. - waitForInput: true - } - }, - { - // Branching is on edges `e28` / `e29` — see `decision_account`. - id: "decision_approval", - type: "decision", - label: "Approved for Conversion?" - }, - { - // The approval gate, on the surface a REST caller reaches (REQ-0005 - // acceptance 3). `convert_lead`'s `visible` predicate hides the button and - // `lead.hook.ts` refuses the write, but this flow has its own door — - // `POST /automation/lead_conversion/trigger` — and without this branch a - // caller through that door would run the whole conversion and only be - // refused at `mark_converted`, by which point the account, the contact and - // the opportunity have already been written and the lead is left - // half-converted. Refusing HERE, ahead of `screen_1`, is what makes the - // gate whole: every create and update in this flow sits behind that - // screen, and this path never reaches it. - id: "refuse_unapproved", - type: "screen", - label: "Conversion Refused", - config: { - title: "Conversion refused", - description: "This lead has not been approved for conversion. An approver has to sign it off before it can become an account, contact and opportunity; the Conversion Approval field on the lead shows whether the decision is still pending or was refused. Keep working the lead in the meantime \u2014 nothing about it is frozen.", - // Field-less screen: `waitForInput` is what turns it from a server-side - // pass-through into the dialog the rep reads. See - // `refuse_confirmed_duplicate` for the mechanism. - waitForInput: true - } - }, - { - // Branching is on edges `e31` / `e32` — see `decision_account`. The - // match-key guard sits between the duplicate verdict and `screen_1`, so - // it dominates `find_account` and a key-less lead is refused before the - // rep fills in the form and before any write. It is the LAST of the - // three refusals on purpose: an unapproved lead or a confirmed duplicate - // is told that verdict first, and a missing key is a repairable data - // gap rather than a verdict. - id: "decision_match_key", - type: "decision", - label: "Company Match Key?" - }, - { - // The KEY-LESS refusal (#2017). Why `find_account` must not run without - // a key is recorded on that node; this is what the rep reads instead. - // - // A refusal, not a new account, and that is the flow's own stated intent - // rather than a fresh choice: a conversion that stops is far cheaper to - // diagnose than one that quietly attaches to the wrong account or - // creates a duplicate one, and `screen_1` offers the rep no account - // choice that could confirm a match by hand. - // - // The copy claims only what holds on every path into it: the key is - // derived from `company` on every write that carries it - // (`lead_duplicate_check`), and nothing has been written, because every - // create and update in this flow sits behind `screen_1`. Its title and - // body are translated in the packs, like the other two refusals. - // - // Field-less screen: `waitForInput` is what turns it from a server-side - // pass-through into the dialog the rep reads. See - // `refuse_confirmed_duplicate` for the mechanism. - id: "refuse_no_match_key", - type: "screen", - label: "Conversion Refused", - config: { - title: "Conversion refused", - description: "This lead's company has no match key, so conversion cannot tell which account it belongs to, and it will not guess: a guess could file the contact and opportunity under another customer. Saving the lead's Company rebuilds the key, so save it again, then convert. Nothing has been created.", - waitForInput: true - } - }, - { - // Account dedupe: match on the NORMALIZED company name, never on the raw - // one — "Acme Corp" and "ACME Corp" are the same account. - // - // Both sides of this comparison are stored, hook-maintained columns, and - // on 17.x that was forced rather than chosen: a flow template could not - // normalize ANYTHING. `service-automation`'s `resolveToken` recognises exactly one - // function form — `NOW()` / `TODAY()` — and every bare identifier in the - // expression fallback is substituted before evaluation, so no string - // method is reachable either: `{LOWER(x)}`, `{TRIM(x)}` and - // `{x.toLowerCase()}` all resolve to `undefined`, and an unwrapped - // `LOWER({x})` interpolates literally to "LOWER(Acme Corp)". A formula - // field is no help either — it has no physical column to filter on. So - // the producer canonicalizes (`account_protection`, - // `lead_duplicate_check`) and this node does a plain, indexed equality - // match. `test/account-name-normalized-match.test.ts` re-measures all of - // that rather than trusting this paragraph. - // - // Normalize-then-EXACT only: lower + trim + collapse internal - // whitespace. Fuzzy matching stays out of scope. - // - // A lead with NO `company_normalized` never reaches this node: - // `decision_match_key`, ahead of `screen_1`, refuses it first. The node - // cannot be left to refuse on its own, because "no key" arrives in two - // shapes that behave differently (both measured on 17.7.0): - // - // · ABSENT — a sparse datasource (`driver-memory` / `driver-mongodb`) - // on a row never written with the column. The token resolves to - // nothing and `get_record` refuses to run, so the run FAILS - // (`FLOW_FAILED`, "refusing to run — 1 filter condition(s) resolved - // to nothing and were dropped from the query …"). - // · NULL — SQL, or any datasource once the column is written empty, - // which `lead_duplicate_check` does on purpose for a company that - // folds to nothing. The token resolves to `null`, and a bare `null` - // in a filter is the platform's documented HAS-NO-VALUE predicate - // (`$eq: null`, `@objectstack/spec` `data/filter.zod.ts`). This - // lookup then MATCHES every account whose own key is null, and the - // lead converts onto an unrelated customer's account (#2017). - // - // A key-less lead is not only a row written before the producer existed - // (the backfill in docs/MAINTENANCE.md §3.3): a non-string company - // written through the record API folds to `null` too. A conversion that - // stops is far cheaper to diagnose than one that quietly attaches to the - // wrong account or creates a duplicate one, so the answer is the - // refusal the rep reads in `refuse_no_match_key`. - // - // Since 18.0.0-next.0 the operand is a CEL envelope: an absent key fails - // the run before the query, and a null one refuses the node instead of - // matching (the platform's `flow-value-slot-template-dialect-refused` - // entry; not re-measured here). Neither shape converts onto another - // account any more, and `decision_match_key` still refuses first, with - // copy the rep can read. - // - // ⛔ Never paper this over with a second, case-sensitive lookup on the - // raw `name`: a missing key means the producer could not derive one, and - // a tolerant consumer path would hide that while restoring the exact bug - // this node exists to fix. - id: "find_account", - type: "get_record", - label: "Find Existing Account", - config: { objectName: "crm_account", filter: { name_normalized: cel6`leadRecord.company_normalized` }, outputVariable: "matchedAccount" } - }, - { - // Branching is on edges `e5` / `e6`. No `config.condition` here: a - // `decision` node's singular one is never evaluated. - id: "decision_account", - type: "decision", - label: "Account Already Exists?" - }, - { - // NEW-account branch. outputVariable is `createdAccount`; the assignment - // below normalizes both branches onto a single `accountId` id string so - // downstream nodes don't need to know which path ran. - // - // `name` carries the lead's company VERBATIM — the display value. The - // match key `name_normalized` is deliberately absent: it is readonly and - // hook-owned, and `account_protection` derives it from the `name` written - // here, so an account created by this node is immediately findable by the - // next conversion. - id: "create_account", - type: "create_record", - label: "Create Account", - config: { - objectName: "crm_account", - fields: { - // `company` is required on a lead; every other copied fact is - // optional, so its read is guarded to null (an insert treats null as - // it treated the key the template left out). - name: cel6`leadRecord.company`, - phone: cel6`has(leadRecord.phone) ? leadRecord.phone : null`, - website: cel6`has(leadRecord.website) ? leadRecord.website : null`, - industry: cel6`has(leadRecord.industry) ? leadRecord.industry : null`, - annual_revenue: cel6`has(leadRecord.annual_revenue) ? leadRecord.annual_revenue : null`, - number_of_employees: cel6`has(leadRecord.number_of_employees) ? leadRecord.number_of_employees : null`, - billing_address: cel6`has(leadRecord.address) ? leadRecord.address : null`, - owner_id: cel6`current_user.id`, - is_active: true - }, - outputVariable: "createdAccount" - } - }, - { - id: "use_new_account", - type: "assignment", - label: "Use New Account", - config: { assignments: { accountId: cel6`createdAccount.id` } } - }, - { - id: "use_existing_account", - type: "assignment", - label: "Reuse Existing Account", - config: { assignments: { accountId: cel6`matchedAccount.id` } } - }, - { - // Contact dedupe by email — GLOBAL, not per-account. ⛔ Never scope this - // lookup to the account: `crm_contact` carries a global unique index on - // `email`, so an account-scoped lookup misses a same-email contact under - // another account and `create_contact` then explodes on the DB index - // AFTER the account has been created, orphaning it. Leads require an - // email, so the match key is reliable. - id: "find_contact", - type: "get_record", - label: "Find Existing Contact", - config: { - objectName: "crm_contact", - filter: { email: cel6`leadRecord.email` }, - outputVariable: "matchedContact" - } - }, - { - // Branching is on edges `e11` / `e12` — see `decision_account`. - id: "decision_contact", - type: "decision", - label: "Contact Already Exists?" - }, - { - // `accountId` is a bare id string from whichever account branch ran. - id: "create_contact", - type: "create_record", - label: "Create Contact", - config: { - objectName: "crm_contact", - fields: { - // The person's own facts travel with them (#2068). `crm_contact` - // declares each of these on the lead's vocabulary (`_picklists.ts` - // for the two selects, pinned by `test/actions-flows-integrity`), so - // a straight copy is always legal. The two opt-outs are copied, - // never defaulted: a lead that opted out must not become a contact - // that has not — `email_opt_out` hides Send Email and silences - // `contact_welcome`, `do_not_call` refuses a scheduled call. A - // REUSED contact does not come through here: see - // `decision_contact_do_not_call`. - // - // Names and email are required on a lead and read bare; the rest - // are optional and guarded to null, which an insert reads as the - // omitted key the template wrote (each opt-out then takes its - // `false` default, as before). - salutation: cel6`has(leadRecord.salutation) ? leadRecord.salutation : null`, - mobile: cel6`has(leadRecord.mobile) ? leadRecord.mobile : null`, - lead_source: cel6`has(leadRecord.lead_source) ? leadRecord.lead_source : null`, - do_not_call: cel6`has(leadRecord.do_not_call) ? leadRecord.do_not_call : null`, - email_opt_out: cel6`has(leadRecord.email_opt_out) ? leadRecord.email_opt_out : null`, - first_name: cel6`leadRecord.first_name`, - last_name: cel6`leadRecord.last_name`, - email: cel6`leadRecord.email`, - phone: cel6`has(leadRecord.phone) ? leadRecord.phone : null`, - title: cel6`has(leadRecord.title) ? leadRecord.title : null`, - crm_account: cel6`accountId`, - is_primary: true, - owner_id: cel6`current_user.id` - }, - outputVariable: "createdContact" - } - }, - { - id: "use_new_contact", - type: "assignment", - label: "Use New Contact", - config: { assignments: { contactId: cel6`createdContact.id` } } - }, - { - id: "use_existing_contact", - type: "assignment", - label: "Reuse Existing Contact", - config: { assignments: { contactId: cel6`matchedContact.id` } } - }, - { - // ── A REUSED contact keeps the stricter consent (#2068) ────────────── - // - // `create_contact` copies the lead's opt-outs onto a NEW contact. A - // reused contact already holds its own answer, and an opt-out is a - // promise to a person that a conversion never takes back — so this path - // only ever RAISES a flag, one node per flag, and only when the lead - // carries it. The `raise_*` nodes write the literal `true`, ⛔ never a - // copy of `leadRecord.x`: a copy would write the lead's `false` over a contact - // who had opted out. `crm_account` carries neither flag, so the account - // half of "the stricter value wins" has nothing to write. - // - // The edges read the LEAD's flag only, not whether the contact already - // holds it. Reading `vars.matchedContact.x` needs a - // `has(vars.matchedContact)` guard, which - // `test/flow-variable-conditions.test.ts` forbids on this flow (a - // `get_record` binds it on every path) — and writing `true` over `true` - // changes nothing. - // - // Branching on `e35` / `e36`, then `e38` / `e39`: each pair is TOTAL and - // partitions by De Morgan, so exactly one edge holds on every shape - // `get_lead` can bind — pinned in `test/flow-conversion.test.ts`. - id: "decision_contact_do_not_call", - type: "decision", - label: "Lead Is Do-Not-Call?" - }, - { - id: "raise_contact_do_not_call", - type: "update_record", - label: "Carry Do-Not-Call to Contact", - config: { objectName: "crm_contact", filter: { id: cel6`contactId` }, fields: { do_not_call: true } } - }, - { - id: "decision_contact_email_opt_out", - type: "decision", - label: "Lead Opted Out of Email?" - }, - { - id: "raise_contact_email_opt_out", - type: "update_record", - label: "Carry Email Opt-Out to Contact", - config: { objectName: "crm_contact", filter: { id: cel6`contactId` }, fields: { email_opt_out: true } } - }, - { - // Branching is on edges `e16` / `e17` — see `decision_account`. - id: "decision_opportunity", - type: "decision", - label: "Create Opportunity?" - }, - { - // `close_date` comes from the screen field, which is the only layer that - // can carry the `isoDate(daysFromNow(90))` expression — see the - // `closeDate` declaration. An unbound `closeDate` fails the run at this - // node rather than inventing a quarter, which is the failure this node - // is allowed to have. - id: "create_opportunity", - type: "create_record", - label: "Create Opportunity", - config: { - objectName: "crm_opportunity", - fields: { - name: cel6`opportunityName`, - crm_account: cel6`accountId`, - primary_contact: cel6`contactId`, - amount: cel6`opportunityAmount`, - stage: "prospecting", - probability: 10, - lead_source: cel6`has(leadRecord.lead_source) ? leadRecord.lead_source : null`, - close_date: cel6`closeDate`, - owner_id: cel6`current_user.id` - }, - outputVariable: "createdOpportunity" - } - }, - { - // Normalize both opportunity branches onto a single `opportunityId`, the - // same pattern as accountId/contactId. ⛔ Never reference - // `createdOpportunity.id` downstream instead: on the "No" branch the - // create node never ran, and the unbound read fails the run (on 17.x the - // unresolved token interpolated into the `converted_opportunity` lookup - // as a placeholder). - id: "use_new_opportunity", - type: "assignment", - label: "Use New Opportunity", - config: { assignments: { opportunityId: cel6`createdOpportunity.id` } } - }, - { - id: "no_opportunity", - type: "assignment", - label: "No Opportunity", - config: { assignments: { opportunityId: null } } - }, - { - id: "mark_converted", - type: "update_record", - label: "Mark Lead as Converted", - config: { - objectName: "crm_lead", - filter: { id: cel6`recordId` }, - fields: { - // `status: 'converted'` rides along so list views agree with the - // conversion flags (the qualified → converted transition is legal - // per the lead_status_progression state machine). - is_converted: true, - status: "converted", - converted_date: cel6`isoDatetime(now())`, - converted_account: cel6`accountId`, - converted_contact: cel6`contactId`, - converted_opportunity: cel6`opportunityId` - } - } - }, - { - // ADR-0012: deliver via the `notify` node (inbox + email). The legacy - // `script` + `actionType:'email'` shape is a no-op stub in 7.4. - id: "send_notification", - type: "notify", - label: "Send Confirmation", - config: { - recipients: [cel6`current_user.id`], - channels: ["inbox", "email"], - topic: "lead_converted", - template: "crm.lead_converted", - templateData: { first_name: cel6`leadRecord.first_name`, last_name: cel6`leadRecord.last_name` }, - actionUrl: "/crm_account/{{accountId}}" - } - }, - { id: "end", type: "end", label: "End" } - ], - edges: [ - // ⛔ A retired edge's id stays VACANT and every surviving edge keeps the id - // it has always had — `e1`, `e3` and `e15` are gaps on purpose. - // Renumbering to close a gap rewrites ids that other notes, tests and run - // logs refer to. - { id: "e0", source: "start", target: "get_lead", type: "default" }, - // ⛔ When you add an edge, take the next id AFTER THE HIGHEST IN USE — do - // not reuse a vacant one, and do not assume an unused-looking id is free. - // A duplicate id is INERT (traversal filters out-edges by `source`, never - // by `id`), so nothing fails and the collision survives to trap the next - // editor picking out of the sequence. `e1`, `e3` and `e15` are vacant - // retired ids and stay that way; `e27` is above the highest live id, not - // a gap-fill. - { id: "e27", source: "get_lead", target: "decision_approval", type: "default" }, - // ── The approval gate (REQ-0005 step 7) ──────────────────────────── - // - // The same TOTAL, PARTITIONING pair the duplicate verdict below is written - // as, and for the same measured reason: a decision node declaring no - // `config.conditions` takes EVERY out-edge whose condition holds, in - // parallel, so two overlapping guards would refuse the conversion and - // continue it in one run. `e29` is `e28` negated by De Morgan. - // - // ⚠️ The polarity is fail-OPEN, unlike the duplicate branch, and that is the - // gate's off switch rather than a slip. Only the two verdicts a live - // approval writes refuse; `not_required` — the shipped default — and an - // absent column (a lead from before the field existed) both continue, so - // with the gate off this pair is invisible and conversion behaves exactly as - // it did before. `lead.hook.ts` and `convert_lead.visible` carry the same - // polarity, because the three have to agree about what "off" means. - { id: "e28", source: "decision_approval", target: "refuse_unapproved", type: "default", condition: P26`has(vars.leadRecord) && has(vars.leadRecord.conversion_approval_status) - && (vars.leadRecord.conversion_approval_status == "pending" || vars.leadRecord.conversion_approval_status == "rejected")`, label: "Not approved" }, - { id: "e29", source: "decision_approval", target: "decision_duplicate", type: "default", condition: P26`!has(vars.leadRecord) || !has(vars.leadRecord.conversion_approval_status) - || (vars.leadRecord.conversion_approval_status != "pending" && vars.leadRecord.conversion_approval_status != "rejected")`, label: "Clear" }, - // Rejoins nothing, exactly like `e26`: the refusal IS not reaching a writer. - { id: "e30", source: "refuse_unapproved", target: "end", type: "default" }, - // ⚠️ Both conditions are TOTAL, and on this surface that is not a style - // preference: a flow condition is interpreted strict CEL on every run, and - // an unguarded field read against a driver that omits absent columns - // (`driver-memory` / `driver-mongodb`) aborts — which FAILS THE RUN, so an - // unguarded read here would make ordinary leads unconvertible. Measured, in - // exactly that shape: `condition failed to evaluate as CEL: No such key: - // duplicate_status`. The full table is in - // `test/flow-condition-totality.test.ts`. - // - // TWO guards, in the spelling `test/flow-variable-conditions.test.ts` - // requires, and the outer one is not decoration: `vars.leadRecord` is a - // KEY, so a plain `vars.leadRecord != null` would itself abort with - // `Unknown variable` on the run where `get_lead` bound nothing — the guard - // would be the fault it was written to prevent. `has(vars.leadRecord)` - // answers instead of reading. - // - // The THREE edges PARTITION by De Morgan (`!(a && b && c)` written out as - // `!a || !b || !c`, with the two verdict tests conjoined under the last - // term), so exactly one is true for every record shape, including the - // shapes where the column, the row or both are missing. - // - // ⛔ `e22`'s third term must carry BOTH inequalities. A decision node that - // declares no `config.conditions` reports no branch, so traversal takes - // EVERY out-edge whose condition holds, IN PARALLEL — with `e22` left at - // `!= "suspected"` a confirmed lead satisfies `e22` AND `e25`, showing the - // refusal and converting the lead in the same run. Measured on - // `AutomationEngine.evaluateCondition` across all seven record shapes; the - // pin is in `test/lead-duplicate-visibility.test.ts`. - { id: "e21", source: "decision_duplicate", target: "warn_duplicate", type: "default", condition: P26`has(vars.leadRecord) && has(vars.leadRecord.duplicate_status) && vars.leadRecord.duplicate_status == "suspected"`, label: "Suspected" }, - { id: "e25", source: "decision_duplicate", target: "refuse_confirmed_duplicate", type: "default", condition: P26`has(vars.leadRecord) && has(vars.leadRecord.duplicate_status) && vars.leadRecord.duplicate_status == "confirmed"`, label: "Confirmed" }, - { id: "e22", source: "decision_duplicate", target: "no_duplicate_warning", type: "default", condition: P26`!has(vars.leadRecord) || !has(vars.leadRecord.duplicate_status) || (vars.leadRecord.duplicate_status != "suspected" && vars.leadRecord.duplicate_status != "confirmed")`, label: "Clean" }, - // Both clear duplicate branches pass the match-key guard before the form. - { id: "e23", source: "warn_duplicate", target: "decision_match_key", type: "default" }, - { id: "e24", source: "no_duplicate_warning", target: "decision_match_key", type: "default" }, - // ── The match-key guard (#2017) ──────────────────────────────────── - // - // TOTAL and PARTITIONING, for the reason recorded at `e28` / `e29`: `e32` - // is `e31` negated by De Morgan, so exactly one holds for every shape - // `get_lead` can bind — unbound, a null row, the column absent, null, - // empty, or keyed. `has()` alone is not the test: on a row that carries - // the column as null it answers true, so the value needs `isBlank` too. - // Fail-CLOSED, unlike the approval gate: without a key there is nothing to - // match on, and a guess is the defect. - { id: "e31", source: "decision_match_key", target: "screen_1", type: "default", condition: P26`has(vars.leadRecord) && has(vars.leadRecord.company_normalized) && !isBlank(vars.leadRecord.company_normalized)`, label: "Has match key" }, - { id: "e32", source: "decision_match_key", target: "refuse_no_match_key", type: "default", condition: P26`!has(vars.leadRecord) || !has(vars.leadRecord.company_normalized) || isBlank(vars.leadRecord.company_normalized)`, label: "No match key" }, - // Rejoins nothing, exactly like `e26` / `e30`. - { id: "e33", source: "refuse_no_match_key", target: "end", type: "default" }, - // The refusal branch rejoins nothing: it goes straight to `end`, so no - // node that writes is downstream of it. That is the refusal — the flow's - // every create/update sits behind `screen_1`, which this path never - // reaches. - { id: "e26", source: "refuse_confirmed_duplicate", target: "end", type: "default" }, - { id: "e2", source: "screen_1", target: "find_account", type: "default" }, - { id: "e4", source: "find_account", target: "decision_account", type: "default" }, - // Existing account → reuse; no account → create. Both converge on create_contact. - // `find_account` is reached only with a match key (`e31`), so a match - // here is an equality on a real key, never the has-no-value predicate. - // ⛔ No second copy of the key test on these two edges: it could never - // be false here, and an inert restatement of a live predicate is the - // shape #650 retired from this repo's decision nodes. - { id: "e5", source: "decision_account", target: "use_existing_account", type: "default", condition: P26`vars.matchedAccount != null`, label: "Existing" }, - { id: "e6", source: "decision_account", target: "create_account", type: "default", condition: P26`vars.matchedAccount == null`, label: "New" }, - { id: "e7", source: "create_account", target: "use_new_account", type: "default" }, - // Both account branches converge on the contact-dedupe lookup. - { id: "e8", source: "use_new_account", target: "find_contact", type: "default" }, - { id: "e9", source: "use_existing_account", target: "find_contact", type: "default" }, - { id: "e10", source: "find_contact", target: "decision_contact", type: "default" }, - // Existing contact → reuse; none → create. Both converge on - // decision_opportunity, the reuse path through the consent raise below. - { id: "e11", source: "decision_contact", target: "use_existing_contact", type: "default", condition: P26`vars.matchedContact != null`, label: "Existing" }, - { id: "e12", source: "decision_contact", target: "create_contact", type: "default", condition: P26`vars.matchedContact == null`, label: "New" }, - { id: "e13", source: "create_contact", target: "use_new_contact", type: "default" }, - { id: "e14", source: "use_new_contact", target: "decision_opportunity", type: "default" }, - // ── The reused contact's consent raise (#2068) ───────────────────── - // - // `e15` (use_existing_contact → decision_opportunity) is RETIRED and stays - // vacant; `e34` replaces it. Each pair below is TOTAL and PARTITIONING, and - // only a flag the lead carries as `true` takes the raise. - { id: "e34", source: "use_existing_contact", target: "decision_contact_do_not_call", type: "default" }, - { id: "e35", source: "decision_contact_do_not_call", target: "raise_contact_do_not_call", type: "default", condition: P26`has(vars.leadRecord) && has(vars.leadRecord.do_not_call) && vars.leadRecord.do_not_call == true`, label: "Do not call" }, - { id: "e36", source: "decision_contact_do_not_call", target: "decision_contact_email_opt_out", type: "default", condition: P26`!has(vars.leadRecord) || !has(vars.leadRecord.do_not_call) || vars.leadRecord.do_not_call != true`, label: "Callable" }, - { id: "e37", source: "raise_contact_do_not_call", target: "decision_contact_email_opt_out", type: "default" }, - { id: "e38", source: "decision_contact_email_opt_out", target: "raise_contact_email_opt_out", type: "default", condition: P26`has(vars.leadRecord) && has(vars.leadRecord.email_opt_out) && vars.leadRecord.email_opt_out == true`, label: "Opted out" }, - { id: "e39", source: "decision_contact_email_opt_out", target: "decision_opportunity", type: "default", condition: P26`!has(vars.leadRecord) || !has(vars.leadRecord.email_opt_out) || vars.leadRecord.email_opt_out != true`, label: "Emailable" }, - { id: "e40", source: "raise_contact_email_opt_out", target: "decision_opportunity", type: "default" }, - { id: "e16", source: "decision_opportunity", target: "create_opportunity", type: "default", condition: P26`vars.createOpportunity == true`, label: "Yes" }, - { id: "e17", source: "decision_opportunity", target: "no_opportunity", type: "default", condition: P26`vars.createOpportunity != true`, label: "No" }, - { id: "e18", source: "create_opportunity", target: "use_new_opportunity", type: "default" }, - { id: "e18a", source: "use_new_opportunity", target: "mark_converted", type: "default" }, - { id: "e18b", source: "no_opportunity", target: "mark_converted", type: "default" }, - { id: "e19", source: "mark_converted", target: "send_notification", type: "default" }, - { id: "e20", source: "send_notification", target: "end", type: "default" } - ] -}; - -// src/sales/flows/lead-conversion-approval.flow.ts -import { P as P27, cel as cel7 } from "@objectstack/spec"; -var LeadConversionApprovalFlow = { - name: "lead_conversion_approval", - label: "Lead Conversion Approval", - description: "Sign-off a lead needs before it may be converted. Inert unless the install arms the gate on crm_lead.conversion_approval_status.", - type: "record_change", - status: "active", - // Same reading `opportunity_approval` records, and for the same two reasons. - // A gate exists to CONSTRAIN the submitter, so the submitter's own scope is - // the wrong identity to evaluate it under — and an approval control that - // engages only for writers carrying a session is not a control, since a - // `runAs: 'system'` importer creating leads would simply bypass it. The - // verdict writes below also land on `conversion_approval_status`, which is - // `readonly: true` on the object, so only a platform write reaches it. - runAs: "system", - variables: [ - { name: "leadId", type: "text", isInput: true, isOutput: false } - ], - nodes: [ - { - id: "start", - type: "start", - label: "Start", - config: { - objectName: "crm_lead", - triggerType: "record-after-create", - // TOTALITY (AGENTS.md — validation predicates must be TOTAL): `has()` - // on every read. A flow condition is strict CEL on every run, and an - // unguarded read against a driver that omits absent columns aborts — - // which from 17.0.0-rc.2 FAILS THE RUN rather than skipping it. The - // absent case must read as "not gated": a lead with no approval column - // at all is a lead from before the field existed, and it converts the - // way it always did. - condition: P27`has(record.conversion_approval_status) && record.conversion_approval_status == "pending"` - } - }, - { - id: "get_lead", - type: "get_record", - label: "Get Lead", - config: { objectName: "crm_lead", filter: { id: cel7`record.id` }, outputVariable: "leadRecord" } - }, - { - id: "conversion_review", - type: "approval", - label: "Lead Conversion Review", - config: { - // The customer's chain is 销售负责人 → 销售总监; the generic shape core - // ships is the manager bench this app already declares approvers - // against. A second tier, or a different position, is overlay - // configuration — the same status as the need-type vocabulary. - approvers: [{ type: "position", value: "sales_manager" }], - // Explicit though it is the schema default, exactly as - // `opportunity_approval` authors it: approvers snapshot at request - // creation, so an empty bench would otherwise leave the request - // undecidable — and here that means a lead nobody can ever convert. - onEmptyApprovers: "admin_rescue", - behavior: "first_response", - // ⚠️ `false`, and NOT the schema default `true` — the one place this - // node deliberately differs from its opportunity sibling. A deal under - // review is a document being negotiated; a LEAD under review is a person - // a rep is still calling. Locking the record would freeze - // `last_contacted_date`, `next_followup_date`, the notes and every - // activity bubble for as long as the approver takes, so the gate would - // stop the work it exists to authorise. Nothing is at risk in leaving it - // open: the verdict column is `readonly: true`, so the only field this - // node's decision touches is one no user may write anyway. - lockRecord: false, - approvalStatusField: "conversion_approval_status" - } - }, - { - id: "mark_approved", - type: "update_record", - label: "Mark Approved", - config: { - objectName: "crm_lead", - filter: { id: cel7`record.id` }, - fields: { conversion_approval_status: "approved" } - } - }, - { - id: "notify_approved", - type: "notify", - label: "Notify Owner \u2014 Approved", - config: { - recipients: [cel7`has(leadRecord.owner_id) ? leadRecord.owner_id : null`], - channels: ["inbox"], - topic: "lead_conversion_approved", - template: "crm.lead_conversion_approved", - templateData: { first_name: cel7`leadRecord.first_name`, last_name: cel7`leadRecord.last_name` }, - actionUrl: "/crm_lead/{{record.id}}" - } - }, - { - id: "mark_rejected", - type: "update_record", - label: "Mark Rejected", - config: { - objectName: "crm_lead", - filter: { id: cel7`record.id` }, - fields: { conversion_approval_status: "rejected" } - } - }, - { - id: "notify_rejected", - type: "notify", - label: "Notify Owner \u2014 Rejected", - config: { - recipients: [cel7`has(leadRecord.owner_id) ? leadRecord.owner_id : null`], - channels: ["inbox"], - severity: "warning", - topic: "lead_conversion_rejected", - template: "crm.lead_conversion_rejected", - templateData: { first_name: cel7`leadRecord.first_name`, last_name: cel7`leadRecord.last_name` }, - actionUrl: "/crm_lead/{{record.id}}" - } - }, - { id: "end", type: "end", label: "End" } - ], - edges: [ - { id: "e1", source: "start", target: "get_lead", type: "default" }, - { id: "e2", source: "get_lead", target: "conversion_review", type: "default" }, - // Approval-node branch labels — the engine resumes down the out-edge whose - // `label` matches the recorded decision. - { id: "e3", source: "conversion_review", target: "mark_approved", type: "default", label: "approve" }, - { id: "e4", source: "conversion_review", target: "mark_rejected", type: "default", label: "reject" }, - { id: "e5", source: "mark_approved", target: "notify_approved", type: "default" }, - { id: "e6", source: "notify_approved", target: "end", type: "default" }, - { id: "e7", source: "mark_rejected", target: "notify_rejected", type: "default" }, - { id: "e8", source: "notify_rejected", target: "end", type: "default" } - ] -}; - -// src/sales/flows/account-approval.flow.ts -import { P as P28, cel as cel8 } from "@objectstack/spec"; -var AccountApprovalFlow = { - name: "account_approval", - label: "Account Approval", - description: "Sign-off a newly created account needs before it counts as established data. Switchable from crm_account.approval_status.", - type: "record_change", - status: "active", - // Same reading the two sibling approval flows record. A gate exists to - // CONSTRAIN the submitter, so the submitter's own scope is the wrong identity - // to evaluate it under; and the verdict writes below land on - // `approval_status`, which is `readonly: true` on the object, so only a - // platform write reaches it at all. - runAs: "system", - variables: [{ name: "accountId", type: "text", isInput: true, isOutput: false }], - nodes: [ - { - id: "start", - type: "start", - label: "Start", - config: { - objectName: "crm_account", - triggerType: "record-after-create", - // Fires on the BLANK a new account is born with (see the header): - // absent on a sparse driver, null on SQL. A user cannot pre-fill the - // column (it is `readonly`), so only a system writer or an install's - // `approved` default can make it non-blank at insert, and both mean - // "nothing to submit". - // TOTALITY (AGENTS.md — validation predicates must be TOTAL): the - // `(!has(x) || isBlank(x))` form is the "x holds no value" row of that - // table. A flow condition is strict CEL on every run, and an unguarded - // read against a driver that omits absent columns aborts — which from - // 17.0.0-rc.2 FAILS THE RUN rather than skipping it. - condition: P28`!has(record.approval_status) || isBlank(record.approval_status)` - } - }, - { - id: "get_account", - type: "get_record", - label: "Get Account", - config: { - objectName: "crm_account", - filter: { id: cel8`record.id` }, - outputVariable: "accountRecord" - } - }, - { - id: "account_review", - type: "approval", - label: "Account Review", - config: { - // The customer's chain is 销售负责人 → 销售总监; REQ-0003 rules that named - // chain **C** (overlay — one company's org chart), so core ships the - // one generic tier against the manager bench this app already declares. - approvers: [{ type: "position", value: "sales_manager" }], - // Explicit though it is the schema default, exactly as both sibling - // flows author it: approvers snapshot at request creation, so an empty - // bench would otherwise leave the request undecidable — and here that - // means an account nobody can ever approve. - onEmptyApprovers: "admin_rescue", - behavior: "first_response", - // ⚠️ `false`, matching the lead sibling rather than the opportunity one. - // An account under review is a record a rep is still working — contacts - // are being attached, the address is being corrected, activity is - // landing on it. Locking it would freeze exactly the data-entry the - // approval exists to review. Nothing is at risk: the verdict column is - // `readonly: true`, so the only field this decision touches is one no - // user may write anyway. - lockRecord: false, - approvalStatusField: "approval_status" - } - }, - { - id: "mark_approved", - type: "update_record", - label: "Mark Approved", - config: { - objectName: "crm_account", - filter: { id: cel8`record.id` }, - fields: { approval_status: "approved" } - } - }, - { - id: "notify_approved", - type: "notify", - label: "Notify Owner \u2014 Approved", - config: { - recipients: [cel8`has(accountRecord.owner_id) ? accountRecord.owner_id : null`], - channels: ["inbox"], - topic: "account_approved", - template: "crm.account_approved", - templateData: { name: cel8`accountRecord.name` }, - actionUrl: "/crm_account/{{record.id}}" - } - }, - { - id: "mark_rejected", - type: "update_record", - label: "Mark Rejected", - config: { - objectName: "crm_account", - filter: { id: cel8`record.id` }, - fields: { approval_status: "rejected" } - } - }, - { - id: "notify_rejected", - type: "notify", - label: "Notify Owner \u2014 Rejected", - config: { - recipients: [cel8`has(accountRecord.owner_id) ? accountRecord.owner_id : null`], - channels: ["inbox"], - severity: "warning", - topic: "account_rejected", - template: "crm.account_rejected", - templateData: { name: cel8`accountRecord.name` }, - actionUrl: "/crm_account/{{record.id}}" - } - }, - { id: "end", type: "end", label: "End" } - ], - edges: [ - { id: "e1", source: "start", target: "get_account", type: "default" }, - { id: "e2", source: "get_account", target: "account_review", type: "default" }, - // Approval-node branch labels — the engine resumes down the out-edge whose - // `label` matches the recorded decision. - { id: "e3", source: "account_review", target: "mark_approved", type: "default", label: "approve" }, - { id: "e4", source: "account_review", target: "mark_rejected", type: "default", label: "reject" }, - { id: "e5", source: "mark_approved", target: "notify_approved", type: "default" }, - { id: "e6", source: "notify_approved", target: "end", type: "default" }, - { id: "e7", source: "mark_rejected", target: "notify_rejected", type: "default" }, - { id: "e8", source: "notify_rejected", target: "end", type: "default" } - ] -}; - -// src/sales/flows/schedule-followup.flow.ts -import { cel as cel9 } from "@objectstack/spec"; -var ScheduleFollowUpFlow = { - name: "schedule_followup", - label: "Schedule Follow-up", - description: "Create the next follow-up task on a lead, already linked and owned.", - type: "screen", - status: "active", - variables: [ - // MUST be `recordId` — the console's flow-action contract seeds only that - // name (and its camelCase object alias); a custom name arrives undefined. - { name: "recordId", type: "text", isInput: true, isOutput: false }, - { name: "subject", type: "text", isInput: true, isOutput: false }, - { name: "dueDate", type: "date", isInput: true, isOutput: false }, - { name: "activityType", type: "text", isInput: true, isOutput: false }, - { name: "priority", type: "text", isInput: true, isOutput: false }, - { name: "notes", type: "text", isInput: true, isOutput: false } - ], - nodes: [ - { id: "start", type: "start", label: "Start", config: { objectName: "crm_lead" } }, - { - id: "screen_1", - type: "screen", - label: "Schedule Follow-up", - config: { - fields: [ - { name: "subject", label: "What is the next step?", type: "text", required: true }, - { name: "dueDate", label: "Due Date", type: "date", required: true }, - { - name: "activityType", - label: "Activity Type", - type: "select", - // Mirrors crm_task.type exactly. ⛔ Never hand-copy the subset — it - // silently drops an option (`other`) from the picker. - options: plainOptions(TASK_TYPE_OPTIONS) - }, - { - name: "priority", - label: "Priority", - type: "select", - options: [ - { label: "Low", value: "low" }, - { label: "Normal", value: "normal" }, - { label: "High", value: "high" }, - { label: "Urgent", value: "urgent" } - ] - }, - { name: "notes", label: "Notes", type: "textarea" } - ] - } - }, - { - id: "get_lead", - type: "get_record", - label: "Get Lead Record", - config: { objectName: "crm_lead", filter: { id: cel9`recordId` }, outputVariable: "leadRecord" } - }, - { - id: "create_task", - type: "create_record", - label: "Create Follow-up Task", - config: { - objectName: "crm_task", - fields: { - subject: cel9`subject`, - due_date: cel9`dueDate`, - // The three optional answers: a resume may leave one unbound, which - // the template wrote as nothing and the guard writes as null. On an - // insert the two are the same — the engine applies a field's default - // to an explicit null exactly as to an omitted key, so an unanswered - // priority still lands as `normal`. - type: cel9`has(vars.activityType) ? activityType : null`, - priority: cel9`has(vars.priority) ? priority : null`, - description: cel9`has(vars.notes) ? notes : null`, - status: "not_started", - owner_id: cel9`current_user.id`, - // Polymorphic parent: both halves are required for the lead's - // Related tab to pick the task up. - related_to_type: "crm_lead", - related_to_lead: cel9`recordId` - }, - outputVariable: "createdTask" - } - }, - { - // Keep the lead's own follow-up date in step with the task that was just - // filed, so the Hot Leads view (sorted by next_followup_date) reflects - // the commitment the rep actually made. - id: "stamp_lead", - type: "update_record", - label: "Stamp Next Follow-up Date", - config: { - objectName: "crm_lead", - filter: { id: cel9`recordId` }, - fields: { next_followup_date: cel9`dueDate` } - } - }, - { id: "end", type: "end", label: "End" } - ], - edges: [ - { id: "e1", source: "start", target: "screen_1", type: "default" }, - { id: "e2", source: "screen_1", target: "get_lead", type: "default" }, - { id: "e3", source: "get_lead", target: "create_task", type: "default" }, - { id: "e4", source: "create_task", target: "stamp_lead", type: "default" }, - { id: "e5", source: "stamp_lead", target: "end", type: "default" } - ] -}; - -// src/sales/flows/opportunity-approval.flow.ts -import { P as P29, cel as cel10 } from "@objectstack/spec"; -var OpportunityApprovalFlow = { - name: "opportunity_approval", - label: "Large Deal Approval", - description: "Tiered approval for opportunities: manager review at $100K or more, director sign-off > $500K.", - type: "record_change", - status: "active", - // Same user-less exposure as every record-change flow (ADR-0049) — and the - // one with teeth. Measured on 17.0.0-rc.2: a $150K renewal - // created by the `runAs: 'system'` contract_renewal sweep fired this flow - // with no trigger user, and the run died at `get_opportunity`. The deal sat - // at `approval_status: 'not_required'`, unlocked, with no approval request - // ever opened — the gate was bypassed by the writer simply not carrying a - // session. An approval control that only engages for logged-in writers is - // not a control. - // - // Elevating the USER-driven runs too is not merely acceptable here, it is - // required. This gate exists to CONSTRAIN the submitter, so the submitter's - // own scope is the wrong identity to evaluate it under; and - // `mark_approved` / `mark_rejected` stamp `approval_status` on a record the - // approval node holds locked (`lockRecord: true`), which only a platform - // write may land. The approval node itself already opens its request under - // the platform identity while re-attaching the deciding user for - // attribution, so this declaration aligns the flow with the node it drives. - runAs: "system", - variables: [ - { name: "opportunityId", type: "text", isInput: true, isOutput: false } - ], - nodes: [ - { - id: "start", - type: "start", - label: "Start", - // Trigger wiring (7.4): bind to afterUpdate; gate on crossing the entry - // threshold while not already in an approval state. The `not_required` - // guard stops the flow's own approval_status writes from re-triggering it. - config: { - objectName: "crm_opportunity", - triggerType: "record-after-update", - // Null-tolerant: rows inserted before approval_status had a field-level - // defaultValue (e.g. flow-created opportunities) carry null, which must - // still enter approval. - // Stage guard: a settled deal must never (re-)enter approval — the - // freeze hook rejects approval-status writes on closed records, so - // without this guard the flow opened a locked approval request it - // could never resolve (lockRecord held the closed record hostage). - // TOTALITY: `has(...)` on every read, plus `!= null` on the - // ordering comparison — `has()` passes an explicit null and - // `record.amount >= 100000` then aborts with - // `no such overload: dyn >= int`. Measured total as authored - // today (amount/stage are required, approval_status is defaulted), but - // that is `crm_opportunity`'s schema doing the work, not the - // predicate. An absent `approval_status` reads the same as the null - // this condition already tolerates; an absent `stage` is not a settled - // stage, so it must not block approval. - condition: P29`has(record.amount) && record.amount != null && record.amount >= ${LARGE_DEAL_AMOUNT} - && (!has(record.approval_status) || record.approval_status == "not_required" || record.approval_status == null) - && (!has(record.stage) || (record.stage != "closed_won" && record.stage != "closed_lost"))` - } - }, - { - id: "get_opportunity", - type: "get_record", - label: "Get Opportunity", - config: { objectName: "crm_opportunity", filter: { id: cel10`record.id` }, outputVariable: "oppRecord" } - }, - // ── Tier 1: Sales Manager review (all deals at $100K or more) ─── - { - id: "manager_review", - type: "approval", - label: "Sales Manager Review", - config: { - // ⛔ Never add an org-owner approver as an empty-bench workaround. - // `onEmptyApprovers: 'admin_rescue'` is the node policy for an empty - // position on @objectstack 17 (approvers snapshot at request creation, - // so a position with no holders would otherwise leave the request - // undecidable while `lockRecord` held the record hostage). An - // `{ type: 'org_membership_level', value: 'owner' }` entry overshoots: - // with `behavior: 'first_response'` it makes an org owner a routine - // approver for every deal, not a rescue when the bench is empty. - approvers: [{ type: "position", value: "sales_manager" }], - // Explicit even though `admin_rescue` is the schema default — this is - // the mechanism the node depends on, so it is authored, not inherited. - onEmptyApprovers: "admin_rescue", - behavior: "first_response", - lockRecord: true, - approvalStatusField: "approval_status" - } - }, - // ── Tier gate: does this deal also need director sign-off? ────── - { - // No `config.condition` here: the branch is on edges `e5` / `e6`, which - // is where the engine actually reads it. A copy on the node would be - // inert and indistinguishable from the live one (17.0.0-rc.2's - // `flow-inert-node-condition`). - id: "check_high_value", - type: "decision", - label: "High Value (> $500K)?" - }, - // ── Tier 2: Sales Director sign-off (deals > $500K only) ──────── - { - id: "director_signoff", - type: "approval", - label: "Sales Director Sign-off", - config: { - // Same node policy as manager_review — see the note there. - approvers: [{ type: "position", value: "sales_director" }], - onEmptyApprovers: "admin_rescue", - behavior: "first_response", - lockRecord: true, - approvalStatusField: "approval_status" - } - }, - // ── Final approve: stamp status + notify owner ────────────────── - { - id: "mark_approved", - type: "update_record", - label: "Mark Approved", - config: { - objectName: "crm_opportunity", - filter: { id: cel10`record.id` }, - fields: { approval_status: "approved", approved_date: cel10`isoDatetime(now())` } - } - }, - { - id: "notify_approved", - type: "notify", - label: "Notify Owner \u2014 Approved", - config: { - recipients: [cel10`has(oppRecord.owner_id) ? oppRecord.owner_id : null`], - channels: ["inbox", "email"], - topic: "opportunity_approved", - template: "crm.opportunity_approved", - templateData: { name: cel10`oppRecord.name` }, - actionUrl: "/crm_opportunity/{{record.id}}" - } - }, - // ── Rejection: stamp status + notify owner ────────────────────── - { - id: "mark_rejected", - type: "update_record", - label: "Mark Rejected", - config: { - objectName: "crm_opportunity", - filter: { id: cel10`record.id` }, - fields: { approval_status: "rejected" } - } - }, - { - id: "notify_rejected", - type: "notify", - label: "Notify Owner \u2014 Rejected", - config: { - recipients: [cel10`has(oppRecord.owner_id) ? oppRecord.owner_id : null`], - channels: ["inbox", "email"], - severity: "warning", - topic: "opportunity_rejected", - template: "crm.opportunity_rejected", - templateData: { name: cel10`oppRecord.name` }, - actionUrl: "/crm_opportunity/{{record.id}}" - } - }, - { id: "end", type: "end", label: "End" } - ], - edges: [ - { id: "e1", source: "start", target: "get_opportunity", type: "default" }, - { id: "e2", source: "get_opportunity", target: "manager_review", type: "default" }, - // Manager decision (approval-node branch labels) - { id: "e3", source: "manager_review", target: "check_high_value", type: "default", label: "approve" }, - { id: "e4", source: "manager_review", target: "mark_rejected", type: "default", label: "reject" }, - // Tier gate (decision-node conditional branches). These EDGES are the live - // sites — the engine never evaluates a `decision` node's singular - // `config.condition` — and they must PARTITION, so the guards are written - // in opposite polarity. A deal whose amount cannot be read lands on - // `mark_approved`: the manager has already approved it, and an unreadable - // amount must not strand an approved deal in a locked, undecidable - // director step. - // - // TOTALITY: `oppRecord` is a `get_record` OUTPUT, so the read needs - // `has(vars.oppRecord)` (the variable), `has(vars.oppRecord.amount)` (the - // column — `findOne` answers a miss with `null`, and a sparse driver row - // omits an unwritten column outright) and `!= null` (an explicit null - // passes `has()` and the ordering comparison then aborts with `no such - // overload: dyn > int`). Measured total as authored today — `amount` - // is `required` on `crm_opportunity` and the `get_record` is keyed on the - // row that just fired the trigger — but that is the neighbouring schema - // doing the work, exactly as in the start condition above. `vars.`-scoped - // rather than bare: `has(oppRecord.amount)` still aborts with `Unknown - // variable: oppRecord` on an unbound variable, `has(vars.oppRecord)` - // answers `false` (measured). From 17.0.0-rc.2 an unevaluable condition - // ABORTS the step rather than skipping it, so a guard that was - // belt-and-braces is now what keeps the run alive. - { id: "e5", source: "check_high_value", target: "director_signoff", type: "conditional", condition: P29`has(vars.oppRecord) && has(vars.oppRecord.amount) - && vars.oppRecord.amount != null && vars.oppRecord.amount > ${HIGH_VALUE_DEAL_AMOUNT}`, label: "High value (> $500K)" }, - { id: "e6", source: "check_high_value", target: "mark_approved", type: "conditional", condition: P29`!has(vars.oppRecord) || !has(vars.oppRecord.amount) - || vars.oppRecord.amount == null || vars.oppRecord.amount <= ${HIGH_VALUE_DEAL_AMOUNT}`, label: "Standard (\u2264 $500K)" }, - // Director decision (approval-node branch labels) - { id: "e7", source: "director_signoff", target: "mark_approved", type: "default", label: "approve" }, - { id: "e8", source: "director_signoff", target: "mark_rejected", type: "default", label: "reject" }, - // Terminal branches - { id: "e9", source: "mark_approved", target: "notify_approved", type: "default" }, - { id: "e10", source: "notify_approved", target: "end", type: "default" }, - { id: "e11", source: "mark_rejected", target: "notify_rejected", type: "default" }, - { id: "e12", source: "notify_rejected", target: "end", type: "default" } - ] -}; -var OpportunityApprovalOnCreateFlow = { - ...OpportunityApprovalFlow, - name: "opportunity_approval_on_create", - label: "Large Deal Approval (on create)", - description: "Approval intake for opportunities created above the threshold (insert-time twin of opportunity_approval).", - nodes: OpportunityApprovalFlow.nodes.map( - (n) => n.id === "start" ? { ...n, config: { ...n.config, triggerType: "record-after-create" } } : n - ) -}; - -// src/sales/flows/opportunity-status-change-approval.flow.ts -import { P as P30, cel as cel11 } from "@objectstack/spec"; -var OpportunityStatusChangeApprovalFlow = { - name: "opportunity_status_change_approval", - label: "Opportunity Status Change Approval", - description: "Sign-off a deal needs before it is declared won or lost. Inert unless the install arms the gate on crm_opportunity.status_change_approval_status.", - type: "record_change", - status: "active", - // REQ-0006 acceptance 4, and the same reading `opportunity_approval` records - // from its own measured failure: a gate that engages only for writers - // carrying a session is not a control — a `runAs: 'system'` sweep or import - // would simply bypass it. The verdict and the stage write below also land on - // columns the readonly strip protects, which only a platform write reaches. - runAs: "system", - variables: [ - { name: "opportunityId", type: "text", isInput: true, isOutput: false } - ], - nodes: [ - { - id: "start", - type: "start", - label: "Start", - config: { - objectName: "crm_opportunity", - triggerType: "record-after-update", - // TOTALITY (AGENTS.md — validation predicates must be TOTAL): `has()` - // on every read. A flow condition is strict CEL on every run and an - // unguarded read against a driver that omits absent columns aborts, - // which from 17.0.0-rc.2 FAILS THE RUN rather than skipping it. The - // absent case must read as "not gated": a deal with no gate column at - // all predates the field and closes the way it always did. - // - // Three halves: - // - // - the gate is ARMED: `pending` (born armed, no request decided yet) - // or `rejected` (the last request was refused). `rejected` re-opens - // on a new request because `opportunity.hook.ts` refuses a direct - // close in both states — if only `pending` entered here, a rejected - // deal could be neither requested nor closed, ever. - // - a request is present; - // - the request is NEW on this write. TRANSITION, not current value — - // the idiom `billing_handoff_closed_won` records for this object. - // Without it the flow re-fires on its own write-back while the - // request is still open (the approval node's `pending` stamp through - // `approvalStatusField` is an update of this record). Measured on - // 17.6.0 with this term deleted: one re-entry per request, each - // caught only by the engine's self-trigger guard ("the guard as - // authored does not exclude the flow's own write-back"); with it, - // none. `previous.*` is guarded FAIL-CLOSED: no visible prior - // value, no visible new request. - // - // `apply_status` leaves the gate `approved` (out of reach) and - // `clear_request` empties the request, so neither re-enters. - condition: P30`has(record.status_change_approval_status) - && (record.status_change_approval_status == "pending" || record.status_change_approval_status == "rejected") - && has(record.requested_status) && record.requested_status != null && record.requested_status != "" - && has(previous.requested_status) && previous.requested_status != record.requested_status` - } - }, - { - id: "get_opportunity", - type: "get_record", - label: "Get Opportunity", - config: { objectName: "crm_opportunity", filter: { id: cel11`record.id` }, outputVariable: "oppRecord" } - }, - { - id: "status_review", - type: "approval", - label: "Status Change Review", - config: { - // The customer's chain is 销售负责人 → 事业部负责人; the generic shape core - // ships is the manager bench this app already declares approvers - // against. A second tier, or a different position, is overlay - // configuration (REQ-0006 acceptance 5). - approvers: [{ type: "position", value: "sales_manager" }], - // Explicit though it is the schema default, exactly as both sibling - // approvals author it: approvers snapshot at request creation, so an - // empty bench would leave the request undecidable — and here that - // means a deal nobody can ever close. - onEmptyApprovers: "admin_rescue", - behavior: "first_response", - // `true`, matching `opportunity_approval` and NOT the lead gate: a deal - // awaiting a won/lost verdict must not keep moving underneath the - // approver. Its narrative fields are what the freeze hook leaves open - // anyway. - lockRecord: true, - approvalStatusField: "status_change_approval_status" - } - }, - { - // The approved decision is what moves the stage — "通过后正式生效". - // - // ⚠️ Both fields in ONE write, and that is load-bearing: the - // status-change guard in `opportunity.hook.ts` reads the gate column - // INPUT-FIRST, so this write presents itself as already-approved and the - // guard lets the stage through. Splitting it into two writes would have - // the guard refuse the flow's own write (ELEVATION IS NOT ANONYMITY — - // `runAs: 'system'` carries the triggering user, so `ctx.user?.id` is - // present in this run). - // - // `win_reason` / `loss_reason` are `requiredWhen` the stage is closed and - // are evaluated against the merged record, so the values the rep captured - // when requesting satisfy them here. - id: "apply_status", - type: "update_record", - label: "Apply Requested Status", - config: { - objectName: "crm_opportunity", - filter: { id: cel11`record.id` }, - fields: { - stage: cel11`oppRecord.requested_status`, - status_change_approval_status: "approved", - approved_date: cel11`isoDatetime(now())` - } - } - }, - { - // A rejected request is cleared, not left standing, and the verdict stays - // `rejected` so the hook keeps refusing a direct close: the way on is a - // new request, which the start condition opens as a fresh approval. - id: "clear_request", - type: "update_record", - label: "Clear Rejected Request", - config: { - objectName: "crm_opportunity", - filter: { id: cel11`record.id` }, - fields: { status_change_approval_status: "rejected", requested_status: null } - } - }, - { id: "end", type: "end", label: "End" } - ], - edges: [ - { id: "e1", source: "start", target: "get_opportunity", type: "default" }, - { id: "e2", source: "get_opportunity", target: "status_review", type: "default" }, - // Approval-node branch labels. - { id: "e3", source: "status_review", target: "apply_status", type: "default", label: "approve" }, - { id: "e4", source: "status_review", target: "clear_request", type: "default", label: "reject" }, - { id: "e5", source: "apply_status", target: "end", type: "default" }, - { id: "e6", source: "clear_request", target: "end", type: "default" } - ] -}; - -// src/sales/flows/opportunity-qualification-approval.flow.ts -import { P as P31, cel as cel12 } from "@objectstack/spec"; -var OpportunityQualificationApprovalFlow = { - name: "opportunity_qualification_approval", - label: "Opportunity Qualification Approval", - description: "The \u7ACB\u9879 sign-off a deal needs before its stage or won/lost call may change. Inert unless the install arms the gate on crm_opportunity.qualification_approval_status.", - type: "record_change", - status: "active", - // The reading both sibling gates record from `opportunity_approval`'s - // measured failure: a gate that engages only for writers carrying a session - // is not a control. The verdict writes below also land on a column the - // readonly strip protects, which only a platform write reaches. - runAs: "system", - variables: [ - { name: "opportunityId", type: "text", isInput: true, isOutput: false } - ], - nodes: [ - { - id: "start", - type: "start", - label: "Start", - config: { - objectName: "crm_opportunity", - triggerType: "record-after-update", - // TOTALITY (AGENTS.md — validation predicates must be TOTAL): `has()` - // on every read; the absent case reads as "not gated". - // - // Three halves, the status-change gate's own: - // - // - the gate is ARMED: `pending` or `rejected`. `rejected` re-opens on a - // new request because the hook refuses the gated acts in both states — - // if only `pending` entered here, a rejected deal could never qualify. - // - the request is ticked; - // - the request is NEW on this write. TRANSITION, not current value: - // the approval node's `pending` stamp through `approvalStatusField` is - // an update of this record while the request is still ticked, and a - // current-value test re-fires on it. Measured on a 17.6.0 boot with - // this term deleted: one re-entry per request, caught only by the - // engine's self-trigger guard ("the guard as authored does not - // exclude the flow's own write-back"); with it, none. `previous.*` is - // guarded FAIL-CLOSED: no visible prior value, no visible new request. - // - // `mark_qualified` leaves the gate `approved` (out of reach) and - // `clear_request` unticks the request, so neither re-enters. - condition: P31`has(record.qualification_approval_status) - && (record.qualification_approval_status == "pending" || record.qualification_approval_status == "rejected") - && has(record.qualification_requested) && record.qualification_requested == true - && has(previous.qualification_requested) && previous.qualification_requested != true` - } - }, - { - id: "get_opportunity", - type: "get_record", - label: "Get Opportunity", - config: { objectName: "crm_opportunity", filter: { id: cel12`record.id` }, outputVariable: "oppRecord" } - }, - { - id: "qualification_review", - type: "approval", - label: "Qualification Review", - config: { - // The customer's chain is 销售负责人 / 事业部审批岗 → 事业部负责人; the generic - // shape core ships is the manager bench both sibling gates route to. A - // second tier, or a different position, is overlay configuration - // (REQ-0006: the named approval chains are C). - approvers: [{ type: "position", value: "sales_manager" }], - // Explicit though it is the schema default, as every sibling authors - // it: an empty bench would leave the request undecidable — here, a - // deal that can never move its stage. - onEmptyApprovers: "admin_rescue", - behavior: "first_response", - // ⚠️ `false`, NOT the status-change gate's `true` — the one term this - // node deliberately takes from the LEAD gate instead. Step 11 says it - // in as many words: 「新增商机可跟进」. A deal awaiting 立项 is still being - // worked — the narrative, the customer calendar, the amount and Will - // Bid are what the approver reads — and locking it would stop that work - // for as long as the approver takes. The two acts the gate exists to hold - // are refused by `opportunity_lifecycle` whether or not a request is - // open, so the lock would add nothing but the freeze. - lockRecord: false, - approvalStatusField: "qualification_approval_status" - } - }, - { - id: "mark_qualified", - type: "update_record", - label: "Mark Qualified", - config: { - objectName: "crm_opportunity", - filter: { id: cel12`record.id` }, - fields: { qualification_approval_status: "approved" } - } - }, - { - // A rejected request is cleared, not left standing, and the verdict stays - // `rejected` so the hook keeps refusing the gated acts: the way on is a - // new request, which the start condition opens as a fresh approval. - id: "clear_request", - type: "update_record", - label: "Clear Rejected Request", - config: { - objectName: "crm_opportunity", - filter: { id: cel12`record.id` }, - fields: { qualification_approval_status: "rejected", qualification_requested: false } - } - }, - { id: "end", type: "end", label: "End" } - ], - edges: [ - { id: "e1", source: "start", target: "get_opportunity", type: "default" }, - { id: "e2", source: "get_opportunity", target: "qualification_review", type: "default" }, - // Approval-node branch labels. - { id: "e3", source: "qualification_review", target: "mark_qualified", type: "default", label: "approve" }, - { id: "e4", source: "qualification_review", target: "clear_request", type: "default", label: "reject" }, - { id: "e5", source: "mark_qualified", target: "end", type: "default" }, - { id: "e6", source: "clear_request", target: "end", type: "default" } - ] -}; - -// src/sales/flows/opportunity-stagnation.flow.ts -import { P as P32, cel as cel13 } from "@objectstack/spec"; -var STALE_THRESHOLD_DAYS = 14; -var OpportunityStagnationFlow = { - name: "opportunity_stagnation", - label: "Stalled Deal Alert", - description: "Daily sweep: nudge owners about open opportunities stuck in-stage beyond the threshold.", - type: "schedule", - status: "active", - // Scheduled runs have no trigger user, so under the default runAs:'user' the - // data nodes execute UNSCOPED anyway. Declare runAs:'system' to make that - // RLS-bypassing elevation explicit and intended (ADR-0049). - runAs: "system", - variables: [], - nodes: [ - { id: "start", type: "start", label: "Start (daily 07:30)", config: { schedule: "30 7 * * *" } }, - { - id: "query_stalled", - type: "get_record", - label: "Find Stalled Deals", - config: { - objectName: "crm_opportunity", - // ⛔ Predicate on the STORED `stage_entry_date`, never on - // `days_in_stage`: the latter is a formula, computed after the query, so - // as a filter key it addresses a column that does not exist. - // `entry < today − N` - // is the same test as `days_in_stage > N`, computed by a CEL value - // envelope (the `isoDate(daysAgo(n))` spelling; contract-renewal uses - // its `daysFromNow` twin). - // A row with a null `stage_entry_date` does not satisfy `$lt` and is - // skipped, preserving "nothing has stagnated yet" for unstamped rows. - filter: { - stage: { $nin: ["closed_won", "closed_lost"] }, - stage_entry_date: { $lt: cel13`isoDate(daysAgo(${STALE_THRESHOLD_DAYS}))` } - }, - limit: 500, - outputVariable: "oppList" - } - }, - { - id: "loop_opps", - type: "loop", - label: "For Each Stalled Deal", - config: { - collection: cel13`oppList`, - iteratorVariable: "currentOpp", - body: guarded("opp", { - nodes: [ - { - // Idempotency gate: a still-open stall task means this deal was - // already nudged. ⛔ Without it the daily sweep re-notifies and - // re-creates an identical task every morning for as long as the - // deal stays stalled — an unbounded duplicate pile-up. - id: "find_existing_task", - type: "get_record", - label: "Already Nudged?", - config: { - objectName: "crm_task", - filter: { - related_to_opportunity: cel13`currentOpp.id`, - subject: cel13`'Advance stalled deal: ' + currentOpp.name`, - status: { $nin: ["completed"] } - }, - outputVariable: "existingStallTask" - } - }, - { - // Gateway only — the predicate lives on the out-edge. - id: "check_not_nudged", - type: "decision", - label: "First Nudge?" - }, - { - // Owner only: `{currentOpp.owner_id.manager}` cannot traverse a - // lookup in flow templates — it interpolates to the literal - // "undefined" (cf. opportunity_won_alert). - id: "notify_owner", - type: "notify", - label: "Nudge Owner", - config: { - recipients: [cel13`has(currentOpp.owner_id) ? currentOpp.owner_id : null`], - channels: ["inbox", "email"], - topic: "deal_stalled", - template: "crm.deal_stalled", - templateData: { - name: cel13`currentOpp.name`, - stage: cel13`currentOpp.stage`, - days_in_stage: cel13`currentOpp.days_in_stage` - }, - actionUrl: "/crm_opportunity/{{currentOpp.id}}" - } - }, - { - id: "create_followup_task", - type: "create_record", - label: "Create Follow-up Task", - config: { - objectName: "crm_task", - fields: { - subject: cel13`'Advance stalled deal: ' + currentOpp.name`, - type: "follow_up", - priority: "high", - status: "not_started", - due_date: cel13`isoDate(daysFromNow(2))`, - owner_id: cel13`has(currentOpp.owner_id) ? currentOpp.owner_id : null`, - // ORG PARTITION. A schedule trigger carries no - // organization, so without this the nudge task is born - // `organization_id` NULL — outside every org partition. - // Upstream ruling objectstack#6155 Q2=A assigns the answer to - // the flow author; the task belongs to the org of the deal it - // nudges. `crm_opportunity` carries the column, so the read - // resolves. It is deliberately UNGUARDED: on 17.x a source - // lacking it interpolated to `undefined` and landed as NULL - // while looking declared; CEL fails the iteration instead, and - // a `has()` guard would write that NULL back. - organization_id: cel13`currentOpp.organization_id`, - related_to_type: "crm_opportunity", - related_to_opportunity: cel13`currentOpp.id` - } - } - } - ], - edges: [ - { id: "b1", source: "find_existing_task", target: "check_not_nudged", type: "default" }, - // "Already nudged" has no edge, so the loop moves to the next item. - // This edge is the ONLY site for the predicate: a `decision` - // node's singular `config.condition` is never read, so a node copy - // would be inert metadata free to drift away from what runs. - { id: "b2", source: "check_not_nudged", target: "notify_owner", type: "conditional", condition: P32`existingStallTask == null`, label: "First nudge" }, - { id: "b3", source: "notify_owner", target: "create_followup_task", type: "default" } - ] - }) - } - }, - { id: "end", type: "end", label: "End" } - ], - edges: [ - { id: "e1", source: "start", target: "query_stalled", type: "default" }, - { id: "e2", source: "query_stalled", target: "loop_opps", type: "default" }, - { id: "e3", source: "loop_opps", target: "end", type: "default" } - ] -}; - -// src/sales/flows/forecast-snapshot.flow.ts -import { P as P33, expression as expression2, cel as cel14 } from "@objectstack/spec"; -var SNAPSHOT_PERIOD = "quarter"; -var OPEN_STAGES = { $nin: ["closed_won", "closed_lost"] }; -var CURRENT_PERIOD_FILTER = { - owner_id: cel14`currentOwner.id`, - period: SNAPSHOT_PERIOD, - period_start: { $lte: cel14`isoDate(today())` }, - period_end: { $gte: cel14`isoDate(today())` } -}; -var OWNED_PERIOD_FILTER = { ...CURRENT_PERIOD_FILTER, source: "scheduled" }; -var inPeriod = (extra) => ({ - owner_id: cel14`currentOwner.id`, - organization_id: cel14`currentForecast.organization_id`, - close_date: { - $gte: cel14`currentForecast.period_start`, - $lte: cel14`currentForecast.period_end` - }, - ...extra -}); -var sumBucket = (key, label, filter, total, item = `current_${key}`) => ({ - find: { - id: `find_${key}`, - type: "get_record", - label: `Find ${label}`, - config: { - objectName: "crm_opportunity", - filter, - limit: 500, - outputVariable: `${key}Opps` - } - }, - sum: { - id: `sum_${key}`, - type: "loop", - label: `Sum ${label}`, - config: { - collection: expression2(`${key}Opps`, "cel"), - iteratorVariable: item, - body: { - nodes: [ - { - id: `add_${key}`, - type: "assignment", - label: `Add to ${label}`, - config: { - assignments: { - [total]: expression2(`${total} + (!has(${item}.amount) || isBlank(${item}.amount) ? 0.0 : double(${item}.amount))`, "cel") - } - } - } - ], - edges: [] - } - } - } -}); -var BUCKETS = [ - sumBucket("pipeline", "Open Pipeline", inPeriod({ stage: OPEN_STAGES }), "pipelineTotal"), - sumBucket( - "best_case", - "Best Case", - inPeriod({ stage: OPEN_STAGES, forecast_category: { $in: ["best_case", "commit"] } }), - "bestCaseTotal" - ), - sumBucket( - "commit", - "Commit", - inPeriod({ stage: OPEN_STAGES, forecast_category: "commit" }), - "commitTotal" - ), - sumBucket("won", "Closed Won", inPeriod({ stage: "closed_won" }), "closedTotal") -]; -var OWNER_CHAIN = [ - "reset_totals", - ...BUCKETS.flatMap((b) => [b.find.id, b.sum.id]), - "write_snapshot" -]; -var ForecastSnapshotFlow = { - name: "forecast_snapshot", - label: "Forecast Snapshot", - description: "Nightly sweep: upsert a current-quarter crm_forecast row per active opportunity owner with pipeline, best-case, commit and closed-won totals.", - type: "schedule", - status: "active", - // Scheduled runs have no trigger user, so under the default runAs:'user' the - // data nodes execute UNSCOPED anyway. Declare runAs:'system' to make that - // RLS-bypassing elevation explicit and intended (ADR-0049) — and it - // is load-bearing here: `crm_forecast` is `sharingModel: 'private'`, so a - // user-scoped sweep could only ever see its own rows. - runAs: "system", - variables: [], - nodes: [ - { id: "start", type: "start", label: "Start (daily 03:00)", config: { schedule: "0 3 * * *" } }, - { - // Every user is a candidate; the `has_deals` gate below decides who is - // actually an opportunity owner. Filtering `sys_user` here instead would - // hard-code an activity flag this app does not own. - // No `filter` key: an EMPTY filter node (`{}`) reduces to TRUE and - // matches every row, so it is indistinguishable from an absent key — - // ObjectStack 17.0.0-rc.6 promotes the pair to an author-time error - // (`filter-empty-node`) precisely because only the absent key SAYS - // "every user is a candidate" to the next reader. The `has_deals` gate - // below is what actually narrows the set. - id: "query_owners", - type: "get_record", - label: "Find Users", - config: { objectName: "sys_user", limit: 500, outputVariable: "ownerList" } - }, - { - id: "loop_owners", - type: "loop", - label: "For Each Owner", - config: { - collection: cel14`ownerList`, - iteratorVariable: "currentOwner", - body: guarded("owner", { - nodes: [ - { - // Cheap findOne gate: a user with no live opportunity is not a - // forecast owner, and must not get a row (a fresh install would - // otherwise gain one empty snapshot per employee). - id: "find_any_deal", - type: "get_record", - label: "Owns Any Live Deal?", - config: { - objectName: "crm_opportunity", - filter: { owner_id: cel14`currentOwner.id`, stage: { $nin: ["closed_lost"] } }, - outputVariable: "ownerAnyDeal" - } - }, - { - // Gateway only — the predicate lives on the out-edge. - id: "has_deals", - type: "decision", - label: "Active Owner?" - }, - { - // Idempotency gate AND period lookup in one read: the row whose - // window contains today IS this owner's current-period snapshot. - id: "find_forecast", - type: "get_record", - label: "Current-Period Snapshot?", - config: { - objectName: "crm_forecast", - filter: CURRENT_PERIOD_FILTER, - outputVariable: "existingForecast" - } - }, - { - // Gateway only — the predicate lives on the out-edges. - id: "check_missing", - type: "decision", - label: "First Snapshot This Period?" - }, - { - // Only `period` is supplied: `forecast.hook.ts` derives - // period_start/period_end/period_label so the boundaries are - // calendar-true without the flow doing date arithmetic it - // cannot do. `quota` is omitted on purpose — see the header. - // A leaf node: the two mutually-exclusive edges out of - // `check_missing` both converge on `reload_forecast`, so the - // chain below runs exactly once on either path. - id: "create_forecast", - type: "create_record", - label: "Open Snapshot Row", - config: { - objectName: "crm_forecast", - fields: { - owner_id: cel14`currentOwner.id`, - // ORG PARTITION. A schedule trigger carries no - // organization, so without this the snapshot row is born - // `organization_id` NULL — outside every org partition, where - // an `(organization_id, …)` unique index does not constrain - // and org-scoped reads never see it. Upstream ruling - // objectstack#6155 Q2=A assigns the answer to the flow author. - // - // The source is `ownerAnyDeal`, NOT `currentOwner`. The loop - // item here is a `sys_user` row, and `sys_user` declares NO - // `organization_id` — identity is global, org-partitioned it - // is not (it carries `primary_business_unit_id` instead). - // On 17.x `{currentOwner.organization_id}` interpolated to - // `undefined` and landed as NULL: the publish guard, which only - // checks that the key is declared, went green over a row still - // born outside every partition (measured, not assumed). Under - // CEL that read fails the iteration instead. - // - // `ownerAnyDeal` is the `crm_opportunity` from `find_any_deal` - // — it carries the column, and edge `b2` (`ownerAnyDeal != - // null`) is the only route to this node, so it is never null - // here. Semantically right too: an owner's forecast belongs to - // the org their pipeline is in. - organization_id: cel14`ownerAnyDeal.organization_id`, - period: SNAPSHOT_PERIOD, - snapshot_date: cel14`isoDate(today())`, - source: "scheduled", - pipeline_amount: 0, - best_case_amount: 0, - commit_amount: 0, - closed_amount: 0 - } - } - }, - { - // Re-read rather than reuse the create output, so both paths - // (row already existed / row just created) hand the rest of the - // body ONE variable carrying the hook-derived period window. - // - // ⛔ Scope this to OWNED_PERIOD_FILTER, never to the gate's - // window: this read chooses the row that gets WRITTEN, and the - // sweep only ever owns its own. A miss binds `currentForecast` to - // null — `get_record` always binds — which is exactly what - // `check_owned` below is there to read. - id: "reload_forecast", - type: "get_record", - label: "Load Snapshot Row", - config: { - objectName: "crm_forecast", - filter: OWNED_PERIOD_FILTER, - outputVariable: "currentForecast" - } - }, - { - // Gateway only — the predicate lives on the out-edge. - // - // The stand-down gate. The window is handled either way by the - // time we get here; this asks whether the row handling it is the - // sweep's. Same single-out-edge skip shape as `has_deals`: when - // the only conditional edge does not match, the iteration ends and - // the engine records the unreached nodes as `skipped` with this - // node as `skippedBy` — so a stand-down is visible in the run log - // rather than silent. - id: "check_owned", - type: "decision", - label: "Sweep Owns This Row?" - }, - { - // Accumulators live in the flow-wide variable map (a loop body - // shares the enclosing scope), so they MUST be zeroed per owner - // or every rep inherits the previous rep's totals. - id: "reset_totals", - type: "assignment", - label: "Reset Totals", - config: { - assignments: { - pipelineTotal: 0, - bestCaseTotal: 0, - commitTotal: 0, - closedTotal: 0 - } - } - }, - ...BUCKETS.flatMap((b) => [b.find, b.sum]), - { - // Filter by id: `update_record` calls `data.update` without - // `options.multi`, so a filter matching more than one row fails - // (same constraint as demo_bootstrap / case_sla_monitor). - id: "write_snapshot", - type: "update_record", - label: "Write Snapshot", - config: { - objectName: "crm_forecast", - filter: { id: cel14`currentForecast.id` }, - fields: { - pipeline_amount: cel14`pipelineTotal`, - best_case_amount: cel14`bestCaseTotal`, - commit_amount: cel14`commitTotal`, - closed_amount: cel14`closedTotal`, - snapshot_date: cel14`isoDate(today())`, - source: "scheduled" - } - } - } - ], - edges: [ - // Loop-nested conditions are explicit CEL envelopes (`P`): the - // conversion pass that wraps bare strings only walks a flow's - // TOP-LEVEL edges, so a bare string in here would fall through to - // the legacy template path and compare as text — a gate that never - // opens, silently. - // - // These edges are the ONLY site for their predicates: a - // `decision` node's singular `config.condition` is never read, so a - // node-level copy would be inert metadata free to drift. - { id: "b1", source: "find_any_deal", target: "has_deals", type: "default" }, - // No matching edge simply ends this iteration, so a user with no - // live deal is skipped without a snapshot row. - { id: "b2", source: "has_deals", target: "find_forecast", type: "conditional", condition: P33`ownerAnyDeal != null`, label: "Active owner" }, - { id: "b3", source: "find_forecast", target: "check_missing", type: "default" }, - // Mutually exclusive, and both reach `reload_forecast` — never a - // default edge alongside a conditional one, which would traverse - // BOTH and double-count the whole chain. - { id: "b4", source: "check_missing", target: "create_forecast", type: "conditional", condition: P33`existingForecast == null`, label: "Open new row" }, - { id: "b5", source: "check_missing", target: "reload_forecast", type: "conditional", condition: P33`existingForecast != null`, label: "Refresh existing row" }, - { id: "b6", source: "create_forecast", target: "reload_forecast", type: "default" }, - { id: "b7", source: "reload_forecast", target: "check_owned", type: "default" }, - // The stand-down. No complementary edge, on purpose: the - // false branch is "this window belongs to a manual/ai row", and the - // whole point is that the sweep then does NOTHING — no write, and - // no second row. A variable-root null test, so no `has()` guard is - // needed: `reload_forecast` is a `get_record` and binds - // `currentForecast` unconditionally, to `null` on a miss. - { id: "b8", source: "check_owned", target: "reset_totals", type: "conditional", condition: P33`currentForecast != null`, label: "Sweep owns the row" }, - ...OWNER_CHAIN.slice(0, -1).map((source, i) => ({ - id: `c${i}`, - source, - target: OWNER_CHAIN[i + 1], - type: "default" - })) - ] - }) - } - }, - { id: "end", type: "end", label: "End" } - ], - edges: [ - { id: "e1", source: "start", target: "query_owners", type: "default" }, - { id: "e2", source: "query_owners", target: "loop_owners", type: "default" }, - { id: "e3", source: "loop_owners", target: "end", type: "default" } - ] -}; - -// src/sales/flows/lead-assignment.flow.ts -import { P as P34, cel as cel15 } from "@objectstack/spec"; -var LeadAssignmentFlow = { - name: "lead_assignment", - label: "New Lead Routing & SLA", - description: "On new lead: set a rating-based follow-up SLA and alert the lead owner.", - type: "record_change", - status: "active", - // A record-change flow fired by a SYSTEM write carries no trigger user - // either (ADR-0049). This is the population the flow is FOR: - // leads arrive from web-to-lead, a CSV import, a partner integration or a - // seed load, none of which carry a user session. Measured on 17.0.0-rc.2, a - // user-less run refuses `sla_hot` / `sla_std` outright, so the lead lands - // with no follow-up SLA and no alert at all — silently, since the refusal - // surfaces only in the server log. - // - // Elevating the USER-driven runs too is correct: the SLA stamp is the - // platform's routing decision about the row that just fired the trigger - // (keyed to `{record.id}`), not the submitting rep's own edit, and a rep who - // may create a lead is not thereby guaranteed edit rights on it. - runAs: "system", - variables: [], - nodes: [ - { - id: "start", - type: "start", - label: "Start (lead created)", - config: { objectName: "crm_lead", triggerType: "record-after-create" } - }, - { - // Branching lives on edges `e2` / `e3` — see the totality note there. - // This node carries no `config.condition`: the engine never evaluates a - // `decision` node's singular one, so a copy here would restate the gate - // without being the gate (17.0.0-rc.2's `flow-inert-node-condition`). - id: "check_hot", - type: "decision", - label: "Hot Lead (rating \u2265 4)?" - }, - // ── Hot path: 1-day SLA, high-severity alert ─────────────────── - { - id: "sla_hot", - type: "update_record", - label: "Set 1-Day SLA", - config: { objectName: "crm_lead", filter: { id: cel15`record.id` }, fields: { next_followup_date: cel15`isoDate(daysFromNow(1))` } } - }, - { - id: "notify_hot", - type: "notify", - label: "Alert \u2014 Hot Lead", - config: { - // Route to the lead's OWNER (a real user id). A CRM position like - // 'sales_manager' is NOT a messaging audience — the messaging service - // resolves user:/role:(sys_member)/team:/owner_of:, and a bare - // 'sales_manager' was stored verbatim as sys_inbox_message.user_id, - // matching no real user, so these alerts reached nobody. owner is set - // on insert (defaultValue os.user.id) and is the accountable party. - recipients: [cel15`record.owner_id`], - channels: ["inbox", "email"], - severity: "warning", - topic: "lead_routing", - template: "crm.lead_routing_hot", - templateData: { - first_name: cel15`record.first_name`, - last_name: cel15`record.last_name`, - company: cel15`record.company`, - rating: cel15`record.rating` - }, - actionUrl: "/crm_lead/{{record.id}}" - } - }, - // ── Standard path: 3-day SLA, normal alert ───────────────────── - { - id: "sla_std", - type: "update_record", - label: "Set 3-Day SLA", - config: { objectName: "crm_lead", filter: { id: cel15`record.id` }, fields: { next_followup_date: cel15`isoDate(daysFromNow(3))` } } - }, - { - id: "notify_std", - type: "notify", - label: "Alert \u2014 New Lead", - config: { - // Route to the lead's owner — see notify_hot for why a bare - // 'sales_manager' position never reached anyone. - recipients: [cel15`record.owner_id`], - channels: ["inbox"], - topic: "lead_routing", - template: "crm.lead_routing_new", - templateData: { - first_name: cel15`record.first_name`, - last_name: cel15`record.last_name`, - company: cel15`record.company` - }, - actionUrl: "/crm_lead/{{record.id}}" - } - }, - { id: "end", type: "end", label: "End" } - ], - edges: [ - { id: "e1", source: "start", target: "check_hot", type: "default" }, - // TOTALITY: these two edges must PARTITION every lead — a rating - // the predicate cannot read has to fall down one branch, never neither. - // Guarding both with `has(...) &&` would have traded a loud abort for a - // silent no-op (unrated lead → no SLA, no alert, no error), which is the - // "declared ≠ enforced" shape this repo keeps deleting rules over. So the - // hot branch demands a readable rating and the standard branch absorbs - // everything else: an unrated lead is, correctly, not a hot lead. - // - // `rating` is neither required nor defaulted, so a lead written without one - // is stored with NO `rating` column on driver-memory / driver-mongodb. - // Measured end-to-end: the unguarded `record.rating >= 4` aborted with `No - // such key: rating` and an unrated lead got no SLA stamp and no alert at - // all. `has()` alone is not enough on an ORDERING comparison — an explicit - // `rating: null` passes `has()` and then aborts with `no such overload: - // dyn >= int` — so both guards are required, in this order. - { id: "e2", source: "check_hot", target: "sla_hot", type: "conditional", condition: P34`has(record.rating) && record.rating != null && record.rating >= 4`, label: "Hot" }, - { id: "e3", source: "check_hot", target: "sla_std", type: "conditional", condition: P34`!has(record.rating) || record.rating == null || record.rating < 4`, label: "Standard" }, - { id: "e4", source: "sla_hot", target: "notify_hot", type: "default" }, - { id: "e5", source: "notify_hot", target: "end", type: "default" }, - { id: "e6", source: "sla_std", target: "notify_std", type: "default" }, - { id: "e7", source: "notify_std", target: "end", type: "default" } - ] -}; - -// src/sales/flows/contact-welcome.flow.ts -import { P as P35, cel as cel16 } from "@objectstack/spec"; -var ContactWelcomeFlow = { - name: "contact_welcome", - label: "Contact Welcome", - description: "On new contact: prompt the owner to welcome them.", - type: "record_change", - status: "active", - // A record-change flow fired by a SYSTEM write carries no trigger user - // either (ADR-0049) — and this flow exists FOR that - // population: the start condition below already documents the seeded / - // integration-written contacts whose `owner_id` the security middleware - // never stamped because the write carried no session. - // - // Measured honestly on 17.0.0-rc.2: this flow has NO data node today (start - // → notify → end), the runAs refusal covers get/create/update/delete only, - // and `notify` dispatches through the messaging service without a run data - // context — so a user-less run completes and delivers today, and this - // declaration changes nothing observable right now. It is declared anyway - // because the decision being recorded is "record-change automation runs as - // the platform", not "this flow currently happens to have no data node". - // The day a data node is added — or a start-node `config.expand`, which is - // the remedy the notify node's own error message recommends and which reads - // through the same guarded path — the elevation has already been reasoned - // about here rather than discovered as a refusal in production. Elevation is - // harmless for the user-driven runs: there is no data operation to scope. - runAs: "system", - variables: [], - nodes: [ - { - id: "start", - type: "start", - label: "Start (contact created)", - config: { - objectName: "crm_contact", - triggerType: "record-after-create", - // TOTALITY: every `record.x` read carries a `has(record.x)` - // guard — see the house-rule block in - // `test/flow-condition-totality.test.ts`. The absent-key case is real - // here, not hypothetical: `owner_id` is auto-stamped by the security - // middleware only on writes that CARRY a user, and a system write — - // seed data, an integration, a `runAs: 'system'` flow — short-circuits - // that middleware entirely. Such a row reaches driver-memory - // with NO `owner_id` column at all, so `record.owner_id != null` alone - // aborts with `No such key` and no seeded contact ever gets a welcome - // prompt. `!= null` is not a substitute for `has()`: on an absent key - // it aborts exactly like `== "v"` does. An absent `email_opt_out` - // means the contact has not opted out. - condition: P35`has(record.owner_id) && record.owner_id != null - && (!has(record.email_opt_out) || record.email_opt_out != true)` - } - }, - { - id: "send_welcome", - type: "notify", - label: "Prompt Owner to Welcome", - config: { - recipients: [cel16`record.owner_id`], - channels: ["inbox", "email"], - topic: "contact_welcome", - template: "crm.contact_welcome", - templateData: { first_name: cel16`record.first_name`, last_name: cel16`record.last_name` }, - actionUrl: "/crm_contact/{{record.id}}" - } - }, - { id: "end", type: "end", label: "End" } - ], - edges: [ - { id: "e1", source: "start", target: "send_welcome", type: "default" }, - { id: "e2", source: "send_welcome", target: "end", type: "default" } - ] -}; - -// src/sales/flows/opportunity-won-alert.flow.ts -import { P as P36, cel as cel17 } from "@objectstack/spec"; -var OpportunityWonAlertFlow = { - name: "opportunity_won_alert", - label: "Large Deal Won Alert", - description: "On closed_won opportunities of $100K or more: notify the owner \u2014 the owner alone, not their manager.", - type: "record_change", - status: "active", - // A record-change flow fired by a SYSTEM write carries no trigger user - // either (ADR-0049). Deals reach `closed_won` through - // machinery as well as through a rep's own save — `lead_conversion` and the - // `contract_renewal` sweep both write opportunities, and the latter is - // itself `runAs: 'system'`. - // - // Measured honestly on 17.0.0-rc.2: this flow has NO data node (start → - // notify → end), so the refusal does not reach it today and declaring - // `system` changes nothing observable. Declared for the same reason as - // `contact_welcome` — see the fuller note there. Nothing to scope, so - // elevating the user-driven runs costs nothing. - runAs: "system", - variables: [], - nodes: [ - { - id: "start", - type: "start", - label: "Start (opp updated)", - config: { - objectName: "crm_opportunity", - triggerType: "record-after-update", - // `previous.stage` guard: fire on the TRANSITION into closed_won only. - // Without it every later edit of a won deal (seed-ownership - // claims, approval-status stamps, description tweaks) re-sent the - // congratulations blast. The trigger forwards `previous` into the - // condition scope (cf. the engine's record-change context). - // TOTALITY: `has(...)` on every read, plus `!= null` on the - // ordering comparison (`has()` passes an explicit null and - // `record.amount >= 100000` then aborts with - // `no such overload: dyn >= int`). - // - // `previous.stage` is guarded FAIL-CLOSED — `has(previous.stage) &&`, - // not `!has(previous.stage) ||` — which is the opposite of how - // `record.stage` is guarded, deliberately. This term exists solely to - // suppress a re-fire, and the failure it was written for (a - // congratulations blast to management re-sent on every later edit of a - // won deal) is worse than a missed one. When the engine cannot see - // what the prior stage was it cannot see a TRANSITION either, so it - // must not claim one. In practice `previous` is a full prior row on - // every record-after-update; the shape this covers is a bulk - // `updateMany`, where ObjectQL never reads a prior row and `previous` - // arrives null — and firing one blast per row of a bulk update is - // exactly what nobody wants. - condition: P36`has(record.stage) && record.stage == "closed_won" - && has(previous.stage) && previous.stage != "closed_won" - && has(record.amount) && record.amount != null && record.amount >= ${LARGE_DEAL_AMOUNT}` - } - }, - { - // The `label` names what this node actually does: it notifies the owner - // and nobody else. The `id` keeps its original `notify_management` - // spelling on purpose — `edges[]` reference nodes by id, so renaming one - // is a behaviour change, not a wording fix. - id: "notify_management", - type: "notify", - label: "Notify Owner", - config: { - // Owner only: `{record.owner_id.manager}` cannot traverse a lookup on the - // raw trigger snapshot — it interpolates to the literal "undefined" - // and the message is delivered to a phantom user. - recipients: [cel17`record.owner_id`], - channels: ["inbox", "email"], - severity: "info", - topic: "large_deal_won", - template: "crm.large_deal_won", - templateData: { name: cel17`record.name`, amount: cel17`record.amount` }, - actionUrl: "/crm_opportunity/{{record.id}}" - } - }, - { id: "end", type: "end", label: "End" } - ], - edges: [ - { id: "e1", source: "start", target: "notify_management", type: "default" }, - { id: "e2", source: "notify_management", target: "end", type: "default" } - ] -}; - -// src/sales/flows/task-urgent-alert.flow.ts -import { P as P37, cel as cel18 } from "@objectstack/spec"; -var TaskUrgentAlertFlow = { - name: "task_urgent_alert", - label: "Urgent Task Alert", - description: "On new urgent task: notify the owner.", - type: "record_change", - status: "active", - // A record-change flow fired by a SYSTEM write carries no trigger user - // either (ADR-0049), and most urgent tasks in this app are - // machine-written: `case_status_side_effects` opens the escalation follow-up - // task, and the scheduled sweeps create their own — none of those writes - // carries a session. - // - // Measured honestly on 17.0.0-rc.2: this flow has NO data node (start → - // notify → end), so the refusal does not reach it today and declaring - // `system` changes nothing observable. Declared for the same reason as - // `contact_welcome` — see the fuller note there: the recorded decision is - // that record-change automation runs as the platform, so a data node added - // later inherits an elevation that was reasoned about rather than one - // discovered as a production refusal. No data operation exists to scope, so - // elevating the user-driven runs costs nothing. - runAs: "system", - variables: [], - nodes: [ - { - id: "start", - type: "start", - label: "Start (task created)", - config: { - objectName: "crm_task", - triggerType: "record-after-create", - // Gate on the `status` enum, not the `is_completed` boolean: on - // SQLite/libsql booleans persist as integer 1, so `is_completed != true` - // is `1 != true` = always true and the guard never trips (cf. the same - // hazard documented in case_escalation). - // TOTALITY: `has(...)` on every read. Both fields are `required` - // AND defaulted today, so this predicate measured total as authored — - // but that is a property of `crm_task`'s schema, not of the predicate. - // Drop either default and the flow goes silently inert on - // driver-memory / driver-mongodb, with nothing to catch it. An absent - // `status` is not `completed`, so it must not suppress the alert. - condition: P37`has(record.priority) && record.priority == "urgent" - && (!has(record.status) || record.status != "completed")` - } - }, - { - id: "notify_owner", - type: "notify", - label: "Notify Owner", - config: { - recipients: [cel18`record.owner_id`], - channels: ["inbox", "email"], - severity: "warning", - topic: "urgent_task", - template: "crm.urgent_task", - templateData: { subject: cel18`record.subject` }, - actionUrl: "/crm_task/{{record.id}}" - } - }, - { id: "end", type: "end", label: "End" } - ], - edges: [ - { id: "e1", source: "start", target: "notify_owner", type: "default" }, - { id: "e2", source: "notify_owner", target: "end", type: "default" } - ] -}; - -// src/sales/flows/task-due-reminder.flow.ts -import { cel as cel19 } from "@objectstack/spec"; -var TaskDueReminderFlow = { - name: "task_due_reminder", - label: "Task Due Reminder", - description: "Hourly sweep: notify owners of tasks whose reminder time has arrived.", - type: "schedule", - status: "active", - // Scheduled runs have no trigger user, so under the default runAs:'user' the - // data nodes execute UNSCOPED anyway. Declare runAs:'system' to make that - // RLS-bypassing elevation explicit and intended (ADR-0049). - runAs: "system", - variables: [], - nodes: [ - { - id: "start", - type: "start", - label: "Start (hourly)", - config: { schedule: "0 * * * *" } - }, - { - id: "query_due", - type: "get_record", - label: "Find Tasks Due for Reminder", - config: { - objectName: "crm_task", - // De-dup via `reminder_date` itself: the sweep notifies tasks whose - // reminder time has arrived, then CLEARS reminder_date (see mark_sent), - // so the row no longer matches `$lte` next tick. We do NOT filter on the - // `reminder_sent` boolean here — empirically, a where-clause on that - // (newly added) boolean column returns zero rows at runtime in this - // engine build, while the long-standing `is_completed` boolean works. - // Reusing the verified `$lte` + `is_completed` predicates keeps the - // sweep reliable; `reminder_sent` is still stamped for the audit trail. - filter: { - is_completed: false, - reminder_date: { $lte: cel19`isoDatetime(now())` } - }, - limit: 500, - outputVariable: "reminderList" - } - }, - { - // The loop body MUST be nested in `config.body` — a flat-graph loop - // (body omitted, iterator wired via outer edges) does NOT iterate or bind - // the iterator variable in the runtime (legacy no-op path), so - // `{currentTask.*}` resolves empty. Verified empirically. - id: "loop_tasks", - type: "loop", - label: "For Each Due Task", - config: { - collection: cel19`reminderList`, - iteratorVariable: "currentTask", - body: guarded("task", { - nodes: [ - { - id: "notify_owner", - type: "notify", - label: "Notify Owner", - config: { - recipients: [cel19`has(currentTask.owner_id) ? currentTask.owner_id : null`], - channels: ["inbox", "email"], - severity: "warning", - topic: "task_reminder", - template: "crm.task_reminder", - templateData: { - subject: cel19`currentTask.subject`, - reminder_date: cel19`currentTask.reminder_date` - }, - actionUrl: "/crm_task/{{currentTask.id}}" - } - }, - { - id: "mark_sent", - type: "update_record", - label: "Mark Reminder Sent", - config: { - objectName: "crm_task", - filter: { id: cel19`currentTask.id` }, - // Clearing reminder_date is what de-dups (the row stops matching - // the sweep's `$lte` next tick); reminder_sent is the audit flag. - fields: { reminder_sent: true, reminder_date: null } - } - } - ], - edges: [ - { id: "b1", source: "notify_owner", target: "mark_sent", type: "default" } - ] - }) - } - }, - { id: "end", type: "end", label: "End" } - ], - edges: [ - { id: "e1", source: "start", target: "query_due", type: "default" }, - { id: "e2", source: "query_due", target: "loop_tasks", type: "default" }, - { id: "e3", source: "loop_tasks", target: "end", type: "default" } - ] -}; - -// src/sales/flows/billing-handoff-closed-won.flow.ts -import { P as P38, cel as cel21 } from "@objectstack/spec"; - -// src/sales/flows/_billing-endpoint.ts -import { cel as cel20, expression as expression3 } from "@objectstack/spec"; -var BILLING_HANDOFF_ENDPOINT = process.env.HOTCRM_BILLING_ENDPOINT?.trim() || "https://billing.example.com/hotcrm/events"; -var BILLING_HANDOFF_SIGNING_SECRET = process.env.HOTCRM_BILLING_SIGNING_SECRET?.trim() || void 0; -var BILLING_HANDOFF_TIMEOUT_MS = 3e4; -var BILLING_HANDOFF_EVENT = { - opportunityClosedWon: "crm.opportunity.closed_won", - contractActivated: "crm.contract.activated" -}; -var BILLING_HANDOFF_PAYLOAD_VERSION = 1; -var BILLING_HANDOFF_LINE_ITEM_LIMIT = 200; -var ACCOUNT_FIELDS = [ - "id", - "name", - "account_number", - "billing_address", - "billing_country", - "phone", - "website" -]; -var LINE_ITEM_FIELDS = [ - "id", - "line_number", - "crm_product", - "description", - "quantity", - "list_price", - "unit_price", - "discount", - "total_price" -]; -var accountField = (field) => `has(billingAccount.${field}) ? billingAccount.${field} : null`; -var ACCOUNT_BLOCK = `{'id': billingAccount.id, 'name': billingAccount.name, 'account_number': billingAccount.account_number, 'billing_address': ${accountField("billing_address")}, 'billing_country': ${accountField("billing_country")}, 'phone': ${accountField("phone")}, 'website': ${accountField("website")}}`; -var billingBody = (event, key, fields) => expression3( - `{'event': dyn('${event}'), 'version': dyn(${BILLING_HANDOFF_PAYLOAD_VERSION}), 'occurred_at': dyn(isoDatetime(now())), '${key}': dyn({${fields.map((f) => typeof f === "string" ? [f, f] : f).map(([k, f]) => `'${k}': record.${f}`).join(", ")}}), 'account': dyn(${ACCOUNT_BLOCK}), 'line_items': billingLineItems}` -); -var loadAccountNode = () => ({ - id: "load_account", - type: "get_record", - label: "Load Account", - config: { - objectName: "crm_account", - filter: { id: cel20`record.crm_account` }, - fields: ACCOUNT_FIELDS, - // No `limit`: `get_record` calls `findOne` below 2 and binds the single row - // itself, which is what the account block's `billingAccount.FIELD` reads need. - outputVariable: "billingAccount" - } -}); - -// src/sales/flows/billing-handoff-closed-won.flow.ts -var BillingHandoffClosedWonFlow = { - name: "billing_handoff_closed_won", - label: "Billing Hand-off: Closed Won", - description: "On the transition into closed_won: POST the deal, its account and its line items to the billing endpoint via the durable HTTP outbox.", - type: "record_change", - status: "active", - // A record-change flow fired by a SYSTEM write carries no trigger user - // (ADR-0049), and opportunities reach `closed_won` through - // machinery as well as a rep's own save — `lead_conversion` writes them, and - // the `contract_renewal` sweep is itself `runAs: 'system'`. This flow has two - // data nodes, so under the default `runAs: 'user'` those reads would be - // REFUSED on exactly those runs and the hand-off would vanish silently. The - // hand-off must also see the WHOLE deal, not the slice the closing rep may - // read: an RLS-scoped line-item query that returns three of five rows would - // under-bill the customer without failing anything. - runAs: "system", - variables: [ - // Bound with a default so the payload key always exists. Not strictly - // needed here (this flow always runs the read) — declared for symmetry with - // the contract flow, where the read is conditional, so the two payloads - // cannot drift into different shapes for an empty item list. - { name: "billingLineItems", type: "collection", isInput: false, isOutput: false, defaultValue: [] } - ], - nodes: [ - { - id: "start", - type: "start", - label: "Start (opportunity updated)", - config: { - objectName: "crm_opportunity", - triggerType: "record-after-update", - // TRANSITION, not current value — see the file header. `previous.stage` - // is guarded fail-closed: no visible prior stage means no visible - // transition, so no hand-off. - condition: P38`has(record.stage) && record.stage == "closed_won" - && has(previous.stage) && previous.stage != "closed_won"` - } - }, - loadAccountNode(), - { - id: "load_line_items", - type: "get_record", - label: "Load Line Items", - config: { - objectName: "crm_opportunity_line_item", - filter: { crm_opportunity: cel21`record.id` }, - fields: LINE_ITEM_FIELDS, - // > 1 is what makes `get_record` issue a `find` and bind an ARRAY; - // omit it and the node calls `findOne` and binds a single row. - limit: BILLING_HANDOFF_LINE_ITEM_LIMIT, - outputVariable: "billingLineItems" - } - }, - { - // The node id becomes the delivery's `X-Objectstack-Event` header - // (`flow:`), so it is named for the event and not for the verb. - id: "send_closed_won_handoff", - type: "http", - label: "Enqueue Billing Hand-off", - config: { - url: BILLING_HANDOFF_ENDPOINT, - method: "POST", - // The whole point of this route: enqueue on `sys_http_delivery` rather - // than call inline, so a receiver that is down gets the delivery when - // it comes back instead of losing it. - durable: true, - timeoutMs: BILLING_HANDOFF_TIMEOUT_MS, - signingSecret: BILLING_HANDOFF_SIGNING_SECRET, - // One envelope building the whole payload (see `billingBody`). Each - // read is the value itself, never its stringification, so the amount - // stays a number and the line items an array. - body: billingBody(BILLING_HANDOFF_EVENT.opportunityClosedWon, "opportunity", [ - "id", - "name", - "amount", - "close_date", - "stage", - "type", - ["account_id", "crm_account"], - "owner_id" - ]) - } - }, - { id: "end", type: "end", label: "End" } - ], - edges: [ - { id: "e1", source: "start", target: "load_account", type: "default" }, - { id: "e2", source: "load_account", target: "load_line_items", type: "default" }, - { id: "e3", source: "load_line_items", target: "send_closed_won_handoff", type: "default" }, - { id: "e4", source: "send_closed_won_handoff", target: "end", type: "default" } - ] -}; - -// src/revenue/flows/quote-generation.flow.ts -import { P as P39, expression as expression4, cel as cel22 } from "@objectstack/spec"; -var DISCOUNT = "(!has(vars.discount) || isBlank(vars.discount) ? 0.0 : double(vars.discount))"; -var ADVANCE = `has(vars.oppRecord) && has(vars.oppRecord.stage) - && (vars.oppRecord.stage == "prospecting" || vars.oppRecord.stage == "qualification" || vars.oppRecord.stage == "needs_analysis") - && (!has(vars.oppRecord.approval_status) || vars.oppRecord.approval_status != "pending")`; -var QuoteGenerationFlow = { - name: "quote_generation", - label: "Generate Quote from Opportunity", - description: "Create a quote based on opportunity details", - type: "screen", - status: "active", - variables: [ - // MUST be `recordId` — the console's flow-action trigger contract seeds - // only that name ({ recordId, objectName }); a custom name like - // `opportunityId` arrives undefined. - { name: "recordId", type: "text", isInput: true, isOutput: false }, - { name: "quoteName", type: "text", isInput: true, isOutput: false }, - { name: "expirationDays", type: "number", isInput: true, isOutput: false }, - { name: "discount", type: "number", isInput: true, isOutput: false } - ], - nodes: [ - { id: "start", type: "start", label: "Start", config: { objectName: "crm_opportunity" } }, - // ─── The 立项 (qualification) gate, REQ-0006 step 11 (#2032) ───────── - // - // 「新增商机可跟进，立项通过后方可更新阶段、投标、赢丢单操作。」 Ruled (hotcrm-R74b - // item 2, B): before 立项 is approved, Generate Quote REFUSES and creates - // nothing. Steps 15 and 18 put quoting after the deal's approval too. - // - // Why the refusal is HERE, ahead of the form and of every writer: this - // flow writes the quote BEFORE the stage, and a flow carries no - // transaction (ADR-0077). With the gate armed, `opportunity_lifecycle` - // refuses the `update_opportunity` stage write — so the run used to fail - // AFTER `create_quote` had landed: measured on 17.7.0 as a sales_rep, - // `FLOW_FAILED` 400 at `update_opportunity` ("This deal needs - // qualification approval first …"), one draft quote left behind, the - // stage unchanged. ⛔ Not #2015's keep-stage-and-quote: that lock does - // not hold quoting, this gate does. - // - // The flow is the one choke point every door reaches — the record-header - // and list-row buttons and `POST /automation/quote_generation/trigger` — - // so the refusal lives here and `generate_quote` stays visible: hiding - // it would leave the rep a missing button with no reason, because an - // action's `visible` / `disabled` are bare predicates with nowhere to - // put a sentence. - // - // The FILTER is the gate's reading, the one `opportunity_lifecycle` - // applies: `pending` or `rejected` holds the deal (an approver's "no" is - // not a release), every other value — the shipped `not_required`, - // `approved`, none at all — does not. So `held` binds the deal only while - // it is held, and `null` otherwise; `test/flow-quote.test.ts` pins that - // the two answer alike, verdict by verdict. - // - // A read of its own, at click time. ⛔ Do not fold it into - // `get_opportunity`: that read stays AFTER the screen so the pricing and - // the #2015 approval branch (`e4a` / `e4b`) see the deal as it is at - // submit. The verdict cannot drift toward held while the form is open: - // `not_required` and `approved` are never written back to `pending`. - { id: "get_held", type: "get_record", label: "Get Held Deal", config: { objectName: "crm_opportunity", filter: { id: cel22`recordId`, qualification_approval_status: { $in: ["pending", "rejected"] } }, outputVariable: "held" } }, - // A first-class refusal (`EndConfigSchema` `outcome: 'refused'`): the run - // ends `refused`, never `failed` and never parked, nothing is written, - // and the console shows the message with Close only — no Submit and no - // "completed" toast, which is what a message-only screen would give. It - // names the next step the `opportunity_lifecycle` refusal of this gate - // names. - // - // Translated: since 18.0.0-next.0 the `flows` translation group keys an - // `end` node's refusal as `refusals.refuse_held.message`, which the - // engine renders in the run's locale (at 17.7.0 it had no such key, the - // gap raised from #2032). The console titles the dialog with the action's - // translated label. ⛔ Do not re-route the refusal through a screen to - // borrow a translatable title. - { id: "refuse_held", type: "end", label: "Quote Refused", config: { outcome: "refused", message: "Qualification approval comes first: tick Request Qualification Approval. Nothing was created." } }, - { - id: "screen_1", - type: "screen", - label: "Quote Details", - config: { - fields: [ - { name: "quoteName", label: "Quote Name", type: "text", required: true }, - { name: "expirationDays", label: "Valid For (Days)", type: "number", required: true, defaultValue: 30 }, - // The ceiling is a HARD block with no override - // (`crm_quote.discount_within_ceiling`), so until it is written here - // a rep meets the number only by having the quote refused. Both - // strings below interpolate `QUOTE_DISCOUNT_CEILING` — imported, - // never retyped, the same rule the two object rules follow — so the - // hint cannot drift from the rule it describes. - // - // ⛔ There is deliberately NO `max`, and adding one does not work: - // `ScreenFieldConfigSchema` is STRICT at 17.3.0 and its entire key - // set is `name` / `label` / `type` / `required` / `options` / - // `defaultValue` / `placeholder` / `visibleWhen`. `max` is rejected - // BY NAME (`Unrecognized key(s) on this screen field: max`), so - // it fails `pnpm validate` rather than quietly doing nothing, and - // the executor forwards no such key into the `ScreenSpec` the client - // renders. `helpText` is rejected the same way — the console's - // dialog would render one, but no flow screen can carry it there. - // - // That leaves two carriers, and the label is the load-bearing one: - // `placeholder` renders only while the input is empty and - // `defaultValue: 0` seeds it, so it surfaces for the moment the rep - // clears the box to type — real, but not enough on its own. - { - name: "discount", - label: `Discount % (\u2264 ${QUOTE_DISCOUNT_CEILING})`, - type: "percent", - defaultValue: 0, - placeholder: `0-${QUOTE_DISCOUNT_CEILING}` - } - ] - } - }, - { - id: "get_opportunity", - type: "get_record", - label: "Get Opportunity", - config: { objectName: "crm_opportunity", filter: { id: cel22`recordId` }, outputVariable: "oppRecord" } - }, - { - id: "create_quote", - type: "create_record", - label: "Create Quote", - config: { - objectName: "crm_quote", - fields: { - name: cel22`quoteName`, - crm_opportunity: cel22`recordId`, - crm_account: cel22`oppRecord.crm_account`, - crm_contact: cel22`has(oppRecord.primary_contact) ? oppRecord.primary_contact : null`, - owner_id: cel22`current_user.id`, - status: "draft", - quote_date: cel22`isoDate(today())`, - expiration_date: cel22`isoDate(addDays(today(), expirationDays))`, - // `subtotal` is a bare path pass-through and needs no rounding: it - // copies `crm_opportunity.amount` as stored and does no arithmetic, - // so it adds no floating-point tail of its own. - // `discount` is an optional screen answer: a resume may leave it - // unbound, which the template wrote as nothing and the guard writes - // as null (the quote field has no default, so the two agree). - subtotal: cel22`oppRecord.amount`, - discount: cel22`has(vars.discount) ? discount : null`, - // ⛔ A currency × percentage MUST be rounded to whole cents inside the - // expression — the flow hands the engine a money amount, never an - // unrounded double. `discount / 100` is inexact for every percentage - // whose hundredth is not a dyadic rational, so a BARE product carries - // a tail: 180,000 at 30% is 125999.99999999999. While these fields - // declared `scale: 2` the insert was rejected for it (`Total Price - // must have at most 2 decimal places (got 11)`, #1206). Currency - // fields no longer declare `scale` — the platform refuses it, a - // currency's decimals are its ISO 4217 minor unit (#1965) — so the - // write is now ACCEPTED and the tail would be stored silently. The - // rounding keeps `discount_amount` / `total_price` whole-cent amounts. - // - // Both are CEL value envelopes. CEL's `round()` is INTEGER-ONLY and - // single-argument, and it returns an INT — so the divisor MUST be - // the decimal `100.0`. ⛔ Never `/ 100`: in CEL int / int is integer - // division, which silently drops the cents (1,234.56 at 10% would - // store 123, not 123.46; `test/flow-quote.test.ts` pins it). ⛔ Not - // `round(x, 2)` either: there is no precision form, and it fails - // loudly. `double()` types the amount, which some drivers return as - // a string. A cleared discount (null / absent / "") prices as 0%, as - // it did before; the `has()` guard is what keeps that TOTAL. - // - // ⭐ This shape applies ANYWHERE a flow multiplies a currency by a - // percentage. Write the rounding, not the bare product. - discount_amount: expression4(`round(double(oppRecord.amount) * (${DISCOUNT} / 100.0) * 100.0) / 100.0`, "cel"), - total_price: expression4(`round(double(oppRecord.amount) * (1.0 - ${DISCOUNT} / 100.0) * 100.0) / 100.0`, "cel"), - payment_terms: "net_30" - }, - outputVariable: "quoteId" - } - }, - { - // Advance to `proposal` only from a PRE-proposal stage (the state machine - // allows `→ proposal` from all three). ⛔ Never re-write `proposal` on a - // deal already at proposal/negotiation: that is an illegal self/backward - // transition. Those deals keep their stage; the quote is still created. - // - // ⛔ Nor on a deal AWAITING APPROVAL (`approval_status == "pending"`). A - // deal of `LARGE_DEAL_AMOUNT` or more is held by `opportunity_approval`'s - // approval node (`lockRecord: true`) until a manager decides, and the - // lock refuses this run's stage write — the run is the rep's - // (`runAs: 'user'`), and the lock is the approval working as intended. - // `create_quote` has already landed by then and a flow carries no - // transaction (ADR-0077), so the refusal used to fail the run AFTER the - // quote existed: measured on 17.7.0, `FLOW_FAILED` 400 `RECORD_LOCKED` - // at `update_opportunity`, the rep told the quote failed, and the draft - // quote left standing (#2015). A deal under review keeps its stage - // exactly like a deal already at proposal; the quote is still created — - // the button is offered at every open stage, and a draft quote commits - // nothing the approval is there to hold. `approval_status` is the lock's - // own mirror (`approvalStatusField`): the approvals plugin stamps - // `pending` when it opens the locking request and a terminal verdict - // when it releases it. - // - // The predicate itself lives on edges `e4a` / `e4b` — a `decision` node's - // singular `config.condition` is never evaluated, so a copy here would be - // inert (17.0.0-rc.2's `flow-inert-node-condition`). The totality - // rationale is on those edges, where the guards are. - id: "check_stage", - type: "decision", - label: "Can Advance to Proposal?" - }, - { - id: "update_opportunity", - type: "update_record", - label: "Update Opportunity", - config: { - // ⛔ No `last_activity_date` write: `crm_opportunity` has no such field - // (it lives on `crm_account`), and an unknown column fails this node. - objectName: "crm_opportunity", - filter: { id: cel22`recordId` }, - fields: { stage: "proposal" } - } - }, - { - // ADR-0012: deliver via the `notify` node (inbox + email). The legacy - // `script` + `actionType:'email'` shape is a no-op stub in 7.4. - id: "notify_owner", - type: "notify", - label: "Send Notification", - config: { - recipients: [cel22`current_user.id`], - channels: ["inbox", "email"], - topic: "quote_created", - template: "crm.quote_created", - templateData: { quote_name: cel22`quoteName` }, - actionUrl: "/crm_quote/{{quoteId.id}}" - } - }, - { id: "end", type: "end", label: "End" } - ], - edges: [ - // ⛔ A retired edge's id stays VACANT: `e1` (start → screen_1) is one. - // Every surviving edge keeps its id, and a new one takes the next id after - // the highest in use — a duplicate id is inert, so nothing would flag it. - { id: "e7", source: "start", target: "get_held", type: "default" }, - // ── The 立项 gate (#2032) ────────────────────────────────────────── - // - // COMPLEMENTARY CONDITIONALS off a plain data node, not a `decision` — the - // shape `billing-handoff-contract-activated.flow.ts` records: they are - // evaluated one by one, and `!= null` / `== null` partition exactly. - // `get_held` dominates both and binds `held` on every path — the row, or - // `null` on a miss — so neither read takes a `has()` guard: the - // get_record-dominated case `test/flow-variable-conditions.test.ts` - // records as needing none, written like `lead_conversion`'s `e5` / `e6`. - // Fail-OPEN like the hook: a deal the read cannot see goes on to the form - // and fails at `create_quote` exactly as it always did. - { id: "e9", source: "get_held", target: "refuse_held", type: "default", condition: P39`vars.held != null`, label: "Held" }, - { id: "e10", source: "get_held", target: "screen_1", type: "default", condition: P39`vars.held == null`, label: "Not held" }, - { id: "e2", source: "screen_1", target: "get_opportunity", type: "default" }, - { id: "e3", source: "get_opportunity", target: "create_quote", type: "default" }, - { id: "e4", source: "create_quote", target: "check_stage", type: "default" }, - // The two branches must PARTITION, so the keep side is the advance side - // negated whole (`ADVANCE` above): `has(…) && …` advances and everything - // else keeps. An unknown stage therefore lands on "keep stage" — the quote - // is still created and nothing illegal is written to the state machine. - // These EDGES are the live sites; `check_stage` carries no - // `config.condition` at all, because the engine never evaluates one. - // - // TOTALITY: `oppRecord` is a `get_record` OUTPUT — `findOne` answers - // a miss with `null`, and reading a field off it then aborts with `No such - // key: stage`. Measured unreachable TODAY only because two neighbouring - // schemas happen to close it: `crm_opportunity.stage` is `required` (never - // a sparse column) and `crm_quote.crm_account` is `required`, so a null - // `oppRecord` makes `create_quote` fail one node earlier. Both are one - // `required: false` away from re-opening it, so the predicate carries its - // own guard — and from 17.0.0-rc.2 an unevaluable condition aborts the step - // instead of skipping it, so the guard is load-bearing, not - // decorative. Note the scope is `vars.oppRecord`, not bare `oppRecord`: - // measured, `has(oppRecord.stage)` still aborts with `Unknown variable: - // oppRecord` when the variable is unbound, while `has(vars.oppRecord)` - // answers `false` — only the `vars.`-scoped form is total against both - // hazards. - // - // The approval term (see `check_stage`) is guarded the same way: an absent - // or null `approval_status` is "not under approval" and advances, as it - // did before the term existed. - { id: "e4a", source: "check_stage", target: "update_opportunity", type: "conditional", condition: expression4(ADVANCE, "cel"), label: "Advance" }, - { id: "e4b", source: "check_stage", target: "notify_owner", type: "conditional", condition: expression4(`!(${ADVANCE})`, "cel"), label: "Keep stage" }, - { id: "e5", source: "update_opportunity", target: "notify_owner", type: "default" }, - { id: "e6", source: "notify_owner", target: "end", type: "default" } - ] -}; - -// src/revenue/flows/contract-renewal.flow.ts -import { P as P40, cel as cel23 } from "@objectstack/spec"; -var ContractRenewalFlow = { - name: "contract_renewal", - label: "Contract Renewal Reminder", - description: "Daily sweep: open renewal tasks/opportunities for contracts nearing end_date.", - type: "schedule", - status: "active", - // Scheduled runs have no trigger user, so under the default runAs:'user' the - // data nodes execute UNSCOPED anyway. Declare runAs:'system' to make that - // RLS-bypassing elevation explicit and intended (ADR-0049). - runAs: "system", - variables: [], - nodes: [ - { id: "start", type: "start", label: "Start (daily 08:00)", config: { schedule: "0 8 * * *" } }, - { - // Broad pre-filter (next 120 days — ⛔ must cover the LARGEST - // renewal_notice_days in use; seeds go up to 90). The per-record notice - // window is applied in the decision node below so each contract honours - // its own renewal_notice_days. A pre-filter narrower than the largest - // notice period silently truncates it: a 90-day contract stays invisible - // until 60 days out. - id: "query_contracts", - type: "get_record", - label: "Find Expiring Contracts", - config: { - objectName: "crm_contract", - filter: { status: "activated", end_date: { $gte: cel23`isoDate(today())`, $lte: cel23`isoDate(daysFromNow(120))` } }, - limit: 500, - outputVariable: "contractList" - } - }, - { - id: "loop_contracts", - type: "loop", - label: "For Each Contract", - config: { - collection: cel23`contractList`, - iteratorVariable: "currentContract", - body: guarded("contract", { - nodes: [ - { - // Gateway only — the predicate lives on the out-edge. - id: "check_notice_window", - type: "decision", - label: "Within Notice Window?" - }, - { - // Idempotency gate: the sweep matches the same contract every day - // of its notice window, so ⛔ without it every day produces a - // duplicate task + notification (and, below, a duplicate - // pipeline-inflating renewal opportunity). An open renewal task - // for this contract means this window was already handled. - id: "find_existing_task", - type: "get_record", - label: "Already Reminded?", - config: { - objectName: "crm_task", - filter: { - related_to_account: cel23`currentContract.crm_account`, - subject: cel23`'Renewal due: contract ' + currentContract.contract_number`, - status: { $nin: ["completed"] } - }, - outputVariable: "existingRenewalTask" - } - }, - { - // Gateway only — the predicate lives on the out-edge. - id: "check_not_reminded", - type: "decision", - label: "First Reminder?" - }, - { - id: "create_renewal_task", - type: "create_record", - label: "Create Renewal Task", - config: { - objectName: "crm_task", - fields: { - subject: cel23`'Renewal due: contract ' + currentContract.contract_number`, - type: "follow_up", - priority: "high", - status: "not_started", - due_date: cel23`currentContract.end_date`, - owner_id: cel23`has(currentContract.owner_id) ? currentContract.owner_id : null`, - // ORG PARTITION. A schedule trigger carries no - // organization, so the engine has nothing to fill this from - // and the row would be born `organization_id` NULL — outside - // every org partition, where an `(organization_id, …)` unique - // index does not constrain and org-scoped reads never see it. - // Upstream ruling objectstack#6155 Q2=A puts the answer here, - // with the flow author: a renewal task belongs to the org of - // the contract that spawned it. Fill-only precedence means an - // author-set value wins over the engine (objectstack#6153). - // The source MUST be a row that actually carries the column. - // On 17.x an absent key interpolated to `undefined` and landed - // as NULL, which satisfied the publish guard while reproducing - // the bug; the CEL read below fails the iteration instead, and - // it is deliberately left UNGUARDED — a `has()` guard would - // write that NULL back. `crm_contract` carries it; `sys_user` - // does not. - organization_id: cel23`currentContract.organization_id`, - related_to_type: "crm_account", - related_to_account: cel23`currentContract.crm_account` - } - } - }, - { - id: "notify_owner", - type: "notify", - label: "Notify Owner", - config: { - recipients: [cel23`has(currentContract.owner_id) ? currentContract.owner_id : null`], - channels: ["inbox", "email"], - topic: "contract_renewal", - template: "crm.contract_renewal", - templateData: { - contract_number: cel23`currentContract.contract_number`, - end_date: cel23`currentContract.end_date` - }, - actionUrl: "/crm_contract/{{currentContract.id}}" - } - }, - { - // Gateway only — the predicate lives on the out-edge. - id: "check_auto_renewal", - type: "decision", - label: "Auto-Renewal On?" - }, - { - // Second gate: never open a second renewal opportunity while one - // is still in flight for this account (belt-and-braces for the - // case where the task was completed but the deal is still open). - id: "find_existing_renewal_opp", - type: "get_record", - label: "Open Renewal Deal Exists?", - config: { - objectName: "crm_opportunity", - filter: { - crm_account: cel23`currentContract.crm_account`, - type: "existing_renewal", - stage: { $nin: ["closed_won", "closed_lost"] } - }, - outputVariable: "existingRenewalOpp" - } - }, - { - // Gateway only — the predicate lives on the out-edge. - id: "check_no_open_renewal", - type: "decision", - label: "No Open Renewal Deal?" - }, - { - id: "create_renewal_opp", - type: "create_record", - label: "Open Renewal Opportunity", - config: { - objectName: "crm_opportunity", - fields: { - name: cel23`'Renewal — ' + currentContract.contract_number`, - crm_account: cel23`currentContract.crm_account`, - amount: cel23`currentContract.contract_value`, - stage: "proposal", - type: "existing_renewal", - close_date: cel23`currentContract.end_date`, - owner_id: cel23`has(currentContract.owner_id) ? currentContract.owner_id : null`, - // ORG PARTITION — see `create_renewal_task` above. - // The renewal deal belongs to the same org as the contract. - organization_id: cel23`currentContract.organization_id`, - next_step: "Confirm renewal terms with customer" - } - } - } - ], - edges: [ - // Only act when inside the per-contract notice window; gates with - // no matching edge simply end the iteration, so the loop moves on. - // - // The EDGE is the ONLY site: a `decision` node's singular - // `config.condition` is never read — the executor reads the plural - // `config.conditions[]` and nothing else — so a copy on the node - // would be inert metadata that drifts silently. `check_notice_window` - // is therefore a bare gateway and this predicate is authored once. - // - // `end_date` is a DATE field and arrives as `YYYY-MM-DD`, but CEL's - // `timestamp()` only accepts a full ISO 8601 datetime and throws - // otherwise ("timestamp() requires a string in ISO 8601 format"). - // Appending the time part is what makes this evaluate instead of - // blowing up mid-sweep. - // - // TOTALITY: `currentContract` is a LOOP ITEM over - // `contractList`, which `get_record` filled from `data.find` — - // every element is a raw driver row, sparse in exactly the way - // a raw driver row is. `end_date` is `required` on `crm_contract` so - // that column is always written, but `renewal_notice_days` - // (`defaultValue: 30`) and `auto_renewal` (`defaultValue: false`) - // are only DEFAULTED, and a row written before the default existed - // carries neither the column nor a value. Both operands - // additionally need `!= null`, because the abort here is not the - // usual overload error: `null + "T00:00:00Z"` and `int(null)` each - // blow up inside the function call, one contract into a 500-row - // sweep, taking the whole scheduled run with them. - { id: "b1", source: "check_notice_window", target: "find_existing_task", type: "conditional", condition: P40`has(vars.currentContract) && has(vars.currentContract.end_date) && has(vars.currentContract.renewal_notice_days) - && vars.currentContract.end_date != null && vars.currentContract.renewal_notice_days != null - && timestamp(vars.currentContract.end_date + "T00:00:00Z") <= daysFromNow(int(vars.currentContract.renewal_notice_days))`, label: "In window" }, - { id: "b2", source: "find_existing_task", target: "check_not_reminded", type: "default" }, - { id: "b3", source: "check_not_reminded", target: "create_renewal_task", type: "conditional", condition: P40`existingRenewalTask == null`, label: "First reminder" }, - { id: "b4", source: "create_renewal_task", target: "notify_owner", type: "default" }, - { id: "b5", source: "notify_owner", target: "check_auto_renewal", type: "default" }, - // TOTALITY: same loop item, same sparse driver row. Only an - // explicit `true` opens a renewal deal, so an absent column reads - // as "auto-renewal off" — the conservative branch. - { id: "b6", source: "check_auto_renewal", target: "find_existing_renewal_opp", type: "conditional", condition: P40`has(vars.currentContract) && has(vars.currentContract.auto_renewal) - && vars.currentContract.auto_renewal == true`, label: "Auto-renew" }, - { id: "b7", source: "find_existing_renewal_opp", target: "check_no_open_renewal", type: "default" }, - { id: "b8", source: "check_no_open_renewal", target: "create_renewal_opp", type: "conditional", condition: P40`existingRenewalOpp == null`, label: "Open renewal deal" } - ] - }) - } - }, - { id: "end", type: "end", label: "End" } - ], - edges: [ - { id: "e1", source: "start", target: "query_contracts", type: "default" }, - { id: "e2", source: "query_contracts", target: "loop_contracts", type: "default" }, - { id: "e3", source: "loop_contracts", target: "end", type: "default" } - ] -}; - -// src/revenue/flows/quote-expiration.flow.ts -import { cel as cel24 } from "@objectstack/spec"; -var QuoteExpirationFlow = { - name: "quote_expiration", - label: "Quote Auto-Expiration", - description: "Daily: expire quotes past their expiration_date that are still open.", - type: "schedule", - status: "active", - // Scheduled runs have no trigger user, so under the default runAs:'user' the - // data nodes execute UNSCOPED anyway. Declare runAs:'system' to make that - // RLS-bypassing elevation explicit and intended (ADR-0049). - runAs: "system", - variables: [], - nodes: [ - { id: "start", type: "start", label: "Start (daily 01:00)", config: { schedule: "0 1 * * *" } }, - { - id: "query_quotes", - type: "get_record", - label: "Find Expired Quotes", - config: { - objectName: "crm_quote", - filter: { status: { $nin: ["accepted", "rejected", "expired"] }, expiration_date: { $lt: cel24`isoDate(today())` } }, - limit: 500, - outputVariable: "quoteList" - } - }, - { - id: "loop_quotes", - type: "loop", - label: "For Each Quote", - config: { - collection: cel24`quoteList`, - iteratorVariable: "currentQuote", - body: guarded("quote", { - nodes: [ - { - id: "mark_expired", - type: "update_record", - label: "Mark Expired", - config: { objectName: "crm_quote", filter: { id: cel24`currentQuote.id` }, fields: { status: "expired" } } - } - ], - edges: [] - }) - } - }, - { id: "end", type: "end", label: "End" } - ], - edges: [ - { id: "e1", source: "start", target: "query_quotes", type: "default" }, - { id: "e2", source: "query_quotes", target: "loop_quotes", type: "default" }, - { id: "e3", source: "loop_quotes", target: "end", type: "default" } - ] -}; - -// src/revenue/flows/contract-expiration.flow.ts -import { cel as cel25 } from "@objectstack/spec"; -var ContractExpirationFlow = { - name: "contract_expiration", - label: "Contract Auto-Expiration", - description: "Daily: expire activated contracts past their end_date and notify the owner.", - type: "schedule", - status: "active", - // Scheduled runs have no trigger user, so under the default runAs:'user' the - // data nodes execute UNSCOPED anyway. Declare runAs:'system' to make that - // RLS-bypassing elevation explicit and intended (ADR-0049). - runAs: "system", - variables: [], - nodes: [ - { id: "start", type: "start", label: "Start (daily 00:00)", config: { schedule: "0 0 * * *" } }, - { - id: "query_contracts", - type: "get_record", - label: "Find Expired Contracts", - config: { - objectName: "crm_contract", - filter: { status: "activated", end_date: { $lt: cel25`isoDate(today())` } }, - limit: 500, - outputVariable: "contractList" - } - }, - { - id: "loop_contracts", - type: "loop", - label: "For Each Contract", - config: { - collection: cel25`contractList`, - iteratorVariable: "currentContract", - body: guarded("contract", { - nodes: [ - { - id: "mark_expired", - type: "update_record", - label: "Mark Expired", - config: { objectName: "crm_contract", filter: { id: cel25`currentContract.id` }, fields: { status: "expired" } } - }, - { - id: "notify_owner", - type: "notify", - label: "Notify Owner", - config: { - recipients: [cel25`has(currentContract.owner_id) ? currentContract.owner_id : null`], - channels: ["inbox", "email"], - topic: "contract_expired", - template: "crm.contract_expired", - templateData: { contract_number: cel25`currentContract.contract_number` }, - actionUrl: "/crm_contract/{{currentContract.id}}" - } - } - ], - edges: [ - { id: "b1", source: "mark_expired", target: "notify_owner", type: "default" } - ] - }) - } - }, - { id: "end", type: "end", label: "End" } - ], - edges: [ - { id: "e1", source: "start", target: "query_contracts", type: "default" }, - { id: "e2", source: "query_contracts", target: "loop_contracts", type: "default" }, - { id: "e3", source: "loop_contracts", target: "end", type: "default" } - ] -}; - -// src/revenue/flows/billing-handoff-contract-activated.flow.ts -import { P as P41, cel as cel26 } from "@objectstack/spec"; -var BillingHandoffContractActivatedFlow = { - name: "billing_handoff_contract_activated", - label: "Billing Hand-off: Contract Activated", - description: "On the transition into activated: POST the contract, its account and the originating deal\u2019s line items to the billing endpoint via the durable HTTP outbox.", - type: "record_change", - status: "active", - // Contracts are activated by machinery as well as by hand — `contract.hook.ts` - // stamps the account promotion and signed date on that same transition, and - // the renewal sweep runs `runAs: 'system'`. A system write carries no trigger - // user, so under the default `runAs: 'user'` this flow's two reads would be - // refused on exactly those runs and the hand-off would disappear without a - // failed step. Elevation also guarantees the payload is the whole contract, - // not an RLS-narrowed view of it. - runAs: "system", - variables: [ - // Bound with a default because the line-item read below is CONDITIONAL: a - // contract need not have an originating opportunity. Without the default, - // the skipped path leaves `billingLineItems` unbound and the payload key - // vanishes — so a receiver could not tell "no items" from "not sent". - { name: "billingLineItems", type: "collection", isInput: false, isOutput: false, defaultValue: [] } - ], - nodes: [ - { - id: "start", - type: "start", - label: "Start (contract updated)", - config: { - objectName: "crm_contract", - triggerType: "record-after-update", - condition: P41`has(record.status) && record.status == "activated" - && has(previous.status) && previous.status != "activated"` - } - }, - loadAccountNode(), - { - id: "load_line_items", - type: "get_record", - label: "Load Originating Deal\u2019s Line Items", - config: { - objectName: "crm_opportunity_line_item", - // Contracts carry no line items of their own; what was sold sits on the - // opportunity the contract came from. Reached only via the guarded edge - // below, because `crm_opportunity` is OPTIONAL on a contract and a - // filter operand that evaluates to null makes `get_record` refuse the - // step (an absent condition widens a query rather than narrowing it). - filter: { crm_opportunity: cel26`record.crm_opportunity` }, - fields: LINE_ITEM_FIELDS, - limit: BILLING_HANDOFF_LINE_ITEM_LIMIT, - outputVariable: "billingLineItems" - } - }, - { - id: "send_contract_activated_handoff", - type: "http", - label: "Enqueue Billing Hand-off", - config: { - url: BILLING_HANDOFF_ENDPOINT, - method: "POST", - durable: true, - timeoutMs: BILLING_HANDOFF_TIMEOUT_MS, - signingSecret: BILLING_HANDOFF_SIGNING_SECRET, - // One envelope building the whole payload (see `billingBody`). This - // flow is the consumer of `billing_frequency` and `payment_terms`: they - // are what the billing system needs to raise the schedule HotCRM - // deliberately does not model. - body: billingBody(BILLING_HANDOFF_EVENT.contractActivated, "contract", [ - "id", - "contract_number", - "status", - "contract_type", - "start_date", - "end_date", - "contract_term_months", - "contract_value", - "billing_frequency", - "payment_terms", - "auto_renewal", - "signed_date", - ["account_id", "crm_account"], - ["opportunity_id", "crm_opportunity"], - "owner_id" - ]) - } - }, - { id: "end", type: "end", label: "End" } - ], - edges: [ - { id: "e1", source: "start", target: "load_account", type: "default" }, - // The two edges below are COMPLEMENTARY CONDITIONALS on a plain data node, - // deliberately not a `decision` gateway. A decision with no declared - // `config.conditions` reports the engine's `default` branch label, and - // traversal then narrows the edge set to out-edges claiming that label — - // an `isDefault: true` sibling would swallow the whole branch and the - // conditional edge would never be evaluated. Complementary conditions off a - // non-branching node are evaluated one by one, which is the behaviour this - // needs. - { - id: "e2", - source: "load_account", - target: "load_line_items", - type: "conditional", - label: "Has originating deal", - condition: P41`has(record.crm_opportunity) && record.crm_opportunity != null` - }, - { - id: "e3", - source: "load_account", - target: "send_contract_activated_handoff", - type: "conditional", - label: "No originating deal", - condition: P41`!has(record.crm_opportunity) || record.crm_opportunity == null` - }, - { id: "e4", source: "load_line_items", target: "send_contract_activated_handoff", type: "default" }, - { id: "e5", source: "send_contract_activated_handoff", target: "end", type: "default" } - ] -}; - -// src/marketing/flows/campaign-enrollment.flow.ts -import { P as P42, cel as cel27 } from "@objectstack/spec"; -var CampaignEnrollmentFlow = { - name: "campaign_enrollment", - label: "Enroll Members in Campaign", - description: "Bulk enroll eligible leads or contacts into this campaign (skips already-enrolled and opted-out people).", - type: "screen", - status: "active", - variables: [ - // `recordId` matches the console's flow-action trigger contract - // ({ recordId, objectName }) — cf. lead_conversion / quote_generation. - { name: "recordId", type: "text", isInput: true, isOutput: false }, - /** - * `memberSource` is BOUND BY THIS DECLARATION — not by a seeding node. - * - * Both branch edges (`e4` / `e7`) read `vars.memberSource`, so it must be - * bound on every path reaching them. `FlowVariableSchema` carries - * `defaultValue` and the engine seeds it before the start node runs, so this - * key alone binds the name — while a caller-supplied - * `context.params.memberSource` still WINS over it. - * - * ⚠️ Measured on the 17.1.0 spec, with the schema key re-checked on 17.2.0. - * Neither that key nor the seeding behaviour was re-checked on 17.3.0 or - * 17.4.0 (PR #1814, #1807), nor on 17.5.0, 17.6.0, 17.7.0 or 18.0.0-next.0 (the pin since #2031). - * - * ⛔ Never seed this with an assignment node instead. An assignment is - * unconditional, so it CLOBBERS a supplied param — measured: launching with - * `params.memberSource = 'contacts'` ran the LEAD branch. It also restates a - * default the screen field carries, with nothing keeping the two in step. - * - * A second, independent reason no seeding node is needed here: the - * `memberSource` screen field below is `required: true`, and since - * 17.0.0-rc.2 the SERVER holds a screen resume to the declared field - * contract. A resume signal omitting `memberSource` is refused with - * `INVALID_SCREEN_INPUT` and the run stays paused, so the ordinary resume - * path cannot reach an unbound read at all — unlike `lead_conversion`'s - * checkbox, which is deliberately not `required` and therefore has an - * unanswered state. The one path that skips that check is a resume carrying - * NO signal object; measured on 17.x, it fails one node later at - * `query_leads` regardless of this binding, because `leadStatus` is unbound - * and the query never runs widened. Since 18.0.0-next.0 the filter operand - * is a CEL envelope, and an unbound variable fails the run before the query - * (the platform's `flow-value-slot-template-dialect-refused` contract; not - * re-measured here). - * - * The literal lives HERE and nowhere else: the screen field derives its - * prefill from this variable (its `defaultValue` envelope reads `memberSource`). - */ - { name: "memberSource", type: "text", isInput: true, isOutput: false, defaultValue: "leads" }, - /** - * `leadStatus` / `contactDepartment` deliberately carry NO `defaultValue`, - * and the asymmetry with `memberSource` is the point. No condition in this - * flow reads either one — each is a `get_record` `filter` operand — so the - * binding analysis in `test/flow-variable-conditions.test.ts` does not - * cover them. An unbound one fails the run before the query is made (the - * 18.0.0-next.0 filter-operand contract), because an absent condition - * widens a query instead of narrowing it. Seeding these two would turn that - * loud failure into a silent enrolment of a segment nobody chose; their - * `required: true` screen fields are what supply them. - */ - { name: "leadStatus", type: "text", isInput: true, isOutput: false }, - { name: "contactDepartment", type: "text", isInput: true, isOutput: false } - ], - nodes: [ - { id: "start", type: "start", label: "Start", config: { objectName: "crm_campaign" } }, - { - id: "screen_1", - type: "screen", - label: "Enrollment Criteria", - config: { - fields: [ - { - // Prefill DERIVED from the variable, so the default is written - // once (on the declaration) rather than restated here — the - // single-authority form. The envelope is evaluated before the - // screen goes on the wire, so the client receives the raw value, - // the string `leads`, which is what a literal - // `defaultValue: 'leads'` used to send. - name: "memberSource", - label: "Enroll", - type: "select", - required: true, - defaultValue: cel27`memberSource`, - options: [ - { label: "Leads", value: "leads" }, - { label: "Contacts", value: "contacts" } - ] - }, - { - name: "leadStatus", - label: "Enroll leads in status", - type: "select", - required: true, - defaultValue: "new", - options: [ - { label: "New", value: "new" }, - { label: "Contacted", value: "contacted" }, - { label: "Qualified", value: "qualified" } - ] - }, - { - // Required, like `leadStatus`, and for the same reason: a blank - // segment would reach the filter as an empty string and - // silently match the contacts with NO department rather than all of - // them. Both branches make the caller name a segment. - name: "contactDepartment", - label: "Enroll contacts in department", - type: "select", - required: true, - defaultValue: "executive", - options: [ - { label: "Executive", value: "executive" }, - { label: "Sales", value: "sales" }, - { label: "Marketing", value: "marketing" }, - { label: "Engineering", value: "engineering" }, - { label: "Support", value: "support" }, - { label: "Finance", value: "finance" }, - { label: "Human Resources", value: "hr" }, - { label: "Operations", value: "operations" } - ] - } - ] - } - }, - { - id: "get_campaign", - type: "get_record", - label: "Get Campaign", - config: { objectName: "crm_campaign", filter: { id: cel27`recordId` }, outputVariable: "campaignRecord" } - }, - { - // The gate itself is on edges `e4` / `e7` — see the notes there. This node - // carries NO `config.condition`: the key is the trigger gate on a `start` - // node and is read nowhere else, so a copy here would be a second, inert - // statement of the predicate that no reader can tell apart from the live - // one (flagged by `flow-inert-node-condition` from 17.0.0-rc.2). - id: "check_campaign_open", - type: "decision", - label: "Campaign Open?" - }, - { - id: "query_leads", - type: "get_record", - label: "Find Eligible Leads", - config: { - objectName: "crm_lead", - filter: { - status: cel27`leadStatus`, - is_converted: false, - email: { $ne: null }, - // This is email-campaign enrollment — honour the opt-out flag. - // `campaign_member_optout_sync` populates it: an unsubscribed member - // round-trips to the person's `email_opt_out`. - email_opt_out: false - }, - limit: 1e3, - outputVariable: "leadList" - } - }, - { - id: "loop_leads", - type: "loop", - label: "Process Each Lead", - config: { - collection: cel27`leadList`, - iteratorVariable: "currentLead", - body: guarded("lead", { - nodes: [ - { - // Dedupe: skip leads already enrolled in THIS campaign, so a - // re-run tops up instead of double-enrolling (double rows - // inflated num_sent / response_rate). - id: "find_existing_member", - type: "get_record", - label: "Already Enrolled?", - config: { - objectName: "crm_campaign_member", - filter: { crm_campaign: cel27`recordId`, crm_lead: cel27`currentLead.id` }, - outputVariable: "existingMember" - } - }, - { - // Gateway only — the predicate lives on the out-edge. - id: "check_not_enrolled", - type: "decision", - label: "New Member?" - }, - { - // ⭐ The INSERT is elevated, this flow is NOT. `added_date` is - // `readonly: true`, and from @objectstack/objectql 17.4.0 the - // readonly strip runs inside `engine.insert` for a non-system - // caller as well as on update — so a write from this screen - // flow's user context now loses the stamp. The remedy the - // platform names is a system context; the remedy AGENTS.md house - // rule 9 names is a dedicated `system` sub-flow rather than - // elevating the screen flow. Both are satisfied here. ⛔ Do not - // fold this back by giving THIS flow `runAs: 'system'`: it would - // also lift RLS off `query_leads` / `query_contacts`, and - // `crm_lead` is `sharingModel: 'private'`. - // See `src/marketing/flows/campaign-member-enroll.flow.ts`. - id: "create_campaign_member", - type: "subflow", - label: "Add to Campaign", - config: { - flowName: "campaign_lead_member_enroll", - input: { campaignId: cel27`recordId`, leadId: cel27`currentLead.id` } - } - } - ], - edges: [ - { id: "b1", source: "find_existing_member", target: "check_not_enrolled", type: "default" }, - // Already enrolled → no edge → next lead. This edge is the ONLY - // site for the predicate: a `decision` node's singular - // `config.condition` is never read, so a node copy would be inert. - { id: "b2", source: "check_not_enrolled", target: "create_campaign_member", type: "conditional", condition: P42`existingMember == null`, label: "Enroll" } - ] - }) - } - }, - { - id: "query_contacts", - type: "get_record", - label: "Find Eligible Contacts", - config: { - objectName: "crm_contact", - filter: { - department: cel27`contactDepartment`, - email: { $ne: null }, - // Same opt-out honour as the lead branch. There is no `is_converted` - // twin here: a contact IS the converted end state. - email_opt_out: false - }, - limit: 1e3, - outputVariable: "contactList" - } - }, - { - id: "loop_contacts", - type: "loop", - label: "Process Each Contact", - config: { - collection: cel27`contactList`, - iteratorVariable: "currentContact", - body: guarded("contact", { - nodes: [ - { - // Dedupe scoped on `crm_contact`, so a person enrolled as a LEAD - // and again as a CONTACT is not treated as a duplicate: those are - // two records of two different relationships, and the seed - // datasets key them separately for the same reason. - id: "find_existing_contact_member", - type: "get_record", - label: "Already Enrolled?", - config: { - objectName: "crm_campaign_member", - filter: { crm_campaign: cel27`recordId`, crm_contact: cel27`currentContact.id` }, - outputVariable: "existingContactMember" - } - }, - { - // Gateway only — the predicate lives on the out-edge. - id: "check_contact_not_enrolled", - type: "decision", - label: "New Member?" - }, - { - // The contact mirror of `create_campaign_member` above — same - // elevation, same reason. See that node's note. - id: "create_contact_member", - type: "subflow", - label: "Add Contact to Campaign", - config: { - flowName: "campaign_contact_member_enroll", - input: { campaignId: cel27`recordId`, contactId: cel27`currentContact.id` } - } - } - ], - edges: [ - { id: "c1", source: "find_existing_contact_member", target: "check_contact_not_enrolled", type: "default" }, - { id: "c2", source: "check_contact_not_enrolled", target: "create_contact_member", type: "conditional", condition: P42`existingContactMember == null`, label: "Enroll" } - ] - }) - } - }, - { id: "end", type: "end", label: "End" } - ], - edges: [ - { id: "e1", source: "start", target: "screen_1", type: "default" }, - { id: "e2", source: "screen_1", target: "get_campaign", type: "default" }, - { id: "e3", source: "get_campaign", target: "check_campaign_open", type: "default" }, - // Closed campaign → no edge → flow ends without enrolling. - // - // THE live gate, on the EDGES and only here. A `decision` node's singular - // `config.condition` is never read by the engine. - // - // Only enroll into campaigns that are actually running (or planned): - // topping up a completed/aborted campaign would corrupt its recorded - // metrics. (Status values: planning / in_progress / completed / aborted.) - // - // TOTALITY: `has(vars.campaignRecord)` first, then - // `has(vars.campaignRecord.status)`. `campaignRecord` is a `get_record` - // OUTPUT, and `findOne` answers a miss with `null` — so a campaign that was - // deleted (or hidden by sharing) between the action click and this node - // leaves the variable bound to null, and an unguarded read aborts with - // `No such key: status`, recording the run `failed` with not one lead - // enrolled. `status` is `required` on `crm_campaign` today so the column is - // never sparse — but that is the neighbouring schema doing the work, not - // this predicate, so it is guarded too. - // - // TWO conditional out-edges, one per member side. The open-campaign clause - // is repeated on both rather than hoisted to a second decision node: the - // gate IS the edge predicate here, so a separate "which side" node would - // need its own out-edges carrying the same clause anyway, and a node - // stating it once in `config.condition` is inert. - { id: "e4", source: "check_campaign_open", target: "query_leads", type: "conditional", condition: P42`has(vars.campaignRecord) && has(vars.campaignRecord.status) - && (vars.campaignRecord.status == "planning" || vars.campaignRecord.status == "in_progress") - && vars.memberSource != "contacts"`, label: "Open \xB7 Leads" }, - { id: "e5", source: "query_leads", target: "loop_leads", type: "default" }, - { id: "e6", source: "loop_leads", target: "end", type: "default" }, - // The contact branch. `memberSource` carries no `has()` guard on either - // edge, deliberately: its `flow.variables` declaration carries - // `defaultValue: 'leads'`, which the engine seeds before the start node, so - // it is bound on every path that reaches here — and on the ordinary resume - // path the server has already refused any signal that omitted the - // `required` screen field. A guard would have buried the policy ("no answer - // means leads") inside a predicate and left the graph defect in place — see - // test/flow-variable-conditions.test.ts. - { id: "e7", source: "check_campaign_open", target: "query_contacts", type: "conditional", condition: P42`has(vars.campaignRecord) && has(vars.campaignRecord.status) - && (vars.campaignRecord.status == "planning" || vars.campaignRecord.status == "in_progress") - && vars.memberSource == "contacts"`, label: "Open \xB7 Contacts" }, - { id: "e8", source: "query_contacts", target: "loop_contacts", type: "default" }, - { id: "e9", source: "loop_contacts", target: "end", type: "default" } - ] -}; - -// src/marketing/flows/campaign-member-enroll.flow.ts -import { cel as cel28 } from "@objectstack/spec"; -var MEMBERSHIP_FIELDS = { - status: "sent", - // The readonly stamp this elevation exists for. - added_date: cel28`isoDatetime(now())` -}; -var CampaignLeadMemberEnrollFlow = { - name: "campaign_lead_member_enroll", - label: "Enroll Lead in Campaign", - description: "Insert one lead campaign-membership row with its readonly added_date stamp, using the system context. Called by campaign_enrollment through a subflow node.", - type: "autolaunched", - status: "active", - // ⭐ THE ENTIRE POINT OF THIS FILE — see the header. One `create_record`. - runAs: "system", - variables: [ - // Supplied by the caller's `subflow` node. - { name: "campaignId", type: "text", isInput: true, isOutput: false }, - { name: "leadId", type: "text", isInput: true, isOutput: false } - ], - nodes: [ - // `config: {}` — an autolaunched callee is handed its params by the - // `subflow` executor and resolves no trigger record of its own, so there is - // no `objectName` for the start node to load. Same shape as - // `case_escalation_stamp`, measured in `test/readonly-write-semantics.test.ts`. - { id: "start", type: "start", label: "Start", config: {} }, - { - id: "create_campaign_member", - type: "create_record", - label: "Add to Campaign", - config: { - objectName: "crm_campaign_member", - // ⛔ Do not add fields here. Every column in this node is written with - // the elevated context; anything a marketer may legitimately type - // belongs in `campaign_enrollment` instead. - fields: { crm_campaign: cel28`campaignId`, crm_lead: cel28`leadId`, ...MEMBERSHIP_FIELDS } - } - }, - { id: "end", type: "end", label: "End" } - ], - edges: [ - { id: "e1", source: "start", target: "create_campaign_member", type: "default" }, - { id: "e2", source: "create_campaign_member", target: "end", type: "default" } - ] -}; -var CampaignContactMemberEnrollFlow = { - name: "campaign_contact_member_enroll", - label: "Enroll Contact in Campaign", - description: "Insert one contact campaign-membership row with its readonly added_date stamp, using the system context. Called by campaign_enrollment through a subflow node.", - type: "autolaunched", - status: "active", - runAs: "system", - variables: [ - { name: "campaignId", type: "text", isInput: true, isOutput: false }, - { name: "contactId", type: "text", isInput: true, isOutput: false } - ], - nodes: [ - { id: "start", type: "start", label: "Start", config: {} }, - { - id: "create_contact_member", - type: "create_record", - label: "Add Contact to Campaign", - config: { - objectName: "crm_campaign_member", - fields: { crm_campaign: cel28`campaignId`, crm_contact: cel28`contactId`, ...MEMBERSHIP_FIELDS } - } - }, - { id: "end", type: "end", label: "End" } - ], - edges: [ - { id: "e1", source: "start", target: "create_contact_member", type: "default" }, - { id: "e2", source: "create_contact_member", target: "end", type: "default" } - ] -}; - -// src/marketing/flows/campaign-completion.flow.ts -import { cel as cel29 } from "@objectstack/spec"; -var CampaignCompletionFlow = { - name: "campaign_completion", - label: "Campaign Auto-Completion", - description: "Daily: mark in_progress campaigns whose end_date has passed as completed.", - type: "schedule", - status: "active", - // Scheduled runs have no trigger user, so under the default runAs:'user' the - // data nodes execute UNSCOPED anyway. Declare runAs:'system' to make that - // RLS-bypassing elevation explicit and intended (ADR-0049). - runAs: "system", - variables: [], - nodes: [ - { id: "start", type: "start", label: "Start (daily 02:00)", config: { schedule: "0 2 * * *" } }, - { - id: "query_campaigns", - type: "get_record", - label: "Find Ended Campaigns", - config: { - objectName: "crm_campaign", - filter: { status: "in_progress", end_date: { $lt: cel29`isoDate(today())` } }, - limit: 500, - outputVariable: "campaignList" - } - }, - { - id: "loop_campaigns", - type: "loop", - label: "For Each Campaign", - config: { - collection: cel29`campaignList`, - iteratorVariable: "currentCampaign", - body: guarded("campaign", { - nodes: [ - { - id: "mark_completed", - type: "update_record", - label: "Mark Completed", - config: { objectName: "crm_campaign", filter: { id: cel29`currentCampaign.id` }, fields: { status: "completed" } } - } - ], - edges: [] - }) - } - }, - { id: "end", type: "end", label: "End" } - ], - edges: [ - { id: "e1", source: "start", target: "query_campaigns", type: "default" }, - { id: "e2", source: "query_campaigns", target: "loop_campaigns", type: "default" }, - { id: "e3", source: "loop_campaigns", target: "end", type: "default" } - ] -}; - -// src/sales/skills/lead-qualification.skill.ts -import { defineSkill as defineSkill2 } from "@objectstack/spec"; -var LeadQualificationSkill = defineSkill2({ - name: "lead_qualification", - label: "Lead Qualification", - description: "Qualifies inbound leads using BANT criteria and assigns a 0\u2013100 score.", - instructions: `When the user asks to qualify, score, or analyse a lead: - -1. Read the lead \u2014 \`describe_object\` for \`crm_lead\` first (fields - change), then \`get_record\`. Use \`query_records\` to pull the - related activity history when the lead has any. -2. Score it yourself, 0\u2013100, with BANT. There is no scoring tool: - Budget (is spend confirmed or inferable from company size?), - Authority (is the contact a decision maker?), Need (is there a - stated problem you solve?), Timeline (is there a date?). Weight - them evenly unless the user says otherwise. -3. Report the score, one line of justification per BANT dimension - naming the field or activity you read, and the single recommended - next step. Cite the lead ID. -4. Score >= 70 and the user agrees \u2192 call \`action_convert_lead\`. -5. Otherwise, or when the user wants to nurture, call - \`action_schedule_followup\` with the date you recommend. Say why - that date. -6. Never convert without explicit confirmation \u2014 conversion is not - reversible from this surface.`, - tools: [ - "describe_object", - "get_record", - "query_records", - "action_convert_lead", - "action_schedule_followup" - ], - triggerConditions: [ - { field: "objectName", operator: "eq", value: "crm_lead" } - ] -}); - -// src/sales/skills/email-drafting.skill.ts -import { defineSkill as defineSkill3 } from "@objectstack/spec"; -var EmailDraftingSkill = defineSkill3({ - name: "email_drafting", - label: "Email Drafting", - description: "Drafts personalised outbound emails grounded in live contact data, ready for a human to review and send.", - instructions: `When the user asks to draft, write, or optimise an email: - -1. Ground it in real data before writing a word: \`get_record\` the - contact (and the related account or opportunity when the request - references one) so names, titles and recent activity are accurate. - Use \`query_records\` when you need the recent history. -2. Write the copy yourself \u2014 subject and body. You do not have, and do - not need, a copy-generation tool. Aim for: a subject under 60 - characters naming the concrete value, a first line referencing - something specific to THIS recipient rather than a generic - pleasantry, one clear ask, and no more than 150 words. -3. Offer two subject-line variants, say which you recommend and why, - so the user can A/B them. -4. Show the draft and stop. You cannot send \u2014 say so plainly rather - than implying a send is queued. -5. Point the user at **Send Email** on the contact record, where the - subject and body you drafted can be pasted, reviewed and sent.`, - tools: ["get_record", "query_records"] -}); - -// src/sales/skills/revenue-forecasting.skill.ts -import { defineSkill as defineSkill4 } from "@objectstack/spec"; -var RevenueForecastingSkill = defineSkill4({ - name: "revenue_forecasting", - label: "Revenue Forecasting", - description: "Analyses pipeline health, surfaces at-risk deals, and forecasts revenue from live opportunity data.", - instructions: `When the user asks about pipeline health, forecast, -risk, or deal slippage: - -1. Establish the shape first: \`describe_object\` for - \`crm_opportunity\` so you use the CURRENT stage, amount, - probability and close-date fields rather than assumed ones. -2. Summarise the pipeline with \`aggregate_data\` \u2014 count and summed - amount grouped by stage, scoped to the period the user names - (default: the current quarter). Weighted value is amount \xD7 - probability; compute it yourself from what you read. -3. Surface at-risk deals with \`query_records\`: close date already - past, or no activity in 30+ days, or the stage unchanged for longer - than its typical duration. Name each deal and the specific signal. -4. Forecast by summing weighted value for open deals plus closed-won - in the period. State the assumption behind the number in one line, - and give a range rather than false precision \u2014 the spread between - commit-only (high-probability stages) and full weighted pipeline. -5. Offer \`visualize_data\` when a chart would carry the answer better - than prose, e.g. stage distribution or month-over-month trend. -6. Be quantitative: every claim cites a number or a deal name. If the - data cannot support a claim, say so instead of estimating.`, - tools: ["describe_object", "aggregate_data", "query_records", "visualize_data"], - triggerConditions: [ - { field: "objectName", operator: "in", value: ["crm_opportunity", "dashboard"] } - ] -}); - -// src/sales/skills/customer-360.skill.ts -import { defineSkill as defineSkill5 } from "@objectstack/spec"; -var Customer360Skill = defineSkill5({ - name: "customer_360", - label: "Customer 360", - description: "Aggregates account, recent cases, open opportunities, and knowledge hits into a single customer profile.", - instructions: `When the user asks for "the full picture" of a -customer / account / contact: - -1. Read the shape first \u2014 \`describe_object\` for \`crm_account\`, and for - each related object before you query it. Admins add fields; never - summarise from memory of a previous turn. -2. \`get_record\` the account, then pull the related work with - \`query_records\`, each filtered to this account: - - \`crm_contact\` \u2014 who the people are, primary contact first. - - \`crm_case\` \u2014 cases where \`is_closed\` is false, newest first. - - \`crm_opportunity\` \u2014 open deals with stage, amount and close date. - Quote totals from \`aggregate_data\` (open pipeline amount, case count - by status) rather than adding up rows yourself. -3. For the policy or playbook context, \`query_records\` on - \`crm_knowledge_article\` \u2014 \`status\` published, matched on the - \`category\` or \`tags\` of the cases you just read. You have no - knowledge-search tool in this skill and do not need one: the knowledge - base is an object like any other. -4. Summarise into three sections: **Account Snapshot** \xB7 **Active Work** \xB7 - **Risks & Notes**. Every risk names the record and the signal that - raised it \u2014 an escalated case, a close date already past, a deal with - no activity in 30+ days. Do not infer risk you cannot cite. -5. Cite record IDs inline (e.g. "case CASE-01234", "article KA-0007") so - the UI can deep link. If a section has no records, say so plainly - instead of filling it.`, - tools: ["describe_object", "get_record", "query_records", "aggregate_data"] -}); - -// src/sales/skills/live-data.skill.ts -import { defineSkill as defineSkill6 } from "@objectstack/spec"; -var LiveDataSkill = defineSkill6({ - name: "live_data", - label: "Live Data Access", - description: "Queries any CRM object using the current live schema. Always inspects the object structure first so newly added fields are picked up immediately.", - instructions: `When the user asks a question that touches a CRM -record (account, contact, lead, opportunity, case, quote, etc.): - -1. **Always** call \`describe_object\` for the relevant object FIRST, - even if you think you remember the fields. The schema can change - between turns \u2014 trust the tool, not your memory. -2. Use \`list_objects\` if you are not sure which object holds the - data the user is asking about. -3. Use \`query_records\` (filters, sort, limit) for lists, - \`get_record\` for a single ID, \`aggregate_data\` for sums / - counts / averages. -4. When you reference data, cite the record ID inline so the UI - can deep-link (e.g. "opportunity OPP-1234"). -5. If \`describe_object\` shows a field you've never seen before, - USE IT \u2014 that's the user's whole point in adding it. Surface it - in your answer when relevant.`, - tools: [ - "describe_object", - "list_objects", - "query_records", - "get_record", - "aggregate_data" - ] -}); - -// src/sales/sharing/account.sharing.ts -import { P as P43 } from "@objectstack/spec"; -var AccountTeamSharingRule = { - name: "account_team_sharing", - label: "Account Team Sharing", - object: "crm_account", - type: "criteria", - condition: P43`record.type == "customer" && record.is_active == true`, - accessLevel: "edit", - sharedWith: { type: "position", value: "sales_manager" } -}; -var TerritorySharingRules = [ - { - name: "north_america_territory", - label: "North America Territory", - object: "crm_account", - type: "criteria", - condition: P43`record.territory == ${TERRITORY.NA}`, - accessLevel: "edit", - sharedWith: { type: "position", value: "na_sales_team" } - }, - { - name: "europe_territory", - label: "Europe Territory", - object: "crm_account", - type: "criteria", - condition: P43`record.territory == ${TERRITORY.EMEA}`, - accessLevel: "edit", - sharedWith: { type: "position", value: "eu_sales_team" } - } -]; - -// src/sales/sharing/opportunity.sharing.ts -import { P as P44 } from "@objectstack/spec"; -var OpportunitySalesSharingRule = { - name: "opportunity_sales_sharing", - label: "Opportunity Sales Team Sharing", - object: "crm_opportunity", - type: "criteria", - condition: P44`!(record.stage in ["closed_won", "closed_lost"]) && record.amount >= ${LARGE_DEAL_AMOUNT}`, - accessLevel: "read", - sharedWith: { type: "position", value: "sales_director" } -}; -var OpportunityExecutiveSharingRule = { - name: "opportunity_executive_sharing", - label: "Large Open Deals \u2014 Executive", - object: "crm_opportunity", - type: "criteria", - condition: P44`!(record.stage in ["closed_won", "closed_lost"]) && record.amount >= ${LARGE_DEAL_AMOUNT}`, - accessLevel: "read", - sharedWith: { type: "position", value: "executive" } -}; - -// src/sales/sharing/positions.ts -var CrmPositions = [ - { name: "executive", label: "Executive" }, - { name: "sales_director", label: "Sales Director" }, - { name: "sales_manager", label: "Sales Manager" }, - { name: "sales_rep", label: "Sales Representative" }, - { name: "service_director", label: "Service Director" }, - { name: "service_manager", label: "Service Manager" }, - { name: "service_agent", label: "Service Agent" }, - { name: "marketing_director", label: "Marketing Director" }, - { name: "marketing_manager", label: "Marketing Manager" }, - { name: "marketing_user", label: "Marketing User" }, - // Territory groupings referenced by the account sharing rules. - { name: "na_sales_team", label: "NA Sales Team" }, - { name: "eu_sales_team", label: "EU Sales Team" } -]; - -// src/marketing/sharing/campaign.sharing.ts -import { P as P45 } from "@objectstack/spec"; -var CampaignLeadershipSharingRules = [ - { - name: "campaign_leadership_manager", - label: "Live Campaigns \u2014 Marketing Manager", - object: "crm_campaign", - type: "criteria", - condition: P45`record.status in ["planning", "in_progress"] && record.is_active == true`, - accessLevel: "edit", - sharedWith: { type: "position", value: "marketing_manager" } - }, - { - name: "campaign_leadership_director", - label: "Live Campaigns \u2014 Marketing Director", - object: "crm_campaign", - type: "criteria", - condition: P45`record.status in ["planning", "in_progress"] && record.is_active == true`, - accessLevel: "edit", - sharedWith: { type: "position", value: "marketing_director" } - } -]; - -// src/sales/data/sales.seed.ts -import { defineSeed } from "@objectstack/spec/data"; -import { cel as cel31 } from "@objectstack/spec"; - -// src/sales/data/_shared.ts -import { cel as cel30 } from "@objectstack/spec"; -var celDaysAgo = (n) => cel30`daysAgo(${n})`; -var lineTotal = (l) => Math.round(l.quantity * l.unit_price * (1 - (l.discount ?? 0) / 100) * 100) / 100; -var linesTotal = (lines) => Math.round(lines.reduce((sum, l) => sum + lineTotal(l), 0) * 100) / 100; - -// src/sales/data/sales.seed.ts -var accounts = defineSeed(Account, { - mode: "upsert", - externalId: "name", - records: [ - { - name: "Acme Corporation", - approval_status: "approved", - type: "customer", - industry: "technology", - annual_revenue: 5e6, - number_of_employees: 250, - phone: "+1-415-555-0100", - billing_address: { street: "500 Howard Street, Suite 400", city: "San Francisco", state: "CA", postalCode: "94105", country: "US" }, - website: "https://acme.example.com", - tier: "enterprise", - segment: "growth", - health_score: "healthy", - // Held: workshop, demo, calls and an onsite visit — see `service.seed.ts`. - last_activity_date: cel31`today()`, - // The ARR line below used to read "signed Q1 2025 renewal" while the - // deal it describes closes `daysAgo(15)` — a fixed calendar quarter on a - // relative-date record, wrong in both the quarter and the year (#1692). - // The label is not re-derived here either: that date belongs to - // `Acme Annual Renewal 2025` (`close_date`) and to its contract - // (`signed_date`, `revenue.seed.ts`), and computing a copy in this module - // means re-stating that record's own offset — a second source of truth - // for a value two records already own. Same ruling as the `next_step` - // block below (#1660): no date goes back into this prose, absolute OR - // relative. What stays true however the renewal is dated is that it IS - // signed: the deal is `closed_won` and its contract `activated`. - description: `**Strategic Customer \xB7 Enterprise Tier** - -Acme Corporation is a Series-C robotics & industrial automation -company that switched from a competitor 18 months ago. They run -HotCRM as their system of record for sales + service across -three regional teams (NA, EMEA, APAC). - -**Relationship** -- Primary economic buyer: Jordan Park (CTO) \u2014 values our open - architecture and AI roadmap. -- Day-to-day champion: John Smith (VP Engineering) \u2014 owns the - technical evaluation and integration questions. -- Procurement: handled by Lisa Kim \u2014 prefers annual contracts, - net-30 terms. - -**Current state** -- ARR: $220K (signed renewal). Up 22% YoY. -- 1 open enterprise opportunity ($150K platform upgrade) in proposal - stage, 1 service ticket open (login issues), 1 billing dispute - awaiting customer response. -- AI agent governance became a hard requirement for that upgrade - after their internal compliance review, so the workshop now on - the calendar is the gate on signature. - -**Red flags** -- Lost the $75K Marketing Cloud add-on on timing \u2014 their marketing - org is locked into a 2-year HubSpot contract, and the buying - window opens when that contract renews. -- Login issues ticket is already past its SLA clock \u2014 needs eyes - today.` - }, - { - name: "Globex Industries", - approval_status: "approved", - type: "prospect", - industry: "manufacturing", - annual_revenue: 12e6, - number_of_employees: 800, - phone: "+1-312-555-0200", - billing_address: { street: "233 South Wacker Drive", city: "Chicago", state: "IL", postalCode: "60606", country: "US" }, - website: "https://globex.example.com", - tier: "enterprise", - segment: "net_new", - // Only a booked demo and a cancelled review — neither bubbles, so this - // 8-day age survives the seed load and stays inside every churn window. - last_activity_date: cel31`daysAgo(8)` - }, - { - name: "Initech Solutions", - approval_status: "approved", - type: "customer", - industry: "finance", - annual_revenue: 35e5, - number_of_employees: 150, - phone: "+1-212-555-0300", - billing_address: { street: "1 Liberty Plaza, 23rd Floor", city: "New York", state: "NY", postalCode: "10006", country: "US" }, - website: "https://initech.example.com", - tier: "mid_market", - segment: "at_risk", - health_score: "at_risk", - // QUIET 60+ — the `at_risk` segment and health score, with a clock that - // finally agrees with them: ten weeks of silence. A no-show call 55 days - // ago was the last attempt; the re-engagement call on the calendar is - // `planned`, so it moves nothing. - last_activity_date: cel31`daysAgo(72)` - }, - { - name: "Stark Medical", - approval_status: "approved", - type: "partner", - industry: "healthcare", - annual_revenue: 8e6, - number_of_employees: 400, - // The one Canadian account: still inside north_america_territory, and the - // reason that rule's `$in` list is not a single-country list in disguise. - phone: "+1-416-555-0400", - billing_address: { street: "181 Bay Street, Suite 2200", city: "Toronto", state: "ON", postalCode: "M5J 2T3", country: "CA" }, - website: "https://starkmed.example.com", - tier: "mid_market", - segment: "stable", - // `at_risk` rather than `churning`, and the distinction is the reason - // this row can exist at all: a partner whose pilot was WON and whose - // expansion then died on a capital freeze can be at risk, but it was - // never a subscription that could churn. The records say it — `Stark - // Expansion (Lost)` closed `no_budget` 60 days ago and the partnership - // contract is still in legal review — and the panel's criterion admits - // both values, so the honest severity is also the one that flags. - // - // Diverging from `segment: 'stable'` is deliberate, the same split - // Wayne demonstrates below: `segment` is how the book classifies the - // account, `health_score` is what a person asserts about it. The clock - // stays at today(), so like Wayne this row is outside every windowed - // panel on that report: it reaches `csm_flagged_accounts` and no other - // block. - health_score: "at_risk", - // The completed 'Send welcome package' task bubbles here on every seed - // load, so this has ALWAYS resolved to today — the previous `daysAgo(5)` - // was authored and then overwritten before anyone could read it. - last_activity_date: cel31`today()` - }, - { - name: "Wayne Enterprises", - approval_status: "approved", - type: "customer", - industry: "technology", - annual_revenue: 25e6, - number_of_employees: 2e3, - phone: "+1-650-555-0500", - billing_address: { street: "3000 Hanover Street", city: "Palo Alto", state: "CA", postalCode: "94304", country: "US" }, - website: "https://wayne.example.com", - tier: "strategic", - segment: "growth", - // CHURNING, with the clock still running — the population - // `csm_flagged_accounts` exists for (#1414). Every DERIVED signal on - // this row reads healthy: an operations rollout closed four days ago, a - // licence sits at 80% two weeks from signature, three meetings were held - // this month. The CSM who has been in the room says the account is going - // anyway, and `health_score` is the only churn signal in the model a - // person ASSERTS — which is why the panel that reads it is first on the - // report and carries no time window. - // - // ⛔ Do not "correct" this to `at_risk` to agree with the pipeline, and - // ⛔ do not stop the clock to agree with the health score: either edit - // folds the row back into `at_risk_accounts` (60-day window) and the - // flagged panel goes back to restating its neighbour. - health_score: "churning", - // Held: negotiation meeting, security-addendum call, governance webinar. - last_activity_date: cel31`today()` - }, - { - name: "Northwind Energy", - approval_status: "approved", - type: "prospect", - industry: "energy", - annual_revenue: 18e6, - number_of_employees: 1100, - // europe_territory, half 1: DE. - phone: "+49-89-5550-0600", - billing_address: { street: "Leopoldstrasse 21", city: "Munich", state: "BY", postalCode: "80802", country: "DE" }, - website: "https://northwind.example.com", - tier: "enterprise", - segment: "net_new", - // QUIET 30+ — the field-service pilot was lost 80 days ago and the grid - // program has not been worked since. The discovery workshop is booked, - // not held. - last_activity_date: cel31`daysAgo(41)`, - description: "A regional energy provider evaluating a unified operations and customer-data platform." - }, - { - name: "Vertex Analytics", - approval_status: "approved", - type: "customer", - industry: "software", - annual_revenue: 95e5, - number_of_employees: 420, - phone: "+1-512-555-0700", - billing_address: { street: "600 Congress Avenue, Floor 14", city: "Austin", state: "TX", postalCode: "78701", country: "US" }, - website: "https://vertex.example.com", - tier: "enterprise", - segment: "growth", - health_score: "healthy", - // Held: rollout meeting, analytics demo, committee call, retrospective. - last_activity_date: cel31`today()`, - description: "An analytics SaaS customer expanding usage from the data team to its revenue organization." - }, - { - name: "Lattice Education", - approval_status: "approved", - type: "customer", - industry: "education", - annual_revenue: 68e5, - number_of_employees: 320, - // europe_territory, half 2 — and the alias fixture. `UK` is not ISO - // 3166-1 alpha-2 (`GB` is); it is an ACCEPTED SPELLING in - // `src/sales/objects/_territory.ts`, so this row proves on stock data that a - // legacy spelling still lands in `emea` (#639). No `state`: an address - // without a subdivision is a normal shape, and only `country` is read. - phone: "+44-20-7946-0800", - billing_address: { street: "20 Fenchurch Street", city: "London", postalCode: "EC3M 3BY", country: "UK" }, - website: "https://lattice.example.com", - tier: "mid_market", - segment: "stable", - health_score: "healthy", - // Signed the analytics expansion six days ago; the renewal review is - // booked, not held, so nothing bubbles and this age stands. - last_activity_date: cel31`daysAgo(6)`, - description: "A higher-education technology company consolidating admissions, student-success and alumni workflows." - }, - { - name: "Apex Logistics", - approval_status: "approved", - type: "prospect", - industry: "logistics", - annual_revenue: 22e6, - number_of_employees: 1400, - // `territory == "other"` on purpose: without a record that matches - // neither rule, "the rules partition the accounts" is unfalsifiable — - // a match-all regression would look identical to a working one. `SG` is - // a real country the staffed territories do not cover, which is exactly - // what `other` is for (#639) — it is a stated classification here, not a - // blank. - phone: "+65-6555-0900", - billing_address: { street: "10 Marina Boulevard, #30-01", city: "Singapore", postalCode: "018983", country: "SG" }, - website: "https://apexlogistics.example.com", - tier: "enterprise", - segment: "net_new", - // QUIET 90+ — a lost compliance deal 110 days ago and a data-hub - // evaluation that has been silent for a quarter. Only a booked - // re-engagement call. - last_activity_date: cel31`daysAgo(104)`, - description: "A fast-growing logistics provider assessing a modern data hub for its operations and commercial teams." - } - ] -}); -var contacts = defineSeed(Contact, { - mode: "upsert", - externalId: "email", - records: [ - { - salutation: "mr", - first_name: "John", - last_name: "Smith", - email: "john.smith@acme.example.com", - phone: "+1-415-555-0101", - title: "VP of Engineering", - department: "engineering", - crm_account: "Acme Corporation", - is_primary: true - }, - { - salutation: "ms", - first_name: "Sarah", - last_name: "Johnson", - email: "sarah.j@globex.example.com", - phone: "+1-312-555-0201", - title: "Chief Procurement Officer", - department: "executive", - crm_account: "Globex Industries", - is_primary: true - }, - { - salutation: "dr", - first_name: "Michael", - last_name: "Chen", - email: "mchen@initech.example.com", - phone: "+1-212-555-0301", - title: "Director of Operations", - department: "operations", - crm_account: "Initech Solutions", - is_primary: true - }, - { - salutation: "ms", - first_name: "Emily", - last_name: "Davis", - email: "emily.d@starkmed.example.com", - phone: "+1-617-555-0401", - title: "Head of Partnerships", - department: "sales", - crm_account: "Stark Medical", - is_primary: true - }, - { - salutation: "mr", - first_name: "Robert", - last_name: "Wilson", - email: "rwilson@wayne.example.com", - phone: "+1-650-555-0501", - title: "CTO", - department: "engineering", - crm_account: "Wayne Enterprises", - is_primary: true - }, - { - salutation: "ms", - first_name: "Olivia", - last_name: "Chen", - email: "olivia.chen@northwind.example.com", - phone: "+1-303-555-0601", - title: "VP of Digital Operations", - department: "operations", - crm_account: "Northwind Energy", - is_primary: true - }, - { - salutation: "mr", - first_name: "Ethan", - last_name: "Brooks", - email: "ethan.brooks@vertex.example.com", - phone: "+1-512-555-0701", - title: "Chief Revenue Officer", - department: "executive", - crm_account: "Vertex Analytics", - is_primary: true - }, - { - salutation: "ms", - first_name: "Priya", - last_name: "Shah", - email: "priya.shah@lattice.example.com", - phone: "+1-617-555-0801", - title: "VP of Student Success", - department: "operations", - crm_account: "Lattice Education", - is_primary: true - }, - { - salutation: "mr", - first_name: "Marcus", - last_name: "Reed", - email: "marcus.reed@apexlogistics.example.com", - phone: "+1-404-555-0901", - title: "Director of Commercial Systems", - department: "operations", - crm_account: "Apex Logistics", - is_primary: true - } - ] -}); -var DISQUALIFICATION_REASONS = [ - { reason: "no_budget", note: "No budget approved for this fiscal year \u2014 revisit next planning cycle." }, - { reason: "not_a_fit", note: "Requirements sit outside what the product covers today." }, - { reason: "wrong_persona", note: "Contact has no say in the buying decision and no path to an owner." }, - { reason: "unreachable", note: "Six touches across email and phone over four weeks, no response." } -]; -var leads = defineSeed(Lead, { - mode: "upsert", - externalId: "email", - records: [ - { - first_name: "Alice", - last_name: "Martinez", - company: "NextGen Retail", - email: "alice@nextgenretail.example.com", - phone: "+1-503-555-0600", - status: "new", - lead_source: "web", - industry: "retail", - rating: 3, - next_followup_date: cel31`daysFromNow(2)` - }, - { - first_name: "David", - last_name: "Kim", - company: "EduTech Labs", - email: "dkim@edutechlabs.example.com", - phone: "+1-408-555-0700", - status: "contacted", - lead_source: "referral", - industry: "education", - rating: 4, - next_followup_date: cel31`daysFromNow(1)`, - // A seeded `held` event names this lead, and `event_activity_bubble` - // stamps `last_contacted_date` with the SEED MOMENT rather than the - // event's own timestamp — so an authored age here would be overwritten - // the instant it was written (doctrine rule 2 in `./_shared.ts`). Day - // granularity is the honest match: the seed writes today's UTC midnight, - // the bubble writes today's instant, and both render as "today". - last_contacted_date: cel31`today()` - }, - { - first_name: "Lisa", - last_name: "Thompson", - company: "CloudFirst Inc", - email: "lisa.t@cloudfirst.example.com", - phone: "+1-206-555-0800", - status: "qualified", - lead_source: "event", - industry: "technology", - // WHOLE stars only. `lead.hook.ts` rounds its computed score to an - // integer because "half values rendered inconsistently in the star - // widget", and the hook leaves an explicitly seeded number alone — so a - // seeded 4.5 was the one rating in the system the contract could never - // produce, and it rendered as the broken half-star it was meant to - // prevent (#591). - rating: 5, - next_followup_date: cel31`daysFromNow(0)`, - // Same as David Kim above: a `held` qualification call names this lead. - last_contacted_date: cel31`today()` - }, - // ─── Generated demo leads — spread across 6 months for monthly-bucket reports - // (`LeadInflowByMonthSourceReport`). Each `last_contacted_date` lives in a - // distinct month / source pair so the matrix has multiple cells populated. - ...[ - { fn: "Noah", ln: "Patel", co: "Vertex Analytics", src: "web", ind: "technology", age: 7 }, - { fn: "Maya", ln: "Singh", co: "BluePeak Logistics", src: "referral", ind: "logistics", age: 14 }, - { fn: "Owen", ln: "Becker", co: "Northwind Energy", src: "event", ind: "energy", age: 21 }, - { fn: "Sara", ln: "Lopez", co: "Helios Solar", src: "partner", ind: "energy", age: 28 }, - { fn: "Leo", ln: "Vance", co: "CleanCart", src: "web", ind: "retail", age: 38 }, - { fn: "Iris", ln: "Okafor", co: "PulseHealth", src: "cold_call", ind: "healthcare", age: 45 }, - { fn: "Ravi", ln: "Mehta", co: "Foundry Robotics", src: "event", ind: "manufacturing", age: 52 }, - { fn: "Tess", ln: "Brown", co: "Lattice Education", src: "referral", ind: "education", age: 67 }, - { fn: "Marco", ln: "Ricci", co: "Aurora Travel", src: "advertisement", ind: "hospitality", age: 74 }, - { fn: "Pia", ln: "Anand", co: "Citrine Finance", src: "partner", ind: "finance", age: 81 }, - { fn: "Jonas", ln: "Holt", co: "Polar Cargo", src: "web", ind: "logistics", age: 95 }, - { fn: "Anya", ln: "Volkov", co: "RedOak Realty", src: "cold_call", ind: "real_estate", age: 102 }, - { fn: "Theo", ln: "Park", co: "Skyline Media", src: "advertisement", ind: "media", age: 116 }, - { fn: "Wren", ln: "Garcia", co: "Maple Bakery Group", src: "event", ind: "retail", age: 123 }, - { fn: "Hugo", ln: "Dubois", co: "Nimbus Aerospace", src: "referral", ind: "manufacturing", age: 138 }, - { fn: "Lena", ln: "Fischer", co: "Granite Insurance", src: "partner", ind: "finance", age: 145 }, - { fn: "Kai", ln: "Watanabe", co: "Coral Reef Hotels", src: "web", ind: "hospitality", age: 162 }, - { fn: "Mira", ln: "Costa", co: "Atlas Construction", src: "cold_call", ind: "other", age: 175 } - ].map((l, i) => { - const domain = `${l.co.toLowerCase().replace(/\s+/g, "")}.example.com`; - const status = ["new", "contacted", "qualified", "unqualified"][i % 4]; - return { - first_name: l.fn, - last_name: l.ln, - company: l.co, - email: `${l.fn.toLowerCase()}.${l.ln.toLowerCase()}@${domain}`, - phone: `+1-555-01${String(i).padStart(2, "0")}-${String(1e3 + i * 7)}`, - status, - lead_source: l.src, - industry: l.ind, - rating: 1 + i * 7 % 5, - last_contacted_date: celDaysAgo(l.age), - // The qualification fields were left blank on every generated lead, so - // the detail page's Contact / Lead Detail / Description sections had - // nothing to render (they also drop whatever the highlights strip - // already shows, so all four collapsed to nothing) and the demo read - // like a half-finished import. - title: ["VP Operations", "Head of IT", "Director of Sales", "COO", "Procurement Lead"][i % 5], - mobile: `+1-555-02${String(i).padStart(2, "0")}-${String(2e3 + i * 3)}`, - website: `https://${domain}`, - annual_revenue: 2e6 + i * 37e5 % 9e7, - number_of_employees: 25 + i * 137 % 4800, - description: `Inbound via ${l.src.replace(/_/g, " ")}. Evaluating a CRM to replace spreadsheets across their ${l.ind.replace(/_/g, " ")} operation.`, - ...status === "unqualified" ? { - disqualification_reason: DISQUALIFICATION_REASONS[(i >> 2) % DISQUALIFICATION_REASONS.length].reason, - notes: DISQUALIFICATION_REASONS[(i >> 2) % DISQUALIFICATION_REASONS.length].note - } : {} - }; - }) - ] -}); -var OPPORTUNITY_LINES = { - "Acme Platform Upgrade": [ - { product: "ObjectStack Platform", quantity: 2, unit_price: 5e4, discount: 10, description: "Enterprise edition \u2014 NA + EMEA production tenants (multi-year discount)." }, - { product: "Premium Support", quantity: 1, unit_price: 25e3, description: "24\xD77 premium support with a named TAM." }, - { product: "AI Agent Seat (Annual)", quantity: 35, unit_price: 1e3, description: "Agent seats for the Ops organization." } - ], - "Globex Manufacturing Suite": [ - { product: "ObjectStack Platform", quantity: 1, unit_price: 5e4, description: "Enterprise edition \u2014 one shared tenant serving all six manufacturing sites." }, - { product: "Admin Training Workshop", quantity: 4, unit_price: 6e3, description: "Four workshop days, one per regional plant cluster." }, - { product: "Standard Support", quantity: 1, unit_price: 9e3, description: "Business-hours support for the first year." }, - { product: "AI Agent Seat (Annual)", quantity: 12, unit_price: 1e3, description: "Agent seats for the plant operations leads." } - ], - "Wayne Enterprise License": [ - { product: "ObjectStack Platform", quantity: 20, unit_price: 5e4, discount: 15, description: "Enterprise-wide license, volume discount at 20 tenants." }, - { product: "Premium Support", quantity: 4, unit_price: 25e3, description: "Premium support across four business units." }, - { product: "AI Agent Seat (Annual)", quantity: 250, unit_price: 1e3, description: "Agent seats for the global revenue organization." } - ], - "Initech Cloud Migration": [ - { product: "Data Migration Services", quantity: 1, unit_price: 35e3, description: "Migration off the legacy on-premise CRM." }, - { product: "Cloud Hosting (Annual)", quantity: 2, unit_price: 12e3, description: "Managed hosting, primary + DR region." }, - { product: "Standard Support", quantity: 1, unit_price: 9e3, description: "Business-hours support for the first year." }, - { product: "AI Agent Seat (Annual)", quantity: 12, unit_price: 1e3, description: "Agent seats for the service desk." } - ], - "Acme Annual Renewal 2025": [ - { product: "ObjectStack Platform", quantity: 3, unit_price: 5e4, description: "Renewal of the three production tenants." }, - { product: "Premium Support", quantity: 1, unit_price: 25e3, description: "Premium support renewal." }, - { product: "AI Agent Seat (Annual)", quantity: 45, unit_price: 1e3, description: "Seat expansion driven by the new EMEA team." } - ], - "Stark Medical Pilot": [ - { product: "ObjectStack Platform", quantity: 2, unit_price: 5e4, description: "Pilot tenants for two clinical service lines." }, - { product: "Standard Support", quantity: 1, unit_price: 9e3, description: "Standard support during the pilot." }, - { product: "Admin Training Workshop", quantity: 6, unit_price: 6e3, description: "Six workshop days for the clinical operations admins." } - ], - "Wayne Q1 Expansion": [ - { product: "ObjectStack Platform", quantity: 6, unit_price: 5e4, description: "Expansion into six additional subsidiaries." }, - { product: "Premium Support", quantity: 2, unit_price: 25e3, description: "Premium support for the expanded footprint." }, - { product: "AI Agent Seat (Annual)", quantity: 30, unit_price: 1e3, description: "Agent seats for the expansion teams." } - ], - "Globex Training Package": [ - { product: "Admin Training Workshop", quantity: 10, unit_price: 6e3, description: "Ten workshop days across the plant admin community." }, - { product: "AI Agent Seat (Annual)", quantity: 5, unit_price: 1e3, description: "Agent seats for the training sandbox." } - ], - "Initech Phase 1": [ - { product: "Implementation Services", quantity: 1, unit_price: 75e3, description: "Phase 1 implementation: accounts, contacts, pipeline." }, - { product: "Standard Support", quantity: 1, unit_price: 9e3, description: "Standard support for phase 1." }, - { product: "AI Agent Seat (Annual)", quantity: 6, unit_price: 1e3, description: "Agent seats for the phase-1 pilot group." } - ], - "Acme Add-on (Lost)": [ - { product: "Analytics Add-on", quantity: 2, unit_price: 22e3, description: "Marketing analytics for two business units." }, - { product: "Integration Connector Pack", quantity: 1, unit_price: 16e3, description: "Marketing-automation connector pack." }, - { product: "Sandbox Environment (Annual)", quantity: 2, unit_price: 7500, description: "Two sandboxes for the marketing build-out." } - ], - "Stark Expansion (Lost)": [ - { product: "ObjectStack Platform", quantity: 2, unit_price: 5e4, description: "Two additional clinical tenants." }, - { product: "Field Service Mobile", quantity: 1, unit_price: 14e3, description: "Field service mobile for the device-servicing team." }, - { product: "AI Agent Seat (Annual)", quantity: 6, unit_price: 1e3, description: "Agent seats for the service coordinators." } - ], - "Globex Line Expansion (Lost)": [ - { product: "ObjectStack Platform", quantity: 2, unit_price: 5e4, description: "Two further production-line tenants." }, - { product: "Integration Connector Pack", quantity: 1, unit_price: 16e3, description: "Connector pack for the line-control systems." }, - { product: "AI Agent Seat (Annual)", quantity: 8, unit_price: 1e3, description: "Agent seats for the line supervisors." } - ], - "Northwind Field Service Pilot (Lost)": [ - { product: "Field Service Mobile", quantity: 1, unit_price: 14e3, description: "Field-service mobile for the metering crews." }, - { product: "Standard Support", quantity: 1, unit_price: 9e3, description: "Business-hours support during the pilot." }, - { product: "AI Agent Seat (Annual)", quantity: 10, unit_price: 1e3, description: "Agent seats for the dispatch desk." } - ], - "Apex Compliance Reporting (Lost)": [ - { product: "Analytics Add-on", quantity: 1, unit_price: 22e3, description: "Regulatory reporting pack for fleet compliance." }, - { product: "Sandbox Environment (Annual)", quantity: 1, unit_price: 7500, description: "Sandbox for the compliance rule build-out." }, - { product: "AI Agent Seat (Annual)", quantity: 6, unit_price: 1e3, description: "Agent seats for the compliance analysts." } - ], - "Northwind Grid Modernization": [ - { product: "ObjectStack Platform", quantity: 1, unit_price: 5e4, description: "Enterprise edition for grid, field and customer operations." }, - { product: "Field Service Mobile", quantity: 1, unit_price: 14e3, description: "Field-service mobile for the grid maintenance crews." }, - { product: "Sandbox Environment (Annual)", quantity: 1, unit_price: 7500, description: "Sandbox for the operational-data assessment." }, - { product: "AI Agent Seat (Annual)", quantity: 15, unit_price: 1e3, description: "Agent seats for the control-room pilot." } - ], - "Lattice Student Success Platform": [ - { product: "ObjectStack Platform (SMB Edition)", quantity: 2, unit_price: 18e3, description: "Student-success tenants for the two pilot colleges." }, - { product: "Admin Training Workshop", quantity: 2, unit_price: 6e3, description: "Two workshop days for the student-success advisers." }, - { product: "AI Agent Seat (Annual)", quantity: 5, unit_price: 1e3, description: "Agent seats for the advising team." } - ], - "Vertex Analytics Expansion": [ - { product: "Analytics Add-on", quantity: 2, unit_price: 22e3, description: "Analytics for the sales and marketing teams." }, - { product: "Premium Support", quantity: 1, unit_price: 25e3, description: "Premium support for the expanded footprint." }, - { product: "AI Agent Seat (Annual)", quantity: 10, unit_price: 1e3, description: "Agent seats for the revenue operations team." } - ], - "Apex Logistics Data Hub": [ - { product: "ObjectStack Platform", quantity: 1, unit_price: 5e4, description: "Data-hub tenant shared by commercial, operations and finance." }, - { product: "Data Migration Services", quantity: 1, unit_price: 35e3, description: "Consolidation of four fragmented commercial systems." }, - { product: "AI Agent Seat (Annual)", quantity: 8, unit_price: 1e3, description: "Agent seats for the commercial operations team." } - ], - "Lattice Education Renewal": [ - { product: "ObjectStack Platform", quantity: 1, unit_price: 5e4, description: "Renewal of the institution-wide tenant." }, - { product: "Analytics Add-on", quantity: 1, unit_price: 22e3, description: "Expanded analytics package for the renewal term." }, - { product: "AI Agent Seat (Annual)", quantity: 15, unit_price: 1e3, description: "Student-success automation seats." } - ], - "Vertex Enterprise Rollout": [ - { product: "ObjectStack Platform", quantity: 1, unit_price: 5e4, discount: 20, description: "Phase-one tenant for the first region, with data-residency controls (multi-phase commitment discount)." }, - { product: "Data Migration Services", quantity: 1, unit_price: 35e3, description: "Phase-one migration of the regional revenue data." }, - { product: "Standard Support", quantity: 1, unit_price: 9e3, description: "Business-hours support for phase one." }, - { product: "AI Agent Seat (Annual)", quantity: 10, unit_price: 1e3, description: "Agent seats for the first rollout wave." } - ], - // Campaign-attributed wins — see the campaign metrics note below. - "Lattice Analytics Expansion": [ - { product: "Analytics Add-on", quantity: 2, unit_price: 22e3, description: "Analytics for admissions and alumni engagement." }, - { product: "Admin Training Workshop", quantity: 1, unit_price: 6e3, description: "Analytics enablement day for the institutional-research team." }, - { product: "AI Agent Seat (Annual)", quantity: 20, unit_price: 1e3, description: "Agent seats for the admissions team." } - ], - "Wayne Operations Module Rollout": [ - { product: "ObjectStack Platform", quantity: 2, unit_price: 5e4, description: "Operations tenants for two manufacturing divisions." }, - { product: "Standard Support", quantity: 1, unit_price: 9e3, description: "Standard support for the operations rollout." }, - { product: "AI Agent Seat (Annual)", quantity: 11, unit_price: 1e3, description: "Agent seats for the operations planners." } - ], - "Vertex Developer Platform Adoption": [ - { product: "ObjectStack Platform", quantity: 3, unit_price: 5e4, description: "Developer platform tenants for three product teams." }, - { product: "Integration Connector Pack", quantity: 1, unit_price: 16e3, description: "Connector pack for the internal data warehouse." }, - { product: "Analytics Add-on", quantity: 1, unit_price: 22e3, description: "Product-usage analytics for the platform team." }, - { product: "AI Agent Seat (Annual)", quantity: 12, unit_price: 1e3, description: "Agent seats for the developer-experience team." } - ] -}; -var dealValue = (opportunityName, probability) => { - const lines = OPPORTUNITY_LINES[opportunityName]; - if (!lines) throw new Error(`Seed error: no line items authored for opportunity "${opportunityName}"`); - const amount = linesTotal(lines); - return { amount, expected_revenue: Math.round(amount * probability) / 100 }; -}; -var opportunities = defineSeed(Opportunity, { - mode: "upsert", - externalId: "name", - records: [ - { - name: "Acme Platform Upgrade", - crm_account: "Acme Corporation", - ...dealValue("Acme Platform Upgrade", 60), - stage: "proposal", - probability: 60, - close_date: cel31`daysFromNow(30)`, - type: "existing_upgrade", - forecast_category: "commit", - lead_source: "web", - stage_entry_date: celDaysAgo(12), - description: `Upgrade from Standard to Enterprise edition for the -NA + EMEA teams. Drivers: (1) AI agent governance becomes a hard -requirement after their internal compliance review, (2) advanced -analytics seats for the Ops org, (3) priority support SLA.`, - // This sentence used to DATE the workshop itself ("the week of - // close_date - 14d" => daysFromNow(16)) while the seeded event had it at - // daysFromNow(6) and a seeded task chased it at daysFromNow(7) — three - // records, three answers (#1660). The date now lives in exactly ONE - // place, the `crm_event` row in service.seed.ts, and this prose states - // only what stays true however that event is scheduled: it is booked, - // and its invitation has gone out (the attendee builder clamps - // `invited_date` at daysAgo(0), so a planned event's invite is never in - // the future). Re-dating the event therefore cannot strand this line. - // Do not put a date back here, absolute OR relative: a second copy is - // a second thing to drift. - next_step: `Send the revised proposal (Enterprise edition, 18-month term, 12% multi-year discount) to Jordan Park by EOW. The AI governance workshop with their compliance team is already booked and the invitation is out.` - }, - { - name: "Globex Manufacturing Suite", - crm_account: "Globex Industries", - ...dealValue("Globex Manufacturing Suite", 25), - stage: "qualification", - probability: 25, - close_date: cel31`daysFromNow(60)`, - type: "new_business", - forecast_category: "pipeline", - lead_source: "referral", - stage_entry_date: celDaysAgo(45) - }, - { - name: "Wayne Enterprise License", - crm_account: "Wayne Enterprises", - ...dealValue("Wayne Enterprise License", 80), - stage: "negotiation", - probability: 80, - close_date: cel31`daysFromNow(14)`, - type: "new_business", - forecast_category: "commit", - lead_source: "partner", - stage_entry_date: celDaysAgo(7) - }, - { - name: "Initech Cloud Migration", - crm_account: "Initech Solutions", - ...dealValue("Initech Cloud Migration", 40), - stage: "needs_analysis", - probability: 40, - close_date: cel31`daysFromNow(45)`, - type: "existing_upgrade", - forecast_category: "best_case", - lead_source: "event", - stage_entry_date: celDaysAgo(38) - }, - // ─── Closed Won deals (powers KPIs & revenue trends) ──────────────── - { - name: "Acme Annual Renewal 2025", - crm_account: "Acme Corporation", - ...dealValue("Acme Annual Renewal 2025", 100), - stage: "closed_won", - probability: 100, - close_date: cel31`daysAgo(15)`, - stage_entry_date: cel31`daysAgo(15)`, - type: "existing_renewal", - forecast_category: "closed", - lead_source: "partner", - win_reason: "relationship", - description: `Annual renewal of the Acme Standard subscription, signed two weeks ahead of the renewal date. 22% YoY uplift driven by seat expansion in the new EMEA team. Multi-year option declined this round \u2014 they want to see how the platform upgrade lands first.` - }, - { - name: "Stark Medical Pilot", - crm_account: "Stark Medical", - ...dealValue("Stark Medical Pilot", 100), - stage: "closed_won", - probability: 100, - close_date: cel31`daysAgo(50)`, - stage_entry_date: cel31`daysAgo(50)`, - type: "new_business", - forecast_category: "closed", - lead_source: "event", - win_reason: "best_fit" - }, - { - name: "Wayne Q1 Expansion", - crm_account: "Wayne Enterprises", - ...dealValue("Wayne Q1 Expansion", 100), - stage: "closed_won", - probability: 100, - close_date: cel31`daysAgo(95)`, - stage_entry_date: cel31`daysAgo(95)`, - type: "existing_upgrade", - forecast_category: "closed", - lead_source: "web", - win_reason: "better_product" - }, - { - name: "Globex Training Package", - crm_account: "Globex Industries", - ...dealValue("Globex Training Package", 100), - stage: "closed_won", - probability: 100, - close_date: cel31`daysAgo(140)`, - stage_entry_date: cel31`daysAgo(140)`, - type: "new_business", - forecast_category: "closed", - lead_source: "referral", - win_reason: "better_support" - }, - { - name: "Initech Phase 1", - crm_account: "Initech Solutions", - ...dealValue("Initech Phase 1", 100), - stage: "closed_won", - probability: 100, - close_date: cel31`daysAgo(200)`, - stage_entry_date: cel31`daysAgo(200)`, - type: "new_business", - forecast_category: "closed", - lead_source: "web", - win_reason: "better_price" - }, - // ─── Campaign-attributed wins ─────────────────────────────────────── - // `crm_campaign` is what `campaign_attribution_refresh` counts - // (`num_opportunities` / `num_won_opportunities` / the summed - // `actual_revenue`) — on every opportunity insert, update and delete, not - // once at completion. Before #591 not one opportunity carried it, so those - // three metrics were structurally zero and every campaign's seeded - // `actual_revenue` was a number the hook would have overwritten on the - // first attributed write. - // These three wins are what make the marketing ROI numbers below TRUE. - { - name: "Lattice Analytics Expansion", - crm_account: "Lattice Education", - primary_contact: "priya.shah@lattice.example.com", - crm_campaign: "Q3 Enterprise Email Nurture", - ...dealValue("Lattice Analytics Expansion", 100), - stage: "closed_won", - probability: 100, - close_date: cel31`daysAgo(6)`, - stage_entry_date: cel31`daysAgo(6)`, - type: "existing_expansion", - forecast_category: "closed", - lead_source: "email_campaign", - win_reason: "best_fit", - description: "Analytics package for admissions and alumni engagement, sourced from the enterprise nurture track." - }, - { - name: "Wayne Operations Module Rollout", - crm_account: "Wayne Enterprises", - primary_contact: "rwilson@wayne.example.com", - crm_campaign: "Operations Platform Launch", - ...dealValue("Wayne Operations Module Rollout", 100), - stage: "closed_won", - probability: 100, - close_date: cel31`daysAgo(4)`, - stage_entry_date: cel31`daysAgo(4)`, - type: "existing_upgrade", - forecast_category: "closed", - lead_source: "content", - description: "Operations module for two manufacturing divisions, closed off the operations-platform launch program.", - win_reason: "relationship" - }, - { - name: "Vertex Developer Platform Adoption", - crm_account: "Vertex Analytics", - primary_contact: "ethan.brooks@vertex.example.com", - crm_campaign: "Developer Content Marketing Push", - ...dealValue("Vertex Developer Platform Adoption", 100), - stage: "closed_won", - probability: 100, - close_date: cel31`daysAgo(6)`, - stage_entry_date: cel31`daysAgo(6)`, - type: "existing_expansion", - forecast_category: "closed", - lead_source: "content", - description: "Three product teams adopted the developer platform after the technical content series.", - win_reason: "better_product" - }, - // ─── Closed Lost deals (powers win-rate + loss-reason analytics) ──── - // - // Five losses across five distinct `loss_reason` values, and every one of - // them is now MANDATORY rather than decorative: `loss_reason` is - // `requiredWhen` stage is `closed_lost` (#593), so a seeded lost deal - // without one is rejected by the engine at seed time — the demo database - // cannot boot with the empty column that made the loss-reason widget - // unbuildable in the first place. - // - // Their `lead_source` values are chosen so that the sources carrying a loss - // ALSO carry a win (`web`, `referral`, `content`), plus two sources that - // only ever lost (`cold_call`, `advertisement`). That is what makes - // `win_rate_by_lead_source` a real measurement instead of a column of - // 100%s: three rows where both halves of the ratio move, and two rows that - // show what an all-loss source looks like. - { - name: "Acme Add-on (Lost)", - crm_account: "Acme Corporation", - ...dealValue("Acme Add-on (Lost)", 0), - stage: "closed_lost", - probability: 0, - close_date: cel31`daysAgo(25)`, - stage_entry_date: cel31`daysAgo(25)`, - type: "existing_upgrade", - forecast_category: "omitted", - lead_source: "cold_call", - loss_reason: "timing", - loss_details: "Marketing is locked into a 2-year HubSpot contract; the buying window opens when that renews.", - // This line used to end "Revisit in Q3" — a hand-typed calendar quarter - // on a record whose `close_date` is `daysAgo(25)`, so the quarter it told - // a rep to wait for is the one the deal was already lost in, and it - // contradicted this record's own `loss_details`: a 2-year lock does not - // reopen inside the quarter the deal closed in (#1712). Same ruling as - // the `next_step` block above (#1660): no date goes back into this prose, - // absolute OR relative. The renewal is the anchor that stays true however - // this record is dated — which is how `loss_details` and the account - // description already state it. - description: `Tried to bolt on the Marketing Cloud module via cold outbound. Lost because Acme's marketing org is already on a 2-year HubSpot contract. Revisit when that contract comes up for renewal \u2014 that is when the buying window opens.` - }, - { - name: "Stark Expansion (Lost)", - crm_account: "Stark Medical", - ...dealValue("Stark Expansion (Lost)", 0), - stage: "closed_lost", - probability: 0, - close_date: cel31`daysAgo(60)`, - stage_entry_date: cel31`daysAgo(60)`, - type: "new_business", - forecast_category: "omitted", - lead_source: "advertisement", - loss_reason: "no_budget", - loss_details: "Capital freeze on non-clinical systems for the rest of the fiscal year." - }, - { - name: "Globex Line Expansion (Lost)", - crm_account: "Globex Industries", - ...dealValue("Globex Line Expansion (Lost)", 0), - stage: "closed_lost", - probability: 0, - close_date: cel31`daysAgo(35)`, - stage_entry_date: cel31`daysAgo(35)`, - type: "existing_expansion", - forecast_category: "omitted", - lead_source: "referral", - loss_reason: "competitor", - loss_details: "Incumbent MES vendor bundled the two additional lines into an existing master agreement.", - description: "Expansion into two further production lines, lost to the incumbent MES vendor on bundling." - }, - { - name: "Northwind Field Service Pilot (Lost)", - crm_account: "Northwind Energy", - ...dealValue("Northwind Field Service Pilot (Lost)", 0), - stage: "closed_lost", - probability: 0, - close_date: cel31`daysAgo(80)`, - stage_entry_date: cel31`daysAgo(80)`, - type: "new_business", - forecast_category: "omitted", - lead_source: "web", - loss_reason: "price", - loss_details: "Per-technician pricing landed ~30% above the budget the operations director had approved.", - description: "Field-service pilot for the metering crews, lost on price against a cheaper point solution." - }, - { - name: "Apex Compliance Reporting (Lost)", - crm_account: "Apex Logistics", - ...dealValue("Apex Compliance Reporting (Lost)", 0), - stage: "closed_lost", - probability: 0, - close_date: cel31`daysAgo(110)`, - stage_entry_date: cel31`daysAgo(110)`, - type: "new_business", - forecast_category: "omitted", - lead_source: "content", - loss_reason: "features", - loss_details: "No native hours-of-service audit trail; the compliance team could not sign off without it.", - description: "Regulatory reporting pack for the fleet compliance team, lost on a missing audit-trail capability." - }, - // ─── Curated active pipeline ───────────────────────────────────── - // Two cards in each active stage make the kanban immediately legible in - // a customer demo. They also tell a coherent sales story instead of - // overwhelming the board with anonymous generated rows. - // - // PRICED TO STAY DRAGGABLE (#1902). A deal at or above - // `LARGE_DEAL_AMOUNT` is born into `opportunity_approval_on_create`, whose - // approval nodes hold the record with `lockRecord: true` — on the board - // that card refuses every drag with `RECORD_LOCKED`. When nine of the ten - // open deals sat over the line, the one board a demo opens first was - // frozen. So exactly TWO open deals exhibit the approval flow, one per - // tier, and both are in the block above: `Acme Platform Upgrade` - // (manager review only, $100K–$500K) and `Wayne Enterprise License` - // (manager, then director sign-off, over `HIGH_VALUE_DEAL_AMOUNT`). Every - // deal in this block is priced under the line, so each active stage keeps - // at least one card that moves. `test/seed-consistency.test.ts` pins the - // two by name — re-pricing a deal here over $100K goes red there. - { - name: "Northwind Grid Modernization", - crm_account: "Northwind Energy", - primary_contact: "olivia.chen@northwind.example.com", - ...dealValue("Northwind Grid Modernization", 10), - stage: "prospecting", - probability: 10, - close_date: cel31`daysFromNow(72)`, - type: "new_business", - forecast_category: "pipeline", - lead_source: "webinar", - stage_entry_date: celDaysAgo(4), - description: "Northwind is assessing a unified grid-modernization program after an executive webinar.", - next_step: "Confirm discovery participants and agree the operational-data assessment scope." - }, - { - name: "Lattice Student Success Platform", - crm_account: "Lattice Education", - primary_contact: "priya.shah@lattice.example.com", - crm_campaign: "Developer Content Marketing Push", - ...dealValue("Lattice Student Success Platform", 10), - stage: "prospecting", - probability: 10, - close_date: cel31`daysFromNow(96)`, - type: "new_business", - forecast_category: "pipeline", - lead_source: "content", - stage_entry_date: celDaysAgo(11), - description: "A new student-success initiative sourced from the higher-education content series.", - next_step: "Invite the operations sponsor to the discovery workshop." - }, - { - name: "Vertex Analytics Expansion", - crm_account: "Vertex Analytics", - primary_contact: "ethan.brooks@vertex.example.com", - ...dealValue("Vertex Analytics Expansion", 25), - stage: "qualification", - probability: 25, - close_date: cel31`daysFromNow(52)`, - type: "existing_expansion", - forecast_category: "pipeline", - lead_source: "partner", - stage_entry_date: celDaysAgo(8), - description: "Vertex wants to extend the platform from its data team to the full revenue organization.", - next_step: "Validate the buying committee, budget owner and expansion timeline." - }, - { - name: "Apex Logistics Data Hub", - crm_account: "Apex Logistics", - primary_contact: "marcus.reed@apexlogistics.example.com", - ...dealValue("Apex Logistics Data Hub", 40), - stage: "needs_analysis", - probability: 40, - close_date: cel31`daysFromNow(38)`, - type: "new_business", - forecast_category: "best_case", - lead_source: "partner", - stage_entry_date: celDaysAgo(18), - description: "Apex is mapping its fragmented commercial systems before committing to a data-hub program.", - next_step: "Complete the architecture workshop and quantify the integration backlog." - }, - { - name: "Lattice Education Renewal", - crm_account: "Lattice Education", - primary_contact: "priya.shah@lattice.example.com", - crm_campaign: "Q3 Enterprise Email Nurture", - ...dealValue("Lattice Education Renewal", 60), - stage: "proposal", - probability: 60, - close_date: cel31`daysFromNow(24)`, - type: "existing_renewal", - forecast_category: "commit", - lead_source: "email_campaign", - stage_entry_date: celDaysAgo(6), - description: "Renewal proposal adds student-success automation and an expanded analytics package.", - next_step: "Review the two-year option with procurement before the executive sponsor meeting." - }, - { - name: "Vertex Enterprise Rollout", - crm_account: "Vertex Analytics", - primary_contact: "ethan.brooks@vertex.example.com", - ...dealValue("Vertex Enterprise Rollout", 80), - stage: "negotiation", - probability: 80, - close_date: cel31`daysFromNow(11)`, - type: "existing_expansion", - forecast_category: "commit", - lead_source: "referral", - stage_entry_date: celDaysAgo(3), - description: "Phase one of an enterprise rollout, negotiated around phased deployment and data-residency requirements.", - next_step: "Resolve the final security addendum and confirm the procurement signature date." - } - ] -}); - -// src/sales/data/activity.seed.ts -import { defineSeed as defineSeed2 } from "@objectstack/spec/data"; -import { cel as cel32 } from "@objectstack/spec"; -var tasks = defineSeed2(Task, { - mode: "upsert", - externalId: "subject", - records: [ - { - subject: "Follow up with Acme on proposal", - description: "Send Jordan Park the revised Enterprise proposal and a 30-min calendar slot to walk through the AI governance section.", - status: "not_started", - priority: "high", - priority_rank: 3, - due_date: cel32`daysFromNow(2)`, - related_to_type: "crm_opportunity", - related_to_account: "Acme Corporation", - related_to_opportunity: "Acme Platform Upgrade" - }, - { - // The workshop this task asks someone to book is ALREADY on the - // calendar: the `Acme — AI agent governance workshop` event lower in - // this file is `planned` at daysFromNow(6), and the attendee builder - // dates its invitation `daysAgo(max(-6 + invitedDaysBefore(9), 0))` = - // daysAgo(3) — already sent, and already answered `tentative`. So the - // booking task is DONE, and it was done the day the invitation went - // out. An open "schedule it" task beside a booked-and-invited meeting - // is the contradiction itself, not a due date to nudge (#1660). - // - // The EVENT owns the workshop's date. Nothing here restates it — both - // dates below derive from the invitation instant — so there is no - // second copy to drift out of step. - subject: "Acme \u2014 schedule AI governance workshop", - description: "Block a 90-min joint workshop with Acme\u2019s compliance team to walk through how HotCRM agents handle data scoping, RBAC, audit trails, and human-in-the-loop. Pre-read: ADR-0007 + the governance demo deck.", - status: "completed", - priority: "high", - priority_rank: 3, - due_date: cel32`daysAgo(3)`, - completed_date: cel32`daysAgo(3)`, - // Hooks don't run over seeds — mirror what task_completion would stamp. - is_completed: true, - progress_percent: 100, - related_to_type: "crm_opportunity", - related_to_account: "Acme Corporation", - related_to_opportunity: "Acme Platform Upgrade" - }, - { - subject: "Acme \u2014 close out login-issues ticket before SLA", - description: "Confirm engineering has the EMEA SSO clock-skew patch ready, deploy to Acme\u2019s tenant, and send Lisa Kim a customer-facing post-mortem.", - status: "in_progress", - priority: "urgent", - priority_rank: 4, - due_date: cel32`daysFromNow(1)`, - related_to_type: "crm_case", - related_to_account: "Acme Corporation", - related_to_case: "Login issues after platform upgrade" - }, - { - subject: "Schedule demo for Globex team", - status: "in_progress", - priority: "normal", - priority_rank: 2, - due_date: cel32`daysFromNow(5)`, - related_to_type: "crm_account", - related_to_account: "Globex Industries" - }, - { - subject: "Prepare contract for Wayne Enterprises", - status: "not_started", - priority: "urgent", - priority_rank: 4, - due_date: cel32`daysFromNow(1)`, - related_to_type: "crm_account", - related_to_account: "Wayne Enterprises" - }, - { - subject: "Send welcome package to Stark Medical", - status: "completed", - priority: "low", - priority_rank: 1, - completed_date: cel32`daysAgo(2)`, - // Hooks don't run over seeds — mirror what task_completion would stamp. - is_completed: true, - progress_percent: 100, - related_to_type: "crm_account", - related_to_account: "Stark Medical" - }, - { - // Internal housekeeping task — deliberately unparented (the - // related_to_required rule is a warning, not an error). - subject: "Update CRM pipeline report", - status: "not_started", - priority: "normal", - priority_rank: 2, - due_date: cel32`daysFromNow(7)` - } - ] -}); -var EVENT_RELATED_FIELD = { - crm_account: "related_to_account", - crm_contact: "related_to_contact", - crm_opportunity: "related_to_opportunity", - crm_lead: "related_to_lead", - crm_case: "related_to_case" -}; -var celClock = (daysAgo, hour, minute) => { - const clock = `${hour}h${minute}m`; - return daysAgo >= 0 ? cel32`daysAgo(${daysAgo}) + duration(${clock})` : cel32`daysFromNow(${-daysAgo}) + duration(${clock})`; -}; -var EVENT_SPECS = [ - // ─── Acme Corporation — the hero account, worked across every parent ──── - { - subject: "Acme \u2014 Enterprise edition walkthrough", - type: "demo", - status: "held", - daysAgo: 2, - at: [10, 0], - minutes: 60, - relatedType: "crm_opportunity", - relatedKey: "Acme Platform Upgrade", - account: "Acme Corporation", - location: "Zoom", - outcome: "Walked the Ops team through agent governance and the analytics seats. Revised proposal to follow this week.", - attendees: [{ contact: "john.smith@acme.example.com", response: "accepted" }] - }, - { - subject: "Acme \u2014 proposal follow-up call", - type: "call", - status: "held", - daysAgo: 5, - at: [15, 30], - minutes: 25, - relatedType: "crm_contact", - relatedKey: "john.smith@acme.example.com", - account: "Acme Corporation", - outcome: "Procurement wants an 18-month term. Pricing to be re-cut before the governance workshop.", - attendees: [{ contact: "john.smith@acme.example.com", response: "accepted" }] - }, - { - subject: "Acme \u2014 AI governance scoping session", - type: "meeting", - status: "held", - daysAgo: 12, - at: [9, 0], - minutes: 90, - relatedType: "crm_account", - relatedKey: "Acme Corporation", - location: "Google Meet", - outcome: "Agreed the workshop agenda: data scoping, RBAC, audit trails, human-in-the-loop.", - attendees: [{ contact: "john.smith@acme.example.com", response: "accepted" }] - }, - { - subject: "Acme \u2014 login incident status call", - type: "call", - status: "held", - daysAgo: 16, - at: [8, 30], - minutes: 20, - relatedType: "crm_case", - relatedKey: "Login issues after platform upgrade", - account: "Acme Corporation", - outcome: "Confirmed the EMEA SSO clock-skew hypothesis; engineering reproducing in staging.", - attendees: [{ contact: "john.smith@acme.example.com", response: "accepted" }] - }, - { - subject: "Acme \u2014 renewal signature review", - type: "meeting", - status: "held", - daysAgo: 20, - at: [14, 0], - minutes: 45, - relatedType: "crm_opportunity", - relatedKey: "Acme Annual Renewal 2025", - account: "Acme Corporation", - outcome: "Signed two weeks ahead of the renewal date. Multi-year deferred to the upgrade decision.", - attendees: [{ contact: "john.smith@acme.example.com", response: "accepted" }] - }, - { - subject: "Acme \u2014 San Francisco HQ business review", - type: "onsite_visit", - status: "held", - daysAgo: 33, - at: [13, 0], - minutes: 120, - relatedType: "crm_account", - relatedKey: "Acme Corporation", - location: "500 Howard Street, Suite 400, San Francisco", - outcome: "Quarterly review with the CTO org. Expansion into the EMEA team confirmed as the next motion.", - attendees: [{ contact: "john.smith@acme.example.com", response: "accepted" }] - }, - // ─── Wayne Enterprises — a deal in negotiation ────────────────────────── - { - subject: "Wayne \u2014 enterprise license negotiation", - type: "meeting", - status: "held", - daysAgo: 3, - at: [16, 0], - minutes: 60, - relatedType: "crm_opportunity", - relatedKey: "Wayne Enterprise License", - account: "Wayne Enterprises", - location: "Zoom", - outcome: "Volume tier agreed at 20 tenants. Security addendum is the last open item.", - attendees: [{ contact: "rwilson@wayne.example.com", response: "accepted" }] - }, - { - subject: "Wayne \u2014 security addendum walkthrough", - type: "call", - status: "held", - daysAgo: 8, - at: [11, 0], - minutes: 30, - relatedType: "crm_contact", - relatedKey: "rwilson@wayne.example.com", - account: "Wayne Enterprises", - outcome: "Legal to return redlines within the week.", - attendees: [{ contact: "rwilson@wayne.example.com", response: "accepted" }] - }, - { - subject: "Wayne \u2014 platform governance webinar", - type: "webinar", - status: "held", - daysAgo: 26, - at: [15, 0], - minutes: 60, - relatedType: "crm_account", - relatedKey: "Wayne Enterprises", - location: "https://acme.example.com/webinars/governance", - outcome: "Four business units attended; two asked for their own rollout plan.", - attendees: [{ contact: "rwilson@wayne.example.com", response: "accepted" }] - }, - { - subject: "Wayne \u2014 bulk import rollout check-in", - type: "call", - status: "held", - daysAgo: 45, - at: [10, 30], - minutes: 25, - relatedType: "crm_case", - relatedKey: "Request: bulk import via CSV", - account: "Wayne Enterprises", - outcome: "CSV import shipped and documented; the customer closed the request out on the call.", - attendees: [{ contact: "rwilson@wayne.example.com", response: "accepted" }] - }, - // ─── Vertex Analytics — expansion, then an enterprise rollout ─────────── - { - subject: "Vertex \u2014 rollout phasing and data residency", - type: "meeting", - status: "held", - daysAgo: 1, - at: [9, 30], - minutes: 75, - relatedType: "crm_opportunity", - relatedKey: "Vertex Enterprise Rollout", - account: "Vertex Analytics", - location: "Zoom", - outcome: "Phase 1 scoped to four regions. Residency controls to be confirmed with their security team.", - attendees: [{ contact: "ethan.brooks@vertex.example.com", response: "accepted" }] - }, - { - subject: "Vertex \u2014 revenue analytics demo", - type: "demo", - status: "held", - daysAgo: 10, - at: [14, 30], - minutes: 45, - relatedType: "crm_opportunity", - relatedKey: "Vertex Analytics Expansion", - account: "Vertex Analytics", - location: "Zoom", - outcome: "Sales, marketing and service leads all asked for their own workspace \u2014 the expansion case makes itself.", - attendees: [{ contact: "ethan.brooks@vertex.example.com", response: "accepted" }] - }, - { - subject: "Vertex \u2014 expansion buying committee call", - type: "call", - status: "held", - daysAgo: 19, - at: [16, 30], - minutes: 30, - relatedType: "crm_contact", - relatedKey: "ethan.brooks@vertex.example.com", - account: "Vertex Analytics", - outcome: "CRO owns the budget; the data team stays the technical sponsor.", - attendees: [{ contact: "ethan.brooks@vertex.example.com", response: "accepted" }] - }, - { - subject: "Vertex \u2014 developer platform retrospective", - type: "meeting", - status: "held", - daysAgo: 38, - at: [11, 0], - minutes: 60, - relatedType: "crm_account", - relatedKey: "Vertex Analytics", - outcome: "Three product teams live on the developer platform; usage analytics is the next ask.", - attendees: [{ contact: "ethan.brooks@vertex.example.com", response: "accepted" }] - }, - // ─── Stark Medical — the partner motion ──────────────────────────────── - { - subject: "Stark Medical \u2014 Toronto clinical operations visit", - type: "onsite_visit", - status: "held", - daysAgo: 52, - at: [9, 0], - minutes: 180, - relatedType: "crm_account", - relatedKey: "Stark Medical", - location: "181 Bay Street, Suite 2200, Toronto", - outcome: "Two clinical service lines live on the pilot. Device-servicing expansion parked on budget.", - attendees: [{ contact: "emily.d@starkmed.example.com", response: "accepted" }] - }, - // ─── Leads: the only held rows that touch a prospect's own clock ──────── - { - subject: "CloudFirst \u2014 qualification call with Lisa Thompson", - type: "call", - status: "held", - daysAgo: 1, - at: [11, 0], - minutes: 30, - relatedType: "crm_lead", - relatedKey: "lisa.t@cloudfirst.example.com", - outcome: "Budget confirmed and a technical evaluation agreed \u2014 qualified.", - attendees: [{ lead: "lisa.t@cloudfirst.example.com", response: "accepted" }] - }, - { - subject: "EduTech Labs \u2014 discovery call with David Kim", - type: "call", - status: "held", - daysAgo: 4, - at: [13, 0], - minutes: 30, - relatedType: "crm_lead", - relatedKey: "dkim@edutechlabs.example.com", - outcome: "Replacing spreadsheets across admissions. Referral source confirmed.", - attendees: [{ lead: "dkim@edutechlabs.example.com", response: "accepted" }] - }, - // The earlier touch on each of the two leads above, so each lead's Activity - // tab reads as a short history rather than a single row. Both leads already - // carry `last_contacted_date: today()` for their later call, so a second held - // row moves no recency clock (`event_activity_bubble` stamps the seed moment). - { - subject: "CloudFirst \u2014 follow-up meeting after the Cloud Summit booth", - type: "meeting", - status: "held", - daysAgo: 8, - at: [15, 0], - minutes: 45, - relatedType: "crm_lead", - relatedKey: "lisa.t@cloudfirst.example.com", - outcome: "Walked through pipeline and forecasting. Asked for a qualification call with finance.", - attendees: [{ lead: "lisa.t@cloudfirst.example.com", response: "accepted" }] - }, - { - subject: "EduTech Labs \u2014 referral intro call with David Kim", - type: "call", - status: "held", - daysAgo: 9, - at: [10, 0], - minutes: 15, - relatedType: "crm_lead", - relatedKey: "dkim@edutechlabs.example.com", - outcome: "Warm intro from the referring partner. Booked a proper discovery call.", - attendees: [{ lead: "dkim@edutechlabs.example.com", response: "accepted" }] - }, - // ─── Booked, not held: the calendar ahead ─────────────────────────────── - // These are what `status` exists for. Not one of them moves a recency clock, - // and the three re-engagement rows below sit on the accounts the churn tiles - // count — which is the demonstration, not an oversight. - { - subject: "Acme \u2014 AI agent governance workshop", - type: "meeting", - status: "planned", - daysAgo: -6, - at: [9, 0], - minutes: 90, - relatedType: "crm_opportunity", - relatedKey: "Acme Platform Upgrade", - account: "Acme Corporation", - location: "Google Meet", - description: "Joint workshop with Acme compliance: data scoping, RBAC, audit trails, human-in-the-loop.", - attendees: [{ contact: "john.smith@acme.example.com", response: "tentative" }], - invitedDaysBefore: 9 - }, - { - subject: "Wayne \u2014 procurement signature call", - type: "meeting", - status: "planned", - daysAgo: -1, - at: [11, 0], - minutes: 30, - relatedType: "crm_opportunity", - relatedKey: "Wayne Enterprise License", - account: "Wayne Enterprises", - description: "Confirm the signature date once the security addendum is closed.", - attendees: [{ contact: "rwilson@wayne.example.com", response: "accepted" }], - invitedDaysBefore: 4 - }, - { - subject: "Globex \u2014 manufacturing suite demo", - type: "demo", - status: "planned", - daysAgo: -5, - at: [15, 0], - minutes: 60, - relatedType: "crm_opportunity", - relatedKey: "Globex Manufacturing Suite", - account: "Globex Industries", - location: "Zoom", - description: "Plant-operations demo for the six-site rollout, ahead of the qualification review.", - attendees: [{ contact: "sarah.j@globex.example.com", response: "accepted" }], - invitedDaysBefore: 8 - }, - { - subject: "Lattice \u2014 renewal proposal review", - type: "meeting", - status: "planned", - daysAgo: -3, - at: [10, 0], - minutes: 45, - relatedType: "crm_opportunity", - relatedKey: "Lattice Education Renewal", - account: "Lattice Education", - description: "Walk procurement through the two-year option before the executive sponsor meeting.", - attendees: [{ contact: "priya.shah@lattice.example.com", response: "accepted" }], - invitedDaysBefore: 6 - }, - { - subject: "Initech \u2014 re-engagement call before renewal", - type: "call", - status: "planned", - daysAgo: -2, - at: [14, 0], - minutes: 30, - relatedType: "crm_account", - relatedKey: "Initech Solutions", - description: "Nobody has spoken to Initech in ten weeks and the renewal is 75 days out. Re-open the relationship.", - attendees: [{ contact: "mchen@initech.example.com", response: "no_response" }], - invitedDaysBefore: 5 - }, - { - subject: "Northwind \u2014 grid modernization discovery workshop", - type: "meeting", - status: "planned", - daysAgo: -7, - at: [9, 30], - minutes: 120, - relatedType: "crm_opportunity", - relatedKey: "Northwind Grid Modernization", - account: "Northwind Energy", - location: "Leopoldstrasse 21, Munich", - description: "Confirm discovery participants and agree the operational-data assessment scope.", - attendees: [{ contact: "olivia.chen@northwind.example.com", response: "tentative" }], - invitedDaysBefore: 10 - }, - { - subject: "Apex Logistics \u2014 data hub re-engagement call", - type: "call", - status: "planned", - daysAgo: -4, - at: [16, 0], - minutes: 30, - relatedType: "crm_account", - relatedKey: "Apex Logistics", - description: "The data-hub evaluation has been silent for a quarter. Re-establish the commercial sponsor.", - attendees: [{ contact: "marcus.reed@apexlogistics.example.com", response: "no_response" }], - invitedDaysBefore: 6 - }, - { - subject: "NextGen Retail \u2014 first discovery call with Alice Martinez", - type: "call", - status: "planned", - daysAgo: -2, - at: [15, 0], - minutes: 30, - relatedType: "crm_lead", - relatedKey: "alice@nextgenretail.example.com", - description: "Inbound web lead, booked on her follow-up date.", - attendees: [{ lead: "alice@nextgenretail.example.com", response: "no_response" }], - invitedDaysBefore: 3 - }, - // ─── Neither held nor booked ──────────────────────────────────────────── - // `duration_minutes` is 0 on both, exactly as `event_schedule_derive` - // recomputes it: a meeting nobody attended occupies nobody's time, while the - // calendar slot it was booked into stays on the record as evidence of the - // attempt. - { - subject: "Globex \u2014 line expansion review", - type: "meeting", - status: "cancelled", - daysAgo: 30, - at: [14, 0], - minutes: 60, - relatedType: "crm_opportunity", - relatedKey: "Globex Line Expansion (Lost)", - account: "Globex Industries", - description: "Cancelled by the customer: the incumbent MES vendor had already bundled the two lines.", - attendees: [{ contact: "sarah.j@globex.example.com", response: "declined" }], - invitedDaysBefore: 7 - }, - { - subject: "Initech \u2014 SSO configuration check-in", - type: "call", - status: "no_show", - daysAgo: 55, - at: [10, 0], - minutes: 30, - relatedType: "crm_account", - relatedKey: "Initech Solutions", - description: "Customer did not join. The last attempt to reach Initech before the account went quiet.", - attendees: [{ contact: "mchen@initech.example.com", response: "no_response" }], - invitedDaysBefore: 4 - } -]; -var endClock = (spec) => { - const total = spec.at[0] * 60 + spec.at[1] + spec.minutes; - return [Math.floor(total / 60), total % 60]; -}; -var events = defineSeed2(Event, { - mode: "upsert", - externalId: "subject", - records: EVENT_SPECS.map((spec) => { - const [endHour, endMinute] = endClock(spec); - return { - subject: spec.subject, - type: spec.type, - status: spec.status, - start_datetime: celClock(spec.daysAgo, spec.at[0], spec.at[1]), - end_datetime: celClock(spec.daysAgo, endHour, endMinute), - // Authored rather than left to the hook, and authored to the value the - // hook computes: `event_schedule_derive` measures the gap between the two - // timestamps above, then zeroes it for a cancelled / no-show row. Both - // branches agree with this literal, so the figure is right whether or not - // hooks fire over the seed write (`./_shared.ts`, doctrine rule 2). - duration_minutes: spec.status === "cancelled" || spec.status === "no_show" ? 0 : spec.minutes, - all_day: false, - related_to_type: spec.relatedType, - [EVENT_RELATED_FIELD[spec.relatedType]]: spec.relatedKey, - // The account link is authored on every row that has one, including rows - // whose `related_to_type` is the contact / opportunity / case — the same - // shape the task seeds use, and what fills the ACCOUNT's activity list. - ...spec.account && spec.relatedType !== "crm_account" ? { related_to_account: spec.account } : {}, - ...spec.location ? { location: spec.location } : {}, - ...spec.description ? { description: spec.description } : {}, - ...spec.outcome ? { outcome_notes: spec.outcome } : {} - // No `owner_id`: a seed cannot name a user (see `objectstack.composition.ts`, - // "A seed can't name a user"), so these rows land ownerless and the - // platform's seed-ownership claim hands them to the first administrator - // when the seed settles (#671, #1892). - }; - }) -}); -var attendeeRecords = (kind) => EVENT_SPECS.flatMap( - (spec) => spec.attendees.filter((a) => kind === "lead" ? a.lead : a.contact).map((a) => ({ - crm_event: spec.subject, - attendee_type: kind, - ...kind === "lead" ? { crm_lead: a.lead } : { crm_contact: a.contact }, - response: a.response, - is_organizer: false, - // The invitation predates the slot. Clamped at 0 so a meeting booked - // for the day after tomorrow was invited today, never tomorrow. - invited_date: celDaysAgo(Math.max(spec.daysAgo + (spec.invitedDaysBefore ?? 3), 0)) - })) -); -var eventAttendeesFromContacts = defineSeed2(EventAttendee, { - mode: "upsert", - externalId: ["crm_event", "crm_contact"], - records: attendeeRecords("contact") -}); -var eventAttendeesFromLeads = defineSeed2(EventAttendee, { - mode: "upsert", - externalId: ["crm_event", "crm_lead"], - records: attendeeRecords("lead") -}); -var SYS_ACTIVITY_RETENTION_DAYS = 14; -var LOGGED_SUMMARY_PREFIX = { - call: "", - meeting: "Meeting: " -}; -var leadInteractionPointers = { - object: "sys_activity", - mode: "upsert", - // One timeline pointer per rich source record, exactly as the action writes - // it. Matched on the RESOLVED ids, so replay boots dedupe. - externalId: ["source_object", "source_id"], - records: EVENT_SPECS.filter( - (spec) => spec.relatedType === "crm_lead" && spec.status === "held" && LOGGED_SUMMARY_PREFIX[spec.type] !== void 0 && spec.daysAgo >= 0 && spec.daysAgo < SYS_ACTIVITY_RETENTION_DAYS - ).map((spec) => { - const [endHour, endMinute] = endClock(spec); - return { - // `held` is what both actions write as `completed` — the `task` feed - // kind, the one the lead Activity tab renders. - type: "completed", - // The action's own summary: prefix, subject, duration in brackets. - summary: `${LOGGED_SUMMARY_PREFIX[spec.type]}${spec.subject} (${spec.minutes} min)`, - // Logged when the slot ended. - timestamp: celClock(spec.daysAgo, endHour, endMinute), - object_name: "crm_lead", - record_id: spec.relatedKey, - source_object: "crm_event", - source_id: spec.subject, - metadata: JSON.stringify({ - kind: spec.type, - duration_minutes: spec.minutes, - notes: spec.outcome ?? "", - attendee_count: spec.attendees.length - }) - }; - }) -}; - -// src/sales/data/forecast.seed.ts -import { defineSeed as defineSeed3 } from "@objectstack/spec/data"; -import { cel as cel33 } from "@objectstack/spec"; -var FORECAST_MONTHS = ["Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"]; -var forecastIsoDate = (d) => `${d.getUTCFullYear()}-${String(d.getUTCMonth() + 1).padStart(2, "0")}-${String(d.getUTCDate()).padStart(2, "0")}`; -var forecastQuarterLabel = (d) => `Q${Math.floor(d.getUTCMonth() / 3) + 1} ${d.getUTCFullYear()}`; -var forecastMonthLabel = (d) => `${FORECAST_MONTHS[d.getUTCMonth()]} ${d.getUTCFullYear()}`; -var forecastNow = /* @__PURE__ */ new Date(); -var forecastYear = forecastNow.getUTCFullYear(); -var forecastMonth = forecastNow.getUTCMonth(); -var forecastQuarterMonth = Math.floor(forecastMonth / 3) * 3; -var thisMonthStart = new Date(Date.UTC(forecastYear, forecastMonth, 1)); -var thisMonthEnd = new Date(Date.UTC(forecastYear, forecastMonth + 1, 0)); -var lastQuarterStart = new Date(Date.UTC(forecastYear, forecastQuarterMonth - 3, 1)); -var lastQuarterEnd = new Date(Date.UTC(forecastYear, forecastQuarterMonth, 0)); -var quarterStartAgo = (n) => new Date(Date.UTC(forecastYear, forecastQuarterMonth - 3 * n, 1)); -var quarterEndAgo = (n) => new Date(Date.UTC(forecastYear, forecastQuarterMonth - 3 * (n - 1), 0)); -var monthStartAgo = (n) => new Date(Date.UTC(forecastYear, forecastMonth - n, 1)); -var monthEndAgo = (n) => new Date(Date.UTC(forecastYear, forecastMonth - n + 1, 0)); -var closedPeriod = (seed_key, period, start, end, quota, closed, open, notes) => ({ - seed_key, - period, - period_label: period === "quarter" ? forecastQuarterLabel(start) : forecastMonthLabel(start), - period_start: forecastIsoDate(start), - period_end: forecastIsoDate(end), - snapshot_date: forecastIsoDate(end), - quota, - pipeline_amount: open.pipeline, - best_case_amount: open.bestCase, - commit_amount: open.commit, - closed_amount: closed, - source: "scheduled", - notes -}); -var forecasts = defineSeed3(Forecast, { - mode: "upsert", - externalId: "seed_key", - records: [ - { - seed_key: "demo_month_current", - period: "month", - period_label: forecastMonthLabel(thisMonthStart), - period_start: forecastIsoDate(thisMonthStart), - period_end: forecastIsoDate(thisMonthEnd), - snapshot_date: cel33`today()`, - quota: 5e5, - pipeline_amount: 76e4, - best_case_amount: 54e4, - commit_amount: 36e4, - closed_amount: 295e3, - source: "scheduled", - notes: "Healthy coverage; two commit deals expected to close this week." - }, - { - seed_key: "demo_quarter_minus_1", - period: "quarter", - period_label: forecastQuarterLabel(lastQuarterStart), - period_start: forecastIsoDate(lastQuarterStart), - period_end: forecastIsoDate(lastQuarterEnd), - snapshot_date: forecastIsoDate(lastQuarterEnd), - quota: 14e5, - pipeline_amount: 24e4, - best_case_amount: 15e4, - commit_amount: 95e3, - closed_amount: 1485e3, - source: "scheduled", - notes: "Closed at 106% of quota." - }, - closedPeriod( - "demo_quarter_minus_2", - "quarter", - quarterStartAgo(2), - quarterEndAgo(2), - 13e5, - 1196e3, - { pipeline: 285e3, bestCase: 19e4, commit: 12e4 }, - "Closed at 92% of quota \u2014 two enterprise deals slipped into the next quarter." - ), - closedPeriod( - "demo_quarter_minus_3", - "quarter", - quarterStartAgo(3), - quarterEndAgo(3), - 12e5, - 1308e3, - { pipeline: 195e3, bestCase: 13e4, commit: 85e3 }, - "Closed at 109% of quota, carried by the enterprise renewal cohort." - ), - closedPeriod( - "demo_quarter_minus_4", - "quarter", - quarterStartAgo(4), - quarterEndAgo(4), - 11e5, - 1045e3, - { pipeline: 165e3, bestCase: 11e4, commit: 7e4 }, - "Closed at 95% of quota in the first quarter on the new territory model." - ), - closedPeriod( - "demo_month_minus_1", - "month", - monthStartAgo(1), - monthEndAgo(1), - 48e4, - 505e3, - { pipeline: 96e3, bestCase: 62e3, commit: 4e4 }, - "Closed at 105% of quota; the expansion motion covered a soft new-business month." - ), - closedPeriod( - "demo_month_minus_2", - "month", - monthStartAgo(2), - monthEndAgo(2), - 46e4, - 414e3, - { pipeline: 92e3, bestCase: 58e3, commit: 35e3 }, - "Closed at 90% of quota \u2014 summer slowdown across the mid-market segment." - ) - ] -}); - -// src/sales/data/index.ts -var COMPOSITION_ENV_VAR = "HOTCRM_COMPOSITION"; -var HOTCRM_COMPOSITIONS = ["default", "saas"]; -function resolveComposition(raw = process.env[COMPOSITION_ENV_VAR]) { - const value = (raw ?? "").trim(); - if (value === "") return "default"; - if (HOTCRM_COMPOSITIONS.includes(value)) { - return value; - } - throw new Error( - `${COMPOSITION_ENV_VAR}="${value}" is not a HotCRM composition. Expected one of: ${HOTCRM_COMPOSITIONS.join(", ")} (or leave it unset for 'default').` - ); -} - -// src/revenue/data/catalog.seed.ts -import { defineSeed as defineSeed4 } from "@objectstack/spec/data"; -var products = defineSeed4(Product, { - mode: "upsert", - externalId: "name", - records: [ - { - name: "ObjectStack Platform", - description: "The enterprise edition: unlimited objects, AI agents, governance and audit.", - category: "software", - family: "enterprise", - sku: "OS-PLAT-ENT", - list_price: 5e4, - cost: 12e3, - is_active: true - }, - { - name: "ObjectStack Platform (SMB Edition)", - description: "The mid-market edition: core CRM objects and automation, capped agent usage.", - category: "software", - family: "smb", - sku: "OS-PLAT-SMB", - list_price: 18e3, - cost: 4500, - is_active: true - }, - { - name: "Cloud Hosting (Annual)", - description: "Managed hosting with regional data residency and a 99.9% availability target.", - category: "subscription", - family: "cloud", - sku: "OS-CLOUD-HOST", - list_price: 12e3, - cost: 4200, - is_active: true - }, - { - name: "Sandbox Environment (Annual)", - description: "A full-copy non-production environment for testing metadata changes before release.", - category: "subscription", - family: "cloud", - sku: "OS-CLOUD-SBX", - list_price: 7500, - cost: 2600, - is_active: true - }, - { - name: "AI Agent Seat (Annual)", - description: "A named-user seat for the Co-Pilot and agent surfaces, billed annually.", - category: "subscription", - family: "cloud", - sku: "OS-AI-SEAT", - list_price: 1e3, - cost: 260, - is_active: true - }, - { - name: "Analytics Add-on", - description: "Dashboards, cubes and scheduled reporting for the revenue organization.", - category: "software", - family: "enterprise", - sku: "OS-ADDON-ANL", - list_price: 22e3, - cost: 6500, - is_active: true - }, - { - name: "Integration Connector Pack", - description: "Pre-built connectors for ERP, marketing automation and data warehouse targets.", - category: "software", - family: "enterprise", - sku: "OS-ADDON-INT", - list_price: 16e3, - cost: 5200, - is_active: true - }, - { - name: "Field Service Mobile", - description: "Offline-capable mobile app for field technicians and route-based service work.", - category: "software", - family: "smb", - sku: "OS-ADDON-FSM", - list_price: 14e3, - cost: 4200, - is_active: true - }, - { - name: "Premium Support", - description: "24\xD77 support with a one-hour P1 response target and a named technical account manager.", - category: "support", - family: "services", - sku: "OS-SUP-PREM", - list_price: 25e3, - cost: 9e3, - is_active: true - }, - { - name: "Standard Support", - description: "Business-hours support with a next-business-day response target.", - category: "support", - family: "services", - sku: "OS-SUP-STD", - list_price: 9e3, - cost: 3600, - is_active: true - }, - { - name: "Implementation Services", - description: "Guided implementation: discovery, metadata build, integration and go-live support.", - category: "service", - family: "services", - sku: "OS-SVC-IMPL", - list_price: 75e3, - cost: 41e3, - is_active: true - }, - { - name: "Data Migration Services", - description: "Extraction, mapping and reconciliation of legacy CRM and spreadsheet data.", - category: "service", - family: "services", - sku: "OS-SVC-MIGR", - list_price: 35e3, - cost: 19e3, - is_active: true - }, - { - name: "Admin Training Workshop", - description: "A one-day workshop for administrators on metadata, permissions and analytics.", - category: "service", - family: "services", - sku: "OS-SVC-TRN", - list_price: 6e3, - cost: 2400, - is_active: true - } - ] -}); -var catalogPrice = (productName) => { - const product = products.records.find((r) => r.name === productName); - if (!product || typeof product.list_price !== "number") { - throw new Error(`Seed error: no catalog product named "${productName}"`); - } - return product.list_price; -}; -var lineItemRecords = (parentField, table) => Object.entries(table).flatMap( - ([parent, lines]) => lines.map((l, i) => ({ - [parentField]: parent, - crm_product: l.product, - description: l.description, - quantity: l.quantity, - list_price: catalogPrice(l.product), - unit_price: l.unit_price, - discount: l.discount ?? 0, - line_number: i + 1 - })) -); - -// src/revenue/data/opportunity-line-item.seed.ts -import { defineSeed as defineSeed5 } from "@objectstack/spec/data"; -var opportunityLineItems = defineSeed5(OpportunityLineItem, { - mode: "upsert", - externalId: ["crm_opportunity", "crm_product"], - records: lineItemRecords("crm_opportunity", OPPORTUNITY_LINES) -}); - -// src/revenue/data/revenue.seed.ts -import { defineSeed as defineSeed6 } from "@objectstack/spec/data"; -import { cel as cel34 } from "@objectstack/spec"; -var contracts = defineSeed6(Contract, { - mode: "upsert", - externalId: "description", - records: [ - // The one ACTIVATED contract in the app — `contract_renewal`, - // `contract_expiration` and `billing_handoff` all filter on exactly that - // status — so it has to be a contract that was really signed, off a deal - // that was really won. - // - // It used to link `Acme Platform Upgrade` and carry that deal's line total - // (150000) while that deal is still `proposal`, closing `daysFromNow(30)` - // (#1661). Nothing in this app can produce that pairing: `quote_on_accepted` - // close-wins an opportunity the moment its quote is accepted, and - // `closed_won` is TERMINAL in `opportunity_stage_progression` — so a signed - // contract can never sit on an open deal, from either direction. - // - // Every field below is now derived from `Acme Annual Renewal 2025`, the - // `closed_won` deal this contract's own description was already describing: - // contract_value — that deal's line-item total, which is also the ARR the - // account description reports. 150000 was the upgrade's - // total, i.e. the value came from a different deal than - // the link did; - // signed_date — its `close_date`: you sign when you win, and - // `quote_on_accepted` stamps that same day; - // start_date — signature + 14d, because that deal's description says - // it was "signed two weeks ahead of the renewal date"; - // end_date — start + 365d, the span every other row here uses for a - // 12-month term. - { - crm_account: "Acme Corporation", - crm_contact: "john.smith@acme.example.com", - crm_opportunity: "Acme Annual Renewal 2025", - status: "activated", - contract_term_months: 12, - start_date: cel34`daysAgo(1)`, - end_date: cel34`daysFromNow(364)`, - contract_value: 22e4, - billing_frequency: "annually", - payment_terms: "net_30", - auto_renewal: true, - renewal_notice_days: 60, - contract_type: "subscription", - signed_date: cel34`daysAgo(15)`, - signed_by: "John Smith", - description: "Annual platform subscription with premium support tier." - }, - { - crm_account: "Wayne Enterprises", - crm_contact: "rwilson@wayne.example.com", - crm_opportunity: "Wayne Enterprise License", - status: "in_approval", - contract_term_months: 36, - start_date: cel34`daysFromNow(14)`, - end_date: cel34`daysFromNow(1109)`, - contract_value: 12e5, - billing_frequency: "annually", - payment_terms: "net_60", - auto_renewal: false, - renewal_notice_days: 90, - contract_type: "license", - description: "Multi-year enterprise license with custom SLA." - }, - { - crm_account: "Initech Solutions", - crm_contact: "mchen@initech.example.com", - status: "expired", - contract_term_months: 12, - start_date: cel34`daysAgo(400)`, - end_date: cel34`daysAgo(35)`, - contract_value: 6e4, - billing_frequency: "quarterly", - payment_terms: "net_30", - auto_renewal: false, - renewal_notice_days: 30, - contract_type: "service", - signed_date: cel34`daysAgo(405)`, - signed_by: "Michael Chen", - description: "Initial service agreement, pending renewal discussion." - }, - { - crm_account: "Stark Medical", - crm_contact: "emily.d@starkmed.example.com", - status: "draft", - contract_term_months: 24, - start_date: cel34`daysFromNow(30)`, - end_date: cel34`daysFromNow(760)`, - contract_value: 35e4, - billing_frequency: "monthly", - payment_terms: "net_30", - auto_renewal: true, - renewal_notice_days: 60, - contract_type: "partnership", - description: "Healthcare partnership agreement, currently under legal review." - } - ] -}); -var QUOTE_LINES = { - "Acme Platform Upgrade Quote": OPPORTUNITY_LINES["Acme Platform Upgrade"], - "Acme Annual Renewal 2025 Quote": OPPORTUNITY_LINES["Acme Annual Renewal 2025"], - "Globex Manufacturing Suite Proposal": OPPORTUNITY_LINES["Globex Manufacturing Suite"], - "Wayne Enterprise License Quote": OPPORTUNITY_LINES["Wayne Enterprise License"], - "Initech Cloud Migration Estimate": OPPORTUNITY_LINES["Initech Cloud Migration"], - // Quoted standalone, before any opportunity existed — and then rejected. - "Stark Medical Pilot Quote": [ - { product: "Admin Training Workshop", quantity: 5, unit_price: 6e3, description: "Five workshop days for the pilot clinical teams." }, - { product: "Standard Support", quantity: 1, unit_price: 9e3, description: "Standard support for the pilot term." }, - { product: "AI Agent Seat (Annual)", quantity: 6, unit_price: 1e3, description: "Agent seats for the pilot coordinators." } - ] -}; -var quoteTotals = (quoteName, opts) => { - const lines = QUOTE_LINES[quoteName]; - if (!lines) throw new Error(`Seed error: no line items authored for quote "${quoteName}"`); - const subtotal = linesTotal(lines); - const discount_amount = Math.round(subtotal * (opts.discount / 100) * 100) / 100; - const total_price = Math.round((subtotal - discount_amount + opts.tax + opts.shipping_handling) * 100) / 100; - return { - subtotal, - discount: opts.discount, - discount_amount, - tax: opts.tax, - shipping_handling: opts.shipping_handling, - total_price - }; -}; -var quotes = defineSeed6(Quote, { - mode: "upsert", - externalId: "name", - records: [ - { - name: "Acme Platform Upgrade Quote", - crm_account: "Acme Corporation", - crm_contact: "john.smith@acme.example.com", - crm_opportunity: "Acme Platform Upgrade", - // `expired`, not `accepted` (#1661). Accepting this quote would have - // close-won `Acme Platform Upgrade`, which is `proposal` and 30 days from - // close — the same impossible pairing the contract above carried, one - // object over. `expired` is what `quote_expiration` computes for a - // presented quote past its `expiration_date`, and it is what the deal's - // own next step assumes: the revised Enterprise proposal still has to go - // out. Its `crm_contact` stays put — the row is no longer gated by - // `requiredWhen`, but the recipient is still who it was sent to. - status: "expired", - quote_date: cel34`daysAgo(45)`, - expiration_date: cel34`daysAgo(15)`, - ...quoteTotals("Acme Platform Upgrade Quote", { discount: 10, tax: 11475, shipping_handling: 0 }), - payment_terms: "net_30", - description: "Platform upgrade with 10% loyalty discount applied." - }, - // The renewal's own quote, and the seed's one ACCEPTED quote. Acceptance is - // only coherent here: `quote_on_accepted` close-wins whatever opportunity a - // quote links, so an accepted quote can only ever point at a `closed_won` - // deal. It also completes the provenance chain the contract above needs — - // deal won, quote accepted, contract drafted, then completed and activated - // by an admin (the draft the hook writes is explicitly a starting point). - // `Acme Annual Renewal 2025` keeps its rep-recorded `relationship` win - // reason: the hook only supplies `quote_accepted` when nobody recorded one. - { - name: "Acme Annual Renewal 2025 Quote", - crm_account: "Acme Corporation", - crm_contact: "john.smith@acme.example.com", - crm_opportunity: "Acme Annual Renewal 2025", - status: "accepted", - quote_date: cel34`daysAgo(30)`, - expiration_date: cel34`daysAgo(1)`, - // No discount — the renewal went at list ("multi-year option declined - // this round"), which is what its 22% YoY uplift is made of. Tax is 8.5% - // of the post-discount subtotal, the rate the other Acme quote bills at; - // every non-Acme quote here bills 8%. - ...quoteTotals("Acme Annual Renewal 2025 Quote", { discount: 0, tax: 18700, shipping_handling: 0 }), - payment_terms: "net_30", - description: "Annual renewal \u2014 three production tenants, premium support and the EMEA seat expansion." - }, - { - name: "Globex Manufacturing Suite Proposal", - crm_account: "Globex Industries", - crm_contact: "sarah.j@globex.example.com", - crm_opportunity: "Globex Manufacturing Suite", - status: "presented", - quote_date: cel34`daysAgo(7)`, - expiration_date: cel34`daysFromNow(23)`, - ...quoteTotals("Globex Manufacturing Suite Proposal", { discount: 5, tax: 7220, shipping_handling: 2500 }), - payment_terms: "net_60", - description: "Manufacturing suite licensing with plant-admin training." - }, - { - name: "Wayne Enterprise License Quote", - crm_account: "Wayne Enterprises", - crm_contact: "rwilson@wayne.example.com", - crm_opportunity: "Wayne Enterprise License", - status: "in_review", - quote_date: cel34`daysAgo(3)`, - expiration_date: cel34`daysFromNow(27)`, - ...quoteTotals("Wayne Enterprise License Quote", { discount: 15, tax: 81600, shipping_handling: 0 }), - payment_terms: "net_60", - description: "Multi-year enterprise license with volume discount." - }, - { - name: "Initech Cloud Migration Estimate", - crm_account: "Initech Solutions", - crm_contact: "mchen@initech.example.com", - crm_opportunity: "Initech Cloud Migration", - status: "draft", - quote_date: cel34`daysAgo(1)`, - expiration_date: cel34`daysFromNow(29)`, - ...quoteTotals("Initech Cloud Migration Estimate", { discount: 0, tax: 6400, shipping_handling: 0 }), - payment_terms: "net_30", - description: "Cloud migration services, awaiting internal review." - }, - { - name: "Stark Medical Pilot Quote", - crm_account: "Stark Medical", - crm_contact: "emily.d@starkmed.example.com", - status: "rejected", - quote_date: cel34`daysAgo(60)`, - expiration_date: cel34`daysAgo(30)`, - ...quoteTotals("Stark Medical Pilot Quote", { discount: 0, tax: 3600, shipping_handling: 0 }), - payment_terms: "net_30", - description: "Pilot project quote, rejected due to budget constraints.", - internal_notes: "Customer requested re-quote with smaller scope." - } - ] -}); -var quoteLineItems = defineSeed6(QuoteLineItem, { - mode: "upsert", - externalId: ["crm_quote", "crm_product"], - records: lineItemRecords("crm_quote", QUOTE_LINES) -}); - -// src/service/data/service.seed.ts -import { defineSeed as defineSeed7 } from "@objectstack/spec/data"; -import { cel as cel35 } from "@objectstack/spec"; - -// src/service/objects/_case-sla.ts -var CASE_SLA_DEFAULT_TIER = "smb"; -var CASE_SLA_CALENDAR_HOURS = { - // strategic enterprise mid_market smb - critical: { strategic: 4, enterprise: 4, mid_market: 4, smb: 4 }, - high: { strategic: 6, enterprise: 8, mid_market: 8, smb: 8 }, - medium: { strategic: 24, enterprise: 36, mid_market: 48, smb: 48 }, - low: { strategic: 96, enterprise: 120, mid_market: 168, smb: 168 } -}; -function caseSlaCalendarHours(priority, tier) { - const row = CASE_SLA_CALENDAR_HOURS[priority]; - if (!row) return void 0; - return row[tier] ?? row[CASE_SLA_DEFAULT_TIER]; -} -var caseSlaBreached = (dueAt, clockStoppedAt) => dueAt < clockStoppedAt; - -// src/service/data/service.seed.ts -var TIER_BY_ACCOUNT = new Map( - accounts.records.map((a) => [ - String(a.name), - typeof a.tier === "string" ? a.tier : CASE_SLA_DEFAULT_TIER - ]) -); -var seededSlaHours = (priority, accountName) => { - const hours = caseSlaCalendarHours(priority, accountName ? TIER_BY_ACCOUNT.get(accountName) : void 0); - if (hours === void 0) throw new Error(`seed: no SLA matrix row for priority "${priority}"`); - return hours; -}; -var celCaseSlaDue = (createdDaysAgo, priority, accountName) => cel35`daysAgo(${createdDaysAgo}) + duration('${seededSlaHours(priority, accountName)}h')`; -var seededSettledBreach = (createdDaysAgo, settledDaysAgo, priority, accountName) => caseSlaBreached(seededSlaHours(priority, accountName), (createdDaysAgo - settledDaysAgo) * 24); -var cases = defineSeed7(Case, { - mode: "upsert", - externalId: "subject", - records: [ - { - subject: "Login issues after platform upgrade", - description: `Users in the EMEA office report intermittent 401 errors when logging in after the v4.2 upgrade rolled out Wednesday night. Pattern: only affects users authenticating via SAML through Okta, only between 09:00\u201310:30 UTC. NA and APAC users are unaffected. - -**Customer impact:** ~40 users blocked at peak, costing ~3 productive hours per affected user. - -**Initial triage:** Suspect a clock-skew issue on the EMEA SSO relay added during the upgrade window. Engineering is reproducing in staging.`, - crm_account: "Acme Corporation", - crm_contact: "john.smith@acme.example.com", - status: "in_progress", - priority: "high", - priority_rank: 3, - type: "problem", - origin: "email", - is_closed: false, - is_sla_violated: false, - is_escalated: false, - created_at: cel35`daysAgo(2)`, - sla_due_date: celCaseSlaDue(2, "high", "Acme Corporation") - }, - { - subject: "Data export timing out for large datasets", - description: "CSV export fails for datasets over 10k rows.", - crm_account: "Globex Industries", - crm_contact: "sarah.j@globex.example.com", - status: "escalated", - priority: "critical", - priority_rank: 4, - type: "bug", - origin: "phone", - is_closed: false, - is_sla_violated: true, - is_escalated: true, - escalation_reason: "Customer threatening churn", - created_at: cel35`daysAgo(5)`, - sla_due_date: celCaseSlaDue(5, "critical", "Globex Industries") - }, - { - subject: "How to configure SSO with Okta?", - description: "Customer needs guidance on SSO setup with Okta.", - crm_account: "Initech Solutions", - crm_contact: "mchen@initech.example.com", - status: "resolved", - priority: "medium", - priority_rank: 2, - type: "question", - origin: "web", - // Resolved-but-not-closed: case.hook keeps is_closed=false and stamps - // closed_date as the resolved-date proxy; resolution_time_hours is the - // closed−created delta the hook would compute (daysAgo() is day-granular, - // so deltas come in 24h steps). - is_closed: false, - is_sla_violated: seededSettledBreach(3, 2, "medium", "Initech Solutions"), - is_escalated: false, - resolution_time_hours: 24, - created_at: cel35`daysAgo(3)`, - closed_date: cel35`daysAgo(2)`, - sla_due_date: celCaseSlaDue(3, "medium", "Initech Solutions") - }, - { - subject: "API rate limit exceeded on production", - description: "Production environment hitting rate limits during peak hours.", - crm_account: "Wayne Enterprises", - crm_contact: "rwilson@wayne.example.com", - status: "closed", - priority: "high", - priority_rank: 3, - type: "problem", - origin: "chat", - is_closed: true, - is_sla_violated: seededSettledBreach(7, 6, "high", "Wayne Enterprises"), - is_escalated: false, - // `resolution` is REQUIRED when status is 'closed' (object validation - // `resolution_required_for_closed`) — without it the seed row is rejected. - resolution: "Raised the production rate-limit tier and added client-side backoff; usage now within limits.", - // The deflection link (#601): this case was answered out of the knowledge - // base, so it names the article that resolved it. Referenced by the - // article seed's `externalId` (`title`), the same way every other seeded - // lookup names its target. - resolved_by_article: "API Rate Limits", - // closed−created delta, as case.hook computes it. - resolution_time_hours: 24, - created_at: cel35`daysAgo(7)`, - closed_date: cel35`daysAgo(6)`, - sla_due_date: celCaseSlaDue(7, "high", "Wayne Enterprises") - }, - { - subject: "PDF reports not rendering charts correctly", - description: "Charts appear blank when exporting dashboard to PDF.", - crm_account: "Stark Medical", - crm_contact: "emily.d@starkmed.example.com", - status: "new", - priority: "medium", - priority_rank: 2, - type: "bug", - origin: "email", - is_closed: false, - is_sla_violated: false, - is_escalated: false, - created_at: cel35`daysAgo(1)`, - sla_due_date: celCaseSlaDue(1, "medium", "Stark Medical") - }, - { - subject: "Billing discrepancy on last invoice", - description: `Customer (Lisa Kim, Procurement) flagged that the May invoice shows 15 active seats but Acme is only using 12. Two of the seats were de-provisioned in early April when two engineers left the company. - -**Root cause:** the de-provisioning happened in our admin console but the seat-count metric in billing only refreshes monthly, so the May invoice picked up the pre-change count. - -**Resolution path:** issue a $1,200 credit memo and switch Acme to the new real-time seat-billing pipeline so this can't recur. Waiting on Lisa to confirm she's good with the credit-memo treatment vs a refund.`, - crm_account: "Acme Corporation", - crm_contact: "john.smith@acme.example.com", - status: "waiting_customer", - priority: "low", - priority_rank: 1, - type: "problem", - origin: "email", - is_closed: false, - is_sla_violated: false, - is_escalated: false, - created_at: cel35`daysAgo(4)`, - sla_due_date: celCaseSlaDue(4, "low", "Acme Corporation") - }, - { - subject: "Mobile app crashes on iOS 17", - description: "App crashes on launch for users running iOS 17.2+.", - crm_account: "Globex Industries", - crm_contact: "sarah.j@globex.example.com", - status: "in_progress", - priority: "critical", - priority_rank: 4, - type: "bug", - origin: "web", - is_closed: false, - is_sla_violated: true, - is_escalated: true, - escalation_reason: "Affects 30% of mobile users", - created_at: cel35`daysAgo(3)`, - sla_due_date: celCaseSlaDue(3, "critical", "Globex Industries") - }, - { - subject: "Request: bulk import via CSV", - description: "Customer requesting ability to import records via CSV upload.", - crm_account: "Wayne Enterprises", - crm_contact: "rwilson@wayne.example.com", - status: "closed", - priority: "low", - priority_rank: 1, - type: "feature_request", - origin: "web", - is_closed: true, - is_sla_violated: seededSettledBreach(10, 8, "low", "Wayne Enterprises"), - is_escalated: false, - // Required for closed cases (resolution_required_for_closed). - resolution: "Delivered CSV bulk-import in the 9.4 release; shared the docs link with the customer.", - // closed−created delta, as case.hook computes it. - resolution_time_hours: 48, - created_at: cel35`daysAgo(10)`, - closed_date: cel35`daysAgo(8)`, - sla_due_date: celCaseSlaDue(10, "low", "Wayne Enterprises") - }, - // ─── Generated demo cases — 30 cases over the last 30 days, mixed across - // priorities. Powers `CasesOpenedByDayPriorityReport` (daily bucketing - // matrix) and the service dashboard's daily-volume area chart. - // - // ### Why every axis carries a rotation, and not just `i % length` (#1659) - // - // These rows used to read ONE counter for every axis: `crm_account` and - // `status` both took `i % 5`, and `priority`, `type` and `origin` all took - // `i % 4`. Equal-length lists walked by one index advance in lockstep, so - // each group came out PERFECTLY correlated — every Acme case `new`, every - // Globex case `in_progress`, and every `low` case a `question` raised by - // `email`. Thirty rows of volume with no variety, which is the opposite of - // what a volume generator is for: the account × status cross-tab held 5 of - // its 25 cells, and priority × type × origin 4 of 16 apiece. - // - // Each list now advances one step per row PLUS a rotation — `c` extra steps - // every `m` rows. Two axes stay correlated exactly when their relative - // offset never moves, so the rotations are chosen to make every relative - // offset sweep its whole cycle. `crm_account` is the anchor and carries no - // rotation; the other four are stated relative to it. - // - // `account × status` is complete BY CONSTRUCTION rather than by luck, and - // the proof is one line: account `a` takes rows i = a, a+5 … a+25, whose - // block numbers run 0…5, so its statuses are `(a + b) % 5` over b = 0…5 — - // all five of them. The thirty rows therefore walk the whole 5 × 5 grid, - // twenty-five cells once and five of them a second time. - // - // ⚠️ The remaining three constants are TUNED, not derived. They were picked - // by computing all ten pairwise cross-tabs and keeping the assignment that - // left the fewest empty cells. Measured over the lists as shipped: 188 of - // the 193 pairwise cells are occupied, no cell holds more than 3 rows, and - // the marginals stay as flat as thirty rows allow — 6/6/6/6/6 by account - // and by status, 8/7/7/8 by priority, type and origin. ⛔ Changing the - // LENGTH of any list below voids that tuning: re-measure the cross-tabs - // rather than assuming the rotations still separate the axes. - // - // Two schemes that read as more principled than they measure were rejected - // here, and are recorded so they are not re-derived: rotating the 5-lists - // on the 4-block and the 4-lists on the 5-block ("the lengths are coprime, - // so they cannot resonate") empties one status completely; and rotating - // `crm_account` as well — to break the every-fifth-day beat it walks the - // calendar on — costs twelve further empty cells. That beat is the - // deliberate price of anchoring: with one row per day, some axis has to be - // the fixed one the other four are measured against. - ...(() => { - const priorities = ["low", "medium", "high", "critical"]; - const rankByPriority = { low: 1, medium: 2, high: 3, critical: 4 }; - const types = ["question", "bug", "problem", "feature_request"]; - const origins = ["email", "phone", "web", "chat"]; - const statuses = ["new", "in_progress", "resolved", "closed", "escalated"]; - const accountsList = ["Acme Corporation", "Globex Industries", "Wayne Enterprises", "Initech Solutions", "Stark Medical"]; - const out = []; - for (let i = 0; i < 30; i++) { - const account = accountsList[i % accountsList.length]; - const status = statuses[(i + Math.floor(i / accountsList.length)) % statuses.length]; - const priority = priorities[(i + Math.floor(i / priorities.length)) % priorities.length]; - const type = types[(i + 2 * Math.floor(i / types.length)) % types.length]; - const origin = origins[(i + Math.floor(i / 10)) % origins.length]; - const settled = status === "resolved" || status === "closed"; - const ageDays = 1 + i % 30; - const resolutionDays = Math.min(ageDays, 1 + i % 3); - const slaViolated = settled ? seededSettledBreach(ageDays, ageDays - resolutionDays, priority, account) : priority === "critical" && i % 3 === 0; - out.push({ - subject: `Demo case ${String(i + 1).padStart(2, "0")} \u2014 ${priority} ${type}`, - description: `Auto-generated demo case for ${priority} priority on day -${ageDays}.`, - crm_account: account, - status, - priority, - priority_rank: rankByPriority[priority], - type, - origin, - // is_closed strictly mirrors case.hook: true ONLY for status - // 'closed' — a resolved case is NOT closed yet. - is_closed: status === "closed", - is_sla_violated: slaViolated, - is_escalated: status === "escalated", - ...settled ? { resolution_time_hours: resolutionDays * 24 } : {}, - // Object validations require these when closed/escalated — without - // them the generated rows are rejected (resolution_required_for_closed - // / escalation_reason_required). - ...status === "closed" ? { resolution: "Resolved per standard runbook; root cause documented and customer confirmed." } : {}, - ...status === "escalated" ? { escalation_reason: "Escalated to tier-2 engineering for SLA-risk review." } : {}, - created_at: celDaysAgo(ageDays), - // Resolved cases also carry closed_date: case.hook stamps it as the - // resolved-date proxy while keeping is_closed=false. - ...settled ? { closed_date: celDaysAgo(ageDays - resolutionDays) } : {}, - sla_due_date: celCaseSlaDue(ageDays, priority, account) - }); - } - return out; - })() - ] -}); -var knowledgeArticles = defineSeed7(KnowledgeArticle, { - mode: "upsert", - externalId: "title", - records: [ - { - title: "Getting Started with HotCRM", - summary: "A five-minute tour of accounts, contacts, leads and the sales pipeline.", - category: "getting_started", - status: "published", - audience: "public", - language: "en", - body: `# Getting Started with HotCRM - -Welcome! This guide walks you through the core objects: - -1. **Accounts** \u2014 the companies you sell to and serve. -2. **Contacts** \u2014 the people at those accounts. -3. **Leads** \u2014 unqualified prospects in the top of the funnel. -4. **Opportunities** \u2014 qualified deals moving through your pipeline. - -Open the **Sales Pipeline** kanban to drag deals between stages, and use the -**Executive Overview** dashboard to track revenue at a glance.`, - published_at: cel35`daysAgo(40)`, - last_reviewed_at: cel35`daysAgo(20)` - }, - { - title: "Resetting Your Password", - summary: "How end users reset a forgotten password from the login screen.", - category: "how_to", - status: "published", - audience: "public", - language: "en", - body: `# Resetting Your Password - -1. On the login screen, click **Forgot password?** -2. Enter the email associated with your account. -3. Check your inbox for a reset link (valid for 30 minutes). -4. Choose a new password of at least 12 characters. - -If the email does not arrive, check spam or contact your administrator.`, - published_at: cel35`daysAgo(25)`, - last_reviewed_at: cel35`daysAgo(10)` - }, - { - title: "API Rate Limits", - summary: "Per-token request quotas and recommended back-off strategy.", - category: "api", - status: "draft", - audience: "internal", - language: "en", - body: `# API Rate Limits (DRAFT) - -Default quota is 600 requests/minute per token. On HTTP 429, back off -exponentially starting at 1s. Numbers pending final review with platform team.` - }, - { - title: "Legacy SSO Setup", - summary: "SAML configuration for the pre-2025 identity stack.", - category: "troubleshooting", - status: "published", - audience: "internal", - language: "en", - body: `# Legacy SSO Setup - -This covers the deprecated SAML 1.1 flow. New tenants should use the OIDC -connector instead. Retained for customers still on the legacy stack.`, - published_at: cel35`daysAgo(240)`, - last_reviewed_at: cel35`daysAgo(220)` - } - ] -}); - -// src/marketing/data/marketing.seed.ts -import { defineSeed as defineSeed8 } from "@objectstack/spec/data"; -import { cel as cel36 } from "@objectstack/spec"; -var CAMPAIGN_MEMBERS = { - "Q3 Enterprise Email Nurture": [ - { lead: "noah.patel@vertexanalytics.example.com", status: "responded", addedDaysAgo: 14, respondedDaysAgo: 9 }, - { lead: "maya.singh@bluepeaklogistics.example.com", status: "sent", addedDaysAgo: 14 }, - { lead: "owen.becker@northwindenergy.example.com", status: "responded", addedDaysAgo: 14, respondedDaysAgo: 11 }, - { lead: "sara.lopez@heliossolar.example.com", status: "sent", addedDaysAgo: 14 }, - { lead: "leo.vance@cleancart.example.com", status: "unsubscribed", addedDaysAgo: 14 }, - { lead: "iris.okafor@pulsehealth.example.com", status: "sent", addedDaysAgo: 13 }, - { lead: "ravi.mehta@foundryrobotics.example.com", status: "sent", addedDaysAgo: 13 }, - { lead: "tess.brown@latticeeducation.example.com", status: "responded", addedDaysAgo: 13, respondedDaysAgo: 8 }, - { contact: "john.smith@acme.example.com", status: "responded", addedDaysAgo: 14, respondedDaysAgo: 10 }, - { contact: "ethan.brooks@vertex.example.com", status: "sent", addedDaysAgo: 14 }, - { contact: "priya.shah@lattice.example.com", status: "responded", addedDaysAgo: 14, respondedDaysAgo: 7 }, - { contact: "rwilson@wayne.example.com", status: "sent", addedDaysAgo: 13 } - ], - "Operations Platform Launch": [ - { lead: "jonas.holt@polarcargo.example.com", status: "responded", addedDaysAgo: 11, respondedDaysAgo: 6 }, - { lead: "anya.volkov@redoakrealty.example.com", status: "sent", addedDaysAgo: 11 }, - { lead: "theo.park@skylinemedia.example.com", status: "sent", addedDaysAgo: 11 }, - { lead: "wren.garcia@maplebakerygroup.example.com", status: "responded", addedDaysAgo: 10, respondedDaysAgo: 5 }, - { lead: "hugo.dubois@nimbusaerospace.example.com", status: "sent", addedDaysAgo: 10 }, - { contact: "rwilson@wayne.example.com", status: "responded", addedDaysAgo: 11, respondedDaysAgo: 7 }, - { contact: "marcus.reed@apexlogistics.example.com", status: "sent", addedDaysAgo: 11 }, - { contact: "olivia.chen@northwind.example.com", status: "sent", addedDaysAgo: 10 }, - { contact: "sarah.j@globex.example.com", status: "sent", addedDaysAgo: 10 } - ], - "Developer Content Marketing Push": [ - { lead: "lena.fischer@graniteinsurance.example.com", status: "responded", addedDaysAgo: 33, respondedDaysAgo: 27 }, - { lead: "kai.watanabe@coralreefhotels.example.com", status: "sent", addedDaysAgo: 33 }, - { lead: "mira.costa@atlasconstruction.example.com", status: "unsubscribed", addedDaysAgo: 33 }, - { lead: "pia.anand@citrinefinance.example.com", status: "responded", addedDaysAgo: 32, respondedDaysAgo: 24 }, - { lead: "marco.ricci@auroratravel.example.com", status: "sent", addedDaysAgo: 32 }, - { lead: "lisa.t@cloudfirst.example.com", status: "responded", addedDaysAgo: 30, respondedDaysAgo: 21 }, - { contact: "ethan.brooks@vertex.example.com", status: "responded", addedDaysAgo: 33, respondedDaysAgo: 19 }, - { contact: "mchen@initech.example.com", status: "sent", addedDaysAgo: 33 }, - { contact: "john.smith@acme.example.com", status: "sent", addedDaysAgo: 32 }, - { contact: "emily.d@starkmed.example.com", status: "sent", addedDaysAgo: 32 }, - { contact: "sarah.j@globex.example.com", status: "sent", addedDaysAgo: 30 } - ], - // Campaigns still in `planning` carry their invitation / registration list: - // the enrollment flow runs for `planning` and `in_progress` campaigns alike - // and stamps `sent` on enrollment, so a pre-launch target list looks exactly - // like this. - "Cloud Migration Webinar": [ - { lead: "dkim@edutechlabs.example.com", status: "sent", addedDaysAgo: 4 }, - { lead: "alice@nextgenretail.example.com", status: "sent", addedDaysAgo: 4 }, - { lead: "jonas.holt@polarcargo.example.com", status: "sent", addedDaysAgo: 3 }, - { lead: "anya.volkov@redoakrealty.example.com", status: "sent", addedDaysAgo: 3 }, - { contact: "mchen@initech.example.com", status: "sent", addedDaysAgo: 4 }, - { contact: "marcus.reed@apexlogistics.example.com", status: "sent", addedDaysAgo: 3 } - ], - "Executive AI Governance Roundtable": [ - { contact: "john.smith@acme.example.com", status: "sent", addedDaysAgo: 6 }, - { contact: "rwilson@wayne.example.com", status: "sent", addedDaysAgo: 6 }, - { contact: "ethan.brooks@vertex.example.com", status: "sent", addedDaysAgo: 5 }, - { contact: "priya.shah@lattice.example.com", status: "sent", addedDaysAgo: 5 }, - { contact: "emily.d@starkmed.example.com", status: "sent", addedDaysAgo: 5 } - ], - "Partner Operations Roadshow": [ - { lead: "maya.singh@bluepeaklogistics.example.com", status: "sent", addedDaysAgo: 7 }, - { lead: "ravi.mehta@foundryrobotics.example.com", status: "sent", addedDaysAgo: 7 }, - { contact: "marcus.reed@apexlogistics.example.com", status: "sent", addedDaysAgo: 6 }, - { contact: "olivia.chen@northwind.example.com", status: "sent", addedDaysAgo: 6 } - ], - "SaaSCon 2026 Trade Show": [ - { lead: "theo.park@skylinemedia.example.com", status: "sent", addedDaysAgo: 8 }, - { lead: "wren.garcia@maplebakerygroup.example.com", status: "sent", addedDaysAgo: 8 }, - { lead: "hugo.dubois@nimbusaerospace.example.com", status: "sent", addedDaysAgo: 7 }, - { lead: "marco.ricci@auroratravel.example.com", status: "sent", addedDaysAgo: 7 } - ] -}; -var campaignMetrics = (campaignName) => { - const members = CAMPAIGN_MEMBERS[campaignName] ?? []; - const leadKeys = new Set(members.map((m) => m.lead).filter((e) => Boolean(e))); - const convertedLeads = leads.records.filter( - (l) => typeof l.email === "string" && leadKeys.has(l.email) && l.is_converted === true - ).length; - const attributed = opportunities.records.filter((o) => o.crm_campaign === campaignName); - const won = attributed.filter((o) => o.stage === "closed_won"); - return { - // "Total members enrolled" — campaign.hook.ts's single definition of num_sent. - num_sent: members.length, - // `responded` or `converted`, as in `computeCampaignMetrics`. The seed set - // holds no `converted` member (see the note on CAMPAIGN_MEMBERS), so the - // two predicates coincide on this data — spelled the narrow way because - // widening it here would suggest a seeded state that does not exist. - num_responses: members.filter((m) => m.status === "responded").length, - num_leads: leadKeys.size, - num_converted_leads: convertedLeads, - num_opportunities: attributed.length, - num_won_opportunities: won.length, - actual_revenue: won.reduce((sum, o) => sum + (typeof o.amount === "number" ? o.amount : 0), 0) - }; -}; -var campaigns = defineSeed8(Campaign, { - mode: "upsert", - externalId: "name", - records: [ - { - name: "Q3 Enterprise Email Nurture", - description: "Multi-touch nurture for enterprise IT decision makers evaluating AI governance and analytics.", - type: "email", - channel: "email", - status: "in_progress", - start_date: cel36`daysAgo(15)`, - end_date: cel36`daysFromNow(21)`, - budgeted_cost: 28e3, - actual_cost: 14e3, - expected_revenue: 56e4, - target_size: 5e3, - ...campaignMetrics("Q3 Enterprise Email Nurture"), - landing_page_url: "https://acme.example.com/lp/enterprise-q3", - is_active: true - }, - { - name: "Executive AI Governance Roundtable", - description: "A live executive roundtable on operating AI agents with governance, auditability and trust.", - type: "conference", - channel: "events", - status: "planning", - start_date: cel36`daysFromNow(2)`, - end_date: cel36`daysFromNow(3)`, - budgeted_cost: 22e3, - expected_revenue: 32e4, - target_size: 120, - ...campaignMetrics("Executive AI Governance Roundtable"), - is_active: true - }, - { - name: "Cloud Migration Webinar", - description: "A technical webinar on modernizing customer operations and data workflows in the cloud.", - type: "webinar", - channel: "digital", - status: "planning", - start_date: cel36`daysFromNow(6)`, - end_date: cel36`daysFromNow(8)`, - budgeted_cost: 18e3, - expected_revenue: 36e4, - target_size: 1500, - ...campaignMetrics("Cloud Migration Webinar"), - landing_page_url: "https://acme.example.com/webinars/cloud-migration", - is_active: true - }, - { - name: "Operations Platform Launch", - description: "Launch campaign for the operations platform, pairing product content with customer proof points.", - type: "content", - channel: "digital", - status: "in_progress", - // Was `daysFromNow(12)` — an `in_progress` campaign that had not started - // yet, which no attribution can be consistent with (#591). - start_date: cel36`daysAgo(12)`, - end_date: cel36`daysFromNow(14)`, - budgeted_cost: 36e3, - actual_cost: 12e3, - expected_revenue: 48e4, - target_size: 8e3, - ...campaignMetrics("Operations Platform Launch"), - landing_page_url: "https://acme.example.com/launch/operations-platform", - is_active: true - }, - { - name: "Partner Operations Roadshow", - description: "Joint regional sessions with strategic partners for operations and IT leaders.", - type: "partner", - channel: "partner", - status: "planning", - start_date: cel36`daysFromNow(19)`, - end_date: cel36`daysFromNow(22)`, - budgeted_cost: 48e3, - expected_revenue: 72e4, - target_size: 600, - ...campaignMetrics("Partner Operations Roadshow"), - is_active: true - }, - { - name: "SaaSCon 2026 Trade Show", - description: "A focused booth, executive dinner and customer-story program at the SaaSCon industry conference.", - type: "trade_show", - channel: "events", - status: "planning", - start_date: cel36`daysFromNow(27)`, - end_date: cel36`daysFromNow(30)`, - budgeted_cost: 75e3, - expected_revenue: 12e5, - target_size: 3e3, - ...campaignMetrics("SaaSCon 2026 Trade Show"), - is_active: true - }, - { - name: "Developer Content Marketing Push", - description: "Technical blog posts, video tutorials and developer community engagement completed last month.", - type: "content", - channel: "digital", - status: "completed", - start_date: cel36`daysAgo(35)`, - end_date: cel36`daysAgo(4)`, - budgeted_cost: 4e4, - actual_cost: 25e3, - expected_revenue: 25e4, - target_size: 1e4, - ...campaignMetrics("Developer Content Marketing Push"), - landing_page_url: "https://acme.example.com/developers", - is_active: true - } - ] -}); -var memberRecords = (kind) => Object.entries(CAMPAIGN_MEMBERS).flatMap( - ([campaign, members]) => members.filter((m) => kind === "lead" ? m.lead : m.contact).map((m) => ({ - crm_campaign: campaign, - ...kind === "lead" ? { crm_lead: m.lead } : { crm_contact: m.contact }, - status: m.status, - added_date: celDaysAgo(m.addedDaysAgo), - // `has_responded` / `response_date` track the `responded` status - // exactly — a responded member with no response date is a shape the - // response-tracking surfaces cannot render. - has_responded: m.status === "responded", - ...m.respondedDaysAgo !== void 0 ? { response_date: celDaysAgo(m.respondedDaysAgo) } : {} - })) -); -var campaignMembersFromLeads = defineSeed8(CampaignMember, { - mode: "upsert", - externalId: ["crm_campaign", "crm_lead"], - records: memberRecords("lead") -}); -var campaignMembersFromContacts = defineSeed8(CampaignMember, { - mode: "upsert", - externalId: ["crm_campaign", "crm_contact"], - records: memberRecords("contact") -}); - -// objectstack.composition.ts -var byExportName = (merged) => Object.entries(merged).sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0).map(([, value]) => value); -var appHooks = [ - account_hook_default, - campaign_hook_default, - opportunity_campaign_metrics_hook_default, - lead_campaign_metrics_hook_default, - campaign_member_hook_default, - contact_hook_default, - contract_hook_default, - event_hook_default, - forecast_hook_default, - lead_hook_default, - opportunity_hook_default, - opportunity_line_item_hook_default, - product_hook_default, - quote_hook_default, - quote_line_item_hook_default, - task_hook_default -].flatMap((entry) => Array.isArray(entry) ? entry : [entry]); -var appFlows = [ - CampaignEnrollmentFlow, - CampaignLeadMemberEnrollFlow, - CampaignContactMemberEnrollFlow, - AccountApprovalFlow, - LeadConversionFlow, - LeadConversionApprovalFlow, - ScheduleFollowUpFlow, - OpportunityApprovalFlow, - OpportunityApprovalOnCreateFlow, - OpportunityStatusChangeApprovalFlow, - OpportunityQualificationApprovalFlow, - QuoteGenerationFlow, - ContractRenewalFlow, - OpportunityStagnationFlow, - ForecastSnapshotFlow, - LeadAssignmentFlow, - CampaignCompletionFlow, - QuoteExpirationFlow, - ContractExpirationFlow, - ContactWelcomeFlow, - OpportunityWonAlertFlow, - TaskUrgentAlertFlow, - TaskDueReminderFlow, - BillingHandoffClosedWonFlow, - BillingHandoffContractActivatedFlow -]; -var appSkills = [ - LeadQualificationSkill, - EmailDraftingSkill, - RevenueForecastingSkill, - Customer360Skill, - LiveDataSkill -]; -var appObjects = byExportName({ - ...objects_exports2, - ...objects_exports3, - ...objects_exports4 -}); -var appActions = byExportName({ ...actions_exports, ...actions_exports2 }); -var appDashboards = byExportName({ ...dashboards_exports }); -var appDatasets = byExportName({ ...datasets_exports, ...datasets_exports2 }); -var appReports = byExportName({ ...reports_exports }); -var appViews = byExportName({ - ...views_exports, - ...views_exports2, - ...views_exports3 -}); -var appPages = byExportName({ ...pages_exports }); -var appMappings = byExportName({ ...mappings_exports }); -var appApps = byExportName({ ...apps_exports }); -var appTranslations = byExportName({ ...translations_exports }); -var appEmailTemplates = byExportName({ - ...email_templates_exports, - ...email_templates_exports2 -}).flat(); -var allProfiles = profiles_exports; -var appSharingRules = [ - AccountTeamSharingRule, - OpportunitySalesSharingRule, - OpportunityExecutiveSharingRule, - ...TerritorySharingRules, - ...CampaignLeadershipSharingRules -]; -var allHooks = [...appHooks, ...serviceHooks]; -var allFlows = [...appFlows, ...serviceFlows]; -var allSkills = [...appSkills, ...serviceSkills]; -var CrmSharingRules = [...appSharingRules, ...serviceSharingRules]; -var CrmSeedData = [ - accounts, - contacts, - leads, - opportunities, - products, - opportunityLineItems, - tasks, - cases, - // Events come after the five objects their `related_to_*` lookups resolve - // against (accounts, contacts, leads, opportunities, cases); the attendee - // junctions come after the events they hang off. - events, - eventAttendeesFromContacts, - eventAttendeesFromLeads, - leadInteractionPointers, - campaigns, - campaignMembersFromLeads, - campaignMembersFromContacts, - contracts, - quotes, - quoteLineItems, - forecasts, - knowledgeArticles -]; -var SaasTenantSeedData = [products]; -var ServiceSeedData = [cases, knowledgeArticles]; -var AppSeedData = CrmSeedData.filter((family) => !ServiceSeedData.includes(family)); -var seedDataFor = (composition2) => composition2 === "saas" ? { app: SaasTenantSeedData, service: [] } : { app: AppSeedData, service: ServiceSeedData }; -var composition = resolveComposition(); -var isSaas = composition === "saas"; -var seedData = seedDataFor(composition); -var compositionPermissions = isSaas ? [...Object.values(allProfiles).filter((set) => set !== SystemAdminProfile), TenantAdminProfile] : Object.values(allProfiles); -var serviceStack = createHotCrmServiceStack({ data: seedData.service }); -var appStack = createHotCrmAppStack( - { - objects: appObjects, - actions: appActions, - dashboards: appDashboards, - datasets: appDatasets, - reports: appReports, - // Reusable import projections (#603). Referenced by name from the import - // endpoint — `mappingName: 'crm_account_import'` — so a customer's own - // spreadsheet loads without per-column mapping by hand. Templates: - // `assets/import-templates/`. - mappings: appMappings, - flows: appFlows, - skills: appSkills, - permissions: compositionPermissions, - apps: appApps, - views: appViews, - pages: appPages, - // Approvals are modeled as `record_change` flows with `approval` nodes - // (ADR-0019); see src/sales/flows/opportunity-approval.flow.ts. The - // standalone `approvals` stack field was removed in ObjectStack 7.4. - // No `analyticsCubes`: datasets (ADR-0021) are the semantic layer — the - // analytics service compiles each dataset into its cube internally, and a - // second hand-written cube layer only duplicates and drifts. - hooks: appHooks, - data: seedData.app, - translations: appTranslations, - // The localizable content path for `notify` (#9205). A node names a template - // and supplies its `templateData`; the delivery path resolves - // `(name, locale)` against these rows PER RECIPIENT, after fan-out — the - // recipient's own `sys_user.locale` when set, else `i18n.defaultLocale` — - // so two people on one notification can read it in two languages. - emailTemplates: appEmailTemplates, - sharingRules: appSharingRules, - // ADR-0090 D3: positions are flat capability-distribution groups — the v1 - // role hierarchy's parent links are gone (hierarchy belongs to the - // business-unit tree, which this app does not model). - positions: CrmPositions - }, - { artifactObjects: (serviceStack.objects ?? []).map((object) => object.name) } -); - -// objectstack.config.ts -var objectstack_config_default = composeStacks([serviceStack, appStack], { manifest: "preserve" }); -export { - objectstack_config_default as default -}; -//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["objectstack.config.ts", "src/sales/index.ts", "src/service/index.ts", "src/service/actions/case.actions.ts", "src/service/objects/index.ts", "src/service/objects/article_feedback.object.ts", "src/service/objects/case.object.ts", "src/service/objects/knowledge_article.object.ts", "src/sales/objects/index.ts", "src/sales/objects/account.object.ts", "src/sales/objects/_picklists.ts", "src/sales/objects/_territory.ts", "src/sales/objects/contact.object.ts", "src/sales/objects/event.object.ts", "src/sales/objects/event_attendee.object.ts", "src/sales/objects/forecast.object.ts", "src/sales/objects/lead.object.ts", "src/sales/objects/opportunity.object.ts", "src/sales/objects/task.object.ts", "src/sales/actions/activity-actions.ts", "src/service/actions/case-activity.actions.ts", "src/service/actions/knowledge_article.actions.ts", "src/service/dashboards/service.dashboard.ts", "src/service/datasets/case.dataset.ts", "src/sales/email-templates/_bundle.ts", "src/service/email-templates/en.ts", "src/service/email-templates/zh-CN.ts", "src/service/email-templates/ja-JP.ts", "src/service/email-templates/es-ES.ts", "src/service/email-templates/crm.email-template.ts", "src/service/flows/case-escalation.flow.ts", "src/service/flows/case-actions.flow.ts", "src/service/objects/_case-assignment.ts", "src/service/flows/case-escalation-stamp.flow.ts", "src/service/flows/case-sla-monitor.flow.ts", "src/sales/flows/_guarded-iteration.ts", "src/service/objects/article_feedback.hook.ts", "src/service/objects/case.hook.ts", "src/service/objects/knowledge_article.hook.ts", "src/service/pages/case_detail.page.ts", "src/service/reports/case.report.ts", "src/service/sharing/case.sharing.ts", "src/service/skills/case-triage.skill.ts", "src/service/views/case.view.ts", "src/service/views/knowledge_article.view.ts", "src/revenue/objects/index.ts", "src/revenue/objects/contract.object.ts", "src/revenue/objects/opportunity_line_item.object.ts", "src/revenue/objects/product.object.ts", "src/revenue/objects/quote.object.ts", "src/sales/objects/_thresholds.ts", "src/revenue/objects/quote_line_item.object.ts", "src/marketing/objects/index.ts", "src/marketing/objects/campaign.object.ts", "src/marketing/objects/campaign_member.object.ts", "src/sales/actions/index.ts", "src/sales/actions/contact.actions.ts", "src/sales/actions/lead.actions.ts", "src/sales/actions/opportunity.actions.ts", "src/marketing/actions/index.ts", "src/marketing/actions/campaign.actions.ts", "src/sales/dashboards/index.ts", "src/sales/dashboards/activity.dashboard.ts", "src/sales/dashboards/shared-widgets.ts", "src/sales/dashboards/crm.dashboard.ts", "src/sales/dashboards/executive.dashboard.ts", "src/sales/dashboards/sales.dashboard.ts", "src/sales/datasets/index.ts", "src/sales/datasets/opportunity.dataset.ts", "src/sales/datasets/account.dataset.ts", "src/sales/datasets/contact.dataset.ts", "src/sales/datasets/lead.dataset.ts", "src/sales/datasets/task.dataset.ts", "src/sales/datasets/event.dataset.ts", "src/sales/datasets/forecast.dataset.ts", "src/revenue/datasets/index.ts", "src/revenue/datasets/product.dataset.ts", "src/sales/reports/index.ts", "src/sales/reports/account.report.ts", "src/sales/reports/lead.report.ts", "src/sales/reports/opportunity.report.ts", "src/sales/reports/churn.report.ts", "src/sales/mappings/index.ts", "src/sales/mappings/account_import.mapping.ts", "src/sales/mappings/_shared.ts", "src/sales/mappings/contact_import.mapping.ts", "src/sales/mappings/lead_import.mapping.ts", "src/sales/apps/index.ts", "src/sales/apps/crm.app.ts", "src/sales/profiles/index.ts", "src/sales/profiles/guest-portal.profile.ts", "src/sales/profiles/marketing-user.profile.ts", "src/sales/profiles/sales-manager.profile.ts", "src/sales/profiles/sales-rep.profile.ts", "src/sales/profiles/service-agent.profile.ts", "src/sales/profiles/system-admin.profile.ts", "src/sales/translations/index.ts", "src/sales/translations/en/app.ts", "src/sales/translations/en/_shared.ts", "src/sales/translations/en/objects.customer.ts", "src/sales/translations/en/objects.pipeline.ts", "src/sales/translations/en/objects.commerce.ts", "src/sales/translations/en/objects.service.ts", "src/sales/translations/en/objects.activity.ts", "src/sales/translations/en/objects.marketing.ts", "src/sales/translations/en.ts", "src/sales/translations/zh-CN/app.ts", "src/sales/translations/zh-CN/_shared.ts", "src/sales/translations/zh-CN/objects.customer.ts", "src/sales/translations/zh-CN/objects.pipeline.ts", "src/sales/translations/zh-CN/objects.commerce.ts", "src/sales/translations/zh-CN/objects.service.ts", "src/sales/translations/zh-CN/objects.activity.ts", "src/sales/translations/zh-CN/objects.marketing.ts", "src/sales/translations/zh-CN.ts", "src/sales/translations/ja-JP/app.ts", "src/sales/translations/ja-JP/_shared.ts", "src/sales/translations/ja-JP/objects.customer.ts", "src/sales/translations/ja-JP/objects.pipeline.ts", "src/sales/translations/ja-JP/objects.commerce.ts", "src/sales/translations/ja-JP/objects.service.ts", "src/sales/translations/ja-JP/objects.activity.ts", "src/sales/translations/ja-JP/objects.marketing.ts", "src/sales/translations/ja-JP.ts", "src/sales/translations/es-ES/app.ts", "src/sales/translations/es-ES/_shared.ts", "src/sales/translations/es-ES/objects.customer.ts", "src/sales/translations/es-ES/objects.pipeline.ts", "src/sales/translations/es-ES/objects.commerce.ts", "src/sales/translations/es-ES/objects.service.ts", "src/sales/translations/es-ES/objects.activity.ts", "src/sales/translations/es-ES/objects.marketing.ts", "src/sales/translations/es-ES.ts", "src/sales/translations/crm.translation.ts", "src/sales/views/index.ts", "src/sales/views/lead.view.ts", "src/sales/views/account.view.ts", "src/sales/views/contact.view.ts", "src/sales/views/opportunity.view.ts", "src/sales/views/task.view.ts", "src/sales/views/event.view.ts", "src/sales/views/event_attendee.view.ts", "src/sales/views/forecast.view.ts", "src/revenue/views/index.ts", "src/revenue/views/contract.view.ts", "src/revenue/views/product.view.ts", "src/revenue/views/quote.view.ts", "src/marketing/views/index.ts", "src/marketing/views/campaign.view.ts", "src/sales/pages/index.ts", "src/sales/pages/lead_detail.page.ts", "src/sales/pages/opportunity_detail.page.ts", "src/sales/pages/account_detail.page.ts", "src/sales/pages/account_workbench.page.ts", "src/sales/pages/home.page.ts", "src/sales/pages/app_launcher.page.ts", "src/sales/pages/utility_bar.page.ts", "src/sales/email-templates/index.ts", "src/sales/email-templates/en.ts", "src/sales/email-templates/zh-CN.ts", "src/sales/email-templates/ja-JP.ts", "src/sales/email-templates/es-ES.ts", "src/sales/email-templates/crm.email-template.ts", "src/revenue/email-templates/index.ts", "src/revenue/email-templates/en.ts", "src/revenue/email-templates/zh-CN.ts", "src/revenue/email-templates/ja-JP.ts", "src/revenue/email-templates/es-ES.ts", "src/revenue/email-templates/crm.email-template.ts", "src/sales/profiles/tenant-admin.profile.ts", "src/sales/objects/account.hook.ts", "src/sales/objects/contact.hook.ts", "src/sales/objects/event.hook.ts", "src/sales/objects/forecast.hook.ts", "src/sales/objects/lead.hook.ts", "src/sales/objects/lead.campaign-metrics.hook.ts", "src/sales/objects/opportunity.hook.ts", "src/sales/objects/opportunity.campaign-metrics.hook.ts", "src/sales/objects/task.hook.ts", "src/revenue/objects/contract.hook.ts", "src/revenue/objects/_line-item-price-fill.ts", "src/revenue/objects/opportunity_line_item.hook.ts", "src/revenue/objects/product.hook.ts", "src/revenue/objects/quote.hook.ts", "src/revenue/objects/quote_line_item.hook.ts", "src/marketing/objects/campaign.hook.ts", "src/marketing/objects/campaign_member.hook.ts", "src/sales/flows/lead-conversion.flow.ts", "src/sales/flows/lead-conversion-approval.flow.ts", "src/sales/flows/account-approval.flow.ts", "src/sales/flows/schedule-followup.flow.ts", "src/sales/flows/opportunity-approval.flow.ts", "src/sales/flows/opportunity-status-change-approval.flow.ts", "src/sales/flows/opportunity-qualification-approval.flow.ts", "src/sales/flows/opportunity-stagnation.flow.ts", "src/sales/flows/forecast-snapshot.flow.ts", "src/sales/flows/lead-assignment.flow.ts", "src/sales/flows/contact-welcome.flow.ts", "src/sales/flows/opportunity-won-alert.flow.ts", "src/sales/flows/task-urgent-alert.flow.ts", "src/sales/flows/task-due-reminder.flow.ts", "src/sales/flows/billing-handoff-closed-won.flow.ts", "src/sales/flows/_billing-endpoint.ts", "src/revenue/flows/quote-generation.flow.ts", "src/revenue/flows/contract-renewal.flow.ts", "src/revenue/flows/quote-expiration.flow.ts", "src/revenue/flows/contract-expiration.flow.ts", "src/revenue/flows/billing-handoff-contract-activated.flow.ts", "src/marketing/flows/campaign-enrollment.flow.ts", "src/marketing/flows/campaign-member-enroll.flow.ts", "src/marketing/flows/campaign-completion.flow.ts", "src/sales/skills/lead-qualification.skill.ts", "src/sales/skills/email-drafting.skill.ts", "src/sales/skills/revenue-forecasting.skill.ts", "src/sales/skills/customer-360.skill.ts", "src/sales/skills/live-data.skill.ts", "src/sales/sharing/account.sharing.ts", "src/sales/sharing/opportunity.sharing.ts", "src/sales/sharing/positions.ts", "src/marketing/sharing/campaign.sharing.ts", "src/sales/data/sales.seed.ts", "src/sales/data/_shared.ts", "src/sales/data/activity.seed.ts", "src/sales/data/forecast.seed.ts", "src/sales/data/index.ts", "src/revenue/data/catalog.seed.ts", "src/revenue/data/opportunity-line-item.seed.ts", "src/revenue/data/revenue.seed.ts", "src/service/data/service.seed.ts", "src/service/objects/_case-sla.ts", "src/marketing/data/marketing.seed.ts", "objectstack.composition.ts"],
  "sourcesContent": ["const __injected_filename__ = \"/home/user/hotcrm-issue-2097/objectstack.config.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/objectstack.config.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport { composeStacks } from '@objectstack/spec';\n\n// The two package stacks, built \u2014 see `objectstack.composition.ts`, which also\n// resolves the `HOTCRM_COMPOSITION` knob and records why that work cannot live\n// in this file (\u26D4 this module may carry no named export: the build parses it\n// against a `.strict` stack schema and fails on any key but the default).\nimport { serviceStack, appStack } from './objectstack.composition.js';\n\n/**\n * ONE release artifact, TWO packages (ADR-0130 D4).\n *\n *  - `app.objectstack.hotcrm` (`src/sales/index.ts`) \u2014 the `type: 'app'`\n *    package a customer installs: sales, plus the `src/revenue/` and\n *    `src/marketing/` directories it still registers, the app and its\n *    navigation groups, the permission sets, the locale packs.\n *  - `app.objectstack.hotcrm.service` (`src/service/index.ts`) \u2014 the support\n *    module: cases and knowledge, and the five navigation entries it\n *    contributes into the app's groups.\n *\n * `manifest: 'preserve'` is the only option that separates \"one artifact\n * carrying N packages\" from the pick-one composition every other strategy\n * performs. It emits `packages[]`, one entry per input stack carrying that\n * package ASSEMBLED \u2014 its manifest plus the collections it owns. That list is\n * what `ObjectQL.registerApp` registers package by package, and it is where\n * per-package OWNERSHIP comes from. Each definition is carried ONCE, in the\n * body of the package that owns it: a multi-package artifact has no flattened\n * copy of its collections beside `packages[]` (ADR-0130 D4, 2026-09-22\n * addendum), so a reader wanting \"every object of the app\" resolves the\n * package bodies, as every platform reader does.\n *\n * The App package is LAST deliberately, and that is not the load-bearing half:\n *\n *  - the singular `manifest` is still picked by the default `'last'` rule, so\n *    the artifact identifies as the App a consumer installs (ADR-0019 D1),\n *    `app.objectstack.hotcrm`, not as one of its modules;\n *  - REGISTRATION order is decided by `dependencies` \u2014 the service module\n *    declares `app.objectstack.hotcrm`, and `packages[]` is sorted through the\n *    platform's one topological sorter (ADR-0130 D5, ADR-0116) \u2014 so the app\n *    registers first whatever slot it occupies here. An artifact that only\n *    worked because someone listed the packages in the right order is the\n *    failure ADR-0116 exists about, and it fails SILENTLY.\n *\n * `objectstack build` compiles this file into one `dist/objectstack.json`;\n * `objectstack dev` boots the same shape straight from source.\n */\nexport default composeStacks([serviceStack, appStack], { manifest: 'preserve' });\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/sales/index.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/sales\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/sales/index.ts\";// Copyright (c) 2026 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport { defineStack, type ObjectStackDefinition, type ObjectStackDefinitionInput } from '@objectstack/spec';\n\n/**\n * Everything the app package REGISTERS, as opposed to what it IS.\n *\n * The identity keys are not in it and cannot be passed: `manifest`, `requires`\n * and `i18n` are this package's own statement about itself, and `packages`\n * belongs to the artifact envelope one level up.\n */\nexport type HotCrmAppCollections = Omit<\n  ObjectStackDefinitionInput,\n  'manifest' | 'packages' | 'requires' | 'i18n'\n>;\n\n/**\n * `app.objectstack.hotcrm` \u2014 the App package of this artifact, and the sales\n * module (ADR-0130 D4, `module-split-plan.md` decision 4).\n *\n * ADR-0019 requires exactly one `type: 'app'` package per artifact and the\n * artifact takes its identity from it; nothing requires that package to be an\n * empty shell, and the platform's own two-package fixture\n * (`examples/app-multi-package`) says the opposite \u2014 its App package owns the\n * customer object and the navigation. So sales IS the app: it keeps the id\n * `app.objectstack.hotcrm`, owns the customer core and the activity objects,\n * the app and its navigation GROUPS, the cross-domain dashboards and skills,\n * the permission sets, the positions, the four locale packs, the import\n * mappings, and every source file more than one package needs.\n *\n * ## Why this file takes its collections instead of importing them\n *\n * `src/revenue/` and `src/marketing/` are packages in the LAYOUT but not yet\n * packages in the ARTIFACT \u2014 the ruling asked for sales and support first \u2014 so\n * the app package registers their collections for now. A file under\n * `src/sales/` may not import from a module directory (AGENTS.md *Project\n * Architecture* rule 2: own directory or `src/sales/`, never sideways), so the\n * assembly of those two cannot happen here. It happens in\n * `objectstack.composition.ts`, the root module that is allowed to see every\n * package. When revenue and marketing become packages of their own, the\n * argument shrinks to the sales barrels and this file can import them itself.\n *\n * ## `artifactObjects` \u2014 the permission sets stay whole here\n *\n * ADR-0130's 2026-09-02 addendum keeps every permission set WHOLE in the\n * `type: 'app'` package: a set is authored per ROLE, so no module owns one. The\n * app package also owns objects of its own, so `defineStack` would otherwise\n * read a grant on `crm_case` as a grant on an object \"not defined in objects\".\n * `artifactObjects` is the platform's answer to exactly that (objectstack#18202):\n * the names the OTHER packages of this artifact own, against which this\n * package's `permissions[].objects` and `data[].object` \u2014 and those two\n * reference classes only \u2014 are resolved. Measured on 17.7.0: without it, the\n * seven sets' 18 grants on `crm_case`, `crm_knowledge_article` and\n * `crm_article_feedback` are refused (\"defineStack cross-reference validation\n * failed (18 issues)\"); with it, none. The claim is verified, not trusted: a\n * grant naming an object no package of the artifact defines is still refused,\n * by `composeStacks`' artifact pass, even when the name is listed here. A hook\n * or an app navigation entry on another package's object stays refused;\n * navigation crosses only through the module's `navigationContributions`.\n *\n * ## What is deliberately NOT here\n *\n * The `HOTCRM_COMPOSITION` knob (#1361). It selects permission sets and seed\n * families, and it is resolved once at the root and handed down already\n * applied \u2014 `objectstack.composition.ts` carries the full audit of what the\n * knob changes and why, because the answer is about the ARTIFACT, not about\n * this package.\n */\nexport const createHotCrmAppStack = (\n  collections: HotCrmAppCollections,\n  options: { artifactObjects: readonly string[] },\n): ObjectStackDefinition =>\n  defineStack({\n    manifest: {\n      id: 'app.objectstack.hotcrm',\n      namespace: 'crm',\n      version: '4.0.1',\n      type: 'app',\n      name: 'HotCRM',\n      description: 'AI-Native CRM for the ObjectStack marketplace \u2014 Accounts, Contacts, Leads, Opportunities, Cases, Knowledge, Forecasts, Campaigns, Contracts.',\n      // ADR-0087 protocol handshake (ADR-0025 \u00A73.2): the metadata/runtime\n      // protocol major this app's metadata is authored against. Only the major\n      // participates in the check \u2014 a runtime on a different major refuses the\n      // load with a structured OS_PROTOCOL_INCOMPATIBLE diagnostic (naming the\n      // `objectstack migrate meta` replay) instead of failing deep in a schema\n      // parse. Bump together with `specVersion` on every platform upgrade\n      // (docs/MAINTENANCE.md \u00A73) \u2014 `test/docs-declared-versions.test.ts` now\n      // enforces that pairing against `objectstack.manifest.json` instead of\n      // trusting this comment, because two platform upgrades in a row (rc.2, then\n      // rc.3) moved the manifest and left this line behind (#728). Every package\n      // of this artifact states the same protocol; `src/service/index.ts`\n      // repeats it for the same reason.\n      engines: { protocol: '^18.0.0-next.0' },\n    },\n\n    // \u2500\u2500\u2500 Platform capabilities this app needs \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n    // The runtime resolves each capability name to a built-in service plugin\n    // and auto-loads it (with extras like Automation's node packs). No need\n    // to hand-instantiate plugins or pass `--preset` flags. See\n    // packages/cli/src/commands/serve.ts CAPABILITY_PROVIDERS for the\n    // complete map; explicit `plugins: [...]` always shadows the resolver.\n    // `auth` enables the auth/login surface (login/register) via @objectstack/plugin-auth.\n    // `ui`   serves the unified Console shell and CRM apps under /_console/\n    //        (login at /_console/login). ObjectStack 7.x replaced the legacy\n    //        /_studio/ and /_account/ mounts with this single /_console/ surface.\n    // Both are required for a clickable login flow when running `objectstack start`\n    // off the compiled artifact.\n    // Note: the foundational slate (queue, job, cache, settings, email,\n    // storage) is auto-injected by the CLI for every non-`minimal`\n    // preset \u2014 see `ALWAYS_CAPS` in packages/cli/src/commands/serve.ts.\n    // Listed below only the *opt-in* capabilities this stack actually\n    // wants on top of that slate.\n    // `triggers` installs the record-change + schedule trigger providers that\n    // actually fire autolaunched flows (record_change & schedule types). Without\n    // it the `automation` engine registers flows but nothing ever launches them.\n    // Schedule triggers run via the job service (in the always-on slate).\n    //\n    // This is the APP package's slate. `defineStack` validates capabilities per\n    // stack, so `src/service/index.ts` declares the four its own metadata needs\n    // itself, and the artifact's slate is the union of the two lists.\n    //\n    // `ai` is deliberately NOT listed. ObjectStack 11.3.0 (ADR-0025 S2) removed\n    // `@objectstack/service-ai` from the open edition \u2014 the AI runtime now ships\n    // only in the closed cloud package, and the framework CLI does not depend on\n    // it. Under ObjectStack 16, `requires: ['ai']` is a *fail-fast* capability:\n    // the serve command hard-aborts boot when the package is absent, so keeping it\n    // here would break `objectstack start`/`dev` for this open-edition app (the AI\n    // block runs before every other capability resolves). The AI metadata is\n    // unaffected \u2014 the skills still validate, build into the artifact, and run\n    // wherever a runtime provides the `ai` tier (cloud's objectos-runtime). There\n    // are no app-authored agents: they were retired in #512 and the surface is\n    // skills-only (ADR-0063 \u00A72); skills attach to a platform agent by `surface`.\n    // A local open-edition boot simply omits the AI service and hides its console\n    // surface. To run AI locally, declare `@objectstack/service-ai` (cloud) in\n    // package.json \u2014 its mere presence best-effort auto-loads it.\n    // `hierarchy-security` is the ONE enterprise-edition capability this app\n    // declares. It was introduced for #880 \u2014 `sales_manager` authored\n    // `writeScope: 'own_and_reports'` on `crm_contract`, an ADR-0057 HIERARCHY\n    // scope resolved by the `hierarchy-scope-resolver` service that ships only\n    // in `@objectstack/security-enterprise`, and `defineStack` refuses such a\n    // grant unless the capability is declared. Since #549 `crm_contract` is\n    // `controlled_by_parent` under the account, that scope is inert and is no\n    // longer authored; the app currently authors NO hierarchy scope at all.\n    //\n    // The declaration STAYS. Maintainer ruling 2026-08-31 (#1378, pinned by\n    // `test/hierarchy-read-depth.test.ts`): nothing is removed from `requires[]`.\n    // Maintainer ruling, 2026-08-11, verbatim: \u300C\u672C\u9879\u76EE\u662F\u5143\u6570\u636Eapp\uFF0C\u5728\u4F01\u4E1A\u7248\u8FD0\u884C\u5C31\n    // \u5177\u5907\u4F01\u4E1A\u7248\u76F8\u5173\u7684\u80FD\u529B\uFF0C\u4E0D\u91CD\u590D\u5F00\u53D1\u3002\u300D The app states what it MEANS and the\n    // edition supplies the capability, rather than approximating it with a broader\n    // open-edition value.\n    //\n    // UNLIKE `ai` above, this is SAFE to declare on an open-edition boot and does\n    // NOT fail fast. Verified against `@objectstack/cli`'s serve command: the\n    // capability resolver looks the token up in `CAPABILITY_PROVIDERS`, finds no\n    // entry, and because `hierarchy-security` IS in the known\n    // `PLATFORM_CAPABILITY_TOKENS` vocabulary it takes the deliberate \"stay quiet\"\n    // branch \u2014 no warning, no abort \u2014 since the capability arrives via an explicit\n    // enterprise plugin in `plugins[]`. Only tier-gated tokens (ai / ai-studio /\n    // i18n / ui / auth) have the dedicated hard-abort blocks the note above\n    // describes. `objectstack validate` does print one informational line naming\n    // the package to install; that is expected output, not a defect to silence.\n    requires: ['automation', 'triggers', 'analytics', 'auth', 'ui', 'approvals', 'sharing', 'hierarchy-security'],\n\n    // The locale configuration is the ARTIFACT's, and `i18n` is a\n    // `'single'`-disposition key: two stacks declaring different values make\n    // `composeStacks` throw, and declaring identical ones twice is a second\n    // place to drift. It lives on the App package, alone.\n    i18n: {\n      defaultLocale: 'en',\n      supportedLocales: ['en', 'zh-CN', 'ja-JP', 'es-ES'],\n      fallbackLocale: 'en',\n    },\n\n    ...collections,\n  }, { artifactObjects: options.artifactObjects });\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/service/index.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/service\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/service/index.ts\";// Copyright (c) 2026 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport { defineStack, type ObjectStackDefinition, type ObjectStackDefinitionInput } from '@objectstack/spec';\n\nimport {\n  EscalateCaseAction, CloseCaseAction, ClaimCaseAction,\n  LogCallAction, LogMeetingAction, CaseScheduleMeetingAction,\n  MarkArticleHelpfulAction, MarkArticleNotHelpfulAction,\n} from './actions/index.js';\nimport { ServiceDashboard } from './dashboards/index.js';\nimport { CaseDataset } from './datasets/index.js';\nimport { ServiceEmailTemplates } from './email-templates/index.js';\nimport {\n  CaseEscalationFlow, CaseEscalationOnCreateFlow, EscalateCaseFlow, CloseCaseFlow,\n  ClaimCaseFlow, CaseEscalationStampFlow, CaseSlaMonitorFlow,\n} from './flows/index.js';\nimport { ArticleFeedback, Case, KnowledgeArticle } from './objects/index.js';\nimport { articleFeedbackHook, caseHook, knowledgeArticleHook } from './objects/hooks.js';\nimport { CaseDetailPage } from './pages/index.js';\nimport {\n  CasesByStatusPriorityReport, SlaPerformanceReport, CasesOpenedByDayPriorityReport,\n} from './reports/index.js';\nimport {\n  CaseDirectorSharingRule, CaseEscalationSharingRule, CaseUnassignedTriageSharingRule,\n} from './sharing/index.js';\nimport { CaseTriageSkill } from './skills/index.js';\nimport { CaseViews, KnowledgeArticleViews } from './views/index.js';\n\n/**\n * The four collections of this package that the app-wide sweeps also read,\n * named once, here.\n *\n * `objectstack.composition.ts` assembles `allHooks`, `allFlows`, `allSkills`\n * and `CrmSharingRules` \u2014 every hook, flow, skill and sharing rule of the\n * ARTIFACT \u2014 out of each package's own list, so the suites that sweep them keep\n * reading one list and this package's half of it is the very array its stack\n * registers. `.flat()` because a `*.hook.ts` may default-export an ARRAY of\n * hooks (one file, several triggers on its object).\n */\nexport const serviceHooks = [articleFeedbackHook, caseHook, knowledgeArticleHook].flat();\n\n/** This package's flows \u2014 see {@link serviceHooks}. */\nexport const serviceFlows = [\n  CaseEscalationFlow, CaseEscalationOnCreateFlow, EscalateCaseFlow, CloseCaseFlow,\n  ClaimCaseFlow, CaseEscalationStampFlow, CaseSlaMonitorFlow,\n];\n\n/** This package's skills \u2014 see {@link serviceHooks}. */\nexport const serviceSkills = [CaseTriageSkill];\n\n/** This package's sharing rules \u2014 see {@link serviceHooks}. */\nexport const serviceSharingRules = [\n  CaseEscalationSharingRule, CaseDirectorSharingRule, CaseUnassignedTriageSharingRule,\n];\n\n/**\n * What this package registers but does not assemble: its seed rows.\n *\n * Everything else comes from this package's own barrels. The seed families are\n * the one exception because WHICH families a build replays is the\n * `HOTCRM_COMPOSITION` knob's decision (#1361), made once, at the root \u2014 a\n * SaaS tenant gets the product catalogue and nothing else, so this package\n * registers no rows in that shape. See `seedDataFor` in\n * `objectstack.composition.ts`.\n */\nexport type HotCrmServiceCollections = Pick<ObjectStackDefinitionInput, 'data'>;\n\n/**\n * `app.objectstack.hotcrm.service` \u2014 the SUPPORT module of this artifact\n * (ADR-0130 D4: one release artifact, N packages, one namespace).\n *\n * It owns `crm_case`, `crm_knowledge_article` and `crm_article_feedback`, and\n * every item authored against them: their hooks, views, the case detail page,\n * the seven case flows, the case and article actions, `case_metrics` and the\n * three reports over it, the Service Overview dashboard, the case-triage skill,\n * the three case sharing rules, the two case notification templates and the\n * case and knowledge seed rows.\n *\n * Three properties are load-bearing:\n *\n *  - **The same `namespace` as the app package.** That is what ADR-0130 D1\n *    buys: co-ownership of one namespace inside one artifact, so `crm_case`\n *    keeps its name instead of becoming `service_case`. The object `name` IS\n *    the table name, the REST path and the saved-view key (ADR-0129 D1\u2013D2), so\n *    a rename would be a data migration; this split costs none.\n *  - **`dependencies` is the edge; the array order in `objectstack.config.ts`\n *    is not.** The load path sorts `packages[]` through the platform's one\n *    topological sorter (ADR-0130 D5, ADR-0116), so the app package registers\n *    first whatever slot it occupies in the `composeStacks([\u2026])` call.\n *  - **Navigation crosses only through contributions** \u2014 the block below.\n *\n * \u26D4 No `i18n` here: it is a `'single'`-disposition stack key, so two stacks\n * declaring DIFFERENT values make `composeStacks` throw and declaring identical\n * ones twice is a second place to drift. The app package declares it once, for\n * the artifact \u2014 and the locale packs that label this package's objects stay\n * whole in the app package with it.\n *\n * `requires` is the opposite: `defineStack` validates trigger capability PER\n * STACK, so a package whose own flows declare `record_change` / `schedule`\n * triggers must declare `triggers` itself \u2014 the app package's slate does not\n * reach this parse:\n *\n *     \u2717 flow 'case_escalation' declares a 'record_change' trigger but\n *       `requires` does not include 'automation' or 'triggers' \u2014 no\n *       'record_change' trigger would be registered \u2026\n *\n * (measured on 17.7.0 by deleting the line below: three such refusals, one\n * per triggered case flow).\n *\n * So this list is exactly what THIS package's metadata needs: `automation` and\n * `triggers` for the seven case flows, `analytics` for `case_metrics` and the\n * items over it, `sharing` for the three case sharing rules. The app package's\n * surface capabilities (`auth`, `ui`, `approvals`, `hierarchy-security`) are\n * not repeated.\n *\n * Registration stays file-by-file: every item is named here, through its\n * directory barrel. A file that reaches no barrel and no line below is\n * validated by nothing.\n */\nexport const createHotCrmServiceStack = (\n  collections: HotCrmServiceCollections,\n): ObjectStackDefinition => defineStack({\n  manifest: {\n    id: 'app.objectstack.hotcrm.service',\n    name: 'HotCRM Service',\n    // The app package's namespace, deliberately (ADR-0130 D1).\n    namespace: 'crm',\n    // The ARTIFACT's version: one `package.json`, one build, one release\n    // (ADR-0130 D6), so a module of this artifact is never at a version of its\n    // own. Bump it with the app package's and `package.json` \u2014\n    // `test/docs-declared-versions.test.ts` holds all three, and the range\n    // below, to one value.\n    version: '4.0.1',\n    type: 'module',\n    description: 'HotCRM support module \u2014 cases, knowledge articles, and the SLA surface.',\n    // The same protocol as the app package (ADR-0087 handshake); bump it with\n    // `specVersion` on every platform upgrade, exactly as the app's is.\n    engines: { protocol: '^18.0.0-next.0' },\n    // The App package this module extends.\n    dependencies: { 'app.objectstack.hotcrm': '^4.0.1' },\n\n    /**\n     * The five navigation entries this module puts into the app's menu\n     * (ADR-0029 D7).\n     *\n     * Not a design choice: an app's own `navigation` may not name another\n     * package's object (ADR-0130 \u00A71.5, rule R3 of `module-split-plan.md`), so\n     * all five became contributions the moment `crm_case`,\n     * `crm_knowledge_article`, `service_dashboard` and `sla_performance` left\n     * the app package. The app keeps the GROUPS (`group_service`, `group_work`,\n     * `group_insights`) \u2014 a container a module cannot declare inside an app it\n     * does not own \u2014 and this module fills them.\n     *\n     * `app` is the app's bare `name` (`crm_enterprise`), not the manifest id: a\n     * dotted id is refused as a non-snake_case identifier.\n     *\n     * \u26A0\uFE0F `priority` orders CONTRIBUTIONS against each other inside a group. It\n     * does NOT interleave them with the app's own children \u2014 a contributed item\n     * is appended after everything the app itself declares in that group. The\n     * one visible consequence is `nav_my_cases`, 4th of 6 in *My Work* before\n     * the split and last after it; the three `group_service` items and\n     * `nav_report_sla` keep their positions because the app declares nothing\n     * after them. \u26D4 Do not compensate with a per-item `order`: that key sorts\n     * in the renderer only, this app authors none anywhere, and adding one to\n     * work around a platform merge rule is what AGENTS.md forbids.\n     */\n    navigationContributions: [\n      {\n        app: 'crm_enterprise',\n        group: 'group_service',\n        // Stated rather than defaulted so that the day a second package\n        // contributes into one of these groups, the order is an authored fact\n        // instead of a registration-order accident.\n        priority: 10,\n        items: [\n          { id: 'nav_case',      type: 'object', objectName: 'crm_case',              label: 'Cases',     icon: 'life-buoy' },\n          { id: 'nav_knowledge', type: 'object', objectName: 'crm_knowledge_article', label: 'Knowledge', icon: 'book-open' },\n          { id: 'nav_service_dashboard', type: 'dashboard', dashboardName: 'service_dashboard', label: 'Service Overview', icon: 'gauge' },\n        ],\n      },\n      {\n        app: 'crm_enterprise',\n        group: 'group_work',\n        priority: 20,\n        items: [\n          { id: 'nav_my_cases', type: 'object', objectName: 'crm_case', viewName: 'my_open_cases', label: 'My Cases', icon: 'life-buoy' },\n        ],\n      },\n      {\n        app: 'crm_enterprise',\n        group: 'group_insights',\n        priority: 30,\n        items: [\n          { id: 'nav_report_sla', type: 'report', reportName: 'sla_performance', label: 'SLA Performance', icon: 'timer' },\n        ],\n      },\n    ],\n  },\n\n  // What THIS package's metadata needs \u2014 see the `requires` paragraph above.\n  requires: ['automation', 'triggers', 'analytics', 'sharing'],\n\n  objects: [ArticleFeedback, Case, KnowledgeArticle],\n  hooks: serviceHooks,\n  views: [CaseViews, KnowledgeArticleViews],\n  pages: [CaseDetailPage],\n  flows: serviceFlows,\n  actions: [\n    EscalateCaseAction, CloseCaseAction, ClaimCaseAction,\n    LogCallAction, LogMeetingAction, CaseScheduleMeetingAction,\n    MarkArticleHelpfulAction, MarkArticleNotHelpfulAction,\n  ],\n  datasets: [CaseDataset],\n  reports: [CasesByStatusPriorityReport, SlaPerformanceReport, CasesOpenedByDayPriorityReport],\n  dashboards: [ServiceDashboard],\n  skills: serviceSkills,\n  sharingRules: serviceSharingRules,\n  emailTemplates: ServiceEmailTemplates,\n\n  ...collections,\n});\n\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/service/actions/case.actions.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/service/actions\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/service/actions/case.actions.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport type { Action } from '@objectstack/spec/ui';\nimport { P } from '@objectstack/spec';\n\n/**\n * Case actions \u2014 all three delegate to screen flows in\n * `src/service/flows/case-actions.flow.ts` (see the note there for why: modal\n * actions never execute their body in 16.1.0, and script bodies cannot\n * UPDATE a record on a sharing-ruled object; screen flows are the mechanism\n * that demonstrably works, same as `convert_lead` / `schedule_followup`).\n */\nexport const EscalateCaseAction: Action = {\n  name: 'escalate_case',\n  label: 'Escalate Case',\n  objectName: 'crm_case',\n  icon: 'alert-triangle',\n  type: 'flow',\n  target: 'escalate_case',\n  locations: ['record_header', 'list_item'],\n  visible: P`has(record.is_escalated) && record.is_escalated == false && has(record.is_closed) && record.is_closed == false`,\n  confirmText: 'This will escalate the case to the escalation team. Continue?',\n  successMessage: 'Case escalated successfully!',\n  refreshAfter: true,\n};\n\nexport const CloseCaseAction: Action = {\n  name: 'close_case',\n  label: 'Close Case',\n  objectName: 'crm_case',\n  icon: 'check-circle',\n  type: 'flow',\n  target: 'close_case',\n  locations: ['record_header'],\n  visible: P`has(record.is_closed) && record.is_closed == false`,\n  confirmText: 'Are you sure you want to close this case?',\n  successMessage: 'Case closed successfully!',\n  refreshAfter: true,\n};\n\n/**\n * Claim Case \u2014 the affordance for the unassigned-triage gesture.\n *\n * \u26A0\uFE0F `visible` MUST mirror the sharing grant, never a convenience flag.\n * `case_unassigned_triage_sharing` (`src/service/sharing/case.sharing.ts`) is what\n * decides whether the agent looking at this button may write the row at all, so\n * the predicate here is copied from it verbatim. \u26D4 Never restate it as\n * `record.is_closed == false`: that flag is derived as `status === 'closed'` and\n * never flips on `resolved`, so it would offer a Claim button on resolved\n * ownerless cases the agent is not shared and cannot claim \u2014 a button that\n * answers FORBIDDEN. The button and the grant are one sentence stated twice, and\n * `test/claim-case-one-owner-writer.test.ts` holds them to that.\n *\n * No `confirmText`: the flow opens a screen that asks which working status the\n * agent is claiming into, and that screen IS the confirmation. A modal in front\n * of it would be two dialogs for one gesture.\n */\nexport const ClaimCaseAction: Action = {\n  name: 'claim_case',\n  label: 'Claim Case',\n  objectName: 'crm_case',\n  icon: 'user-plus',\n  type: 'flow',\n  target: 'claim_case',\n  locations: ['record_header', 'list_item'],\n  // \u26D4 Deliberately NOT `has()`-guarded \u2014 the one site the #1890 totality sweep\n  // left alone after making every other `visible` in `src/actions/` total. This\n  // predicate is the sharing grant's own text, verbatim, and\n  // `test/claim-case-one-owner-writer.test.ts` compares the two strings; the\n  // grant itself cannot carry `has()`, because `plugin-sharing` compiles a\n  // criteria condition with `compileCelToFilter`, which rejects the whole\n  // function-call class, and an untranslatable rule is DROPPED by the seeder\n  // (#621). `src/service/sharing/case.sharing.ts` writes that out in full, including why\n  // `record.owner_id == null` is total one layer down (`{ owner_id: { $null: true } }`).\n  // \u26A0\uFE0F What that reasoning does NOT cover is THIS surface: an action `visible` is\n  // interpreted by CEL in the browser against whatever the page holds, which is\n  // `{}` for the first renders, so this predicate does abort there. Making it\n  // total needs the grant and the parity pin moved together \u2014 a maintainer call,\n  // not this card's. (#1890)\n  visible: P`record.owner_id == null && record.status != \"resolved\" && record.status != \"closed\"`,\n  successMessage: 'Case claimed \u2014 it is yours now.',\n  refreshAfter: true,\n};\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/service/objects/index.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/service/objects\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/service/objects/index.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\n/**\n * Service object barrel.\n *\n * Re-exports this package's *.object.ts definitions; the `*.hook.ts` files\n * beside them register through `./hooks.ts`. The canonical note on the\n * collaboration capabilities (`enable.files`, `enable.feeds`) that every\n * object in this app points at is written once, in\n * `src/sales/objects/index.ts`.\n */\n\nexport { ArticleFeedback } from './article_feedback.object';\nexport { Case } from './case.object';\nexport { KnowledgeArticle } from './knowledge_article.object';\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/service/objects/article_feedback.object.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/service/objects\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/service/objects/article_feedback.object.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport { ObjectSchema, Field } from '@objectstack/spec/data';\n\n/**\n * Article Feedback Object (#601)\n *\n * One reader's verdict on one knowledge article \u2014 the WRITER behind\n * `crm_knowledge_article.helpful_count` / `not_helpful_count`, which were\n * `readonly` with nothing on either side of the platform able to move them.\n *\n * ### Why a row and not a counter bump\n *\n * The obvious shape \u2014 a \"Helpful\" button whose action body does\n * `helpful_count + 1` \u2014 cannot be built on this platform, and the reason is\n * measured rather than assumed:\n *\n *  - A `type: 'script'` action body runs in the QuickJS sandbox, whose\n *    execution context carries no caller identity. An UPDATE it issues against\n *    an object with sharing rules is refused by the sharing middleware even for\n *    the record's owner \u2014 the measurement `src/service/flows/case-actions.flow.ts`\n *    records, and the reason both case actions are screen flows. INSERTS are\n *    unaffected, which is the seam this object takes.\n *  - `crm_knowledge_article` is `public_read`: read-open, WRITE-OWNED. So the\n *    one agent who could bump the counter by hand is the article's author,\n *    which is precisely the person whose vote is worthless.\n *  - There is no atomic increment on the data API, so two concurrent votes\n *    read-modify-write the same value and one of them disappears.\n *\n * A vote row sidesteps all three: the reader INSERTS their own row (allowed),\n * and `article_feedback_metrics_refresh` (`article_feedback.hook.ts`) RECOUNTS\n * the article's two counters from this table under the hook's own privileges.\n * Recount, not increment \u2014 it is idempotent, it self-heals after a deleted or\n * edited vote, and it cannot drift the way a running total does. Exactly the\n * shape `campaign_member_metrics_refresh` uses to keep `crm_campaign`'s metric\n * block live (#597), which is the precedent this file follows on purpose\n * rather than inventing a second idiom for the same problem.\n *\n * ### What it buys beyond a writer\n *\n * A counter with no row behind it cannot answer \"did this person already\n * vote\", so it counts one enthusiast forty times. `unique_vote_per_reader`\n * below keys one row per (article, reader) and the `submit_article_feedback`\n * action UPDATES that row when a reader changes their mind \u2014 so the counters\n * mean \"how many people\", which is the only reading that makes\n * `helpful_count` vs `not_helpful_count` a comparison rather than two\n * unrelated tallies.\n *\n * \u26A0\uFE0F `verdict` is deliberately two-valued. A five-star scale, a free-text\n * reason taxonomy and \"was this article up to date\" are all plausible and all\n * unbuilt: this object exists to give two declared counters a real writer, and\n * a vocabulary nothing reads would recreate the very defect it is fixing.\n */\nexport const ArticleFeedback = ObjectSchema.create({\n  name: 'crm_article_feedback',\n  label: 'Article Feedback',\n  pluralLabel: 'Article Feedback',\n  icon: 'thumbs-up',\n  description: 'One reader\u2019s helpful / not-helpful verdict on a knowledge article',\n\n  // ADR-0090 D1/D7: OWD is an authored decision. Feedback is an attribute of\n  // the article, so record access DERIVES from it (ADR-0055) \u2014 the same call\n  // `crm_campaign_member` makes, and for the same reason: a vote row means\n  // nothing apart from the article it is about, and `crm_knowledge_article` is\n  // `public_read`, so anyone who can read the article can read its feedback.\n  //\n  // \u26D4 Not `private`: with the voter as owner, the counters' own evidence would\n  // be invisible to the author trying to understand them \u2014 the same way it was\n  // wrong on `crm_campaign_member`.\n  sharingModel: 'controlled_by_parent',\n\n  // ADR-0079: junction rows have no derivable text title; point the canonical\n  // nameField at the stored autonumber explicitly (autonumber is not in the\n  // auto-derivation whitelist). Same call as `crm_campaign_member` and\n  // `crm_event_attendee`.\n  nameField: 'feedback_number',\n\n  // A related list takes its columns from the child's `highlightFields` MINUS\n  // the lookup it is scoped by, and this object ships no view of its own \u2014 so\n  // this list IS the feedback panel on an article's detail page (#944): the\n  // verdict, and who gave it.\n  //\n  // TWO fields are deliberately absent, for two different reasons:\n  //\n  //  - `feedback_number`, the same call `crm_campaign_member` makes with\n  //    `member_number`: it is the record TITLE, which a detail page hoists out\n  //    of the body, so leading the strip with it would fill the panel with\n  //    autonumbers instead of verdicts.\n  //  - `comment`, a 500-character textarea. A highlight strip holds short\n  //    values, and keeping it out is also what stops the `basic` group being\n  //    ENTIRELY title-or-strip \u2014 a group whose every field is hoisted keeps its\n  //    heading on forms and silently vanishes from detail pages\n  //    (`field-group-shadowed`, the same trap `crm_campaign_member`'s `basic`\n  //    group and `crm_task`'s `assignment` group each had to be rescued from).\n  //    So the comment is the group's own content on the row's detail page,\n  //    and reaches the panel through `relatedListColumns` on the article\n  //    lookup below instead (#1199).\n  highlightFields: ['crm_knowledge_article', 'verdict', 'owner_id'],\n\n  fieldGroups: [\n    { key: 'basic', label: 'Feedback', icon: 'message-square' },\n  ],\n\n  fields: {\n    feedback_number: Field.autonumber({\n      label: 'Feedback #',\n      format: 'AF-{0000}',\n      group: 'basic',\n    }),\n\n    // Platform ownership anchor \u2014 canonical note in `account.object.ts` (#548).\n    // Here it is also the VOTER: the platform stamps it on insert, which is\n    // what `unique_vote_per_reader` keys on and what lets a reader change\n    // their own mind without an admin's help.\n    owner_id: Field.lookup('sys_user', {\n      label: 'Reader',\n      group: 'basic',\n      system: true,\n      readonly: false,\n    }),\n\n    /**\n     * The article this verdict is about.\n     *\n     * `deleteBehavior: 'cascade'` \u2014 a vote on a deleted article denotes\n     * nothing. This is the lesson #696 cost the campaign junction: both party\n     * lookups there took `Field.lookup`'s `set_null` default, the cleared row\n     * instantly violated the object's own required-reference rule, and every\n     * enrolled person became permanently undeletable. A required lookup that\n     * defaults to `set_null` is that bug waiting to happen, so the behaviour is\n     * spelled out here rather than inherited.\n     */\n    crm_knowledge_article: Field.lookup('crm_knowledge_article', {\n      label: 'Article',\n      required: true,\n      storage: { notNull: true },\n      group: 'basic',\n      deleteBehavior: 'cascade',\n      description: 'Knowledge article this feedback is about.',\n\n      // Curates the feedback panel on the article's detail page \u2014 the surface\n      // the article's AUTHOR reads (#1199). A related list reads\n      // `relatedListColumns` on the child's lookup before it falls back to\n      // `highlightFields` minus that lookup (#944), so this is a SUPERSET of\n      // the fallback (Verdict / Reader) plus `comment`: the note a reader\n      // types to explain a verdict was stored and shown on no list, and the\n      // author the field's own description names could not see it without\n      // opening each row. Last, because it is the one long value.\n      //\n      // \u26D4 Deliberately NOT solved by adding `comment` to `highlightFields` \u2014\n      // see the note above that list (`field-group-shadowed`).\n      relatedListColumns: ['verdict', 'owner_id', 'comment'],\n    }),\n\n    verdict: Field.select({\n      label: 'Verdict',\n      required: true,\n      storage: { notNull: true },\n      group: 'basic',\n      options: [\n        { label: 'Helpful', value: 'helpful', color: '#10B981', default: true },\n        { label: 'Not Helpful', value: 'not_helpful', color: '#EF4444' },\n      ],\n    }),\n\n    comment: Field.textarea({\n      label: 'Comment',\n      group: 'basic',\n      maxLength: 500,\n      description: 'Optional note explaining the verdict \u2014 read by the article\u2019s author.',\n    }),\n  },\n\n  indexes: [\n    { fields: ['crm_knowledge_article'] },\n    { fields: ['verdict'] },\n    // One vote per reader per article. Without it the counters answer \"how many\n    // clicks\", which is not a number anybody wants next to \"Not Helpful\".\n    //\n    // `unique: 'organization'` states the scope explicitly, per ADR-0120: the\n    // driver prepends the NULL-safe organization key part\n    // (`COALESCE(organization_id, '__global__')`) at registration, so the\n    // constraint is one vote per reader per article WITHIN an organization,\n    // and rows with no organization form one bucket rather than each escaping\n    // under SQL's NULL-distinct semantics. Bare `unique: true` is the\n    // deprecated positional spelling of `'global'` \u2014 it warns today\n    // (`unique/unscoped-declared-index`) and protocol 18 rejects it, and\n    // \"globally unique across every installation\" is not what one reader's\n    // opinion of one article means.\n    { fields: ['crm_knowledge_article', 'owner_id'], unique: 'organization' },\n  ],\n\n  enable: {\n    apiEnabled: true,\n    apiMethods: ['get', 'list', 'create', 'update', 'delete'],\n  },\n});\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/service/objects/case.object.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/service/objects\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/service/objects/case.object.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport { ObjectSchema, Field } from '@objectstack/spec/data';\nimport { F, P } from '@objectstack/spec';\n\nexport const Case = ObjectSchema.create({\n  name: 'crm_case',\n  label: 'Case',\n  pluralLabel: 'Cases',\n  icon: 'life-buoy',\n  description: 'Customer support cases and service requests',\n\n  // ADR-0090 D1/D7: OWD is an authored decision. Owner + escalation sharing rule.\n  sharingModel: 'private',\n\n  fieldGroups: [\n    { key: 'basic',       label: 'Case Information', icon: 'info' },\n    { key: 'origin',      label: 'Origin & Routing', icon: 'route' },\n    { key: 'sla',         label: 'SLA & Priority',   icon: 'clock' },\n    { key: 'resolution',  label: 'Resolution',       icon: 'check-circle' },\n    { key: 'escalation',  label: 'Escalation',       icon: 'alert-triangle', collapse: 'collapsed' },\n    { key: 'system',      label: 'System',           icon: 'database',       collapse: 'collapsed' },\n  ],\n\n  fields: {\n    // Platform ownership anchor \u2014 canonical note in `account.object.ts` (#548).\n    owner_id: Field.lookup('sys_user', {\n      label: 'Case Owner',\n      group: 'origin',\n      system: true,\n      readonly: false,\n      trackHistory: true,\n    }),\n\n    // Case Information\n    //\n    // `unique: true` is declared HERE, on the field, and deliberately NOT as a\n    // `{ fields: ['organization_id', 'case_number'], unique: true }` entry in\n    // `indexes[]` below (#1023) \u2014 same spelling `crm_account.name`,\n    // `crm_contact.email` and `crm_product.sku` already use, for the same\n    // reason. Since framework #3696 the field-level form is per-organization:\n    // it materializes as the composite `(organization key part, case_number)`,\n    // unique WITHIN an organization. Since platform 17.0.0-rc.4 (ADR-0120 D3,\n    // #5030) that key part is NULL-safe \u2014 `COALESCE(organization_id,\n    // '__global__')` \u2014 so rows with no organization form ONE bucket instead of\n    // each escaping the constraint under SQL's NULL-distinct semantics.\n    //\n    // The hand-written table composite this replaced could not get that: a\n    // declared index is taken verbatim, so it materialized as plain\n    // `UNIQUE (organization_id, case_number)` and enforced NOTHING on any row\n    // whose `organization_id` was NULL \u2014 i.e. every row of a single-organization\n    // or untenanted install. It also read as \"unique per organization\" while\n    // materializing as an unscoped composite, which is the bare-`unique: true`\n    // spelling ADR-0120 warns on in 17.x and protocol 18 rejects (#5082).\n    //\n    // Scope spelling: bare `true` at FIELD level already means \"per\n    // organization\" and carries no deprecation (`'organization'` is its\n    // explicit synonym with byte-identical materialization \u2014 measured). It is\n    // written as `true` to match the four sibling objects above; switching the\n    // repo to the explicit word is a uniform decision for all of them, not\n    // something `crm_case` forks on alone.\n    case_number: Field.autonumber({\n      label: 'Case Number',\n      group: 'basic',\n      format: 'CASE-{00000}',\n      unique: true,\n    }),\n    \n    subject: Field.text({\n      label: 'Subject',\n      group: 'basic',\n      required: true,\n      storage: { notNull: true },\n      searchable: true,\n      maxLength: 255,\n    }),\n\n    // ADR-0079 record title (was titleFormat '{case_number} - {subject}').\n    display_title: Field.formula({\n      label: 'Display Title',\n      group: 'basic',\n      expression: F`record.case_number + \" - \" + record.subject`,\n    }),\n\n    description: Field.markdown({\n      label: 'Description',\n      group: 'basic',\n      required: true,\n      storage: { notNull: true },\n    }),\n    \n    // Relationships\n    crm_account: Field.lookup('crm_account', {\n      label: 'Account',\n      group: 'basic',\n    }),\n    \n    crm_contact: Field.lookup('crm_contact', {\n      label: 'Contact',\n      group: 'basic',\n      // Optional so Web-to-Case (anonymous) submissions can land without\n      // an existing CRM contact. Back-office staff or a triage flow links\n      // the case to a contact after the fact. This matches the Salesforce\n      // Web-to-Case convention.\n      // @objectstack 12: string[] `referenceFilters` is dead (not read by the\n      // picker). `dependsOn` is the live cascading-lookup form \u2014 it scopes the\n      // contact candidates to those sharing the case's `crm_account` (ADR-0049).\n      dependsOn: ['crm_account'],\n    }),\n    \n    // Case Management\n    status: Field.select({\n      label: 'Status',\n      group: 'basic',\n      required: true,\n      storage: { notNull: true },\n      // ADR-0052 \u00A75b.1 \u2014 platform auto-renders status changes on the timeline\n      // (\"Status: New \u2192 Escalated\"). Delivers the case timeline declaratively\n      // (the hand-coded version was deferred in #396 due to a hook-crash bug).\n      trackHistory: true,\n      options: [\n        { label: 'New', value: 'new', color: '#808080', default: true },\n        { label: 'In Progress', value: 'in_progress', color: '#FFA500' },\n        { label: 'Waiting on Customer', value: 'waiting_customer', color: '#FFD700' },\n        { label: 'Waiting on Support', value: 'waiting_support', color: '#4169E1' },\n        { label: 'Escalated', value: 'escalated', color: '#FF0000' },\n        { label: 'Resolved', value: 'resolved', color: '#00AA00' },\n        { label: 'Closed', value: 'closed', color: '#006400' },\n      ]\n    }),\n    \n    priority: Field.select({\n      label: 'Priority',\n      group: 'sla',\n      required: true,\n      storage: { notNull: true },\n      trackHistory: true,\n      options: [\n        { label: 'Low', value: 'low', color: '#4169E1', default: true },\n        { label: 'Medium', value: 'medium', color: '#FFA500' },\n        { label: 'High', value: 'high', color: '#FF4500' },\n        { label: 'Critical', value: 'critical', color: '#FF0000' },\n      ]\n    }),\n\n    // Sortable ordinal for `priority`. Ordering a queue by the select field\n    // itself sorts the raw strings, so `priority desc` yields\n    // medium > low > high > critical \u2014 the exact inversion of urgency, which\n    // buried every critical case at the bottom of the agent's queue. Select\n    // options carry no ordinal in the spec, so the rank is materialised here\n    // and stamped by `case_sla_defaults`; queue views sort on it instead.\n    // `0` is the UNRANKED sentinel, shared with crm_task.priority_rank: it is\n    // what a record carries when no recognised priority has been stamped, and\n    // it sorts below every real rank (1\u20134) on the `priority_rank desc` queues.\n    // \u26D4 It must not be `1` here (or `2` on crm_task): a non-zero sentinel\n    // orders the same unknown priority differently on the two objects, and on\n    // this one it is indistinguishable from a genuine `low`.\n    priority_rank: Field.number({\n      label: 'Priority Rank',\n      readonly: true,\n      defaultValue: 0,\n    }),\n\n    type: Field.select({\n      label: 'Case Type',\n      group: 'basic',\n      options: [\n        { label: 'Question', value: 'question' },\n        { label: 'Problem', value: 'problem' },\n        { label: 'Feature Request', value: 'feature_request' },\n        { label: 'Bug', value: 'bug' },\n      ]\n    }),\n    \n    origin: Field.select({\n      label: 'Case Origin',\n      group: 'origin',\n      options: [\n        { label: 'Email', value: 'email' },\n        { label: 'Phone', value: 'phone' },\n        { label: 'Web', value: 'web' },\n        { label: 'Chat', value: 'chat' },\n        { label: 'Social Media', value: 'social_media' },\n      ]\n    }),\n    \n    // Assignment\n    \n    // SLA and Metrics\n    //\n    // NO `created_date` here (#1992, the #575 B2 precedent on\n    // `crm_opportunity`): the platform already injects `created_at` on every\n    // object and stamps it on every insert, while this duplicate had no writer\n    // at all \u2014 only the seed data set it, so every case created through the\n    // UI or REST stored null and fell out of \"Cases Opened by Priority \u00D7 Day\"\n    // and the service dashboard's date range. Surfaces that need the creation\n    // instant read `created_at` (the `case_metrics` dataset, the dashboard\n    // range, the `case_timeline` view, `case_sla_defaults`' resolution time);\n    // the seeds author it directly, and the seed loader keeps an authored\n    // `created_at` on first insert since @objectstack/objectql 17.7.0\n    // (objectstack#21646).\n    closed_date: Field.datetime({\n      label: 'Closed Date',\n      group: 'sla',\n      readonly: true,\n    }),\n    \n    // \u26D4 NOT `readonly`: stamped by `event_activity_bubble`\n    // (`src/sales/objects/event.hook.ts`) on the first HELD `crm_event` related to the\n    // case, whoever wrote that event. \u26A0\uFE0F That hook reaches this case through\n    // `ctx.api`, a `ScopedContext` over the ACTING USER's execution context \u2014\n    // so its write is a CALLER-supplied write from a non-`isSystem` context,\n    // which `stripReadonlyFields` deletes. `readonly` here silently disables\n    // the stamp. (A hook writing its OWN record's `ctx.input.data` is a\n    // different case and SURVIVES `readonly` \u2014 hook-written keys are not\n    // caller-supplied. Measured in `test/readonly-write-semantics.test.ts`.)\n    //\n    // Definition: the moment the customer first heard back from us, matching\n    // Salesforce `FirstResponseDateTime` / Zendesk first reply time \u2014 NOT an\n    // internal status change, which would report \"responded\" while the customer\n    // is still waiting.\n    first_response_date: Field.datetime({\n      label: 'First Response Date',\n      group: 'sla',\n    }),\n    \n    resolution_time_hours: Field.number({\n      label: 'Resolution Time (Hours)',\n      group: 'sla',\n      readonly: true,\n      scale: 2,\n    }),\n    \n    // Stamped once, on the first write that gives the case a priority, from the\n    // priority \u00D7 account-tier matrix in `./_case-sla.ts` (`case_sla_defaults`).\n    // Not `readonly`: a service manager may legitimately renegotiate a deadline,\n    // and the hook never overwrites a value that is already there.\n    sla_due_date: Field.datetime({\n      label: 'SLA Due Date',\n      description: 'Set from the case priority and the account\u2019s Customer Tier, in calendar hours: nights, weekends and holidays count.',\n      group: 'sla',\n    }),\n    \n    // Stamped by two writers, one per side of the clock stop (#2070): the\n    // `case_sla_monitor` schedule flow while the case is live work, and\n    // `case_sla_defaults` on the write that resolves or closes it late. The\n    // rule both apply is `caseSlaBreached` in `./_case-sla.ts`.\n    //\n    // NOT `readonly` \u2014 but NOT for the reason this comment used to give, and\n    // the difference is measured in `test/readonly-write-semantics.test.ts`\n    // (#1429). `case_sla_monitor` declares `runAs: 'system'`, so its writes\n    // would SURVIVE a `readonly: true` here. It stays writable pending a\n    // decision that has to weigh the other surfaces (seed data,\n    // `service-agent.profile.ts`, the create form), not because the platform\n    // would drop the sweep's write.\n    //\n    // \u26A0\uFE0F This is now the ONLY escalation-group flag still declared writable:\n    // `is_escalated` and `escalated_date` became `readonly: true` when #1434\n    // moved their user-context writer into a system sub-flow. So the open\n    // question here is narrower than it was \u2014 it is purely about this field's\n    // authoring surfaces, with no platform obstacle left to blame.\n    is_sla_violated: Field.boolean({\n      label: 'SLA Violated',\n      group: 'sla',\n      defaultValue: false,\n    }),\n    \n    // Escalation\n    //\n    // `readonly: true` \u2014 the honest declaration, because nobody types this.\n    // Its three writers are now unanimously elevated (#1434, maintainer-\n    // approved decision batch #21 \u2461):\n    //\n    //   case_escalation        runAs: 'system'  (record-change)\n    //   case_sla_monitor       runAs: 'system'  (schedule)\n    //   case_escalation_stamp  runAs: 'system'  (called by the escalate_case\n    //                                            screen flow via a subflow node)\n    //\n    // \u2B50 What changed, and why the readonly declaration is now safe: the\n    // `escalate_case` screen flow used to write this field itself, and it\n    // stays `runAs: 'user'` because a person clicks it. The platform's\n    // readonly strip is one branch of the UPDATE path\n    // (`if (!opCtx.context?.isSystem)`, over CALLER-supplied keys), so that\n    // user-context write WOULD have been silently dropped. Rather than\n    // elevating the whole screen flow, the stamp moved into the dedicated\n    // `case_escalation_stamp` sub-flow. The agent's own writes\n    // (`escalation_reason`, `priority`, `status`) still carry their identity;\n    // only these two stamps are elevated.\n    //\n    // The guest-submission branch of `case.hook.ts` also forces this false, and\n    // is unaffected: it is a `beforeInsert` hook, so its key is not\n    // caller-supplied AND the INSERT path is exempt from the strip entirely.\n    // Seed data (`service.seed.ts`) is exempt for the same reason.\n    //\n    // \u26D4 If you find yourself reverting this to writable so a user-context flow\n    // write lands, you are re-opening #1434 \u2014 add a `subflow` step instead.\n    // Semantics measured in `test/readonly-write-semantics.test.ts`.\n    is_escalated: Field.boolean({\n      label: 'Escalated',\n      group: 'escalation',\n      readonly: true,\n      defaultValue: false,\n    }),\n    \n    // `readonly: true`, same reasoning as `is_escalated` above and stamped by\n    // the same writers \u2014 `case_escalation` and the `case_escalation_stamp`\n    // sub-flow, both `runAs: 'system'`. Never typed by a person.\n    escalated_date: Field.datetime({\n      label: 'Escalated Date',\n      group: 'escalation',\n      readonly: true,\n    }),\n    \n    // \u26D4 DELIBERATELY NOT `readonly`, and this is load-bearing (#1434). This is\n    // the agent's own screen input \u2014 `escalate_case`'s screen collects it and\n    // writes it with the USER's context. Declaring it readonly would make the\n    // platform silently strip the reason the agent just typed, which is the\n    // harm #1434 was filed about, inverted onto user input. It is also\n    // required whenever `is_escalated` flips true (the\n    // `escalation_reason_required` validation below), so dropping it would\n    // reject the escalation outright.\n    escalation_reason: Field.textarea({\n      label: 'Escalation Reason',\n      group: 'escalation',\n    }),\n    \n    // No `parent_case`. A case hierarchy was declared here and never\n    // traversed: nothing rolled child cases up, nothing closed or notified them\n    // with the parent, and no service flow read the link. Related cases that\n    // matter in this app are linked through the knowledge article that resolved\n    // them (`resolved_by_article`), which the deflection measures do read.\n    \n    // Resolution\n    resolution: Field.markdown({\n      label: 'Resolution',\n      group: 'resolution',\n    }),\n\n    /**\n     * The knowledge article that RESOLVED this case (#601).\n     *\n     * The second half of a two-way link, and deliberately not a replacement for\n     * the first. `crm_knowledge_article.related_to_case` points the other way \u2014\n     * \"the case this article was WRITTEN FROM\" \u2014 and the two answer different\n     * questions: provenance (where did this article come from) versus\n     * deflection (what did this article save us). Merging them would make both\n     * unanswerable, so both stay.\n     *\n     * This is the column the deflection measures on `case_metrics` read\n     * (`kb_resolved_count` / `kb_deflection_rate`), which is why blank is\n     * normalised to NULL by `case_resolution_article_normalize` in\n     * `case.hook.ts`: the close-case screen sends `''` for a field the agent\n     * left empty, an empty string is NOT null, and `count(resolved_by_article)`\n     * counts it \u2014 a silently inflated numerator on a ratio widget, the exact\n     * shape of #614.\n     */\n    resolved_by_article: Field.lookup('crm_knowledge_article', {\n      label: 'Resolved by Article',\n      group: 'resolution',\n      description: 'Knowledge article that resolved this case \u2014 the deflection signal.',\n    }),\n\n\n    // Internal notes\n    internal_notes: Field.markdown({\n      label: 'Internal Notes',\n      group: 'system',\n      description: 'Internal notes; not visible to the customer.',\n    }),\n    \n    // Flags\n    is_closed: Field.boolean({\n      label: 'Is Closed',\n      group: 'system',\n      defaultValue: false,\n      readonly: true,\n    }),\n  },\n  \n  // Database indexes for performance\n  //\n  // `case_number` is an autonumber (`CASE-{00000}`), and the platform's\n  // autonumber sequence is PER TENANT \u2014 every organization counts from 1. A\n  // platform-wide unique index on it therefore rejects the second\n  // organization's `CASE-00001` on insert: the exact collision framework #3696\n  // exists to prevent. The constraint has to match the sequence that feeds it.\n  //\n  // No `{ fields: ['organization_id', 'case_number'], unique: true }` here\n  // (#1023). Case-number uniqueness is declared on the `case_number` field\n  // itself \u2014 see the note there for why the hand-written table composite could\n  // not express it. Do NOT add it back alongside the field-level declaration\n  // either: declaring both makes the verbatim index win and leaves the\n  // per-organization one unreachable (framework#3991\n  // `unique/double-declaration`), which would silently undo the fix.\n  indexes: [\n    { fields: ['crm_account'] },\n    { fields: ['owner_id'] },\n    { fields: ['status'] },\n    { fields: ['priority'] },\n  ],\n  \n  // API surface. History \u2192 Field.trackHistory (ADR-0052).\n  enable: {\n    apiEnabled: true,\n    // #602 \u2014 screenshots and logs are how a support case gets diagnosed.\n    // See the canonical capability note in `src/sales/objects/index.ts`.\n    files: true,\n  },\n\n  // ADR-0052 \u00A75b.2 \u2014 declarative milestone activity for the service narrative.\n  // The caseSideEffects hook still owns its real side-effects (escalation task,\n  // closed-date stamping); these are timeline entries only, emitted by the platform.\n  activityMilestones: [\n    { field: 'status', value: 'escalated', summary: 'Case escalated \u2014 {subject}', type: 'updated' },\n    { field: 'status', value: 'resolved', summary: 'Case resolved \u2014 {subject}', type: 'completed' },\n    { field: 'status', value: 'closed', summary: 'Case closed \u2014 {subject}', type: 'completed' },\n  ],\n\n  // ADR-0079: render-only `titleFormat` retired in favor of `nameField`,\n  // which names a real field. The former template composed two local fields, so\n  // the `display_title` formula field (see fields) reproduces it.\n  nameField: 'display_title',\n  // Explicit search targets (ADR-0061). REQUIRED because nameField is a\n  // FORMULA (display_title/full_name): without this, $search auto-defaults to\n  // the formula field, which isn't a real column, so the lookup picker + global\n  // search silently return zero. These are real, indexed columns.\n  searchableFields: ['subject', 'case_number'],\n  highlightFields: ['case_number', 'subject', 'crm_account', 'status', 'priority'],\n  \n  // Removed: list_views and form_views belong in UI configuration, not object definition\n  \n  // Predicates below are TOTAL: every `record.x` read is `has()`-guarded, so the\n  // rule returns a verdict even when the merged record has no such key. See\n  // AGENTS.md \"Validation predicates must be TOTAL\" and\n  // test/object-validation-predicates.test.ts, which fails the build otherwise.\n  validations: [\n    {\n      name: 'resolution_required_for_closed',\n      type: 'script',\n      severity: 'error',\n      message: 'Resolution is required when closing a case',\n      condition: P`has(record.status) && record.status == \"closed\" && (!has(record.resolution) || isBlank(record.resolution))`,\n    },\n    {\n      name: 'escalation_reason_required',\n      type: 'script',\n      severity: 'error',\n      message: 'Escalation reason is required when escalating a case',\n      condition: P`has(record.is_escalated) && record.is_escalated == true && (!has(record.escalation_reason) || isBlank(record.escalation_reason))`,\n    },\n    {\n      name: 'case_status_progression',\n      type: 'state_machine',\n      severity: 'warning',\n      message: 'Invalid status transition',\n      field: 'status',\n      // Escalate + Close actions are available from ANY open status (see\n      // escalate_case / close_case visibility). The transition map must permit\n      // \u2192escalated and \u2192closed from every open state, else those actions emit a\n      // spurious \"Invalid status transition\" warning (e.g. escalating a brand-new\n      // case, which is a legitimate support move).\n      transitions: {\n        'new': ['in_progress', 'waiting_customer', 'escalated', 'closed'],\n        'in_progress': ['waiting_customer', 'waiting_support', 'escalated', 'resolved', 'closed'],\n        'waiting_customer': ['in_progress', 'waiting_support', 'escalated', 'closed'],\n        'waiting_support': ['in_progress', 'waiting_customer', 'escalated', 'closed'],\n        'escalated': ['in_progress', 'resolved', 'closed'],\n        'resolved': ['closed', 'in_progress'],  // Can reopen\n        'closed': ['in_progress'],  // Can reopen\n      }\n    },\n  ],\n  \n  // \u26A0\uFE0F No `workflows[]` here, and none is possible: object `workflows[]` were\n  // removed from the platform. Field updates live in this object's `*.hook.ts`;\n  // scheduled status flips and notifications live in `src/*/flows/*.flow.ts`.\n});\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/service/objects/knowledge_article.object.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/service/objects\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/service/objects/knowledge_article.object.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport { ObjectSchema, Field } from '@objectstack/spec/data';\nimport { F, P } from '@objectstack/spec';\n\n/**\n * Knowledge Article Object\n *\n * Reusable, search-indexed answers that back the Support Knowledge Base\n * and ground the assistant's case-resolution skills.\n *\n * Lifecycle: draft \u2192 in_review \u2192 published \u2192 archived.\n * Audience:  public (customer portal visible) | internal (agent-only).\n */\nexport const KnowledgeArticle = ObjectSchema.create({\n  name: 'crm_knowledge_article',\n  label: 'Knowledge Article',\n  pluralLabel: 'Knowledge Articles',\n  icon: 'book-open',\n  description: 'Reusable knowledge base articles for self-service and AI grounding',\n\n  // ADR-0090 D1/D7: OWD is an authored decision. Knowledge base is org-readable; authors edit.\n  sharingModel: 'public_read',\n\n  // \u2500\u2500\u2500 Public access \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n  //\n  // Publishing a public article mints a share link through the platform's\n  // `publicSharing` surface (maintainer ruling, 2026-08-02: no customer portal,\n  // no anonymous-grant widening). \u26D4 The whole safety of that rests on\n  // `eligibility`, which is the ONLY thing standing between a share dialog and\n  // a stranger reading an internal or draft article \u2014 so this block may only be\n  // declared while every key below is enforced.\n  //\n  // MEASURED on `@objectstack/plugin-sharing@17.1.0` \u2014 the version\n  // installed AT THE TIME of the measurement, not the current pin (this table\n  // has NOT been re-taken on any later pin \u2014 not 17.3.0, #1676, not 17.4.0,\n  // PR #1814, and not 17.5.0) \u2014\n  // against the real `ShareLinkService` and a real engine,\n  // not read off a grep count:\n  //\n  //   | key                  | measured on 17.1.0                             |\n  //   | -------------------- | ---------------------------------------------- |\n  //   | `enabled`            | ENFORCED \u2014 false \u21D2 SHARING_NOT_ENABLED 422     |\n  //   | `allowedAudiences`   | ENFORCED \u2014 `signed_in` refused 422             |\n  //   | `allowedPermissions` | ENFORCED \u2014 non-`view` refused 422              |\n  //   | `redactFields`       | APPLIED to every token-served response         |\n  //   | `eligibility`        | **ENFORCED \u2014 false verdict \u21D2 422, no link**    |\n  //\n  // `test/knowledge-article-share-links.test.ts` drives all of it end to end\n  // and is the acceptance evidence; read it before changing anything here.\n  //\n  // \u26A0\uFE0F TWO SPELLING TRAPS, both measured, both of which produce a block that\n  // LOOKS declared and silently is not:\n  //\n  //  1. `eligibility` must be a PLAIN STRING. It is `z.ZodString` in the spec\n  //     and `getPolicy()` keeps it only when `typeof raw.eligibility ===\n  //     'string'`. The `P` tagged template used by `validations[].condition`\n  //     below returns an Expression OBJECT `{ dialect, source }` \u2014 passing one\n  //     here does not narrow anything, it makes the predicate vanish.\n  //\n  //  2. Every field read is `record.`-PREFIXED. The evaluator is\n  //     `ExpressionEngine` from `@objectstack/formula` (record-level CEL), and\n  //     `record` is the ONLY binding it is given. The bare-identifier spelling\n  //     `status == 'published' && audience == 'public'` COMPILES and then fails\n  //     at evaluate with `Unknown variable: audience`,\n  //     which `assertEligible` turns into ELIGIBILITY_UNEVALUABLE 422. That\n  //     fails CLOSED, so it is not a security hole; it is a feature that never\n  //     mints a single link while reading as if it works.\n  //\n  // The predicate is TOTAL for the same reason the `validations` below are:\n  // `has()` guards every read. `assertEligible` materializes declared fields to\n  // `null` first, so an absent key would not abort here today \u2014 the guards keep\n  // that true if the field set changes. (The `has(record.x)` caveat carried\n  // from objectstack#7861 is about `compileCelToFilter`, the SHARING-RULE path.\n  // That is a different evaluator, it is not on this code path, and it is not\n  // even exported from `@objectstack/plugin-sharing`. Verified, not assumed.)\n  //\n  // \u26A0\uFE0F Eligibility is evaluated at MINT time only; `resolveToken()` does not\n  // re-check it. Re-classifying a published/public article to internal or back\n  // to draft does NOT revoke links already minted from it \u2014 those must be\n  // revoked explicitly. That is platform behaviour, filed upstream, not\n  // something this app compensates for app-side.\n  publicSharing: {\n    enabled: true,\n    // `public` and `link_only` only. `signed_in` would be a different feature\n    // and `email` is refused at creation without an allowlist.\n    allowedAudiences: ['public', 'link_only'],\n    // Read-only. Same as the platform default, declared anyway: this is a\n    // security boundary, and a default is not a decision.\n    allowedPermissions: ['view'],\n    // The gate. Published AND public-audience, nothing else \u2014 a draft, an\n    // in_review, an archived, or any internal-audience article is refused at\n    // `createLink` with RECORD_NOT_ELIGIBLE 422 and no row is written.\n    eligibility:\n      'has(record.status) && record.status == \"published\" && ' +\n      'has(record.audience) && record.audience == \"public\"',\n    // Stripped from every token-served response. These are the fields that\n    // exist for staff: who owns the article, which customer case it was\n    // written from, and when an editor last reviewed it. None of them are part\n    // of the answer a reader followed the link for.\n    redactFields: ['owner_id', 'related_to_case', 'last_reviewed_at'],\n  },\n\n  // ADR-0079: render-only `titleFormat` retired in favor of `nameField`,\n  // which names a real field. The former template composed two local fields, so\n  // a `display_title` formula field reproduces it for the record title.\n  nameField: 'display_title',\n  // Explicit search targets (ADR-0061). REQUIRED because nameField is a\n  // FORMULA (display_title/full_name): without this, $search auto-defaults to\n  // the formula field, which isn't a real column, so the lookup picker + global\n  // search silently return zero. These are real, indexed columns.\n  searchableFields: ['title', 'article_number', 'summary'],\n  highlightFields: ['article_number', 'title', 'category', 'status', 'audience'],\n\n  fieldGroups: [\n    { key: 'basic',     label: 'Article Information', icon: 'info' },\n    { key: 'content',   label: 'Content',             icon: 'file-text' },\n    { key: 'taxonomy',  label: 'Categorization',      icon: 'tag' },\n    { key: 'metrics',   label: 'Engagement',          icon: 'activity', collapse: 'collapsed' },\n  ],\n\n  fields: {\n    // Platform ownership anchor \u2014 canonical note in `account.object.ts` (#548).\n    owner_id: Field.lookup('sys_user', {\n      label: 'Article Owner',\n      group: 'basic',\n      system: true,\n      readonly: false,\n      trackHistory: true,\n    }),\n\n    article_number: Field.autonumber({\n      label: 'Article Number',\n      format: 'KA-{0000}',\n      group: 'basic',\n    }),\n\n    title: Field.text({\n      label: 'Title',\n      required: true,\n      storage: { notNull: true },\n      searchable: true,\n      maxLength: 255,\n      group: 'basic',\n    }),\n\n    // ADR-0079 record title (was titleFormat '{article_number} - {title}').\n    display_title: Field.formula({\n      label: 'Display Title',\n      expression: F`record.article_number + \" - \" + record.title`,\n      group: 'basic',\n    }),\n\n    summary: Field.text({\n      label: 'Summary',\n      description: 'One-paragraph TL;DR shown in search results and AI citations.',\n      maxLength: 500,\n      searchable: true,\n      group: 'basic',\n    }),\n\n    body: Field.markdown({\n      label: 'Body',\n      description: 'Full article content (Markdown).',\n      searchable: true,\n      group: 'content',\n    }),\n\n    category: Field.select({\n      label: 'Category',\n      group: 'taxonomy',\n      options: [\n        { label: 'Getting Started',     value: 'getting_started', default: true },\n        { label: 'How-To',              value: 'how_to' },\n        { label: 'Troubleshooting',     value: 'troubleshooting' },\n        { label: 'Billing & Pricing',   value: 'billing' },\n        { label: 'API & Integrations',  value: 'api' },\n        { label: 'Release Notes',       value: 'release_notes' },\n        { label: 'Policy',              value: 'policy' },\n      ],\n    }),\n\n    tags: Field.select({\n      label: 'Tags',\n      multiple: true,\n      group: 'taxonomy',\n      options: [\n        { label: 'Auth',          value: 'auth' },\n        { label: 'SSO',           value: 'sso' },\n        { label: 'Mobile',        value: 'mobile' },\n        { label: 'Email',         value: 'email' },\n        { label: 'Reports',       value: 'reports' },\n        { label: 'Performance',   value: 'performance' },\n        { label: 'Data Import',   value: 'data_import' },\n        { label: 'Webhooks',      value: 'webhooks' },\n      ],\n    }),\n\n    status: Field.select({\n      label: 'Status',\n      required: true,\n      storage: { notNull: true },\n      group: 'basic',\n      trackHistory: true,\n      options: [\n        { label: 'Draft',      value: 'draft',     color: '#94A3B8', default: true },\n        { label: 'In Review',  value: 'in_review', color: '#F59E0B' },\n        { label: 'Published',  value: 'published', color: '#10B981' },\n        { label: 'Archived',   value: 'archived',  color: '#475569' },\n      ],\n    }),\n\n    audience: Field.select({\n      label: 'Audience',\n      required: true,\n      storage: { notNull: true },\n      group: 'basic',\n      description: 'Public articles are visible in the customer portal; internal articles are agent-only.',\n      options: [\n        { label: 'Public',   value: 'public', default: true, color: '#0EA5E9' },\n        { label: 'Internal', value: 'internal', color: '#7C3AED' },\n      ],\n    }),\n\n    language: Field.select({\n      label: 'Language',\n      group: 'basic',\n      options: [\n        { label: 'English',             value: 'en', default: true },\n        { label: 'Simplified Chinese',  value: 'zh_cn' },\n        { label: 'Spanish',             value: 'es_es' },\n        { label: 'Japanese',            value: 'ja_jp' },\n      ],\n    }),\n\n    related_to_case: Field.lookup('crm_case', {\n      label: 'Originating Case',\n      description: 'Case this article was authored from (optional).',\n      group: 'content',\n    }),\n\n\n    published_at: Field.datetime({\n      label: 'Published At',\n      readonly: true,\n      group: 'basic',\n    }),\n\n    last_reviewed_at: Field.datetime({\n      label: 'Last Reviewed At',\n      readonly: true,\n      group: 'basic',\n    }),\n\n    /**\n     * `view_count` is GONE (#601), and this note is the record of why.\n     *\n     * All three engagement counters were `readonly: true` with a writer\n     * nowhere \u2014 on the platform or in this app \u2014 so all three were pinned at\n     * whatever the seed said, forever, while the article grid summed a \"Views\"\n     * column. ADR-0049's enforce-or-remove leaves two honest endings per\n     * field: give it a writer, or delete it. The card left this one to the\n     * implementer, and the two below went the other way, so the split is\n     * argued rather than assumed.\n     *\n     * A page-view writer WOULD have been expressible \u2014 `afterFind` is a real\n     * hook event on this platform. It is not built, because of what the event\n     * actually means: `beforeFind`/`afterFind` fire on record MATERIALIZATION,\n     * for `find` and `findOne` alike, with no per-method read event\n     * (deliberately \u2014 see the spec's note on #3195). So a counter written\n     * there would increment on the article grid, on global search, on the\n     * lookup picker in the close-case screen, on the AI grounding queries that\n     * cite articles \u2014 every one of them a \"view\" of a row nobody read. The\n     * number would grow fastest for articles nobody opens, and it would carry\n     * a database write on every read path in the app to do it.\n     *\n     * \"Views\" that means \"appearances in any query\" is a worse lie than a\n     * field that is missing, because it looks like data. A real page-view\n     * counter needs a real view event from a real article surface \u2014 the day\n     * one exists, this field comes back with it, and not before.\n     *\n     * `helpful_count` / `not_helpful_count` DO get a writer, and it is the\n     * whole reason `crm_article_feedback` exists: reader verdicts are recorded\n     * as rows and these two are RECOUNTED from them by\n     * `article_feedback_metrics_refresh`. They stay `readonly: true` and that\n     * is now an accurate statement \u2014 derived from evidence, never typed in.\n     */\n    helpful_count: Field.number({\n      label: 'Helpful Votes',\n      group: 'metrics',\n      readonly: true,\n      defaultValue: 0,\n      description: 'Recounted from crm_article_feedback \u2014 never typed in.',\n    }),\n\n    not_helpful_count: Field.number({\n      label: 'Not Helpful Votes',\n      group: 'metrics',\n      readonly: true,\n      defaultValue: 0,\n      description: 'Recounted from crm_article_feedback \u2014 never typed in.',\n    }),\n  },\n\n  indexes: [\n    { fields: ['title'] },\n    { fields: ['category'] },\n    { fields: ['status'] },\n    { fields: ['audience'] },\n    { fields: ['language'] },\n  ],\n\n  // API surface. History \u2192 Field.trackHistory (ADR-0052).\n  enable: {\n    apiEnabled: true,\n    apiMethods: ['get', 'list', 'create', 'update', 'delete'],\n  },\n\n  // Predicates below are TOTAL: every `record.x` read is `has()`-guarded, so the\n  // rule returns a verdict even when the merged record has no such key. See\n  // AGENTS.md \"Validation predicates must be TOTAL\" and\n  // test/object-validation-predicates.test.ts, which fails the build otherwise.\n  validations: [\n    {\n      name: 'published_requires_body',\n      type: 'script',\n      severity: 'error',\n      message: 'Articles cannot be published without a body.',\n      condition: P`has(record.status) && record.status == \"published\" && (!has(record.body) || record.body == null || record.body == \"\")`,\n    },\n    {\n      name: 'published_requires_summary',\n      type: 'script',\n      severity: 'warning',\n      message: 'Published articles should have a summary for search results and AI citations.',\n      condition: P`has(record.status) && record.status == \"published\" && (!has(record.summary) || record.summary == null || record.summary == \"\")`,\n    },\n  ],\n});\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/sales/objects/index.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/sales/objects\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/sales/objects/index.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\n/**\n * Object Definitions Barrel\n * \n * Re-exports this package's *.object.ts definitions for registration by the\n * app package's stack (`objectstack.composition.ts` \u2192 `src/sales/index.ts`). The `*.hook.ts` files sit beside them and are\n * registered through `./hooks.ts` instead \u2014 a hook is attached to the object\n * it names, and since the ADR-0130 layout a directory is a package, so the two\n * travel together.\n */\n\n/*\n * Canonical note \u2014 the collaboration capabilities (`enable.files`,\n * `enable.feeds`). Referenced from each object that opts in (#602).\n *\n * **`enable.files` \u2014 attachments. Opt-in, spec default `false`.** It is a real,\n * doubly-enforced switch, not documentation:\n *\n * - Server: `plugin-audit`'s `enforceFilesCapability` runs `beforeInsert` on\n *   `sys_attachment` and throws `FILES_DISABLED` (403) when the row's\n *   `parent_object` does not declare `files: true`. No flag \u2192 no attachment can\n *   exist against the record, whatever the UI offers.\n * - Client: the console's `RecordDetailView` gates its Attachments panel on\n *   `enable?.files === true`, so an object without the flag has no upload\n *   surface at all.\n *\n * The flag opens the surface; it grants **no** access of its own, and nothing\n * else on the platform does either. `sys_attachment` is an object like any\n * other: the platform's member baseline names it nowhere (it was narrowed to\n * explicit-allow, objectstack-ai/objectstack#5491), so a person whose\n * permission sets do not grant it is refused the whole panel with 403\n * `PERMISSION_DENIED`, reads included. Measured on a fresh `pnpm dev` box\n * (#2029): `na.rep`, opening a quote they can read, got \"You don't have access\n * to these attachments\", and every other demo persona got the same answer.\n * The platform's attachments-access page names the remedy: an ordinary,\n * position-distributed permission set grants `sys_attachment`. So EVERY\n * permission set whose holders can read a files-enabled object grants it\n * `allowRead`, and `guest_portal` grants nothing.\n *\n * WHICH attachments that grant reaches stays with the parent record: a\n * `service-storage` middleware intersects every `sys_attachment` read with the\n * parents the caller can actually see (failing closed to a deny-all filter on\n * error). So a rep lists the attachments of the quotes they can read and of no\n * other (`test/record-attachments-access.test.ts` measures it).\n *\n * **Upload and delete are NOT granted, on purpose (#2029).** Their gate is\n * `canEdit(parent)` (attach) and uploader-or-`canEdit(parent)` (delete), asked\n * of the sharing service, and on 17.7.0 that service answers `true` for EVERY\n * `controlled_by_parent` object: it reads that model as `public` and never asks\n * the master. Three of the six files-enabled objects are such children\n * (`crm_contact`, `crm_quote`, `crm_contract`). Measured on the same box with\n * the write bits granted: `na.rep` attached a file to a quote they get 404 on\n * (201), and on a contract whose own PATCH answers them 403 they attached a\n * file (201) and deleted the admin's executed-contract file (200), while an\n * attach to a private account they cannot read answered 403\n * `ATTACHMENT_PARENT_ACCESS`. So the write bits would let every persona plant\n * files on, and delete others' files from, quotes, contracts and contacts\n * they cannot edit. That is a platform defect, reported upstream\n * from #2029; until its fix is in the pinned version, only an administrator\n * uploads, and the write bits join `allowRead` here when it lands (AGENTS.md\n * \u00A72: wait, do not route around it).\n *\n * Leads are deliberately excluded \u2014 attachments on unqualified leads invite\n * junk. Revisit on demand.\n *\n * **`enable.feeds` \u2014 record comments (`sys_comment`). Opt-OUT, spec default\n * `true`.** Both enforcement points gate on an explicit `false`\n * (`enforceFeedsCapability` throws `FEEDS_DISABLED` only for `feeds === false`;\n * the console renders the feed unless `enable?.feeds === false`), so every\n * HotCRM object already has comments enabled and authoring `feeds: true` would\n * restate a default rather than change behaviour. Do not add it: an inert\n * restatement is the kind of metadata that later reads as load-bearing.\n * If comments ever need to be switched off for an object, author `false`.\n * `test/collaboration-capabilities.test.ts` pins both halves of this rule.\n *\n * Verified in a live console (#602): the Discussion panel renders on the\n * opportunity and account records, a posted comment round-trips\n * (`POST /api/v1/data/sys_comment` \u2192 201) and survives a reload.\n *\n * Like `enable.files`, the flag opens the surface and grants no access. The\n * Discussion panel reads two platform objects, `sys_comment` (the comments)\n * and `sys_activity` (the record's activity timeline), and the member baseline\n * names neither, so through #2029 every persona but the platform admin got\n * \"You don't have permission to view comments on this record\" and the same for\n * its activity (403 `PERMISSION_DENIED`). So every set that grants\n * `sys_attachment` also grants `sys_comment` read, create and edit and\n * `sys_activity` read, and `guest_portal` grants neither.\n *\n * WHICH threads those grants reach is the platform's, and it follows the\n * parent record (the platform's objectstack-ai/objectstack#4630 gates): a\n * `plugin-audit` middleware narrows every `sys_comment` and `sys_activity` read\n * to rows whose parent the caller can read, a post to a thread whose record the\n * caller cannot read is refused with 403 `RECORD_NOT_ACCESSIBLE`, and only a\n * comment's author may edit it. Measured as `na.rep` on a fresh `pnpm dev` box\n * (#2029): the comments and activity of the accounts, quotes and contracts they\n * can read are listed, those of records they cannot read are not (404 by id),\n * and a post to one of those is refused. `test/record-comments-access.test.ts`\n * pins it.\n *\n * **Deleting a comment is NOT granted, on purpose (#2029).** Its gate is\n * author-or-`canEdit(parent)`, the same sharing-service call as the attachment\n * gate above, with the same 17.7.0 answer of `true` for every\n * `controlled_by_parent` parent. Measured with the delete bit granted: `na.rep`\n * deleted the admin's comment on a contract whose own PATCH answers them 403.\n * Reported upstream from #2029; the delete bit joins the grant when the fix is\n * in the pinned version (AGENTS.md \u00A72).\n */\n\nexport { Account } from './account.object';\nexport { Contact } from './contact.object';\nexport { Event } from './event.object';\nexport { EventAttendee } from './event_attendee.object';\nexport { Forecast } from './forecast.object';\nexport { Lead } from './lead.object';\nexport { Opportunity } from './opportunity.object';\nexport { Task } from './task.object';\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/sales/objects/account.object.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/sales/objects\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/sales/objects/account.object.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport { ObjectSchema, Field } from '@objectstack/spec/data';\nimport { F } from '@objectstack/spec';\nimport { INDUSTRY_OPTIONS } from './_picklists';\nimport { TERRITORY_OPTIONS } from './_territory';\n\nexport const Account = ObjectSchema.create({\n  name: 'crm_account',\n  label: 'Account',\n  pluralLabel: 'Accounts',\n  icon: 'building',\n  description: 'Companies and organizations doing business with us',\n\n  // ADR-0090 D1/D7: OWD is an authored decision. Owner + sharing rules (team/territory grants below).\n  sharingModel: 'private',\n  // ADR-0079: render-only `titleFormat` retired in favor of `nameField`,\n  // which names a real field. The former template composed two local fields, so\n  // a `display_title` formula field reproduces it for the record title.\n  nameField: 'display_title',\n  // Explicit search targets (ADR-0061). REQUIRED because nameField is a\n  // FORMULA (display_title/full_name): without this, $search auto-defaults to\n  // the formula field, which isn't a real column, so the lookup picker + global\n  // search silently return zero. These are real, indexed columns.\n  searchableFields: ['name', 'account_number', 'registration_number'],\n  highlightFields: ['account_number', 'name', 'type', 'owner_id'],\n  // The record's picture (#1199): the record chrome draws the logo beside the\n  // title in every account page header. No logo, no picture: the platform\n  // draws no placeholder or initials in its place.\n  imageField: 'logo',\n\n  // Field groups organize the form layout. Array order == display order.\n  // Each field below opts in via `group: '<key>'`.\n  fieldGroups: [\n    { key: 'basic',        label: 'Basic Information',  icon: 'building' },\n    { key: 'financials',   label: 'Financials',         icon: 'dollar-sign' },\n    // REQ-0003 acceptance 3: the business-profile fields render as their own\n    // group with NO `record:details` section authored anywhere \u2014 the derived\n    // layout ladder's rung 1 (AGENTS.md: escape hatches are for extreme cases).\n    { key: 'business_profile', label: 'Business Profile', icon: 'briefcase' },\n    { key: 'contact_info', label: 'Contact Information', icon: 'phone' },\n    { key: 'ownership',    label: 'Ownership & Status', icon: 'users' },\n    { key: 'branding',     label: 'Branding',           icon: 'palette', collapse: 'collapsed' },\n    { key: 'system',       label: 'System',             icon: 'settings', collapse: 'collapsed' },\n  ],\n\n  fields: {\n    // \u2500\u2500\u2500 Ownership \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n    //\n    // `owner_id` is the PLATFORM ownership anchor, not an app invention: the\n    // registry injects exactly this column into every user-owned object\n    // (`applySystemFields`), and it is the one OWD, sharing rules, owner-scope\n    // widening and the `is_private` row filter all read. \u26D4 Never author a\n    // SECOND `owner` lookup beside it \u2014 reassigning that moves the record in\n    // every list and report and moves no access at all.\n    //\n    // \u26A0\uFE0F Declared rather than left to injection, which the platform supports\n    // explicitly (\"author-declared fields with the same name always win over\n    // injection, no overwrite\"). Three things only a declaration buys:\n    //   \u2022 `os validate` resolves it. An injected column is invisible to every\n    //     author-time rule, so `highlightFields: ['owner_id']` is reported as\n    //     \"not a field on this object \u2014 silently skipped by every consumer\",\n    //     and a CEL predicate reading `record.owner_id` fails outright.\n    //   \u2022 the per-object label and `group` survive (an injected field carries\n    //     the generic label \"Owner\" and no group at all);\n    //   \u2022 `trackHistory` survives, so a transfer still renders on the record\n    //     timeline instead of only in the compliance audit log.\n    // `system: true` keeps the injected marker the platform's own tooling\n    // reads \u2014 notably the clone path, which strips system columns so a copy is\n    // stamped to the cloner rather than inheriting the source's owner.\n    //\n    // No `defaultValue`: the security middleware stamps `owner_id` to the\n    // acting user on any insert that leaves it empty, and denies one that names\n    // another user without `allowTransfer` (#3004). That is stronger than a\n    // field default, which evaluates to nothing on every user-less write.\n    owner_id: Field.lookup('sys_user', {\n      label: 'Account Owner',\n      group: 'ownership',\n      system: true,\n      readonly: false,\n      trackHistory: true,\n    }),\n\n    // AutoNumber field - Unique account identifier\n    account_number: Field.autonumber({\n      label: 'Account Number',\n      format: 'ACC-{000000}',\n      group: 'basic',\n    }),\n\n    // Basic Information\n    //\n    // \u26A0\uFE0F `unique: true` is declared HERE, on the field, and deliberately NOT as\n    // a `{ fields: ['name'], unique: true }` entry in `indexes[]` below. The\n    // field-level form is tenant-scoped \u2014 it materializes as\n    // `(organization_id, name)`, unique WITHIN an organization \u2014 while a\n    // declared index is taken verbatim, i.e. platform-wide. The table form\n    // means the SECOND organization to create an \"Acme Corp\" is rejected by the\n    // database, and account name is also the seed data's external-id / upsert\n    // key (`src/sales/data/sales.seed.ts`), so it bites the first multi-tenant\n    // install. The composite also indexes the column, so no separate\n    // `{ fields: ['name'] }` entry is needed for the `searchableFields` /\n    // seed-upsert read paths.\n    name: Field.text({\n      label: 'Account Name',\n      required: true,\n      storage: { notNull: true },\n      searchable: true,\n      unique: true,\n      maxLength: 255,\n      group: 'basic',\n    }),\n\n    /**\n     * Case- and whitespace-folded copy of `name` \u2014 the key lead conversion\n     * matches accounts on.\n     *\n     * ### Why a stored column, and not any of the cheaper shapes\n     *\n     * \u26A0\uFE0F Three cheaper fixes are all dead ends, and each is a live platform\n     * constraint. `test/account-name-normalized-match.test.ts` re-measures every\n     * one so this note cannot quietly go stale:\n     *\n     * - **A flow cannot normalize.** `service-automation`'s `resolveToken`\n     *   understands exactly one function form, `/^(NOW|TODAY)\\s*\\(\\s*\\)\u2026/`.\n     *   `{LOWER(x)}`, `{TRIM(x)}` and `{x.toLowerCase()}` all resolve to\n     *   `undefined` (every bare identifier is substituted before the expression\n     *   is evaluated, so no string method is reachable), and an unwrapped\n     *   `LOWER({x})` interpolates literally to `\"LOWER(Acme Corp)\"`.\n     * - **A formula field cannot be the match key.** `driver-sql`'s\n     *   `fieldHasColumn` returns false for `type: 'formula'`, so a computed\n     *   value has no physical column and nothing can filter on it.\n     * - **`$regex` is not an answer.** On `driver-sql` it does not run as a\n     *   regex at all: it compiles to `LIKE '%value%'`, a SUBSTRING match, so\n     *   `\"Acme Corp\"` also matches `\"Not Acme Corp Ltd\"`. It cannot collapse\n     *   internal whitespace, the leading wildcard defeats the index, and on the\n     *   in-memory driver it does compile user-controlled text into a `RegExp`.\n     *\n     * So the canonical form is established by the PRODUCER at write time \u2014 the\n     * same doctrine `crm_lead.email` / `crm_contact.email` follow \u2014 and the\n     * reader does a plain, indexed equality match. The other side of that\n     * comparison is `crm_lead.company_normalized`, which exists for the same\n     * reason: a flow can compare two stored columns, it cannot compute either.\n     *\n     * ### What it holds\n     *\n     * `name`, trimmed, lower-cased, with runs of internal whitespace collapsed\n     * to one space. Nothing else \u2014 normalize-then-EXACT. Fuzzy matching\n     * (punctuation folding, legal-suffix stripping, edit distance) is\n     * deliberately out of scope; it turns a lookup into a ranking problem and\n     * needs a human review affordance this app does not have.\n     *\n     * Derived, never authored: `account.hook.ts` recomputes it on every write\n     * that carries `name`, and leaves it alone otherwise. `readonly` keeps\n     * user/API writes off it (INSERT is exempt from the strip and UPDATE strips\n     * only CALLER-supplied keys, so the hook's own write always survives);\n     * `hidden` keeps a machine-owned column out of forms and pickers \u2014 the same\n     * pairing `crm_forecast.seed_key` uses.\n     */\n    name_normalized: Field.text({\n      label: 'Account Name (Normalized)',\n      description:\n        'Match key for lead conversion: Account Name lower-cased, trimmed, with internal whitespace collapsed. Maintained by the account_protection hook \u2014 never edit directly.',\n      readonly: true,\n      hidden: true,\n      maxLength: 255,\n      group: 'system',\n    }),\n\n    // ADR-0079 record title (was titleFormat '{account_number} - {name}').\n    display_title: Field.formula({\n      label: 'Display Title',\n      expression: F`record.account_number + \" - \" + record.name`,\n      group: 'basic',\n    }),\n\n    /**\n     * The counterparty's registered identity in a government registry.\n     *\n     * \u26D4 NOT named after one country's registry, and that is the whole design\n     * constraint (REQ-0003 *Disposition & rationale*). The requirement arrived\n     * as \u793E\u4F1A\u4FE1\u7528\u4EE3\u7801 because the customer registers in China; a Japanese install\n     * writes \u6CD5\u4EBA\u756A\u53F7 here, a German one a Handelsregisternummer, a US one an\n     * EIN. A `unified_social_credit_code` field would carry one country's\n     * registry in its NAME, where no install can rename it \u2014 so the core field\n     * is generic and the registry it came from is the install's own knowledge.\n     *\n     * \u26A0\uFE0F Distinct from `account_number` above, which is OUR sequence\n     * (`Field.autonumber`, `ACC-{000000}`) and already spent as half the record\n     * title. That is an identifier we issue; this is one we were given, and\n     * invoicing, credit checks and entity resolution key on the latter.\n     *\n     * `searchable` + the `searchableFields` entry above is REQ-0003 acceptance\n     * 1 \u2014 the value is findable from global search and the lookup picker. It is\n     * indexed below for that read path.\n     *\n     * \u26D4 NOT `unique: true`. Refusing a save because two rows carry the same\n     * registered identity is a data-quality POLICY, and this repo has already\n     * chosen the soft shape for that question once \u2014 the hard unique on\n     * `crm_lead.email` was removed because refusing a repeat is worse than\n     * recording it. The same reasoning `name_normalized` records: a match key,\n     * not a policy. Deduplication is a review affordance this app does not have.\n     */\n    registration_number: Field.text({\n      label: 'Registration Number',\n      description:\n        \"The counterparty's registered identity as issued by its own government registry \u2014 whichever registry that is. Not the Account Number, which we issue.\",\n      searchable: true,\n      maxLength: 64,\n      group: 'basic',\n    }),\n\n    /**\n     * What this account may be used for commercially \u2014 the category that GATES\n     * capability rather than merely classifying (REQ-0003, the record's most\n     * valuable primitive: *some counterparties are payable but not sellable*).\n     *\n     * ## Why a field BESIDE `type`, and not four more options on it\n     *\n     * REQ-0003 leaves this open (\"either new options on `type` or a field\n     * beside it, decided when built\"). It is a separate field because `type`\n     * is a RELATIONSHIP-STAGE axis \u2014 prospect \u2192 customer \u2192 former, plus\n     * partner \u2014 and it already has two readers that would be broken by a value\n     * meaning \"may not be sold to\": `account.hook.ts` promotes on it, and\n     * `opportunity.hook.ts` flips a won deal's account to `customer`. An\n     * `agency` option on `type` would therefore be overwritten into `customer`\n     * by the first won deal booked against it, silently un-restricting the\n     * account. The two axes are independent \u2014 an agency can be a prospect, a\n     * customer or a former customer \u2014 so they are two fields.\n     *\n     * ## Generic values only\n     *\n     * REQ-0003 rules the customer's own vocabulary (\u62DB\u6807\u4EE3\u7406\u516C\u53F8 \u2026) **C**:\n     * overlay configuration, \u26D4 never committed into core. Core ships the\n     * capability distinction itself; an install maps its market's categories\n     * onto these two values.\n     *\n     * ## What reads it: `opportunity.hook.ts` `beforeInsert`\n     *\n     * REQ-0003 is explicit that \"a category no rule reads is prose, and the\n     * rule is the point\", so this field ships WITH its reader. The reader is a\n     * hook, and which construct carries the gate is a maintainer ruling\n     * (2026-09-16), quoted verbatim and kept untranslated:\n     *\n     *   \u300C\u95F8\u95E8\u8D70 `opportunity.hook.ts` \u7684 `beforeInsert`\uFF0C\u7528 hook \u7684 `ctx.api` \u8BFB\u5BA2\u6237\u7C7B\u522B\u3002\n     *    REQ-0003 \u7B2C 128 \u884C\u7684 `validations[]` \u4E0E\u8BE5\u8BB0\u5F55\u81EA\u5DF1\u7684\u9A8C\u6536\u7B2C 2 \u6761\u51B2\u7A81\uFF0C\u4EE5\u9A8C\u6536\u4E3A\u51C6\u3002\u300D\n     *\n     * \u26D4 Do NOT restate the gate as the `validations[]` entry REQ-0003 line\n     * 128 names. TWO independent measurements say it cannot be that, and both\n     * are recorded here because each alone would be talked past:\n     *\n     *   1. **It would brick history.** A validation is evaluated against\n     *      `{...previous, ...data}` on EVERY write, so \"already linked to a\n     *      restricted account\" and \"linking now\" are the same state and every\n     *      later edit to every historical opportunity would be refused \u2014 the\n     *      exact thing REQ-0003 acceptance 2 forbids (\"opportunities that\n     *      already point at it keep working and keep being editable\").\n     *      `lead.hook.ts` carries the same finding for its own gate.\n     *   2. **It cannot read the account at all.** A predicate is evaluated by\n     *      `checkPredicate(rule, merged, previous)` over plain data objects \u2014\n     *      the opportunity's OWN stored columns. `record.crm_account.type`\n     *      does not traverse the lookup (measured: `runtime: No such key:\n     *      type`), and `os.lookup(...)` has no overload because `buildScope()`\n     *      in `@objectstack/formula` composes `os` from only `ctx.user` /\n     *      `ctx.org` / `ctx.env` and never binds `ctx.api` (measured:\n     *      `runtime: found no matching overload for 'dyn.lookup(string,\n     *      dyn)'`; filed upstream as objectstack#18318). An unevaluable\n     *      predicate REJECTS THE WRITE, so authoring it literally refuses\n     *      every opportunity write, insert and update alike.\n     *\n     * \u26A0\uFE0F The hook's `ctx.api` is a DIFFERENT surface from the formula\n     * `EvalContext.api` that measurement 2 is about, and the two are routinely\n     * confused. The hook one is live and used ~20 times across\n     * `src/sales/objects/*.hook.ts`; its shape is `./_hook-api.ts`, pinned\n     * against a real engine by `test/hook-query-predicate.test.ts` and\n     * `test/hook-write-shape.test.ts`. objectstack#18318 does not block this\n     * field.\n     *\n     * \u26D4 Do NOT \"fix\" anything here by denormalising this value onto\n     * `crm_opportunity`: a copy needs a writer and goes stale the moment an\n     * account is reclassified, and anything able to write the copy is able to\n     * simply refuse.\n     */\n    commercial_capability: Field.select({\n      label: 'Commercial Capability',\n      group: 'basic',\n      description:\n        'Whether new business may be opened against this account. Settlement Only accounts stay fully usable for billing and payment, but no new opportunity may be linked to them.',\n      defaultValue: 'full',\n      options: [\n        { label: 'Full', value: 'full', color: '#00AA00', default: true },\n        { label: 'Settlement Only', value: 'settlement_only', color: '#FFA500' },\n      ],\n    }),\n\n    // Select fields with custom options\n    type: Field.select({\n      label: 'Account Type',\n      group: 'basic',\n      options: [\n        { label: 'Prospect', value: 'prospect', color: '#FFA500', default: true },\n        { label: 'Customer', value: 'customer', color: '#00AA00' },\n        { label: 'Partner', value: 'partner', color: '#0000FF' },\n        { label: 'Former Customer', value: 'former', color: '#999999' },\n      ]\n    }),\n\n    industry: Field.select({\n      label: 'Industry',\n      group: 'basic',\n      // Canonical set shared with Lead (#490): lead_conversion copies\n      // `leadRecord.industry` onto the account it creates, so this must\n      // accept every Lead value.\n      options: [...INDUSTRY_OPTIONS],\n    }),\n\n    description: Field.markdown({\n      label: 'Description',\n      group: 'basic',\n    }),\n\n    // Number fields\n    annual_revenue: Field.currency({\n      label: 'Annual Revenue',\n      min: 0,\n      group: 'financials',\n      trackHistory: true,\n    }),\n\n    /**\n     * Rolled-up annual revenue of this account's direct children.\n     *\n     * \u26A0\uFE0F DIRECT children only, one level \u2014 the engine aggregates over the rows\n     * whose `parent_account` is this account, not over a transitive closure. A\n     * grandparent shows the sum of its own children, and the docs say so;\n     * anything else needs a different (and much more expensive) primitive than\n     * the one the platform ships.\n     *\n     * Self-referencing roll-ups are worth measuring rather than assuming,\n     * because parent and child are the same object and the engine's summary\n     * index is keyed by child object. `test/decorative-field-sweep.test.ts`\n     * drives all four legs of the lifecycle (insert, raise, re-parent, delete)\n     * so a platform regression cannot quietly turn this back into decoration.\n     */\n    child_account_revenue: Field.summary({\n      label: 'Child Account Revenue',\n      group: 'financials',\n      scale: 2,\n      summaryOperations: {\n        object: 'crm_account',\n        field: 'annual_revenue',\n        function: 'sum',\n        relationshipField: 'parent_account',\n      },\n    }),\n\n    number_of_employees: Field.number({\n      label: 'Employees',\n      min: 0,\n      group: 'financials',\n    }),\n\n    // \u2500\u2500\u2500 Business profile (REQ-0003 step 3) \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n    //\n    // Generic B2B sales intelligence, not IT-services vocabulary: who holds the\n    // account today, how much there is to win this year, and how they pay.\n    //\n    // \u26A0\uFE0F `annual_revenue` above answers none of these \u2014 it is the account's OWN\n    // turnover, what the counterparty earns, whereas the budget below is what\n    // it will SPEND with vendors. Reusing one for the other is the mistake this\n    // group exists to prevent.\n    //\n    // \u26A0\uFE0F `pnpm validate` reports all three as \"carrier-only \u2014 declared but\n    // nothing in this stack reads or displays it\", and that reading is EXPECTED\n    // here rather than a defect to tidy away. The liveness diagnostic counts\n    // view columns, form sections, page bindings, flow nodes, formulas, hooks\n    // and actions as sites; it does NOT count `fieldGroups` membership, which\n    // is precisely the DERIVED layout REQ-0003 acceptance 3 asks for (\"render\n    // as their own group \u2026 without any `record:details` section being\n    // authored\"). These are data-entry fields a person fills in and a person\n    // reads off the derived form. \u26D4 Do NOT answer the warning by authoring a\n    // `record:details` section \u2014 that is the escape hatch AGENTS.md reserves\n    // for a named customer demand, and it would trade acceptance 3 for a\n    // quieter log. No guard reads this warning.\n\n    incumbent_vendor: Field.text({\n      label: 'Incumbent Vendor',\n      description: 'The supplier currently holding this account for the spend we are chasing.',\n      maxLength: 255,\n      group: 'business_profile',\n    }),\n\n    annual_purchasing_budget: Field.currency({\n      label: 'Annual Purchasing Budget',\n      description: \"What this account expects to SPEND with vendors this year \u2014 not its own revenue.\",\n      min: 0,\n      group: 'business_profile',\n    }),\n\n    // Payment terms as a select, not free text: it is read by a person sizing\n    // cash-flow risk, and a picklist keeps that domain knowable. The values are\n    // the net-terms ladder every B2B install shares; a customer whose contracts\n    // use a different ladder overlays its own.\n    payment_cycle: Field.select({\n      label: 'Payment Cycle',\n      group: 'business_profile',\n      options: [\n        { label: 'Prepaid', value: 'prepaid' },\n        { label: 'Net 30', value: 'net_30' },\n        { label: 'Net 60', value: 'net_60' },\n        { label: 'Net 90', value: 'net_90' },\n      ],\n    }),\n\n    // Contact Information\n    phone: Field.text({\n      label: 'Phone',\n      format: 'phone',\n      group: 'contact_info',\n    }),\n\n    website: Field.url({\n      label: 'Website',\n      group: 'contact_info',\n    }),\n\n    // Structured Address field (new field type)\n    billing_address: Field.address({\n      label: 'Billing Address',\n      group: 'contact_info',\n    }),\n\n    /**\n     * Flat projection of `billing_address.country`.\n     *\n     * ### Why the flat column exists \u2014 the trap that catches every rule\n     * ### authored against an `address`\n     *\n     * \u26A0\uFE0F `billing_address` is an `address` field: the platform stores the whole\n     * {street, city, state, postalCode, country, countryCode, formatted} value\n     * in ONE column. A sharing rule's CEL condition is compiled to a\n     * pushdown-able `FilterCondition` by `compileCelToFilter`, and that compiler\n     * rejects every path reaching INSIDE such a value:\n     *\n     *     record.billing_address.country in [\"US\",\"CA\",\"MX\"]\n     *       \u2192 unsupported: cross-object/nested field path\n     *         \"record.billing_address.country\" is not pushdown-able\n     *\n     * `plugin-sharing` then refuses to seed the rule rather than degrade it to\n     * match-all, so the rule is dropped on every boot and its recipients get\n     * nothing at all. Measured: the blocker is the NESTED PATH, not the\n     * `in [...]` operator \u2014 `in [...]`, `==`, `!=`, `<`, `>`, `&&`, `||`, `!`,\n     * `startsWith()` and `== null` all compile fine against a FLAT field.\n     * Rewriting the condition as a disjunction of `==` therefore does NOT help;\n     * only a flat column does. `test/sharing-seeding.test.ts` measures that\n     * matrix instead of assuming it.\n     *\n     * ### What it holds\n     *\n     * `billing_address.country`, trimmed, internal whitespace collapsed, and\n     * upper-cased \u2014 nothing else. It is what was TYPED, so it is still free\n     * text and still capable of holding `Deutschland`. Nothing matches against\n     * it: `territory` below classifies it, and an unrecognised spelling lands in\n     * a stated `other`. `countryCode` is deliberately not consulted; see the\n     * note in `account.hook.ts` for why the ISO slot is not the input.\n     *\n     * Derived, never authored: `account.hook.ts` recomputes it on every write\n     * that carries `billing_address`, and leaves it untouched otherwise.\n     */\n    billing_country: Field.text({\n      label: 'Billing Country',\n      description:\n        'Derived from Billing Address \u2014 the country exactly as it was entered, trimmed and upper-cased. Territory is classified from it.',\n      readonly: true,\n      maxLength: 64,\n      group: 'contact_info',\n    }),\n\n    /**\n     * Territory \u2014 the declared value the territory sharing rules filter on.\n     *\n     * ### Why a select and not the country\n     *\n     * Matching free-text `billing_country` against a list of country codes\n     * inside a CEL string means an account whose address reads `United States`\n     * belongs to NO territory, silently \u2014 the metadata says territory sharing\n     * works and for that account it does nothing, with no error anywhere. A\n     * `select` makes the domain knowable: three values, declared, every one\n     * reachable, and an account outside the staffed territories says `other`\n     * rather than nothing.\n     *\n     * It also collapses four copies of the country list (two CEL strings and\n     * six localised documentation tables) into one authored table in\n     * `./_territory.ts`. Adding a country is a line there; the sharing rules,\n     * this picklist and the docs all follow, and\n     * `test/territory-single-source.test.ts` fails if any of them does not.\n     *\n     * ### Readonly, and always stated\n     *\n     * Derived by `account_protection` from `billing_address.country`, never\n     * authored \u2014 correcting an account's territory means correcting its\n     * address, which keeps ONE fact behind the classification. Every insert\n     * states it (an account with no address at all is `other`), and an update\n     * that does not carry the address leaves it alone.\n     */\n    territory: Field.select({\n      label: 'Territory',\n      description:\n        'Derived from Billing Address \u2014 the sales territory this account belongs to. Accounts outside the staffed territories are Other.',\n      readonly: true,\n      options: [...TERRITORY_OPTIONS],\n      group: 'contact_info',\n    }),\n\n    // Office Location (new field type)\n    office_location: Field.location({\n      label: 'Office Location',\n      group: 'contact_info',\n    }),\n\n    // Relationship fields\n\n    /**\n     * The account hierarchy. `child_account_revenue` below is its one reader \u2014\n     * the platform computes roll-up summaries itself, so the honest consumer is\n     * a single declaration rather than hand-written recompute hooks.\n     */\n    parent_account: Field.lookup('crm_account', {\n      label: 'Parent Account',\n      description: 'Parent company in hierarchy',\n      group: 'ownership',\n    }),\n\n    // Boolean field\n    is_active: Field.boolean({\n      label: 'Active',\n      defaultValue: true,\n      group: 'ownership',\n      trackHistory: true,\n    }),\n\n    /**\n     * Where this account stands in its sign-off (REQ-0003 step 5 / acceptance 4).\n     *\n     * `readonly`, so only the platform's own approval write reaches it: a\n     * user's insert or edit that names this column has it stripped (measured\n     * on 17.7.0 for `approved`, `pending` and `rejected` alike, #2067).\n     *\n     * \u26D4 NOT a second boolean beside `is_active`, which REQ-0003 rules out by\n     * name. `is_active` answers \"is this account live at all\"; this answers\n     * \"has the record been signed off\", and collapsing them would make\n     * deactivating an account indistinguishable from rejecting one.\n     *\n     * \u26A0\uFE0F Ships with NO default, and that is what keeps the gate armed (#2067).\n     * A new account is born blank, `account_approval` starts on the blank, and\n     * its approval node opens the request; the node's `approvalStatusField`\n     * mirror then writes `pending` (plugin-approvals `openNodeRequest`) before\n     * the create returns; only the create's own response body still shows the\n     * blank row it inserted. So with approvals in the composition REQ-0003\n     * acceptance 4 holds in as many words (\"A newly created account sits in a\n     * pending state, appears in the platform approval inbox \u2026\"), and `pending`\n     * always has a request behind it. Without approvals (a plan or edition\n     * that omits the capability) nothing opens a request, so nothing writes\n     * `pending`: the account stays blank and editable instead of reading\n     * \"locked for approval\" forever, which is what a shipped `pending` default\n     * did, since the console derives its lock from this column's value.\n     *\n     * \u26D4 Do not restore `defaultValue: 'pending'`, nor an option-level\n     * `default: true` on Pending (the form would preselect it). An install\n     * that wants no account sign-off ADDS `defaultValue: 'approved'`; the\n     * flow's start condition is then false for every record and the gate is\n     * off, switchable and inert. That is the same kind of off switch\n     * `crm_lead.conversion_approval_status` records, and \u26D4 NOT the flow's\n     * `status`, for the reasons measured in `lead-conversion-approval.flow.ts`.\n     *\n     * \u26D4 There is deliberately no `not_required` value. Blank already says\n     * \"no request has been opened\", and `approved` already spells \"nothing to\n     * decide\".\n     */\n    approval_status: Field.select({\n      label: 'Approval Status',\n      group: 'ownership',\n      readonly: true,\n      trackHistory: true,\n      options: [\n        { label: 'Pending', value: 'pending', color: '#FFA500' },\n        { label: 'Approved', value: 'approved', color: '#00AA00' },\n        { label: 'Rejected', value: 'rejected', color: '#FF0000' },\n      ],\n    }),\n\n    // Brand color (new field type)\n    brand_color: Field.color({\n      label: 'Brand Color',\n      group: 'branding',\n    }),\n\n    // Company logo (uploaded image). `accept` / `maxSize` are server-enforced\n    // from @objectstack 17 \u2014 see the note on `crm_product.image`.\n    logo: Field.image({\n      label: 'Company Logo',\n      group: 'branding',\n      accept: ['image/png', 'image/jpeg', 'image/svg+xml', 'image/webp'],\n      maxSize: 2 * 1024 * 1024,\n    }),\n\n    // Date field\n    //\n    // \u26D4 NOT `readonly`, and it must not become readonly. This is the signal\n    // `at_risk_accounts` and `customer_churn_signals` are built on, and it is\n    // written by ONE path: another object's hook calling\n    // `api.object('crm_account').update({ last_activity_date }, \u2026)`.\n    //\n    // \u26A0\uFE0F Platform constraint: `stripReadonlyFields` deletes a readonly key from\n    // any payload whose CALLER supplied it, for every context that is not\n    // `isSystem` \u2014 and a hook's `ctx.api` is a `ScopedContext` over the ACTING\n    // USER's execution context, not a system one. So a readonly field a hook\n    // writes is silently dropped: the engine logs `Field '\u2026' is read-only \u2014\n    // ignoring incoming change` and the column stays null forever.\n    //\n    // \u26D4 `crm_campaign_member.added_date` was cited here as a twin and is NOT\n    // one \u2014 it was ruled `readonly: true` in #1667 precisely because its\n    // writers are INSERTs, which the strip never reaches. THIS field is an\n    // UPDATE through a hook's `ctx.api`, which is the one shape that cannot be\n    // `readonly`. Note the rule\n    // is about the CONTEXT, not about hooks or flows as such \u2014 a hook stamping\n    // its own `ctx.input.data` survives, and a flow survives when its `runAs`\n    // is `'system'` (measured: `test/readonly-write-semantics.test.ts`, #1429;\n    // `crm_case.is_sla_violated` is cited elsewhere as a twin of this field\n    // and is NOT one \u2014 its writer is a system flow). This field stays out of\n    // every form section instead, which is the protection that actually\n    // holds. `test/activity-recency.test.ts` proves\n    // the write lands \u2014 and fails if the flag comes back.\n    last_activity_date: Field.date({\n      label: 'Last Activity Date',\n      group: 'system',\n    }),\n\n    // \u2500\u2500\u2500 Customer Success / Account Health \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n    tier: Field.select({\n      label: 'Customer Tier',\n      group: 'ownership',\n      options: [\n        { label: 'Strategic',  value: 'strategic',  color: '#7C3AED' },\n        { label: 'Enterprise', value: 'enterprise', color: '#4169E1' },\n        { label: 'Mid-Market', value: 'mid_market', color: '#00AA00' },\n        { label: 'SMB',        value: 'smb',        color: '#FFA500', default: true },\n      ],\n    }),\n\n    segment: Field.select({\n      label: 'Segment',\n      group: 'ownership',\n      options: [\n        { label: 'Net New',    value: 'net_new' },\n        { label: 'Growth',     value: 'growth' },\n        { label: 'At Risk',    value: 'at_risk' },\n        { label: 'Stable',     value: 'stable' },\n      ],\n    }),\n\n    health_score: Field.select({\n      label: 'Health Score',\n      group: 'ownership',\n      description: 'CSM-maintained health indicator',\n      options: [\n        { label: 'Healthy',    value: 'healthy',    color: '#00AA00' },\n        { label: 'Watching',   value: 'watching',   color: '#FFA500' },\n        { label: 'At Risk',    value: 'at_risk',    color: '#FF4500' },\n        { label: 'Churning',   value: 'churning',   color: '#FF0000' },\n      ],\n    }),\n\n    // \u26D4 No account-level renewal model here, on purpose. Renewal is a\n    // CONTRACT-level process with exactly one home \u2014 `crm_contract.end_date` +\n    // `renewal_notice_days`, swept daily by `src/revenue/flows/contract-renewal.flow.ts`,\n    // which books the task and notifies the CONTRACT owner; the user-facing\n    // queue is that object's `renewal_calendar` view. A `renewal_owner` /\n    // `next_renewal_date` pair here would be declared and inert, telling an\n    // admin a renewal reaches the CSM they named when nothing would. If an\n    // account-level renewal owner is ever wanted, it is a change to that flow\n    // plus a real writer for the date \u2014 not a second pair of fields.\n  },\n  \n  // Database indexes for performance\n  //\n  // \u26A0\uFE0F No `{ fields: ['name'], unique: true }` here. Account-name uniqueness is\n  // declared on the `name` field itself, which the framework builds as the\n  // tenant composite `(organization_id, name)`. Declaring the single-column\n  // index too makes the platform-wide constraint win and leaves the per-tenant\n  // one unreachable (framework#3991 `unique/double-declaration`) \u2014 the same\n  // trap `crm_contact`, `crm_lead` and `crm_product` document. Two\n  // organizations must be able to each have their own \"Acme Corp\".\n  indexes: [\n    { fields: ['owner_id'] },\n    { fields: ['type', 'is_active'] },\n    // The territory sharing rules filter on this column, so it is read on every\n    // account query a territory recipient makes. `billing_country` carries no\n    // index of its own: nothing filters on it \u2014 it is displayed, and classified\n    // into this column by the hook.\n    { fields: ['territory'] },\n    // Lead conversion filters on this column on every conversion \u2014 the column\n    // exists to replace an unindexed `$regex` scan. Plain index, NOT\n    // `unique: true`, deliberately:\n    //\n    // 1. Per-tenant uniqueness of account names is already declared on the\n    //    `name` field. A unique `name_normalized` would SUBSUME it (equal names\n    //    normalize equally) and force that constraint to be re-decided.\n    // 2. This column is a MATCH key, not a policy. Rejecting a near-duplicate\n    //    name outright is a separate data-quality decision, and this repo has\n    //    already chosen the soft shape for that question once (the hard unique\n    //    on `crm_lead.email` was removed because refusing a repeat enquiry is\n    //    worse than recording it).\n    // 3. \u26A0\uFE0F Measured hazard: `create_index` FAILS on any deployment already\n    //    holding `Acme Corp` and `ACME  Corp` separately, so a unique index\n    //    could not be an upgrade step without a merge pass first. That hazard\n    //    is bounded today ONLY because this repo's deployment shape is fresh\n    //    installs \u2014 see docs/MAINTENANCE.md \u00A73.3. The conclusion is conditional\n    //    on that premise, not universal.\n    //\n    // Consequence, recorded rather than hidden: two accounts CAN still hold the\n    // same normalized name if something outside the flow creates them, and\n    // `get_record` has no `sort` option, so the conversion would reuse an\n    // arbitrary one. Reusing one of N is still better than creating the N+1th.\n    { fields: ['name_normalized'] },\n    // `searchableFields` carries `registration_number`, and the note at the top\n    // of this file records why those must be real, indexed columns.\n    { fields: ['registration_number'] },\n  ],\n  \n  // API surface + capabilities. `files` and `feeds` are live and enforced (see\n  // the canonical note in `src/sales/objects/index.ts`). Field history lives on\n  // individual `Field.trackHistory` (ADR-0052); global search uses\n  // `searchableFields` / per-field `searchable`.\n  enable: {\n    apiEnabled: true,       // Expose via REST/GraphQL\n    apiMethods: ['get', 'list', 'create', 'update', 'delete'], // Whitelist allowed API operations\n    // Contracts, org charts and RFPs live on the account record. Opt-in (spec\n    // default false); attach/download/delete authority is the parent record's\n    // own, so this adds a surface, not a grant.\n    files: true,\n  },\n  \n  // \u26A0\uFE0F No `workflows[]` here, and none is possible: object `workflows[]` were\n  // removed from the platform. Field updates live in this object's `*.hook.ts`;\n  // scheduled status flips and notifications live in `src/*/flows/*.flow.ts`.\n});\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/sales/objects/_picklists.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/sales/objects\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/sales/objects/_picklists.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport type { SelectOption } from '@objectstack/spec/data';\n\n/**\n * Canonical picklist value sets shared across objects, flows, and actions.\n *\n * Several fields carry the same business vocabulary on more than one object\n * (`lead_source` on Lead/Contact/Opportunity, `industry` on Lead/Account,\n * `salutation` on Lead/Contact, `payment_terms` on Quote/Contract), and a few\n * flows/actions re-declare an object's own options inline (Task `type` in the\n * schedule_followup screen, Opportunity `stage` in mass_update_stage). Each\n * copy drifted independently (#490): the lead_conversion flow copies\n * `leadRecord.industry` / `leadRecord.lead_source` verbatim onto the created\n * Account/Opportunity, so any Lead-only value (`logistics`, `webinar`, \u2026)\n * became an illegal enum value on the target object.\n *\n * Declaring the set ONCE here and spreading it into every declaration keeps\n * the vocabularies identical by construction. Cross-object copies (flows,\n * conversion mappings) are then always legal.\n *\n * NOTE: spread (`[...X]`) at every use site so each ObjectSchema gets its own\n * array instance \u2014 schemas must not alias one another's metadata.\n */\n\n/** Salutation \u2014 Lead + Contact. Superset (incl. `prof`, formerly Contact-only). */\nexport const SALUTATION_OPTIONS: SelectOption[] = [\n  { label: 'Mr.', value: 'mr' },\n  { label: 'Ms.', value: 'ms' },\n  { label: 'Mrs.', value: 'mrs' },\n  { label: 'Dr.', value: 'dr' },\n  { label: 'Prof.', value: 'prof' },\n];\n\n/**\n * Industry \u2014 Lead + Account. Superset (formerly 15 on Lead, 6 on Account);\n * lead_conversion copies `leadRecord.industry` onto the created Account, so\n * Account MUST accept every Lead value.\n */\nexport const INDUSTRY_OPTIONS: SelectOption[] = [\n  { label: 'Technology',          value: 'technology' },\n  { label: 'Software / SaaS',     value: 'software' },\n  { label: 'Finance',             value: 'finance' },\n  { label: 'Healthcare',          value: 'healthcare' },\n  { label: 'Retail',              value: 'retail' },\n  { label: 'Manufacturing',       value: 'manufacturing' },\n  { label: 'Education',           value: 'education' },\n  { label: 'Real Estate',         value: 'real_estate' },\n  { label: 'Media & Entertainment', value: 'media' },\n  { label: 'Logistics',           value: 'logistics' },\n  { label: 'Hospitality',         value: 'hospitality' },\n  { label: 'Energy & Utilities',  value: 'energy' },\n  { label: 'Government',          value: 'government' },\n  { label: 'Non-profit',          value: 'nonprofit' },\n  { label: 'Other',               value: 'other' },\n];\n\n/**\n * Lead Source \u2014 Lead + Contact + Opportunity. Superset (formerly 12/5/6);\n * lead_conversion copies `leadRecord.lead_source` onto the created\n * Opportunity, so Opportunity MUST accept every Lead value.\n */\nexport const LEAD_SOURCE_OPTIONS: SelectOption[] = [\n  { label: 'Web',             value: 'web' },\n  { label: 'Referral',        value: 'referral' },\n  { label: 'Event / Trade Show', value: 'event' },\n  { label: 'Webinar',         value: 'webinar' },\n  { label: 'Partner',         value: 'partner' },\n  { label: 'Advertisement',   value: 'advertisement' },\n  { label: 'Paid Search',     value: 'paid_search' },\n  { label: 'Social Media',    value: 'social' },\n  { label: 'Content / Blog',  value: 'content' },\n  { label: 'Cold Call',       value: 'cold_call' },\n  { label: 'Email Campaign',  value: 'email_campaign' },\n  { label: 'Other',           value: 'other' },\n];\n\n/**\n * Payment Terms \u2014 Quote + Contract. Superset (incl. `due_on_receipt`,\n * formerly Quote-only): an accepted quote's terms carry over to the contract,\n * so the contract vocabulary must cover every quote value.\n *\n * The carry-over is `quote_accepted_contract_draft` in `src/revenue/objects/quote.hook.ts`, named\n * here because this rationale spent its first months unenforced (#873): the\n * hook drafted the contract without `payment_terms`, so every accepted quote\n * produced a contract on the `net_30` option default below regardless of what\n * was negotiated \u2014 a shared vocabulary justified by a copy that did not exist.\n * A comment that names its enforcer can be checked; this one could not be.\n */\nexport const PAYMENT_TERMS_OPTIONS: SelectOption[] = [\n  { label: 'Net 15', value: 'net_15' },\n  { label: 'Net 30', value: 'net_30', default: true },\n  { label: 'Net 60', value: 'net_60' },\n  { label: 'Net 90', value: 'net_90' },\n  { label: 'Due on Receipt', value: 'due_on_receipt' },\n];\n\n/**\n * Task Type \u2014 crm_task.type, also re-rendered as the `activityType` select in\n * the schedule_followup screen flow (which had drifted to a 5-value copy\n * missing `other`).\n */\nexport const TASK_TYPE_OPTIONS: SelectOption[] = [\n  { label: 'Call', value: 'call' },\n  { label: 'Email', value: 'email' },\n  { label: 'Meeting', value: 'meeting' },\n  { label: 'Follow-up', value: 'follow_up' },\n  { label: 'Demo', value: 'demo' },\n  { label: 'Other', value: 'other' },\n];\n\n/**\n * Opportunity Stage \u2014 crm_opportunity.stage, also re-rendered as the `stage`\n * param of the mass_update_stage action. Colors/default only matter on the\n * object schema; use {@link plainOptions} where a screen/param select wants\n * bare label/value pairs.\n */\nexport const OPPORTUNITY_STAGE_OPTIONS: SelectOption[] = [\n  { label: 'Prospecting', value: 'prospecting', color: '#808080', default: true },\n  { label: 'Qualification', value: 'qualification', color: '#FFA500' },\n  { label: 'Needs Analysis', value: 'needs_analysis', color: '#FFD700' },\n  { label: 'Proposal', value: 'proposal', color: '#4169E1' },\n  { label: 'Negotiation', value: 'negotiation', color: '#9370DB' },\n  { label: 'Closed Won', value: 'closed_won', color: '#00AA00' },\n  { label: 'Closed Lost', value: 'closed_lost', color: '#FF0000' },\n];\n\n/**\n * Event Type \u2014 crm_event.type, and the `kind` discriminator the per-object\n * activity actions stamp on the `crm_event` row they insert (#592).\n *\n * Distinct from {@link TASK_TYPE_OPTIONS} on purpose: a Task is something a rep\n * still owes someone, an Event is an interaction that occupies a slot on the\n * calendar. `email` is therefore absent here (an email is not a meeting slot;\n * it stays a `sys_email` + `sys_activity` pair) and `webinar` / `onsite_visit`\n * are present, because those are the meeting shapes a rep books.\n */\nexport const EVENT_TYPE_OPTIONS: SelectOption[] = [\n  { label: 'Meeting',      value: 'meeting',       color: '#4169E1', default: true },\n  { label: 'Call',         value: 'call',          color: '#00AA00' },\n  { label: 'Demo',         value: 'demo',          color: '#9370DB' },\n  { label: 'Webinar',      value: 'webinar',       color: '#FFA500' },\n  { label: 'Onsite Visit', value: 'onsite_visit',  color: '#0EA5E9' },\n  { label: 'Other',        value: 'other',         color: '#808080' },\n];\n\n/**\n * Event Status \u2014 crm_event.status.\n *\n * The `planned` \u2192 `held` transition is what separates \"a meeting is booked\"\n * from \"an interaction happened\", and only the second one bumps\n * `crm_account.last_activity_date` (see `event.hook.ts`). Without that split a\n * meeting booked for next quarter would reset the churn clock today.\n */\nexport const EVENT_STATUS_OPTIONS: SelectOption[] = [\n  { label: 'Planned',   value: 'planned',   color: '#4169E1', default: true },\n  { label: 'Held',      value: 'held',      color: '#00AA00' },\n  { label: 'Cancelled', value: 'cancelled', color: '#999999' },\n  { label: 'No Show',   value: 'no_show',   color: '#FF4500' },\n];\n\n/**\n * Attendee Response \u2014 crm_event_attendee.response.\n *\n * The reason attendees are RECORDS rather than a JSON string on the activity\n * (#592 acceptance): a per-attendee response only exists if the attendee does.\n */\nexport const ATTENDEE_RESPONSE_OPTIONS: SelectOption[] = [\n  { label: 'No Response', value: 'no_response', color: '#808080', default: true },\n  { label: 'Accepted',    value: 'accepted',    color: '#00AA00' },\n  { label: 'Declined',    value: 'declined',    color: '#FF0000' },\n  { label: 'Tentative',   value: 'tentative',   color: '#FFA500' },\n];\n\n/**\n * Polymorphic \"Related To\" type \u2014 crm_task.related_to_type and\n * crm_event.related_to_type.\n *\n * Both activity objects carry the same five `related_to_*` lookups, and both\n * hooks bubble recency through the same `related_to_type \u2192 lookup field` map.\n * Declared once so the vocabulary of the discriminator cannot drift from the\n * set of lookups that back it \u2014 a drift that reads as \"the bubble silently\n * stopped firing for one object type\".\n */\nexport const RELATED_TO_TYPE_OPTIONS: SelectOption[] = [\n  { label: 'Account',     value: 'crm_account' },\n  { label: 'Contact',     value: 'crm_contact' },\n  { label: 'Opportunity', value: 'crm_opportunity' },\n  { label: 'Lead',        value: 'crm_lead' },\n  { label: 'Case',        value: 'crm_case' },\n];\n\n/**\n * Duplicate Of \u2014 crm_lead.duplicate_of_type, the discriminator half of the\n * `duplicate_of_lead` / `duplicate_of_contact` pair (#598).\n *\n * Two vocabularies, deliberately, and the split is the enforcement:\n *\n *   - {@link DUPLICATE_OF_TYPE_AUTHORABLE_OPTIONS} is what a human may pick. Each\n *     value names an object, and `lead.object.ts` pairs it with that object's\n *     lookup through `requiredWhen`, so choosing one demands a record.\n *   - {@link DUPLICATE_OF_TYPE_OPTIONS} is what the COLUMN may hold. It is the\n *     authorable set plus {@link DUPLICATE_OF_TYPE_ERASED}, a tombstone no\n *     author writes.\n *\n * The form spreads the authorable set (`src/sales/views/lead.view.ts`) and the object\n * spreads the full one, so the tombstone is unpickable BY CONSTRUCTION rather\n * than by a hand-maintained exclusion list: a fourth authorable object type\n * added below reaches the form automatically, and the tombstone never does.\n */\nexport const DUPLICATE_OF_TYPE_AUTHORABLE_OPTIONS: SelectOption[] = [\n  { label: 'Lead',    value: 'crm_lead' },\n  { label: 'Contact', value: 'crm_contact' },\n];\n\n/**\n * The tombstone (#1164): \"this lead was confirmed a duplicate of a record that\n * has since been erased.\"\n *\n * It exists because on the record \u2014 which is all a validation can see, being\n * evaluated against `{...previous, ...data}` \u2014 \"the pointer was erased\" and\n * \"this claim never named anyone\" were the SAME state. Every way of teaching a\n * rule to tolerate the first also admitted the second, which is why the erasure\n * path could not be cleared by relaxing anything (measured in full on #1164).\n * Giving the two states different values makes them different facts, and then\n * no rule has to be loosened at all: the `requiredWhen` pairing fires only on\n * `crm_lead` / `crm_contact` so it never sees this value, and\n * `duplicate_disqualification_requires_survivor` asks for a NON-BLANK type,\n * which this is.\n *\n * Deliberately not an object name: it is the answer to \"which object holds the\n * survivor\" when the answer is \"none, any more\".\n *\n * \u26A0\uFE0F `lead_duplicate_check` (`lead.hook.ts`, job 1c) is the ONLY writer, and it\n * spells the value as an inline literal \u2014 L2 hook bodies run body-only in the\n * QuickJS sandbox, so a module constant resolves at authoring time and arrives\n * as `undefined` (same constraint as the SLA matrix in `case.hook.ts`). The two\n * spellings are pinned together, and the writer pinned to that one site, by\n * `test/lead-duplicate-management.test.ts`.\n */\nexport const DUPLICATE_OF_TYPE_ERASED = 'erased';\n\n/** The full column vocabulary: what an author may pick, plus the tombstone. */\nexport const DUPLICATE_OF_TYPE_OPTIONS: SelectOption[] = [\n  ...DUPLICATE_OF_TYPE_AUTHORABLE_OPTIONS,\n  { label: 'Erased Record', value: DUPLICATE_OF_TYPE_ERASED },\n];\n\n/** Project a canonical set down to bare `{ label, value }` pairs for flow\n * screens and action params, which don't understand color/default keys. */\nexport const plainOptions = (options: SelectOption[]): { label: string; value: string }[] =>\n  options.map(({ label, value }) => ({ label, value }));\n\n/**\n * Need Type \u2014 `crm_lead.need_type`, the answer to \"what is this prospect\n * asking for\" (REQ-0005 step 6, \u9700\u6C42\u7C7B\u578B).\n *\n * A GENERIC STARTER SET, and that is the disposition rather than an apology\n * for a short list: REQ-0005 rules the *slot* standard and the *values*\n * configuration \u2014 \"a customer's own demand taxonomy is overlay configuration\n * the same way `industry` values are\". So these seven are the vocabulary a\n * fresh install routes and reports on until an overlay replaces them, and\n * replacing them is a one-site edit because the set is declared here.\n *\n * \u26A0\uFE0F NOT the same axis as `crm_opportunity.type`, and \u26D4 never folded into it.\n * That field answers \"is this new business, an upgrade, a renewal or an\n * expansion\" \u2014 the customer RELATIONSHIP the deal changes. This one answers\n * what the buyer wants delivered, which is orthogonal: a renewal of a support\n * contract and a renewal of a consulting engagement differ here and not there.\n * They are deliberately not shared, so \u26D4 do not spread this set onto\n * `crm_opportunity` to make a conversion mapping possible.\n *\n * SINGLE-valued, for the reason `crm_contact.buying_function` records: a\n * grouped list view answers with one server-side aggregate per raw stored\n * value, so a `multiple: true` column groups by the COMBINATION and loses the\n * groupability REQ-0005 acceptance 1 asks for.\n */\nexport const LEAD_NEED_TYPE_OPTIONS: SelectOption[] = [\n  { label: 'New Implementation',   value: 'new_implementation' },\n  { label: 'Expansion',            value: 'expansion' },\n  { label: 'Replacement',          value: 'replacement' },\n  { label: 'Renewal',              value: 'renewal' },\n  { label: 'Consulting',           value: 'consulting' },\n  { label: 'Support & Maintenance', value: 'support' },\n  { label: 'Other',                value: 'other' },\n];\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/sales/objects/_territory.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/sales/objects\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/sales/objects/_territory.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport type { SelectOption } from '@objectstack/spec/data';\n\n/**\n * Territory \u2014 the ONE place the country-to-territory mapping is authored.\n *\n * \u26D4 Territory is a declared `select` on `crm_account`, derived from the billing\n * country by `account_protection`, and the sharing rules compare\n * `record.territory` against a declared value. A country string is never\n * compared again. Matching free text inside a CEL condition fails four ways,\n * all of them silent: an account whose country reads `United States` rather\n * than `US` lands in NO territory with nothing errored; adding a country means\n * editing a CEL string AND three localised tables with nothing to fail if you\n * edit fewer than all four; a wrong code (`UK` for `GB`) cannot be corrected\n * without evicting every account already typed that way; and free text has no\n * enumerable DOMAIN, so no authoring surface, import mapping or generated seed\n * can be checked against it.\n *\n * ### The three authored tables, and everything derived from them\n *\n * {@link TERRITORY_OPTIONS} (the picklist), {@link TERRITORY_COUNTRIES} (which\n * countries a territory covers) and {@link COUNTRY_ALIASES} (how else a country\n * may be spelled) are AUTHORED. {@link COUNTRY_TERRITORY} and\n * {@link territoryFor} are DERIVED from them, and so are the sharing rule\n * conditions, the account form's picklist and the documentation tables \u2014 see\n * `test/territory-single-source.test.ts`, which pins every derivation.\n *\n * ### \u26A0\uFE0F Why `account.hook.ts` still carries a copy of this map\n *\n * It has to. A hook handler is lowered to a metadata-only `body.source` and\n * evaluated inside QuickJS with NO module scope: a reference to anything\n * exported here is not a closure at runtime, it is a `ReferenceError`.\n * `extractHookBody` rejects such a handler outright\n * (`detectFreeIdentifiers`), and `test/action-sandbox.test.ts` fails the\n * build's own lowering pass for every registered hook. So the derivation cannot\n * import this module \u2014 the table has to be inline in the handler.\n *\n * `test/territory-single-source.test.ts` closes that gap from both directions:\n * it parses the inline table out of the LOWERED body source and asserts deep\n * equality with {@link COUNTRY_TERRITORY} (so a country added to either side\n * alone is red), and it runs the real body in the real sandbox over every\n * declared spelling and asserts the territory it produces. The map is therefore\n * authored once even though it is stored twice.\n *\n * ### Scope of the country list\n *\n * This is a SPELLING table for the countries the two staffed territories cover,\n * not a world country list. The value domain is `na` / `emea` / `other`;\n * everything else \u2014 `SG`, `JP`, an empty address \u2014 is `other`, explicitly.\n */\n\n/** The declared territory domain. `other` is a stated fact, never a blank. */\nexport type Territory = 'na' | 'emea' | 'other';\n\n/**\n * The stored values, named. Every other declaration in the repo that needs one\n * spells it through here \u2014 including the sharing rule conditions, where `P`\n * quotes the interpolated value (`record.territory == \"na\"`), so a rename of a\n * territory value cannot be applied to the picklist and missed in the rules.\n */\nexport const TERRITORY: Record<'NA' | 'EMEA' | 'OTHER', Territory> = {\n  NA: 'na',\n  EMEA: 'emea',\n  OTHER: 'other',\n};\n\n/**\n * The account picklist. `other` is deliberately a VALUE and not an empty\n * string: \"this account belongs to no territory\" and \"nobody filled this in\"\n * are different facts, and free text could not tell them apart (#639).\n */\nexport const TERRITORY_OPTIONS: SelectOption[] = [\n  { label: 'North America', value: TERRITORY.NA, color: '#0070D2' },\n  { label: 'EMEA', value: TERRITORY.EMEA, color: '#7C3AED' },\n  { label: 'Other', value: TERRITORY.OTHER, color: '#999999' },\n];\n\n/** The territory every unmapped country falls into. */\nexport const TERRITORY_FALLBACK: Territory = TERRITORY.OTHER;\n\n/**\n * Which countries each staffed territory covers, by ISO 3166-1 alpha-2 code.\n *\n * `other` is absent on purpose \u2014 it is the FALLBACK, reached by every country\n * not named here, so listing countries under it would be a second way to say\n * the same thing. The documentation tables render this record plus one row\n * stating the fallback.\n */\nexport const TERRITORY_COUNTRIES: Record<Exclude<Territory, 'other'>, readonly string[]> = {\n  na: ['US', 'CA', 'MX'],\n  emea: ['GB', 'DE', 'FR', 'IT', 'ES'],\n};\n\n/**\n * Accepted alternative spellings, mapped to the canonical code.\n *\n * Authored in DISPLAY form (`United States`, not `UNITED STATES`) because this\n * is what the documentation tables render \u2014 {@link COUNTRY_TERRITORY} applies\n * {@link normalizeCountry} when it flattens them, so the lookup is\n * case-insensitive without the authored table having to be shouted.\n *\n * `UK -> GB` is deliberate: `UK` is not the ISO 3166-1 alpha-2 code for the\n * United Kingdom, but the stock London account and every customer record typed\n * the same way must keep landing in `emea`. Because the rules no longer compare\n * a country at all, `GB` can be canonical AND `UK` can keep working.\n *\n * English names are here because they are what a CSV import, a generated seed\n * or a person typing into the address form actually produces. Native-language\n * spellings are NOT: they are unbounded, and the failure they would prevent is\n * now visible (`other`) rather than silent.\n */\nexport const COUNTRY_ALIASES: Record<string, string> = {\n  'United States': 'US',\n  'United States of America': 'US',\n  USA: 'US',\n  Canada: 'CA',\n  Mexico: 'MX',\n  UK: 'GB',\n  'United Kingdom': 'GB',\n  'Great Britain': 'GB',\n  Germany: 'DE',\n  France: 'FR',\n  Italy: 'IT',\n  Spain: 'ES',\n};\n\n/**\n * Every accepted spelling to its territory \u2014 the flattened form the hook body\n * carries inline and `test/territory-single-source.test.ts` pins it against.\n *\n * Derived, never authored: add a country to {@link TERRITORY_COUNTRIES} or a\n * spelling to {@link COUNTRY_ALIASES} and it appears here, in the docs tables\n * and (once the hook's inline copy is updated, which the pin test forces) in\n * the derivation.\n */\nexport const COUNTRY_TERRITORY: Record<string, Territory> = (() => {\n  const map: Record<string, Territory> = {};\n  for (const [territory, countries] of Object.entries(TERRITORY_COUNTRIES)) {\n    for (const code of countries) map[code] = territory as Territory;\n  }\n  for (const [alias, code] of Object.entries(COUNTRY_ALIASES)) {\n    const territory = map[code];\n    if (!territory) {\n      // A spelling pointing at a country no territory covers would resolve to\n      // `other` and read as deliberate. Failing at module load makes it a\n      // build-time error instead of a wrong answer at runtime.\n      throw new Error(`COUNTRY_ALIASES: \"${alias}\" points at \"${code}\", which no territory covers`);\n    }\n    const key = normalizeCountry(alias);\n    if (map[key] && map[key] !== territory) {\n      // Two spellings that normalise to the same key and disagree: last write\n      // would win, silently, and the loser's territory would just be wrong.\n      throw new Error(`COUNTRY_ALIASES: \"${alias}\" collides with an entry mapped to \"${map[key]}\"`);\n    }\n    map[key] = territory;\n  }\n  return map;\n})();\n\n/**\n * The one normalisation rule: trim, collapse internal whitespace, upper-case.\n *\n * `crm_account.billing_country` stores exactly this form, and every key above\n * is written in it, so the lookup is a plain property read. `de `, ` DE` and\n * `United  States` are all handled here rather than by a tolerant lookup \u2014\n * one rule, applied once, instead of a set of fallbacks at each reader.\n */\nexport function normalizeCountry(value: unknown): string {\n  return typeof value === 'string' ? value.trim().replace(/\\s+/g, ' ').toUpperCase() : '';\n}\n\n/**\n * The territory a country string belongs to. Total: every input has an answer,\n * and an unrecognised one is `other` rather than blank.\n */\nexport function territoryFor(value: unknown): Territory {\n  return COUNTRY_TERRITORY[normalizeCountry(value)] ?? TERRITORY_FALLBACK;\n}\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/sales/objects/contact.object.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/sales/objects\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/sales/objects/contact.object.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport { ObjectSchema, Field } from '@objectstack/spec/data';\nimport { F } from '@objectstack/spec';\nimport { SALUTATION_OPTIONS, LEAD_SOURCE_OPTIONS } from './_picklists';\n\nexport const Contact = ObjectSchema.create({\n  name: 'crm_contact',\n  label: 'Contact',\n  pluralLabel: 'Contacts',\n  icon: 'user',\n  description: 'People associated with accounts',\n\n  // ADR-0090 D1/D7: OWD is an authored decision. Master-detail child of crm_account \u2014 inherits the account's sharing.\n  sharingModel: 'controlled_by_parent',\n  \n  fieldGroups: [\n    { key: 'identity',        label: 'Identity',             icon: 'user' },\n    { key: 'account_info',    label: 'Account & Title',      icon: 'briefcase' },\n    { key: 'buying_centre',   label: 'Buying Centre',        icon: 'users' },\n    { key: 'contact_info',    label: 'Contact Information',  icon: 'phone' },\n    { key: 'mailing_address', label: 'Mailing Address',      icon: 'map-pin', collapse: 'collapsed' },\n    { key: 'additional',      label: 'Additional Info',      icon: 'info', collapse: 'collapsed' },\n    { key: 'preferences',     label: 'Communication Preferences', icon: 'bell-off', collapse: 'collapsed' },\n  ],\n\n  fields: {\n    // Platform ownership anchor \u2014 canonical note in `account.object.ts` (#548).\n    owner_id: Field.lookup('sys_user', {\n      label: 'Contact Owner',\n      group: 'account_info',\n      system: true,\n      readonly: false,\n      trackHistory: true,\n    }),\n\n    // Name fields\n    salutation: Field.select({\n      label: 'Salutation',\n      group: 'identity',\n      // Canonical set shared with Lead (#490) \u2014 see _picklists.ts.\n      options: [...SALUTATION_OPTIONS],\n    }),\n    first_name: Field.text({\n      label: 'First Name',\n      required: true,\n      storage: { notNull: true },\n      searchable: true,\n      group: 'identity',\n    }),\n    last_name: Field.text({\n      label: 'Last Name',\n      required: true,\n      storage: { notNull: true },\n      searchable: true,\n      group: 'identity',\n    }),\n\n    // Formula field - Full name\n    // `salutation` is a picklist, so the formula sees the raw VALUE (`ms`, `dr`),\n    // not the label \u2014 names rendered as \"ms Emily Davis\" in lists and details\n    // (#461). The formula language has no proper-case or option-label lookup, and\n    // hardcoding \"Ms.\" would defeat translation, so the name is built from the\n    // name fields alone; salutation stays its own (translated) field.\n    full_name: Field.formula({\n      label: 'Full Name',\n      expression: F`joinNonEmpty([record.first_name, record.last_name], ' ')`,\n      group: 'identity',\n    }),\n\n    // Avatar field. `accept` / `maxSize` are server-enforced from\n    // @objectstack 17 \u2014 see the note on `crm_product.image`.\n    avatar: Field.avatar({\n      label: 'Profile Picture',\n      group: 'identity',\n      accept: ['image/png', 'image/jpeg', 'image/webp'],\n      maxSize: 2 * 1024 * 1024,\n    }),\n\n    // Relationship: Link to Account (Master-Detail)\n    crm_account: Field.masterDetail('crm_account', {\n      label: 'Account',\n      required: true,\n      storage: { notNull: true },\n      deleteBehavior: 'cascade',  // Delete contacts when account is deleted\n      group: 'account_info',\n    }),\n\n    // Professional Information\n    title: Field.text({\n      label: 'Job Title',\n      group: 'account_info',\n    }),\n\n    department: Field.select({\n      label: 'Department',\n      group: 'account_info',\n      options: [\n        { label: 'Executive', value: 'executive' },\n        { label: 'Sales', value: 'sales' },\n        { label: 'Marketing', value: 'marketing' },\n        { label: 'Engineering', value: 'engineering' },\n        { label: 'Support', value: 'support' },\n        { label: 'Finance', value: 'finance' },\n        { label: 'Human Resources', value: 'hr' },\n        { label: 'Operations', value: 'operations' },\n      ]\n    }),\n\n    // \u2500\u2500 Buying centre (REQ-0004) \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n    //\n    // The three attributes that turn an account's contact list from a\n    // DIRECTORY into a MAP: what this person does in the purchase decision,\n    // where they stand on us, and how strong our relationship with them is.\n    // `title` above is the employer's job title and `is_primary` below is a\n    // one-bit answer to \"who do we call\" \u2014 neither of them is this fact.\n    //\n    // \u26D4 Read by people and by reporting, never by a gate. No hook, no flow\n    // and no validation is authored against any of the three, none is\n    // `required`, and none carries an option `default`: a contact with all\n    // three blank saves exactly as it did before this group existed\n    // (REQ-0004 acceptance 4). They are sales intelligence, and AGENTS.md\n    // metadata semantics rule 8 is what keeps a machine signal from refusing\n    // a write.\n    // \u26A0\uFE0F `buying_function`, not `buying_role` \u2014 and 'Buying Function', not\n    // 'Buying Role'. `security-role-word` (an author-time rule, ADR-0090 D3)\n    // refuses the word `role` on BOTH, measured on this branch as two\n    // successive `pnpm validate` exit-1 runs: first the field name, then the\n    // label, because \"admins must meet ONE vocabulary\" and `role` is the\n    // platform's security vocabulary (permission_set / position /\n    // business_unit). Its own remedy prescribes the replacement used here \u2014\n    // \"a domain word (e.g. 'function', 'duty')\".\n    //\n    // The rule's surface is the ENGLISH one it can read: it matches\n    // `/\\brole(s)?\\b/i` over object/field/action/permission-set/position/app\n    // declarations and does not reach the locale packs. So the three\n    // non-English packs keep the natural business term for this concept in\n    // their own language (zh-CN \u91C7\u8D2D\u89D2\u8272, es-ES Rol de Compra, ja-JP \u8CFC\u8CB7\u5F79\u5272)\n    // \u2014 same fact, each written the way its reader says it.\n    buying_function: Field.select({\n      label: 'Buying Function',\n      group: 'buying_centre',\n      // SINGLE-valued, and REQ-0004 left that call to the implementing PR.\n      // `multiple: true` would cost the field the property acceptance 2 asks\n      // for: `GroupingConfigSchema` (`@objectstack/spec/ui`, the installed\n      // pin) answers a grouped list with ONE server-side aggregate query, and\n      // its `GroupingFieldSchema.field` says the group header \"carries its\n      // raw stored value\" \u2014 so a multi-valued column groups by the\n      // COMBINATION. `decision_maker` + `user` would become a group of its\n      // own instead of feeding both, which is the opposite of reading an\n      // account as a map. A person who is genuinely two things is recorded as\n      // the role that governs THIS decision; the second one is already\n      // legible from `title` / `department`.\n      //\n      // The six are the generic buying-centre slots every industry reads the\n      // same way \u2014 \u26D4 deliberately not one company's role model.\n      options: [\n        { label: 'Decision Maker',      value: 'decision_maker' },\n        { label: 'Economic Buyer',      value: 'economic_buyer' },\n        { label: 'Technical Evaluator', value: 'technical_evaluator' },\n        { label: 'User',                value: 'user' },\n        { label: 'Influencer',          value: 'influencer' },\n        { label: 'Gatekeeper',          value: 'gatekeeper' },\n      ]\n    }),\n\n    attitude: Field.select({\n      label: 'Attitude to Us',\n      group: 'buying_centre',\n      // ORDERED, most to least favourable \u2014 declaration order IS the order a\n      // picklist and a grouped list present, so the ladder is authored rather\n      // than described. A blank means nobody has formed a view yet, which is\n      // a different fact from `neutral`.\n      options: [\n        { label: 'Champion',   value: 'champion' },\n        { label: 'Supportive', value: 'supportive' },\n        { label: 'Neutral',    value: 'neutral' },\n        { label: 'Skeptical',  value: 'skeptical' },\n        { label: 'Blocker',    value: 'blocker' },\n      ]\n    }),\n\n    relationship_strength: Field.select({\n      label: 'Relationship Strength',\n      group: 'buying_centre',\n      // ORDERED, weakest to strongest. \u26D4 Not a free-text score, and \u26D4 not\n      // derived from `last_contacted_date` below: recency is machine-written\n      // and measures something else \u2014 a weekly call with someone who will not\n      // take our side is not a strong relationship. A blank means unassessed;\n      // `distant` is an assessment that came back weak.\n      options: [\n        { label: 'Distant',              value: 'distant' },\n        { label: 'Acquaintance',         value: 'acquaintance' },\n        { label: 'Working Relationship', value: 'working' },\n        { label: 'Strong',               value: 'strong' },\n        { label: 'Trusted Advisor',      value: 'trusted_advisor' },\n      ]\n    }),\n\n    // No `reports_to`. The org chart was declared and never built: no page\n    // rendered the tree the contact docs promised, no skill read the chain when\n    // summarising an account, and no flow escalated along it. Sharing derives\n    // from the master `crm_account`, never from this lookup.\n\n    // Contact Information\n    email: Field.email({\n      label: 'Email',\n      required: true,\n      storage: { notNull: true },\n      unique: true,\n      group: 'contact_info',\n    }),\n\n    phone: Field.text({\n      label: 'Phone',\n      format: 'phone',\n      group: 'contact_info',\n    }),\n\n    mobile: Field.text({\n      label: 'Mobile',\n      format: 'phone',\n      group: 'contact_info',\n    }),\n\n    // Mailing Address \u2014 one structured `address` value, the same shape as\n    // `crm_account.billing_address` and `crm_lead.address`, because a postal\n    // address is one fact and AGENTS.md's field-type guidance names\n    // `Field.address()` for it (ruling on #1836; it replaced five flat\n    // `mailing_*` text fields, converted by `scripts/backfill-contact-mailing-address.ts`).\n    mailing_address: Field.address({\n      label: 'Mailing Address',\n      group: 'mailing_address',\n    }),\n\n    // Additional Information\n    //\n    // No `birthdate`. Nothing greeted, segmented or reported on it, and an\n    // importable date of birth with no consumer is personal data held for no\n    // stated purpose \u2014 the one field on this object where \"declared but inert\"\n    // also carries a data-protection cost.\n\n    lead_source: Field.select({\n      label: 'Lead Source',\n      group: 'additional',\n      // Canonical set shared with Lead + Opportunity (#490) \u2014 a converted\n      // lead's source must remain representable on the contact.\n      options: [...LEAD_SOURCE_OPTIONS],\n    }),\n\n    description: Field.markdown({\n      label: 'Description',\n      group: 'additional',\n    }),\n\n    // Flags\n    is_primary: Field.boolean({\n      label: 'Primary Contact',\n      defaultValue: false,\n      description: 'Is this the main contact for the account?',\n      group: 'preferences',\n    }),\n\n    do_not_call: Field.boolean({\n      label: 'Do Not Call',\n      defaultValue: false,\n      group: 'preferences',\n    }),\n\n    email_opt_out: Field.boolean({\n      label: 'Email Opt Out',\n      defaultValue: false,\n      group: 'preferences',\n    }),\n\n    // Interaction recency for the PERSON (#592). `crm_account` carries\n    // `last_activity_date` for the company and `crm_lead` carries\n    // `last_contacted_date` for a prospect; the contact \u2014 the record a rep\n    // actually calls and emails \u2014 had neither, so \"when did anyone last speak\n    // to our champion?\" was unanswerable.\n    //\n    // Written by the activity bubble in `event.hook.ts` / `task.hook.ts` and by\n    // `send_email`. Deliberately NOT `readonly`: a readonly field is stripped\n    // from every non-system write whose caller supplied the key (#2948), which\n    // is exactly how the account and lead columns above ended up permanently\n    // null. It is kept off the form sections instead.\n    last_contacted_date: Field.datetime({\n      label: 'Last Contacted',\n      group: 'additional',\n    }),\n  },\n  \n  // Enable features\n  // API surface. History \u2192 Field.trackHistory (ADR-0052).\n  enable: {\n    apiEnabled: true,\n    // #602 \u2014 signed NDAs, business cards, meeting notes attach to the person.\n    // See the canonical capability note in `src/sales/objects/index.ts`.\n    files: true,\n  },\n  \n  // Database indexes for performance\n  //\n  // NOTE: no `{ fields: ['email'], unique: true }` here. Email uniqueness is\n  // declared on the field itself (`unique: true`), which since framework #3696\n  // materializes as the tenant composite `(organization_id, email)` \u2014 unique\n  // WITHIN an organization, which is what a multi-tenant CRM wants (two orgs\n  // may each know john@acme.com). A declared single-column index is taken\n  // verbatim, i.e. platform-wide, so declaring both left the global index\n  // enforcing the old behaviour and the per-tenant constraint unreachable\n  // (framework#3991 `unique/double-declaration`).\n  indexes: [\n    { fields: ['crm_account'] },\n    { fields: ['owner_id'] },\n    { fields: ['last_name', 'first_name'] },\n  ],\n  \n  // Display configuration. ADR-0079 `nameField` names the real field holding\n  // the record title \u2014 here the `full_name` formula field defined above.\n  nameField: 'full_name',\n  // Explicit search targets (ADR-0061). REQUIRED because nameField is a\n  // FORMULA (display_title/full_name): without this, $search auto-defaults to\n  // the formula field, which isn't a real column, so the lookup picker + global\n  // search silently return zero. These are real, indexed columns.\n  searchableFields: ['first_name', 'last_name', 'email'],\n  highlightFields: ['full_name', 'email', 'crm_account', 'phone'],\n  \n  // \u26A0\uFE0F No standalone `type: 'unique'` validation exists on this platform\n  // (ADR-0032 validation union). Email uniqueness is enforced by the\n  // field-level `unique: true` above, scoped per organization.\n\n  // \u26A0\uFE0F No `workflows[]` here, and none is possible: object `workflows[]` were\n  // removed from the platform. Field updates live in this object's `*.hook.ts`;\n  // scheduled status flips and notifications live in `src/*/flows/*.flow.ts`.\n});", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/sales/objects/event.object.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/sales/objects\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/sales/objects/event.object.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport { P } from '@objectstack/spec';\nimport { ObjectSchema, Field } from '@objectstack/spec/data';\nimport {\n  EVENT_STATUS_OPTIONS,\n  EVENT_TYPE_OPTIONS,\n  RELATED_TO_TYPE_OPTIONS,\n} from './_picklists';\n\n/**\n * Event \u2014 a first-class interaction record (#592).\n *\n * # Why this object exists\n *\n * The CRM could not answer *\"what happened with this customer, and when?\"*.\n * `crm_task.type` offered a `meeting` value with no start time, no end time,\n * no location and no attendees, and `log_meeting` stuffed the attendee list\n * into a JSON string inside `sys_activity.metadata` \u2014 a payload no list view\n * can filter, no dataset can group by, and no report can count.\n *\n * `crm_event` is the queryable half of that story: one row per interaction\n * that occupies a slot on someone's calendar, whether it already happened (a\n * logged call) or is booked for next Tuesday (a scheduled meeting).\n *\n * # The Task / Event split\n *\n * `crm_task` stays what it was \u2014 something a rep still *owes* someone, due on\n * a date. `crm_event` is something that *occurs*, between two timestamps, with\n * people in the room. The two objects deliberately do NOT merge: a to-do list\n * sorted by due date and a calendar scaled by duration are different surfaces,\n * and every CRM that collapsed them ended up with a \"duration\" column that is\n * null on 90% of rows.\n *\n * Emails are the third shape and stay out: an email is not a calendar slot, so\n * `send_email` keeps writing `sys_email` + `sys_activity` (it does now also\n * stamp contact recency \u2014 see `contact.actions.ts`).\n *\n * # `status` is what makes the churn signal honest\n *\n * Only a `held` event bumps `crm_account.last_activity_date` /\n * `crm_lead.last_contacted_date` (see `event.hook.ts`). A meeting *booked* for\n * next quarter is not an interaction that happened, and letting it reset the\n * recency clock is precisely how an \"at risk\" report learns to lie.\n */\nexport const Event = ObjectSchema.create({\n  name: 'crm_event',\n  label: 'Event',\n  pluralLabel: 'Events',\n  icon: 'calendar-days',\n  description: 'Meetings, calls and other scheduled interactions with customers',\n\n  // ADR-0090 D1/D7: OWD is an authored decision. Mirrors `crm_task`: an event\n  // is a personal activity record, owned by the rep who ran it.\n  sharingModel: 'private',\n\n  fieldGroups: [\n    { key: 'basic',    label: 'Event Information', icon: 'info' },\n    { key: 'schedule', label: 'Schedule',          icon: 'calendar' },\n    { key: 'related',  label: 'Related Records',   icon: 'link' },\n    { key: 'outcome',  label: 'Outcome',           icon: 'clipboard-check', collapse: 'collapsed' },\n  ],\n\n  fields: {\n    // Platform ownership anchor \u2014 canonical note in `account.object.ts` (#548).\n    owner_id: Field.lookup('sys_user', {\n      label: 'Assigned To',\n      group: 'basic',\n      system: true,\n      readonly: false,\n      trackHistory: true,\n    }),\n\n    // \u2500\u2500\u2500 Event Information \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n    subject: Field.text({\n      group: 'basic',\n      label: 'Subject',\n      required: true,\n      storage: { notNull: true },\n      searchable: true,\n      maxLength: 255,\n    }),\n\n    type: Field.select({\n      group: 'basic',\n      label: 'Event Type',\n      required: true,\n      storage: { notNull: true },\n      // Field-level default, not just the option flag: the option `default`\n      // only preselects in some form surfaces, so a quick-create opened from a\n      // related list left this required field blank (same defect crm_task.status\n      // carries a note about).\n      defaultValue: 'meeting',\n      options: [...EVENT_TYPE_OPTIONS],\n    }),\n\n    status: Field.select({\n      group: 'basic',\n      label: 'Status',\n      required: true,\n      storage: { notNull: true },\n      trackHistory: true,\n      defaultValue: 'planned',\n      options: [...EVENT_STATUS_OPTIONS],\n    }),\n\n    description: Field.markdown({\n      group: 'basic',\n      label: 'Description',\n    }),\n\n    // \u2500\u2500\u2500 Schedule \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n    start_datetime: Field.datetime({\n      group: 'schedule',\n      label: 'Start',\n      required: true,\n      storage: { notNull: true },\n    }),\n\n    end_datetime: Field.datetime({\n      group: 'schedule',\n      label: 'End',\n    }),\n\n    all_day: Field.boolean({\n      group: 'schedule',\n      label: 'All Day Event',\n      defaultValue: false,\n    }),\n\n    // Derived in `event.hook.ts` from start/end. NOT `readonly`: the field is\n    // also what the activity actions supply directly when a rep logs a call\n    // that took 20 minutes, and a readonly field is stripped from any write\n    // whose CALLER supplied the key (#2948) \u2014 including an action body running\n    // under the rep's own context. Derivation inside this object's own\n    // before-hook is unaffected either way (the strip keys off the caller's\n    // payload, not the post-hook document), so leaving it writable costs\n    // nothing and keeps `log_call` honest.\n    duration_minutes: Field.number({\n      group: 'schedule',\n      label: 'Duration (minutes)',\n      min: 0,\n      scale: 0,\n    }),\n\n    location: Field.text({\n      group: 'schedule',\n      label: 'Location',\n      maxLength: 255,\n      description: 'Room, address, or meeting link',\n    }),\n\n    // \u2500\u2500\u2500 Related Records (polymorphic, same shape as crm_task) \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n    related_to_type: Field.select({\n      group: 'related',\n      label: 'Related To Type',\n      options: [...RELATED_TO_TYPE_OPTIONS],\n    }),\n\n    related_to_account: Field.lookup('crm_account', {\n      group: 'related',\n      label: 'Related Account',\n    }),\n\n    related_to_contact: Field.lookup('crm_contact', {\n      group: 'related',\n      label: 'Related Contact',\n    }),\n\n    related_to_opportunity: Field.lookup('crm_opportunity', {\n      group: 'related',\n      label: 'Related Opportunity',\n    }),\n\n    related_to_lead: Field.lookup('crm_lead', {\n      group: 'related',\n      label: 'Related Lead',\n    }),\n\n    related_to_case: Field.lookup('crm_case', {\n      group: 'related',\n      label: 'Related Case',\n    }),\n\n    // \u2500\u2500\u2500 Outcome \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n    outcome_notes: Field.markdown({\n      group: 'outcome',\n      label: 'Outcome Notes',\n      description: 'What was agreed, and what happens next',\n    }),\n\n    // No `is_past` / `is_upcoming` boolean. A write-time snapshot of \"has this\n    // happened yet\" is stale the moment the clock passes it, and the app has\n    // already been burnt by exactly that (`crm_task.is_overdue` \u2014 see the\n    // `overdue_tasks` view's label note). `status` is the authored, non-decaying\n    // signal, and the upcoming/past views filter on it and sort by\n    // `start_datetime` instead.\n  },\n\n  // API surface. History \u2192 Field.trackHistory (ADR-0052).\n  enable: {\n    apiEnabled: true,\n  },\n\n  indexes: [\n    { fields: ['start_datetime'] },\n    { fields: ['owner_id'] },\n    { fields: ['status'] },\n    { fields: ['related_to_account'] },\n    { fields: ['related_to_opportunity'] },\n  ],\n\n  // ADR-0079: `nameField` names the real field holding the record title.\n  nameField: 'subject',\n  highlightFields: ['subject', 'type', 'status', 'start_datetime', 'owner_id'],\n  searchableFields: ['subject', 'location'],\n\n  // Predicates below are TOTAL: every `record.x` read is `has()`-guarded, so the\n  // rule returns a verdict even when the merged record has no such key. See\n  // AGENTS.md \"Validation predicates must be TOTAL\" and\n  // test/object-validation-predicates.test.ts, which fails the build otherwise.\n  validations: [\n    {\n      name: 'end_after_start',\n      type: 'script',\n      severity: 'error',\n      message: 'The end time must be after the start time',\n      // BOTH guards, on both operands, because they answer different hazards\n      // (AGENTS.md \"Validation predicates must be TOTAL\"):\n      //   \u00B7 `has(...)`  \u2014 absent key. On a driver that stores only the columns\n      //     a row was written with, an absent `end_datetime` aborts the whole\n      //     predicate under strict CEL, and from 17.0.0-rc.2 that abort REJECTS\n      //     the save rather than skipping the rule (#4649).\n      //   \u00B7 `!= null`   \u2014 present-but-null. `dyn<null> < dyn` aborts too, and\n      //     `has()` says nothing about it.\n      // An ordering comparison needs both; neither substitutes for the other.\n      condition: P`has(record.start_datetime) && has(record.end_datetime) && record.start_datetime != null && record.end_datetime != null && !isBlank(record.end_datetime) && record.end_datetime < record.start_datetime`,\n    },\n    {\n      name: 'related_to_required',\n      type: 'script',\n      severity: 'warning',\n      message: 'At least one related record should be selected',\n      condition: P`(!has(record.related_to_account) || isBlank(record.related_to_account)) && (!has(record.related_to_contact) || isBlank(record.related_to_contact)) && (!has(record.related_to_opportunity) || isBlank(record.related_to_opportunity)) && (!has(record.related_to_lead) || isBlank(record.related_to_lead)) && (!has(record.related_to_case) || isBlank(record.related_to_case))`,\n    },\n  ],\n});\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/sales/objects/event_attendee.object.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/sales/objects\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/sales/objects/event_attendee.object.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport { expression } from '@objectstack/spec';\nimport { ObjectSchema, Field } from '@objectstack/spec/data';\nimport { ATTENDEE_RESPONSE_OPTIONS } from './_picklists';\n\n/**\n * The ways an attendee row can name a person \u2014 ONE declaration, not two lists\n * that happen to line up.\n *\n * `attendee_type` is the discriminator and each of the four columns below is a\n * resolution. \u26D4 Authoring the two separately lets them drift, and the failure\n * is silent: a type with no matching resolution means an external guest can\n * only be STORED MISLABELLED (a row claiming to be a Contact while pointing at\n * no contact is ACCEPTED, and an omitted type falls to the field default).\n *\n * Deriving BOTH the picklist and the two rules from this table is the point: a\n * fifth resolution cannot be added without its type, and a type cannot be added\n * without saying which column it names \u2014 the failure is not expressible in this\n * shape. Everything downstream (options, `attendee_resolves`,\n * `attendee_type_exclusive`) is generated below; nothing repeats the pairing.\n * `test/attendee-type-resolution.test.ts` pins it.\n *\n * Adding a row here is a user-visible picklist change: it needs a label in all\n * four locale packs (`test/i18n-references.test.ts` fails otherwise) and a\n * changeset.\n */\nexport const ATTENDEE_RESOLUTIONS = [\n  { value: 'contact',  column: 'crm_contact',   label: 'Contact',  color: '#4169E1' },\n  { value: 'lead',     column: 'crm_lead',      label: 'Lead',     color: '#FFA500' },\n  { value: 'user',     column: 'sys_user',      label: 'User',     color: '#00AA00' },\n  { value: 'external', column: 'external_name', label: 'External', color: '#8A8A8A' },\n] as const;\n\n/** A new attendee row is a Contact until the author says otherwise. */\nexport const DEFAULT_ATTENDEE_TYPE = 'contact';\n\n// The predicate fragments below are the TOTAL shapes from the house rule in\n// `test/object-validation-predicates.test.ts`: every `record.x` read carries its\n// own `has(record.x)` in the same expression, so the rule returns a verdict on a\n// merged record with absent keys instead of aborting (and, from 17.0.0-rc.2,\n// rejecting the write it could not judge).\nconst blank = (f: string) => `(!has(record.${f}) || isBlank(record.${f}))`;\nconst filled = (f: string) => `(has(record.${f}) && !isBlank(record.${f}))`;\nconst typeIs = (v: string) => `(has(record.attendee_type) && record.attendee_type == \"${v}\")`;\nconst typeIsNot = (v: string) => `(has(record.attendee_type) && record.attendee_type != \"${v}\")`;\n\n/**\n * Violation predicates \u2014 validations fire when the condition is TRUE.\n *\n * They are the two halves of \"declared = enforced\", split so each condition\n * carries its own wording: a row missing the party its type names is a\n * different mistake from a row naming a party its type does not.\n *\n * A record whose `attendee_type` is absent satisfies neither (every fragment is\n * `has()`-guarded on it), which is deliberate: \"no type at all\" is the REQUIRED\n * field's job \u2014 `Attendee Type is required` names the real obstacle, and a\n * second rule saying so would only shadow it.\n */\nconst RESOLVES_CONDITION = ATTENDEE_RESOLUTIONS\n  .map((r) => `(${typeIs(r.value)} && ${blank(r.column)})`)\n  .join(' || ');\n\nconst EXCLUSIVE_CONDITION = ATTENDEE_RESOLUTIONS\n  .map((r) => `(${filled(r.column)} && ${typeIsNot(r.value)})`)\n  .join(' || ');\n\n/**\n * `requiredWhen` for one party column \u2014 the SAME correspondence the two rules\n * enforce, asked one layer earlier so the form marks the column the chosen type\n * names instead of letting the save discover it is empty. Derived from\n * `ATTENDEE_RESOLUTIONS` like everything else here: a fifth resolution gets its\n * hint for free and cannot get it wrong.\n *\n * This is a HINT, not the contract. `attendee_resolves` and\n * `attendee_type_exclusive` at the bottom of this file are the contract every\n * writer meets \u2014 REST, ObjectQL, seeds, flows \u2014 and nothing here relaxes\n * either. \u26A0\uFE0F `requiredWhen` is a transition gate, not an invariant: it asks the\n * write in front of it for the column, it does not state a property of stored\n * rows. The duplication is deliberate and visible \u2014 a REST insert omitting the\n * named column answers twice, once per layer, and the accepted set is\n * unchanged.\n *\n * \u26A0\uFE0F The predicate is TOTAL (`has()`-guarded via `typeIs`), the same house rule\n * AGENTS.md states for every authored CEL predicate. `requiredWhen` fails\n * CLOSED in the Console \u2014 an unevaluable predicate demands nothing \u2014 so an\n * unguarded one would read as enforced here and require nothing at the form.\n *\n * # \u26D4 Why there is no `visibleWhen` beside it\n *\n * \u26A0\uFE0F Platform constraint, measured in the browser on 17.1.0: the Console hides\n * a populated field WITHOUT clearing it and submits the stale value anyway.\n * Fill Contact, then change the type to Lead \u2014 the Contact column leaves the\n * DOM, its value stays in form state, and the write carries it:\n *\n *     POST  {\"attendee_type\":\"lead\", \u2026, \"crm_contact\":\"AEwPffbkMvx-OlC4\",\n *                                       \"crm_lead\":\"0AM_zbdjuLcXMdnL\"}\n *     400   An attendee names exactly one party \u2014 clear every party column\n *           its Attendee Type does not name\n *\n * \u2014 so the row is refused, correctly, by a message naming a column no longer on\n * screen to clear. On the EDIT path it is a dead end rather than a puzzle:\n * retyping a stored `contact` row to `user` re-sends the stored `crm_contact`\n * on every attempt, and the Console offers no way to empty it. Today's form is\n * worse-looking and strictly more usable: the offending column is visible, so\n * the error can be acted on.\n *\n * Nothing in `@objectstack/spec` 17.1.0 or the shipped Console clears a value\n * when its field goes invisible \u2014 no `clearOnHide`-shaped key exists on either\n * surface \u2014 so `visibleWhen` here cannot be paired into safety from this repo.\n * The half that would need to change is upstream; it is the same\n * fail-open/stale-state family as the note in `src/sales/views/lead.view.ts`. \u26D4 Do\n * not add `visibleWhen` to these four columns until a hidden field stops being\n * submitted; the rules above will keep refusing the row, but the person in\n * front of the form will have no way to fix it.\n */\nconst partyFormHints = (column: string) => {\n  const resolution = ATTENDEE_RESOLUTIONS.find((r) => r.column === column);\n  if (!resolution) {\n    throw new Error(`No attendee resolution declares the column \"${column}\"`);\n  }\n  return {\n    requiredWhen: expression(typeIs(resolution.value), 'cel'),\n  };\n};\n\n/**\n * Event Attendee \u2014 who was in the room.\n *\n * # Why a junction object, and not multi-value lookups\n *\n * \"Attendees are queryable RECORDS, not JSON strings\", and three properties\n * decide the shape:\n *\n *  1. **Attendees are heterogeneous.** A customer meeting has internal people\n *     (`sys_user`), existing customers (`crm_contact`) and prospects\n *     (`crm_lead`) in it. A `Field.lookup(..., { multiple: true })` points at\n *     exactly ONE object, so a multi-lookup design needs three parallel\n *     multi-lookups and no way to order or de-duplicate across them.\n *  2. **An attendee carries its own attributes.** `response` and `is_organizer`\n *     belong to the *pairing* of a person and an event, not to either side. A\n *     multi-value lookup stores a bare id array with nowhere to hang them.\n *  3. **A junction is queryable.** \"Meetings this rep attended\", \"contacts who\n *     declined twice this quarter\" and \"accounts whose champion has not\n *     attended anything in 90 days\" are all `find()` calls on this object.\n *     Against an id array inside a multi-value column they are not expressible\n *     in ObjectQL at all.\n *\n * This mirrors `crm_campaign_member`, the app's existing junction, down to the\n * autonumber `nameField` and the `controlled_by_parent` OWD.\n *\n * # Access derives from the event\n *\n * `sharingModel: 'controlled_by_parent'` (ADR-0055). The relation resolver\n * accepts the REQUIRED `crm_event` lookup as the parent, so no master-detail\n * conversion is needed \u2014 same construction as `crm_campaign_member`.\n *\n * Reads are filtered to attendees whose `crm_event` the caller can read, and\n * adding or updating an attendee requires edit access to that event. \u26A0\uFE0F That\n * derivation resolves through the same paths a direct read of the event takes \u2014\n * ownership scope and `sys_record_share` grants folded in, not the master's\n * row-level security policies alone. The distinction is not academic: an\n * earlier platform version consulted master RLS policies ONLY, under a SYSTEM\n * context, and HotCRM authors none on `crm_event` \u2014 so every attendee row of\n * every meeting reached every holder of object-level read.\n * `test/parent-derived-reach.test.ts` pins the narrow behaviour and was written\n * to go red the day the platform changed it.\n */\nexport const EventAttendee = ObjectSchema.create({\n  name: 'crm_event_attendee',\n  label: 'Event Attendee',\n  pluralLabel: 'Event Attendees',\n  icon: 'users',\n  description: 'A person invited to or present at an event',\n\n  sharingModel: 'controlled_by_parent',\n\n  // ADR-0079: junction rows have no derivable text title; point the canonical\n  // nameField at the stored autonumber explicitly (autonumber is not in the\n  // auto-derivation whitelist).\n  nameField: 'attendee_number',\n\n  highlightFields: ['crm_event', 'attendee_type', 'response', 'is_organizer'],\n\n  fieldGroups: [\n    { key: 'basic',    label: 'Attendee',   icon: 'user' },\n    { key: 'response', label: 'Invitation', icon: 'mail-check' },\n  ],\n\n  fields: {\n    attendee_number: Field.autonumber({\n      group: 'basic',\n      label: 'Attendee Number',\n      format: 'EA-{00000}',\n    }),\n\n    // \u26A0\uFE0F Deliberately left on the spec default, and NOT cascaded with the party\n    // lookups below. Because it is REQUIRED, the engine escalates the stored\n    // `set_null` to a refusal at delete time, with a message naming the real\n    // obstacle instead of an unrelated rule: \"Cannot delete crm_event (...): 3\n    // dependent crm_event_attendee record(s) reference it via crm_event\n    // (crm_event is required, so it cannot be cleared).\" That is the correct\n    // answer on this side, for the same reason `crm_campaign_member.crm_campaign`\n    // keeps it: a meeting's attendee list is the meeting's historical record,\n    // not a per-person artefact. `test/event-attendee-cascade.test.ts` pins the\n    // resolved value so a copy-paste of the three cascades cannot reach here.\n    crm_event: Field.lookup('crm_event', {\n      group: 'basic',\n      label: 'Event',\n      required: true,\n      storage: { notNull: true },\n    }),\n\n    // The discriminator says which of the four columns below is the live one. It\n    // is authored rather than derived so a query can filter \"internal attendees\n    // only\" without four OR'd null checks. The options are GENERATED from the\n    // resolution table rather than retyped \u2014 see the note at the top of this\n    // file for why the pairing is declared once.\n    attendee_type: Field.select({\n      group: 'basic',\n      label: 'Attendee Type',\n      required: true,\n      storage: { notNull: true },\n      defaultValue: DEFAULT_ATTENDEE_TYPE,\n      options: ATTENDEE_RESOLUTIONS.map((r) => ({\n        label: r.label,\n        value: r.value,\n        color: r.color,\n        ...(r.value === DEFAULT_ATTENDEE_TYPE ? { default: true } : {}),\n      })),\n    }),\n\n    // \u26D4 `deleteBehavior: 'cascade'` on ALL THREE party lookups, not the default.\n    //\n    // \u26A0\uFE0F Platform constraint: a lookup defaults to `set_null`, and the engine\n    // implements `set_null` by UPDATING the row that holds it. On a column a\n    // validation rule reads, that makes the referenced party permanently\n    // UNDELETABLE: clearing this column leaves the row the engine just edited in\n    // violation of `attendee_resolves` below, and the whole delete rolls back\n    // with an error naming an object the caller never addressed. The same\n    // construction bites `crm_campaign_member`.\n    //\n    // `external_name` is the fourth resolution, but it is blank on every row the\n    // product actually writes (`src/sales/actions/activity-actions.ts` logs attendees\n    // with a party reference and never an external name), so it rescues nothing.\n    //\n    // Cascade rather than `restrict`: an attendee row is a JUNCTION whose whole\n    // meaning is \"this person was in this room\". Once the person is gone the row\n    // denotes nothing, and the query it exists to serve (\"meetings this person\n    // attended\") has lost its subject. `restrict` would produce an accurate\n    // message but keep the person undeletable until someone deleted their\n    // attendance by hand, and undeletable PEOPLE is the impact being fixed.\n    // Cascade also leaves no reachable state in which a stored attendee row\n    // breaks its own object's rule.\n    crm_contact: Field.lookup('crm_contact', {\n      group: 'basic',\n      label: 'Contact',\n      deleteBehavior: 'cascade',\n      description: 'Set when the attendee is an existing customer contact',\n      ...partyFormHints('crm_contact'),\n    }),\n\n    crm_lead: Field.lookup('crm_lead', {\n      group: 'basic',\n      label: 'Lead',\n      deleteBehavior: 'cascade',\n      description: 'Set when the attendee is still an unconverted lead',\n      ...partyFormHints('crm_lead'),\n    }),\n\n    // `sys_user` gets the SAME answer as the two CRM parties, and it was worth a\n    // second look rather than a copy-paste:\n    //\n    //  \u00B7 Deleting a user is a real, reachable operation. Generic CRUD delete on\n    //    the identity table is off (`sys_user` ships `apiMethods: ['get',\n    //    'list', 'update', 'bulk']`), but better-auth's own routes \u2014\n    //    `/api/v1/auth/delete-user`, which the platform's `sys_user` object\n    //    surfaces as the \"Delete My Account\" record action, and\n    //    `/api/v1/auth/admin/remove-user` \u2014 resolve `user` to `sys_user` and\n    //    land on `dataEngine.delete(...)`, i.e. the SAME ObjectQL delete that\n    //    runs the referential pass. So `set_null` here is not dormant: it breaks\n    //    account erasure for any colleague who ever attended a meeting.\n    //  \u00B7 The app's shipped stance is already \"a deleted user's references\n    //    degrade\". EVERY other `sys_user` lookup in HotCRM (every `owner_id`,\n    //    plus `product_manager`) is `set_null` and NO validation rule reads any\n    //    of them \u2014 the rule below is the only one in the app that reads a user\n    //    reference at all, which is precisely why this is the only lookup where\n    //    the default misbehaves. `restrict` here would make this junction the\n    //    ONE app row able to veto a platform identity erasure \u2014 an app object\n    //    holding a `protection: { lock: 'full' }`, better-auth-managed table\n    //    hostage, surfacing as an opaque failure from an auth route. That is a\n    //    layering inversion, not a fix.\n    //  \u00B7 The cost of cascade is bounded and is the right half to lose: the\n    //    meeting itself (`crm_event` \u2014 subject, times, outcome notes) survives\n    //    untouched; only the per-person row goes, and it goes because the\n    //    person's identity record was erased. Deactivation, not deletion, is the\n    //    ordinary offboarding path (the platform ships ban/unban), and it\n    //    touches nothing here.\n    sys_user: Field.lookup('sys_user', {\n      group: 'basic',\n      label: 'User',\n      deleteBehavior: 'cascade',\n      description: 'Set when the attendee is a colleague',\n      ...partyFormHints('sys_user'),\n    }),\n\n    // Free text is the LAST resort, not the default: it exists only for the\n    // genuinely unmodelled guest (a prospect's lawyer who is in no CRM object).\n    // It is the resolution of ONE attendee type \u2014 `external` \u2014 and the rules\n    // below enforce that both ways: an `external` row must fill it, and no\n    // other type may. It is not a place to paste a list, and not a note field\n    // to hang off a Contact row.\n    external_name: Field.text({\n      group: 'basic',\n      label: 'External Attendee',\n      maxLength: 255,\n      description: 'Name of an attendee who is in no CRM object \u2014 set when Attendee Type is External',\n      ...partyFormHints('external_name'),\n    }),\n\n    response: Field.select({\n      group: 'response',\n      label: 'Response',\n      required: true,\n      storage: { notNull: true },\n      trackHistory: true,\n      defaultValue: 'no_response',\n      options: [...ATTENDEE_RESPONSE_OPTIONS],\n    }),\n\n    is_organizer: Field.boolean({\n      group: 'response',\n      label: 'Organizer',\n      defaultValue: false,\n    }),\n\n    // \u26D4 NOT `readonly` \u2014 but the cross-reference this note used to carry is\n    // retired, not merely reworded: `crm_campaign_member.added_date` was ruled\n    // `readonly: true` in #1667, so it is no longer a precedent for keeping an\n    // insert-stamped column open, and the reason it cited (\"the engine strips a\n    // readonly key the CALLER supplied\") does not reach an INSERT at all \u2014 the\n    // strip is an UPDATE-path rule (`test/readonly-write-semantics.test.ts`).\n    // What holds it open is now MEASURED (#1747, the per-writer census #1435\n    // ran for the other three), not \"nobody has ruled on it\": this column has a\n    // user-context UPDATE writer, which none of the three columns #1666 / #1667\n    // moved had. The census, in full:\n    //   \u2022 the fifteen generated activity actions (5 `ACTIVITY_TARGETS` \u00D7 3\n    //     kinds, one shared body in `activity-actions.ts`) INSERT it, and an\n    //     action body runs `isSystem` \u2014 exempt twice over;\n    //   \u2022 the two `service.seed.ts` attendee seeds write it, and their\n    //     `mode: 'upsert'` replay UPDATE is exempt too, because seed writes are\n    //     `isSystem` (`flow-scheduled.test.ts` pins that via ownerless rows);\n    //   \u2022 the record form \u2014 `event_attendee.view.ts` lists it in the\n    //     `invitation` section, AUTHORED rather than synthesized, and the four\n    //     profiles that name the object all grant `allowEdit`. A rep correcting\n    //     Invited on a saved row is a non-`isSystem` UPDATE carrying a\n    //     caller-supplied key: precisely what the strip deletes. The three\n    //     flipped columns appear in NO form section anywhere in `src/*/views/`,\n    //     `crm_opportunity`'s authored form included.\n    // \u2B50 It is also not the same KIND of column. `added_date` / `approved_date`\n    // are stamped `{NOW()}` by the writer, so their value IS the write moment;\n    // `invited_date` records when the invitation went out, and the seed dates it\n    // 3-10 days before its own event, per row. A column whose value is not the\n    // write moment is one a person can be right about. \u26D4 Do not flip it on the\n    // strength of the sibling ruling.\n    invited_date: Field.datetime({\n      group: 'response',\n      label: 'Invited',\n    }),\n  },\n\n  indexes: [\n    { fields: ['crm_event'] },\n    { fields: ['crm_contact'] },\n    { fields: ['sys_user'] },\n  ],\n\n  // \u26A0\uFE0F Predicates below are TOTAL: every `record.x` read is `has()`-guarded, so\n  // the rule returns a verdict even when the merged record has no such key. See\n  // AGENTS.md \"Validation predicates must be TOTAL\" and\n  // test/object-validation-predicates.test.ts, which fails the build otherwise.\n  //\n  // Both rules are GENERATED from `ATTENDEE_RESOLUTIONS` at the top of this\n  // file. \u26A0\uFE0F `expression(..., 'cel')` is the same envelope the ``P`\u2026` `` tag\n  // produces, but the tag JSON-quotes an interpolated string and so cannot\n  // splice a source fragment \u2014 which is why these use the function form. The\n  // pairing is declared once and read twice; see the note up there.\n  validations: [\n    // The type's own column must be filled.\n    {\n      name: 'attendee_resolves',\n      type: 'script',\n      severity: 'error',\n      message:\n        'An attendee must fill the party its Attendee Type names \u2014 a Contact row needs a Contact, an External row needs an External Attendee name',\n      condition: expression(RESOLVES_CONDITION, 'cel'),\n    },\n    // \u2026and no other column may be filled. The separate rule is deliberate: one\n    // condition, one wording. Folding both into `attendee_resolves` would make\n    // its message a lie for half the rows it rejects, and \"you filled the wrong\n    // column\" is not the same instruction as \"you filled nothing\".\n    {\n      name: 'attendee_type_exclusive',\n      type: 'script',\n      severity: 'error',\n      message:\n        'An attendee names exactly one party \u2014 clear every party column its Attendee Type does not name',\n      condition: expression(EXCLUSIVE_CONDITION, 'cel'),\n    },\n  ],\n});\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/sales/objects/forecast.object.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/sales/objects\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/sales/objects/forecast.object.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport { ObjectSchema, Field } from '@objectstack/spec/data';\nimport { F, P } from '@objectstack/spec';\n\n/**\n * Forecast Object\n *\n * Monthly / quarterly snapshot of pipeline by owner. Each record holds\n * the aggregated amounts at the moment of snapshot, so trend reports\n * (\"how did our Q3 forecast change week over week?\") can be built\n * without re-aggregating opportunity history.\n *\n * Written by:\n *   \u2022 `src/sales/flows/forecast-snapshot.flow.ts` \u2014 the `forecast_snapshot`\n *     scheduled flow, nightly at 03:00, one current-quarter row per active\n *     opportunity owner (#590). It never touches `quota`.\n *   \u2022 `revenue_forecasting` AI skill on demand\n *   \u2022 `forecast.hook.ts` derives the period family + `snapshot_date` on every\n *     write; it creates nothing on its own.\n *\n * Forecast categories follow the standard Salesforce ladder, and the buckets\n * are CUMULATIVE \u2014 each is a subset of the one above it:\n *   pipeline  \u2192 all open opps closing in the period\n *   best_case \u2192 open opps whose forecast_category is best_case OR commit\n *   commit    \u2192 open opps whose forecast_category is commit\n *   closed    \u2192 already-won amount in the period\n *\n * The bucket boundary is the stored `forecast_category` column (derived from\n * `stage` by the opportunity lifecycle hook), NOT a probability threshold \u2014\n * one definition, shared with the \"Commit & Best Case\" opportunity view and\n * the `pipeline_by_forecast_category` dashboard widget.\n */\nexport const Forecast = ObjectSchema.create({\n  name: 'crm_forecast',\n  label: 'Forecast',\n  pluralLabel: 'Forecasts',\n  icon: 'trending-up',\n  description: 'Periodic pipeline snapshot by owner used for revenue forecasting.',\n\n  // OWD is an authored decision (ADR-0090 D1/D7). Forecasts are personal to the\n  // owner.\n  sharingModel: 'private',\n  // ADR-0079 record title. \u26A0\uFE0F A formula cannot dot-walk a lookup (ADR-0072), so\n  // `display_title` composes local fields only: period_label + (period_start).\n  nameField: 'display_title',\n  // \u26A0\uFE0F Explicit search targets (ADR-0061), REQUIRED because `nameField` is a\n  // FORMULA: without this, `$search` auto-defaults to the formula field, which\n  // is not a real column, so the lookup picker and global search silently\n  // return zero. These are real, indexed columns.\n  searchableFields: ['period_label'],\n  highlightFields: ['owner_id', 'period', 'period_start', 'commit_amount', 'closed_amount'],\n\n  fieldGroups: [\n    { key: 'basic',   label: 'Snapshot',    icon: 'info' },\n    { key: 'amounts', label: 'Amounts',     icon: 'dollar-sign' },\n    { key: 'meta',    label: 'Source',      icon: 'database', collapse: 'collapsed' },\n  ],\n\n  fields: {\n    // Platform ownership anchor \u2014 canonical note in `account.object.ts` (#548).\n    owner_id: Field.lookup('sys_user', {\n      label: 'Owner',\n      group: 'basic',\n      system: true,\n      readonly: false,\n      trackHistory: true,\n    }),\n\n\n    period: Field.select({\n      label: 'Period',\n      required: true,\n      storage: { notNull: true },\n      group: 'basic',\n      options: [\n        { label: 'Month',   value: 'month', default: true },\n        { label: 'Quarter', value: 'quarter' },\n      ],\n    }),\n\n    // Wording mirrors the two refusal messages this field is bound by\n    // (`period_start_first_of_period` / `quarter_starts_on_quarter_boundary`,\n    // both below) so the form and the rejection agree on the same rule\n    // instead of describing two different ones (#1085).\n    period_start: Field.date({\n      label: 'Period Start',\n      description:\n        'Must be the first day of the period \u2014 e.g. 2026-08-01 for Aug 2026. A quarterly forecast must additionally start on a quarter boundary: January 1, April 1, July 1 or October 1.',\n      required: true,\n      storage: { notNull: true },\n      group: 'basic',\n    }),\n\n    // Still not read-only: `forecast.hook.ts` fills it only when the write\n    // leaves it unset, and `src/sales/data/forecast.seed.ts` hand-fills it on every\n    // seeded row \u2014 so hand-entry is a capability this app uses. A hand-filled\n    // value is pinned to the same calendar period `period_start` is\n    // (`period_end_matches_calendar_period` below), and the description states\n    // that rule rather than the weaker `period_end_after_start` it subsumes:\n    // the form says what is actually enforced.\n    period_end: Field.date({\n      label: 'Period End',\n      description:\n        'Normally derived automatically from Period and Period Start. If set by hand, it must be the last day of that period \u2014 e.g. 2026-09-30 for a quarter starting 2026-07-01, or 2026-08-31 for Aug 2026.',\n      required: true,\n      storage: { notNull: true },\n      group: 'basic',\n    }),\n\n    period_label: Field.text({\n      label: 'Period Label',\n      description: 'Human-friendly label, e.g. \"Q3 2026\" or \"Aug 2026\".',\n      group: 'basic',\n    }),\n\n    // ADR-0079 record title. \u26A0\uFE0F A formula cannot dot-walk a lookup (ADR-0072),\n    // so this composes local fields only; `period_start` (a date) is\n    // string()-coerced for concat.\n    //\n    // \u26A0\uFE0F The coercion is `string()`, NOT `text()`. `text` is not a registered\n    // CEL function \u2014 it is absent from `CEL_STDLIB_FUNCTIONS` \u2014 so a formula\n    // using it faults at runtime and leaves the record's `nameField` null. The\n    // author-time `expression-invalid` rule now REPORTS it (\"found no matching\n    // overload for 'text(dyn)'\") instead of letting a broken formula through to\n    // null silently. `string` is the catalog's coercion, alongside\n    // `int`/`bool`/`double`/`timestamp`.\n    display_title: Field.formula({\n      label: 'Display Title',\n      expression: F`record.period_label + \" (\" + string(record.period_start) + \")\"`,\n      group: 'basic',\n    }),\n\n    snapshot_date: Field.date({\n      label: 'Snapshot Date',\n      description: 'The day this snapshot was captured.',\n      required: true,\n      storage: { notNull: true },\n      group: 'meta',\n    }),\n\n    quota: Field.currency({\n      label: 'Quota',\n      min: 0,\n      group: 'amounts',\n      trackHistory: true,\n    }),\n\n    pipeline_amount: Field.currency({\n      label: 'Pipeline',\n      description: 'Sum of all open opportunities closing in this period (any stage).',\n      min: 0,\n      group: 'amounts',\n    }),\n\n    best_case_amount: Field.currency({\n      label: 'Best Case',\n      description: 'Open opportunities in the Best Case or Commit forecast category.',\n      min: 0,\n      group: 'amounts',\n    }),\n\n    commit_amount: Field.currency({\n      label: 'Commit',\n      description: 'Open opportunities in the Commit forecast category (owner-committed).',\n      min: 0,\n      group: 'amounts',\n    }),\n\n    closed_amount: Field.currency({\n      label: 'Closed Won',\n      description: 'Already-closed-won amount in this period.',\n      min: 0,\n      group: 'amounts',\n    }),\n\n    expected_amount: Field.formula({\n      label: 'Expected',\n      description: 'Closed Won + Commit \u2014 what the owner reasonably expects to land.',\n      expression: F`coalesce(record.closed_amount, 0) + coalesce(record.commit_amount, 0)`,\n      scale: 2,\n      group: 'amounts',\n    }),\n\n    attainment_pct: Field.formula({\n      label: 'Attainment %',\n      description: 'Closed Won \u00F7 Quota \u00D7 100. Reads 0% until a positive quota is set.',\n      expression: F`coalesce(record.quota, 0) > 0 ? (coalesce(record.closed_amount, 0) * 100.0) / record.quota : 0.0`,\n      scale: 2,\n      group: 'amounts',\n    }),\n\n    coverage_ratio: Field.formula({\n      label: 'Coverage Ratio',\n      description: 'Pipeline \u00F7 (Quota \u2212 Closed Won) \u2014 whether enough pipeline remains to cover the gap. Reads 0 once the quota is already met.',\n      expression: F`(coalesce(record.quota, 0) - coalesce(record.closed_amount, 0)) > 0 ? coalesce(record.pipeline_amount, 0) / (record.quota - coalesce(record.closed_amount, 0)) : 0.0`,\n      scale: 2,\n      group: 'amounts',\n    }),\n\n    source: Field.select({\n      label: 'Source',\n      group: 'meta',\n      options: [\n        { label: 'Scheduled snapshot', value: 'scheduled', default: true },\n        { label: 'AI skill',           value: 'ai' },\n        { label: 'Manual entry',       value: 'manual' },\n      ],\n    }),\n\n    notes: Field.text({\n      label: 'Notes',\n      maxLength: 1000,\n      group: 'meta',\n    }),\n\n    // Fixture identity \u2014 the seed loader's `externalId`, and nothing else.\n    //\n    // `crm_forecast` is a PER-OWNER snapshot: its real identity is\n    // (owner_id, period, period_start), and every other column is a rendering of\n    // part of that. `period_label` in particular names a SET of rows once the\n    // `forecast_snapshot` sweep writes one row per active owner per quarter \u2014\n    // they all read 'Q3 2026' \u2014 so upserting on that label lets a re-seed match,\n    // and overwrite, a real rep's snapshot.\n    //\n    // \u26A0\uFE0F The true composite `externalId: ['owner_id', 'period', 'period_start']`\n    // is not available here: a seed cannot name a user (see the note in\n    // `objectstack.composition.ts`, \"A seed can't name a user\"), so `owner_id`\n    // is null on every seeded row, and\n    // the loader's `externalIdKey` returns \"\" as soon as any part is empty. An\n    // empty key never matches, so upsert degrades to insert-on-every-replay.\n    // Dropping `owner_id` does not rescue it: a runtime row for the current\n    // quarter carries exactly the same (period, period_start).\n    //\n    // \u26A0\uFE0F `mode: 'insert'` does NOT mean \"insert once\" \u2014 the loader inserts\n    // unconditionally on every replay boot (framework#3434). `'ignore'` is the\n    // real insert-once mode, but it decides \"already there?\" from the same\n    // `externalId`, so on a broken key it would SKIP the demo row because a real\n    // rep's row already claimed 'Q3 2026'. Fixing the identity is a prerequisite\n    // either way. Hence this synthetic, seeder-only key.\n    //\n    // \u26A0\uFE0F `readonly` is the load-bearing part, not decoration: seed writes run\n    // `{ isSystem: true }` and bypass readonly stripping, while readonly\n    // stripping does guard user/API writes \u2014 so a genuine forecast row can never\n    // acquire a `seed_key` and can never be matched by a re-seed. That is what\n    // makes the fix structural rather than a naming convention. `hidden` keeps a\n    // fixtures-only column out of forms and pickers.\n    seed_key: Field.text({\n      label: 'Seed Key',\n      description: 'Demo-fixture identity. Written only by the seed loader; empty on every real snapshot.',\n      maxLength: 64,\n      readonly: true,\n      hidden: true,\n      group: 'meta',\n    }),\n  },\n\n  indexes: [\n    { fields: ['owner_id', 'period_start', 'period'] },\n    { fields: ['snapshot_date'] },\n    { fields: ['period_start'] },\n  ],\n\n  // API surface. History \u2192 Field.trackHistory (ADR-0052).\n  enable: {\n    apiEnabled: true,\n    apiMethods: ['get', 'list', 'create', 'update', 'delete'],\n  },\n\n  // Predicates below are TOTAL: every `record.x` read is `has()`-guarded, so the\n  // rule returns a verdict even when the merged record has no such key. See\n  // AGENTS.md \"Validation predicates must be TOTAL\" and\n  // test/object-validation-predicates.test.ts, which fails the build otherwise.\n  validations: [\n    {\n      name: 'period_end_after_start',\n      type: 'script',\n      severity: 'error',\n      message: 'Period End must be after Period Start.',\n      // `<=`, not `<`: the rule name says \"after\" and a forecast period is a\n      // month or a quarter, never a single instant, so `period_end ==\n      // period_start` is a zero-length period rather than a valid one. Same\n      // operator and wording as the `end_after_start` twins on\n      // campaign/contract.\n      condition: P`has(record.period_end) && record.period_end != null && has(record.period_start) && record.period_start != null && record.period_end <= record.period_start`,\n    },\n    // A hand-filled `period_start` must be the first day of the calendar period\n    // it labels. Maintainer ruling 2026-08-11: \u300C\u63A5\u53D7\u4F60\u7684\u5168\u90E8\u5EFA\u8BAE\u300D \u2014 refuse\n    // rather than accept or snap.\n    //\n    // The hook derives `period_end` as \"start + one period\" \u2014 a ROLLING window.\n    // That is calendar-true for a start on a boundary and drifts for anything\n    // else: `period: 'quarter'` + `period_start: 2026-08-15` derives\n    // `period_end: 2026-10-31` under `period_label: 'Q3 2026'`, a window\n    // labelled Q3 that reaches a month into Q4. The row is internally\n    // inconsistent in a way no consumer can detect: every \"this quarter\"\n    // equals-filter reads `period_start`, and the nightly sweep selects the\n    // current row by `period_start <= today <= period_end`.\n    //\n    // These rules are the ONE enforcement point \u2014 deliberately not a throw in\n    // `forecast.hook.ts` as well. \u26A0\uFE0F A declared rule is the shape the platform\n    // can act on: it refuses the write with a `ValidationError` /\n    // `VALIDATION_FAILED` envelope (HTTP 400) on the record form, on the API and\n    // on a seed's system write alike, where a hook throw is a bare `Error`. The\n    // derivation is left alone: with the start pinned to a boundary, \"start +\n    // one period\" IS the calendar period.\n    //\n    // \u26A0\uFE0F WHY A REGEX AND NOT DATE ARITHMETIC: the CEL stdlib this app compiles\n    // against (`CEL_STDLIB_FUNCTIONS`) has no month/day accessor \u2014 the date\n    // functions are `today`/`daysBetween`/`addDays`/`addMonths`/`date` \u2014 so \"the\n    // 1st of its month\" is not expressible as arithmetic. Both drivers this app\n    // can run on hand `period_start` back as a `YYYY-MM-DD` string, and an ISO\n    // *datetime* string still matches these prefix-anchored patterns. A caller\n    // that writes a JS `Date` object is the one shape `string()` has no overload\n    // for; the engine then rejects that write naming the rule rather than\n    // admitting it, and no writer in this app does that.\n    {\n      name: 'period_start_first_of_period',\n      type: 'script',\n      severity: 'error',\n      message: 'Period Start must be the first day of the period \u2014 e.g. 2026-08-01 for Aug 2026.',\n      condition: P`has(record.period_start) && record.period_start != null && !matches(string(record.period_start), \"^[0-9]{4}-[0-9]{2}-01\")`,\n    },\n    {\n      name: 'quarter_starts_on_quarter_boundary',\n      type: 'script',\n      severity: 'error',\n      // The month rule above already rejects any non-1st day, so this one only\n      // ever adds the quarter-month half: 2026-08-01 is a valid month start and\n      // not a valid quarter start.\n      message: 'A quarterly forecast must start on a quarter boundary \u2014 January 1, April 1, July 1 or October 1.',\n      condition: P`has(record.period) && record.period == \"quarter\" && has(record.period_start) && record.period_start != null && !matches(string(record.period_start), \"^[0-9]{4}-(01|04|07|10)-01\")`,\n    },\n    // \u2026and the OTHER end of the same window. The two rules above pin the START;\n    // `period_end` stays reachable, because the hook derives it only when the\n    // write leaves it unset and the field sits editable on the record form.\n    // Without this rule, `period: 'quarter'` + `period_start: 2026-07-01` (a\n    // boundary the rules above admit) + a hand-typed `period_end: 2027-05-15` is\n    // ADMITTED under `period_label: 'Q3 2026'` \u2014 a ten-month window labelled as\n    // one quarter, reached through the other field.\n    //\n    // WHY A RULE AND NOT A READ-ONLY FIELD: deriving `period_end` always and\n    // locking the form breaks the demo seed \u2014\n    // `src/sales/data/forecast.seed.ts` hand-fills it on every seeded row.\n    // Hand-entry stays; it is now bounded.\n    //\n    // \u26A0\uFE0F WHY `type: 'script'` AND NOT A FIELD CONSTRAINT: a field bound judges\n    // only the value being written, so a row already stored wrong keeps\n    // accepting edits forever; a script validation is evaluated against the\n    // MERGED record on every write and is therefore a true invariant.\n    // `test/forecast-period-end-boundary.test.ts` pins both halves \u2014 a legacy\n    // row is refused on its next unrelated edit, and the repair is admitted.\n    //\n    // WHY DATE ARITHMETIC HERE WHEN THE TWO RULES ABOVE USE A REGEX: not taste.\n    // Those rules inspect ONE date's components (\"is this the 1st of its\n    // month?\"), and the CEL stdlib has no month/day accessor. This rule compares\n    // TWO dates, which `addMonths`/`addDays`/`daysBetween` express directly.\n    //\n    // The predicate says \"one period long\", and that is the same claim as \"ends\n    // on the calendar boundary\" ONLY because the two rules above pin the start\n    // to one. That coupling is deliberate: the three are one set enforcing one\n    // invariant (a row's window is exactly the calendar period it is labelled\n    // with), not three independent gates.\n    //\n    // \u26A0\uFE0F `daysBetween(a, b) != 0` rather than `a == b`: both drivers this app\n    // runs on hand dates back as `YYYY-MM-DD` strings while `addDays` returns a\n    // timestamp, and a string never `==` a timestamp \u2014 the rule would be\n    // permanently green. `daysBetween` puts both sides through the same\n    // `toDate`, so the string, an ISO datetime spelling and a JS `Date` all\n    // compare alike.\n    //\n    // \u26A0\uFE0F The `!= null` guards are load-bearing for a THIRD hazard beyond the two\n    // AGENTS.md names: `daysBetween(null, \u2026)` reaches `BigInt(NaN)` and THROWS,\n    // which the engine reports as `predicate failed to evaluate` \u2014 a rule that\n    // cannot answer, i.e. a rejected ordinary save. This predicate has no\n    // ordering operator, so `object-validation-predicates.test.ts`'s\n    // unguarded-comparison sweep does not cover it; the pin lives in\n    // `test/forecast-period-end-boundary.test.ts` instead.\n    {\n      name: 'period_end_matches_calendar_period',\n      type: 'script',\n      severity: 'error',\n      message:\n        'Period End must be the last day of the period \u2014 e.g. 2026-09-30 for a quarter starting 2026-07-01, or 2026-08-31 for Aug 2026.',\n      // Spelled out per period value instead of a ternary on the month count:\n      // an undeclared `period` is refused BY NAME by the picklist (\"Period must\n      // be one of: month, quarter\", measured), so this rule judges only the two\n      // values it understands and leaves the rest to the schema.\n      condition: P`has(record.period) && record.period != null && has(record.period_start) && record.period_start != null && has(record.period_end) && record.period_end != null && ((record.period == \"month\" && daysBetween(record.period_end, addDays(addMonths(record.period_start, 1), -1)) != 0) || (record.period == \"quarter\" && daysBetween(record.period_end, addDays(addMonths(record.period_start, 3), -1)) != 0))`,\n    },\n    {\n      name: 'snapshot_amounts_non_negative',\n      type: 'script',\n      severity: 'error',\n      message: 'Snapshot amounts cannot be negative.',\n      condition: P`(has(record.pipeline_amount) && record.pipeline_amount != null && record.pipeline_amount < 0) || (has(record.best_case_amount) && record.best_case_amount != null && record.best_case_amount < 0) || (has(record.commit_amount) && record.commit_amount != null && record.commit_amount < 0) || (has(record.closed_amount) && record.closed_amount != null && record.closed_amount < 0)`,\n    },\n  ],\n});\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/sales/objects/lead.object.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/sales/objects\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/sales/objects/lead.object.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport { ObjectSchema, Field } from '@objectstack/spec/data';\nimport { F, P } from '@objectstack/spec';\nimport {\n  SALUTATION_OPTIONS,\n  INDUSTRY_OPTIONS,\n  LEAD_SOURCE_OPTIONS,\n  LEAD_NEED_TYPE_OPTIONS,\n  DUPLICATE_OF_TYPE_OPTIONS,\n} from './_picklists';\n\nexport const Lead = ObjectSchema.create({\n  name: 'crm_lead',\n  label: 'Lead',\n  pluralLabel: 'Leads',\n  icon: 'user-plus',\n  description: 'Potential customers not yet qualified',\n\n  // ADR-0090 D1/D7: OWD is an authored decision. Owner-worked queue.\n  sharingModel: 'private',\n  \n  fieldGroups: [\n    { key: 'identity',     label: 'Identity',           icon: 'user-plus' },\n    { key: 'company_info', label: 'Company Information', icon: 'building' },\n    { key: 'contact_info', label: 'Contact Information', icon: 'phone' },\n    { key: 'qualification', label: 'Qualification',     icon: 'star' },\n    { key: 'assignment',   label: 'Assignment',         icon: 'user' },\n    { key: 'address',      label: 'Address',            icon: 'map-pin', collapse: 'collapsed' },\n    { key: 'additional',   label: 'Additional Info',    icon: 'info', collapse: 'collapsed' },\n    { key: 'preferences',  label: 'Communication Preferences', icon: 'bell-off', collapse: 'collapsed' },\n    { key: 'conversion',   label: 'Conversion',         icon: 'check-circle', collapse: 'collapsed' },\n    { key: 'duplicates',   label: 'Duplicate Management', icon: 'copy', collapse: 'collapsed' },\n  ],\n\n  fields: {\n    // Platform ownership anchor \u2014 canonical note in `account.object.ts` (#548).\n    owner_id: Field.lookup('sys_user', {\n      label: 'Lead Owner',\n      group: 'assignment',\n      system: true,\n      readonly: false,\n      trackHistory: true,\n    }),\n\n    // Personal Information\n    salutation: Field.select({\n      label: 'Salutation',\n      group: 'identity',\n      // Canonical set shared with Contact (#490) \u2014 see _picklists.ts.\n      options: [...SALUTATION_OPTIONS],\n    }),\n\n    first_name: Field.text({\n      label: 'First Name',\n      required: true,\n      storage: { notNull: true },\n      searchable: true,\n      group: 'identity',\n    }),\n\n    last_name: Field.text({\n      label: 'Last Name',\n      required: true,\n      storage: { notNull: true },\n      searchable: true,\n      group: 'identity',\n    }),\n\n    // \u26A0\uFE0F `salutation` is a picklist, so a formula sees the raw VALUE (`ms`,\n    // `dr`), not the label \u2014 including it renders names as \"ms Emily Davis\" in\n    // lists and details. Dropped here and from `display_title` below, matching\n    // Contact.\n    full_name: Field.formula({\n      label: 'Full Name',\n      expression: F`joinNonEmpty([record.first_name, record.last_name], ' ')`,\n      group: 'identity',\n    }),\n\n    // ADR-0079 record title (was titleFormat '{full_name} - {company}').\n    // Composed from the same source fields as `full_name` (not formula-on-formula)\n    // plus `company`, so the title resolves from real stored values.\n    display_title: Field.formula({\n      label: 'Display Title',\n      expression: F`joinNonEmpty([record.first_name, record.last_name], ' ') + \" - \" + record.company`,\n      group: 'identity',\n    }),\n\n    // Company Information\n    company: Field.text({\n      label: 'Company',\n      required: true,\n      storage: { notNull: true },\n      searchable: true,\n      group: 'company_info',\n    }),\n\n    /**\n     * Case- and whitespace-folded copy of `company` \u2014 the value lead conversion\n     * compares against `crm_account.name_normalized`.\n     *\n     * ### Why the LEAD needs one too\n     *\n     * \u26A0\uFE0F A normalized column on `crm_account` alone fixes nothing: the\n     * conversion flow would then compare a raw company string against a folded\n     * account name, and `\"ACME  Corp\"` still would not match `acme corp`. Both\n     * sides have to be canonical, and the flow can canonicalize neither \u2014\n     * `service-automation`'s `resolveToken` accepts exactly one function form\n     * (`NOW()` / `TODAY()`), so `{LOWER(x)}`, `{TRIM(x)}` and\n     * `{x.toLowerCase()}` all resolve to `undefined`. See the field comment on\n     * `crm_account.name_normalized` for the full measurement.\n     *\n     * `company` itself is NOT folded in place: it is the display value, it is\n     * copied verbatim onto the account the conversion creates, and lower-casing\n     * it would ship `acme corp` as a customer-visible account name. That is the\n     * one way this differs from `email`, which has no meaningful case and so is\n     * canonicalized in place.\n     *\n     * Derived, never authored: `lead_duplicate_check` recomputes it on every\n     * write that carries `company`. Not indexed \u2014 nothing filters on it; it is\n     * read off the lead record the flow already fetched.\n     */\n    company_normalized: Field.text({\n      label: 'Company (Normalized)',\n      description:\n        'Match key for lead conversion: Company lower-cased, trimmed, with internal whitespace collapsed. Maintained by the lead_duplicate_check hook \u2014 never edit directly.',\n      readonly: true,\n      hidden: true,\n      maxLength: 255,\n      group: 'company_info',\n    }),\n\n    title: Field.text({\n      label: 'Job Title',\n      group: 'company_info',\n    }),\n\n    industry: Field.select({\n      label: 'Industry',\n      group: 'company_info',\n      // Canonical set shared with Account (#490): lead_conversion copies this\n      // value onto the created Account, so both objects MUST agree.\n      options: [...INDUSTRY_OPTIONS],\n    }),\n\n    // \u26A0\uFE0F NOT `unique`. A hard uniqueness constraint on a lead's email says a\n    // person may enquire once, ever, and the database enforces it by REJECTING\n    // the second enquiry \u2014 turning an ordinary follow-up into a 500 on the\n    // public form. Real funnels re-capture the same address routinely.\n    // Duplicates are a fact to be RECORDED, not an error: `lead_duplicate_check`\n    // in lead.hook.ts links the new lead to the record it repeats (see the\n    // `duplicates` field group below). The plain index below is what keeps the\n    // column indexed in the constraint's absence \u2014 the intake dedupe lookup, the\n    // `crm_lead_import` upsert key and the conversion flow all read leads by\n    // email on every write.\n    email: Field.email({\n      label: 'Email',\n      required: true,\n      storage: { notNull: true },\n      group: 'contact_info',\n    }),\n\n    phone: Field.text({\n      label: 'Phone',\n      format: 'phone',\n      group: 'contact_info',\n    }),\n\n    mobile: Field.text({\n      label: 'Mobile',\n      format: 'phone',\n      group: 'contact_info',\n    }),\n\n    website: Field.url({\n      label: 'Website',\n      group: 'contact_info',\n    }),\n\n    // Lead Qualification\n    status: Field.select({\n      label: 'Lead Status',\n      required: true,\n      storage: { notNull: true },\n      group: 'qualification',\n      trackHistory: true,\n      // Field-level default: option-level `default: true` only preselects in\n      // UI forms after first paint; the quick-create dialog and API inserts\n      // need a real defaultValue (see approval_status for the same lesson).\n      defaultValue: 'new',\n      options: [\n        { label: 'New', value: 'new', color: '#808080', default: true },\n        { label: 'Contacted', value: 'contacted', color: '#FFA500' },\n        { label: 'Qualified', value: 'qualified', color: '#4169E1' },\n        { label: 'Unqualified', value: 'unqualified', color: '#FF0000' },\n        { label: 'Converted', value: 'converted', color: '#00AA00' },\n      ]\n    }),\n\n    rating: Field.rating(5, {\n      label: 'Lead Score',\n      description: 'Lead quality score (1-5 stars)',\n      group: 'qualification',\n    }),\n\n    lead_source: Field.select({\n      label: 'Lead Source',\n      group: 'qualification',\n      // Canonical set shared with Contact + Opportunity (#490): lead_conversion\n      // copies this value onto the created Opportunity, so all three MUST agree.\n      options: [...LEAD_SOURCE_OPTIONS],\n    }),\n\n    // \u2500\u2500 Demand: what this prospect wants, and what it is worth \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n    //\n    // REQ-0005 steps 6-7. Both fields are in `qualification` because they ARE\n    // qualification data \u2014 what the buyer is asking for and how big it is are\n    // the two facts a rep weighs before working a lead \u2014 and neither is\n    // required: a lead captured off the public form has neither, and saves\n    // exactly as it did before.\n\n    need_type: Field.select({\n      label: 'Need Type',\n      group: 'qualification',\n      description: 'What this prospect is asking for. Routing, prioritisation and demand reporting read this.',\n      // Generic starter vocabulary, declared once in `_picklists.ts` \u2014 see the\n      // note there for why it is NOT shared with `crm_opportunity.type`.\n      options: [...LEAD_NEED_TYPE_OPTIONS],\n    }),\n\n    // \u26D4 NEVER conflated with `annual_revenue`, which sits two groups below in\n    // `additional` and answers a different question: that is the prospect\n    // COMPANY's own turnover, a size signal, and it is the value\n    // `lead_conversion` copies onto the account it creates. This is the value\n    // of the DEMAND \u2014 the number that becomes `crm_opportunity.amount` when the\n    // lead converts, and the only figure the pipeline has before then.\n    //\n    // \u26D4 Nor is it a second copy of `crm_opportunity.amount`. The opportunity's\n    // amount is a committed deal figure a rep defends in a forecast; this is an\n    // estimate taken before qualification, and the conversion screen is where a\n    // human turns one into the other (it PREFILLS from here \u2014 see the\n    // `opportunityAmount` screen field in `lead-conversion.flow.ts` \u2014 rather\n    // than copying silently, so the rep confirms the number that enters the\n    // forecast).\n    estimated_amount: Field.currency({\n      label: 'Estimated Amount',\n      group: 'qualification',\n      description: 'Estimated value of this demand, before qualification. Prefills the deal amount at conversion.',\n    }),\n\n    // \u2500\u2500 The conversion approval gate (REQ-0005 step 7) \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n    //\n    // \u26A0\uFE0F `defaultValue: 'not_required'` IS THE GATE'S OFF SWITCH, and it is the\n    // one line an install changes to arm it. REQ-0005: \"The gate must be\n    // configurable \u2014 off by default. A single-seller install must not be forced\n    // through an approval to convert a lead.\"\n    //\n    //   OFF (shipped)  every lead is born `not_required`; nothing ever writes\n    //                  `pending`, so `lead_conversion_approval` never enters,\n    //                  the Convert button never hides and the write-path gate in\n    //                  `lead.hook.ts` never fires. Conversion behaves EXACTLY as\n    //                  it did before this field existed.\n    //   ON             change this one value to `'pending'`. Every lead is then\n    //                  born pending, `lead_conversion_approval` opens its\n    //                  request, and conversion is refused until an approver\n    //                  decides.\n    //\n    // Leads that predate the switch keep whatever they were born with, which is\n    // the point: arming the gate does not invalidate or re-open a single\n    // existing record (REQ-0005 acceptance 4). This is a TRANSITION GATE, not an\n    // invariant (AGENTS.md metadata semantics rule 7) \u2014 what is refused is the\n    // ACT of converting, evaluated against `previous` in `lead.hook.ts`, never\n    // the state of a record that is already converted.\n    //\n    // Shape copied from `crm_opportunity.approval_status`: `readonly: true`\n    // plus a REAL field-level `defaultValue`, \u26D4 not only an option-level\n    // `default: true` \u2014 the same lesson `status` above records, and the reason\n    // that field's own comment gives: an option default only preselects in UI\n    // forms after first paint, so a quick-create dialog or an API insert would\n    // land a null and a null matches no flow entry condition.\n    //\n    // \u26D4 Do NOT add an \"approved\" value to `status` instead. That select is the\n    // qualification lifecycle; a sixth value there would break the\n    // `convert_lead` predicate, the `lead_status_progression` transitions and\n    // the seeded rows, and would conflate \"this lead is worth working\" with\n    // \"someone signed off on converting it\".\n    conversion_approval_status: Field.select({\n      label: 'Conversion Approval',\n      group: 'qualification',\n      readonly: true,\n      trackHistory: true,\n      description:\n        'Whether this lead has been signed off for conversion. Not Required means no approval is asked for \u2014 the shipped default.',\n      defaultValue: 'not_required',\n      options: [\n        { label: 'Not Required', value: 'not_required', default: true },\n        { label: 'Pending', value: 'pending', color: '#FFA500' },\n        { label: 'Approved', value: 'approved', color: '#00AA00' },\n        { label: 'Rejected', value: 'rejected', color: '#FF0000' },\n      ],\n    }),\n\n    // Assignment\n\n    // Conversion tracking.\n    // \u26D4 NOT `readonly`: the `lead_conversion` flow's `mark_converted` node\n    // UPDATEs this column and the four `converted_*` ones below, and that flow\n    // declares no `runAs` \u2014 so it runs at the engine default `'user'`, which is\n    // also where house rule 9 keeps a screen flow. `stripReadonlyFields` runs\n    // under `if (!opCtx.context?.isSystem)` and deletes every readonly key the\n    // CALLER supplied, so `readonly` here would silently un-convert every\n    // conversion.\n    // \u26A0\uFE0F The other writer is unaffected, and is not the reason: the\n    // guest-submission sanitiser in `lead.hook.ts` ASSIGNS these on\n    // `beforeInsert`, and hook-written keys are not caller-supplied \u2014 nor does\n    // the strip run on INSERT at all. Measured in\n    // `test/readonly-write-semantics.test.ts`.\n    // \u21D2 Declaring these `readonly` would need the flow's write ELEVATED, which\n    // is a privilege decision on the maintainer's floor, not this file's (#1435).\n    // Edit-protection is the `beforeUpdate` guard in `lead.hook.ts`, which\n    // rejects any USER edit to a converted lead outside a small allow-list \u2014\n    // and it is the ONLY guard, deliberately: a script validation beside it\n    // never fires, because the hook's throw always wins the race.\n    is_converted: Field.boolean({\n      label: 'Converted',\n      defaultValue: false,\n      group: 'conversion',\n      trackHistory: true,\n    }),\n\n    converted_account: Field.lookup('crm_account', {\n      label: 'Converted Account',\n      group: 'conversion',\n    }),\n\n    converted_contact: Field.lookup('crm_contact', {\n      label: 'Converted Contact',\n      group: 'conversion',\n    }),\n\n    converted_opportunity: Field.lookup('crm_opportunity', {\n      label: 'Converted Opportunity',\n      group: 'conversion',\n    }),\n\n    converted_date: Field.datetime({\n      label: 'Converted Date',\n      group: 'conversion',\n    }),\n\n    // Address (using new address field type)\n    address: Field.address({\n      label: 'Address',\n      group: 'address',\n    }),\n\n    // Additional Info\n    annual_revenue: Field.currency({\n      label: 'Annual Revenue',\n      group: 'additional',\n    }),\n\n    number_of_employees: Field.number({\n      label: 'Number of Employees',\n      group: 'additional',\n    }),\n\n    description: Field.markdown({\n      label: 'Description',\n      group: 'additional',\n    }),\n\n    // Custom notes with rich text formatting\n    notes: Field.richtext({\n      label: 'Notes',\n      description: 'Working notes on this lead \u2014 supports formatting.',\n      group: 'additional',\n    }),\n\n    // Flags\n    do_not_call: Field.boolean({\n      label: 'Do Not Call',\n      defaultValue: false,\n      group: 'preferences',\n    }),\n\n    email_opt_out: Field.boolean({\n      label: 'Email Opt Out',\n      defaultValue: false,\n      group: 'preferences',\n    }),\n\n    // Follow-up & disqualification tracking\n    next_followup_date: Field.date({\n      label: 'Next Follow-up Date',\n      group: 'qualification',\n    }),\n\n    // NOT `readonly` (#592) \u2014 see the long note on\n    // `crm_account.last_activity_date`. The activity bubble writes this from\n    // another object's hook, and a readonly field is stripped from any\n    // non-system write whose caller supplied the key (#2948), so every bubble\n    // into this column was silently discarded.\n    last_contacted_date: Field.datetime({\n      label: 'Last Contacted',\n      group: 'qualification',\n    }),\n\n    disqualification_reason: Field.select({\n      label: 'Disqualification Reason',\n      group: 'qualification',\n      description: 'Required when status is Unqualified',\n      options: [\n        { label: 'Not a Fit',         value: 'not_a_fit' },\n        { label: 'No Budget',         value: 'no_budget' },\n        { label: 'Wrong Persona',     value: 'wrong_persona' },\n        { label: 'Unreachable',       value: 'unreachable' },\n        { label: 'Duplicate',         value: 'duplicate' },\n        { label: 'Competitor',        value: 'competitor' },\n        { label: 'Other',             value: 'other' },\n      ],\n    }),\n\n    // \u2500\u2500 Duplicate management \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n    //\n    // `disqualification_reason: 'duplicate'` is only meaningful if the record\n    // says WHAT it duplicates \u2014 otherwise the \"duplicate\" bar on the\n    // disqualification breakdown points at nothing you can open.\n    //\n    // \u26A0\uFE0F The surviving record can live on either object \u2014 a still-open lead, or\n    // a contact the prospect already became \u2014 and `Field.lookup` takes exactly\n    // one target (`Field.lookup(['crm_lead','crm_contact'])` is rejected at\n    // schema parse: \"reference: expected string, received array\"). So the link\n    // is the same TYPE-DISCRIMINATOR shape `crm_task.related_to_*` already uses:\n    // one select naming the object, one lookup per object, and the pairing\n    // enforced declaratively.\n    //\n    // The vocabulary is TWO sets, declared and split in `_picklists.ts`: the two\n    // object names an author may pick, plus `erased` \u2014 a tombstone the form does\n    // not offer and only `lead_duplicate_check` ever writes.\n    //\n    // The tombstone is what lets an erasure COMPLETE against a lead a human\n    // confirmed as a duplicate, without relaxing one rule, so read it as a\n    // constraint rather than as a spare value: `requiredWhen` below pairs only\n    // `crm_lead` / `crm_contact`, so a tombstoned type never fires either\n    // pairing and never demands a pointer to a record that is gone; and\n    // `duplicate_disqualification_requires_survivor` asks for a NON-BLANK type\n    // plus `duplicate_status == \"confirmed\"`, both of which a tombstoned lead\n    // still satisfies \u2014 so the verdict a reviewer recorded survives the erasure\n    // instead of being deleted as a side effect of someone else's GDPR request.\n    duplicate_of_type: Field.select({\n      label: 'Duplicate Of',\n      group: 'duplicates',\n      description: 'Which object holds the surviving record this lead repeats.',\n      options: [...DUPLICATE_OF_TYPE_OPTIONS],\n    }),\n\n    // \u26A0\uFE0F The type\u2194lookup pairing is `requiredWhen`, not a script validation:\n    // \"the lookup named by the type must be populated\" is exactly a conditional\n    // write contract, the engine evaluates it on insert and update, and it\n    // reports against the FIELD, so the form marks the empty lookup instead of\n    // showing a record-level error. (`crm_task` states the same intent as a\n    // warning-severity script rule because it predates `requiredWhen`,\n    // ADR-0113.)\n    //\n    // \u26A0\uFE0F `has(...)` is load-bearing, not decoration. A bare\n    // `record.duplicate_of_type == \"crm_lead\"` aborts with `No such key` on any\n    // record whose merged shape omits the column, and the engine's response to a\n    // predicate that fails to evaluate is to SKIP it (\"requiredWhen for\n    // 'duplicate_of_lead' failed to evaluate \u2014 skipped\"). The rule would then\n    // read as enforced and require nothing at all.\n    //\n    // \u26A0\uFE0F Both lookups take the spec default `deleteBehavior: 'set_null'`, and\n    // that is deliberate: a lead is a first-class record that happens to carry a\n    // flag, so `cascade` would destroy the lead because the record it was\n    // compared against was deleted. What keeps the pairing honest under a\n    // `set_null` clear is the retirement block in `lead_duplicate_check`\n    // (`lead.hook.ts`, job 1c): when a write leaves the named lookup blank it\n    // drops `duplicate_of_type` and `duplicate_status` in the same write, so the\n    // pair is never left half-stated and this rule never has to be loosened to\n    // tolerate one. Read that note before changing either predicate.\n    duplicate_of_lead: Field.lookup('crm_lead', {\n      label: 'Duplicate Of Lead',\n      group: 'duplicates',\n      requiredWhen: P`has(record.duplicate_of_type) && record.duplicate_of_type == \"crm_lead\"`,\n    }),\n\n    duplicate_of_contact: Field.lookup('crm_contact', {\n      label: 'Duplicate Of Contact',\n      group: 'duplicates',\n      requiredWhen: P`has(record.duplicate_of_type) && record.duplicate_of_type == \"crm_contact\"`,\n    }),\n\n    // Machine suspicion and human verdict are ONE field with two values, not two\n    // parallel sets of link fields: the intake hook writes `suspected` and only\n    // ever when this is blank (lead.hook.ts), so a human's `confirmed` survives\n    // every later write, and both states stay queryable off one column.\n    duplicate_status: Field.select({\n      label: 'Duplicate Status',\n      group: 'duplicates',\n      trackHistory: true,\n      description:\n        'Suspected = flagged automatically at intake. Confirmed = a human verified the match.',\n      options: [\n        { label: 'Suspected', value: 'suspected', color: '#FFA500' },\n        { label: 'Confirmed', value: 'confirmed', color: '#FF0000' },\n      ],\n    }),\n  },\n\n  // Lifecycle transitions are enforced via a `state_machine` validation rule\n  // (see validations[] below). \u26A0\uFE0F There is no top-level `stateMachines` key on\n  // the platform \u2014 status state machines are expressed in the validation union.\n\n  // Database indexes for performance\n  //\n  // \u26A0\uFE0F `email` is indexed but NOT unique, and the index must stay explicit: it\n  // used to exist only as a side effect of a field-level `unique: true`, so\n  // dropping that constraint would otherwise have dropped the index with it and\n  // left three read paths \u2014 the `lead_duplicate_check` intake lookup, the\n  // `crm_lead_import` upsert key and the conversion flow \u2014 scanning the table\n  // on every write.\n  //\n  // \u26D4 Do NOT add `unique: true` back here: a single-column unique index makes\n  // the platform-wide constraint win over the per-tenant composite\n  // (framework#3991), so two organizations could not work the same address\n  // independently. Uniqueness is not the rule this object wants at all.\n  indexes: [\n    { fields: ['owner_id'] },\n    { fields: ['status'] },\n    { fields: ['company'] },\n    { fields: ['email'] },\n  ],\n  \n  // API surface. History \u2192 Field.trackHistory (ADR-0052).\n  enable: {\n    apiEnabled: true,\n  },\n  \n  // ADR-0079 record title \u2014 the `display_title` formula field defined above.\n  nameField: 'display_title',\n  // Explicit search targets (ADR-0061). REQUIRED because nameField is a\n  // FORMULA (display_title/full_name): without this, $search auto-defaults to\n  // the formula field, which isn't a real column, so the lookup picker + global\n  // search silently return zero. These are real, indexed columns.\n  searchableFields: ['first_name', 'last_name', 'company', 'email'],\n  highlightFields: ['full_name', 'company', 'email', 'status', 'owner_id'],\n  \n  // Removed: list_views and form_views belong in UI configuration, not object definition\n  \n  // Predicates below are TOTAL: every `record.x` read is `has()`-guarded, so the\n  // rule returns a verdict even when the merged record has no such key. See\n  // AGENTS.md \"Validation predicates must be TOTAL\" and\n  // test/object-validation-predicates.test.ts, which fails the build otherwise.\n  validations: [\n    {\n      name: 'email_required',\n      type: 'script',\n      severity: 'error',\n      message: 'Email is required',\n      condition: P`!has(record.email) || isBlank(record.email)`,\n    },\n    {\n      // The field description promises \"Required when status is Unqualified\";\n      // this is what enforces it. A lead in `unqualified` with no recorded\n      // reason loses the one datum a disqualification review needs. Same shape\n      // as `crm_case.escalation_reason_required`.\n      name: 'disqualification_reason_required',\n      type: 'script',\n      severity: 'error',\n      message: 'Disqualification reason is required when a lead is Unqualified',\n      condition: P`has(record.status) && record.status == \"unqualified\" && (!has(record.disqualification_reason) || isBlank(record.disqualification_reason))`,\n    },\n    {\n      // \"Disqualified as a duplicate\" has to name the survivor.\n      //\n      // Same shape as `disqualification_reason_required` directly above \u2014 a\n      // declarative condition evaluated by the engine on insert and update, with\n      // no hook involved. The two clauses are the two things the field-level\n      // `requiredWhen` on the lookups cannot say:\n      //\n      //   1. `duplicate_of_type` must be chosen, which is what makes exactly one\n      //      of the two `requiredWhen` predicates fire and demand its lookup.\n      //   2. `duplicate_status` must be `confirmed` SPECIFICALLY. `requiredWhen`\n      //      asks whether a field is populated, not what it holds \u2014 and a lead\n      //      closed on the machine's `suspected` guess is precisely the outcome\n      //      this rule exists to prevent. A human has to look and agree.\n      //\n      // \u26A0\uFE0F Every field reference is wrapped in `has(...)`, and that is what makes\n      // this an enforced rule rather than a decorative one. The engine evaluates\n      // a validation against `{...previous, ...data}` and fills absent fields\n      // with null on INSERT \u2014 but not on UPDATE, where `previous` is whatever\n      // the driver returned, and a driver that stores only the columns a row was\n      // written with hands back a record with no `duplicate_status` key at all.\n      // Strict CEL then aborts the whole predicate with `No such key`, and a\n      // predicate that fails to evaluate is SKIPPED, not failed:\n      //\n      //     WARN Validation rule '\u2026' predicate failed to evaluate (\u2026) \u2014 skipped\n      //\n      // The unguarded first draft of this rule let a lead be closed as a\n      // duplicate with no survivor named, silently, on the in-memory driver \u2014\n      // the driver the whole test suite runs on.\n      name: 'duplicate_disqualification_requires_survivor',\n      type: 'script',\n      severity: 'error',\n      message:\n        'Disqualifying a lead as Duplicate requires naming the surviving record and setting Duplicate Status to Confirmed',\n      condition: P`has(record.disqualification_reason) && record.disqualification_reason == \"duplicate\" && !(has(record.duplicate_of_type) && !isBlank(record.duplicate_of_type) && has(record.duplicate_status) && record.duplicate_status == \"confirmed\")`,\n    },\n    {\n      name: 'lead_status_progression',\n      type: 'state_machine',\n      severity: 'warning',\n      message: 'Invalid lead status transition',\n      field: 'status',\n      // Conversion (\u2192 converted) is allowed from any worked-open status so the\n      // Convert action's widened visibility (new/contacted/qualified) never trips\n      // a spurious \"invalid transition\" warning when the flow stamps\n      // status:'converted'.\n      transitions: {\n        new: ['contacted', 'qualified', 'unqualified', 'converted'],\n        contacted: ['qualified', 'unqualified', 'converted'],\n        qualified: ['converted', 'unqualified'],\n        unqualified: ['new'],\n        converted: [],\n      },\n    },\n  ],\n  \n  // \u26A0\uFE0F No `workflows[]` here, and none is possible: object `workflows[]` were\n  // removed from the platform. Field updates live in this object's `*.hook.ts`;\n  // scheduled status flips and notifications live in `src/*/flows/*.flow.ts`.\n});\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/sales/objects/opportunity.object.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/sales/objects\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/sales/objects/opportunity.object.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport { ObjectSchema, Field } from '@objectstack/spec/data';\nimport { F, P } from '@objectstack/spec';\nimport { LEAD_SOURCE_OPTIONS, OPPORTUNITY_STAGE_OPTIONS } from './_picklists';\n\nexport const Opportunity = ObjectSchema.create({\n  name: 'crm_opportunity',\n  label: 'Opportunity',\n  pluralLabel: 'Opportunities',\n  icon: 'dollar-sign',\n  description: 'Sales opportunities and deals in the pipeline',\n\n  // ADR-0090 D1/D7: OWD is an authored decision. Owner + high-value management sharing rule.\n  sharingModel: 'private',\n  // \u26A0\uFE0F ADR-0079 `nameField` is a FIELD, not a render template, and a FORMULA\n  // sees the stored select VALUE rather than its translated label \u2014 so a\n  // `'{name} - {stage}'` title renders every deal \"Enterprise Deal -\n  // closed_won\" in lookups, related lists and search, in every locale. The\n  // formula language has no option-label lookup, so the title is the plain\n  // `name` column; `stage` still leads the highlight strip below, translated.\n  nameField: 'name',\n  // Explicit search targets (ADR-0061). `name` is a real indexed column, so\n  // $search resolves on its own here; the list is kept explicit to pin the\n  // intent (other objects whose nameField IS a formula rely on it).\n  searchableFields: ['name'],\n  highlightFields: ['name', 'crm_account', 'amount', 'stage', 'owner_id'],\n\n  fieldGroups: [\n    { key: 'basic',       label: 'Basic Information',   icon: 'dollar-sign' },\n    { key: 'financials',  label: 'Financials',          icon: 'trending-up' },\n    { key: 'sales_process', label: 'Sales Process',     icon: 'target' },\n    { key: 'qualification', label: 'Qualification',     icon: 'filter' },\n    { key: 'narrative',   label: 'Deal Narrative',      icon: 'book-open' },\n    { key: 'classification', label: 'Classification',   icon: 'tag' },\n    { key: 'campaign', label: 'Campaigns', icon: 'flag', collapse: 'collapsed' },\n    { key: 'notes',       label: 'Notes & Next Steps',  icon: 'file-text' },\n    { key: 'crm_forecast',    label: 'Forecast & Metrics',  icon: 'bar-chart', collapse: 'collapsed' },\n  ],\n\n  fields: {\n    // Platform ownership anchor \u2014 canonical note in `account.object.ts` (#548).\n    owner_id: Field.lookup('sys_user', {\n      label: 'Opportunity Owner',\n      group: 'basic',\n      system: true,\n      readonly: false,\n      trackHistory: true,\n    }),\n\n    // Basic Information\n    name: Field.text({\n      label: 'Opportunity Name',\n      required: true,\n      storage: { notNull: true },\n      searchable: true,\n      group: 'basic',\n    }),\n\n    // (No `display_title` formula \u2014 see `nameField` above: composing the title\n    // from `stage` leaked the raw select value into every rendered title.)\n\n    // Relationships\n    crm_account: Field.lookup('crm_account', {\n      label: 'Account',\n      required: true,\n      storage: { notNull: true },\n      group: 'basic',\n    }),\n\n    primary_contact: Field.lookup('crm_contact', {\n      label: 'Primary Contact',\n      // @objectstack 12: string[] `referenceFilters` is dead (not read by the\n      // picker); `dependsOn` is the live cascading form \u2014 scopes contacts to the\n      // opportunity's `crm_account` (ADR-0049).\n      dependsOn: ['crm_account'],\n      group: 'basic',\n    }),\n\n\n    // Financial Information\n    amount: Field.currency({\n      label: 'Amount',\n      required: true,\n      storage: { notNull: true },\n      min: 0,\n      group: 'financials',\n      trackHistory: true,\n    }),\n\n    expected_revenue: Field.currency({\n      label: 'Expected Revenue',\n      readonly: true,  // Calculated field\n      group: 'financials',\n    }),\n\n    // \u2500\u2500\u2500 Qualification (REQ-0006 step 8) \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n    //\n    // The standard triage vocabulary of a seller that cannot pursue every\n    // deal. `forecast_category` answers a different question \u2014 it is the\n    // forecast roll-up bucket, derived from `stage` \u2014 so none of this is\n    // folded into it. GENERIC values only: a customer's own grading scale is\n    // overlay configuration (REQ-0006 acceptance 5).\n    //\n    // \u26A0\uFE0F `pnpm validate` reports the fields in this block, in the narrative\n    // block below, and the customer-side dates as \"carrier-only \u2014 declared\n    // but nothing in this stack reads or displays it\", and that reading is\n    // EXPECTED here rather than a defect to tidy away. The liveness\n    // diagnostic counts view columns, form sections, page bindings, flow\n    // nodes, formulas, hooks and actions as sites; it does NOT count\n    // `fieldGroups` membership, which is precisely the DERIVED layout\n    // REQ-0006 acceptance 1 asks for. \u26D4 Do NOT answer the warning by\n    // authoring a `record:details` section \u2014 that is the escape hatch\n    // AGENTS.md reserves for a named customer demand, and it would trade\n    // acceptance 1 for a quieter log. `crm_account`'s business-profile block\n    // carries the same verdict on `main` for the same reason (#1948).\n    will_bid: Field.boolean({\n      label: 'Will Bid',\n      description: 'Whether we intend to bid. Unset means the decision is open.',\n      group: 'qualification',\n    }),\n\n    controllability: Field.select({\n      label: 'Controllability',\n      group: 'qualification',\n      options: [\n        { label: 'High', value: 'high' },\n        { label: 'Medium', value: 'medium' },\n        { label: 'Low', value: 'low' },\n      ],\n    }),\n\n    priority: Field.select({\n      label: 'Priority',\n      group: 'qualification',\n      options: [\n        { label: 'High', value: 'high' },\n        { label: 'Medium', value: 'medium' },\n        { label: 'Low', value: 'low' },\n      ],\n    }),\n\n    deal_level: Field.select({\n      label: 'Deal Level',\n      group: 'qualification',\n      options: [\n        { label: 'Strategic', value: 'strategic' },\n        { label: 'Key', value: 'key' },\n        { label: 'Standard', value: 'standard' },\n      ],\n    }),\n\n    // The FACT of subcontracting is generic and belongs in core; the\n    // customer's supplier list is not and is not proposed here.\n    is_subcontracted: Field.boolean({\n      label: 'Involves Subcontracting',\n      defaultValue: false,\n      group: 'qualification',\n    }),\n\n    subcontracting_note: Field.textarea({\n      label: 'Subcontracting Note',\n      group: 'qualification',\n    }),\n\n    // \u2500\u2500\u2500 The \u7ACB\u9879 (qualification) gate: the rep's request \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n    //\n    // REQ-0006 step 11: \u300C\u9500\u552E\u7ACB\u9879\u9700\u8D70\u5BA1\u6279\u6D41\u7A0B\uFF1B\u65B0\u589E\u5546\u673A\u53EF\u8DDF\u8FDB\uFF0C\u7ACB\u9879\u901A\u8FC7\u540E\u65B9\u53EF\u66F4\u65B0\u9636\u6BB5\u3001\n    // \u6295\u6807\u3001\u8D62\u4E22\u5355\u64CD\u4F5C\u3002\u300D The rep ASKS for \u7ACB\u9879 by ticking this box, and\n    // `opportunity_qualification_approval` opens one approval when it turns on\n    // (the TRANSITION, not the current value). A rejection clears it, so\n    // ticking it again is a fresh request \u2014 the role `requested_status` plays\n    // for the status-change gate, as a boolean because \u7ACB\u9879 asks for one thing.\n    //\n    // `defaultValue: false` is load-bearing for the start condition: every deal\n    // born after this column then STORES the key, so `has(previous.\u2026)` holds\n    // on every driver and the off\u2192on transition is visible. Not readonly: this\n    // is the one half of the gate a person writes. Inert while the gate is\n    // off \u2014 nothing reads it unless an install arms the verdict below.\n    qualification_requested: Field.boolean({\n      label: 'Request Qualification Approval',\n      description: 'Tick to send this deal for qualification approval. A rejection clears it; tick it again to ask again.',\n      defaultValue: false,\n      group: 'qualification',\n    }),\n\n    // \u2500\u2500\u2500 The \u7ACB\u9879 gate's switch AND its verdict column \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n    //\n    // \u26A0\uFE0F This `defaultValue` IS the switch, exactly as on\n    // `status_change_approval_status` below, and shipped it is `not_required`:\n    // the gate is OFF by default (REQ-0006 *Disposition*: \"Both gates must be\n    // configurable \u2014 off by default\"). No deal is born `pending`, the flow's\n    // start condition and the `opportunity_lifecycle` refusal are false for\n    // every record that has ever existed, and a stage move, Will Bid and a\n    // direct close work exactly as they do without it. An install ARMS the gate\n    // by changing this one value to `'pending'`; deals that already exist keep\n    // `not_required`, so arming it invalidates no record. \u26D4 Not the flow's\n    // `status` \u2014 `lead-conversion-approval.flow.ts` records why.\n    //\n    // \u26A0\uFE0F Its OWN column \u2014 \u26D4 never `approval_status` (the amount-tiered\n    // flow's; its entry keys on `not_required`, so sharing would re-arm it) and\n    // \u26D4 never `status_change_approval_status` (one gate's verdict would erase\n    // the other's, and the step-14 hook reads that column input-first).\n    //\n    // `readonly: true` on the #1666 grounds: the only writers are the gate's\n    // own `runAs: 'system'` flow and the insert default, and both survive the\n    // readonly strip. A user-supplied verdict is stripped BEFORE the\n    // `beforeUpdate` hooks run \u2014 measured on 17.6.0 with a real ObjectQL: a\n    // user update of `{ stage, qualification_approval_status: 'approved' }`\n    // reached the hooks as `{ id, stage }` and was refused 409 \u2014 so the\n    // input-first read in `opportunity_lifecycle` cannot be fed an `approved`\n    // by hand.\n    qualification_approval_status: Field.select({\n      label: 'Qualification Approval',\n      group: 'qualification',\n      readonly: true,\n      defaultValue: 'not_required',\n      options: [\n        { label: 'Not Required', value: 'not_required', default: true },\n        { label: 'Pending', value: 'pending', color: '#FFA500' },\n        { label: 'Approved', value: 'approved', color: '#00AA00' },\n        { label: 'Rejected', value: 'rejected', color: '#FF0000' },\n      ],\n    }),\n\n    // Sales Process\n    stage: Field.select({\n      label: 'Stage',\n      required: true,\n      storage: { notNull: true },\n      group: 'sales_process',\n      // ADR-0052 \u00A75b.1 \u2014 the platform auto-renders each stage change on the\n      // activity timeline as \"Stage: Proposal \u2192 Negotiation\" (no hook code).\n      trackHistory: true,\n      // Canonical set (#490) \u2014 the mass_update_stage action renders the same\n      // list; see _picklists.ts.\n      options: [...OPPORTUNITY_STAGE_OPTIONS],\n    }),\n\n    probability: Field.percent({\n      label: 'Probability (%)',\n      min: 0,\n      max: 100,\n      defaultValue: 10,\n      group: 'sales_process',\n    }),\n\n    // Important Dates\n    close_date: Field.date({\n      label: 'Close Date',\n      required: true,\n      storage: { notNull: true },\n      group: 'sales_process',\n      trackHistory: true,\n    }),\n\n    // NO `created_date` here: the platform already injects `created_at` on\n    // every object, and this duplicate had no writer at all \u2014 not the seed\n    // data, not a hook, not a flow \u2014 so it was permanently null while\n    // `created_at` carried the real value (#575 B2). Surfaces that need the\n    // creation instant read `created_at` (see the deal_timeline view).\n    //\n    // Stage-age clock (#489). This is the STORED half of the pair: a real,\n    // indexed date column, so it is what automation and views may filter and\n    // sort on. `days_in_stage` below is a formula derived from it.\n    // `opportunity_lifecycle` stamps it on insert and re-stamps it on every\n    // stage change; readonly because nothing but that hook should move it\n    // (before-hook writes survive readonly stripping \u2014 only caller-supplied\n    // keys are dropped).\n    stage_entry_date: Field.date({\n      label: 'Stage Entry Date',\n      description: 'Date this opportunity entered its current stage.',\n      readonly: true,\n      group: 'sales_process',\n    }),\n\n    // \u2500\u2500\u2500 The customer's own procurement calendar (REQ-0006 step 8) \u2500\u2500\u2500\u2500\u2500\n    //\n    // \u26D4 Never folded into `close_date`: that is a single date and it is OUR\n    // expected close. These are three distinct BUYER-side events, and\n    // REQ-0006 acceptance 2 requires them to be reportable independently of\n    // the forecast close date \u2014 see the `tender_this_quarter` list view,\n    // which predicates on `expected_tender_date` alone.\n    customer_initiation_date: Field.date({\n      label: 'Customer Initiation Date',\n      group: 'sales_process',\n    }),\n\n    expected_tender_date: Field.date({\n      label: 'Expected Tender Date',\n      group: 'sales_process',\n    }),\n\n    expected_signing_date: Field.date({\n      label: 'Expected Signing Date',\n      group: 'sales_process',\n    }),\n\n    expected_tender_amount: Field.currency({\n      label: 'Expected Tender Amount',\n      min: 0,\n      group: 'sales_process',\n    }),\n\n    expected_signing_amount: Field.currency({\n      label: 'Expected Signing Amount',\n      min: 0,\n      group: 'sales_process',\n    }),\n\n    // Additional Classification\n    type: Field.select({\n      label: 'Opportunity Type',\n      group: 'classification',\n      options: [\n        { label: 'New Business', value: 'new_business' },\n        { label: 'Existing Customer - Upgrade', value: 'existing_upgrade' },\n        { label: 'Existing Customer - Renewal', value: 'existing_renewal' },\n        { label: 'Existing Customer - Expansion', value: 'existing_expansion' },\n      ]\n    }),\n\n    // \u26D4 BESIDE `type`, never replacing or overloading it: `type`'s four\n    // values are a RELATIONSHIP taxonomy that `opportunity.hook.ts` and\n    // reporting read. Generic delivery-model values only \u2014 the customer's own\n    // line-of-business list is overlay (REQ-0006 acceptance 5).\n    business_line: Field.select({\n      label: 'Business Line',\n      group: 'classification',\n      options: [\n        { label: 'Product', value: 'product' },\n        { label: 'Professional Services', value: 'services' },\n        { label: 'Consulting', value: 'consulting' },\n        { label: 'Support & Maintenance', value: 'support' },\n        { label: 'Other', value: 'other' },\n      ],\n    }),\n\n    lead_source: Field.select({\n      label: 'Lead Source',\n      group: 'classification',\n      // Canonical set shared with Lead + Contact (#490): lead_conversion\n      // copies `leadRecord.lead_source` onto the opportunity it creates, so\n      // this must accept every Lead value.\n      options: [...LEAD_SOURCE_OPTIONS],\n    }),\n\n\n    // Campaign tracking\n    crm_campaign: Field.lookup('crm_campaign', {\n      label: 'Campaign',\n      description: 'Marketing campaign that generated this opportunity',\n      group: 'campaign',\n    }),\n\n    // Sales cycle metrics\n    //\n    // \u26A0\uFE0F FORMULA, not a stored counter. As a plain number column nothing ever\n    // raises it: the hook resets it to 0 on a stage change and no sweep\n    // increments it, so `days_in_stage > 14` matches only rows a seed hardcoded\n    // and the `opportunity_stagnation` flow never fires on real data. Deriving\n    // it from `stage_entry_date` is correct on every read and costs no nightly\n    // full-table pass.\n    //\n    // \u26A0\uFE0F The trade-off: formulas are evaluated AFTER the query (the engine's\n    // `applyFormulaPlan` walks the returned rows), so this is not a real column\n    // and CANNOT appear in a filter or a sort. Anything that needs to *select*\n    // stalled deals predicates on `stage_entry_date` instead \u2014 see\n    // `opportunity-stagnation.flow.ts` and the `stale_opportunities` view.\n    //\n    // \u26A0\uFE0F `has()` + null guard: `daysBetween(null, \u2026)` faults and the whole field\n    // silently evaluates to null, so an unstamped row is spelled out as null\n    // rather than arriving there by accident.\n    days_in_stage: Field.formula({\n      label: 'Days in Current Stage',\n      expression: F`has(record.stage_entry_date) && record.stage_entry_date != null ? daysBetween(record.stage_entry_date, today()) : null`,\n      returnType: 'number',\n      group: 'crm_forecast',\n    }),\n\n    // Additional information\n    description: Field.markdown({\n      label: 'Description',\n      group: 'notes',\n    }),\n\n    next_step: Field.textarea({\n      label: 'Next Steps',\n      group: 'notes',\n    }),\n\n    // \u2500\u2500\u2500 Deal narrative (REQ-0006 step 10) \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n    //\n    // The standard deal-review narrative, split out of `description` so each\n    // part is reviewable, templatable and (later) reportable on its own \u2014\n    // \u26D4 not more prose crammed into one markdown field.\n    //\n    // \u26A0\uFE0F `payment_terms` is PROSE here and a select on `crm_quote` /\n    // `crm_contract`: what a rep records mid-pursuit is the shape of a term\n    // still being negotiated, not the net-terms ladder a signed document\n    // carries. \u26D4 Do not \"unify\" it onto PAYMENT_TERMS_OPTIONS \u2014 that would\n    // force a half-agreed term into a closed vocabulary.\n    //\n    // All four are `Field.textarea` (REQ-0006 names markdown OR textarea per\n    // field). Measured on the 17.6.0 console, the Details tab's edit mode \u2014\n    // the surface these fields render on \u2014 has no markdown editor, so a\n    // markdown field here could be read but never written. The maintainer\n    // ruled textarea for the three that were markdown (2026-10-03, on #1950:\n    // \u300C\u6539\u6210 textarea(\u63A8\u8350)\u300D).\n    customer_background: Field.textarea({\n      label: 'Customer Background',\n      group: 'narrative',\n    }),\n\n    project_background: Field.textarea({\n      label: 'Project Background',\n      group: 'narrative',\n    }),\n\n    risk_analysis: Field.textarea({\n      label: 'Risk Analysis',\n      group: 'narrative',\n    }),\n\n    payment_terms: Field.textarea({\n      label: 'Payment Terms',\n      group: 'narrative',\n    }),\n\n    // Flags\n    is_private: Field.boolean({\n      label: 'Private',\n      defaultValue: false,\n      group: 'crm_forecast',\n    }),\n\n    forecast_category: Field.select({\n      label: 'Forecast Category',\n      group: 'crm_forecast',\n      options: [\n        { label: 'Pipeline', value: 'pipeline' },\n        { label: 'Best Case', value: 'best_case' },\n        { label: 'Commit', value: 'commit' },\n        { label: 'Omitted', value: 'omitted' },\n        { label: 'Closed', value: 'closed' },\n      ]\n    }),\n\n    // Approval workflow tracking.\n    // \u2B50 `readonly: true` \u2014 DECLARED, and the declaration is the honest one\n    // rather than a hopeful one. Audited per writer (#1666): every writer of\n    // this column and of `approved_date` is elevated or an insert.\n    // `opportunity_approval` declares `runAs: 'system'`, and\n    // `opportunity_approval_on_create` inherits it by spreading that flow, so\n    // `resolveRunDataContext` hands the engine `isSystem: true` and the\n    // `if (!opCtx.context?.isSystem)` strip branch is skipped outright; the\n    // `approval` node's own `approvalStatusField` write runs inside those same\n    // system runs; seeds write on INSERT, which the strip never touches. No\n    // view, page or action writes either column. \u21D2 No writer loses its write.\n    // Ruled #1666 (director seat, decision batch #74, 2026-09-07): \"Declared =\n    // enforced\" applies to the audit surface too. \u26D4 The hand-edit escape hatch\n    // \u2014 an admin clearing a stuck approval by typing over the stamp \u2014 is given\n    // up ON PURPOSE: a stuck approval is a platform or flow defect to be fixed\n    // as one, not a reason to keep an audit stamp hand-editable. \u26D4 Do not\n    // reintroduce a bypass, and do not soften either column back to editable\n    // without a new ruling. Both halves are pinned in\n    // `test/audit-stamp-readonly.test.ts`: the system path still lands both\n    // stamps, and a plain user-context UPDATE of either is stripped.\n    // \u26A0\uFE0F `defaultValue` at FIELD level: option-level `default: true`\n    // only preselects in UI forms \u2014 API and flow inserts land null without it,\n    // and a null `approval_status` never matches the flow's entry condition.\n    approval_status: Field.select({\n      label: 'Approval Status',\n      group: 'sales_process',\n      readonly: true,\n      defaultValue: 'not_required',\n      options: [\n        { label: 'Not Required', value: 'not_required', default: true },\n        { label: 'Pending', value: 'pending', color: '#FFA500' },\n        { label: 'Approved', value: 'approved', color: '#00AA00' },\n        { label: 'Rejected', value: 'rejected', color: '#FF0000' },\n      ],\n    }),\n\n    approved_date: Field.datetime({\n      label: 'Approved Date',\n      group: 'sales_process',\n      readonly: true,\n    }),\n\n    // \u2500\u2500\u2500 The status-change gate's switch AND its verdict column \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n    //\n    // \u26A0\uFE0F This `defaultValue` IS the switch, and shipped it is `not_required`,\n    // so the gate is OFF by default \u2014 REQ-0006 acceptance 3: \"with it off\n    // (the default), the existing amount-tiered behaviour of\n    // `opportunity-approval.flow.ts` is bit-for-bit what it is today\". No\n    // record is ever born `pending`, `opportunity_status_change_approval`'s\n    // start condition is false for every row that has ever existed, and\n    // nothing about the amount-tiered flow changes. An install ARMS the gate\n    // by changing this one value to `'pending'`.\n    //\n    // \u26D4 Not the flow's `status`, for the reason\n    // `lead-conversion-approval.flow.ts` records and measured: `draft` still\n    // fires its triggers, and `obsolete` composes with the installation's\n    // activation ledger into a gate no install can ever turn ON.\n    //\n    // \u26A0\uFE0F Deliberately NOT `approval_status`. That column is the amount-tiered\n    // flow's, and sharing it would make either gate's verdict erase the\n    // other's \u2014 and re-trigger the amount flow, whose entry condition keys on\n    // `approval_status == \"not_required\"`.\n    //\n    // `readonly: true` on the same audited grounds as `approval_status`\n    // (#1666): the only writers are the gate's own `runAs: 'system'` flow and\n    // the insert default, and both survive the readonly strip.\n    // What the rep is ASKING for, \u26D4 never the stage itself: REQ-0006\n    // acceptance 3 requires the stage not to move until the request is\n    // decided, and a `record_change` flow binds an AFTER hook \u2014 by the time it\n    // runs, a stage the rep wrote has already moved. So the rep writes the\n    // request here (with the win/loss reason), and the approved decision\n    // writes `stage` \u2014 the customer's own step 14, \u300C\u901A\u8FC7\u540E\u5546\u673A\u72B6\u6001\u6B63\u5F0F\u751F\u6548\u300D.\n    //\n    // Values ARE the two stage values, so the flow's approve branch can apply\n    // it with `stage: '{oppRecord.requested_status}'` and no mapping table can\n    // drift. Not readonly: this is the one half of the gate a person writes.\n    // Inert while the gate is off \u2014 nothing reads it unless the install arms\n    // `status_change_approval_status`.\n    requested_status: Field.select({\n      label: 'Requested Status',\n      group: 'sales_process',\n      options: [\n        { label: 'Won', value: 'closed_won' },\n        { label: 'Lost', value: 'closed_lost' },\n      ],\n    }),\n\n    status_change_approval_status: Field.select({\n      label: 'Status Change Approval',\n      group: 'sales_process',\n      readonly: true,\n      defaultValue: 'not_required',\n      options: [\n        { label: 'Not Required', value: 'not_required', default: true },\n        { label: 'Pending', value: 'pending', color: '#FFA500' },\n        { label: 'Approved', value: 'approved', color: '#00AA00' },\n        { label: 'Rejected', value: 'rejected', color: '#FF0000' },\n      ],\n    }),\n\n    // \u2500\u2500\u2500 Win / Loss analysis \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n    //\n    // \u26D4 The reason is captured AT CLOSE, and that is enforced, not requested.\n    // Leaving both fields optional means every seeded and user-closed deal\n    // lands with them empty and the win/loss widgets below have nothing to draw.\n    //\n    // `requiredWhen`, not a script validation, for the same reason\n    // `crm_lead.duplicate_of_lead` uses it (ADR-0113): \"this field must hold a\n    // value when the record looks like X\" is exactly a conditional write\n    // contract, the engine evaluates it on insert AND update inside\n    // `evaluateValidationRules`, and it reports against the FIELD \u2014 so the form\n    // marks the empty picklist instead of showing a record-level banner. It is\n    // ALSO the only shape the freeze below leaves usable: once a deal is closed,\n    // `opportunity.hook.ts` refuses every user edit outside the narrative\n    // fields, so a reason not captured in the closing write can never be added\n    // afterwards. Close time is the only chance.\n    // `test/win-loss-capture.test.ts` drives both predicates through a real\n    // ObjectQL over a real driver, on insert and on update.\n    //\n    // \u26A0\uFE0F `has(...)` is load-bearing. A bare `record.stage == \"closed_lost\"`\n    // aborts with `No such key` on any merged record that omits the column, and\n    // the engine's answer to a predicate that cannot evaluate is to SKIP it\n    // (\"requiredWhen for 'loss_reason' failed to evaluate \u2014 skipped\"), which\n    // would make this read as enforced while requiring nothing at all.\n    win_reason: Field.select({\n      label: 'Win Reason',\n      description: 'Why this deal was won. Required to close an opportunity as Won.',\n      group: 'classification',\n      requiredWhen: P`has(record.stage) && record.stage == \"closed_won\"`,\n      options: [\n        { label: 'Better Product', value: 'better_product' },\n        { label: 'Better Price', value: 'better_price' },\n        { label: 'Existing Relationship', value: 'relationship' },\n        { label: 'Better Support', value: 'better_support' },\n        { label: 'Best Fit / Features', value: 'best_fit' },\n        // Written by the machine, not chosen by a rep: `quote_on_accepted`\n        // (quote.hook.ts) wins the deal the moment a customer accepts the\n        // quote, and no human is in that write to attribute it. Naming the\n        // automated path is this repo's existing idiom for exactly that split\n        // (`crm_lead.duplicate_status` = machine `suspected` vs human\n        // `confirmed`) and it keeps the rule exception-free: every closed_won\n        // row carries a reason, and an analyst can still tell a CPQ close from\n        // a rep's attribution instead of reading a fabricated \"Better Product\".\n        { label: 'Quote Accepted', value: 'quote_accepted' },\n        { label: 'Other', value: 'other' },\n      ],\n    }),\n\n    loss_reason: Field.select({\n      label: 'Loss Reason',\n      description: 'Why this deal was lost. Required to close an opportunity as Lost.',\n      group: 'classification',\n      requiredWhen: P`has(record.stage) && record.stage == \"closed_lost\"`,\n      options: [\n        { label: 'Price Too High', value: 'price' },\n        { label: 'Lost to Competitor', value: 'competitor' },\n        { label: 'No Budget', value: 'no_budget' },\n        { label: 'No Decision', value: 'no_decision' },\n        { label: 'Bad Timing', value: 'timing' },\n        { label: 'Missing Features', value: 'features' },\n        { label: 'Other', value: 'other' },\n      ],\n    }),\n\n    loss_details: Field.textarea({\n      label: 'Loss/Win Details',\n      description: 'Free-text context behind the win or loss reason.',\n      group: 'classification',\n    }),\n  },\n  \n  // Database indexes for performance\n  indexes: [\n    { fields: ['name'] },\n    { fields: ['crm_account'] },\n    { fields: ['owner_id'] },\n    { fields: ['stage'] },\n    { fields: ['close_date'] },\n    // The stagnation sweep filters on this every morning.\n    { fields: ['stage_entry_date'] },\n  ],\n  \n  // Enable advanced features\n  //\n  // Stage/amount history is tracked per-field via `Field.trackHistory`\n  // (ADR-0052). \u26A0\uFE0F Ownership is NOT: it lives on the platform's injected\n  // `owner_id`, which carries no `trackHistory` flag \u2014 a transfer is recorded\n  // in the compliance audit log (`sys_audit_log`, unconditional) rather than on\n  // the activity feed.\n  enable: {\n    apiEnabled: true,\n    apiMethods: ['get', 'list', 'create', 'update', 'delete'], // Whitelist allowed API operations\n    // #602 \u2014 proposals, redlines and signed orders belong on the deal.\n    // See the canonical capability note in `src/sales/objects/index.ts`.\n    files: true,\n  },\n\n  // ADR-0052 \u00A75b.2 \u2014 declarative milestone activity. When `stage` enters these\n  // values the platform emits a semantic timeline entry (no hook code).\n  // Combined with the field-level `trackHistory` above (stage-change rows) this\n  // replaces any hand-coded activity hook.\n  activityMilestones: [\n    { field: 'stage', value: 'closed_won', summary: 'Deal won \u2014 {name}', type: 'completed' },\n    { field: 'stage', value: 'closed_lost', summary: 'Deal lost \u2014 {name}', type: 'completed' },\n  ],\n\n  // Removed: list_views and form_views belong in UI configuration, not object definition\n  \n  // Lifecycle transitions are enforced via a `state_machine` validation rule\n  // (see validations[] below). \u26A0\uFE0F There is no top-level `stateMachines` key on\n  // the platform \u2014 status state machines live in the validation union.\n\n  // Validation Rules\n  //\n  // Predicates below are TOTAL: every `record.x` read is `has()`-guarded, so the\n  // rule returns a verdict even when the merged record has no such key. See\n  // AGENTS.md \"Validation predicates must be TOTAL\" and\n  // test/object-validation-predicates.test.ts, which fails the build otherwise.\n  validations: [\n    {\n      name: 'close_date_future',\n      type: 'script',\n      severity: 'warning',\n      message: 'Close date should not be in the past unless opportunity is closed',\n      // An absent `stage` key means \"no stage recorded\", which is not a closed\n      // stage \u2014 hence `!has(record.stage) || (\u2026)` rather than a leading\n      // `has(record.stage) &&`, which would suppress the warning instead.\n      condition: P`has(record.close_date) && record.close_date != null && record.close_date < today() && (!has(record.stage) || (record.stage != \"closed_won\" && record.stage != \"closed_lost\"))`,\n    },\n    {\n      name: 'amount_positive',\n      type: 'script',\n      severity: 'error',\n      message: 'Amount must be greater than zero',\n      condition: P`has(record.amount) && record.amount != null && record.amount <= 0`,\n    },\n    {\n      name: 'opportunity_stage_progression',\n      type: 'state_machine',\n      severity: 'warning',\n      message: 'Invalid opportunity stage transition',\n      field: 'stage',\n      transitions: {\n        // `\u2192 proposal` is legal from every pre-proposal stage: the\n        // quote_generation flow fast-forwards the deal to `proposal` when a\n        // quote is generated, which can happen at any open stage.\n        prospecting: ['qualification', 'proposal', 'closed_lost'],\n        qualification: ['needs_analysis', 'proposal', 'closed_lost'],\n        needs_analysis: ['proposal', 'closed_lost'],\n        // `proposal \u2192 closed_won` is legal: the quote_on_accepted hook closes\n        // the linked deal directly from the CPQ path (quote_generation parks\n        // the opportunity at `proposal`; an accepted quote wins it without a\n        // separate negotiation step).\n        proposal: ['negotiation', 'closed_won', 'closed_lost'],\n        negotiation: ['closed_won', 'closed_lost'],\n        closed_won: [],\n        closed_lost: [],\n      },\n    },\n  ],\n  \n  // \u26A0\uFE0F `probability` and `expected_revenue` are NOT computed declaratively.\n  // They are derived in `opportunity.hook.ts` (single source of truth =\n  // stage \u2192 STAGE_PROBABILITY); keeping the math in one place avoids drift\n  // between a declarative CASE() table and the hook's lookup table.\n  //\n  // \u26A0\uFE0F No `workflows[]` here, and none is possible: object `workflows[]` were\n  // removed from the platform. Field updates live in this object's `*.hook.ts`;\n  // scheduled status flips and notifications live in `src/*/flows/*.flow.ts`.\n});\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/sales/objects/task.object.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/sales/objects\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/sales/objects/task.object.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport { ObjectSchema, Field } from '@objectstack/spec/data';\nimport { P } from '@objectstack/spec';\nimport { TASK_TYPE_OPTIONS } from './_picklists';\n\nexport const Task = ObjectSchema.create({\n  name: 'crm_task',\n  label: 'Task',\n  pluralLabel: 'Tasks',\n  icon: 'check-square',\n  description: 'Activities and to-do items',\n\n  // ADR-0090 D1/D7: OWD is an authored decision. Personal activity records.\n  sharingModel: 'private',\n\n  // Every other business object with a detail page groups its fields; task was\n  // one of the two that did not, so its detail page fell back to one flat grid\n  // where the five polymorphic `related_to_*` lookups and the recurrence\n  // machinery sat inline with the subject. The keys mirror the sections the\n  // task form already uses (Task / Related Records / Recurrence & Effort) so\n  // the two surfaces agree.\n  fieldGroups: [\n    { key: 'basic',      label: 'Task Information', icon: 'info' },\n    { key: 'scheduling', label: 'Scheduling',       icon: 'calendar' },\n    // No 'assignment' group: the assignee (`owner_id`) was its only member, and\n    // the synthesized detail page hoists it into the highlight strip \u2014 so the\n    // group rendered on forms and never on detail pages\n    // (`field-group-shadowed`). It lives in `basic` alongside\n    // subject/status/priority instead.\n    { key: 'related',    label: 'Related Records',  icon: 'link' },\n    { key: 'recurrence', label: 'Recurrence',       icon: 'refresh-ccw', collapse: 'collapsed' },\n    { key: 'effort',     label: 'Progress & Effort', icon: 'activity',   collapse: 'collapsed' },\n    { key: 'system',     label: 'System',           icon: 'database',    collapse: 'collapsed' },\n  ],\n\n  fields: {\n    // Platform ownership anchor \u2014 canonical note in `account.object.ts` (#548).\n    owner_id: Field.lookup('sys_user', {\n      label: 'Assigned To',\n      group: 'basic',\n      system: true,\n      readonly: false,\n      trackHistory: true,\n    }),\n\n    // Task Information\n    subject: Field.text({\n      group: 'basic',\n      label: 'Subject',\n      required: true,\n      storage: { notNull: true },\n      searchable: true,\n      maxLength: 255,\n    }),\n    \n    description: Field.markdown({\n      group: 'basic',\n      label: 'Description',\n    }),\n    \n    // Task Management\n    status: Field.select({\n      group: 'basic',\n      label: 'Status',\n      required: true,\n      storage: { notNull: true },\n      trackHistory: true,\n      // Field-level default, not just the option flag: the option `default`\n      // only preselects in some form surfaces, so a quick-create modal opened\n      // from a related list left this required field blank and the rep had to\n      // pick \"Not Started\" by hand every time.\n      defaultValue: 'not_started',\n      options: [\n        { label: 'Not Started', value: 'not_started', color: '#808080', default: true },\n        { label: 'In Progress', value: 'in_progress', color: '#FFA500' },\n        { label: 'Waiting', value: 'waiting', color: '#FFD700' },\n        { label: 'Completed', value: 'completed', color: '#00AA00' },\n        { label: 'Deferred', value: 'deferred', color: '#999999' },\n      ]\n    }),\n\n    priority: Field.select({\n      group: 'basic',\n      label: 'Priority',\n      required: true,\n      storage: { notNull: true },\n      trackHistory: true,\n      // `normal` is the default rather than `low`: a rep filing a to-do has\n      // made no priority judgement, and defaulting everything to Low made the\n      // field meaningless (nothing ever sorted above the noise).\n      defaultValue: 'normal',\n      options: [\n        { label: 'Low', value: 'low', color: '#4169E1' },\n        { label: 'Normal', value: 'normal', color: '#00AA00', default: true },\n        { label: 'High', value: 'high', color: '#FFA500' },\n        { label: 'Urgent', value: 'urgent', color: '#FF0000' },\n      ]\n    }),\n\n    // Sortable ordinal for `priority` \u2014 see crm_case.priority_rank. Sorting on\n    // the select itself compares raw strings (normal > low > high > urgent),\n    // which pushes urgent work to the bottom of the to-do queue.\n    //\n    // `0` is the UNRANKED sentinel, identical to crm_case.priority_rank. \u26D4 It\n    // must stay identical on both: a differing sentinel orders the same unknown\n    // priority differently on the two objects, and `2` here would make an\n    // unranked task indistinguishable from a genuine `normal`.\n    priority_rank: Field.number({\n      label: 'Priority Rank',\n      readonly: true,\n      defaultValue: 0,\n    }),\n\n    type: Field.select({\n      group: 'basic',\n      label: 'Task Type',\n      // Canonical set (#490) \u2014 the schedule_followup screen renders the same\n      // list; see _picklists.ts.\n      options: [...TASK_TYPE_OPTIONS],\n    }),\n    \n    // Dates\n    due_date: Field.date({\n      group: 'scheduling',\n      label: 'Due Date',\n    }),\n    \n    reminder_date: Field.datetime({\n      group: 'scheduling',\n      label: 'Reminder Date/Time',\n    }),\n    \n    completed_date: Field.datetime({\n      group: 'scheduling',\n      label: 'Completed Date',\n      readonly: true,\n    }),\n    \n    // Related To (Polymorphic relationship - can link to multiple object types)\n    related_to_type: Field.select({\n      group: 'related',\n      label: 'Related To Type',\n      options: [\n        { label: 'Account', value: 'crm_account' },\n        { label: 'Contact', value: 'crm_contact' },\n        { label: 'Opportunity', value: 'crm_opportunity' },\n        { label: 'Lead', value: 'crm_lead' },\n        { label: 'Case', value: 'crm_case' },\n      ]\n    }),\n    \n    related_to_account: Field.lookup('crm_account', {\n      group: 'related',\n      label: 'Related Account',\n    }),\n    \n    related_to_contact: Field.lookup('crm_contact', {\n      group: 'related',\n      label: 'Related Contact',\n    }),\n    \n    related_to_opportunity: Field.lookup('crm_opportunity', {\n      group: 'related',\n      label: 'Related Opportunity',\n    }),\n    \n    related_to_lead: Field.lookup('crm_lead', {\n      group: 'related',\n      label: 'Related Lead',\n    }),\n    \n    related_to_case: Field.lookup('crm_case', {\n      group: 'related',\n      label: 'Related Case',\n    }),\n    \n    // Recurrence (for recurring tasks)\n    is_recurring: Field.boolean({\n      group: 'recurrence',\n      label: 'Recurring Task',\n      defaultValue: false,\n    }),\n    \n    recurrence_type: Field.select({\n      group: 'recurrence',\n      label: 'Recurrence Type',\n      options: [\n        { label: 'Daily', value: 'daily' },\n        { label: 'Weekly', value: 'weekly' },\n        { label: 'Monthly', value: 'monthly' },\n        { label: 'Yearly', value: 'yearly' },\n      ]\n    }),\n    \n    recurrence_interval: Field.number({\n      group: 'recurrence',\n      label: 'Recurrence Interval',\n      defaultValue: 1,\n      min: 1,\n    }),\n    \n    recurrence_end_date: Field.date({\n      group: 'recurrence',\n      label: 'Recurrence End Date',\n    }),\n    \n    // Flags\n    is_completed: Field.boolean({\n      group: 'system',\n      label: 'Is Completed',\n      defaultValue: false,\n      readonly: true,\n    }),\n    \n    is_overdue: Field.boolean({\n      group: 'system',\n      label: 'Is Overdue',\n      defaultValue: false,\n      readonly: true,\n    }),\n\n    // Set by the `task_due_reminder` schedule flow once a reminder has fired\n    // (the sweep de-dups on `reminder_date`, which it clears; this flag is the\n    // audit trail), and defaulted to `false` by `task.hook.ts` on insert.\n    //\n    // NOT readonly \u2014 but the old reason here (\"16.x drops flow writes to\n    // readonly fields\") does not survive measurement. Taken on 17.1.0,\n    // RE-TAKEN on 17.2.0 (#1460) and RE-CONFIRMED on 17.3.0 (#1676) \u2014 the pin\n    // at each of those takings; not re-taken on 17.4.0 (PR #1814, #1807) or\n    // 17.5.0 \u2014 same verdict all three times: `task_due_reminder`\n    // declares `runAs: 'system'`, so its write WOULD survive a\n    // `readonly: true`.\n    //\n    // \u26A0\uFE0F The other half of that reason EXPIRED at 17.4.0 and is \u26D4 NOT\n    // renumbered here: \"the insert path is exempt from the strip\" held through\n    // 17.3.0 and was reversed as a declared BREAKING change \u2014 the retirement\n    // is recorded in the INSERT-path section of\n    // `test/readonly-write-semantics.test.ts` (#1429) and in\n    // `campaign_member.object.ts`. Neither half moves this field, which is not\n    // `readonly` at all. Left writable as-is; flipping it is a separate\n    // decision, not a comment fix.\n    reminder_sent: Field.boolean({\n      group: 'system',\n      label: 'Reminder Sent',\n      defaultValue: false,\n    }),\n\n    // Progress\n    progress_percent: Field.percent({\n      group: 'effort',\n      label: 'Progress (%)',\n      min: 0,\n      max: 100,\n      defaultValue: 0,\n    }),\n    \n    // No time tracking. `estimated_hours` / `actual_hours` were declared and\n    // inert: no rollup summed them onto a case or an opportunity, no variance\n    // report compared them, and nothing warned when actual overran estimate.\n    // Effort on a task is `progress_percent`, which the task views do read.\n  },\n  \n  // API surface. History \u2192 Field.trackHistory (ADR-0052).\n  enable: {\n    apiEnabled: true,\n  },\n  \n  // Database indexes for performance\n  indexes: [\n    { fields: ['status'] },\n    { fields: ['priority'] },\n    { fields: ['owner_id'] },\n    { fields: ['due_date'] },\n  ],\n  \n  // ADR-0079: render-only `titleFormat` retired in favor of `nameField`,\n  // which names the real field holding the record title (here: `subject`).\n  nameField: 'subject',\n  highlightFields: ['subject', 'status', 'priority', 'due_date', 'owner_id'],\n  \n  // Removed: list_views and form_views belong in UI configuration, not object definition\n  \n  // Predicates below are TOTAL: every `record.x` read is `has()`-guarded, so the\n  // rule returns a verdict even when the merged record has no such key. See\n  // AGENTS.md \"Validation predicates must be TOTAL\" and\n  // test/object-validation-predicates.test.ts, which fails the build otherwise.\n  validations: [\n    {\n      name: 'completed_date_required',\n      type: 'script',\n      severity: 'error',\n      message: 'Completed date is required when status is Completed',\n      condition: P`has(record.status) && record.status == \"completed\" && (!has(record.completed_date) || isBlank(record.completed_date))`,\n    },\n    {\n      name: 'recurrence_fields_required',\n      type: 'script',\n      severity: 'error',\n      message: 'Recurrence type is required for recurring tasks',\n      condition: P`has(record.is_recurring) && record.is_recurring == true && (!has(record.recurrence_type) || isBlank(record.recurrence_type))`,\n    },\n    {\n      name: 'related_to_required',\n      type: 'script',\n      severity: 'warning',\n      message: 'At least one related record should be selected',\n      condition: P`(!has(record.related_to_account) || isBlank(record.related_to_account)) && (!has(record.related_to_contact) || isBlank(record.related_to_contact)) && (!has(record.related_to_opportunity) || isBlank(record.related_to_opportunity)) && (!has(record.related_to_lead) || isBlank(record.related_to_lead)) && (!has(record.related_to_case) || isBlank(record.related_to_case))`,\n    },\n  ],\n  \n  // \u26A0\uFE0F No `workflows[]` here, and none is possible: object `workflows[]` were\n  // removed from the platform. Field updates live in this object's `*.hook.ts`;\n  // scheduled status flips and notifications live in `src/*/flows/*.flow.ts`.\n});\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/sales/actions/activity-actions.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/sales/actions\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/sales/actions/activity-actions.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport type { Action } from '@objectstack/spec/ui';\nimport * as salesObjects from '../objects';\n\n/**\n * Activity-logging actions \u2014 `log_call`, `log_meeting`, `schedule_meeting`.\n *\n * (It was `src/actions/global.actions.ts` until the ADR-0130 layout: nothing\n * here is a *global* action, and nothing can be \u2014 see the dispatcher note on\n * `objectName` below. The name now says what it builds.)\n *\n * # Why the factory lives in the SALES package\n *\n * Four of the five host objects \u2014 `crm_lead`, `crm_contact`, `crm_account`,\n * `crm_opportunity` \u2014 are sales', as is the `crm_event` every action writes.\n * The fifth, `crm_case`, is service's, and under plan item 7 a source more than\n * one package needs takes the lowest package all its consumers depend on. So\n * the factory is here and `src/service/actions/case-activity.actions.ts`\n * instantiates the case triple from it along the service -> sales edge. One\n * copy, never two.\n *\n * # The two rules this family exists to hold\n *\n *  1. **Scope.** The actions are GENERATED per object: one registered action\n *     per (kind \u00D7 object). \u26D4 Never pin an activity action to a single object,\n *     and never author one without an `objectName` \u2014 the runtime keys the\n *     registry on `<objectName>:<action.name>` and the dispatcher probes\n *     `<objectName>` first, so a single-object action is unreachable from every\n *     other object a rep sells to, and an object-less one is unreachable\n *     everywhere.\n *  2. **Shape.** Each of these actions inserts a real `crm_event`, real\n *     `crm_event_attendee` rows, and keeps the `sys_activity` row purely as the\n *     unified-timeline pointer (ADR-0052 `source_object` / `source_id`), the\n *     same way `send_email` points at its `sys_email`. \u26D4 Never move that\n *     structure back into a `metadata` JSON blob: a blob is not data \u2014 no view\n *     filters it, no dataset groups by it, no report counts it.\n *\n * # Live platform workaround\n *\n * `schedule_meeting` collects its start as a `date` + `time` PAIR rather than\n * as one `datetime` param, because a `datetime` action param cannot be\n * submitted from the Console at all (objectstack-ai/objectstack#5061). Both the\n * body and the param list carry the full reasoning and the revert instruction.\n *\n * The recency bubble (`crm_account.last_activity_date`,\n * `crm_lead.last_contacted_date`, `crm_contact.last_contacted_date`) is\n * deliberately NOT written here. It hangs off `crm_event`'s own hook, so an\n * event created from the calendar, from an import, or from a future flow bumps\n * recency exactly like one created from this button. One writer, not one per\n * entry point.\n */\n\n/**\n * `objectName` \u2192 the object's DECLARED `nameField`, derived from the object\n * definitions rather than hand-listed.\n *\n * \u26D4 Never stamp `record_label` from `ctx.record?.name`: `name` is not the\n * display field on almost anything here \u2014 most objects declare a different\n * `nameField` (`display_title`, `full_name`, `subject`, `contract_number`, \u2026)\n * and have no `name` column at all, so the label lands `null`.\n *\n * Deriving the map keeps it correct when an object retargets its `nameField`.\n * The lookup happens at AUTHORING time (each action knows its own object), so\n * the body carries the resolved field name rather than a table it could miss\n * on.\n *\n * The object definitions are passed IN rather than imported here, because the\n * five host objects no longer live in one directory: `crm_case` is service's.\n * A package hands {@link activityActionsFor} its own object barrel, so the map\n * is still derived from the real definition of the object being bound and no\n * package reaches into another's.\n */\ntype NameFieldSource = { name?: unknown; nameField?: unknown };\n\nconst nameFieldMap = (objectDefs: Record<string, NameFieldSource>): Record<string, string> =>\n  Object.fromEntries(\n    Object.values(objectDefs)\n      .filter(\n        (o): o is { name: string; nameField: string } =>\n          typeof o?.name === 'string' && typeof o?.nameField === 'string',\n      )\n      .map((o) => [o.name, o.nameField]),\n  );\n\n/**\n * The objects a rep can log an interaction against, and the `crm_event`\n * lookup that records the link.\n *\n * The keys are exactly `crm_event.related_to_type`'s options\n * (`RELATED_TO_TYPE_OPTIONS`), and the values exactly the `related_to_*`\n * lookups that back them. `test/activity-actions.test.ts` pins that agreement\n * against the object definition, so adding a sixth `related_to_*` field\n * without extending this map fails in CI instead of producing an action that\n * writes an event linked to nothing.\n */\nexport const ACTIVITY_TARGETS: Record<string, string> = {\n  crm_lead: 'related_to_lead',\n  crm_contact: 'related_to_contact',\n  crm_account: 'related_to_account',\n  crm_opportunity: 'related_to_opportunity',\n  crm_case: 'related_to_case',\n};\n\n/** JS string literal, safely quoted for splicing into a body source. */\nconst lit = (value: string): string => JSON.stringify(value);\n\n/**\n * The acting user's display name, as action-body SOURCE TEXT.\n *\n * Shared verbatim by every body that writes `sys_activity.actor_name`: the\n * activity family below and `send_email` in `contact.actions.ts`.\n *\n * # Why a string and not a function\n *\n * An action body is shipped BODY-ONLY and evaluated in a QuickJS sandbox with\n * no module scope, so a shared helper called from a body is not a closure at\n * runtime \u2014 it is a `ReferenceError` (`test/helpers/action-sandbox.ts` states\n * the same constraint for the shared line-item price fill). A string spliced at\n * AUTHORING time, while Node builds the metadata, has no such problem: what\n * reaches the sandbox is one self-contained body with this text inlined,\n * exactly as if it had been typed there. `test/action-sandbox.test.ts` executes\n * both bodies under the real runner AND pins that both still contain this\n * constant, so the two call sites cannot drift into disagreeing.\n *\n * # Contract for a splice site\n *\n * Splice into a body that has already declared `userId` (`ctx.user?.id ?? null`)\n * and whose action declares `api.read`. Afterwards `actorName` holds a\n * non-blank display name \u2014 the id only as a last resort, never `null`.\n */\nexport const ACTOR_NAME_RESOLUTION_SOURCE = `// The acting user's DISPLAY name, for the sys_activity row (#673 / #678).\n      //\n      // PLATFORM WORKAROUND. \\`ctx.user.name\\` is not a display name on the\n      // dispatch path the Console uses: the REST action dispatcher builds the\n      // body's user as \\`{ id: ec.userId, name: ec.userId, \u2026 }\\` \u2014 the key is\n      // present and carries the raw id, so \\`ctx.user?.name\\` reads as a\n      // plausible string and silently wrote ids like\n      // \"grDEyLoIgnunJ2M7Y2muLgcuQbDUT0s2\" into \\`sys_activity.actor_name\\`\n      // (@objectstack/runtime 17.0.0-rc.2, dist/index.js:5397-5399). The MCP\n      // dispatcher does try a display name first\n      // (\\`ec.userName ?? ec.userDisplayName ?? ec.userId\\`, dist/index.js:1776)\n      // but nothing in the installed platform ever populates either field, so\n      // it falls back to the id too.\n      //\n      // So the name is resolved HERE, from \\`sys_user.name\\` (the column the\n      // platform itself treats as the profile display name), with the id kept\n      // as the last resort \u2014 an opaque id is bad, a blank actor is worse.\n      // A name that differs from the id is taken as already-resolved, which is\n      // what makes this one query and not a query per activity write.\n      //\n      // DELETE THIS once the platform delivers a display name on ctx.user.name\n      // for REST-dispatched action bodies: every splice site collapses back to\n      // \\`actor_name: ctx.user?.name\\` (objectstack-ai/objectstack#5372).\n      const ctxName = ctx.user?.name ? String(ctx.user.name).trim() : '';\n      let actorName = ctxName && ctxName !== userId ? ctxName : '';\n      if (!actorName && userId) {\n        try {\n          const found = await ctx.api.object('sys_user').find({\n            where: { id: userId },\n            fields: ['name'],\n            top: 1,\n          });\n          const users = Array.isArray(found) ? found : (found?.records ?? []);\n          const resolved = users.length && users[0].name ? String(users[0].name).trim() : '';\n          if (resolved) actorName = resolved;\n        } catch (e) {\n          // A denied or unavailable sys_user read must not fail the log \u2014 the\n          // interaction the rep just recorded matters more than its label.\n        }\n      }\n      if (!actorName) actorName = userId;`;\n\n/**\n * The authored difference between one activity action and the next.\n *\n * Everything the variants share lives in {@link activityAction}; this type is\n * the complete list of what a variant is still allowed to differ on. \u26D4 Never\n * hand-copy one variant into another: `log_call` and `log_meeting` were\n * near-verbatim copies once \u2014 identical bodies apart from a summary prefix and\n * a metadata key \u2014 and drifted into disagreeing about whether `duration` is\n * required.\n */\ntype ActivitySpec = {\n  name: string;\n  label: string;\n  icon: string;\n  /** `crm_event.type` for the row this action writes. */\n  eventType: string;\n  /** `crm_event.status`: `held` for something that happened, `planned` for a booking. */\n  eventStatus: 'held' | 'planned';\n  /** Stamped in front of the activity summary; `''` for calls. */\n  summaryPrefix: string;\n  /** Subject used when the user submits the form with the field blank. */\n  defaultSubject: string;\n  subjectLabel: string;\n  notesLabel: string;\n  /** Booked-in-the-future variants collect a start date + wall clock and a location. */\n  collectsSchedule?: boolean;\n  successMessage: string;\n};\n\n/**\n * Build one activity action, bound to one object.\n *\n * `duration` is OPTIONAL everywhere. It was `required: true` for calls and\n * `required: false` for meetings with nothing documenting the split; optional\n * is the direction that keeps every form submittable, and it is the one the\n * body is written for.\n */\nfunction activityAction(spec: ActivitySpec, objectName: string, nameField: string): Action {\n  const relatedField = ACTIVITY_TARGETS[objectName];\n  if (!relatedField) {\n    throw new Error(\n      `activityAction: '${objectName}' is not an activity target \u2014 extend ACTIVITY_TARGETS ` +\n        'together with crm_event.related_to_type and its related_to_* lookup.',\n    );\n  }\n  return {\n    name: spec.name,\n    label: spec.label,\n    // Object-scoped, one registration per object. The runtime registers a body\n    // action under `<objectName>:<name>` and the dispatcher probes\n    // `<objectName>` then `*`; a body action with no objectName lands under a\n    // 'global' key nothing ever probes (\"Action 'log_call' on object '*' not\n    // found\", verified 2026-07-28). \u26D4 Never author an object-less body action.\n    objectName,\n    icon: spec.icon,\n    // script, not modal: modal submits die on GET /api/v1/meta/object/<target>\n    // \u2192 400 in 16.1.0; script actions POST /api/v1/actions/... and execute.\n    type: 'script',\n    body: {\n      language: 'js',\n      source: `\n      const OBJECT_NAME = ${lit(objectName)};\n      const RELATED_FIELD = ${lit(relatedField)};\n      const NAME_FIELD = ${lit(nameField)};\n      const EVENT_TYPE = ${lit(spec.eventType)};\n      const EVENT_STATUS = ${lit(spec.eventStatus)};\n\n      const record = ctx.record ?? {};\n      const recordId = ctx.recordId ?? record.id ?? null;\n      const userId = ctx.user?.id ?? null;\n      const nowIso = new Date().toISOString();\n\n      ${ACTOR_NAME_RESOLUTION_SOURCE}\n\n      const subject = input.subject ? String(input.subject) : ${lit(spec.defaultSubject)};\n      const duration = input.duration ? Number(input.duration) : 0;\n      const notes = input.notes ? String(input.notes) : '';\n      const location = input.location ? String(input.location) : '';\n\n      // A booking states its own start; a log is \"just now\".\n      //\n      // WORKAROUND for objectstack-ai/objectstack#5061 \u2014 the start is collected\n      // as a CALENDAR DAY + a WALL CLOCK (\\`start_date\\` / \\`start_time\\`) and\n      // joined here, instead of as one \\`type: 'datetime'\\` param. A datetime\n      // param is unusable from the Console: it renders as a zone-less\n      // \\`<input type=\"datetime-local\">\\` and POSTs the raw value\n      // (\"2026-08-10T15:00\"), which the runtime's action-param validator rejects\n      // with 400 \"expected an ISO-8601 instant with explicit zone\" \u2014 no user\n      // input can pass. \\`date\\` and \\`time\\` are the two param types whose\n      // renderer output (\"YYYY-MM-DD\" / \"HH:MM\") the validator accepts verbatim,\n      // so the pair is submittable where the single datetime never was.\n      //\n      // TIMEZONE: the wall clock is interpreted as **UTC**, and both param\n      // labels say so. UTC is the only zone this body can apply deterministically\n      // \u2014 the sandbox context carries no user or org timezone (\\`ctx.user\\` is\n      // id/name/email), and reading the server's local zone would make the same\n      // input mean different instants on different hosts and in tests. Everything\n      // else this app writes is likewise a UTC instant (\\`new Date().toISOString()\\`).\n      //\n      // When #5061 lands (the Console serializing datetime-local in the\n      // browser's zone), this reverts to ONE \\`type: 'datetime'\\` param and the\n      // zone becomes the user's own \u2014 see \\`collectsSchedule\\` in this file.\n      let startIso = nowIso;\n      const startDate = input.start_date ? String(input.start_date).trim() : '';\n      if (startDate) {\n        const startTime = input.start_time ? String(input.start_time).trim() : '00:00';\n        // 'HH:MM' and 'HH:MM:SS' are both shapes the validator lets through.\n        const clock = startTime.length === 5 ? startTime + ':00' : startTime;\n        const parsed = new Date(startDate + 'T' + clock + '.000Z');\n        // An unparseable value falls back to now rather than writing NaN into a\n        // required column.\n        if (!isNaN(parsed.getTime())) startIso = parsed.toISOString();\n      }\n\n      // 1. the interaction itself, as a queryable record.\n      const eventDoc = {\n        subject: subject,\n        type: EVENT_TYPE,\n        status: EVENT_STATUS,\n        start_datetime: startIso,\n        // Load-bearing, not decoration: an action body executes with\n        // isSystem: true (runtime buildActionExecutionContext), which\n        // short-circuits the security middleware \u2014 so the insert-time\n        // auto-stamp of owner_id never fires here. Omitting it would land the\n        // interaction ownerless, i.e. invisible in \"My \u2026\" and uneditable under\n        // a private OWD (#548, the #622 failure mode).\n        owner_id: userId,\n        related_to_type: OBJECT_NAME,\n      };\n      if (duration > 0) eventDoc.duration_minutes = duration;\n      if (location) eventDoc.location = location;\n      if (notes) eventDoc.description = notes;\n      if (recordId) eventDoc[RELATED_FIELD] = recordId;\n      const event = await ctx.api.object('crm_event').insert(eventDoc);\n      const eventId = event?.id ?? null;\n\n      // 2. attendees, as rows \u2014 the point of #592.\n      // A multi-lookup param may arrive as an array or, on a surface that\n      // renders it single-valued, as one scalar. Normalising both is not a\n      // lenient parse of authored metadata: it is the console's own input\n      // shape, which this body does not control.\n      const toList = (v) => {\n        if (v === null || v === undefined || v === '') return [];\n        return Array.isArray(v) ? v : [v];\n      };\n      const attendees = [];\n      if (userId) {\n        attendees.push({ attendee_type: 'user', sys_user: userId, is_organizer: true, response: 'accepted' });\n      }\n      // The record the action was fired from IS an attendee when it is a\n      // person. On an account / opportunity / case it is not, so nothing is\n      // invented for it \u2014 the event's related_to_* link already records it.\n      if (OBJECT_NAME === 'crm_contact' && recordId) {\n        attendees.push({ attendee_type: 'contact', crm_contact: recordId, response: 'no_response' });\n      }\n      if (OBJECT_NAME === 'crm_lead' && recordId) {\n        attendees.push({ attendee_type: 'lead', crm_lead: recordId, response: 'no_response' });\n      }\n      for (const c of toList(input.attendee_contacts)) {\n        attendees.push({ attendee_type: 'contact', crm_contact: String(c), response: 'no_response' });\n      }\n      for (const u of toList(input.attendee_users)) {\n        attendees.push({ attendee_type: 'user', sys_user: String(u), response: 'no_response' });\n      }\n\n      const seen = {};\n      const attendeeIds = [];\n      for (const a of attendees) {\n        const who = a.sys_user ?? a.crm_contact ?? a.crm_lead ?? '';\n        const key = a.attendee_type + ':' + who;\n        if (seen[key]) continue;\n        seen[key] = true;\n        const doc = Object.assign({}, a, { crm_event: eventId, invited_date: nowIso });\n        const row = await ctx.api.object('crm_event_attendee').insert(doc);\n        if (row?.id) attendeeIds.push(row.id);\n      }\n\n      // 3. the unified-timeline pointer.\n      // \\`metadata\\` no longer carries the attendee list: it is a display hint\n      // beside a real record now, not the record itself. ADR-0052\n      // source_object/source_id is the queryable drill to the crm_event row.\n      const summary = duration ? subject + ' (' + duration + ' min)' : subject;\n      const activity = await ctx.api.object('sys_activity').insert({\n        type: EVENT_STATUS === 'held' ? 'completed' : 'scheduled',\n        summary: ${lit(spec.summaryPrefix)} + summary,\n        actor_id: userId,\n        actor_name: actorName,\n        object_name: OBJECT_NAME,\n        record_id: recordId,\n        // #514 item 2: the object's DECLARED nameField, not a hardcoded name.\n        record_label: record[NAME_FIELD] ?? null,\n        source_object: 'crm_event',\n        source_id: eventId,\n        metadata: JSON.stringify({\n          kind: EVENT_TYPE,\n          duration_minutes: duration,\n          notes: notes,\n          attendee_count: attendeeIds.length,\n        }),\n      });\n\n      // 4. SLA first-response stamp \u2014 NOT here. #575 B2 originally stamped\n      // \\`crm_case.first_response_date\\` from this body, which meant the metric\n      // was only ever written when the interaction was recorded through the two\n      // buttons this factory builds; an event created any other way left it\n      // null, under a comment asking every future author to remember. #595\n      // moved the stamp to \\`event_activity_bubble\\` in\n      // \\`src/sales/objects/event.hook.ts\\`, which already fires on exactly the\n      // condition that matters (\"a held event, on its transition into held\")\n      // and already resolves \\`related_to_case\\`. Step 1 above writes that\n      // event, so this action still stamps the case \u2014 through one writer\n      // instead of a convention. Do not reintroduce a copy here: two writers\n      // racing on a \"first\" timestamp is how it becomes a \"last\" one.\n\n      return { eventId: eventId, activityId: activity?.id ?? null, attendeeIds: attendeeIds };\n    `,\n      capabilities: ['api.read', 'api.write'],\n      timeoutMs: 5000,\n    },\n    locations: ['record_header', 'list_item', 'record_related'],\n    params: [\n      {\n        name: 'subject',\n        label: spec.subjectLabel,\n        type: 'text',\n        required: true,\n      },\n      // WORKAROUND objectstack-ai/objectstack#5061 \u2014 one `type: 'datetime'`\n      // param (\"Starts At\") is what this WANTS to be, and it is unusable: the\n      // Console renders it as a zone-less `<input type=\"datetime-local\">` and\n      // POSTs the raw value, which the action-param validator rejects with a\n      // 400 (`expected an ISO-8601 instant with explicit zone`). The renderer's\n      // output shape and the validator's accepted shape do not intersect, so\n      // NO user input can submit the action \u2014 reproduced from both the list-row\n      // menu and the record header.\n      //\n      // `date` and `time` are the two param types where they DO intersect: the\n      // Console renders native `<input type=\"date\">` / `<input type=\"time\">`\n      // pickers (`ui-components` DateField / TimeField, both emitting\n      // `e.target.value` verbatim) and the validator's `CalendarDateValueSchema`\n      // /`ClockTimeValueSchema` accept exactly `YYYY-MM-DD` and `HH:MM`. Two\n      // native pickers are also better UX than one free-text box, which is the\n      // other shape that would have submitted.\n      //\n      // The zone is stated in the LABELS, not in `helpText`: the Console's\n      // action-param form forwards only name/label/type/required/placeholder/\n      // options/multiple/accept/maxSize to the field widget, so a `helpText`\n      // here would never reach the user.\n      //\n      // REVERT WHEN #5061 LANDS: back to\n      //   { name: 'start', label: 'Starts At', type: 'datetime', required: true }\n      // and drop the join in the body above.\n      ...(spec.collectsSchedule\n        ? ([\n            { name: 'start_date', label: 'Start Date (UTC)', type: 'date', required: true },\n            { name: 'start_time', label: 'Start Time (UTC)', type: 'time', required: true },\n            { name: 'location', label: 'Location', type: 'text', required: false },\n          ] as NonNullable<Action['params']>)\n        : []),\n      {\n        name: 'duration',\n        label: 'Duration (minutes)',\n        type: 'number',\n        required: false,\n      },\n      // Two typed lookups, not one free-text box: the platform has no\n      // polymorphic picker, and typed lookups produce queryable rows where a\n      // text box produces a comma-separated sentence nothing can filter on.\n      {\n        name: 'attendee_contacts',\n        label: 'Contact Attendees',\n        type: 'lookup',\n        reference: 'crm_contact',\n        multiple: true,\n        required: false,\n      },\n      {\n        name: 'attendee_users',\n        label: 'Internal Attendees',\n        type: 'lookup',\n        reference: 'sys_user',\n        multiple: true,\n        required: false,\n      },\n      {\n        name: 'notes',\n        label: spec.notesLabel,\n        type: 'textarea',\n        required: false,\n      },\n    ],\n    successMessage: spec.successMessage,\n    refreshAfter: true,\n  };\n}\n\nconst LOG_CALL_SPEC: ActivitySpec = {\n  name: 'log_call',\n  label: 'Log a Call',\n  icon: 'phone',\n  eventType: 'call',\n  eventStatus: 'held',\n  summaryPrefix: '',\n  defaultSubject: 'Untitled Call',\n  subjectLabel: 'Call Subject',\n  notesLabel: 'Call Notes',\n  successMessage: 'Call logged successfully!',\n};\n\nconst LOG_MEETING_SPEC: ActivitySpec = {\n  name: 'log_meeting',\n  label: 'Log a Meeting',\n  icon: 'calendar-check',\n  eventType: 'meeting',\n  eventStatus: 'held',\n  summaryPrefix: 'Meeting: ',\n  defaultSubject: 'Untitled Meeting',\n  subjectLabel: 'Meeting Subject',\n  notesLabel: 'Meeting Notes',\n  successMessage: 'Meeting logged successfully!',\n};\n\nconst SCHEDULE_MEETING_SPEC: ActivitySpec = {\n  name: 'schedule_meeting',\n  label: 'Schedule a Meeting',\n  icon: 'calendar-plus',\n  eventType: 'meeting',\n  // `planned`, and that is the whole difference that matters: a booking must\n  // NOT reset the customer's recency clock (see event.hook.ts).\n  eventStatus: 'planned',\n  summaryPrefix: 'Meeting scheduled: ',\n  defaultSubject: 'Untitled Meeting',\n  subjectLabel: 'Meeting Subject',\n  notesLabel: 'Agenda',\n  collectsSchedule: true,\n  successMessage: 'Meeting scheduled!',\n};\n\n/** The three activity kinds, in the order they appear on a record header. */\nexport const ACTIVITY_SPEC_NAMES = ['log_call', 'log_meeting', 'schedule_meeting'] as const;\n\nconst ACTIVITY_SPECS: ActivitySpec[] = [LOG_CALL_SPEC, LOG_MEETING_SPEC, SCHEDULE_MEETING_SPEC];\n\n/**\n * The three activity actions for ONE host object \u2014 the factory every package\n * with an activity target calls.\n *\n * Returned keyed by kind rather than as a list, so the named exports below read\n * as themselves and a caller cannot pick the wrong index. Each package calls\n * this ONCE per host object and exports the three it gets back, so a page that\n * imports `LogCallAction` and the barrel that registers it hold the SAME\n * object: two structurally-identical actions under one `<objectName>:<name>`\n * registry key is a duplicate registration the runtime warns about, and one of\n * them silently loses.\n *\n * `objectDefs` is the calling package's object barrel \u2014 see the note on\n * {@link nameFieldMap} for why the definitions arrive as an argument.\n */\nexport const activityActionsFor = (\n  objectName: string,\n  objectDefs: Record<string, NameFieldSource>,\n): Record<(typeof ACTIVITY_SPEC_NAMES)[number], Action> => {\n  // `?? 'name'` only fires for an object that declares no nameField at all,\n  // which no business object in this app does.\n  const nameField = nameFieldMap(objectDefs)[objectName] ?? 'name';\n  const built = ACTIVITY_SPECS.map((spec) => activityAction(spec, objectName, nameField));\n  return Object.fromEntries(built.map((a) => [a.name, a])) as Record<\n    (typeof ACTIVITY_SPEC_NAMES)[number],\n    Action\n  >;\n};\n\n/*\n * The family, named. `src/sales/actions/index.ts` re-exports exactly these \u2014\n * the stack is built from `Object.values(actions)`, so every export it forwards\n * must be one Action, never a list of them.\n *\n * Spelled out rather than looped for grep-ability: \"which surface can log a\n * call on a lead?\" has to be answerable with one search, and AGENTS.md trades\n * verbosity for exactly that everywhere else too.\n */\nconst leadActivityActions = activityActionsFor('crm_lead', salesObjects);\nconst contactActivityActions = activityActionsFor('crm_contact', salesObjects);\nconst accountActivityActions = activityActionsFor('crm_account', salesObjects);\nconst opportunityActivityActions = activityActionsFor('crm_opportunity', salesObjects);\n\nexport const LeadLogCallAction: Action = leadActivityActions.log_call;\nexport const LeadLogMeetingAction: Action = leadActivityActions.log_meeting;\nexport const LeadScheduleMeetingAction: Action = leadActivityActions.schedule_meeting;\n\nexport const ContactLogCallAction: Action = contactActivityActions.log_call;\nexport const ContactLogMeetingAction: Action = contactActivityActions.log_meeting;\nexport const ContactScheduleMeetingAction: Action = contactActivityActions.schedule_meeting;\n\nexport const AccountLogCallAction: Action = accountActivityActions.log_call;\nexport const AccountLogMeetingAction: Action = accountActivityActions.log_meeting;\nexport const AccountScheduleMeetingAction: Action = accountActivityActions.schedule_meeting;\n\nexport const OpportunityLogCallAction: Action = opportunityActivityActions.log_call;\nexport const OpportunityLogMeetingAction: Action = opportunityActivityActions.log_meeting;\nexport const OpportunityScheduleMeetingAction: Action = opportunityActivityActions.schedule_meeting;\n\n/*\n * The `crm_case`-scoped triple is NOT built here. `crm_case` is the service\n * package's object, so service instantiates it from this factory \u2014 see\n * `src/service/actions/case-activity.actions.ts`, which keeps the original\n * `LogCallAction` / `LogMeetingAction` / `CaseScheduleMeetingAction` export\n * names because `src/service/pages/case_detail.page.ts` imports them by those\n * names.\n */\n\n// \u26D4 Never add a global (object-less) body action here: it registers under the\n// 'global' key the dispatcher never probes \u2014 see the note on `objectName`\n// above. CSV export in particular needs no action at all; the list grids'\n// built-in `exportOptions: ['csv', 'xlsx']` already cover it.\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/service/actions/case-activity.actions.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/service/actions\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/service/actions/case-activity.actions.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport * as serviceObjects from '../objects';\nimport { activityActionsFor } from '../../sales/actions/activity-actions';\n\n/**\n * The `crm_case`-scoped activity triple \u2014 `log_call`, `log_meeting`,\n * `schedule_meeting` on a case.\n *\n * These three used to be built alongside the other twelve in what is now\n * `src/sales/actions/activity-actions.ts`. `crm_case` is this package's object,\n * so the ACTIONS authored against it are this package's too (plan item 5: an\n * item lives with the object it is authored against) \u2014 but the factory that\n * builds them is not duplicated. It stays in sales, where the other four host\n * objects and the `crm_event` every one of these writes live, and service\n * imports it along the one edge ADR-0130 allows a module to import on:\n * service -> sales, never sideways, never a second copy.\n *\n * The export names are the originals \u2014 `LogCallAction`, `LogMeetingAction`,\n * `CaseScheduleMeetingAction`, with no `Case` prefix on the first two \u2014 because\n * `src/service/index.ts` registers them by those names, and the PR that moved\n * this file renamed nothing it exports. (The case page names them by action id\n * since #1653, not by these exports.)\n *\n * No `: Action` annotation on the three: `activityActionsFor` already returns\n * `Record<kind, Action>`, so each export is typed `Action` without one (#2072\n * dropped the three, and the type-only import they needed, to pay for the case\n * header's three new action ids under the `src/service` token ceiling).\n */\nconst caseActivityActions = activityActionsFor('crm_case', serviceObjects);\n\nexport const LogCallAction = caseActivityActions.log_call;\nexport const LogMeetingAction = caseActivityActions.log_meeting;\nexport const CaseScheduleMeetingAction = caseActivityActions.schedule_meeting;\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/service/actions/knowledge_article.actions.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/service/actions\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/service/actions/knowledge_article.actions.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport type { Action } from '@objectstack/spec/ui';\nimport { P } from '@objectstack/spec';\n\n/**\n * Knowledge article feedback actions.\n *\n * The two buttons that make `helpful_count` / `not_helpful_count` move. Neither\n * writes a counter: each records the reader's own `crm_article_feedback` row,\n * and `article_feedback_metrics_refresh` recounts the article from that table.\n * The full reasoning for the indirection \u2014 a sandboxed action body cannot\n * UPDATE a sharing-ruled object, the article is write-owned, and there is no\n * atomic increment \u2014 is on `src/service/objects/article_feedback.object.ts`.\n *\n * ### One body, generated twice\n *\n * `feedbackBody(verdict)` composes the source string both actions ship. This is\n * FACTORY composition, which is allowed and is what `_case-assignment.ts` does\n * for hooks: the string it returns is complete and self-contained, so the body\n * that reaches the QuickJS sandbox reaches for no module scope. \u26D4 Never write\n * the other shape \u2014 a body that CALLS a shared function at runtime lowers to a\n * `ReferenceError`, because the body ships without its module\n * (`test/action-sandbox.test.ts` fails the build on it, and\n * `test/knowledge-feedback.test.ts` pins that these two bodies stay\n * character-identical apart from the verdict).\n *\n * ### Re-voting UPDATES rather than inserting\n *\n * `crm_article_feedback` carries a unique index on\n * (`crm_knowledge_article`, `owner_id`), so a reader who clicks Helpful and\n * then Not Helpful must move their existing row, not add a second one. The\n * body therefore reads first. Without the dedupe the counters would answer\n * \"how many clicks\", and one enthusiastic reader could out-vote a department.\n *\n * `owner_id` is set EXPLICITLY: an action body runs `isSystem`, so nothing\n * stamps the ownership anchor for it (the same note `clone_opportunity`\n * carries). It is the voter's identity that keys the dedupe, so getting it from\n * `ctx.user` is load-bearing rather than tidy \u2014 a null owner would collapse\n * every anonymous-looking vote onto one row.\n */\nconst feedbackBody = (verdict: 'helpful' | 'not_helpful'): string => `\n      const id = ctx.recordId;\n      if (!id) throw new Error('submit_article_feedback requires a recordId');\n      const userId = ctx.user?.id ?? null;\n      if (!userId) throw new Error('Sign in to rate an article.');\n\n      // One row per (article, reader) \u2014 the unique index says so, and this\n      // read is what keeps a mind-change an UPDATE instead of a duplicate.\n      const existing = await ctx.api.object('crm_article_feedback').findOne({\n        where: { crm_knowledge_article: id, owner_id: userId },\n      });\n\n      if (existing && existing.id) {\n        if (existing.verdict === '${verdict}') {\n          return { ok: true, id: existing.id, verdict: '${verdict}', changed: false };\n        }\n        await ctx.api.object('crm_article_feedback').update(\n          { id: existing.id, verdict: '${verdict}' },\n          { where: { id: existing.id } },\n        );\n        return { ok: true, id: existing.id, verdict: '${verdict}', changed: true };\n      }\n\n      const inserted = await ctx.api.object('crm_article_feedback').insert({\n        crm_knowledge_article: id,\n        verdict: '${verdict}',\n        owner_id: userId,\n      });\n      return { ok: true, id: inserted?.id ?? null, verdict: '${verdict}', changed: true };\n    `;\n\n/**\n * Only PUBLISHED articles collect votes. A draft's counters would describe a\n * version no reader outside the authoring team ever saw, and the review queue\n * reads these numbers as a signal about live content.\n */\nconst publishedOnly = P`has(record.status) && record.status == \"published\"`;\n\nexport const MarkArticleHelpfulAction: Action = {\n  name: 'mark_article_helpful',\n  label: 'Helpful',\n  objectName: 'crm_knowledge_article',\n  icon: 'thumbs-up',\n  type: 'script',\n  body: {\n    language: 'js',\n    source: feedbackBody('helpful'),\n    capabilities: ['api.read', 'api.write'],\n    timeoutMs: 5000,\n  },\n  locations: ['record_header'],\n  visible: publishedOnly,\n  successMessage: 'Thanks \u2014 recorded as helpful.',\n  refreshAfter: true,\n};\n\nexport const MarkArticleNotHelpfulAction: Action = {\n  name: 'mark_article_not_helpful',\n  label: 'Not Helpful',\n  objectName: 'crm_knowledge_article',\n  icon: 'thumbs-down',\n  type: 'script',\n  body: {\n    language: 'js',\n    source: feedbackBody('not_helpful'),\n    capabilities: ['api.read', 'api.write'],\n    timeoutMs: 5000,\n  },\n  locations: ['record_header'],\n  visible: publishedOnly,\n  successMessage: 'Thanks \u2014 recorded as not helpful.',\n  refreshAfter: true,\n};\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/service/dashboards/service.dashboard.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/service/dashboards\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/service/dashboards/service.dashboard.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport type { Dashboard } from '@objectstack/spec/ui';\n\n/**\n * The one dataset every widget below binds (`case_metrics`), written once and\n * passed by shorthand (`dataset,`) rather than spelled out on each widget.\n */\nconst dataset = 'case_metrics';\n\n/**\n * Customer Service Dashboard\n *\n * Case load, SLA health, and resolution performance for the support team.\n * Uses semantic colorVariant tokens (warning/danger/success) and chartConfig\n * palettes instead of raw hex values, mirroring the polished CRM dashboard\n * reference at https://github.com/objectstack-ai/objectui/tree/main/examples/crm.\n *\n * No KPI tile declares a `trend`. A period-over-period delta is a measurement,\n * so it has to come from a real comparison query (widget `compareTo`) once the\n * renderer supports it for dataset metrics \u2014 the percentages this file used to\n * carry were typed by hand and recomputed by nothing, so they kept asserting\n * the same \"-6.2% vs last week\" on any data, including an empty database.\n * Same rule as the executive dashboard (#500, #587).\n */\nexport const ServiceDashboard: Dashboard = {\n  name: 'service_dashboard',\n  label: 'Customer Service',\n  description: 'Case load, SLA health, and resolution performance',\n\n  columns: 12,\n  gap: 4,\n  refreshIntervalSeconds: 60, // 1 minute \u2014 service desks need fresh numbers\n\n  header: {\n    showTitle: true,\n    showDescription: true,\n    // Header action buttons removed: `create_case` is not a defined action and\n    // `/objects/case?owner=current_user` / `/reports/sla` are not in-app view\n    // routes \u2014 all three were dead. Re-add real, wired-up actions here when available.\n  },\n\n  // Historical note (#460 \u2192 #1157): this dashboard shipped without a date\n  // picker from PR #546 until the 17.0.0 GA upgrade, because windowing a\n  // `Field.datetime()` could not be compared \u2014 `driver-sql` 16.1.0 coerced\n  // datetime bounds to epoch-ms INTEGER while every datetime in the database is\n  // ISO TEXT, so `$gte` matched everything and `$lte` matched nothing and the\n  // whole dashboard read zeros. Both named preconditions are fixed and\n  // released: objectstack#3912 (the coercion) and objectstack#3777 (a bare-date\n  // `$lte` dropping same-day rows). The window below is not restored on the\n  // strength of those closures alone \u2014 `test/dashboard-date-range-window.test.ts`\n  // executes it against a real SQLite database and compares every widget to a\n  // ground truth computed in the same run, so a re-regression fails CI here\n  // rather than being discovered as an all-zero dashboard again.\n  //\n  // The range windows `created_at`, the platform's creation stamp (#1992). It\n  // used to window `created_date`, which nothing wrote on a real case, so\n  // every case created through the UI or REST fell outside every range.\n  dateRange: { field: 'created_at', defaultRange: 'last_90_days', allowCustomRange: true },\n\n  globalFilters: [\n    {\n      field: 'owner_id',\n      label: { en: 'Agent', 'zh-CN': '\u8D1F\u8D23\u4EBA', 'es-ES': 'Propietario del Caso', 'ja-JP': '\u30B1\u30FC\u30B9\u62C5\u5F53\u8005' },\n      type: 'lookup',\n      scope: 'dashboard',\n      optionsFrom: { object: 'sys_user', valueField: 'id', labelField: 'name' },\n    },\n    {\n      field: 'priority',\n      label: { en: 'Priority', 'zh-CN': '\u4F18\u5148\u7EA7', 'es-ES': 'Prioridad', 'ja-JP': '\u512A\u5148\u5EA6' },\n      type: 'select',\n      scope: 'dashboard',\n      options: [\n        // zh-CN `critical` is \u4E25\u91CD, never \u7D27\u6025 \u2014 \u7D27\u6025 belongs to crm_task.priority.urgent\n        // and the two vocabularies are distinct sets (ruling #1342). Same wording as\n        // `objects.crm_case.fields.priority.options` in every locale pack.\n        { value: 'critical', label: { en: 'Critical', 'zh-CN': '\u4E25\u91CD', 'es-ES': 'Cr\u00EDtica', 'ja-JP': '\u91CD\u5927' } },\n        { value: 'high',     label: { en: 'High', 'zh-CN': '\u9AD8', 'es-ES': 'Alta', 'ja-JP': '\u9AD8' } },\n        { value: 'medium',   label: { en: 'Medium', 'zh-CN': '\u4E2D', 'es-ES': 'Media', 'ja-JP': '\u4E2D' } },\n        { value: 'low',      label: { en: 'Low', 'zh-CN': '\u4F4E', 'es-ES': 'Baja', 'ja-JP': '\u4F4E' } },\n      ],\n    },\n  ],\n\n  widgets: [\n    // \u2500\u2500\u2500 Row 1: Case-Load KPIs \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n    {\n      id: 'open_cases',\n      title: 'Open Cases',\n      description: 'Cases that are not yet closed',\n      type: 'metric',\n      filter: { is_closed: false },\n      colorVariant: 'orange',\n      dataset, values: ['case_count'],\n      layout: { x: 0, y: 0, w: 3, h: 2 },\n    },\n    {\n      id: 'critical_cases',\n      title: 'Critical Cases',\n      description: 'Open cases marked as critical priority',\n      type: 'metric',\n      filter: { priority: 'critical', is_closed: false },\n      colorVariant: 'danger',\n      dataset, values: ['case_count'],\n      layout: { x: 3, y: 0, w: 3, h: 2 },\n    },\n    {\n      id: 'avg_resolution_time',\n      title: 'Avg Resolution Time',\n      description: 'Mean time to close, in hours',\n      type: 'metric',\n      filter: { is_closed: true },\n      colorVariant: 'blue',\n      dataset, values: ['avg_resolution'],\n      layout: { x: 6, y: 0, w: 3, h: 2 },\n    },\n    {\n      id: 'sla_violations',\n      title: 'SLA Violations',\n      description: 'Cases that breached their SLA',\n      type: 'metric',\n      // Counted at READ time (#2070): a case already flagged, OR a case still\n      // open whose deadline has passed. The second branch is the selection\n      // `case_sla_monitor` sweeps \u2014 same status set, same strict `$lt` at the\n      // current instant (`{now}` is that instant in a query filter; `{NOW()}`\n      // in a flow template) \u2014 so the tile reads true on a deployment that runs\n      // no scheduled work, where nothing flags an open breach. It counts; it\n      // does not act: escalation and the owner's alert still need the sweep.\n      // `test/case-sla-breach-on-close.test.ts` pins the two to one selection.\n      filter: {\n        $or: [\n          { is_sla_violated: true },\n          { status: { $nin: ['resolved', 'closed'] }, sla_due_date: { $lt: '{now}' } },\n        ],\n      },\n      colorVariant: 'warning',\n      dataset, values: ['case_count'],\n      layout: { x: 9, y: 0, w: 3, h: 2 },\n    },\n\n    // \u2500\u2500\u2500 Row 2: Distribution \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n    {\n      id: 'cases_by_status',\n      title: 'Cases by Status',\n      description: 'Workload distribution across the pipeline',\n      type: 'donut',\n      filter: { is_closed: false },\n      colorVariant: 'blue',\n      dataset, dimensions: ['status'], values: ['case_count'],\n      layout: { x: 0, y: 2, w: 4, h: 4 },\n      chartConfig: {\n        showLegend: true,\n        showDataLabels: true,\n        colors: ['#0EA5E9', '#06B6D4', '#14B8A6', '#10B981', '#F59E0B'],\n      },\n    },\n    {\n      id: 'cases_by_priority',\n      title: 'Cases by Priority',\n      description: 'Open case mix by urgency',\n      type: 'pie',\n      filter: { is_closed: false },\n      colorVariant: 'warning',\n      dataset, dimensions: ['priority'], values: ['case_count'],\n      layout: { x: 4, y: 2, w: 4, h: 4 },\n      chartConfig: {\n        showLegend: true,\n        showDataLabels: true,\n        // critical \u2192 high \u2192 medium \u2192 low\n        colors: ['#DC2626', '#F97316', '#F59E0B', '#10B981'],\n      },\n    },\n    {\n      id: 'cases_by_origin',\n      title: 'Cases by Origin',\n      description: 'Where our cases are coming from',\n      type: 'bar',\n      colorVariant: 'purple',\n      dataset, dimensions: ['origin'], values: ['case_count'],\n      layout: { x: 8, y: 2, w: 4, h: 4 },\n      chartConfig: {\n        showLegend: false,\n        showDataLabels: true,\n        colors: ['#8B5CF6'],\n      },\n    },\n\n    // \u2500\u2500\u2500 Row 3: Volume & SLA Trends \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n    {\n      id: 'daily_case_volume',\n      title: 'Daily Case Volume',\n      description: 'New cases created over the last 30 days',\n      type: 'area',\n      filter: { created_at: { $gte: '{30_days_ago}' } },\n      // Opted out ON PURPOSE, re-decided in #1157 rather than inherited.\n      //\n      // The floor above is no longer inert: on 17.0.0 `{30_days_ago}` resolves\n      // to a start-of-day bound the driver compares correctly (measured, with a\n      // ground truth, in `test/dashboard-date-range-window.test.ts`), so this\n      // chart really does plot the last 30 days and its title is true again.\n      // That is exactly why it must not follow the picker: the dashboard range\n      // is ANDed into every bound widget, so a reader who selects \"last 7 days\"\n      // would get a 7-day chart still labelled \"last 30 days\". Self-described\n      // windows opt out \u2014 the same rule the Executive dashboard's YTD tile\n      // follows, pinned by `test/action-references.test.ts`. Binding it instead\n      // would mean dropping this filter and retitling the widget in all four\n      // locale bundles; the fixed 30-day volume trend beside a 90-day case load\n      // is the intended reading.\n      filterBindings: { dateRange: false },\n      colorVariant: 'blue',\n      dataset, dimensions: ['created_at'], values: ['case_count'],\n      layout: { x: 0, y: 6, w: 8, h: 4 },\n      chartConfig: {\n        showLegend: false,\n        showDataLabels: false,\n        colors: ['#0EA5E9'],\n        interaction: { tooltips: true, brush: true },\n      },\n      options: { dateGranularity: 'day' },\n    },\n    {\n      id: 'sla_compliance_gauge',\n      title: 'SLA Compliance',\n      description: 'Percent of cases resolved within SLA this period',\n      type: 'gauge',\n      filter: { is_closed: true },\n      colorVariant: 'success',\n      // Plots COMPLIANCE, the quantity the title, the description, the\n      // success colouring and the 0.95 target line all name (#1213). It used\n      // to plot `avg_sla_violated` \u2014 the complement \u2014 with `options.invert`\n      // asking the renderer to flip it. `invert` is not a declared key on\n      // `DashboardWidgetOptionsSchema`; it rode the `.passthrough()`, nothing\n      // could report it inert, and the gauge read 0.0% on an org with 100%\n      // compliance. The key is gone rather than left pretending: a measure\n      // that means what the widget says is the fix, and the measure's own\n      // label prints under the number, so the two cannot drift apart again.\n      dataset, values: ['sla_compliance_rate'],\n      layout: { x: 8, y: 6, w: 4, h: 4 },\n      chartConfig: {\n        showLegend: false,\n        showDataLabels: true,\n        colors: ['#10B981', '#F59E0B', '#EF4444'],\n        annotations: [\n          { type: 'line', axis: 'y', value: 0.95, label: 'Target', style: 'dashed', color: '#10B981' },\n        ],\n      },\n      // The target line was written for COMPLIANCE and is unchanged: it was\n      // always right \u2014 it was the plotted value that disagreed with it. (The\n      // green/amber/red `options.thresholds` ladder beside it was deleted in\n      // 17.6.0's strict cleanup: no dashboard renderer reads widget\n      // `thresholds`, so it never coloured anything.)\n    },\n\n    // \u2500\u2500\u2500 Row 4: Knowledge deflection (#601) \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n    //\n    // The deflection metric the card asks the service dashboard to show, and\n    // the reason it is THREE tiles rather than one: a ratio widget on its own\n    // is unreadable \u2014 100% could be \"40 of 40\" or \"1 of 1\", and a blank rate\n    // could be \"no closed cases\" or \"no KB resolutions\" (measured: a filtered\n    // measure contributes NO row for a group it selects nothing in, so the\n    // rate comes back absent, not 0). Numerator and denominator therefore ship\n    // beside the percentage, the same rule the sales dashboard's win rate\n    // follows after #614.\n    {\n      id: 'kb_deflection_rate',\n      title: 'KB Deflection Rate',\n      description: 'Share of closed cases resolved with a knowledge article',\n      type: 'metric',\n      colorVariant: 'success',\n      dataset, values: ['kb_deflection_rate'],\n      layout: { x: 0, y: 10, w: 4, h: 2 },\n    },\n    {\n      id: 'kb_resolved_cases',\n      title: 'Resolved by KB',\n      description: 'Closed cases pointing at the article that resolved them',\n      type: 'metric',\n      colorVariant: 'blue',\n      dataset, values: ['kb_resolved_count'],\n      layout: { x: 4, y: 10, w: 4, h: 2 },\n    },\n    {\n      id: 'closed_cases_total',\n      title: 'Closed Cases',\n      description: 'The denominator behind the deflection rate',\n      type: 'metric',\n      colorVariant: 'default',\n      dataset, values: ['closed_count'],\n      layout: { x: 8, y: 10, w: 4, h: 2 },\n    },\n    {\n      id: 'top_resolving_articles',\n      title: 'Top Resolving Articles',\n      description: 'Knowledge articles ranked by the closed cases they resolved',\n      type: 'table',\n      filter: { is_closed: true },\n      colorVariant: 'default',\n      dataset, dimensions: ['resolved_article'], values: ['kb_resolved_count'],\n      layout: { x: 0, y: 12, w: 12, h: 4 },\n      options: {\n        sortBy: 'kb_resolved_count',\n        sortOrder: 'desc',\n        limit: 10,\n      },\n    },\n\n    // \u2500\u2500\u2500 Row 5: My Open Cases by Priority \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n    // A dashboard `table` binds to an analytics cube and aggregates; it cannot\n    // list individual cases (ADR-0021) \u2014 for the case-by-case queue, use the\n    // my_open_cases ListView (\"My Cases\" in the My Work nav group).\n    // `{current_user_id}` scopes what this widget SHOWS; it is presentation\n    // scope, not an access boundary \u2014 row-level security owns that (#510).\n    {\n      id: 'my_open_cases_by_priority',\n      title: 'My Open Cases by Priority',\n      description: 'Your open cases and their SLA-violation rate, broken down by priority',\n      type: 'table',\n      filter: { is_closed: false, owner_id: '{current_user_id}' },\n      // Opts out of the Agent global filter (keyed by its field, `owner_id`):\n      // ANDing an agent pick into \"mine\" empties the widget for anyone else.\n      filterBindings: { owner_id: false },\n      colorVariant: 'default',\n      dataset, dimensions: ['priority'], values: ['case_count', 'avg_sla_violated'],\n      layout: { x: 0, y: 16, w: 12, h: 4 },\n      options: {\n        sortBy: 'case_count',\n        sortOrder: 'desc',\n        limit: 10,\n      },\n    },\n  ],\n};\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/service/datasets/case.dataset.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/service/datasets\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/service/datasets/case.dataset.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport { defineDataset } from '@objectstack/spec/ui';\n\n/**\n * Case analytics dataset (ADR-0021) \u2014 the semantic source of truth for the\n * Service dashboard's case counts, resolution time and SLA compliance.\n */\nexport const CaseDataset = defineDataset({\n  name: 'case_metrics',\n  label: 'Case Metrics',\n  description: 'Semantic layer for support-case counts, resolution time and SLA',\n  object: 'crm_case',\n\n  dimensions: [\n    { name: 'status', label: 'Status', field: 'status', type: 'string' },\n    { name: 'priority', label: 'Priority', field: 'priority', type: 'string' },\n    { name: 'origin', label: 'Origin', field: 'origin', type: 'string' },\n    { name: 'type', label: 'Type', field: 'type', type: 'string' },\n    // The platform's creation stamp (#1992) \u2014 the same dimension\n    // `account_metrics` and `lead_metrics` declare, bucketed by day here.\n    { name: 'created_at', label: 'Created', field: 'created_at', type: 'date', dateGranularity: 'day' },\n    // Article ranking by resolutions (#601) \u2014 group closed cases by the\n    // article that resolved them. `type: 'lookup'`, the same spelling the\n    // `owner` dimension on `opportunity_metrics` uses for `owner_id`.\n    { name: 'resolved_article', label: 'Resolving Article', field: 'resolved_by_article', type: 'lookup' },\n  ],\n\n  measures: [\n    { name: 'case_count', label: 'Cases', aggregate: 'count' },\n    { name: 'avg_resolution', label: 'Avg Resolution (h)', aggregate: 'avg', field: 'resolution_time_hours', format: '0.0' },\n    { name: 'avg_sla_violated', label: 'SLA Violation Rate', aggregate: 'avg', field: 'is_sla_violated', format: '0.0%' },\n\n    // \u2500\u2500\u2500 Knowledge deflection (#601) \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n    //\n    // \"% of closed cases resolved with an article\". Built to the shape\n    // `opportunity_metrics.win_rate` arrived at the hard way (#593/#614): the\n    // two halves of the ratio are declared HERE as named measures, once, so no\n    // widget improvises a denominator \u2014 a wrong denominator does not error, it\n    // returns a plausible number.\n    //\n    // Each half carries its OWN `filter`, which the executor runs as a\n    // sub-query and merges back on the selected dimensions. A widget-level\n    // filter cannot express this: it would narrow BOTH halves to the same row\n    // set, which is how you end up dividing a number by itself.\n    //\n    // `kb_resolved_count` counts the COLUMN, not the rows: `count(<field>)`\n    // counts non-NULL values, so it needs no `$ne: null` predicate and no\n    // parallel boolean flag to drift out of step with the lookup. MEASURED on\n    // 17.0.0-rc.6 against both drivers \u2014 the numbers are pinned in\n    // `test/knowledge-deflection.test.ts`. The one thing it CANNOT discount is\n    // an empty string, which is non-NULL; that is why the blank is normalised\n    // to NULL at write time by `case_resolution_article_normalize`, and why\n    // that hook is part of this metric rather than a tidy-up beside it.\n    //\n    // Every widget that shows `kb_deflection_rate` also shows\n    // `kb_resolved_count` and `closed_count` beside it, so a reader can check\n    // the arithmetic that produced the percentage.\n    { name: 'closed_count', label: 'Closed Cases', aggregate: 'count', filter: { is_closed: true } },\n    {\n      name: 'kb_resolved_count',\n      label: 'Resolved by KB',\n      aggregate: 'count',\n      field: 'resolved_by_article',\n      filter: { is_closed: true },\n    },\n    {\n      name: 'kb_deflection_rate',\n      label: 'KB Deflection Rate',\n      derived: { op: 'ratio', of: ['kb_resolved_count', 'closed_count'] },\n      format: '0%',\n    },\n\n    // \u2500\u2500\u2500 SLA compliance (#1213) \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n    //\n    // The service dashboard's gauge asks \"are we meeting SLA?\", so the number\n    // it plots has to BE compliance. It used to plot `avg_sla_violated` \u2014 the\n    // complement \u2014 and ask the renderer to flip it with `options.invert`. That\n    // key is not declared by `DashboardWidgetOptionsSchema`; it rides the\n    // schema's `.passthrough()`, so no validator, lint rule or gate could ever\n    // tell the author it does nothing \u2014 and none did. The gauge read 0.0% on\n    // an org with 100% compliance.\n    //\n    // Spelled as a ratio of two counts rather than `1 - avg_sla_violated`\n    // because `DerivedMeasureOp` operands are MEASURE NAMES only (`of:\n    // string[]` \u2014 \"no raw fields, no raw SQL\"), so there is no literal `1` to\n    // subtract from. `difference` cannot express it either. This is the card's\n    // own second option and the spec's sanctioned shape \u2014 the one\n    // `kb_deflection_rate` above already uses.\n    //\n    // `is_sla_violated: false`, not `$ne: true`: the field declares\n    // `defaultValue: false`, and MEASURED on both drivers this app runs, a\n    // closed case inserted without the column stores `false` rather than NULL.\n    // So `sla_met_count + violated = closed_count` holds with no NULL hole.\n    // Both spellings measured identical (2 of 3, both drivers); the plain one\n    // is the one that reads as what it means.\n    //\n    // The denominator is `closed_count`, already declared above \u2014 the same\n    // measure the `closed_cases_total` tile shows, so a reader can check the\n    // percentage against a number on the same page. An empty numerator group\n    // does NOT blank the rate: the executor fills a `count` column's empty\n    // group with 0 BEFORE evaluating derived measures, so a fully-breached org\n    // reads 0%, not blank. A zero DENOMINATOR (no closed cases at all) does\n    // return null \u2014 \"no data\", which is the honest reading.\n    { name: 'sla_met_count', label: 'Cases Within SLA', aggregate: 'count', filter: { is_closed: true, is_sla_violated: false } },\n    {\n      name: 'sla_compliance_rate',\n      label: 'SLA Compliance Rate',\n      derived: { op: 'ratio', of: ['sla_met_count', 'closed_count'] },\n      format: '0%',\n    },\n  ],\n});\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/sales/email-templates/_bundle.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/sales/email-templates\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/sales/email-templates/_bundle.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport type { EmailTemplateDefinition } from '@objectstack/spec/system';\n\n/**\n * The one spelling of \"a locale pack becomes `sys_email_template` rows\",\n * shared by every package that owns notification templates.\n *\n * `EmailTemplateDefinition` carries ONE `locale` per row, so an n-language\n * bundle is n rows of the same `name` \u2014 that is the spec's own key, not a\n * convention this repo picked. Writing those rows out by hand would mean\n * repeating `name` and the row scaffolding four times per\n * template; here each locale pack states only what actually differs between\n * languages (the label and the two bodies) and this helper produces the rows.\n *\n * It lives in `src/sales/` because `src/service/` and `src/revenue/` both need\n * it: a source more than one package needs has one deterministic home, the\n * lowest package all its consumers depend on (AGENTS.md import rule 2), and\n * modules import it along their edge into sales \u2014 the same placement as\n * `flows/_guarded-iteration.ts` and `objects/_hook-api.ts`.\n */\n\n/**\n * What one template looks like in ONE language \u2014 every field of\n * `EmailTemplateDefinition` whose value is genuinely per-locale.\n *\n * `label` is in here because it is the Studio display name an administrator\n * reads, so it localizes with the content; `name` and `locale` are not, and\n * {@link bundle} supplies them once per row.\n */\nexport interface LocalizedEmailTemplate {\n  /** Studio display label for this template, in this language. */\n  label: string;\n  /** Subject line; `{{var}}` holes are filled from the notify node's `templateData`. */\n  subject: string;\n  /** HTML body; same `{{var}}` holes. `bodyText` is derived by the service when omitted. */\n  bodyHtml: string;\n}\n\n/** One language's face of every template a package owns, keyed by template name. */\nexport type EmailTemplatePack = Record<string, LocalizedEmailTemplate>;\n\n/**\n * Cross a package's locale packs into the flat `(name, locale)` rows\n * `defineStack({ emailTemplates })` takes.\n *\n * \u26A0\uFE0F The ENGLISH pack is registered under `en-US`, not `en`, and that is the\n * resolution ladder's doing rather than a style choice.\n * `EmailService.resolveAndRenderTemplate` matches `(name, locale)` EXACTLY,\n * then retries exactly once against its own `DEFAULT_TEMPLATE_LOCALE` \u2014 the\n * literal `'en-US'`. A recipient whose `sys_user.locale` is this app's default\n * `'en'` therefore misses on the first probe and lands on the second; a\n * recipient carrying `'en-US'` (or any locale this app ships no pack for)\n * lands on it directly. Tagging the rows `'en'` instead would invert that:\n * `'en-US'` is a truthy preferred locale, so the third probe is skipped and\n * the send fails with `TEMPLATE_NOT_FOUND`. `'en-US'` is the tag that cannot\n * strand a recipient.\n */\nexport const bundle = (packs: Record<string, EmailTemplatePack>): EmailTemplateDefinition[] =>\n  Object.entries(packs).flatMap(([locale, pack]) =>\n    Object.entries(pack).map(([name, row]) => ({ name, locale, ...row })));\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/service/email-templates/en.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/service/email-templates\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/service/email-templates/en.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport type { EmailTemplatePack } from '../../sales/email-templates/_bundle';\n\n/**\n * English (en-US) \u2014 the service package's notification templates.\n *\n * Every string is the text its `notify` node already sent, with the flow's\n * `{var.path}` interpolations re-expressed as the `{{key}}` holes the renderer\n * fills from that node's `templateData`. \u26A0\uFE0F Tagged `en-US`, not `en` \u2014 see the\n * resolution-ladder note on `bundle()`.\n */\nexport const en: EmailTemplatePack = {\n  'crm.case_escalated': {\n    label: 'Case Escalated',\n    subject: 'Case escalated: {{case_number}}',\n    bodyHtml: '<p>Case {{case_number}} ({{priority}}) has been auto-escalated on critical priority. Ownership passes to the service manager with the lightest load; while nobody holds that position the case stays with you. Open the case to see who owns it now.</p>',\n  },\n  'crm.case_sla_breach': {\n    label: 'Case SLA Breached',\n    subject: 'SLA breached: case {{case_number}}',\n    bodyHtml: '<p>Case {{case_number}} ({{priority}}) passed its SLA due date and has been auto-escalated.</p>',\n  },\n};\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/service/email-templates/zh-CN.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/service/email-templates\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/service/email-templates/zh-CN.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport type { EmailTemplatePack } from '../../sales/email-templates/_bundle';\n\n/** \u7B80\u4F53\u4E2D\u6587 (zh-CN) \u2014 the service package's notification templates. See `en.ts`. */\nexport const zhCN: EmailTemplatePack = {\n  'crm.case_escalated': {\n    label: '\u5DE5\u5355\u5DF2\u5347\u7EA7',\n    subject: '\u5DE5\u5355\u5DF2\u5347\u7EA7\uFF1A{{case_number}}',\n    bodyHtml: '<p>\u5DE5\u5355 {{case_number}}\uFF08{{priority}}\uFF09\u56E0\u4E25\u91CD\u7EA7\u522B\u5DF2\u81EA\u52A8\u5347\u7EA7\u3002\u6240\u6709\u6743\u5C06\u8F6C\u4EA4\u7ED9\u5F53\u524D\u8D1F\u8377\u6700\u8F7B\u7684\u670D\u52A1\u7ECF\u7406\uFF1B\u82E5\u8BE5\u804C\u4F4D\u6682\u65E0\u4EBA\u62C5\u4EFB\uFF0C\u5DE5\u5355\u4ECD\u5F52\u60A8\u6240\u6709\u3002\u8BF7\u6253\u5F00\u5DE5\u5355\u67E5\u770B\u5F53\u524D\u8D1F\u8D23\u4EBA\u3002</p>',\n  },\n  'crm.case_sla_breach': {\n    label: '\u5DE5\u5355 SLA \u8D85\u65F6',\n    subject: 'SLA \u8D85\u65F6\uFF1A\u5DE5\u5355 {{case_number}}',\n    bodyHtml: '<p>\u5DE5\u5355 {{case_number}}\uFF08{{priority}}\uFF09\u5DF2\u8D85\u8FC7 SLA \u5230\u671F\u65F6\u95F4\uFF0C\u5E76\u5DF2\u81EA\u52A8\u5347\u7EA7\u3002</p>',\n  },\n};\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/service/email-templates/ja-JP.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/service/email-templates\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/service/email-templates/ja-JP.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport type { EmailTemplatePack } from '../../sales/email-templates/_bundle';\n\n/** \u65E5\u672C\u8A9E (ja-JP) \u2014 the service package's notification templates. See `en.ts`. */\nexport const jaJP: EmailTemplatePack = {\n  'crm.case_escalated': {\n    label: '\u30B1\u30FC\u30B9\u306E\u30A8\u30B9\u30AB\u30EC\u30FC\u30B7\u30E7\u30F3',\n    subject: '\u30B1\u30FC\u30B9\u304C\u30A8\u30B9\u30AB\u30EC\u30FC\u30B7\u30E7\u30F3\u3055\u308C\u307E\u3057\u305F: {{case_number}}',\n    bodyHtml: '<p>\u30B1\u30FC\u30B9 {{case_number}}\uFF08{{priority}}\uFF09\u306F\u91CD\u5927\u5EA6\u304C\u9AD8\u3044\u305F\u3081\u81EA\u52D5\u7684\u306B\u30A8\u30B9\u30AB\u30EC\u30FC\u30B7\u30E7\u30F3\u3055\u308C\u307E\u3057\u305F\u3002\u6240\u6709\u6A29\u306F\u8CA0\u8377\u306E\u6700\u3082\u8EFD\u3044\u30B5\u30FC\u30D3\u30B9\u30DE\u30CD\u30FC\u30B8\u30E3\u30FC\u306B\u79FB\u308A\u307E\u3059\u3002\u305D\u306E\u5F79\u8077\u306B\u8AB0\u3082\u3044\u306A\u3044\u9593\u306F\u3001\u30B1\u30FC\u30B9\u306F\u3042\u306A\u305F\u306E\u307E\u307E\u3067\u3059\u3002\u30B1\u30FC\u30B9\u3092\u958B\u3044\u3066\u73FE\u5728\u306E\u6240\u6709\u8005\u3092\u3054\u78BA\u8A8D\u304F\u3060\u3055\u3044\u3002</p>',\n  },\n  'crm.case_sla_breach': {\n    label: '\u30B1\u30FC\u30B9\u306E SLA \u8D85\u904E',\n    subject: 'SLA \u8D85\u904E: \u30B1\u30FC\u30B9 {{case_number}}',\n    bodyHtml: '<p>\u30B1\u30FC\u30B9 {{case_number}}\uFF08{{priority}}\uFF09\u306F SLA \u671F\u9650\u3092\u904E\u304E\u305F\u305F\u3081\u3001\u81EA\u52D5\u7684\u306B\u30A8\u30B9\u30AB\u30EC\u30FC\u30B7\u30E7\u30F3\u3055\u308C\u307E\u3057\u305F\u3002</p>',\n  },\n};\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/service/email-templates/es-ES.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/service/email-templates\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/service/email-templates/es-ES.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport type { EmailTemplatePack } from '../../sales/email-templates/_bundle';\n\n/** Espa\u00F1ol (es-ES) \u2014 the service package's notification templates. See `en.ts`. */\nexport const esES: EmailTemplatePack = {\n  'crm.case_escalated': {\n    label: 'Caso escalado',\n    subject: 'Caso escalado: {{case_number}}',\n    bodyHtml: '<p>El caso {{case_number}} ({{priority}}) se ha escalado autom\u00E1ticamente por prioridad cr\u00EDtica. La propiedad pasa al responsable de servicio con menos carga; mientras nadie ocupe ese puesto, el caso sigue siendo tuyo. Abre el caso para ver qui\u00E9n lo tiene ahora.</p>',\n  },\n  'crm.case_sla_breach': {\n    label: 'SLA del caso incumplido',\n    subject: 'SLA incumplido: caso {{case_number}}',\n    bodyHtml: '<p>El caso {{case_number}} ({{priority}}) super\u00F3 su fecha l\u00EDmite de SLA y se ha escalado autom\u00E1ticamente.</p>',\n  },\n};\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/service/email-templates/crm.email-template.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/service/email-templates\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/service/email-templates/crm.email-template.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport type { EmailTemplateDefinition } from '@objectstack/spec/system';\nimport { bundle } from '../../sales/email-templates/_bundle';\nimport { en } from './en';\nimport { zhCN } from './zh-CN';\nimport { jaJP } from './ja-JP';\nimport { esES } from './es-ES';\n\n/**\n * Service \u2014 every `sys_email_template` row this package's `notify` nodes name.\n *\n * Four locale packs crossed with two template names. `bundle()` is imported\n * along this module's edge into sales, the one deterministic home for a source\n * more than one package needs.\n */\nexport const ServiceEmailTemplates: EmailTemplateDefinition[] = bundle({\n  'en-US': en,\n  'zh-CN': zhCN,\n  'ja-JP': jaJP,\n  'es-ES': esES,\n});\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/service/flows/case-escalation.flow.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/service/flows\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/service/flows/case-escalation.flow.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport { P, cel } from '@objectstack/spec';\nimport type * as Automation from '@objectstack/spec/automation';\ntype Flow = Automation.Flow;\n\n/** Case Escalation \u2014 auto-escalate high-priority cases */\nexport const CaseEscalationFlow: Flow = {\n  name: 'case_escalation',\n  label: 'Case Escalation Process',\n  description: 'Automatically escalate high-priority cases',\n  type: 'record_change',\n  status: 'active',\n  // A record-change flow fired by a SYSTEM write carries no trigger user\n  // either \u2014 the user-less exposure is NOT schedule-only (ADR-0049), and the\n  // platform's own build-time lint cannot see this shape\n  // because it is only knowable at run time. Measured on 17.0.0-rc.2: a\n  // user-less run refuses the very first data node \u2014 \"[runAs] refusing a data\n  // operation (object 'crm_case', event 'record-after-update')\" \u2014 so a case\n  // raised by the seed loader, an integration, or another runAs:'system'\n  // flow's write silently keeps its critical priority forever.\n  //\n  // Elevating the USER-driven runs too is correct here: escalation is a\n  // service-level policy, not the writer's own edit. Both data nodes are keyed\n  // to `{record.id}` \u2014 the row that just fired the trigger \u2014 so user scope\n  // buys no restriction that matters, while it does add a failure mode: an\n  // agent may legitimately raise a case without holding edit rights on the\n  // escalation lifecycle fields (`is_escalated` / `escalated_date` / `status`).\n  // This also puts the flow on the same footing as `case_sla_monitor`, which\n  // performs the same escalation on a schedule under `runAs: 'system'`.\n  runAs: 'system',\n\n  variables: [\n    { name: 'caseId', type: 'text', isInput: true, isOutput: false },\n  ],\n\n  nodes: [\n    {\n      // Trigger wiring (7.4): bind to afterUpdate and gate on the critical\n      // transition. The re-fire guard MUST NOT rely on the boolean\n      // `is_escalated`: this flow's own escalation write re-triggers\n      // record-after-update, and on SQLite/libsql a boolean persists as integer\n      // `1`, so `record.is_escalated != true` is `1 != true` = true \u2014 the guard\n      // never trips and the flow loops forever (it wedged a first-boot seed on\n      // 2026-07-06). Instead:\n      // - `escalated_date == null` marks \"never escalated\" (the escalation write\n      //   stamps it, suppressing the second fire AND any re-escalation when an\n      //   agent later moves the case back to in_progress to work it);\n      // - the status terms keep the flow off cases already escalated or already\n      //   finished \u2014 without them a critical case could never be resolved or\n      //   closed (the flow would yank `status` straight back to `escalated`).\n      id: 'start', type: 'start', label: 'Start',\n      config: {\n        objectName: 'crm_case',\n        triggerType: 'record-after-update',\n        // Also suppress on closed/resolved: closing a critical case is itself\n        // an afterUpdate, and with only the `!= \"escalated\"` guard this flow\n        // re-escalated the case the moment it was closed (observed live:\n        // close_case wrote status \"closed\", this flow immediately rewrote it\n        // to \"escalated\"). Status strings are the reliable guard \u2014 comparing\n        // the boolean is_closed suffers the SQLite `1 != true` trap above.\n        // `escalated_date == null` additionally keeps a case that was already\n        // escalated once (then reopened) from being escalated again.\n        //\n        // TOTALITY: every `record.x` read carries a `has(record.x)`\n        // guard \u2014 see the house-rule block in\n        // `test/flow-condition-totality.test.ts`. Measured end-to-end on\n        // driver-memory: a case BORN critical is stored without an\n        // `escalated_date` column at all, `record.escalated_date == null`\n        // aborted with `No such key: escalated_date`, and this flow never ran\n        // on the very population it exists for. The guards below preserve the\n        // predicate's answer on every shape where it previously had one.\n        // `escalated_date` absent means the same as null (\"never escalated\");\n        // an absent `status` cannot be a terminal status, so it must not\n        // suppress the escalation.\n        condition: P`has(record.priority) && record.priority == \"critical\"\n          && (!has(record.escalated_date) || record.escalated_date == null)\n          && (!has(record.status)\n            || (record.status != \"escalated\" && record.status != \"resolved\" && record.status != \"closed\"))`,\n      },\n    },\n    {\n      id: 'get_case', type: 'get_record', label: 'Get Case Record',\n      config: { objectName: 'crm_case', filter: { id: cel`record.id` }, outputVariable: 'caseRecord' },\n    },\n    {\n      // The `label` names what this node actually does: it flags the case as\n      // escalated (see `fields` below) and reassigns nothing. The `id` keeps\n      // its original `assign_senior_agent` spelling on purpose \u2014 `edges[]`\n      // reference nodes by id, and `CaseEscalationOnCreateFlow` rewrites the\n      // node list by id, so renaming one is a behaviour change, not a wording\n      // fix.\n      id: 'assign_senior_agent', type: 'update_record', label: 'Flag as Escalated',\n      config: {\n        objectName: 'crm_case', filter: { id: cel`record.id` },\n        // `escalation_reason` must be set whenever `is_escalated` flips true \u2014 the\n        // object's `escalation_reason_required` validation rejects the write\n        // otherwise (which silently aborted this flow until it was supplied).\n        //\n        // \u26D4 This node writes NO owner, and cannot: reassigning from a flow\n        // would mean `{caseRecord.owner_id.manager}`, and a flow template\n        // cannot traverse a lookup \u2014 it interpolates to the literal \"undefined\"\n        // and would orphan the case under a phantom owner. The hand-off does not\n        // need to happen here: this very update fires the\n        // `case_escalation_reassign` beforeUpdate hook\n        // (`src/service/objects/_case-assignment.ts`), which puts the case with the\n        // least-loaded holder of the flat `service_manager` position \u2014 a pool,\n        // which the app can resolve, rather than a manager chain, which it\n        // cannot. With that pool unstaffed the case keeps its owner and this\n        // write is unchanged.\n        fields: { is_escalated: true, escalation_reason: 'Auto-escalated: critical priority', escalated_date: cel`isoDatetime(now())`, status: 'escalated' },\n      },\n    },\n    // No `create_task` node here: the escalation write above flips `status` to\n    // `escalated`, which fires the `case_status_side_effects` hook \u2014 the single\n    // owner of escalation follow-up tasks (it also covers the `escalate_case`\n    // action and the SLA monitor). A second task node here produced duplicate,\n    // disagreeing tasks (case owner/high vs account owner/urgent) per escalation.\n    {\n      // Gateway only \u2014 the live predicate is on the out-edge `e4`. The engine\n      // never reads a `decision` node's singular `config.condition`, so a copy\n      // here would restate the gate without BEING the gate\n      // (`flow-inert-node-condition`); `pnpm lint` \u2014 `os lint --strict` \u2014\n      // fails on that.\n      //\n      // Why the gate exists: `crm_case.owner_id` is NULLABLE and an unowned case\n      // is an ordinary state \u2014 this repo ships `scripts/backfill-owner-id.ts`\n      // and `pnpm backfill:owner` precisely because ownerless rows happen, and\n      // ordinary REST creation / import reach the same state. `notify_team`\n      // below addresses exactly ONE recipient, so an ownerless case leaves it\n      // with an empty slate, which the builtin node treats as a HARD failure:\n      // `execute` returns `success: false`, `executeNode` turns that into a\n      // throw, and the run ends `status: 'failed'`.\n      //\n      // BLAST RADIUS, stated precisely because it differs from the sibling\n      // defect in `case_sla_monitor` and the difference is structural: these two\n      // are `record_change` flows with NO loop, so one ownerless case kills only\n      // its OWN run \u2014 there is no queue of other records behind it. A `schedule`\n      // flow whose work sits inside a `loop` awaits `runRegion` with no\n      // try/catch, and there one ownerless row takes down every record ordered\n      // behind it.\n      //\n      // \u26D4 The gate sits AFTER `assign_senior_agent`, which stays\n      // UNCONDITIONAL: the escalation itself must still land (measured\n      // `is_escalated: true`, `status: 'escalated'` on every failing run), so an\n      // ownerless critical case stays visible in views and reports. Only the\n      // notify is gated \u2014 and here that loses nothing a reader would want,\n      // because `caseRecord` is read by `get_case` UPSTREAM of the escalation\n      // write, so `{caseRecord.owner_id}` is deliberately the owner the case had\n      // BEFORE the hand-off. With no such person there is no \"previous owner\"\n      // for the message to be addressed to.\n      //\n      // \u26A0\uFE0F This guard is exactly the duplication objectstack#13682 exists to\n      // retire \u2014 `notify` should treat an empty audience as a RECORDED SKIP\n      // rather than a hard failure. When that lands, delete this node and edge\n      // `e4`'s predicate here, and the same pair in `case-sla-monitor.flow.ts`.\n      id: 'check_owner', type: 'decision', label: 'Case Has an Owner?',\n    },\n    {\n      // ADR-0012: the dedicated `notify` node dispatches through the messaging\n      // service (inbox + email + push). The legacy `script` + `actionType:'email'`\n      // shape is a no-op stub in 7.4 and never delivered anything.\n      // Owner only: `{caseRecord.owner_id.manager}` cannot traverse a lookup in\n      // flow templates \u2014 it interpolates to the literal \"undefined\".\n      // The `label` names the single recipient this node has (`recipients`\n      // below); the `id` keeps its `notify_team` spelling because `edges[]`\n      // reference it. Cf. the same node in `case-sla-monitor.flow.ts`, whose\n      // label already says `Alert Owner`.\n      id: 'notify_team', type: 'notify', label: 'Notify Case Owner',\n      config: {\n        // Owner only, and the owner it reaches is the one the case had BEFORE\n        // the escalation: `caseRecord` was read by `get_case` upstream of the\n        // write, so `{caseRecord.owner_id}` is the agent being handed off from\n        // \u2014 exactly the person this message is for. Flow templates cannot\n        // traverse a lookup (see the note on `assign_senior_agent` above):\n        // `{caseRecord.owner_id.manager}` and `{caseRecord.crm_account.name}`\n        // both interpolate to the literal string \"undefined\" \u2014 a phantom\n        // recipient and a garbled body.\n        recipients: [cel`caseRecord.owner_id`],\n        channels: ['inbox', 'email'],\n        severity: 'critical',\n        topic: 'case_escalated',\n        // \u26A0\uFE0F The body \u2014 now `crm.case_escalated` in `../email-templates/`, one\n        // row per locale \u2014 must stay true on BOTH outcomes. \"It remains\n        // assigned to you\" is false whenever the hand-off finds a manager; the\n        // opposite claim (\"it has been reassigned\") is false whenever the\n        // `service_manager` pool is unstaffed, which is the first-install norm.\n        // So it states the rule and points at the record for the answer, in\n        // every language.\n        template: 'crm.case_escalated',\n        templateData: { case_number: cel`caseRecord.case_number`, priority: cel`caseRecord.priority` },\n        actionUrl: '/crm_case/{{record.id}}',\n      },\n    },\n    { id: 'end', type: 'end', label: 'End' },\n  ],\n\n  edges: [\n    { id: 'e1', source: 'start', target: 'get_case', type: 'default' },\n    { id: 'e2', source: 'get_case', target: 'assign_senior_agent', type: 'default' },\n    { id: 'e3', source: 'assign_senior_agent', target: 'check_owner', type: 'default' },\n    // The gate. A `decision` with no matching out-edge simply ends the run\n    // here, after the escalation has already been written.\n    //\n    // TOTALITY: `caseRecord` is a `get_record` OUTPUT \u2014 a raw driver row, sparse\n    // in the way `driver-memory` / `driver-mongodb` store only the columns a row\n    // was written with \u2014 so only `has()` is total, and it must be `vars.`-scoped\n    // (measured: bare `has(caseRecord.owner_id)` still aborts with `Unknown\n    // variable` on an unbound root, while `has(vars.caseRecord)` answers\n    // `false`).\n    //\n    // \u26D4 EVERY TERM IS LOAD-BEARING \u2014 do not simplify this predicate. The last\n    // one MIRRORS THE NOTIFY NODE'S OWN emptiness rule rather than guessing at\n    // it: builtin `notify` builds its audience with `String(v).trim()` +\n    // `.filter(Boolean)`, so null, undefined, `''` and any all-whitespace value\n    // all collapse to the same empty slate. Each term was measured through\n    // `evaluateCondition` on the shape it alone covers, by dropping it and\n    // recording what the rest do:\n    //   - `has(vars.caseRecord)` \u2014 an UNBOUND root. Without it the predicate\n    //     aborts with `No such key: caseRecord`. `get_case` binds the variable\n    //     on every path here (it sets it even when it matched nothing), so this\n    //     term is what keeps a future graph edit from turning a gate into an\n    //     abort \u2014 and the `vars.`-scoped `has()` pair is the house rule\n    //     `test/flow-variable-conditions.test.ts` enforces.\n    //   - `has(vars.caseRecord.owner_id)` \u2014 the ABSENT key. Without it,\n    //     `vars.caseRecord.owner_id != null` aborts with `No such key: owner_id`.\n    //   - `vars.caseRecord.owner_id != null` \u2014 the explicit NULL. Without it the\n    //     wrap is handed one and aborts with `no matching overload for\n    //     'string(null)'`, so this term must short-circuit in front of it.\n    //   - `string(...).trim() != \"\"` \u2014 the BLANK/whitespace id. `'   ' != \"\"` is\n    //     TRUE in CEL, so a gate written that way opens for a whitespace\n    //     `owner_id` and reproduces this very defect one input narrower. The\n    //     `string()` wrap is not decoration either: measured, a bare `.trim()`\n    //     on a numeric id aborts with `no matching overload for\n    //     'double.trim()'` and `.matches()` with `'double.matches(string)'` \u2014 a\n    //     thrown condition, the fault mode this gate exists to remove.\n    //\n    // \u26D4 Do NOT add a `vars.caseRecord != null` term for the row that is GONE by\n    // the time `get_case` reads it. Measured INERT: `get_record` with no match\n    // sets the variable to `null`, key present, and `has()` on a null base\n    // answers `false` rather than aborting, so the four terms above already\n    // close that shape (`test/flow-escalation-ownerless-case.test.ts` covers\n    // it). A term that cannot change an answer is an inert copy, not defence in\n    // depth.\n    { id: 'e4', source: 'check_owner', target: 'notify_team', type: 'conditional', condition: P`has(vars.caseRecord) && has(vars.caseRecord.owner_id)\n      && vars.caseRecord.owner_id != null && string(vars.caseRecord.owner_id).trim() != \"\"`, label: 'Has owner' },\n    { id: 'e5', source: 'notify_team', target: 'end', type: 'default' },\n  ],\n};\n\n/**\n * Insert-time twin of `case_escalation`: a record-change flow binds exactly one\n * hook event, so the afterUpdate flow above never sees cases that are BORN\n * critical (phone-in P1s \u2014 the common path). Same nodes/edges, only the start\n * node is rebound to afterInsert. The `escalated_date == null` + status guard\n * carries over untouched (a case born critical has neither).\n */\nexport const CaseEscalationOnCreateFlow: Flow = {\n  ...CaseEscalationFlow,\n  name: 'case_escalation_on_create',\n  label: 'Case Escalation Process (on create)',\n  description: 'Escalate cases created critical (insert-time twin of case_escalation)',\n  nodes: CaseEscalationFlow.nodes.map((n) =>\n    n.id === 'start'\n      ? { ...n, config: { ...n.config, triggerType: 'record-after-create' } }\n      : n,\n  ),\n};\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/service/flows/case-actions.flow.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/service/flows\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/service/flows/case-actions.flow.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport { cel } from '@objectstack/spec';\nimport type * as Automation from '@objectstack/spec/automation';\nimport { CLAIMABLE_TARGET_STATUSES } from '../objects/_case-assignment';\ntype Flow = Automation.Flow;\n\n/**\n * Screen flows behind the Claim Case / Escalate Case / Close Case header\n * actions.\n *\n * \u26D4 Never re-express these as `body`-typed actions (verified against the\n * running 16.1.0 console, 2026-07-28):\n *\n *  - `type: 'modal'` never executes the body at all \u2014 on submit the console\n *    resolves the action `target` as an OBJECT name and dies on\n *    `GET /api/v1/meta/object/<target>` \u2192 400 (\"Error loading form\").\n *  - `type: 'script'` DOES reach `POST /api/v1/actions/...`, but a body that\n *    UPDATES a record on an object with sharing rules is rejected by the\n *    sharing middleware (\"FORBIDDEN: insufficient privileges to update\n *    crm_case \u2026\") \u2014 the sandbox execution context does not carry the caller\n *    identity, so `canEdit` fails even for the record owner. Inserts are\n *    unaffected (clone_opportunity works), updates are not.\n *  - Screen flows execute through the automation service, whose\n *    `update_record` nodes demonstrably write `crm_case` (the\n *    case_escalation record-change flow does exactly that in production).\n *\n * Same mechanism as `schedule_followup` / `lead_conversion`.\n */\nexport const EscalateCaseFlow: Flow = {\n  name: 'escalate_case',\n  label: 'Escalate Case',\n  description: 'Collect an escalation reason, then flag and re-prioritise the case.',\n  type: 'screen',\n  status: 'active',\n\n  variables: [\n    // MUST be `recordId` \u2014 the console's flow-action contract seeds only that\n    // name (and its camelCase object alias); a custom name arrives undefined.\n    { name: 'recordId', type: 'text', isInput: true, isOutput: false },\n    { name: 'reason', type: 'text', isInput: true, isOutput: false },\n  ],\n\n  nodes: [\n    { id: 'start', type: 'start', label: 'Start', config: { objectName: 'crm_case' } },\n    {\n      id: 'screen_1', type: 'screen', label: 'Escalate Case',\n      config: {\n        fields: [\n          { name: 'reason', label: 'Escalation Reason', type: 'textarea', required: true },\n        ],\n      },\n    },\n    {\n      // The USER-CONTEXT half of the escalation. Everything here is a\n      // column the acting agent may legitimately write, so it is written with\n      // their identity \u2014 this flow stays `runAs: 'user'`.\n      //\n      //   escalation_reason  the agent's own screen input\n      //   priority           an ordinary editable field\n      //   status             ordinary, and the hook trigger (below)\n      //\n      // The two stamps a person never types \u2014 `is_escalated` and\n      // `escalated_date` \u2014 are `readonly: true` on `crm_case` and are written\n      // by the `case_escalation_stamp` subflow that follows, with the system\n      // context. See `src/service/flows/case-escalation-stamp.flow.ts`.\n      //\n      // \u26A0\uFE0F `status: 'escalated'` MUST stay in this node, and not only because\n      // it is user-writable: it is the trigger both escalation hooks key off \u2014\n      // `case_escalation_reassign` (`_case-assignment.ts`) gates on\n      // `input.status !== 'escalated' || previous.status === 'escalated'`, and\n      // `case_status_side_effects` (`case.hook.ts`) reads the same transition.\n      // Keeping it here keeps the ownership hand-off and the side-effect tasks\n      // firing from the ACTING USER's write, exactly as they did before the\n      // split. Moving it into the elevated subflow would silently re-attribute\n      // both to the system.\n      //\n      // It is also what suppresses a double-fire of the automatic\n      // `case_escalation` record-change flow.\n      id: 'escalate', type: 'update_record', label: 'Escalate Case',\n      config: {\n        objectName: 'crm_case',\n        filter: { id: cel`recordId` },\n        fields: {\n          escalation_reason: cel`reason`,\n          status: 'escalated',\n          priority: 'critical',\n        },\n      },\n    },\n    {\n      // The ELEVATED half, and the only elevation in this flow: one\n      // `runAs: 'system'` flow, one `update_record`, two readonly columns.\n      // The maintainer-approved direction \u2014 elevate the write, not the flow.\n      //\n      // \u26A0\uFE0F THIS NODE MUST RUN AFTER `escalate`, NOT BEFORE. `crm_case`'s\n      // `escalation_reason_required` validation rejects any write whose merged\n      // record has `is_escalated == true` and a blank `escalation_reason`. The\n      // reason is written by the node above, so by the time the flag flips it\n      // is already stored. Reversing these two nodes fires that validation\n      // against a record with no reason yet and the stamp is rejected.\n      //\n      // \u26D4 Do not \"simplify\" this by giving THIS flow `runAs: 'system'` and\n      // folding the stamp back into the node above. That is option A, costed\n      // and explicitly not adopted: it elevates every write this screen flow\n      // makes and stops it carrying the acting user's context downstream.\n      // `AGENTS.md` house rule 9 states it as standing policy.\n      id: 'stamp_escalation', type: 'subflow', label: 'Stamp Escalation Flags',\n      config: {\n        flowName: 'case_escalation_stamp',\n        input: { recordId: cel`recordId` },\n      },\n    },\n    { id: 'end', type: 'end', label: 'End' },\n  ],\n\n  edges: [\n    { id: 'e1', source: 'start', target: 'screen_1', type: 'default' },\n    { id: 'e2', source: 'screen_1', target: 'escalate', type: 'default' },\n    { id: 'e3', source: 'escalate', target: 'stamp_escalation', type: 'default' },\n    { id: 'e4', source: 'stamp_escalation', target: 'end', type: 'default' },\n  ],\n};\n\nexport const CloseCaseFlow: Flow = {\n  name: 'close_case',\n  label: 'Close Case',\n  description: 'Collect the resolution, then close the case and stop the SLA clock.',\n  type: 'screen',\n  status: 'active',\n  // `is_closed` is a readonly lifecycle field. This trusted screen flow owns\n  // the transition and must therefore run with the system writer.\n  //\n  // \u26D4 A HISTORICAL PRECEDENT, NOT A POLICY \u2014 do not cite this line to justify\n  // elevating another screen flow (#1434, the maintainer ruling that settled\n  // it). The standing rule is the opposite one: a screen flow stays\n  // `runAs: 'user'` and a write that genuinely needs elevation is split into a\n  // dedicated `system` sub-flow reached by a `subflow` node \u2014 see\n  // `escalate_case` above and `src/service/flows/case-escalation-stamp.flow.ts`.\n  // \"Readonly stripped my write, so I made the flow system\" is the pattern\n  // that ruling exists to stop being copied; `AGENTS.md` house rule 9 carries\n  // it as house policy. This flow predates that rule and has not been\n  // re-shaped to match it.\n  runAs: 'system',\n\n  variables: [\n    { name: 'recordId', type: 'text', isInput: true, isOutput: false },\n    { name: 'resolution', type: 'text', isInput: true, isOutput: false },\n    { name: 'resolved_by_article', type: 'text', isInput: true, isOutput: false },\n  ],\n\n  nodes: [\n    { id: 'start', type: 'start', label: 'Start', config: { objectName: 'crm_case' } },\n    {\n      // The \"attach the article that resolved it\" affordance. Optional\n      // on purpose: most cases are not resolved out of the knowledge base, and\n      // a required field here would be answered with a junk value rather than\n      // left honest \u2014 which is worse than an absent link for a measure whose\n      // whole job is to say how OFTEN the KB resolves a case.\n      //\n      // `reference` names the object the picker offers. Up to\n      // `@objectstack/spec@17.4.0` a screen field had no such key, so this\n      // `type: 'lookup'` field had nothing to resolve a record picker from;\n      // 17.5.0 added `reference` to `ScreenFieldConfigSchema` and made it\n      // REQUIRED on a lookup screen field (#17913) \u2014 the stack does not load\n      // without it. It is the same target the case's own `resolved_by_article`\n      // lookup declares (`crm_knowledge_article`).\n      //\n      // The `Resolved by Article` lookup in the case's Resolution group, on the\n      // record form, writes the same column; the action is\n      // `refreshAfter: true`, so the record form is what the agent lands on\n      // immediately after closing.\n      id: 'screen_1', type: 'screen', label: 'Close Case',\n      config: {\n        fields: [\n          { name: 'resolution', label: 'Resolution', type: 'textarea', required: true },\n          {\n            name: 'resolved_by_article',\n            label: 'Resolved by Article (optional)',\n            type: 'lookup',\n            reference: 'crm_knowledge_article',\n            required: false,\n          },\n        ],\n      },\n    },\n    {\n      // `resolved_by_article` is written unconditionally, and a blank one is\n      // normalised to NULL by `case_resolution_article_normalize`\n      // (`src/service/objects/case.hook.ts`) rather than branched around here: MEASURED\n      // on the real engine, a screen field left empty resumes as `''` and lands\n      // as an empty string, which `count(resolved_by_article)` counts. A\n      // `decision` node could not have branched it either \u2014 this repo has\n      // measured `decision.config.condition` to be inert metadata\n      // (`test/win-loss-capture.test.ts`'s table of five such surfaces).\n      //\n      // The read is guarded because the field is optional: a resume that omits\n      // it leaves the variable unbound, which the 17.x template wrote as nothing\n      // (the stored link left alone) and CEL refuses. The guard writes NULL\n      // there \u2014 the value a blank field already lands as after the normalize\n      // hook \u2014 so an omitted answer and an empty one now close the case alike.\n      id: 'close', type: 'update_record', label: 'Close Case',\n      config: {\n        objectName: 'crm_case',\n        filter: { id: cel`recordId` },\n        fields: {\n          is_closed: true,\n          resolution: cel`resolution`,\n          status: 'closed',\n          resolved_by_article: cel`has(vars.resolved_by_article) ? resolved_by_article : null`,\n        },\n      },\n    },\n    { id: 'end', type: 'end', label: 'End' },\n  ],\n\n  edges: [\n    { id: 'e1', source: 'start', target: 'screen_1', type: 'default' },\n    { id: 'e2', source: 'screen_1', target: 'close', type: 'default' },\n    { id: 'e3', source: 'close', target: 'end', type: 'default' },\n  ],\n};\n\n/**\n * Claim Case \u2014 the triage claim gesture, given a button.\n *\n * ## What this flow is, and what it deliberately is NOT\n *\n * The claim already exists as behaviour: an agent moves an unowned case out of\n * **Unassigned \u2014 triage** by setting its status to one that means a person is\n * on it, and `case_self_claim` (`src/service/objects/_case-assignment.ts`, priority\n * 260) stamps `owner_id` with the caller. This flow is the screen that says so.\n *\n * It is **pure UI over the existing seam**. Its one write is the\n * STATUS MOVE. It does not write `owner_id`, and that is not a style choice:\n *\n *  - the ownership-transfer gate refuses any payload carrying `owner_id` in the\n *    sharing MIDDLEWARE, upstream of the hook phase, and a screen flow's\n *    `update_record` runs as the caller \u2014 so a flow that wrote the column would\n *    be refused exactly like a hand-written update, loudly and always;\n *  - and `case_self_claim` guard 2 stands down the moment `owner_id` is already\n *    in the payload, so even a caller holding `allowTransfer` would take the\n *    claim seam out of the picture rather than drive it.\n *\n * Ownership therefore keeps exactly ONE writer. `test/claim-case-one-owner-writer.test.ts`\n * is that sentence turned into a guard, so it is enforced rather than intended.\n *\n * ## Why `runAs: 'user'`, spelled out rather than defaulted\n *\n * House rule 9 (`AGENTS.md`) already says a screen flow stays `runAs: 'user'`,\n * but here the default is LOAD-BEARING and worth reading twice: `case_self_claim`\n * returns early for a write with no user, and again for `ctx.session.isSystem`.\n * An elevated run of this flow would move the status and claim NOTHING \u2014 the\n * case would leave the triage tab still ownerless. The declaration is explicit\n * so the next author sees the coupling before reaching for elevation.\n *\n * ## Why a screen, and why the picker is derived\n *\n * The three statuses that claim are one concept with three faces, and which one\n * an agent picks is real information (`waiting_customer` straight off a triage\n * row is a different day's work from `in_progress`). The options are built from\n * {@link CLAIMABLE_TARGET_STATUSES} \u2014 the seam's own declared set \u2014 rather than\n * hand-copied. \u26D4 Never hand-copy the subset: it silently drops an option from\n * the picker and nothing notices. A fourth claimable status makes the label map\n * below a COMPILE error rather than a quietly short picker.\n */\nconst CLAIM_STATUS_LABEL: Record<(typeof CLAIMABLE_TARGET_STATUSES)[number], string> = {\n  in_progress: 'In Progress',\n  waiting_customer: 'Waiting on Customer',\n  waiting_support: 'Waiting on Support',\n};\n\n/** The picker, derived from the seam's set. Labels are pinned to `crm_case.status`'s own. */\nconst CLAIM_STATUS_OPTIONS = CLAIMABLE_TARGET_STATUSES.map((value) => ({\n  value,\n  label: CLAIM_STATUS_LABEL[value],\n}));\n\nexport const ClaimCaseFlow: Flow = {\n  name: 'claim_case',\n  label: 'Claim Case',\n  description: 'Take an unowned case out of triage by moving it to a status that means you are on it.',\n  type: 'screen',\n  status: 'active',\n  // Load-bearing, not boilerplate \u2014 see the header. A system run claims nobody.\n  runAs: 'user',\n\n  variables: [\n    // MUST be `recordId` \u2014 the console's flow-action contract seeds only that\n    // name (and its camelCase object alias); a custom name arrives undefined.\n    { name: 'recordId', type: 'text', isInput: true, isOutput: false },\n    { name: 'claimStatus', type: 'text', isInput: true, isOutput: false },\n  ],\n\n  nodes: [\n    { id: 'start', type: 'start', label: 'Start', config: { objectName: 'crm_case' } },\n    {\n      id: 'screen_1', type: 'screen', label: 'Claim Case',\n      config: {\n        fields: [\n          {\n            name: 'claimStatus', label: 'Working status', type: 'select', required: true,\n            defaultValue: 'in_progress',\n            options: CLAIM_STATUS_OPTIONS,\n          },\n        ],\n      },\n    },\n    {\n      // \u26D4 `status` is the ONLY field this node may ever carry. Adding\n      // `owner_id` here does not \"make the claim explicit\" \u2014 it makes the write\n      // refused by the transfer gate before any hook runs, and it takes\n      // `case_self_claim` out of the path on the one caller it would reach.\n      // The guard beside this file fails on any such addition.\n      id: 'claim', type: 'update_record', label: 'Claim Case',\n      config: {\n        objectName: 'crm_case',\n        filter: { id: cel`recordId` },\n        fields: {\n          status: cel`claimStatus`,\n        },\n      },\n    },\n    { id: 'end', type: 'end', label: 'End' },\n  ],\n\n  edges: [\n    { id: 'e1', source: 'start', target: 'screen_1', type: 'default' },\n    { id: 'e2', source: 'screen_1', target: 'claim', type: 'default' },\n    { id: 'e3', source: 'claim', target: 'end', type: 'default' },\n  ],\n};\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/service/objects/_case-assignment.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/service/objects\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/service/objects/_case-assignment.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport type { Hook, HookContext } from '@objectstack/spec/data';\nimport type { HookApi } from '../../sales/objects/_hook-api';\n\n/**\n * \u2550\u2550\u2550 Case ownership assignment \u2014 the app-level stand-in for a missing queue \u2550\u2550\n *\n * # \u26D4 This module is a STOPGAP. It is the code to delete.\n *\n * Salesforce-shaped case intake routes an ownerless case into a QUEUE and lets\n * agents pull from it. ObjectStack has no queue engine: `sys_queue` does not\n * exist, and the `queue` sharing-recipient and approver enum members are\n * deprecated upstream. So a web-to-case submission \u2014 whose `owner_id` is\n * deliberately stripped by the guest-sanitisation branch of `case_sla_defaults`\n * \u2014 has nowhere to sit and lands with nobody accountable for it.\n *\n * This module substitutes a load-balanced round-robin for the missing queue, at\n * the app layer, the same way `lead_auto_assign` (`lead.hook.ts`) does for\n * inbound leads. **When a platform `sys_queue` or assignment-rule engine lands,\n * this whole module is reclaimed \u2014 not adapted.** Its replacement is\n * declarative queue metadata; a hook that picks an owner by counting rows is not\n * something to keep alongside one. Delete the module, delete its hooks from\n * `case.hook.ts`, and re-point the triage view at the queue.\n *\n * It is a MODULE rather than a branch in `case.hook.ts` so that \"who should own\n * this case\" has ONE home: all three factories below read a POSITION POOL and\n * pick its least-loaded holder, differing only in pool, seam and trigger.\n *\n * # \u26A0\uFE0F The L2 sandbox constraint \u2014 the shape every handler here must take\n *\n * L2 hook bodies run BODY-ONLY inside QuickJS: the handler is lowered to a\n * source string with no module scope, so a body referencing an import, a\n * top-level const or a factory PARAMETER is a `ReferenceError` at runtime, not\n * a closure. `test/action-sandbox.test.ts` lowers every hook in `allHooks` with\n * the CLI build's own extraction pass and fails the ones that leak.\n *\n * So sharing here is authoring-time sharing: the FACTORY composes the hook and\n * owns the doc, the constants and the contract; the handler body closes over\n * nothing but its own `ctx` and spells its literals INLINE. The duplication is\n * not accidental \u2014 it is the only shape the runtime accepts \u2014 and what keeps it\n * honest is a behavioural pin: `test/case-assignment.test.ts` drives the real\n * handler and asserts the pool it queries is exactly\n * {@link SERVICE_AGENT_POSITION}, so constant and literal cannot drift quietly.\n *\n * # \u26A0\uFE0F The ownership-transfer gate (#3004), and the three doors through it\n *\n * Stamping another user's `owner_id` is an ownership TRANSFER, denied unless\n * the caller holds `allowTransfer` on the object (`@objectstack/spec`\n * `security/permission.zod.ts`). `crm_case.allowTransfer` is NOT granted to\n * `service_agent`, and granting it would widen what an agent may do to a case\n * generally \u2014 a permission-model change, not a hook change.\n *\n * The gate is an operation middleware wrapping the whole call, so what it sees\n * depends entirely on the seam a write uses. Measured against the full shipped\n * stack (ObjectQL + `plugin-security` + `plugin-sharing` over this app's own\n * `objectstack.config.ts`), with negative controls proving the observations are\n * not vacuous, and pinned in `test/case-assignment.test.ts` and\n * `test/ownership-model.test.ts`:\n *\n *   \u2460 A `beforeInsert` / `beforeUpdate` hook STAMPING `owner_id` onto a payload\n *      that did not carry the key is INVISIBLE to the gate \u2014 the middleware\n *      observes the payload as authored, and the stored row carries the stamp.\n *      This is the door all three factories here use, and it is why none of\n *      them needs a permission grant.\n *   \u2461 A hook's `ctx.api` WRITE is a fresh operation carrying the caller's\n *      identity, so the gate DOES see it. That is why `case_status_side_effects`\n *      opening an escalation task under the account owner needs\n *      `service_agent.crm_task.allowTransfer`.\n *   \u2462 A caller-supplied `owner_id` is refused INSIDE the middleware, upstream\n *      of the hook phase \u2014 the hook never fires at all. No hook can approve,\n *      launder or adjudicate a payload that carries the key.\n *\n * \u21D2 \"An agent may set `owner_id` to themselves\" is not implementable as an\n * adjudicated write. It IS implementable one level up, as a GESTURE the hook\n * interprets: {@link createCaseSelfClaim}.\n *\n * \u26A0\uFE0F If a platform release moves the gate downstream of the hook phase, door \u2460\n * flips and those tests go red. The signal is then to grant `allowTransfer`\n * deliberately or to stop assigning in a hook \u2014 NOT to widen the permission\n * model to make a red test green.\n */\n\n/** The position whose holders form the case intake pool (`sys_user_position`). */\nexport const SERVICE_AGENT_POSITION = 'service_agent';\n\n/** The position ESCALATED cases are routed to. */\nexport const SERVICE_MANAGER_POSITION = 'service_manager';\n\n/**\n * Statuses that mean \"this case is no longer live work\".\n *\n * Load balancing counts OPEN cases, and `is_closed` is the wrong predicate:\n * it only flips on `closed`, so a pile of `resolved` cases would keep counting\n * against an agent who has already finished them. `case_sla_monitor` settles it\n * the same way \u2014 see the `$nin` note in `src/service/flows/case-sla-monitor.flow.ts`,\n * which also records that comparing the boolean `is_closed` walks into the\n * SQLite `1 != true` trap.\n */\nexport const CLOSED_CASE_STATUSES = ['resolved', 'closed'] as const;\n\n/** Cap on the pool read \u2014 the same bound `lead_auto_assign` uses. */\nexport const POOL_QUERY_LIMIT = 1000;\n\n/**\n * The statuses that mean \"a human has picked this case up and it is not\n * finished\" \u2014 the gesture {@link createCaseSelfClaim} reads as a claim.\n *\n * One concept, not three arbitrary picks: each says a person is engaged and the\n * work is still live. The four statuses NOT here are excluded for a reason\n * apiece:\n *\n *   - `new` \u2014 the state a triage row is already IN. Not a move, so not a claim.\n *   - `escalated` \u2014 {@link createCaseEscalationReassign} owns that transition\n *     and routes to the `service_manager` pool. Two hooks answering \"who owns\n *     this case\" for one status change is the \"one operation, two\n *     implementations\" shape this module exists to prevent.\n *   - `resolved` / `closed` \u2014 finishing a case is not picking it up. An agent\n *     may still resolve an unowned case straight out of triage (the share\n *     grants edit); that records them in `updated_by` and leaves the ownership\n *     column honest about the fact that nobody ever took the work.\n *\n * \u26A0\uFE0F Declared here for the doc and the tests \u2014 the handler body spells the same\n * three strings INLINE, because the L2 sandbox gives it no module scope (see\n * this file's header). `test/unassigned-case-triage-reach.test.ts` drives every\n * one of them through the real engine, so the copies cannot drift.\n */\nexport const CLAIMABLE_TARGET_STATUSES = [\n  'in_progress',\n  'waiting_customer',\n  'waiting_support',\n] as const;\n\n/**\n * Round-robin assignment for ownerless new cases.\n *\n * A case created without an owner \u2014 a web-to-case submission, an email-to-case\n * import, an API capture \u2014 is assigned to the service agent with the FEWEST\n * OPEN cases. Least-loaded is a self-balancing round-robin: no rotation\n * counter, no stored cursor, no coordination between concurrent inserts. It\n * writes `owner_id`, the platform ownership anchor that OWD, sharing rules and\n * the \"My Open Cases\" view all read, so the agent really owns the case rather\n * than merely being named on it.\n *\n * ## Priority 250: it MUST run after `case_sla_defaults` (200)\n *\n * Hooks run in ASCENDING priority order, and `case_sla_defaults` is where the\n * guest-sanitisation branch assigns `input.owner_id = null` to drop a\n * client-spoofed owner from an anonymous submission. Assigning first and being\n * stripped afterwards would land every web-to-case ownerless \u2014 the exact case\n * this hook exists for. `test/case-assignment.test.ts` pins the ordering.\n *\n * ## The empty pool is the FIRST-INSTALL NORM, not an edge case\n *\n * `sys_user_position` membership is runtime data. Before anyone holds the\n * `service_agent` position the pool is empty and this hook is a NO-OP: the case\n * is created and stays ownerless. Never blocking intake is correct, but silent\n * ownerlessness hides the problem, so the no-op path has a UI counterpart \u2014 the\n * `unassigned_triage` pinned tab on `crm_case` (`src/service/views/case.view.ts`) shows\n * exactly the cases this hook could not place.\n *\n * ## Best-effort, always\n *\n * Auto-assignment is an ENHANCEMENT and must never reject the insert. An\n * anonymous Web-to-Case submission runs under the public-form grant, which\n * permits create/read-back on `crm_case` and DENIES `find` on\n * `sys_user_position`; letting that denial propagate would 403 the whole\n * submission and break the public support form. So every read is wrapped and\n * ANY failure leaves the case ownerless for the triage view to surface.\n *\n * @param hookName registry name for the hook (metadata only \u2014 never read by\n *   the body, which the sandbox would not let it be).\n */\nexport function createCaseRoundRobinAssign(hookName = 'case_auto_assign'): Hook {\n  return {\n    name: hookName,\n    object: 'crm_case',\n    events: ['beforeInsert'],\n    priority: 250,\n    description: 'Assign ownerless new cases to the least-loaded service agent.',\n    handler: async (ctx: HookContext) => {\n      const { input } = ctx;\n      // Respect an explicit / creator-assigned owner. On any write that carries\n      // a user the security middleware has ALREADY stamped `owner_id` to that\n      // user by the time this runs, so this is also what keeps the round-robin\n      // scoped to genuinely ownerless intake rather than firing on every\n      // agent-created case.\n      if (typeof input.owner_id === 'string' && input.owner_id) return;\n      const api = ctx.api as HookApi | undefined;\n      if (!api) return;\n\n      try {\n        // The pool = holders of the `service_agent` position. This literal is\n        // the exported SERVICE_AGENT_POSITION; the sandbox forbids reading the\n        // constant here, and `test/case-assignment.test.ts` pins the parity.\n        const holders = await api.object('sys_user_position').find({\n          where: { position: 'service_agent' }, fields: ['user_id'], top: 1000,\n        });\n        const agentIds = Array.from(\n          new Set(\n            (holders ?? [])\n              .map((r) => (typeof r.user_id === 'string' ? r.user_id : ''))\n              .filter(Boolean),\n          ),\n        );\n        // No pool \u2192 leave the case ownerless (no-op). The `unassigned_triage`\n        // view is what makes this visible instead of silent.\n        if (agentIds.length === 0) return;\n\n        // Fewest OPEN cases wins. `$nin` over statuses rather than\n        // `is_closed: false`: a resolved case is finished work and must stop\n        // counting against its agent (same predicate as `case_sla_monitor`).\n        let best: string | undefined;\n        let bestCount = Infinity;\n        for (const agentId of agentIds) {\n          const openCount = await api.object('crm_case').count({\n            where: { owner_id: agentId, status: { $nin: ['resolved', 'closed'] } },\n          });\n          if (openCount < bestCount) {\n            bestCount = openCount;\n            best = agentId;\n          }\n        }\n        if (best) input.owner_id = best;\n      } catch {\n        // Swallow: assignment must never block case creation. The common case\n        // is the anonymous public-form context, which cannot read\n        // `sys_user_position` \u2014 the case is still captured, ownerless, and the\n        // triage view surfaces it. (No `console` here \u2014 the L2 hook sandbox\n        // does not define one.)\n      }\n    },\n  };\n}\n\n/**\n * Hand an escalating case to the least-loaded service manager.\n *\n * On the escalation TRANSITION the case moves to the holder of\n * {@link SERVICE_MANAGER_POSITION} with the fewest open cases \u2014 the same\n * least-loaded balance the intake round-robin computes, against a different\n * pool. Without it, escalation is only a flag, a status and an inbox message:\n * the agent who could not get to the case in time stays the only person who can\n * work it.\n *\n * \u26A0\uFE0F Positions are FLAT (`src/sales/sharing/positions.ts`), so \"the owner's manager\"\n * is not resolvable in this app \u2014 and a flow template referencing a lookup\n * traversal such as `{caseRecord.owner_id.manager}` interpolates to the literal\n * string `undefined` rather than failing. That is why the hand-off is a hook\n * and not a flow, and why the pool substitutes for the chain.\n *\n * ## `beforeUpdate`, not `afterUpdate`\n *\n * The `afterUpdate` shape (a `ctx.api` write) is a fresh operation and is\n * therefore VISIBLE to the transfer gate \u2014 it would need `crm_case.allowTransfer`\n * on `service_agent`, widening what an agent may do to a case generally. The\n * `beforeUpdate` door is invisible to the gate (this module's header, door \u2460),\n * so the hand-off costs no permission change.\n *\n * It also disposes of re-entrancy rather than guarding it: the hook performs NO\n * operation, mutating the payload of the update already in flight, so there is\n * no second write and no second `record-after-update` event for\n * `case_escalation` or `case_status_side_effects` to fire on. The predicate is\n * a TRANSITION rather than a state, so it is false on a replay, and the write\n * is idempotent \u2014 a case already owned by a pool member is left alone.\n * `test/case-assignment.test.ts` drives all three properties.\n *\n * ## The SLA sweep reaches this hook, and depends on it (#1405)\n *\n * `case_sla_monitor`'s `flag_breach` node writes `status: 'escalated'` on every\n * breached case, which IS the transition below \u2014 so the scheduled sweep puts an\n * ownerless breached case through this assignment without any flow-callable\n * seam, and the flow then re-reads the case (`reload_case`) to alert the owner\n * this hook produced. \u26A0\uFE0F That makes the TRANSITION predicate load-bearing for a\n * second caller: narrowing it to record-triggered escalations, or moving the\n * assignment to an `afterUpdate` write, silently returns the sweep to alerting\n * nobody for an unowned breach. `test/flow-sla-ownerless-assignment.test.ts`\n * drives the real flow through the real hook chain and goes red if it does.\n *\n * ## The empty pool: a no-op that is still VISIBLE\n *\n * `sys_user_position` membership is runtime data, and `service_manager` is\n * unstaffed on a fresh install. \u26A0\uFE0F The demo org is NO LONGER one of those: #1102\n * staffs Tomas Okafor into the position (`src/sales/sharing/demo-staffing.ts`), so the\n * exemplar now demonstrates the hand-off rather than the stand-down \u2014 which is\n * also what makes the sweep's assignment visible on this repo's own seed.\n *\n * With no pool the case keeps\n * its owner and the escalation completes as before. Unlike the intake path that\n * needs no new surface to stay visible: an escalated case is not ownerless, it\n * sits in the `escalated_cases` view, and `case_escalation_sharing` already\n * grants every `service_manager` edit access to open critical cases.\n *\n * ## Best-effort, always\n *\n * Reassignment is an ENHANCEMENT to the escalation, never a precondition. A\n * read denial, an empty pool or any other failure leaves the case with its\n * current owner and lets the escalation write through untouched.\n *\n * ## `runAs: 'system'` (#2014), and the organization pin\n *\n * The pool is `sys_user_position`, which a service agent may not read \u2014 so an\n * agent escalating their own case (the record form, or the `escalate_case`\n * action, whose `escalate` node deliberately keeps the status write in the\n * acting user's context) was refused the read, stood down, and the case stayed\n * with the agent who could not get to it; only the SLA sweep's system write\n * reached the pool. Choosing the escalation desk is the business's routing, not\n * the agent's privilege, so the hook elevates. What elevation reaches is the\n * two READS: the hook still issues no write of its own (door \u2460 above), so it\n * needs no transfer grant and moves nothing the escalation write is not\n * already moving.\n *\n * AGENTS.md rule 10: the pool and the load counts are organization-NEUTRAL\n * predicates (a position name, an owner id), so both are pinned to the\n * escalating case's own `organization_id` when it carries one. A person's\n * escalation is already confined by the driver \u2014 the elevated `ctx.api` keeps\n * the trigger's tenant \u2014 but the SLA sweep writes as the system with no\n * tenant at all, and without the pin its escalation would pick the\n * least-loaded manager of ANY organization. A case with no organization (a\n * single-organization install) has no wall to stay inside, and is not pinned.\n * Pinned, a manager whose position assignment is global (no organization)\n * does not receive a tenant's case.\n *\n * @param hookName registry name for the hook (metadata only \u2014 never read by\n *   the body, which the sandbox would not let it be).\n */\nexport function createCaseEscalationReassign(hookName = 'case_escalation_reassign'): Hook {\n  return {\n    name: hookName,\n    object: 'crm_case',\n    events: ['beforeUpdate'],\n    priority: 250,\n    runAs: 'system',\n    description: 'Hand a case being escalated to the least-loaded service manager.',\n    handler: async (ctx: HookContext) => {\n      // D3 stand-down: the escalation TRANSITION is read off this row's\n      // `previous`, so on a predicate update the new owner would be written to\n      // every matched case. `events` is `beforeUpdate` only, so the event half\n      // of the idiom in `forecast.hook.ts` would be a constant here.\n      if (ctx.dispatch?.mode === 'per-row') return;\n\n      const { input } = ctx;\n      const previous = ctx.previous;\n      if (!previous) return;\n\n      // The escalation TRANSITION, not the escalated STATE: a state predicate\n      // re-fires on any write that leaves the status alone, including a replay\n      // of this very update. Comparing status strings also stays clear of the\n      // SQLite boolean trap that `is_escalated != true` walks into.\n      if (input.status !== 'escalated' || previous.status === 'escalated') return;\n\n      // An explicit owner in the SAME payload wins: a manual \"escalate and hand\n      // it to Dana\" must not be overwritten by the pool's arithmetic.\n      if (typeof input.owner_id === 'string' && input.owner_id) return;\n\n      const api = ctx.api as HookApi | undefined;\n      if (!api) return;\n\n      // The escalating case's own organization \u2014 the rule-10 pin on both\n      // reads below. Read off the stored row: an update payload does not carry\n      // it, and the platform stamped it there.\n      const organizationId =\n        typeof previous.organization_id === 'string' && previous.organization_id !== ''\n          ? previous.organization_id\n          : undefined;\n      const inOrganization: Record<string, string> = organizationId ? { organization_id: organizationId } : {};\n\n      try {\n        // The pool = holders of the `service_manager` position. This literal is\n        // the exported SERVICE_MANAGER_POSITION; the sandbox forbids reading the\n        // constant here, and `test/case-assignment.test.ts` pins the parity.\n        const holders = await api.object('sys_user_position').find({\n          where: { position: 'service_manager', ...inOrganization }, fields: ['user_id'], top: 1000,\n        });\n        const managerIds = Array.from(\n          new Set(\n            (holders ?? [])\n              .map((r) => (typeof r.user_id === 'string' ? r.user_id : ''))\n              .filter(Boolean),\n          ),\n        );\n        // No pool \u2192 the case keeps its owner and the escalation still lands.\n        if (managerIds.length === 0) return;\n\n        // Already with the pool \u2192 leave it alone. This is what makes the write\n        // idempotent: a manager escalating their own case, or a second\n        // escalation of a case handed over once already, moves nothing.\n        const currentOwner =\n          (typeof previous.owner_id === 'string' && previous.owner_id) || '';\n        if (currentOwner && managerIds.indexOf(currentOwner) !== -1) return;\n\n        // Fewest OPEN cases wins \u2014 same predicate as the intake round-robin:\n        // `$nin` over statuses rather than `is_closed: false`, because a\n        // resolved case is finished work and must stop counting.\n        let best: string | undefined;\n        let bestCount = Infinity;\n        for (const managerId of managerIds) {\n          const openCount = await api.object('crm_case').count({\n            where: { owner_id: managerId, status: { $nin: ['resolved', 'closed'] }, ...inOrganization },\n          });\n          if (openCount < bestCount) {\n            bestCount = openCount;\n            best = managerId;\n          }\n        }\n        if (best) input.owner_id = best;\n      } catch {\n        // Swallow: the hand-off must never reject the escalation. A failed\n        // pool read leaves the case where it is, escalated.\n        // (No `console` here \u2014 the L2 hook sandbox does not define one.)\n      }\n    },\n  };\n}\n\n/**\n * Let a user CLAIM an unowned case out of triage.\n *\n * Contract: a caller may take ownership only for THEMSELVES, only while the\n * case is unowned, and only while it is not closed.\n *\n * ## Why the claim is a GESTURE, not a value the caller supplies\n *\n * \u26A0\uFE0F The ownership-transfer gate (#3004) rejects a payload carrying `owner_id`\n * INSIDE the operation middleware, upstream of the hook phase \u2014 the hook never\n * fires, so it cannot approve, launder or adjudicate such a write (door \u2462 in\n * this module's header). \"Let the agent write `{ owner_id: <self> }` and have a\n * hook vet it\" is therefore not implementable at all.\n *\n * So the claim is spelled as a MOVE: the caller puts an unowned open case into\n * a status meaning they picked it up ({@link CLAIMABLE_TARGET_STATUSES}) and\n * this hook stamps `ctx.user.id`, the only user id it has. That inverts the\n * safety burden in the app's favour \u2014 \"claim it for somebody else\" and \"claim\n * an owned case\" have no spelling, because the hook reads no target from the\n * payload and is inert unless the STORED row is ownerless. The alternative,\n * granting `crm_case.allowTransfer`, cannot express \"to yourself only\": it\n * would let an agent reassign any case they can edit, to anyone.\n * `src/sales/profiles/service-agent.profile.ts` needs no new grant for this hook.\n *\n * ## The four boundaries\n *\n * | write, as a `service_agent`                         | outcome |\n * | --- | --- |\n * | `{ status: 'in_progress' }` on an unowned OPEN case | claimed \u2014 owner becomes the caller |\n * | the same on a case owned by SOMEBODY ELSE           | refused: no reach, and guard 3 below |\n * | `{ owner_id: <anyone> }`, unowned or not            | refused by the transfer gate, upstream |\n * | the same on an unowned CLOSED case                  | refused: not shared, and guard 4 below |\n *\n * Each guard is doubled on purpose: `case_unassigned_triage_sharing` already\n * hides a closed or otherwise-owned case from an agent, but this hook also runs\n * for callers that rule does not constrain (an admin, a manager holding the\n * escalation share). `test/unassigned-case-triage-reach.test.ts` drives both\n * layers separately so neither can pass on the other's behalf.\n *\n * ## Re-entrancy\n *\n * The hook performs NO operation \u2014 it mutates the payload of the update already\n * in flight, so there is no second write and no second `record-after-update`\n * event for `case_escalation`, `case_sla_monitor` or `case_status_side_effects`\n * to re-fire on. Its predicate is a TRANSITION, not a state, so it is false on\n * a replay; and after a successful claim the stored row HAS an owner, so guard\n * 3 stops every later run. It cannot collide with the escalation hand-off:\n * `escalated` is deliberately not claimable, and at priority 260 this runs\n * after `case_escalation_reassign` (250) and stands down the moment `owner_id`\n * is already in the payload.\n *\n * ## Who this runs for\n *\n * A claim is something a PERSON does, so a write with no user (a seed, a\n * system-context migration, the anonymous web-to-case path) never claims \u2014\n * ownerless intake stays ownerless and stays in the triage tab. A write\n * carrying a real user id claims for that user, whoever they are.\n *\n * @param hookName registry name for the hook (metadata only \u2014 never read by\n *   the body, which the sandbox would not let it be).\n */\nexport function createCaseSelfClaim(hookName = 'case_self_claim'): Hook {\n  return {\n    name: hookName,\n    object: 'crm_case',\n    events: ['beforeUpdate'],\n    priority: 260,\n    description: 'Let a user claim an unowned open case by picking it up; the owner written is always the caller.',\n    handler: async (ctx: HookContext) => {\n      // D3 stand-down: every guard below is decided against this row's\n      // `previous`, so a predicate update would claim rows the caller never\n      // picked up. `beforeUpdate`-only, as above.\n      if (ctx.dispatch?.mode === 'per-row') return;\n\n      const { input } = ctx;\n      const previous = ctx.previous;\n      if (!previous) return;\n\n      // 1. A claim is something a PERSON does. A system or seed write leaves\n      //    the case ownerless for the triage tab to keep showing.\n      const claimant = ctx.user?.id;\n      if (typeof claimant !== 'string' || !claimant) return;\n      if (ctx.session?.isSystem) return;\n\n      // 2. An explicit `owner_id` in the payload WINS and is never touched. For\n      //    an agent that branch is unreachable (the transfer gate refuses such\n      //    a payload upstream), so in practice it means a caller who\n      //    legitimately holds `allowTransfer` gets the owner they named.\n      if ('owner_id' in input) return;\n\n      // 3. Only an UNOWNED case can be claimed. Covers both storage shapes of\n      //    \"no owner\": the key ABSENT (memory/mongo) and the column NULL (SQL).\n      if (typeof previous.owner_id === 'string' && previous.owner_id) return;\n\n      // 4. \u2026and only one that is not CLOSED. \u26A0\uFE0F This guard and the triage\n      //    sharing grant draw DIFFERENT lines on purpose, and \u26D4 neither is to\n      //    be \"aligned\" onto the other. `case_unassigned_triage_sharing`\n      //    (`src/service/sharing/case.sharing.ts`) excludes `resolved` as well as\n      //    `closed`, because a resolved unowned case is history, not backlog,\n      //    and the tab's row count has to keep meaning \"work waiting for a\n      //    human\". This guard stops at `closed` alone, because REOPENING a\n      //    resolved case IS picking the work up, so whoever does it should\n      //    become its owner. The gap between the two lines is live for exactly\n      //    the callers that rule does not reach \u2014 the admin, the manager\n      //    holding the escalation share \u2014 which is why\n      //    `test/unassigned-case-triage-reach.test.ts` drives the closed guard\n      //    once per layer, the second time with an actor that CAN reach the\n      //    row.\n      //\n      //    \u26A0\uFE0F The `is_closed == false` conditions elsewhere in that sharing\n      //    file are NOT this grant and NOT drift: they belong to the manager\n      //    and director rules on critical-priority cases, which keep standing\n      //    reach through the `resolved \u2192 closed` review window by their own\n      //    ruling. Their \u26A0\uFE0F headers carry it; \u26D4 do not read them as this one.\n      //\n      //    `status` is read first because it is a string on every driver;\n      //    `is_closed` is accepted as `true` or `1` because SQLite hands\n      //    booleans back as integers.\n      if (previous.status === 'closed') return;\n      if (previous.is_closed === true || previous.is_closed === 1) return;\n\n      // 5. The gesture: the status MOVES to one meaning a human picked the case\n      //    up. Inline copies of CLAIMABLE_TARGET_STATUSES \u2014 the sandbox forbids\n      //    reading the constant here; `test/unassigned-case-triage-reach.test.ts`\n      //    pins the two in step. `escalated` is absent on purpose: that\n      //    transition belongs to `case_escalation_reassign`.\n      const next = input.status;\n      if (typeof next !== 'string' || next === previous.status) return;\n      if (next !== 'in_progress' && next !== 'waiting_customer' && next !== 'waiting_support') return;\n\n      // The only user id this hook has, and the only one it can write.\n      input.owner_id = claimant;\n    },\n  };\n}\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/service/flows/case-escalation-stamp.flow.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/service/flows\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/service/flows/case-escalation-stamp.flow.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport { cel } from '@objectstack/spec';\nimport type * as Automation from '@objectstack/spec/automation';\ntype Flow = Automation.Flow;\n\n/**\n * The escalation STAMP \u2014 the one elevated step behind the Escalate Case\n * action (maintainer-approved).\n *\n * ## Why this flow exists at all\n *\n * `crm_case.is_escalated` and `escalated_date` are `readonly: true`: nobody\n * types them, so that is the honest declaration. But the platform's readonly\n * strip is one branch of the UPDATE path \u2014\n * `if (!opCtx.context?.isSystem)`, over CALLER-supplied keys \u2014 so a flow write\n * to a readonly column survives exactly when that flow's effective `runAs` is\n * `'system'` (the engine defaults it to `'user'`). The `escalate_case` screen\n * flow is invoked by a person from the UI and MUST keep running as that\n * person, so it cannot make this write itself.\n *\n * The resolution is to elevate the WRITE, not the FLOW: `escalate_case` stays\n * `runAs: 'user'` and calls this dedicated `runAs: 'system'` flow through a\n * `subflow` node. Everything the agent does keeps their identity; only these\n * two stamped columns are written with the elevated context.\n *\n * \u26D4 Do NOT fold this back into `escalate_case` by giving that flow\n * `runAs: 'system'`. That option was costed and explicitly NOT adopted: it\n * elevates every write the screen flow makes, not just these two, and it stops\n * the flow carrying the acting user's context for anything downstream that\n * reads it. See `AGENTS.md` house rule 9 (\"Elevate as little as possible\").\n *\n * ## Measured, not assumed\n *\n * The direction rests on one falsifiable premise \u2014 that a callee flow's own\n * `runAs` governs its writes rather than inheriting the caller's context \u2014 and\n * it is measured against a real engine in\n * `test/readonly-write-semantics.test.ts` (\"a system subflow called from a\n * user parent\"). That measurement reports three things:\n *\n *  - a `runAs: 'system'` callee invoked from a `runAs: 'user'` parent has its\n *    write to a `readonly` column SURVIVE;\n *  - the same callee declared `runAs: 'user'` is STRIPPED \u2014 so it is the\n *    callee's declaration that decides, not the subflow hop;\n *  - the parent's own later write to a readonly column is STILL stripped \u2014 the\n *    elevation is scoped to this run and does not leak back up.\n *\n * The mechanism is `resolveRunContext`\n * (`@objectstack/service-automation`), which re-asserts\n * `runAs: flow.runAs ?? 'user'` AFTER spreading the caller's context, so the\n * callee's own declaration wins: \"a COPY, never mutating the caller's context,\n * so the elevation is scoped to this run and the caller's identity is restored\n * when the run returns\" (ADR-0049).\n *\n * ## \u26D4 What this flow deliberately does NOT write\n *\n * Only the two columns a person never types:\n *\n *   is_escalated    stamped here\n *   escalated_date  stamped here\n *\n * `escalation_reason` is the agent's screen input and `priority` / `status`\n * are ordinary editable columns \u2014 all three stay in `escalate_case`, written\n * with the USER's context. Moving `escalation_reason` here (or declaring it\n * `readonly`) would make the platform silently strip the reason the agent just\n * typed \u2014 the exact harm this split exists to prevent, inverted onto user input.\n *\n * \u26A0\uFE0F ORDERING IS LOAD-BEARING, and it is why this flow runs LAST rather than\n * first. `crm_case`'s `escalation_reason_required` validation rejects any write\n * whose merged record has `is_escalated == true` with a blank\n * `escalation_reason`. `escalate_case` therefore writes the reason FIRST and\n * calls this flow AFTER, so the reason is already stored when the flag flips.\n * Stamping first would fire that validation against a record that does not yet\n * carry a reason. BOTH orders are measured in\n * `test/readonly-write-semantics.test.ts` (\"ordering: the reason must be stored\n * BEFORE the flag flips\"), including the counterfactual: stamping first is\n * refused by that validation, and because a `subflow` node reports its child's\n * failure the run aborts before the reason is written either \u2014 the agent loses\n * the whole escalation.\n */\nexport const CaseEscalationStampFlow: Flow = {\n  name: 'case_escalation_stamp',\n  label: 'Stamp Case Escalation',\n  description:\n    'Write the two readonly escalation stamps (is_escalated, escalated_date) with the system context. Called by escalate_case through a subflow node.',\n  type: 'autolaunched',\n  status: 'active',\n\n  // \u2B50 THE ENTIRE POINT OF THIS FILE. This is the only elevation in the\n  // escalate path, and it covers exactly one `update_record` node.\n  runAs: 'system',\n\n  variables: [\n    // Supplied by the caller's `subflow` node, whose `input` envelope reads its own `recordId`.\n    { name: 'recordId', type: 'text', isInput: true, isOutput: false },\n  ],\n\n  nodes: [\n    // `config: {}` matches the shape measured in\n    // `test/readonly-write-semantics.test.ts`: an autolaunched callee is handed\n    // its params by the `subflow` executor and resolves no trigger record of\n    // its own, so there is no `objectName` for the start node to load.\n    { id: 'start', type: 'start', label: 'Start', config: {} },\n    {\n      id: 'stamp', type: 'update_record', label: 'Stamp Escalation Flags',\n      config: {\n        objectName: 'crm_case',\n        filter: { id: cel`recordId` },\n        // \u26D4 Do not add fields here. Every column in this node is written with\n        // the elevated context; anything a user can legitimately type belongs\n        // in `escalate_case` instead.\n        fields: {\n          is_escalated: true,\n          escalated_date: cel`isoDatetime(now())`,\n        },\n      },\n    },\n    { id: 'end', type: 'end', label: 'End' },\n  ],\n\n  edges: [\n    { id: 'e1', source: 'start', target: 'stamp', type: 'default' },\n    { id: 'e2', source: 'stamp', target: 'end', type: 'default' },\n  ],\n};\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/service/flows/case-sla-monitor.flow.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/service/flows\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/service/flows/case-sla-monitor.flow.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport { P, cel } from '@objectstack/spec';\nimport type * as Automation from '@objectstack/spec/automation';\nimport { guarded } from '../../sales/flows/_guarded-iteration';\ntype Flow = Automation.Flow;\n\n/**\n * Case SLA Monitor \u2014 scheduled breach detection.\n *\n * Complements `case_escalation` (which reacts to *priority* the moment a case\n * is saved) by adding the missing *time* dimension. The schema carries\n * `sla_due_date` and `is_sla_violated`, but nothing watched the clock \u2014 a case\n * could silently blow its SLA. This flow sweeps open (not resolved/closed)\n * cases whose `sla_due_date` has passed, stamps the breach, escalates, and\n * alerts the owner.\n *\n * A breached case with NO owner is the hard case, and it is answered in two\n * halves. The escalation the sweep writes is itself what gives the case an\n * owner \u2014 `case_escalation_reassign` rides on that update and hands the case to\n * the least-loaded `service_manager` \u2014 so this flow re-reads the case\n * afterwards and alerts whoever it now belongs to. When the pool is empty the\n * assignment is a no-op, the case stays unowned, the alert is skipped at a\n * named gate, and the RUN SURVIVES: the breach is still recorded and every\n * other breached case is still swept. \u26D4 No fallback recipient, no\n * manager-chain dot-walk, no hard failure (maintainer ruling 2026-09-03).\n *\n * Capabilities exercised: scheduled trigger + `loop` + `update_record` +\n * `get_record` + `notify`.\n */\n\n/**\n * \"The case in hand carries an owner the `notify` node can address.\"\n *\n * Authored ONCE and used on two edges (`b2` and `b5`) because the two ask the\n * same question at two points in the iteration \u2014 before the sweep's write and\n * after it \u2014 and a hand-copied second spelling is exactly the drift measured on\n * decision nodes. {@link CASE_HAS_NO_OWNER} is its complement.\n *\n * TOTALITY: `currentCase` is a LOOP ITEM over `caseList`, which\n * `get_record` filled from `data.find` \u2014 every element is a raw driver row,\n * sparse in the way a raw driver row is. A case that was never written with\n * an `owner_id` column carries no key at all, so `has()` is the only total\n * accessor; an unguarded `vars.currentCase.owner_id != null` aborts with\n * `No such key` and takes the run down the same way an empty recipient slate\n * once did.\n *\n * Every term is load-bearing, and the last one MIRRORS THE NOTIFY NODE'S OWN\n * emptiness rule rather than guessing at it: builtin `notify` builds its\n * audience with `String(v).trim()` + `.filter(Boolean)`, so null, undefined,\n * `''` AND any all-whitespace value all collapse to the same empty slate.\n * Measured: `'   ' != \"\"` is TRUE in CEL, so a gate written that way opened for\n * a whitespace `owner_id` and reproduced this very defect one input narrower.\n * `string(...).trim() != \"\"` is the same predicate the node applies, in CEL.\n *\n * The `string()` wrap is not decoration: bare `.matches()` / `.trim()` on a\n * non-string id fails with `no matching overload`, which is a thrown condition\n * \u2014 the fault mode this flow exists to keep out. `string()` is total for every\n * non-null scalar, and the `!= null` term in front short-circuits before it can\n * be handed a null (`string(null)` has no overload either).\n */\nconst CASE_HAS_OWNER = () => P`has(vars.currentCase) && has(vars.currentCase.owner_id)\n  && vars.currentCase.owner_id != null && string(vars.currentCase.owner_id).trim() != \"\"`;\n\n/**\n * The exact complement of {@link CASE_HAS_OWNER}, in the opposite polarity the\n * house rule prescribes for a partition (`!has(x) || \u2026 `).\n *\n * \u26A0\uFE0F `has(vars.currentCase)` leads BOTH predicates rather than being negated\n * here, so the two edges partition only the cases where the iterator is bound.\n * That asymmetry is deliberate: with no `currentCase` at all NEITHER edge\n * matches and the iteration simply ends \u2014 the pre-existing behaviour \u2014 instead\n * of routing an unbindable row into `reload_case`, whose `{currentCase.id}`\n * filter token would then resolve to nothing and make `get_record` REFUSE the\n * step, killing the run for the exact reason this flow was repaired.\n */\nconst CASE_HAS_NO_OWNER = () => P`has(vars.currentCase) && (!has(vars.currentCase.owner_id)\n  || vars.currentCase.owner_id == null || string(vars.currentCase.owner_id).trim() == \"\")`;\n\nexport const CaseSlaMonitorFlow: Flow = {\n  name: 'case_sla_monitor',\n  label: 'Case SLA Monitor',\n  description: 'Hourly sweep: flag and escalate open cases that have breached their SLA due date.',\n  type: 'schedule',\n  status: 'active',\n  // Scheduled runs have no trigger user, so under the default runAs:'user' the\n  // data nodes execute UNSCOPED anyway. Declare runAs:'system' to make that\n  // RLS-bypassing elevation explicit and intended (ADR-0049).\n  runAs: 'system',\n\n  variables: [],\n\n  nodes: [\n    { id: 'start', type: 'start', label: 'Start (hourly)', config: { schedule: '0 * * * *' } },\n    {\n      id: 'query_breached', type: 'get_record', label: 'Find Breached Cases',\n      config: {\n        objectName: 'crm_case',\n        // \u26D4 `$nin` on `status`, never `is_closed: false`: a case in `resolved`\n        // has met its SLA \u2014 work is finished \u2014 but `is_closed` only flips on\n        // `closed`, so the boolean filter stamps false breaches on resolved\n        // cases and drags them back to `escalated`.\n        //\n        // `$lt` is `caseSlaBreached` (`src/service/objects/_case-sla.ts`) read\n        // with \"now\" as the instant: STRICTLY past due. Its other half is\n        // `case_sla_defaults`, which applies the same rule on the write that\n        // settles a case \u2014 so a case settled late is flagged even when this\n        // sweep never reached it, or never runs (#2070).\n        //\n        // \"Now\" is the query engine's own `{now}` placeholder, which an\n        // 18.0.0-next.0 filter operand leaves to the engine as written. It\n        // renders the instant's ISO text, as the retired `{NOW()}` flow token\n        // did, and it is the spelling the SLA Violations tile reads, so the\n        // sweep and the tile say \"past due\" in one wording.\n        filter: {\n          status: { $nin: ['resolved', 'closed'] },\n          is_sla_violated: false,\n          sla_due_date: { $lt: '{now}' },\n        },\n        limit: 500,\n        outputVariable: 'caseList',\n      },\n    },\n    {\n      id: 'loop_cases', type: 'loop', label: 'For Each Breached Case',\n      config: {\n        collection: cel`caseList`,\n        iteratorVariable: 'currentCase',\n        body: guarded('case', {\n          nodes: [\n            {\n              id: 'flag_breach', type: 'update_record', label: 'Flag SLA Breach',\n              config: {\n                objectName: 'crm_case',\n                filter: { id: cel`currentCase.id` },\n                // `escalation_reason` must accompany `is_escalated: true` \u2014 the\n                // object's `escalation_reason_required` validation (severity:\n                // error) rejects the whole write otherwise, turning this sweep\n                // into a silent no-op (cf. the same fix in case_escalation).\n                fields: {\n                  is_sla_violated: true,\n                  is_escalated: true,\n                  status: 'escalated',\n                  escalated_date: cel`isoDatetime(now())`,\n                  escalation_reason: 'Auto-escalated: SLA due date breached',\n                },\n              },\n            },\n            {\n              // Gateway only \u2014 the predicate lives on the out-edge.\n              //\n              // `crm_case.owner_id` is NULLABLE and an unowned case is an\n              // ordinary state (this repo ships `scripts/backfill-owner-id.ts` /\n              // `pnpm backfill:owner` precisely because ownerless rows happen;\n              // ordinary REST creation and import reach it too). The `notify`\n              // node below addresses exactly one recipient, so an ownerless case\n              // left it with an empty slate \u2014 which the builtin node treats as a\n              // HARD failure, and that failure is not scoped to the one case:\n              // `executeNode` throws, `runRegion` rethrows, and the `loop` node\n              // awaits it with no try/catch, so the whole sweep died on the\n              // ownerless row and every breached case ORDERED BEHIND IT was\n              // never even flagged. Measured, not assumed \u2014 see\n              // `test/flow-sla-ownerless-case.test.ts`.\n              //\n              // The gate sits AFTER `flag_breach` on purpose. `flag_breach` is\n              // unconditional, so an ownerless breach is still RECORDED on the\n              // record \u2014 visible in views and reports, where a service manager\n              // finds it. Gating both would trade a dead run for a silently\n              // dropped alert on exactly the cases most likely to be neglected.\n              //\n              // The ownerless branch is not a dead end: it goes to\n              // `reload_case`, because by the time the gate is reached the\n              // sweep's own write may ALREADY HAVE GIVEN THE CASE AN OWNER \u2014\n              // see that node (maintainer ruling 2026-09-03, option C).\n              id: 'check_owner', type: 'decision', label: 'Case Has an Owner?',\n            },\n            {\n              // Re-read the case the sweep just wrote.\n              //\n              // \u26A0\uFE0F THE ASSIGNMENT IS NOT AUTHORED HERE, AND MUST NOT BE.\n              // `flag_breach` writes `status: 'escalated'`, and that IS the\n              // escalation transition `case_escalation_reassign`\n              // (`src/service/objects/_case-assignment.ts`, `beforeUpdate`, priority\n              // 250) fires on: it stamps the least-loaded holder of the\n              // `service_manager` position onto the payload of the update\n              // already in flight. So the sweep does not need a seam to \"call\"\n              // the assignment \u2014 performing the transition IS putting the case\n              // through it, and the app keeps ONE answer to \"who should own\n              // this case\" instead of a flow-shaped second implementation of\n              // least-loaded balancing.\n              //\n              // MEASURED, not assumed (`test/flow-sla-ownerless-case.test.ts`\n              // drives the real flow, the real engine and the real hooks): with\n              // a staffed pool an ownerless breached case comes back owned; with\n              // an empty pool the hook stands down and the case comes back\n              // ownerless. No second write, no re-entry, no loop \u2014 the hook\n              // mutates the in-flight payload and issues no operation of its\n              // own.\n              //\n              // \u26D4 The READ is what this node is for, not a second write:\n              // `currentCase` is the loop item bound by `query_breached` BEFORE\n              // `flag_breach` ran, so the owner the sweep just assigned is\n              // invisible to it and `{currentCase.owner_id}` addresses the\n              // pre-write state. Re-binding the SAME variable is what makes the\n              // rest of the iteration \u2014 the gate below and the notify node's\n              // whole template \u2014 read the case as it now stands, with no second\n              // notify node to keep in step.\n              //\n              // No `limit`: `get_record` calls `findOne` at or below 1 and binds\n              // the single row itself, which is what `{currentCase.<field>}`\n              // needs. A miss binds `null` \u2014 `get_record` always binds \u2014 which\n              // `check_assigned` below is there to read.\n              id: 'reload_case', type: 'get_record', label: 'Re-read Case After Escalation',\n              config: {\n                objectName: 'crm_case',\n                filter: { id: cel`currentCase.id` },\n                outputVariable: 'currentCase',\n              },\n            },\n            {\n              // Gateway only \u2014 the predicate lives on the out-edge.\n              //\n              // The ruled empty-pool clause, as a gate rather than a failure:\n              // when the `service_manager` pool resolves empty the hook assigns\n              // nobody, the re-read case is still ownerless, no edge matches and\n              // the iteration ends. The breach stays on the record and in the\n              // run summary, the notification is skipped at a NAMED gate, and\n              // the run survives. \u26D4 No hard failure, no fallback recipient, no\n              // manager-chain dot-walk.\n              id: 'check_assigned', type: 'decision', label: 'Escalation Found an Owner?',\n            },\n            {\n              // Owner only: `{currentCase.owner_id.manager}` cannot traverse a\n              // lookup in flow templates \u2014 it interpolates to the literal\n              // \"undefined\" (cf. case_escalation / opportunity_won_alert).\n              //\n              // Reached from BOTH gates, and the whole template reads\n              // `currentCase` either way: on the owned branch that is the row\n              // `query_breached` bound, on the ownerless branch the row\n              // `reload_case` re-bound. One node, one wording, one recipient\n              // rule \u2014 a second notify node would be the same alert authored\n              // twice, free to drift on the half nobody is looking at.\n              //\n              // \u26A0\uFE0F THE RECIPIENT IS RULED, NOT INCIDENTAL \u2014 #1535, maintainer\n              // ruling 2026-09-07, option A. On a breached\n              // case that ALREADY HAS AN OWNER, `flag_breach` writes\n              // `status: 'escalated'` and `case_escalation_reassign` hands the\n              // case to the least-loaded `service_manager` inside that same\n              // write \u2014 yet this node addresses `currentCase` as\n              // `query_breached` bound it, BEFORE the hand-off. So the breach\n              // alert deliberately reaches the agent the case is being taken\n              // FROM, not the manager who now owns it.\n              //\n              // It is the SAME etiquette `case_escalation` already states in\n              // `content/docs/service/sla-and-escalation.mdx` \u2014 \"the\n              // notification goes to the previous owner alone\" \u2014 and that page\n              // now states it for this sweep too. One escalation etiquette\n              // across both mechanisms.\n              //\n              // \u26D4 Do not \"fix\" this into an alert for the new owner. That is\n              // option C, and it would have to re-rule `case_escalation` in the\n              // same stroke \u2014 \u26D4 never one mechanism only.\n              //\n              // `test/flow-sla-ownerless-assignment.test.ts` pins the pairing\n              // (the owned breach IS handed over AND its alert still goes to\n              // the pre-hand-off owner), and records the ruling's declared gap\n              // as measured: the hand-off hook issues no notice of its own, so\n              // the receiving manager is told nothing by this run.\n              id: 'notify_team', type: 'notify', label: 'Alert Owner',\n              config: {\n                // Owner only \u2014 `{currentCase.owner_id.manager}` dot-walks a\n                // lookup, which flow templates interpolate as \"undefined\".\n                recipients: [cel`currentCase.owner_id`],\n                channels: ['inbox', 'email'],\n                severity: 'critical',\n                topic: 'case_sla_breach',\n                template: 'crm.case_sla_breach',\n                templateData: {\n                  case_number: cel`currentCase.case_number`, priority: cel`currentCase.priority`,\n                },\n                actionUrl: '/crm_case/{{currentCase.id}}',\n              },\n            },\n          ],\n          edges: [\n            { id: 'b1', source: 'flag_breach', target: 'check_owner', type: 'default' },\n            // The two out-edges of `check_owner` are an exact PARTITION of the\n            // cases where `currentCase` is bound (see {@link CASE_HAS_OWNER} /\n            // {@link CASE_HAS_NO_OWNER}) \u2014 never a `default` edge alongside a\n            // conditional one, which would traverse BOTH and notify twice.\n            //\n            // \u26A0\uFE0F The owned branch reads `currentCase` as `query_breached` bound\n            // it, deliberately: a case that already had an\n            // owner keeps alerting THAT owner, which is what the sweep has\n            // always done. \u26A0\uFE0F That is RULED intent now, no longer an open\n            // question \u2014 the `notify_team` node carries the ruling.\n            { id: 'b2', source: 'check_owner', target: 'notify_team', type: 'conditional', condition: CASE_HAS_OWNER(), label: 'Has owner' },\n            { id: 'b3', source: 'check_owner', target: 'reload_case', type: 'conditional', condition: CASE_HAS_NO_OWNER(), label: 'No owner \u2014 re-read after escalation' },\n            { id: 'b4', source: 'reload_case', target: 'check_assigned', type: 'default' },\n            // Both branches converge on the ONE notify node, which is why the\n            // re-read re-binds `currentCase` rather than a second variable: the\n            // recipient, the title, the message and the action URL are authored\n            // once and cannot drift into two versions of the same alert.\n            //\n            // A gate with no matching edge simply ends the iteration, so an\n            // ownerless case the pool could not place is skipped and the loop\n            // moves on to the next breached case \u2014 the run survives, which is\n            // the property this flow was repaired for.\n            { id: 'b5', source: 'check_assigned', target: 'notify_team', type: 'conditional', condition: CASE_HAS_OWNER(), label: 'Escalation assigned an owner' },\n          ],\n        }),\n      },\n    },\n    { id: 'end', type: 'end', label: 'End' },\n  ],\n\n  edges: [\n    { id: 'e1', source: 'start', target: 'query_breached', type: 'default' },\n    { id: 'e2', source: 'query_breached', target: 'loop_cases', type: 'default' },\n    { id: 'e3', source: 'loop_cases', target: 'end', type: 'default' },\n  ],\n};\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/sales/flows/_guarded-iteration.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/sales/flows\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/sales/flows/_guarded-iteration.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\n/**\n * Per-iteration containment for `loop` bodies \u2014 the one spelling, in one place.\n *\n * ## The defect this closes\n *\n * `loop-node.ts` iterates its body with a bare `await` and has no `try`/`catch`\n * at all, so a body node that returns `success: false` or throws propagates\n * straight out of the container. The first failing item therefore ends the\n * WHOLE run: every later item is never processed, and the work already done is\n * not even reported. Measured by the platform on the real engine \u2014 a 5-item\n * sweep failing at item 3 touched 3 items and reported `acted: 0`.\n *\n * That is what `objectstack lint`'s `flow-loop-body-uncontained` names, and the\n * containment it prescribes is a `try_catch` INSIDE the body with the real work\n * moved into its `try` region.\n *\n * ## Why a helper rather than the literal 22x spelling\n *\n * Writing the `try_catch` out at each of the 22 warned loops re-indents every\n * body by two levels, and the re-indentation ALONE measured ~1,327 tokens over\n * the `business semantics` ceiling of `pnpm hygiene:tokens` \u2014 a ceiling that\n * moves only on a maintainer ruling. The ratchet strips comments, so slimming\n * prose cannot buy that back either.\n *\n * This helper wraps the body from OUTSIDE instead. At each site `body: {`\n * becomes `body: guarded('<key>', {` and the closing `},` becomes `}),`, so the\n * body keeps its own indentation byte-for-byte and the whole change costs a few\n * tokens per loop instead of sixty.\n *\n * ## Verified against the pinned `@objectstack/*` this repo installs\n *\n * First taken on 17.3.0; RE-TAKEN on 17.4.0 (#1883, after the PR #1814 bump;\n * not re-taken on 17.5.0), same verdict: a 5-item sweep whose body fails on every item\n * ran to completion \u2014 all 5 items touched, run `success: true` \u2014 where the\n * same sweep with the body UNWRAPPED stopped at the first failure with 1 item\n * touched and the run `failed`. That contrast IS the measurement; a guarded\n * run alone cannot tell containment from a body that never failed.\n *\n * (Not against the platform source tree \u2014 the containment has to work on the\n * artifact that actually ships here.)\n *\n *   - `try_catch` is registered by the pinned engine (`registerTryCatchNode`),\n *     runs its `try` region, and on a caught failure runs `catch` and returns\n *     `success: true`. That `success: true` is what lets the loop continue.\n *   - A bare `assignment` node with no `config` returns `success: true`: its\n *     executor folds an absent config to zero assignments, and `config` is\n *     optional on `FlowNodeSchema`. That is why the minimal handler is legal,\n *     and it is the exact handler the lint rule's own hint prescribes.\n *   - The failed attempt's steps are kept in the run log AHEAD of the handler's\n *     (`childSteps: [...failedAttemptSteps, ...catchSteps]`), so a skipped item\n *     stays visible with its own `status: 'failure'` step and the handler does\n *     not need to re-record it.\n *   - `catch` needs no `edges` (`FlowRegionSchema.edges` carries `.default([])`)\n *     and no `errorVariable` (it defaults to `$error`). A one-node region is\n *     single-entry/single-exit, which is what `analyzeRegion` requires.\n *\n * ## What it deliberately does NOT do\n *\n * The handler swallows the item and moves on. It does not retry (no `retry`\n * policy is declared, so one attempt is made), does not notify, and does not\n * accumulate a failure list \u2014 a sweep that reports its skips is a product\n * feature this card does not have a ruling for. The run log is the record.\n *\n * \u26D4 Not every loop wants this. A sweep MEANT to stop at its first failure is a\n * legitimate reading and keeps its warning, so decide per loop rather than\n * wrapping every warned site by reflex.\n */\n\n/**\n * A control-flow region, structurally. Deliberately looser than the spec's\n * `FlowRegion`: the loop bodies this wraps live under `config`, which the flow\n * schema types as `Record<string, unknown>`, so tightening the parameter here\n * would type-check the bodies for the first time and turn a mechanical wrap\n * into a typing change. Same shape in, same shape out.\n */\ntype Region = { nodes: unknown[]; edges?: unknown[] };\n\n/**\n * Wrap a loop body region so one failing item is contained to that iteration.\n *\n * `key` must be unique within its flow \u2014 it names the two nodes this adds\n * (`guard_<key>` and `handled_<key>`), and node ids collide flow-wide.\n */\nexport const guarded = (key: string, region: Region): Region => ({\n  nodes: [{\n    id: `guard_${key}`,\n    type: 'try_catch',\n    label: 'Guarded Iteration',\n    config: {\n      try: region,\n      catch: { nodes: [{ id: `handled_${key}`, type: 'assignment', label: 'Skip This Item' }] },\n    },\n  }],\n});\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/service/objects/article_feedback.hook.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/service/objects\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/service/objects/article_feedback.hook.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport type { Hook, HookContext } from '@objectstack/spec/data';\nimport type { HookApi } from '../../sales/objects/_hook-api';\n\n/**\n * The writer behind the knowledge article's engagement counters (#601).\n *\n * `crm_knowledge_article.helpful_count` and `not_helpful_count` were declared\n * `readonly: true` with a `defaultValue: 0` and NO writer anywhere \u2014 on the\n * platform or in this app \u2014 so they were structurally pinned at zero while the\n * article grid showed a \"Helpful Votes\" column and summed it. That is the same\n * defect `crm_campaign_member`'s engagement lifecycle was retired for (#597),\n * and ADR-0049's enforce-or-remove leaves exactly two honest endings: give the\n * field a writer, or delete it. Feedback on a knowledge article has a real\n * consumer \u2014 the review queue an author works from \u2014 so these two get a\n * writer. `view_count`, which has none available, was deleted; the reasoning\n * is on `crm_knowledge_article` itself.\n *\n * ### Recount, never increment\n *\n * Every event recomputes both counters from `crm_article_feedback` rather than\n * adding one to what is there. That makes the write idempotent (a replayed\n * hook cannot double-count), self-healing (an admin deleting a bogus vote row\n * is reflected on the next event, and a full recount fixes any historical\n * drift in one pass), and safe under concurrency (two simultaneous votes both\n * converge on the true count, where two read-modify-writes lose one). The\n * counters therefore cannot drift from their own evidence \u2014 which is what makes\n * `readonly: true` an honest declaration again rather than a description of\n * paralysis.\n *\n * `afterDelete` is in the event set for the same reason: the campaign junction\n * learned the hard way (#696) that a junction row's disappearance is a metric\n * change, and a counter that only ever goes up is a different kind of lie.\n *\n * `async: true` + `onError: 'log'` mirrors `campaign_member_metrics_refresh`:\n * the reader's vote is the user's action and must not fail because the article\n * row is momentarily locked. A missed refresh is corrected by the next vote;\n * a rejected write loses the vote itself.\n *\n * `runAs: 'system'` (#2014, AGENTS.md rule 9). The counters are `readonly`,\n * and the engine drops a readonly key a non-system caller writes \u2014 so a recount\n * fired by a PERSON's own write of a vote (an admin withdrawing one) committed\n * without the counters and the article kept counting the withdrawn vote. The\n * recount is the article's writer, not the voter's, so the hook elevates; the\n * vote itself stays the caller's write. Elevation is not anonymity: the\n * article's `updated_by` still names the person. Organization (rule 10): every\n * read and write is keyed to the triggering vote's own article, and the\n * elevated `ctx.api` keeps the trigger's tenant, so the driver's organization\n * predicate still applies.\n *\n * No loop: this writes `crm_knowledge_article`, whose own hook\n * (`knowledge_article_publish_timestamps`) fires on `before*` and returns\n * immediately unless the record is published \u2014 and either way it issues no\n * write against `crm_article_feedback`, so nothing re-enters here.\n *\n * \u26A0\uFE0F The recount block is written out INLINE and is not shared with\n * `campaign_member.hook.ts`'s structurally similar block. A hook handler lowers\n * to a metadata-only, body-only script: a reference to module scope \u2014 an\n * import, a top-level const, a shared factory's parameter \u2014 is a\n * `ReferenceError` at runtime, not a closure, and a handler that reaches for\n * one silently stops lowering (`test/action-sandbox.test.ts` fails the build on\n * it). Hooks may be composed by a FACTORY (`_case-assignment.ts` does exactly\n * that); the logic inside a body may not be imported.\n */\nconst articleFeedbackMetricsRefresh: Hook = {\n  name: 'article_feedback_metrics_refresh',\n  object: 'crm_article_feedback',\n  events: ['afterInsert', 'afterUpdate', 'afterDelete'],\n  priority: 800,\n  async: true,\n  onError: 'log',\n  runAs: 'system',\n  description: 'Recount an article\u2019s helpful / not-helpful votes from crm_article_feedback.',\n  handler: async (ctx: HookContext) => {\n    const api = ctx.api as HookApi | undefined;\n    if (!api) return;\n    const { input } = ctx;\n    const previous = ctx.previous;\n    // Both sides on update: moving a vote between articles has to recount the\n    // article it LEFT as well as the one it arrived at.\n    const articleIds = Array.from(new Set([\n      typeof input?.crm_knowledge_article === 'string' ? input.crm_knowledge_article : '',\n      typeof previous?.crm_knowledge_article === 'string'\n        ? (previous.crm_knowledge_article as string)\n        : '',\n    ].filter(Boolean)));\n\n    for (const id of articleIds) {\n      const helpful = await api.object('crm_article_feedback').count({\n        where: { crm_knowledge_article: id, verdict: 'helpful' },\n      });\n      const notHelpful = await api.object('crm_article_feedback').count({\n        where: { crm_knowledge_article: id, verdict: 'not_helpful' },\n      });\n      await api.object('crm_knowledge_article').update({\n        id,\n        helpful_count: helpful,\n        not_helpful_count: notHelpful,\n      }, { where: { id } });\n    }\n  },\n};\n\nexport default [articleFeedbackMetricsRefresh];\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/service/objects/case.hook.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/service/objects\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/service/objects/case.hook.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport type { Hook, HookContext } from '@objectstack/spec/data';\nimport type { HookApi } from '../../sales/objects/_hook-api';\nimport {\n  createCaseRoundRobinAssign,\n  createCaseEscalationReassign,\n  createCaseSelfClaim,\n} from './_case-assignment';\n\n/**\n * Case SLA & escalation hook.\n *\n * - Stamps `sla_due_date` on a case that has none, from the priority \u00D7 account\n *   tier matrix in `_case-sla.ts`.\n * - Records `is_sla_violated` on the write that resolves or closes a case after\n *   its `sla_due_date` \u2014 the half of the breach rule no schedule can miss.\n * - On escalation: creates a follow-up task OWNED BY the account owner (the\n *   single owner of escalation tasks \u2014 flows must not create their own).\n *   Owning it, not merely labelling it: `owner_id` is the one ownership column,\n *   so the person the task names is the person who can work it.\n * - On `resolved`: bumps account `last_activity_date` \u2014 its own hook,\n *   `case_resolution_account_activity`, because it is the one write here that\n *   needs elevation (#2014).\n *\n * \u26A0\uFE0F Ownership assignment is NOT here: all three answers to \"who should own\n * this case\" live in `_case-assignment.ts` \u2014 the ownerless-intake round-robin,\n * the escalation hand-off to the `service_manager` pool, and the triage\n * self-claim. One module, so the app never grows two independently-authored\n * ownership paths on `crm_case`; its hooks are composed into this module's\n * default export below, so the registry still sees one `crm_case` hook set. In\n * particular the escalation hand-off is deliberately NOT a branch of\n * `case_status_side_effects` below: that hook writes through `ctx.api`, a seam\n * the #3004 transfer guard CAN see (which would demand\n * `crm_case.allowTransfer`) and a second write that re-enters the record-change\n * trigger surface. Both measurements are in `_case-assignment.ts`'s header.\n */\n\nconst caseValidation: Hook = {\n  name: 'case_sla_defaults',\n  object: 'crm_case',\n  events: ['beforeInsert', 'beforeUpdate'],\n  priority: 200,\n  description: 'Apply the priority \u00D7 account-tier SLA matrix and the case lifecycle defaults.',\n  handler: async (ctx: HookContext) => {\n    // D3 stand-down: a predicate update has ONE payload for every matched row,\n    // so the `ctx.previous`-conditioned writes below would land on rows that\n    // did not earn them \u2014 refused as a diverging key set, or stored silently\n    // from the last row. Full account and the measurement: `forecast.hook.ts`.\n    if (ctx.event === 'beforeUpdate' && ctx.dispatch?.mode === 'per-row') return;\n\n    const { input } = ctx;\n    const api = ctx.api as HookApi | undefined;\n\n    // Guest (web-to-case) sanitisation. OVERWRITE with a safe value \u2014 never\n    // `delete`.\n    //\n    // \u2705 HISTORY, RESOLVED \u2014 and the conclusion is unchanged. Through 17.2.0,\n    // `delete ctx.input.<field>` in a hook was a SILENT NO-OP: ObjectQL hands a\n    // hook `ctx.input` as `{ data, options }` behind a flat-record Proxy\n    // (`installFlatInput`, `@objectstack/objectql` `src/hook-wrappers.ts`) that\n    // trapped `get` / `set` / `has` / `ownKeys` / `getOwnPropertyDescriptor` and\n    // routed each into `data` \u2014 but declared no `deleteProperty` trap, so the\n    // delete fell through to the WRAPPER, one level above the record:\n    //\n    //   delete input.owner_id   -> returned TRUE  (JS reported success)\n    //   'owner_id' in input     -> still true\n    //   input.owner_id          -> still the caller's value\n    //\n    // Fifteen such statements across two intake hooks did nothing in production\n    // while their tests passed (#1133). This block was rewritten to ASSIGN.\n    //\n    // The block above predicted its own trigger \u2014 \"a platform release that\n    // POSTDATES 2026-08-26\" \u2014 and that release is **17.3.0**, so every later\n    // pin carries the fix. objectstack#12277 shipped: the in-process Proxy\n    // traps `deleteProperty`, and the sandbox path diffs deletions against the\n    // entry snapshot rather than writing mutations home with `Object.assign`,\n    // which cannot represent a removal. Re-measured through the engine's own\n    // `wrapDeclarativeHook` in `test/hook-input-shape.test.ts`, which now pins\n    // the new contract in both directions.\n    //\n    // \u26D4 The trap arriving is NOT a licence to spell this block with `delete`.\n    // What these lines WRITE is load-bearing independently of how it is spelled:\n    // `case_auto_assign` stands down only on a non-empty STRING `owner_id`, so\n    // the column must arrive `null` rather than ABSENT (see the `null` note\n    // below). Removing a key and writing `null` are different downstream, so\n    // switching to `delete` would be a behaviour change on the public-form\n    // boundary, not a re-spelling. Assign \u2014 for the reason, not the constraint.\n    //\n    // \u26A0\uFE0F `null` rather than `''` or `undefined`, all three measured on the\n    // write path: `null` stores as null, `''` stores as an empty string (wrong\n    // in a lookup \u2014 see `case_resolution_article_normalize` below), and\n    // `undefined` stores the KEY with an undefined value rather than omitting\n    // it, which is not the same as absent and is what a `has()`-guarded CEL\n    // predicate then trips over. `null` is also what the downstream owner\n    // writer reads as \"ownerless\": `case_auto_assign` stands down only on a\n    // non-empty STRING `owner_id`, so a nulled column still reaches the\n    // round-robin.\n    //\n    // \u26A0\uFE0F `!ctx.session?.isSystem` is load-bearing. A predicate of\n    // `!ctx.previous && !ctx.user?.id` conflates the two callers that both\n    // arrive without a user id: an anonymous web-to-case submitter (untrusted,\n    // the caller this branch exists for) and a SYSTEM write \u2014 seed load,\n    // backfill, demo bootstrap, migration \u2014 the most trusted caller there is.\n    // Elsewhere in this app that same absence is read the opposite way:\n    // `lead_automation`'s converted-lead lock treats `!ctx.user?.id` as \"system\n    // write, allow it\". Without the narrowing, a system insert that names an\n    // owner has that owner blanked and every seeded or backfilled case lands\n    // ownerless (eight cases in `test/unassigned-case-triage-reach.test.ts`\n    // insert owned cases exactly that way). `ctx.session.isSystem` is the\n    // discriminator: a system context arrives as `session: { isSystem: true }`\n    // and an anonymous one carries no session at all. Narrowing only ever\n    // REMOVES callers from the branch, so nothing sanitised today stops being.\n    //\n    // `escalation_reason` is stripped ALONGSIDE `is_escalated`, and the pair is\n    // why: cleaning only the FLAG leaves the prose that explains the flag\n    // writable, so a case could carry a stated escalation reason while\n    // `is_escalated` is false \u2014 a contradiction on the record page's own\n    // `escalation` field group, where a service agent reads both. It IS a\n    // widening of a security control, so it is argued rather than assumed:\n    // `escalation_reason` is pipeline, not a fact a submitter states about\n    // themselves \u2014 the rule this branch declares \u2014 and every real writer is\n    // staff-side (`case_escalation`, `case_sla_monitor`, the `escalate_case`\n    // screen flow). The public `web_to_case` form (`src/service/views/case.view.ts`)\n    // collects exactly `subject`, `description`, `type` and `priority`, so\n    // nulling this drops nothing any guest surface asks for. `guest_portal`\n    // grants `crm_case.allowCreate` at the OBJECT level with no field\n    // allow-list, which is precisely why this branch is the field-level control\n    // and why an omission from it is a hole rather than a second layer.\n    //\n    // \u26A0\uFE0F The middleware path is MEASURED, and the answer bounds what this\n    // branch may claim. A real anonymous write does NOT reach these columns on\n    // the shipped app today \u2014 and this branch is not what stops it. Driven\n    // against a real server (`objectstack start`, the production plugin set:\n    // Auth, Security, Sharing, RestAPI), unauthenticated over HTTP:\n    //\n    //   POST  /api/v1/data/crm_case         401 UNAUTHENTICATED\n    //   PATCH /api/v1/data/crm_case/:id     401 UNAUTHENTICATED\n    //   POST  /api/v1/actions/...           401 UNAUTHENTICATED\n    //   POST  /api/v1/mcp                   401 UNAUTHENTICATED\n    //   POST  /api/v1/forms/support/submit  201 \u2014 the ONE anonymous write path\n    //\n    // and that surviving route filters the body against an allow-list built\n    // from the matched form view's OWN declared sections (`@objectstack/rest`,\n    // `registerFormEndpoints`), so a planted internal field is dropped before\n    // ObjectQL and before this hook.\n    // \u26D4 So do NOT write down that a guest reaches these columns in production.\n    //\n    // \u26D4 And do not read that as \"this branch is cosmetic\". That allow-list is\n    // the form's FIELD LIST \u2014 a product decision, not a security declaration \u2014\n    // and #1505 measured it by widening it: ONE line added to `web_to_case`'s\n    // sections and the same anonymous POST stored the planted value, while a\n    // field left off the widened form stayed null in the same request. That is\n    // what identifies the form list as the only thing holding, and this branch\n    // as the layer that has to hold when it moves. \u26A0\uFE0F That measurement was\n    // taken on `customer_rating` / `customer_feedback`, which #1428 has since\n    // retired under ADR-0049 \u2014 the two columns are gone, so the branch no\n    // longer strips them; the mechanism the measurement established is\n    // unchanged and governs every field it still assigns.\n    //\n    // \u26A0\uFE0F Field-level permissions are not a second layer behind this branch, and\n    // that was re-measured against the installed tree rather than taken on\n    // report: `PermissionEvaluator.getFieldPermissions` builds its mask ONLY\n    // from `<object>.<field>` keys a permission set names in its `fields` map,\n    // and `FieldMasker.detectForbiddenWrites` returns early on an empty mask\n    // and otherwise flags only names present in it. `guest_portal` declares no\n    // `fields` key at all, so its mask is empty and the write guard is skipped\n    // outright \u2014 a field NO profile names is unrestricted, not restricted.\n    //\n    // Nulling `escalation_reason` cannot trip the object's\n    // `escalation_reason_required` validation: that rule fires only on\n    // `is_escalated == true`, this same branch forces `is_escalated = false`,\n    // and on the engine's insert path `validateRecord` /\n    // `evaluateValidationRules` run AFTER the `beforeInsert` hooks, against the\n    // row the hook has already rewritten.\n    const isGuestSubmission = !ctx.previous && !ctx.user?.id && !ctx.session?.isSystem;\n    if (isGuestSubmission) {\n      if (!input.origin)   input.origin   = 'web';\n      if (!input.status)   input.status   = 'new';\n      // \u26A0\uFE0F No `priority` default here, and the absence is deliberate. A\n      // `if (!input.priority) input.priority = 'medium'` line here can never\n      // execute: `crm_case.priority` declares its `low` option `default: true`,\n      // and on the engine's own insert path `applyFieldDefaults` produces the\n      // row that BECOMES `ctx.input.data` before `triggerHooks('beforeInsert')`\n      // is called \u2014 so the slot is already full every time this branch runs.\n      // Such a line reads as a declared intent (\"guest submissions start at\n      // medium\") that the app does not honour. Whether a web-submitted case\n      // SHOULD outrank a staff-created one is a product question, and it is not\n      // settled by leaving dead code here that says it already is.\n      input.owner_id          = null;\n      input.is_escalated      = false;\n      input.escalation_reason = null;\n      input.internal_notes    = null;\n      input.resolution        = null;\n    }\n\n    const priority =\n      (typeof input.priority === 'string' && input.priority) ||\n      (typeof ctx.previous?.priority === 'string' && (ctx.previous.priority as string)) ||\n      undefined;\n\n    // Materialise the urgency ordinal so queue views can sort by it. Sorting on\n    // `priority` itself compares raw strings and inverts urgency\n    // (medium > low > high > critical).\n    //\n    // \u26A0\uFE0F The map is declared INLINE and duplicated in task.hook.ts on purpose:\n    // L2 hook bodies run body-only in the QuickJS sandbox, so a shared module\n    // constant resolves at authoring time and arrives as `undefined`. The two\n    // maps key off different vocabularies (medium vs normal), but the UNKNOWN\n    // fallback must stay identical on both objects \u2014 `0`, the unranked sentinel\n    // that sorts below every real rank. `test/priority-rank-parity.test.ts`\n    // pins that agreement.\n    if (priority) {\n      const rank: Record<string, number> = { low: 1, medium: 2, high: 3, critical: 4 };\n      input.priority_rank = rank[priority] ?? 0;\n    }\n\n    // \u2500\u2500 SLA policy matrix: priority \u00D7 account tier \u2500\u2500\n    //\n    // The canonical write-up \u2014 the unit, and why the `critical` row is flat at\n    // 4 \u2014 lives in `_case-sla.ts`.\n    //\n    // \u26A0\uFE0F The table is declared INLINE and duplicated in `_case-sla.ts` on\n    // purpose, for the same reason as the `rank` map above: L2 hook bodies run\n    // body-only in the QuickJS sandbox, so a shared module constant resolves at\n    // authoring time and arrives as `undefined`. The seed module imports the\n    // real constant; this body cannot. `test/case-sla-matrix.test.ts` pins all\n    // sixteen cells by driving THIS handler, so the copies cannot drift.\n    if (priority && !input.sla_due_date && !ctx.previous?.sla_due_date) {\n      const slaCalendarHours: Record<string, Record<string, number>> = {\n        critical: { strategic: 4, enterprise: 4, mid_market: 4, smb: 4 },\n        high: { strategic: 6, enterprise: 8, mid_market: 8, smb: 8 },\n        medium: { strategic: 24, enterprise: 36, mid_market: 48, smb: 48 },\n        low: { strategic: 96, enterprise: 120, mid_market: 168, smb: 168 },\n      };\n      // `smb` is both the loosest column and the `tier` field's own default, so\n      // an unclassified account and an UNREADABLE one land on the same cell.\n      // Erring loose is the safe direction: a tighter deadline invented out of\n      // a permission error would manufacture breaches.\n      const DEFAULT_TIER = 'smb';\n      const row = slaCalendarHours[priority];\n      // An unrecognised priority gets no clock at all rather than a guessed\n      // one \u2014 the same refusal-to-invent as the `0` unranked sentinel above.\n      if (row) {\n        let tier = DEFAULT_TIER;\n        // Only pay for the account read when the row actually varies by tier.\n        // The `critical` row does not, which is what makes a critical case\n        // behave EXACTLY as it did before this hook learned about accounts \u2014\n        // same 4 hours, same absence of any dependency on `ctx.api`.\n        const variesByTier =\n          row.strategic !== row.enterprise ||\n          row.enterprise !== row.mid_market ||\n          row.mid_market !== row.smb;\n        const accountId =\n          (typeof input.crm_account === 'string' && input.crm_account) ||\n          (typeof ctx.previous?.crm_account === 'string' && (ctx.previous.crm_account as string)) ||\n          undefined;\n        if (variesByTier && accountId && api) {\n          try {\n            const found = await api.object('crm_account').find({\n              where: { id: accountId }, fields: ['tier'], top: 1,\n            });\n            const rows = Array.isArray(found) ? found : [];\n            const stored = rows.length ? rows[0].tier : undefined;\n            if (typeof stored === 'string' && stored) tier = stored;\n          } catch {\n            // Best-effort tier resolution: the anonymous web-to-case grant can\n            // create a case and read nothing else, and a denial there must not\n            // reject the submission. Falling through leaves `tier` on the\n            // default column. (No `console` in the L2 hook sandbox \u2014 cf. #471.)\n          }\n        }\n        const hours = row[tier] ?? row[DEFAULT_TIER];\n        // Milliseconds, not `setHours(getHours() + n)`: the latter does LOCAL\n        // calendar arithmetic, so on a host in a DST-observing zone \"+4 hours\"\n        // silently becomes 3 or 5 real hours across a transition \u2014 and a 168h\n        // Low-priority clock crosses one twice a year by construction. These\n        // are elapsed hours, so add elapsed milliseconds.\n        input.sla_due_date = new Date(Date.now() + hours * 3_600_000).toISOString();\n      }\n    }\n\n    // Closed flag/date + resolution time.\n    const effStatus =\n      (typeof input.status === 'string' && input.status) ||\n      (typeof ctx.previous?.status === 'string' && (ctx.previous.status as string)) ||\n      undefined;\n\n    // `is_closed` is DERIVED from `status`, on every write including a guest's.\n    // \u26D4 Never make the recompute conditional on the caller: a guest's\n    // `status: 'closed'` stored alongside `is_closed: false` contradicts\n    // itself, and every consumer keyed on the flag \u2014 the pinned\n    // `unassigned_triage` view, the `case_unassigned_triage_sharing` rule \u2014\n    // reads such a case as open backlog forever. A derived column is derived on\n    // every write or it is not derived at all; the guest's own `is_closed` is\n    // still ignored, because this recompute overwrites whatever they sent.\n    if (typeof effStatus === 'string') input.is_closed = effStatus === 'closed';\n\n    if (!isGuestSubmission) {\n      const becameClosed = input.status === 'closed' && ctx.previous?.status !== 'closed';\n      if (becameClosed && !input.closed_date && !ctx.previous?.closed_date) {\n        input.closed_date = new Date().toISOString();\n      }\n\n      const closedDate =\n        (typeof input.closed_date === 'string' && input.closed_date) ||\n        (typeof ctx.previous?.closed_date === 'string' && (ctx.previous.closed_date as string)) ||\n        undefined;\n      // The creation instant is the platform's `created_at` (#1992): stamped\n      // by `sys_stamp_audit_insert` before this hook runs on an insert (a\n      // seed row keeps its authored value), and read back off the stored row\n      // on an update.\n      const createdDate =\n        (typeof input.created_at === 'string' && input.created_at) ||\n        (typeof ctx.previous?.created_at === 'string' && (ctx.previous.created_at as string)) ||\n        undefined;\n      if (closedDate && createdDate) {\n        const hrs = (new Date(closedDate).getTime() - new Date(createdDate).getTime()) / 3_600_000;\n        if (Number.isFinite(hrs) && hrs >= 0) input.resolution_time_hours = Math.round(hrs * 10) / 10;\n      }\n\n      // \u2500\u2500 The breach is recorded when the clock stops (#2070) \u2500\u2500\n      //\n      // `case_sla_monitor` flags a breach only while a case is live work, and\n      // only where scheduled work runs. A case resolved or closed after its\n      // `sla_due_date` therefore kept `is_sla_violated: false` for good, and\n      // the closed-case surfaces (`sla_performance`, the compliance gauge)\n      // counted it as met. The write that takes the case out of live work is\n      // the moment its clock stops, so that write records a late finish.\n      //\n      // The rule is `caseSlaBreached` in `_case-sla.ts`; the status set is\n      // `CLOSED_CASE_STATUSES` in `_case-assignment.ts`. Both are spelled\n      // inline because this body has no module scope:\n      // `test/case-sla-breach-on-close.test.ts` drives the lowered body\n      // against the helper, and `test/live-work-predicate-parity.test.ts` pins\n      // the set by name. Only the ENTRY into the set is judged (a\n      // resolved \u2192 closed write stopped no clock), a case with no due date is\n      // left alone, and the flag is never cleared \u2014 a breach stays recorded.\n      //\n      // The stop instant is the `closed_date` this write carries \u2014 the stamp\n      // above, or a system writer's own \u2014 else now. The flag is written onto\n      // this record's own payload, which is not a caller-supplied key, so the\n      // agent's `editable: false` mask on it does not refuse the agent's close.\n      const settledStatuses = ['resolved', 'closed'];\n      if (settledStatuses.includes(String(effStatus)) && !settledStatuses.includes(String(ctx.previous?.status))) {\n        const due = input.sla_due_date !== undefined ? input.sla_due_date : ctx.previous?.sla_due_date;\n        const stoppedAt = (typeof input.closed_date === 'string' && input.closed_date) || new Date().toISOString();\n        if (typeof due === 'string' && Date.parse(due) < Date.parse(stoppedAt)) input.is_sla_violated = true;\n      }\n    }\n  },\n};\n\nconst caseSideEffects: Hook = {\n  name: 'case_status_side_effects',\n  object: 'crm_case',\n  events: ['afterUpdate'],\n  priority: 800,\n  async: true,\n  onError: 'log',\n  description: 'Open the escalation follow-up task for the account owner.',\n  handler: async (ctx: HookContext) => {\n    const { input } = ctx;\n    const previous = ctx.previous;\n    if (!previous) return;\n    const api = ctx.api as HookApi | undefined;\n    if (!api) return;\n\n    const caseId =\n      (typeof input.id === 'string' && input.id) ||\n      (typeof previous.id === 'string' ? (previous.id as string) : undefined);\n    const accountId =\n      (typeof input.crm_account === 'string' && input.crm_account) ||\n      (typeof previous.crm_account === 'string' && previous.crm_account) ||\n      undefined;\n\n    // Escalation: open task for the account owner.\n    //\n    // \u26A0\uFE0F `owner_id` is the platform ownership anchor, and planting a record\n    // under ANOTHER user is a transfer: the #3004 guard denies it unless the\n    // caller holds `allowTransfer`. This insert runs on `ctx.api`, which\n    // carries the CALLER's context (not a system one), so the guard applies \u2014\n    // hence the `crm_task.allowTransfer` grant on `service_agent` (see\n    // `src/sales/profiles/service-agent.profile.ts`, and the canonical note in\n    // `src/sales/profiles/index.ts`). One ownership column means one answer, and the\n    // answer is the person who must act.\n    //\n    // The CASE itself has already changed hands by the time this runs, on the\n    // `beforeUpdate` seam of this very update (`case_escalation_reassign`) \u2014 so\n    // this hook still writes no `crm_case.owner_id` and needs no\n    // `crm_case.allowTransfer`. The task and the case are two different\n    // hand-offs: the task goes to the ACCOUNT owner (commercial follow-up), the\n    // case to a service manager (the work itself).\n    if (input.status === 'escalated' && previous.status !== 'escalated' && accountId) {\n      const account = await api.object('crm_account').findOne({ where: { id: accountId } });\n      const ownerId = (account as { owner_id?: string } | null)?.owner_id ?? ctx.user?.id;\n      // UTC calendar for the step, matching the `toISOString()` render below\n      // (same shape as `lead.hook.ts` / `opportunity.hook.ts`): a local\n      // `setDate` step preserves wall-clock time, so a one-day follow-up filed\n      // across a spring-forward lands on the day of the escalation itself.\n      const due = new Date();\n      due.setUTCDate(due.getUTCDate() + 1);\n      // Title the task with what the reader already knows the case by (#1208).\n      // Title the task with what the reader already knows the case by. The\n      // PRIMARY KEY is not that: every case surface in this app (record pages,\n      // list views, breadcrumbs, the `display_title` formula on `crm_case`)\n      // names a case `CASE-00039`, so a queue of urgent rows differing only in\n      // a 16-character opaque id is a queue nobody can triage. The id is not\n      // lost \u2014 it travels in `related_to_case` below, where a relationship\n      // belongs.\n      //\n      // Both parts are read off `previous`, not fetched: an `afterUpdate`\n      // pre-image is the WHOLE stored row (`driver.findOne` with no\n      // projection), so `case_number` \u2014 an engine-issued autonumber, never\n      // present on an update payload \u2014 and `subject` are both already in hand.\n      // `subject` still prefers `input`, since an update may be changing it in\n      // this very write.\n      //\n      // \u26A0\uFE0F The 255 cap is not cosmetic. `crm_task.subject` declares\n      // `maxLength: 255` and the engine ENFORCES it, while `crm_case.subject`\n      // allows the same 255 \u2014 so `Escalated: ` + number + separator + a\n      // max-length case subject is 279 characters and the insert is REJECTED.\n      // This hook is `async: true` + `onError: 'log'`, so that rejection\n      // surfaces nowhere: the escalation task would simply never exist.\n      // Truncating the TAIL keeps the identifier \u2014 the discriminating half \u2014\n      // intact in a column that visibly truncates anyway.\n      //\n      // \u26A0\uFE0F Composed INLINE rather than in a shared helper: hook bodies ship\n      // body-only through QuickJS, and a module-scope reference makes\n      // `extractHookBody` throw \u2014 which the CLI build CATCHES, silently\n      // bundling the closure instead, with no gate going red. The pin runs this\n      // out of the LOWERED body for exactly that reason\n      // (`test/escalation-task-subject.test.ts`).\n      const caseNumber = typeof previous.case_number === 'string' ? previous.case_number.trim() : '';\n      const caseSubject =\n        (typeof input.subject === 'string' && input.subject.trim()) ||\n        (typeof previous.subject === 'string' && previous.subject.trim()) ||\n        '';\n      const label = [caseNumber, caseSubject].filter(Boolean).join(' \u00B7 ');\n      const titled = label ? `Escalated: ${label}` : 'Escalated case needs attention';\n      await api.object('crm_task').insert({\n        subject: titled.length > 255 ? `${titled.slice(0, 254)}\u2026` : titled,\n        status: 'not_started',\n        priority: 'urgent',\n        type: 'follow_up',\n        due_date: due.toISOString().slice(0, 10),\n        owner_id: ownerId,\n        related_to_type: 'crm_case',\n        related_to_case: caseId,\n        related_to_account: accountId,\n      });\n    }\n  },\n};\n\n/**\n * Resolution rollup: a case reaching `resolved` bumps its account's\n * `last_activity_date`.\n *\n * \u26D4 No date is stamped on the CASE \u2014 `closed_date` belongs exclusively to the\n * `closed` transition (stamped by `case_sla_defaults`). Writing it as a proxy\n * for a resolved-date both corrupts resolution metrics (a resolved-then-closed\n * case keeps its resolve time as its close time) and re-enters the\n * record-change trigger surface.\n *\n * ## `runAs: 'system'`, and why this is its own hook (#2014)\n *\n * Cases are resolved by service agents, and an agent holds no edit right on\n * accounts \u2014 so as the caller the bump was refused, `onError: 'log'` swallowed\n * it, and an agent's resolve never reached the account's activity clock. The\n * clock is the account's derived fact, not the agent's edit, so the write is\n * elevated. It is split out of `case_status_side_effects` because `runAs` is\n * per hook and that hook's other write \u2014 the escalation task \u2014 needs no\n * elevation: the agent's narrow `crm_task.allowTransfer` grant exists for it\n * (`service-agent.profile.ts`). Elevating as little as possible (AGENTS.md rule\n * 9) means this one write. Elevation is not anonymity: the account's\n * `updated_by` still names the agent. Organization (rule 10): it writes only\n * the account the triggering case names, and the elevated `ctx.api` keeps the\n * trigger's tenant.\n */\nconst caseResolutionAccountActivity: Hook = {\n  name: 'case_resolution_account_activity',\n  object: 'crm_case',\n  events: ['afterUpdate'],\n  priority: 800,\n  async: true,\n  onError: 'log',\n  runAs: 'system',\n  description: 'Bump the account\u2019s last activity date when a case is resolved.',\n  handler: async (ctx: HookContext) => {\n    const { input } = ctx;\n    const previous = ctx.previous;\n    if (!previous) return;\n    if (input.status !== 'resolved' || previous.status === 'resolved') return;\n    const api = ctx.api as HookApi | undefined;\n    if (!api) return;\n    const accountId =\n      (typeof input.crm_account === 'string' && input.crm_account) ||\n      (typeof previous.crm_account === 'string' && previous.crm_account) ||\n      undefined;\n    if (!accountId) return;\n    await api.object('crm_account').update(\n      { id: accountId, last_activity_date: new Date().toISOString().slice(0, 10) },\n      { where: { id: accountId } },\n    );\n  },\n};\n\n/**\n * Ownerless-intake round-robin, composed from `_case-assignment.ts`.\n *\n * \u26A0\uFE0F Listed AFTER `case_sla_defaults` here for readability only \u2014 runtime\n * ordering is decided by `priority` (250 vs 200), not by array position, and it\n * is load-bearing: `case_sla_defaults` strips a guest-supplied `owner_id` and\n * this hook must run after the strip, never before it.\n */\nconst caseAutoAssign: Hook = createCaseRoundRobinAssign();\n\n/**\n * Escalation hand-off to the `service_manager` pool, composed from\n * `_case-assignment.ts`.\n *\n * Runs on `beforeUpdate` and mutates the escalation write itself \u2014 it issues no\n * operation of its own, which is what keeps it off the record-change trigger\n * surface.\n */\nconst caseEscalationReassign: Hook = createCaseEscalationReassign();\n\n/**\n * Triage self-claim, composed from `_case-assignment.ts`.\n *\n * An agent who moves an unowned open case into a worked status becomes its\n * owner. \u26A0\uFE0F Priority 260 puts it AFTER the escalation hand-off (250), and it\n * stands down whenever `owner_id` is already in the payload \u2014 so the two\n * ownership writers on this seam cannot both speak. Like the hand-off it issues\n * no operation of its own; unlike either sibling it reads no pool, because the\n * only user id it can write is the caller's own.\n */\nconst caseSelfClaim: Hook = createCaseSelfClaim();\n\n/**\n * Normalise a BLANK `resolved_by_article` to NULL.\n *\n * Additive and deliberately independent of everything above: it touches no\n * ownership column and issues no operation of its own.\n *\n * ### Why it has to exist\n *\n * `resolved_by_article` is the column the deflection ratio on `case_metrics`\n * counts (`kb_resolved_count` = `count(resolved_by_article)` over closed cases).\n *\n * \u26A0\uFE0F Platform behaviour, measured against the real automation engine: an\n * optional SCREEN field the agent leaves empty does not arrive as \"absent\" \u2014\n * the resume carries `''`, and `update_record` writes that empty string into\n * the column:\n *\n *   supplied `'ka1'` \u2192 `resolved_by_article: \"ka1\"`\n *   left blank       \u2192 `resolved_by_article: \"\"`      \u2190 counted by count(col)\n *   key omitted      \u2192 column not written at all      \u2190 correct\n *\n * SQL `count(column)` counts every NON-NULL value, and `''` is not NULL. So\n * without this hook every case closed WITHOUT an article lands in the numerator\n * and the deflection rate reads 100% on a dashboard that raises no error while\n * doing it \u2014 a wrong ratio indistinguishable from a right one.\n *\n * Fixing it here rather than in the measure is deliberate: an empty string in a\n * lookup column is wrong for the record form, the list views, the reports and\n * any future reader too, so it is the STORED value that is corrected. Teaching\n * one measure to discount `''` is a lenient consumer papering over bad data,\n * and the next reader would not know to copy it.\n * `test/knowledge-deflection.test.ts` pins both halves.\n *\n * \u26A0\uFE0F The blank test is spelled inline rather than lifted into a shared helper:\n * hook handlers lower to a metadata-only body and a free identifier would push\n * this one into the legacy runtime bundle instead\n * (`test/action-sandbox.test.ts` fails the build on it).\n */\nconst caseResolutionArticleNormalize: Hook = {\n  name: 'case_resolution_article_normalize',\n  object: 'crm_case',\n  events: ['beforeInsert', 'beforeUpdate'],\n  priority: 150,\n  description: 'Normalise a blank resolved_by_article to null so the deflection measure counts only real links.',\n  handler: async (ctx: HookContext) => {\n    const { input } = ctx;\n    // Only a write that CARRIES the key is normalised. An update that never\n    // mentions the column must not clear a link somebody else set.\n    if (!('resolved_by_article' in input)) return;\n    const value = input.resolved_by_article;\n    if (value === '' || value === undefined) {\n      input.resolved_by_article = null;\n      return;\n    }\n    if (typeof value === 'string' && value.trim() === '') {\n      input.resolved_by_article = null;\n    }\n  },\n};\n\nexport default [\n  caseValidation,\n  caseAutoAssign,\n  caseEscalationReassign,\n  caseSelfClaim,\n  caseResolutionArticleNormalize,\n  caseSideEffects,\n  caseResolutionAccountActivity,\n];\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/service/objects/knowledge_article.hook.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/service/objects\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/service/objects/knowledge_article.hook.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport type { Hook, HookContext } from '@objectstack/spec/data';\n\n/**\n * Knowledge article lifecycle hook.\n *\n * On the FIRST publish, stamps `published_at` and `last_reviewed_at`. On every\n * later write that leaves the article published \u2014 an ordinary edit, or a\n * re-publish after archiving \u2014 refreshes `last_reviewed_at` only, so admin\n * \"stale article\" reports keep working while the original publish date stays\n * put.\n *\n * \"First publish\" is decided by whether the record ALREADY CARRIES a\n * `published_at`, not by which status the write arrives from (#780). The old\n * test was `previous.status === 'published'`, which recognises only the\n * published \u2192 published edit as a re-publish. But the documented lifecycle is\n * `draft \u2192 in_review \u2192 published \u2192 archived`, so the ordinary re-shelving move\n * `archived \u2192 published` arrives with `previous.status === 'archived'`, fell\n * into the first-publish branch, and moved a 2024 publish date to today. The\n * `all_articles` view sorts `published_at desc`, so the re-shelved article\n * jumped to the top of the list as if it had just been written.\n *\n * The date is read as `input.published_at ?? previous?.published_at` \u2014 the\n * value this record would end up with if the handler stamped nothing, which is\n * exactly the question \"does it already have one\". This is precedence between\n * the two halves of one write, not a tolerated alias for one key, and both\n * halves are load-bearing:\n *\n *   - `previous` is the FULL stored row: `update()` reads it and binds it BEFORE\n *     dispatching `beforeUpdate` (ADR-0058 Addendum II), so a re-publish sees\n *     the original date there. The `sys_fetch_previous_update` builtin that used\n *     to issue that `findOne` is retired.\n *   - `input` carries the date whenever the write supplies one, and on an INSERT\n *     that value is what gets stored: measured on 17.0.0-rc.2, the engine's\n *     read-only strip runs on the update path only, and hooks run before it in\n *     any case. So an import or migration publishing records with their\n *     historical dates reaches this handler with `published_at` set and no\n *     `previous`, and stamping over it rewrites imported history.\n *\n * Two adjacent engine behaviours this handler deliberately does NOT try to\n * paper over, both measured and filed as #788: `readonly: true` is not enforced\n * on the insert path at all, and on the update path the strip deletes the\n * caller-supplied key together with whatever a hook wrote there \u2014 so an update\n * that echoes `published_at` back can land a published article with none. That\n * outcome is identical before and after this change; a lenient consumer here\n * would only hide it.\n *\n * On the bulk path (`multi: true`) this handler now runs ONCE PER ROW, with\n * `input.id` bound to the row and `previous` its pre-image (ADR-0058 Addendum\n * II, D1/D2); past 10000 matched rows the whole write is refused with\n * `ERR_BULK_PER_ROW_HOOK_LIMIT`. The rc.2-era account \u2014 no `input.id`, no\n * `previous`, nothing stamped (#779, closed) \u2014 is HISTORY. Do not reason from\n * it; it is recorded here only because this file's own argument once did.\n *\n * \u26A0\uFE0F A PREDICATE UPDATE DERIVES NOTHING HERE \u2014 ADR-0058 Addendum II D3, and\n * the stand-down at the top of the handler is the idiom every row-conditioned\n * hook in this app carries. The full account and its measurements live in\n * `forecast.hook.ts`; the short version is that `update(obj, payload,\n * { multi: true, where })` sends ONE `SET` clause for all N matched rows and\n * hands every row's `beforeUpdate` THAT payload rather than a per-row copy, so\n * a write whose if-guard reads `ctx.previous` does not scope itself to the row\n * it was decided on.\n *\n * Both writes below are gated on the row, so both diverge \u2014 and this hook is\n * key-presence divergence (the loud kind) in BOTH limbs. There is no silent\n * limb, because neither write takes its VALUE from the row: both store\n * `nowIso`, a clock read. The row only ever decides WHETHER a key is written.\n *\n *   - `last_reviewed_at` sits behind the `nextStatus !== 'published'` early\n *     return, and that return reads the ROW. Measured on 17.4.0 on a\n *     fresh `pnpm dev`: the platform's own seed-ownership claim (one payload of\n *     `{ owner_id }`, `where: { owner_id: null }`) matched all 4 seeded\n *     articles; the 3 published ones stamped `last_reviewed_at`, the 1 draft\n *     returned early and stamped nothing, and the engine refused the batch \u2014\n *     `Refusing a multi-record update on 'crm_knowledge_article': its\n *     'beforeUpdate' handlers wrote 'last_reviewed_at' for some of the 4\n *     matched records and not for others`. Nothing was written, all 4 articles\n *     stayed ownerless, and `my_drafts` (filtered `owner_id =\n *     {current_user_id}`) was EMPTY until the `demo_bootstrap` sweep repaired\n *     them by id ten minutes later.\n *   - `published_at`'s existence criterion is the same shape one key over:\n *     #1888 measured it refused over 3 rows with\n *     `MULTI_UPDATE_HOOK_KEY_DIVERGENCE`. That limb is what #1265 was filed\n *     for, back when the engine widened in silence instead of refusing.\n *\n * \u26A0\uFE0F The `ctx.event` half of the guard is load-bearing, not ceremony: a batch\n * INSERT also reports `dispatch.mode === 'per-row'`, and there each row carries\n * its OWN payload. This hook is `beforeInsert` too, so dropping that half would\n * stop the seed load stamping `published_at` / `last_reviewed_at` at all.\n *\n * \u26A0\uFE0F HISTORY \u2014 do not reason from it. Until 17.3.0 the sandbox context carried\n * no per-row signal, so a `ctx.dispatch` guard lowered cleanly, passed every\n * in-process test and was INERT in production; PR #1274 recorded that as the\n * reason this could not be fixed here. That is FALSE from 17.3.0 on:\n * `buildSandboxContext` marshals `dispatch` and an `inputOptions` projection\n * (objectstack#11552), and `test/hooks-runtime-service.test.ts` pins that they\n * cross. `ctx.input.id` is still absent \u2014 read `ctx.previous.id`.\n */\nconst knowledgeArticlePublish: Hook = {\n  name: 'knowledge_article_publish_timestamps',\n  object: 'crm_knowledge_article',\n  events: ['beforeInsert', 'beforeUpdate'],\n  priority: 300,\n  description: 'Stamp published_at on the first publish; refresh last_reviewed_at while published.',\n  handler: async (ctx: HookContext) => {\n    // D3 stand-down (see the header). Every write below is decided against this\n    // row's `previous`, and this handler makes no refusal, so the whole body\n    // stands down on the predicate path; deriving still happens per record.\n    if (ctx.event === 'beforeUpdate' && ctx.dispatch?.mode === 'per-row') return;\n\n    const { input } = ctx;\n    const previous = ctx.previous;\n    const nextStatus = (typeof input.status === 'string' && input.status) || previous?.status;\n    if (nextStatus !== 'published') return;\n\n    const nowIso = new Date().toISOString();\n    // Publishing, re-publishing and editing while published are all reviews.\n    input.last_reviewed_at = nowIso;\n    // The emptiness test is spelled out here rather than factored into a\n    // module-scope helper: hook handlers lower to a metadata-only body, and a\n    // free identifier would push this one into the legacy runtime bundle\n    // instead \u2014 `test/action-sandbox.test.ts` fails the build on it.\n    const existing = input.published_at ?? previous?.published_at;\n    if (existing === undefined || existing === null || existing === '') {\n      input.published_at = nowIso;\n    }\n  },\n};\n\nexport default knowledgeArticlePublish;\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/service/pages/case_detail.page.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/service/pages\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/service/pages/case_detail.page.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport type { Page } from '@objectstack/spec/ui';\n\n/**\n * Case Detail Record Page\n *\n * Service-agent record page for the `crm_case` object. Mirrors the\n * opportunity_detail layout: highlights strip, status path, then a tab\n * strip with **Details / Related / Activity**.\n *\n * The Activity tab uses `record:activity`, which pulls the unified\n * timeline from `sys_comment`, `sys_activity`, `feed_item` and the field\n * history (enabled via `trackHistory: true` on `case.object.ts`). That is\n * how case comments and call logs surface here without a custom feed \u2014\n * call logs only because the block sets `showCompleted` (#2071).\n */\nexport const CaseDetailPage: Page = {\n  name: 'case_detail_page',\n  label: 'Case Detail',\n  description:\n    'Service-agent case record: highlights, SLA path, details and activity timeline.',\n\n  type: 'record',\n  object: 'crm_case',\n\n  template: 'full-width',\n  kind: 'full',\n  variables: [\n    { name: 'activeTab', type: 'string', defaultValue: 'details' },\n  ],\n\n  regions: [\n    {\n      name: 'header',\n      width: 'full',\n      components: [\n        {\n          type: 'page:header',\n          id: 'case_header',\n          label: 'Case Information',\n          properties: {\n            title: '{case_number} \u00B7 {subject}',\n            // The lookup field is `crm_account` \u2014 `{account}` matched nothing\n            // and the subtitle rendered blank.\n            subtitle: '{crm_account}',\n            // `icon` removed from `page:header` in @objectstack/spec 17.0.0\n            // (#6946, ADR-0087 D2) \u2014 deleted, not renamed. See the full note on\n            // `account_detail.page.ts`; nothing ever drew it.\n            // `breadcrumb` retired from `page:header` in @objectstack/spec 17.6.0\n            // (#20785, `page-header-breadcrumb-removed`) \u2014 deleted: no renderer\n            // ever drew a trail for it; the app shell's own trail is unchanged.\n            // Action IDs, not `ActionDef` objects: `PageHeaderProps.actions` is\n            // `z.array(z.string())` (\"Action IDs to show in header\") in\n            // @objectstack/spec 17.3.0, and this repo authors against the\n            // protocol (#1653). Each id is the `name` of a crm_case-scoped\n            // action \u2014 `claim_case` / `escalate_case` / `close_case` in\n            // `src/service/actions/case.actions.ts`, the activity trio in\n            // `src/service/actions/case-activity.actions.ts`.\n            //\n            // This list is the whole header (#2072, the #592 sentence on\n            // `lead_detail.page.ts`): an action it does not name is reachable\n            // only from the list row's \u22EE menu, which is how an agent on an\n            // unowned case had to go back to the list to claim it, and could\n            // not log or book a meeting here at all. Each action's own\n            // `visible` still decides when it shows \u2014 `claim_case` only on an\n            // ownerless open case. `claim_case` goes FIRST because the header\n            // draws three buttons inline and folds the rest into \u22EF: on an\n            // ownerless case claiming is the gesture, and on an owned one it\n            // is hidden, so the inline three stay escalate / close / call.\n            // `test/action-references.test.ts` holds this list to every\n            // crm_case action placed at `record_header`.\n            actions: ['claim_case', 'escalate_case', 'close_case', 'log_call', 'log_meeting', 'schedule_meeting'],\n          },\n        },\n        {\n          type: 'record:highlights',\n          id: 'case_highlights',\n          label: 'Key Information',\n          properties: {\n            // crm_case carries a single `sla_due_date` plus the derived\n            // `is_sla_violated` flag \u2014 the split response/resolution deadlines\n            // named here do not exist, so the agent's most time-critical fact\n            // was missing from the strip entirely.\n            fields: [\n              'status',\n              'priority',\n              'sla_due_date',\n              'is_sla_violated',\n              'owner_id',\n              'crm_account',\n            ],\n          },\n        },\n        {\n          type: 'record:path',\n          id: 'case_status_path',\n          label: 'Case Status Path',\n          properties: {\n            statusField: 'status',\n            stages: [\n              { value: 'new', label: 'New' },\n              { value: 'in_progress', label: 'In Progress' },\n              // The status option is `waiting_customer`; the longer spelling\n              // matched no option, so this stage never lit up and rendered\n              // untranslated next to its neighbours.\n              { value: 'waiting_customer', label: 'Waiting on Customer' },\n              { value: 'escalated', label: 'Escalated' },\n              { value: 'resolved', label: 'Resolved' },\n              { value: 'closed', label: 'Closed' },\n            ],\n          },\n        },\n      ],\n    },\n    {\n      name: 'main',\n      width: 'large',\n      components: [\n        {\n          type: 'page:tabs',\n          id: 'case_main_tabs',\n          properties: {\n            // `type` \u2192 `tabStyle` (@objectstack/spec 17.0.0, #6776, ADR-0087\n            // D2). Same concept, same three values (`line` | `card` | `pill`);\n            // the rename exists because a props key called `type` collides with\n            // the component node's own dispatch key and is unauthorable in the\n            // flat and JSX carriers. See the full note on `home.page.ts`.\n            tabStyle: 'line',\n            position: 'top',\n            items: [\n              {\n                // Tab item `key` \u2192 `value` (#1269). `value` is the stable\n                // `?tab=` URL token the renderer reads (`it.value`, falling back\n                // to an index-derived `tab-<i>`); `key` is read by nothing, so\n                // these tabs were addressable only as `tab-0`/`tab-1`/`tab-2`,\n                // which point at different tabs the moment the item list\n                // changes. `PageTabsProps`' own alias table answers `key` with\n                // `value` for exactly this reason.\n                value: 'details',\n                label: 'Details',\n                children: [\n                  {\n                    type: 'record:details',\n                    id: 'case_details',\n                    label: 'Case Details',\n                    properties: {\n                      // `columns` is a STRING enum ('1'|'2'|'3'|'4') in\n                      // @objectstack/spec 17, and `layout` was removed there\n                      // (#6946 / ADR-0087 D2).\n                      columns: '2',\n                      // Every section references one of crm_case's `fieldGroups`\n                      // (#970, the #806 class ruling C): the renderer derives\n                      // members, label, icon and collapse state from the object,\n                      // so this page curates only the order. The full note \u2014\n                      // what a group section does on 17.6.0 and what may not sit\n                      // beside `group` \u2014 is on `lead_detail.page.ts`.\n                      //\n                      // The highlights strip still wins (#1211): the renderer\n                      // drops what `record:highlights` registered (`status`,\n                      // `priority`, `sla_due_date`, `is_sla_violated`,\n                      // `owner_id`, `crm_account`) and the title candidate\n                      // `subject` from the derived members.\n                      //\n                      // `escalated_date` \u2014 written by three flows and shown\n                      // nowhere until now (#970) \u2014 arrives with the `escalation`\n                      // group, beside `is_escalated` and `escalation_reason`.\n                      //\n                      // `internal_notes` (#1428) is in the `system` group with\n                      // `is_closed`. A group whose members are ALL empty renders\n                      // nothing, but a boolean always holds a value, so `system`\n                      // renders on every case and an unwritten `internal_notes`\n                      // stays reachable the way every empty field here is: the\n                      // section's \"Show N empty fields\" toggle, then inline edit.\n                      // \u26D4 Not the create form \u2014 `/new` and edit both resolve\n                      // `view.form`, and `case.hook.ts` nulls the column for\n                      // anonymous web-to-case submissions.\n                      //\n                      // `resolution` / `resolved_by_article` render once the case\n                      // carries one; `close_case` is the flow that collects the\n                      // resolution.\n                      //\n                      // `hideEmpty: false` (#2003, the #1211 reasoning) only on\n                      // `origin`: with `owner_id` in the strip, its one member is\n                      // the channel an agent picks, and without the key the\n                      // section vanishes on a new case. Not on `sla`: outside\n                      // the strip its members are stamps no one types\n                      // (`closed_date` and `resolution_time_hours` at close,\n                      // `first_response_date` by `event.hook.ts`), so the key\n                      // would draw empty rows to look at, not to fill.\n                      sections: [\n                        { group: 'basic' },\n                        { group: 'origin', hideEmpty: false },\n                        { group: 'sla' },\n                        { group: 'escalation' },\n                        { group: 'resolution' },\n                        { group: 'system' },\n                      ],\n                    },\n                  },\n                ],\n              },\n              {\n                value: 'related',\n                label: 'Related',\n                children: [\n                  {\n                    type: 'page:accordion',\n                    id: 'case_related_accordion',\n                    properties: {\n                      items: [\n                        {\n                          // An accordion item `key` is DELETED, not renamed to\n                          // `value` \u2014 the opposite verdict to the tab items\n                          // above, and the difference is a read point (#1269).\n                          // `PageAccordionProps`' item shape is\n                          // `{ label, icon?, collapsed?, children }` and it\n                          // prescribes AGAINST `value` by name: the renderer\n                          // maps every item to `{ ...it, value: `panel-<idx>` }`\n                          // before rendering, so an authored value is\n                          // overwritten. `page:tabs` really does read `it.value`;\n                          // `page:accordion` does not. Nothing addresses these\n                          // panels, so the identifier has nowhere to land.\n                          label: 'Open Tasks',\n                          children: [\n                            {\n                              type: 'record:related_list',\n                              id: 'case_tasks',\n                              properties: {\n                                objectName: 'crm_task',\n                                relationshipField: 'related_to_case',\n                                columns: [\n                                  'subject',\n                                  'status',\n                                  'priority',\n                                  'due_date',\n                                  'owner_id',\n                                ],\n                                filter: [\n                                  { field: 'status', operator: 'not_equals', value: 'completed' },\n                                ],\n                                limit: 10,\n                              },\n                            },\n                          ],\n                        },\n                      ],\n                    },\n                  },\n                ],\n              },\n              {\n                value: 'activity',\n                label: 'Activity',\n                children: [\n                  {\n                    type: 'record:activity',\n                    id: 'case_activity',\n                    properties: {\n                      filterMode: 'all',\n                      showFilterToggle: true,\n                      limit: 25,\n                      unifiedTimeline: true,\n                      showCommentInput: true,\n                      enableMentions: true,\n                      enableReactions: true,\n                      enableThreading: true,\n                      // Load-bearing (#2071): a call or meeting logged on the\n                      // case is a `sys_activity` row of type `completed` (the\n                      // `task` feed kind), and the renderer drops every such\n                      // row unless this is true \u2014 so an agent's logged call\n                      // never reached this tab. The case's other `completed`\n                      // writers are its own `resolved` / `closed` milestones\n                      // (`case.object.ts`), which belong on this timeline too.\n                      // Completed crm_task rows do NOT arrive here: a task's\n                      // audit rows are keyed to the task, and this feed reads\n                      // only rows keyed to the case. No `types` filter, unlike\n                      // the lead page: this timeline mixes comments and field\n                      // changes on purpose (`unifiedTimeline` above).\n                      showCompleted: true,\n                    },\n                  },\n                ],\n              },\n            ],\n          },\n        },\n      ],\n    },\n  ],\n\n  isDefault: true,\n\n  aria: {\n    ariaLabel: 'Case Detail Page',\n    ariaDescribedBy: 'Service-agent case detail view with SLA path, details, related items and activity timeline.',\n  },\n};\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/service/reports/case.report.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/service/reports\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/service/reports/case.report.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport type { Report } from '@objectstack/spec/ui';\n\nexport const CasesByStatusPriorityReport: Report = {\n  name: 'cases_by_status_priority',\n  label: 'Cases by Status and Priority',\n  description: 'Summary of cases by status and priority',\n  // The chart counts cases, so `case_count` must be selected alongside the\n  // resolution time \u2014 and the yAxis must name that MEASURE ('case_number'\n  // was a raw-field name that exists in no dataset, so the axis was empty).\n  dataset: 'case_metrics', rows: ['status', 'priority'], values: ['case_count', 'avg_resolution'],\n  type: 'summary',\n  chart: { type: 'bar', title: 'Cases by Status', showLegend: true, xAxis: 'status', yAxis: 'case_count' }\n};\n\nexport const SlaPerformanceReport: Report = {\n  name: 'sla_performance',\n  label: 'SLA Performance Report',\n  description: 'Analysis of SLA compliance',\n  // 'avg_sla_violated' (not a duplicated 'case_count') \u2014 the table showed two\n  // identical Cases columns and no violation measure; the chart's yAxis must\n  // name a dataset MEASURE, not a raw field ('is_sla_violated' leaked the\n  // column name onto the axis).\n  dataset: 'case_metrics', rows: ['priority'], values: ['case_count', 'avg_sla_violated', 'avg_resolution'],\n  type: 'summary',\n  runtimeFilter: { is_closed: true },\n  chart: { type: 'column', title: 'SLA Violations by Priority', showLegend: false, xAxis: 'priority', yAxis: 'avg_sla_violated' }\n};\n\n/**\n * Daily case inflow by priority \u2014 matrix over `created_at`. Support managers\n * use this to spot priority spikes (e.g. a P1 burst on Tuesday) and staff\n * accordingly.\n *\n * `case_metrics.created_at` declares the day bucket, so records created at\n * different times on the same day aggregate into one column.\n *\n * No `runtimeFilter` (#1992). The column used to be `created_date`, which\n * nothing wrote on a real case, so this report carried\n * `{ created_date: { $ne: null } }` against a headerless '\u2014' column and every\n * case created through the UI or REST fell out of it. `created_at` is the\n * platform's own creation stamp, written on every insert, so there is no\n * empty bucket to exclude and every case opened is counted.\n */\nexport const CasesOpenedByDayPriorityReport: Report = {\n  name: 'cases_opened_by_day_priority',\n  label: 'Cases Opened by Priority \u00D7 Day',\n  description: 'Daily case inflow split by priority',\n  dataset: 'case_metrics', rows: ['priority'], columns: ['created_at'], values: ['case_count'],\n  type: 'matrix',\n};\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/service/sharing/case.sharing.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/service/sharing\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/service/sharing/case.sharing.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport { P } from '@objectstack/spec';\n\n/**\n * Share escalated/critical cases with service managers.\n * ADR-0090 D3: `role_and_subordinates` is gone (positions are flat); the\n * grant now targets the manager position itself.\n *\n * ### \u26A0\uFE0F `is_closed == false` is DELIBERATE here \u2014 ruled 2026-08-31, do NOT align it\n *\n * `is_closed` is derived by `case_sla_defaults` as `effStatus === 'closed'` and\n * never flips on `resolved`, so this grant stands for the WHOLE\n * `resolved \u2192 closed` window: a manager keeps `edit` on a critical case that an\n * agent has already resolved, until somebody closes it.\n *\n * That standing access is the point, not an oversight. `resolved` means \"the\n * agent believes this is fixed\", not \"this case is over\", and the work that\n * belongs in the gap is the manager's: quality-sampling the resolution, calling\n * the customer back, reopening it when the fix did not hold. Taking the grant\n * away at `resolved` would revoke access exactly when that review starts. It is\n * also how mainstream service clouds shape the same window \u2014 a Zendesk\n * satisfaction rating arrives after Solved, ServiceNow surveys on resolution\n * and auto-closes on a timer.\n *\n * Two properties keep this from being the accumulating-permission hazard that\n * #1145 was about: it is NARROW (`critical` only \u2014 not every case a manager\n * could ask for) and it is BOUNDED (closing the case ends it, and closing is an\n * ordinary agent gesture, not an admin one).\n *\n * \u26D4 Do not rewrite this as `status not_in ['resolved', 'closed']` for symmetry\n * with `case_unassigned_triage_sharing` below. Same spelling, different\n * question: that rule asks \"is this work waiting for a human\", this one asks\n * \"may a manager still reach this case\". `test/live-work-predicate-parity.test.ts`\n * holds the difference on its boundary roster, so the alignment turns it red\n * rather than landing silently.\n *\n * ### What would make this the WRONG shape\n *\n * The keep rests on a workflow nobody has yet measured a real user performing,\n * so it is a judgement with named conditions rather than a fact. Any of these\n * turning true makes it a card to re-decide, not a tidy-up to perform:\n *\n *   - cases pile up in `resolved` because nothing closes them, so \"bounded\"\n *     stops being true in practice and the grant is effectively permanent;\n *   - the post-resolution review moves to a surface that needs no record access\n *     (a survey object, a report), leaving this grant with no consumer;\n *   - the criteria widens past `critical`, at which point \"narrow\" is gone too;\n *   - somebody measures that no manager ever opens a resolved case \u2014 the one\n *     piece of evidence #1328 could not obtain and explicitly declined to\n *     assume either way.\n */\nexport const CaseEscalationSharingRule = {\n  name: 'case_escalation_sharing',\n  label: 'Escalated Cases Sharing',\n  object: 'crm_case',\n  type: 'criteria' as const,\n  condition: P`record.priority == \"critical\" && record.is_closed == false`,\n  accessLevel: 'edit' as const,\n  sharedWith: { type: 'position' as const, value: 'service_manager' },\n};\n\n/**\n * The same escalation visibility one rung up.\n *\n * Positions are FLAT (ADR-0090 D3), so the director rung needs its own grant \u2014\n * without it a service director cannot open the critical case their manager is\n * being paged about. Read-only: the manager on the rule above handles it.\n *\n * ### \u26A0\uFE0F `is_closed == false` is DELIBERATE here too \u2014 ruled 2026-08-31\n *\n * Read the note on `CaseEscalationSharingRule` above in full; it is the same\n * decision and the same conditions for revisiting it. The short form: the flag\n * never flips on `resolved`, so a director keeps `read` on a resolved critical\n * case until it is closed, and that `resolved \u2192 closed` window is precisely\n * when a director looks \u2014 an escalation is reviewed after it is handled, not\n * while it is still burning. `read`, not `edit`, is the whole difference from\n * the rule above: the director watches the window, the manager works it.\n *\n * \u26D4 Do not move this onto `status not_in ['resolved', 'closed']`. Pinned on the\n * boundary roster of `test/live-work-predicate-parity.test.ts`, with the reason.\n */\nexport const CaseDirectorSharingRule = {\n  name: 'case_director_sharing',\n  label: 'Escalated Cases \u2014 Service Director',\n  object: 'crm_case',\n  type: 'criteria' as const,\n  condition: P`record.priority == \"critical\" && record.is_closed == false`,\n  accessLevel: 'read' as const,\n  sharedWith: { type: 'position' as const, value: 'service_director' },\n};\n\n/**\n * The intake queue's read side: an OPEN case that nobody owns is visible to\n * every service agent, so they can pull it out of triage (#1096).\n *\n * ### What was broken\n *\n * #596 shipped round-robin intake plus a pinned `Unassigned \u2014 triage` tab, and\n * `case_auto_assign` is a deliberate NO-OP whenever the `service_agent` pool is\n * empty or unreadable (the anonymous web-to-case path cannot read\n * `sys_user_position` at all). Those cases land ownerless \u2014 and `service_agent`\n * holds `crm_case` with `readScope: 'own'`, so an unowned row matched nobody's\n * own-scope. The tab was pinned in every Cases list including the agent's, and\n * it returned zero rows for the one persona it exists for.\n *\n * ### Why THIS shape (the ruling on #1096, option A)\n *\n * The grant is **self-limiting**: it holds only while `owner_id` is empty, so\n * the instant an agent claims the case the criteria stops matching, the share\n * is revoked on the next reconcile, and ordinary own-scope resumes. There is no\n * accumulating permission surface \u2014 the rule's own condition destroys it. That\n * is what makes it narrower than the two rejected alternatives: `viewAllRecords`\n * on the profile (option C) hands every agent every customer's entire case\n * history to solve a null-owner problem, and unpinning the tab (option B) is not\n * expressible \u2014 `ViewTabSchema` has no per-profile scoping \u2014 so it means\n * removing the tab for everyone.\n *\n * `edit`, not `read`: triage is a pull queue. An agent who can see the row but\n * not write it cannot claim it, and claiming is the whole point.\n *\n * ### \u26A0\uFE0F Why there is no `has()` guard here, and why adding one would break it\n *\n * A sharing condition is NOT an interpreted CEL predicate. `plugin-sharing`\n * compiles it to a pushdown filter with `compileCelToFilter`, which rejects the\n * whole function-call class \u2014 so a `has(record.owner_id)` guard makes this rule\n * *untranslatable*, and the seeder then refuses it outright (never degrading it\n * to match-all). The rule would be declared, documented and silently unseeded:\n * exactly the #621 defect. The house totality rule (AGENTS.md #630) governs the\n * two INTERPRETED surfaces \u2014 object `validations[]` / field predicates, and\n * record-change flow conditions \u2014 and does not reach this one.\n *\n * Totality is still answered, one layer down: `record.owner_id == null` lowers\n * to `{ owner_id: { $null: true } }`, and `$null` is the operator form that\n * treats an ABSENT key and a NULL column alike. That matters because the two\n * shapes are both real \u2014 `driver-memory` stores only the columns a row was\n * written with, SQL stores every column \u2014 and a marketplace app does not choose\n * its host's datasource. Both are MEASURED, end to end, in\n * `test/unassigned-case-triage-reach.test.ts`; the compiler's own verdict on\n * `has()` is pinned in `test/sharing-seeding.test.ts`.\n *\n * ### \u26A0\uFE0F Why the second clause is a STATUS chain, not `is_closed == false`\n *\n * This grant is deliberately NARROWER than it was. `is_closed` is derived by\n * `case_sla_defaults` as `effStatus === 'closed'`, so it never flips on\n * `resolved` \u2014 and the old predicate therefore handed every service agent\n * `edit` on every RESOLVED ownerless case, forever. A resolved case is not\n * backlog and not work waiting for a human, so the grant is now the same\n * \"no longer live work\" predicate the load-balancing hooks\n * (`CLOSED_CASE_STATUSES` in `_case-assignment.ts`) and `case_sla_monitor`\n * already use: the case is shared only while its status is neither `resolved`\n * nor `closed`. `test/live-work-predicate-parity.test.ts` holds the four\n * consumers to that one set, BY NAME.\n *\n * \u26A0\uFE0F The tightening does NOT break the claim seam. Record access is resolved\n * against the STORED row, so an agent resolving an unowned open case straight\n * out of triage is still reachable (the case is open at the moment of the\n * write) \u2014 #1143's \"finishing a case is not picking it up\" is unchanged. What\n * the agent loses is reopening an *already* resolved ownerless case, which puts\n * `resolved` in exactly the bucket `closed` has been in since #1134: reopening\n * a terminal unowned case is an admin move, not a triage move.\n *\n * The spelling is the `!=` chain rather than `!(record.status in [...])`, and\n * that is measured, not stylistic. Both compile, but the membership form lowers\n * to a TOP-LEVEL `$not` wrapping an `$in`, a combination absent from the\n * measured operator matrix in `test/sharing-seeding.test.ts` and on the one\n * operator that file records a driver regression for. The chain lowers to\n * `{ $and: [{ status: { $ne: \u2026 } }, \u2026] }` \u2014 plain conjunction of the operator\n * that matrix lists as supported. An untranslatable or unexecutable sharing\n * condition is not a loud failure: the seeder DROPS the rule and the tab goes\n * empty again (#621), so this rule takes the portable form.\n *\n * `status` needs no totality guard the way `owner_id` does: it is `required`\n * with `storage: { notNull: true }` on `crm_case`, so unlike the ownerless\n * column it is never the absent-key shape.\n *\n * A resolved or closed unowned case stays hidden on purpose: it is history, not\n * backlog, and the tab's row count has to keep meaning \"work waiting for a\n * human\".\n */\nexport const CaseUnassignedTriageSharingRule = {\n  name: 'case_unassigned_triage_sharing',\n  label: 'Unassigned Cases \u2014 Triage',\n  object: 'crm_case',\n  type: 'criteria' as const,\n  condition: P`record.owner_id == null && record.status != \"resolved\" && record.status != \"closed\"`,\n  accessLevel: 'edit' as const,\n  sharedWith: { type: 'position' as const, value: 'service_agent' },\n};\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/service/skills/case-triage.skill.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/service/skills\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/service/skills/case-triage.skill.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport { defineSkill } from '@objectstack/spec';\n\n/**\n * Case Triage \u2014 prioritise a support case and route it to the right action.\n *\n * ADR-0109: this skill declares NO tool records. Triage itself is\n * reasoning, not a tool \u2014 the agent reads the case with the platform's\n * data tools and applies the rubric below.\n *\n * It deliberately calls NOTHING that mutates. Escalate and Close carry no\n * `ai` block, and ADR-0011 exposure is opt-in / default off, so the\n * runtime materialises no `action_escalate_case` / `action_close_case`\n * tool for the skill to call. That is the right shape here \u2014 both Actions\n * exist to collect a reason / resolution from a person, so the agent\n * supplies the judgement and the human supplies the words and the\n * decision \u2014 and the skill recommends the button instead of pretending to\n * press it. (Both became `type: 'flow'` in #515, so opting them in later\n * is a governance call, not a mechanical one; the review step is the\n * point.)\n */\nexport const CaseTriageSkill = defineSkill({\n  name: 'case_triage',\n  label: 'Case Triage',\n  description: 'Triages a support case, assigns a priority with its justification, and points at the escalate/close action.',\n\n  instructions: `When the user asks to triage, prioritise, or classify a case:\n\n1. Read the case first \u2014 call \\`describe_object\\` for \\`crm_case\\` (the\n   schema is alive; admins add fields), then \\`get_record\\` for the case\n   at hand. Never triage from memory of a previous turn.\n2. Assign a priority yourself from what you read. There is no triage\n   tool and you do not need one \u2014 weigh, in order: customer tier and\n   contract value, whether the customer is blocked with no workaround,\n   how long the case has been open against its SLA, and the sentiment\n   of the latest customer message.\n3. State the priority and the ONE reason that drove it. Cite the case\n   ID and the field values you used.\n4. If the priority is critical, say so and point the user at\n   **Escalate Case** on the record header \u2014 offer a ready-to-paste\n   \\`reason\\` built from step 3. You cannot escalate yourself, and should\n   not imply otherwise.\n5. If the case is resolved in substance, point at **Close Case** and\n   offer a \\`resolution\\` summary the user can paste.\n6. For the customer-facing reply, hand off to the \\`email_drafting\\`\n   skill rather than drafting it here.`,\n\n  tools: ['describe_object', 'get_record'],\n\n  triggerConditions: [\n    { field: 'objectName', operator: 'eq', value: 'crm_case' },\n  ],\n});\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/service/views/case.view.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/service/views\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/service/views/case.view.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport { defineView } from '@objectstack/spec/ui';\n\n/**\n * The one data provider every view below reads \u2014 the default list, the seven\n * named list views and the web-to-case form all list or write `crm_case` \u2014\n * written once and passed by shorthand (`data,`) rather than spelled out nine\n * times.\n */\nconst data = { provider: 'object', object: 'crm_case' } as const;\n\n/**\n * Case (Service) Views\n *\n *   \u2022 grid     \u2014 support queue with SLA columns\n *   \u2022 kanban   \u2014 case workflow grouped by status\n *   \u2022 timeline \u2014 chronological case stream\n *   \u2022 calendar \u2014 SLA due-date calendar\n */\nexport const CaseViews = defineView({\n  list: {\n    type: 'grid',\n    name: 'all_cases',\n    label: 'All Cases',\n    userActions: { editInline: true },\n    data,\n    columns: [\n      { field: 'case_number', width: 130, sortable: true, link: true, pinned: 'left' },\n      { field: 'subject', width: 280, sortable: true },\n      { field: 'crm_account', width: 180 },\n      { field: 'crm_contact', width: 160 },\n      { field: 'priority', width: 110, sortable: true },\n      { field: 'status', width: 130, sortable: true },\n      { field: 'origin', width: 120 },\n      { field: 'sla_due_date', width: 160, sortable: true },\n      { field: 'is_sla_violated', width: 110, align: 'center' },\n      { field: 'is_escalated', width: 110, align: 'center' },\n      { field: 'owner_id', width: 150 },\n    ],\n    // Sort on the materialised ordinal, not the select itself: `priority desc`\n    // compares raw strings and lands medium > low > high > critical, burying\n    // every critical case at the bottom of the queue.\n    sort: [\n      { field: 'priority_rank', order: 'desc' },\n      { field: 'sla_due_date', order: 'asc' },\n    ],\n    rowColor: {\n      field: 'priority',\n      colors: { critical: 'red', high: 'orange', medium: 'yellow', low: 'slate' },\n    },\n    selection: { type: 'multiple' },\n    pagination: { pageSize: 50 },\n    // The UI door for the `allowExport` grant four profiles already hold on\n    // `crm_case`. Export runs on ONE server-side route\n    // (`GET /api/v1/data/crm_case/export`, gated by `security.canExport`), so\n    // this declares which formats the toolbar offers \u2014 not a second gate: a\n    // profile without the grant gets 403 whether it clicks the button or\n    // curls the route. Measured in #798/#816; before this the grant was live\n    // but reachable only by `curl`.\n    exportOptions: { formats: ['csv', 'xlsx'] },\n    appearance: {\n      showDescription: true,\n      allowedVisualizations: ['grid', 'kanban', 'calendar', 'timeline'],\n    },\n    // Binds the 'calendar' entry above: the switcher opens the same deadlines\n    // the dedicated `sla_calendar` view shows, on the field this list already\n    // sorts by. `sla_due_date` is optional \u2014 a case the SLA monitor has not\n    // stamped carries no date at all, which is the truthful answer; the\n    // alternative the platform refuses is a guessed field putting every such\n    // case on today.\n    calendar: {\n      startDateField: 'sla_due_date',\n      titleField: 'subject',\n      colorField: 'priority',\n    },\n    // Escalate straight from the queue: escalate_case's own\n    // `locations: ['list_item']` auto-injects the row-menu item.\n  },\n\n  listViews: {\n    /** Service workflow board */\n    case_workflow: {\n      name: 'case_workflow',\n      type: 'kanban',\n      label: 'Service Workflow',\n      data,\n      columns: ['case_number', 'subject', 'priority', 'sla_due_date'],\n      kanban: {\n        groupByField: 'status',\n        columns: ['case_number', 'subject', 'crm_account', 'priority', 'owner_id'],\n      },\n      filter: [{ field: 'is_closed', operator: 'equals', value: false }],\n      navigation: { mode: 'drawer', width: '640px' },\n    },\n\n    /** SLA calendar */\n    sla_calendar: {\n      name: 'sla_calendar',\n      type: 'calendar',\n      label: 'SLA Calendar',\n      data,\n      columns: ['case_number', 'subject', 'priority'],\n      calendar: {\n        startDateField: 'sla_due_date',\n        titleField: 'subject',\n        colorField: 'priority',\n      },\n    },\n\n    /** Chronological case stream */\n    case_timeline: {\n      name: 'case_timeline',\n      type: 'timeline',\n      label: 'Case Timeline',\n      data,\n      columns: ['case_number', 'subject'],\n      timeline: {\n        // `created_at`, the platform's own creation stamp \u2014 the object's\n        // duplicate `created_date` was removed in #1992 because nothing wrote\n        // it on a real case, so every user-created case started its bar at\n        // null. Same spelling as `deal_timeline` on crm_opportunity (#575 B2).\n        startDateField: 'created_at',\n        endDateField: 'closed_date',\n        titleField: 'subject',\n        groupByField: 'owner_id',\n        colorField: 'status',\n        scale: 'day',\n      },\n    },\n\n    /**\n     * The agent's personal queue: the cases themselves, one row each. Its\n     * aggregate counterpart is service_dashboard's \"My Open Cases by\n     * Priority\" (#510) \u2014 a dashboard widget counts, it cannot list.\n     */\n    my_open_cases: {\n      name: 'my_open_cases',\n      type: 'grid',\n      label: 'My Open Cases',\n      userActions: { editInline: true },\n      data,\n      columns: ['case_number', 'subject', 'crm_account', 'priority', 'status', 'sla_due_date'],\n      // \u26A0\uFE0F `status not_in CLOSED_CASE_STATUSES`, NOT `is_closed == false`: the\n      // flag is derived as `effStatus === 'closed'` and never flips on\n      // `resolved`, so the flag spelling listed every RESOLVED case under a tab\n      // labelled \"My Open Cases\" \u2014 measured on the seeded demo population, the\n      // flag returned 30 of 38 cases and 7 of those 30 were resolved. A resolved\n      // case is finished work awaiting closure, not an open queue, and the\n      // mainstream service-cloud reading of \"open\" excludes it (Zendesk's open\n      // set omits Solved; ServiceNow's OOTB Open filter is\n      // `state not in (Resolved, Closed, Cancelled)`). Ruled 2026-08-31; pinned by\n      // `test/live-work-predicate-parity.test.ts` (#1145), whose consumer roster\n      // this view joined in the same change.\n      filter: [\n        { field: 'owner_id', operator: 'equals', value: '{current_user_id}' },\n        { field: 'status', operator: 'not_in', value: ['resolved', 'closed'] },\n      ],\n      sort: [\n        { field: 'priority_rank', order: 'desc' },\n        { field: 'sla_due_date', order: 'asc' },\n      ],\n    },\n\n    /**\n     * Unassigned \u2014 triage (#596). The second half of the queue substitute.\n     *\n     * `case_auto_assign` (`src/service/objects/_case-assignment.ts`) is a NO-OP whenever\n     * the `service_agent` pool is empty, and an empty pool is the FIRST-INSTALL\n     * NORM rather than an edge case: `sys_user_position` membership is runtime\n     * data, so on a fresh org \u2014 and any time every agent has been unassigned\n     * from the position \u2014 an inbound web-to-case lands ownerless. Best-effort\n     * assignment also stands down on a permission denial (the anonymous\n     * public-form context cannot read `sys_user_position` at all).\n     *\n     * Those cases used to be invisible: no view filtered on the absence of an\n     * owner, so an unowned case appeared in `All Cases` with a blank Owner\n     * column and nothing distinguished it from the rest. This view is the\n     * standing answer \u2014 silence replaced by a pinned tab whose row count IS the\n     * intake backlog.\n     *\n     * `is_null` on `owner_id`, not `equals: null`: the ownerless shape is an\n     * ABSENT column on driver-memory (see the totality note in\n     * `case-escalation.flow.ts`, where `record.escalated_date == null` aborted\n     * with `No such key`) as well as a NULL one on SQL, and only the operator\n     * form answers the same way for both.\n     *\n     * The predicate for \"no longer live work\" is `status not_in ['resolved',\n     * 'closed']`, NOT `is_closed == false`. `is_closed` is derived by\n     * `case_sla_defaults` as `effStatus === 'closed'`, so it never flips on\n     * `resolved` \u2014 and a resolved ownerless case satisfied both of this view's\n     * old filters and sat here forever, which is neither \"arrives with no\n     * owner\" nor \"work waiting for a human\". `not_in` lowers to the `$nin` the\n     * load-balancing hooks and `case_sla_monitor` already use for the same\n     * concept, so the four consumers now state one predicate; the roster that\n     * holds them together by NAME is `test/live-work-predicate-parity.test.ts`.\n     * `closed` stays excluded for the reason it always was: history, not\n     * backlog.\n     *\n     * \u26A0\uFE0F WHO ACTUALLY SEES ROWS HERE is decided by record-level access, not by\n     * this view, and the answer today is narrower than the tab suggests. A\n     * view tab carries no role scoping \u2014 `ViewTabSchema` has `pinned`,\n     * `isDefault` and a boolean `visible`, and nothing per-profile \u2014 so this is\n     * pinned for everyone who can open Cases, while the ROWS resolve per\n     * profile:\n     *\n     *   - `system_admin` \u2014 `viewAllRecords`, so the full backlog. This is the\n     *     persona the empty-pool state is FOR: an empty `service_agent` pool is\n     *     fixed by staffing `sys_user_position`, which only an admin can do.\n     *   - `sales_manager` \u2014 `viewAllRecords`, read-only.\n     *   - a service manager / director \u2014 the critical, open slice only, via the\n     *     existing `case_escalation_sharing` / `case_director_sharing` criteria\n     *     rules (`src/service/sharing/case.sharing.ts`).\n     *   - `service_agent` \u2014 `readScope: 'own'` on `crm_case`, and an unowned\n     *     row is owned by nobody, so **an agent's triage tab is empty**.\n     *\n     * The last line is a real gap for the \"agent pulls from the queue\" story\n     * and is deliberately NOT closed here: granting service roles sight of\n     * unowned cases is a sharing-model change (a new criteria rule, or a\n     * `readScope` widening), which is outside this card's file surface and is\n     * exactly the kind of quiet permission widening the #596 ruling rules out.\n     * Filed as #1096 for a decision, with the reach table above and the three\n     * options priced.\n     */\n    unassigned_triage: {\n      name: 'unassigned_triage',\n      type: 'grid',\n      label: 'Unassigned \u2014 triage',\n      userActions: { editInline: true },\n      data,\n      columns: ['case_number', 'subject', 'crm_account', 'crm_contact', 'priority', 'status', 'origin', 'sla_due_date'],\n      filter: [\n        { field: 'owner_id', operator: 'is_null' },\n        { field: 'status', operator: 'not_in', value: ['resolved', 'closed'] },\n      ],\n      // Same ordering as the main queue: urgency first (on the materialised\n      // ordinal, never the raw select), then soonest deadline.\n      sort: [\n        { field: 'priority_rank', order: 'desc' },\n        { field: 'sla_due_date', order: 'asc' },\n      ],\n      rowColor: {\n        field: 'priority',\n        colors: { critical: 'red', high: 'orange', medium: 'yellow', low: 'slate' },\n      },\n      // The empty state carries the operational instruction, because \"no rows\"\n      // here is ambiguous on its own: it means either \"the round-robin placed\n      // everything\" (good) or \"no case has arrived yet\" (also fine) \u2014 and the\n      // reader most likely to be looking is someone who just found the tab\n      // full and needs to know why.\n      emptyState: {\n        title: 'Nothing waiting for triage',\n        message: 'Every case has an owner. Cases appear here when they arrive with no owner \u2014 typically a web-to-case submission that arrived while nobody held the Service Agent position.',\n        icon: 'inbox',\n      },\n    },\n\n    escalated_cases: {\n      name: 'escalated_cases',\n      type: 'grid',\n      label: 'Escalated Cases',\n      userActions: { editInline: true },\n      data,\n      columns: ['case_number', 'subject', 'crm_account', 'priority', 'sla_due_date', 'owner_id'],\n      filter: [{ field: 'is_escalated', operator: 'equals', value: true }],\n      sort: [{ field: 'priority_rank', order: 'desc' }],\n    },\n\n    /**\n     * SLA-at-risk: open cases at High or Critical priority needing attention.\n     *\n     * \u26A0\uFE0F Names what the filter below actually selects. This read\n     * \"high/urgent\" until #1333 \u2014 but `crm_case.priority` is\n     * low/medium/high/critical (`case.object.ts:138-142`) and has NO `urgent`;\n     * that value belongs to `crm_task`. The mirror-image crossing already\n     * shipped a real defect once (`task.view.ts:35` \u2014 Case colour keys on the\n     * task view left every urgent and normal row uncoloured), and the\n     * direction that cost something was the one where the comment was\n     * believed. Two overlapping-but-unequal vocabularies: keep them apart.\n     */\n    sla_at_risk: {\n      name: 'sla_at_risk',\n      type: 'grid',\n      label: '\u23F0 SLA at Risk',\n      userActions: { editInline: true },\n      data,\n      columns: ['case_number', 'subject', 'crm_account', 'priority', 'sla_due_date', 'owner_id'],\n      // Operator-only filter \u2014 sort by SLA due date ascending so the soonest\n      // surface first. (The view runtime does not interpolate `{NOW() + 4h}`.)\n      //\n      // \u26A0\uFE0F `status not_in CLOSED_CASE_STATUSES`, NOT `is_closed == false`: the\n      // flag is derived as `effStatus === 'closed'` and never flips on\n      // `resolved`, so the flag spelling listed resolved cases as at risk while\n      // `case_sla_monitor` \u2014 the automation that OWNS SLA \u2014 had already\n      // excluded them (`status: { $nin: ['resolved', 'closed'] }`). The tab a\n      // human reads and the sweep that acts must answer this one question the\n      // same way. Pinned by `test/live-work-predicate-parity.test.ts` (#1145).\n      filter: [\n        { field: 'status', operator: 'not_in', value: ['resolved', 'closed'] },\n        { field: 'priority', operator: 'in', value: ['high', 'critical'] },\n      ],\n      sort: [{ field: 'sla_due_date', order: 'asc' }],\n    },\n  },\n\n  /**\n   * The record form \u2014 and, because the platform has ONE, the CREATE form too.\n   *\n   * ## \u26A0\uFE0F This object's `form` IS the create dialog (#1214 item 3)\n   *\n   * Measured against the console this app shipped at that taking\n   * (`@objectstack/console` 17.1.0, `dist/assets/`; this bundle read was \u26D4 NOT\n   * re-taken on any later pin), BOTH\n   * entry points that open a case form resolve\n   * it the same way and neither takes a create/edit argument:\n   *\n   *   RecordFormPage (`/{object}/new`, `/{object}/record/{id}/edit`)\n   *       view.form ?? view.formViews?.default\n   *   useActionModal (the `+ New` modal off a list view)\n   *       view.form ?? view.formViews?.default\n   *\n   * \u21D2 There is no create-only form to author. `ListViewSchema.addRecord`\n   * carries a `formView` key in `@objectstack/spec`, but NO console code path\n   * reads it (the string appears only in the view designer's own i18n table),\n   * so pointing it at a second form view would ship an ADR-0049\n   * declared-but-unenforced shape and change nothing on screen.\n   *\n   * \u21D2 Therefore the create-safe field set has to BE this form's field set.\n   * That is why the SLA and Resolution sections are gone rather than gated.\n   *\n   * ## \u26D4 Why the tab strip was not the object's `fieldGroups`\n   *\n   * `crm_case.fieldGroups` declares SIX groups (Case Information / Origin &\n   * Routing / SLA & Priority / Resolution / Escalation / System) and the\n   * dialog showed THREE tabs \u2014 these sections. The renderer only reaches for\n   * `fieldGroups` on its AUTO-DERIVED path, taken when a form authors no\n   * `sections` at all; an authored `sections` array wins outright. So\n   * `src/service/objects/case.object.ts` is not part of this surface.\n   *\n   * ## \u26A0\uFE0F Authoring `sections` OPTS OUT of the create-mode field strip\n   *\n   * That auto-derived path also runs two filters the authored path never sees\n   * (`plugin-form`: `Qe` \u2192 `qe` drops `readonly`/`hidden` fields, and on\n   * `mode === 'create'` `Je` additionally drops formula / summary / autonumber\n   * fields). An authored section renders its list VERBATIM. That is the whole\n   * mechanism behind this defect: the platform would have hidden\n   * `created_date` (retired in #1992), `closed_date`, `resolution_time_hours`\n   * and `is_closed` from a creator by itself, and naming them in a section put\n   * them back.\n   *\n   * ## \u26D4 Why not gate the old sections on a predicate instead\n   *\n   * A section-level `visibleWhen` is parsed by `FormSectionSchema` and read by\n   * NOTHING in the form renderer (only FIELD-level `visibleWhen` is\n   * evaluated), so it would hide nothing. And field-level predicate evaluation\n   * FAILS OPEN \u2014 an unevaluable predicate renders the field visible, with no\n   * diagnostic (the house rule at the top of `lead.view.ts`, upstream\n   * objectstack-ai/objectstack#5149). A gate that fails open is not a gate for\n   * a data-integrity control, which is what this one is.\n   *\n   * ## What a creator may author here, and why the rest left\n   *\n   * Everything below is a fact the person raising the case HAS at intake.\n   * `case_number` stays because it is `readonly: true` on the object, so the\n   * renderer disables it \u2014 it is shown, never authored.\n   *\n   * The removed fields are all written by the lifecycle, and every one of them\n   * still has the surface it belongs on (pinned in\n   * `test/case-create-form-narrowing.test.ts`, both directions):\n   *\n   *   closed_date                      readonly; `case_timeline` end\n   *                                    (its start is the platform's\n   *                                    `created_at`; `created_date` was\n   *                                    retired in #1992)\n   *   sla_due_date                     `case.hook.ts` stamps it from the\n   *                                    priority \u00D7 tier matrix; list column,\n   *                                    sort key, `sla_calendar.startDateField`,\n   *                                    detail-page highlights\n   *   first_response_date              `event.hook.ts` is its SINGLE writer\n   *   resolution_time_hours            readonly; derived at close; detail page\n   *   is_sla_violated                  list column + detail-page highlights\n   *   is_escalated, escalation_reason  written by `case_escalation` /\n   *                                    `case_sla_monitor` / `escalate_case`;\n   *                                    detail page's Status & SLA section\n   *   resolution                       detail page's Description section\n   *                                    (the `resolution_required_on_close`\n   *                                    validation still has its surface)\n   *   is_closed                        readonly; derived from `status`\n   *\n   * \u26A0\uFE0F `internal_notes`, `customer_rating` and `customer_feedback` left with\n   * the Resolution section and had NO other authoring surface at all. #1428\n   * settled both halves of that, and neither answer was \"put them back here\":\n   *\n   *   internal_notes                   `case_detail.page.ts`'s Description\n   *                                    section, authored by inline edit \u2014\n   *                                    staff prose an agent writes while\n   *                                    WORKING a case, which is why it did not\n   *                                    come back to this form. The guest\n   *                                    branch of `case.hook.ts` nulls the\n   *                                    column on anonymous intake, so an\n   *                                    intake surface for it would be a\n   *                                    surface for a value the app discards.\n   *\n   *   customer_rating,                 RETIRED under ADR-0049 enforce-or-remove\n   *   customer_feedback                (maintainer ruling, decision batch #21,\n   *                                    2026-09-03). Neither column exists on\n   *                                    `crm_case` any more, so there is nothing\n   *                                    here to omit and nothing anywhere to\n   *                                    author.\n   *\n   * \u26D4 Do not re-introduce either field, here or elsewhere. The ruling was not\n   * \"no room on this form\": a satisfaction score typed by the person being\n   * scored is not the same fact as one the customer gave, and neither field was\n   * named in ANY profile's `fields` map \u2014 which on this platform means\n   * unrestricted, not restricted. `case_csat_followup`, whose only purpose was\n   * to notify the case owner to log a rating, was retired in the same change.\n   * A customer-answered survey is a feature and would arrive as its own card,\n   * not as two inputs added back here.\n   *\n   * `type: 'simple'`, not `'tabbed'`: one section is not a tab strip.\n   */\n  form: {\n    type: 'simple',\n    sections: [\n      {\n        name: 'case',\n        label: 'Case',\n        columns: 2,\n        fields: [\n          'case_number',\n          { field: 'subject', required: true, span: 'full' },\n          { field: 'crm_account', required: true },\n          'crm_contact',\n          { field: 'status', required: true },\n          'priority',\n          'origin',\n          'owner_id',\n          // Required on the object with no default \u2014 a form without it could\n          // never save a new case.\n          { field: 'description', required: true, span: 'full' },\n        ],\n      },\n    ],\n  },\n\n  /**\n   * Additional named form views.\n   *\n   * `web_to_case` is a PUBLIC / ANONYMOUS support form (Salesforce\n   * Web-to-Case equivalent). Hosted at `/forms/support` and embeddable in\n   * a help center. Guests can ONLY submit \u2014 the `guest_portal` profile\n   * denies read/edit/delete on `crm_case`. Internal fields (status, origin,\n   * owner_id, SLA) are stamped by `case.hook.ts` after a guest submission.\n   * `priority` is NOT one of them: this form asks the guest for it, and an\n   * unset one is filled by the `low` option `crm_case.priority` declares\n   * `default: true`. Field defaults are applied before `beforeInsert`, so the\n   * hook only ever reads `priority` (to derive `priority_rank`).\n   */\n  formViews: {\n    web_to_case: {\n      type: 'simple',\n      data,\n      sections: [\n        {\n          name: 'how_can_we_help',\n          label: 'How can we help?',\n          columns: 1,\n          fields: [\n            {\n              field: 'subject',\n              required: true,\n              placeholder: 'Short summary of the issue',\n            },\n            {\n              field: 'description',\n              required: true,\n              placeholder: 'Steps to reproduce, error messages, screenshots...',\n            },\n            {\n              field: 'type',\n              helpText: 'Pick the option that best matches your issue.',\n            },\n            {\n              field: 'priority',\n              helpText: 'Critical issues should also be reported via phone.',\n            },\n          ],\n        },\n      ],\n      sharing: {\n        enabled: true,\n        allowAnonymous: true,\n        publicLink: '/forms/support',\n      },\n    },\n  },\n});\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/service/views/knowledge_article.view.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/service/views\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/service/views/knowledge_article.view.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport { defineView } from '@objectstack/spec/ui';\n\n/**\n * Knowledge Article Views\n *\n *   \u2022 grid      \u2014 agent-facing article queue (status / category / audience)\n *   \u2022 published \u2014 public articles only\n *   \u2022 my drafts \u2014 the author's own drafts and in-review articles\n *\n * A fourth tab, `stale_articles` ('Review Queue \u00B7 Oldest First'), shipped here\n * until #781 and is deliberately absent: the maintainer ruled the knowledge\n * review queue out of the product rather than settling whether it should have\n * become a real 180-day cut. \u26D4 Do not reinstate it as a ranking either \u2014 the\n * ruling removed the FEATURE, not just the window question.\n *\n * `last_reviewed_at` is untouched by that removal and stays a data-layer\n * field: the publish hook still stamps it, and the Engagement form section\n * below still shows it. Whether the field itself should retire is a separate\n * question and is not answered here.\n */\nexport const KnowledgeArticleViews = defineView({\n  list: {\n    type: 'grid',\n    name: 'all_articles',\n    label: 'All Articles',\n    userActions: { editInline: true },\n    data: { provider: 'object', object: 'crm_knowledge_article' },\n    columns: [\n      { field: 'article_number', width: 120, link: true, pinned: 'left', sortable: true },\n      { field: 'title',          width: 320, sortable: true },\n      { field: 'category',       width: 160 },\n      { field: 'status',         width: 130, sortable: true },\n      { field: 'audience',       width: 110 },\n      { field: 'language',       width: 110 },\n      { field: 'owner_id',          width: 150 },\n      { field: 'published_at',   width: 160, sortable: true },\n      { field: 'helpful_count',  width: 110, align: 'right', summary: 'sum' },\n    ],\n    sort: [{ field: 'published_at', order: 'desc' }],\n    grouping: { fields: [{ field: 'category', order: 'asc' }] },\n    selection: { type: 'multiple' },\n    pagination: { pageSize: 50 },\n    rowColor: {\n      field: 'status',\n      colors: { draft: 'slate', in_review: 'amber', published: 'emerald', archived: 'gray' },\n    },\n    appearance: {\n      showDescription: true,\n      allowedVisualizations: ['grid', 'kanban'],\n    },\n  },\n\n  listViews: {\n    published_articles: {\n      name: 'published_articles',\n      type: 'grid',\n      label: 'Published',\n      userActions: { editInline: true },\n      data: { provider: 'object', object: 'crm_knowledge_article' },\n      columns: ['article_number', 'title', 'category', 'audience', 'helpful_count', 'not_helpful_count', 'published_at'],\n      filter: [{ field: 'status', operator: 'equals', value: 'published' }],\n      sort: [{ field: 'helpful_count', order: 'desc' }],\n    },\n    my_drafts: {\n      name: 'my_drafts',\n      type: 'grid',\n      label: 'My Drafts',\n      userActions: { editInline: true },\n      data: { provider: 'object', object: 'crm_knowledge_article' },\n      columns: ['article_number', 'title', 'category', 'status', 'updated_at'],\n      filter: [\n        { field: 'status', operator: 'in',     value: ['draft', 'in_review'] },\n        // `{current_user_id}` is the only user token the view runtime resolves.\n        { field: 'owner_id',  operator: 'equals', value: '{current_user_id}' },\n      ],\n      sort: [{ field: 'updated_at', order: 'desc' }],\n    },\n  },\n\n  form: {\n    type: 'simple',\n    sections: [\n      {\n        name: 'article',\n        label: 'Article',\n        columns: 2,\n        fields: [\n          'article_number',\n          { field: 'title', required: true, span: 'full' },\n          { field: 'summary', span: 'full' },\n          'category',\n          'tags',\n          'status',\n          'audience',\n          'language',\n          'owner_id',\n        ],\n      },\n      {\n        name: 'content',\n        label: 'Content',\n        columns: 1,\n        fields: ['body'],\n      },\n      {\n        // `name` alongside `label` (#1100): a form section declaring only a\n        // label renders its ENGLISH label under every locale, and neither the\n        // existing i18n tests nor the `i18n/missing-*` gate can see it \u2014 the\n        // heading has no key for a translator to miss. This section is named\n        // because this change edits it (`view_count` was removed from it, #601);\n        // the app-wide sweep of the other headings is #1100's job, held behind\n        // this card precisely so the two do not collide in the locale packs.\n        name: 'engagement',\n        label: 'Engagement',\n        columns: 3,\n        fields: ['helpful_count', 'not_helpful_count', 'published_at', 'last_reviewed_at', 'related_to_case'],\n      },\n    ],\n  },\n});\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/revenue/objects/index.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/revenue/objects\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/revenue/objects/index.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\n/**\n * Revenue object barrel.\n *\n * Re-exports this package's *.object.ts definitions; the `*.hook.ts` files\n * beside them register through `./hooks.ts`. The canonical note on the\n * collaboration capabilities (`enable.files`, `enable.feeds`) that every\n * object in this app points at is written once, in\n * `src/sales/objects/index.ts`.\n */\n\nexport { Contract } from './contract.object';\nexport { OpportunityLineItem } from './opportunity_line_item.object';\nexport { Product } from './product.object';\nexport { Quote } from './quote.object';\nexport { QuoteLineItem } from './quote_line_item.object';\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/revenue/objects/contract.object.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/revenue/objects\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/revenue/objects/contract.object.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport { ObjectSchema, Field } from '@objectstack/spec/data';\nimport { P } from '@objectstack/spec';\nimport { PAYMENT_TERMS_OPTIONS } from '../../sales/objects/_picklists';\n\n/**\n * Contract Object\n * Represents legal contracts with customers\n */\nexport const Contract = ObjectSchema.create({\n  name: 'crm_contract',\n  label: 'Contract',\n  pluralLabel: 'Contracts',\n  icon: 'file-pen-line',\n  description: 'Legal contracts and agreements',\n\n  // ADR-0090 D1/D7: OWD is an authored decision. Master-detail child of\n  // crm_account \u2014 a contract IS account data: reachable by whoever can reach\n  // the account, editable by whoever can edit it (#549, ruling 2026-08-31).\n  sharingModel: 'controlled_by_parent',\n  // ADR-0079: render-only `titleFormat` retired in favor of `nameField`.\n  // Original template was '{contract_number} - {crm_account.name}'. The\n  // `crm_account.name` segment is a lookup DOT-WALK, which a formula field\n  // cannot reference (ADR-0072), so it is DROPPED. Only the local\n  // `contract_number` (autonumber) remains, so no formula is needed \u2014 point\n  // `nameField` straight at it.\n  nameField: 'contract_number',\n  highlightFields: ['contract_number', 'crm_account', 'status', 'start_date', 'end_date'],\n\n  fieldGroups: [\n    { key: 'basic',     label: 'Contract Information', icon: 'info' },\n    { key: 'parties',   label: 'Parties',              icon: 'users' },\n    { key: 'terms',     label: 'Terms & Dates',        icon: 'calendar' },\n    { key: 'value',     label: 'Contract Value',       icon: 'dollar-sign' },\n    { key: 'status',    label: 'Status & Approval',    icon: 'check-circle' },\n    { key: 'renewal',   label: 'Renewal',              icon: 'refresh-ccw', collapse: 'collapsed' },\n  ],\n\n  fields: {\n    // Platform ownership anchor \u2014 canonical note in `account.object.ts` (#548).\n    owner_id: Field.lookup('sys_user', {\n      label: 'Contract Owner',\n      group: 'parties',\n      system: true,\n      readonly: false,\n      trackHistory: true,\n    }),\n\n    // AutoNumber field\n    contract_number: Field.autonumber({\n      label: 'Contract Number',\n      group: 'basic',\n      format: 'CTR-{0000}',\n    }),\n    \n    // Relationships \u2014 the master the OWD derives from. Authored as\n    // master-detail so the master is not decided by declaration order against\n    // the required `crm_contact` lookup below (objectstack#14747).\n    crm_account: Field.masterDetail('crm_account', {\n      label: 'Account',\n      group: 'parties',\n      required: true,\n      storage: { notNull: true },\n      deleteBehavior: 'cascade',\n    }),\n    \n    crm_contact: Field.lookup('crm_contact', {\n      label: 'Primary Contact',\n      group: 'parties',\n      required: true,\n      storage: { notNull: true },\n      // @objectstack 12: string[] `referenceFilters` is dead (not read by the\n      // picker); `dependsOn` is the live cascading-lookup form \u2014 scopes contacts\n      // to the contract's `crm_account` (ADR-0049).\n      dependsOn: ['crm_account'],\n    }),\n\n    crm_opportunity: Field.lookup('crm_opportunity', {\n      label: 'Related Opportunity',\n      group: 'parties',\n      // Scope opportunities to the contract's account (was dead referenceFilters).\n      dependsOn: ['crm_account'],\n    }),\n    \n\n    // Status\n    status: Field.select({\n      label: 'Status',\n      group: 'status',\n      options: [\n        { label: 'Draft', value: 'draft', color: '#999999', default: true },\n        { label: 'In Approval', value: 'in_approval', color: '#FFA500' },\n        { label: 'Activated', value: 'activated', color: '#00AA00' },\n        { label: 'Expired', value: 'expired', color: '#FF0000' },\n        { label: 'Terminated', value: 'terminated', color: '#666666' },\n      ],\n      required: true,\n      storage: { notNull: true },\n      trackHistory: true,\n    }),\n    \n    // Contract Terms\n    contract_term_months: Field.number({\n      label: 'Contract Term (Months)',\n      group: 'terms',\n      required: true,\n      storage: { notNull: true },\n      min: 1,\n    }),\n    \n    start_date: Field.date({\n      label: 'Start Date',\n      group: 'terms',\n      required: true,\n      storage: { notNull: true },\n    }),\n    \n    end_date: Field.date({\n      label: 'End Date',\n      group: 'terms',\n      required: true,\n      storage: { notNull: true },\n    }),\n    \n    // Financial\n    contract_value: Field.currency({ \n      label: 'Contract Value',\n      group: 'value',\n      min: 0,\n      required: true,\n      storage: { notNull: true },\n    }),\n    \n    billing_frequency: Field.select({\n      label: 'Billing Frequency',\n      group: 'value',\n      options: [\n        { label: 'Monthly', value: 'monthly', default: true },\n        { label: 'Quarterly', value: 'quarterly' },\n        { label: 'Annually', value: 'annually' },\n        { label: 'One-time', value: 'one_time' },\n      ]\n    }),\n    \n    payment_terms: Field.select({\n      label: 'Payment Terms',\n      group: 'value',\n      // Canonical set shared with Quote: an accepted quote's terms (incl.\n      // due_on_receipt) must survive the copy onto the contract. That copy is\n      // `quote_accepted_contract_draft` (src/revenue/objects/quote.hook.ts). This field's `net_30`\n      // option default applies only when the quote itself carried no term,\n      // which is the intended fall-through, not a gap.\n      options: [...PAYMENT_TERMS_OPTIONS],\n    }),\n    \n    // Renewal\n    auto_renewal: Field.boolean({\n      label: 'Auto Renewal',\n      group: 'renewal',\n      defaultValue: false,\n    }),\n    \n    renewal_notice_days: Field.number({\n      label: 'Renewal Notice (Days)',\n      group: 'renewal',\n      min: 0,\n      defaultValue: 30,\n    }),\n    \n    // Legal\n    contract_type: Field.select({\n      label: 'Contract Type',\n      group: 'basic',\n      options: [\n        { label: 'Subscription', value: 'subscription' },\n        { label: 'Service Agreement', value: 'service' },\n        { label: 'License', value: 'license' },\n        { label: 'Partnership', value: 'partnership' },\n        { label: 'NDA', value: 'nda' },\n        { label: 'MSA', value: 'msa' },\n      ]\n    }),\n    \n    signed_date: Field.date({\n      label: 'Signed Date',\n      group: 'status',\n    }),\n    \n    signed_by: Field.text({\n      label: 'Signed By',\n      group: 'status',\n      maxLength: 255,\n    }),\n    \n    document_url: Field.url({\n      label: 'Contract Document',\n      group: 'basic',\n    }),\n    \n    // Terms & Conditions\n    special_terms: Field.markdown({\n      label: 'Special Terms',\n      group: 'terms',\n    }),\n    \n    description: Field.markdown({\n      label: 'Description',\n      group: 'basic',\n    }),\n    \n    // Billing Address\n    billing_address: Field.address({\n      label: 'Billing Address',\n      group: 'value',\n    }),\n  },\n  \n  // Database indexes\n  indexes: [\n    { fields: ['crm_account'] },\n    { fields: ['status'] },\n    { fields: ['start_date'] },\n    { fields: ['end_date'] },\n    { fields: ['owner_id'] },\n  ],\n  \n  // Enable advanced features\n  // API surface. History \u2192 Field.trackHistory (ADR-0052).\n  enable: {\n    apiEnabled: true,\n    apiMethods: ['get', 'list', 'create', 'update', 'delete'],\n    // #602 \u2014 the executed contract itself. `document_url` remains the pointer\n    // to an external DMS copy; this is where the file actually lives.\n    // See the canonical capability note in `src/sales/objects/index.ts`.\n    files: true,\n  },\n  \n  // Validation Rules\n  //\n  // Predicates below are TOTAL: every `record.x` read is `has()`-guarded, so the\n  // rule returns a verdict even when the merged record has no such key. See\n  // AGENTS.md \"Validation predicates must be TOTAL\" and\n  // test/object-validation-predicates.test.ts, which fails the build otherwise.\n  validations: [\n    {\n      name: 'end_after_start',\n      type: 'script',\n      severity: 'error',\n      message: 'End Date must be after Start Date',\n      condition: P`has(record.end_date) && record.end_date != null && has(record.start_date) && record.start_date != null && record.end_date <= record.start_date`,\n    },\n    // NOTE: the `valid_contract_term` warning (months-between term check) was\n    // dropped in the 9.8.0 upgrade \u2014 its CEL predicate used `monthsBetween()`,\n    // which 9.8.0's aligned CEL stdlib (ADR-0032) no longer provides. It was a\n    // non-blocking warning; the hard end-date>start-date rule above remains.\n    {\n      // #575 B4. Like `crm_quote`, this object shipped a lifecycle vocabulary\n      // with no transition constraint and no status guard in `contract.hook.ts`\n      // \u2014 so `draft \u2192 activated` was a legal move, activating an agreement that\n      // never passed approval. Activation is the consequential edge here:\n      // `contract_on_activation` stamps `signed_date`, promotes the account to\n      // `customer`, and the renewal flow starts counting from it.\n      name: 'contract_status_progression',\n      type: 'state_machine',\n      severity: 'warning',\n      message: 'Invalid contract status transition',\n      field: 'status',\n      transitions: {\n        draft: ['in_approval', 'terminated'],\n        // Approval either lands (`activated`) or sends the paperwork back.\n        in_approval: ['draft', 'activated', 'terminated'],\n        // `\u2192 expired` is the contract_expiration flow, whose own sweep filter\n        // is `status: 'activated'` \u2014 nothing else ages out.\n        activated: ['expired', 'terminated'],\n        // Both ends are terminal: a renewal is a NEW contract (the\n        // contract_renewal flow files a task, it does not revive the old row).\n        expired: [],\n        terminated: [],\n      },\n    },\n  ],\n  \n  // Workflow Rules\n  // \u26A0\uFE0F No `workflows[]` here, and none is possible: object `workflows[]` were\n  // removed from the platform. Field updates live in this object's `*.hook.ts`;\n  // scheduled status flips and notifications live in `src/*/flows/*.flow.ts`.\n});\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/revenue/objects/opportunity_line_item.object.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/revenue/objects\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/revenue/objects/opportunity_line_item.object.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport { ObjectSchema, Field } from '@objectstack/spec/data';\nimport { F, P } from '@objectstack/spec';\n\n/**\n * Opportunity Line Item\n *\n * Individual product/service entry on an Opportunity. Together, all line items\n * roll up to the Opportunity amount. Required for any realistic sales process\n * where the deal value comes from a configured set of products rather than\n * a single typed-in total.\n */\nexport const OpportunityLineItem = ObjectSchema.create({\n  name: 'crm_opportunity_line_item',\n  label: 'Opportunity Line Item',\n  pluralLabel: 'Opportunity Line Items',\n  icon: 'package',\n  description: 'A single product line on an Opportunity',\n\n  // ADR-0090 D1/D7: OWD is an authored decision. A line item has no meaning\n  // apart from its deal, so its record access DERIVES from the opportunity\n  // (ADR-0055), and as of 17.0.0-rc.4 that derivation means what it says.\n  //\n  // \u26A0\uFE0F Reads ARE filtered to line items whose `crm_opportunity` the caller can\n  // read, and master accessibility resolves through the same paths a direct\n  // read of the opportunity takes \u2014 ownership and `sys_record_share` grants\n  // included, NOT the master's row-level security policies alone. So a rep\n  // reads the lines of the deals in their own book plus anything shared to\n  // them, and the private-deal RLS filter carried by the `sales_manager` and\n  // `marketing_user` sets narrows on top of that rather than being the only\n  // thing that narrows. The parent-write gate derives the same way: a line\n  // whose opportunity the caller cannot edit is refused.\n  //\n  // `test/parent-derived-reach.test.ts` pins the narrow semantics and was\n  // written to go red the day the platform widens them: with the master set\n  // resolved from RLS policies alone, any caller without the private-deal\n  // policy \u2014 `sales_rep` included \u2014 reaches EVERY opportunity's lines.\n  // ADR-0055's relation resolver accepts a REQUIRED LOOKUP as the parent, so\n  // this works without converting the relationship to master-detail.\n  //\n  // \u26D4 Not `private`: this object has no owner of its own, so `private` falls\n  // back to the platform's auto-stamped `owner_id` (whoever inserted the row) \u2014\n  // and the rep who owns the deal then cannot see a line the quote-generation\n  // flow or their manager added to it.\n  sharingModel: 'controlled_by_parent',\n\n  // Per-field history is opt-in via `Field.trackHistory` (ADR-0052), set on\n  // quantity/unit_price/discount below. Master-detail children still inherit\n  // the master's sharing automatically.\n\n  highlightFields: ['crm_product', 'quantity', 'unit_price', 'total_price'],\n\n  // Two groups, derived from the nine fields this object actually declares\n  // rather than copied off a neighbour (#1453). The split is the one the\n  // arithmetic already makes: everything `total_price` multiplies together is\n  // `pricing`, everything that says WHICH line this is is `basic`.\n  //\n  // `quantity` is a pricing field here, not an identity one \u2014 it is a factor in\n  // `total_price`, and separating it from the price it multiplies would put the\n  // two halves of one product on two sections. `crm_quote_line_item` takes the\n  // same split over its ten fields, and the parents agree: `crm_quote` and\n  // `crm_product` both keep every money field in `pricing` \u2014 `crm_quote`'s\n  // `tax` included \u2014 and both keep `description` in `basic`.\n  //\n  // \u26A0\uFE0F Neither group may be a subset of the highlight strip: a synthesized\n  // detail page hoists the title plus the first four `highlightFields` out of\n  // the body, so an all-hoisted group renders on forms and nowhere else\n  // (`field-group-shadowed`; `pnpm lint` \u2014 `os lint --strict` \u2014 fails on it).\n  // `basic` keeps crm_opportunity/description/line_number and `pricing` keeps\n  // list_price/discount outside that strip, so both survive the hoist.\n  fieldGroups: [\n    { key: 'basic',   label: 'Line Item', icon: 'package' },\n    { key: 'pricing', label: 'Pricing',   icon: 'dollar-sign' },\n  ],\n\n  fields: {\n    // The parent link, and the ONE field on this object that decides whether the\n    // deal it belongs to can be deleted at all (#727).\n    //\n    // Declaring nothing here does not mean \"no opinion\": `Field.lookup` resolves\n    // `deleteBehavior` to the spec default `set_null`, and the engine's\n    // `cascadeDeleteRelations` escalates a `set_null` default on a REQUIRED\n    // lookup to `restrict` \u2014 a NOT NULL column cannot be cleared. So the silent\n    // default made every itemised opportunity undeletable, with a message that\n    // told the API caller to `set deleteBehavior:'cascade'` on this very field:\n    //\n    //     DELETE /api/v1/data/crm_opportunity/<id>\n    //     \u2192 409 DELETE_RESTRICTED \"\u20261 dependent crm_opportunity_line_item\n    //       record(s) reference it via crm_opportunity\u2026\"\n    //\n    // `cascade` is the semantics this object already claims twice over: the\n    // header comment says a line has no meaning apart from its deal, and\n    // `opportunity_line_item.hook.ts` derives `crm_opportunity.amount` FROM the\n    // line set. A record whose parent is gone denotes nothing and would keep a\n    // dead deal's revenue in the line-level reports.\n    //\n    // This is deliberately NOT the campaign/event answer (#696, #711 kept\n    // `crm_campaign_member.crm_campaign` and `crm_event_attendee.crm_event` on\n    // the restricting default): a member list is a campaign's historical record\n    // and survives on its own terms. A price line does not.\n    crm_opportunity: Field.masterDetail('crm_opportunity', {\n      label: 'Opportunity',\n      group: 'basic',\n      required: true,\n      storage: { notNull: true },\n      deleteBehavior: 'cascade',\n    }),\n\n    // Deliberately left on the default, which the same escalation turns into\n    // `restrict`: deleting a catalog product must NOT shred the priced history\n    // of deals that sold it. `product.hook.ts`'s own `beforeDelete` says the\n    // same thing in words (\"Set is_active=false to retire instead\").\n    crm_product: Field.lookup('crm_product', {\n      label: 'Product',\n      group: 'basic',\n      required: true,\n      storage: { notNull: true },\n    }),\n\n    description: Field.text({\n      label: 'Description',\n      group: 'basic',\n      maxLength: 500,\n    }),\n\n    quantity: Field.number({\n      label: 'Quantity',\n      group: 'pricing',\n      required: true,\n      storage: { notNull: true },\n      scale: 2,\n      min: 0,\n      defaultValue: 1,\n      trackHistory: true,\n    }),\n\n    list_price: Field.currency({\n      label: 'List Price',\n      group: 'pricing',\n      readonly: true,\n      description: \"Auto-populated from the product's List Price.\",\n    }),\n\n    unit_price: Field.currency({\n      label: 'Sales Price',\n      group: 'pricing',\n      required: true,\n      storage: { notNull: true },\n      description: 'Negotiated unit price (may differ from list price)',\n      trackHistory: true,\n    }),\n\n    discount: Field.percent({\n      label: 'Discount %',\n      group: 'pricing',\n      scale: 2,\n      min: 0,\n      max: 100,\n      defaultValue: 0,\n      trackHistory: true,\n    }),\n\n    total_price: Field.formula({\n      label: 'Total',\n      group: 'pricing',\n      expression: F`record.quantity * record.unit_price * (1 - record.discount / 100)`,\n    }),\n\n    line_number: Field.number({\n      label: 'Line #',\n      group: 'basic',\n      scale: 0,\n      readonly: true,\n    }),\n  },\n\n  // Predicates below are TOTAL: every `record.x` read is `has()`-guarded, so the\n  // rule returns a verdict even when the merged record has no such key. See\n  // AGENTS.md \"Validation predicates must be TOTAL\" and\n  // test/object-validation-predicates.test.ts, which fails the build otherwise.\n  validations: [\n    {\n      name: 'unit_price_positive',\n      type: 'script',\n      severity: 'error',\n      message: 'Sales price cannot be negative',\n      // Both guards are load-bearing, not defensive noise. `has(...)` answers\n      // \"is the key present at all\": on update the predicate sees\n      // `{...previous, ...data}`, and a driver that stores only written columns\n      // returns no key, which aborts the whole predicate and silently skips the\n      // rule (#630). `!= null` answers \"does it hold a value\": strict CEL\n      // ABORTS on `null < 0` instead of evaluating it false, so the unguarded\n      // form left this rule inert on a blank price \u2014 it never fired at all,\n      // which is the opposite of what a validation is for. The `null` hazard is\n      // written up at `account.object.ts:244-245`; the same-named rule in\n      // `quote_line_item.object.ts` has carried that guard all along.\n      condition: P`has(record.unit_price) && record.unit_price != null && record.unit_price < 0`,\n    },\n  ],\n});\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/revenue/objects/product.object.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/revenue/objects\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/revenue/objects/product.object.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport { ObjectSchema, Field } from '@objectstack/spec/data';\nimport { F, P } from '@objectstack/spec';\n\n/**\n * Product Object\n * Represents products/services offered by the company\n */\nexport const Product = ObjectSchema.create({\n  name: 'crm_product',\n  label: 'Product',\n  pluralLabel: 'Products',\n  icon: 'box',\n  description: 'Products and services offered by the company',\n\n  // ADR-0090 D1/D7: OWD is an authored decision. Product catalog is org-visible; only owners edit.\n  sharingModel: 'public_read',\n  // ADR-0079: render-only `titleFormat` retired in favor of `nameField`,\n  // which names a real field. The former template composed two local fields, so\n  // a `display_title` formula field reproduces it for the record title.\n  nameField: 'display_title',\n  // Explicit search targets (ADR-0061). REQUIRED because nameField is a\n  // FORMULA (display_title/full_name): without this, $search auto-defaults to\n  // the formula field, which isn't a real column, so the lookup picker + global\n  // search silently return zero. These are real, indexed columns.\n  searchableFields: ['name', 'product_code', 'sku'],\n  highlightFields: ['product_code', 'name', 'category', 'is_active'],\n\n  fieldGroups: [\n    { key: 'basic',    label: 'Product Information', icon: 'info' },\n    { key: 'pricing',  label: 'Pricing',             icon: 'dollar-sign' },\n    { key: 'metadata', label: 'Resources',           icon: 'link', collapse: 'collapsed' },\n  ],\n\n  fields: {\n    // AutoNumber field - Unique product identifier\n    product_code: Field.autonumber({\n      label: 'Product Code',\n      group: 'basic',\n      format: 'PRD-{0000}',\n    }),\n    \n    // Basic Information\n    name: Field.text({\n      label: 'Product Name',\n      group: 'basic',\n      required: true,\n      storage: { notNull: true },\n      searchable: true,\n      maxLength: 255,\n    }),\n\n    // ADR-0079 record title (was titleFormat '{product_code} - {name}').\n    display_title: Field.formula({\n      label: 'Display Title',\n      group: 'basic',\n      expression: F`record.product_code + \" - \" + record.name`,\n    }),\n\n    description: Field.markdown({\n      label: 'Description',\n      group: 'basic',\n    }),\n\n    // Categorization\n    category: Field.select({\n      label: 'Category',\n      group: 'basic',\n      options: [\n        { label: 'Software', value: 'software', default: true },\n        { label: 'Hardware', value: 'hardware' },\n        { label: 'Service', value: 'service' },\n        { label: 'Subscription', value: 'subscription' },\n        { label: 'Support', value: 'support' },\n      ]\n    }),\n    \n    family: Field.select({\n      label: 'Product Family',\n      group: 'basic',\n      options: [\n        { label: 'Enterprise Solutions', value: 'enterprise' },\n        { label: 'SMB Solutions', value: 'smb' },\n        { label: 'Professional Services', value: 'services' },\n        { label: 'Cloud Services', value: 'cloud' },\n      ]\n    }),\n    \n    // Pricing\n    list_price: Field.currency({ \n      label: 'List Price',\n      group: 'pricing',\n      min: 0,\n      required: true,\n      storage: { notNull: true },\n    }),\n    \n    cost: Field.currency({ \n      label: 'Cost',\n      group: 'pricing',\n      min: 0,\n    }),\n    \n    // SKU\n    //\n    // `quantity_on_hand` / `reorder_point` were removed with the rest of the\n    // inventory surface: nothing in this app decremented stock, and the \"Low\n    // Stock\" view they fed compared against a hardcoded 10 rather than the\n    // reorder point beside it. HotCRM sells from a catalog; warehouse state\n    // belongs to the system of record that owns it.\n    sku: Field.text({\n      label: 'SKU',\n      group: 'basic',\n      maxLength: 50,\n      unique: true,\n    }),\n    \n    // Status\n    is_active: Field.boolean({\n      label: 'Active',\n      group: 'basic',\n      defaultValue: true,\n      trackHistory: true,\n    }),\n    \n    // Relationships\n    product_manager: Field.lookup('sys_user', {\n      label: 'Product Manager',\n      group: 'basic',\n    }),\n    \n    // Images and Assets\n    // `accept` / `maxSize` are declarable AND server-enforced from\n    // @objectstack 17 (ADR-0104 D3 wave 2). Before that the upload widget read\n    // them but `FieldSchema` dropped them at parse, so the constraint existed\n    // only in the browser and any direct API caller walked past it.\n    image: Field.image({\n      label: 'Product Image',\n      group: 'metadata',\n      accept: ['image/png', 'image/jpeg', 'image/webp'],\n      maxSize: 5 * 1024 * 1024,\n    }),\n\n    datasheet: Field.file({\n      label: 'Datasheet',\n      group: 'metadata',\n      accept: ['application/pdf'],\n      maxSize: 20 * 1024 * 1024,\n    }),\n\n    // `billing_type` and `unit_of_measure` were removed with the tax flag: both\n    // were seeded on all 13 catalog products and read by nothing \u2014 no quote\n    // total, no revenue-recognition report and no line-item behaviour ever\n    // consulted either. A picklist that only ever renders itself is a\n    // maintenance obligation (four locales, an import column, every future\n    // migration) charged against a capability that does not exist.\n  },\n  \n  // Database indexes\n  //\n  // No `{ fields: ['sku'], unique: true }` here: the field-level `unique: true`\n  // already builds the tenant composite `(organization_id, sku)` since\n  // framework #3696. Declaring the single-column index too made the\n  // platform-wide constraint win and left the per-tenant one unreachable\n  // (framework#3991) \u2014 an SKU is unique inside a catalogue, and two\n  // organizations may legitimately both stock \"ABC-123\".\n  indexes: [\n    { fields: ['name'] },\n    { fields: ['category'] },\n    { fields: ['is_active'] },\n  ],\n  \n  // Enable advanced features\n  // API surface. History \u2192 Field.trackHistory (ADR-0052).\n  enable: {\n    apiEnabled: true,\n    apiMethods: ['get', 'list', 'create', 'update', 'delete'],\n  },\n  \n  // Validation Rules\n  //\n  // Predicates below are TOTAL: every `record.x` read is `has()`-guarded, so the\n  // rule returns a verdict even when the merged record has no such key. See\n  // AGENTS.md \"Validation predicates must be TOTAL\" and\n  // test/object-validation-predicates.test.ts, which fails the build otherwise.\n  validations: [\n    {\n      name: 'price_positive',\n      type: 'script',\n      severity: 'error',\n      message: 'List Price must be positive',\n      // Two distinct guards, both required. `has(...)` answers \"is the key\n      // there at all\" \u2014 on update the merged record is `{...previous, ...data}`\n      // and a driver that stores only written columns hands back no key, which\n      // aborts the whole predicate (#630). `!= null` then answers \"does it hold\n      // a value\" \u2014 strict CEL cannot compare dyn<null> < int, the hazard\n      // written up on `account.object.ts`. `list_price` is `required`, but the\n      // rule also runs on partial updates that omit it.\n      condition: P`has(record.list_price) && record.list_price != null && record.list_price < 0`,\n    },\n    {\n      name: 'cost_less_than_price',\n      type: 'script',\n      severity: 'warning',\n      message: 'Cost should be less than List Price',\n      // Both operands need both guards: `cost` is optional and absent on every\n      // seeded product, so this warning has never once evaluated.\n      condition: P`has(record.cost) && record.cost != null && has(record.list_price) && record.list_price != null && record.cost >= record.list_price`,\n    },\n  ],\n});\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/revenue/objects/quote.object.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/revenue/objects\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/revenue/objects/quote.object.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport { ObjectSchema, Field } from '@objectstack/spec/data';\nimport { F, P, cel } from '@objectstack/spec';\nimport { PAYMENT_TERMS_OPTIONS } from '../../sales/objects/_picklists';\nimport { QUOTE_DISCOUNT_CEILING } from '../../sales/objects/_thresholds';\n\n/**\n * Quote Object\n * Represents price quotes sent to customers\n */\nexport const Quote = ObjectSchema.create({\n  name: 'crm_quote',\n  label: 'Quote',\n  pluralLabel: 'Quotes',\n  icon: 'file-text',\n  description: 'Price quotes for customers',\n\n  // ADR-0090 D1/D7: OWD is an authored decision. Master-detail child of\n  // crm_account \u2014 a quote is reachable by whoever can reach its account, and\n  // its line items derive one level further (#549, ruling 2026-08-31).\n  sharingModel: 'controlled_by_parent',\n  // ADR-0079: render-only `titleFormat` retired in favor of `nameField`,\n  // which names a real field. The former template composed two local fields, so\n  // a `display_title` formula field reproduces it for the record title.\n  nameField: 'display_title',\n  // Explicit search targets (ADR-0061). REQUIRED because nameField is a\n  // FORMULA (display_title/full_name): without this, $search auto-defaults to\n  // the formula field, which isn't a real column, so the lookup picker + global\n  // search silently return zero. These are real, indexed columns.\n  searchableFields: ['name', 'quote_number'],\n  highlightFields: ['quote_number', 'name', 'crm_account', 'status', 'total_price'],\n\n  fieldGroups: [\n    { key: 'basic',     label: 'Quote Information', icon: 'info' },\n    { key: 'pricing',   label: 'Pricing',           icon: 'dollar-sign' },\n    { key: 'terms',     label: 'Terms & Validity',  icon: 'calendar' },\n    { key: 'address',   label: 'Addresses',         icon: 'map-pin', collapse: 'collapsed' },\n    { key: 'system',    label: 'System',            icon: 'database', collapse: 'collapsed' },\n  ],\n\n  fields: {\n    // Platform ownership anchor \u2014 canonical note in `account.object.ts` (#548).\n    owner_id: Field.lookup('sys_user', {\n      label: 'Quote Owner',\n      group: 'basic',\n      system: true,\n      readonly: false,\n      trackHistory: true,\n    }),\n\n    // AutoNumber field\n    quote_number: Field.autonumber({\n      label: 'Quote Number',\n      group: 'basic',\n      format: 'QTE-{0000}',\n    }),\n    \n    // Basic Information\n    name: Field.text({\n      label: 'Quote Name',\n      group: 'basic',\n      required: true,\n      storage: { notNull: true },\n      searchable: true,\n      maxLength: 255,\n    }),\n\n    // ADR-0079 record title (was titleFormat '{quote_number} - {name}').\n    display_title: Field.formula({\n      label: 'Display Title',\n      group: 'basic',\n      expression: F`record.quote_number + \" - \" + record.name`,\n    }),\n\n    // Relationships \u2014 the master the OWD derives from (authored, not positional).\n    crm_account: Field.masterDetail('crm_account', {\n      label: 'Account',\n      group: 'basic',\n      required: true,\n      storage: { notNull: true },\n      deleteBehavior: 'cascade',\n    }),\n    \n    crm_contact: Field.lookup('crm_contact', {\n      label: 'Contact',\n      group: 'basic',\n      // Optional AT DRAFT TIME, required from `presented` on (#1017).\n      //\n      // quote_generation maps the opportunity's `primary_contact`, which is\n      // itself optional \u2014 a flat `required: true` here meant contact-less\n      // opportunities could never draft a quote at all. So the recipient is\n      // nailed down by the time a quote is PRESENTED, not when it is drafted.\n      // That sentence sat in this comment for the field's whole life with\n      // nothing enforcing it: no rule stopped a contact-less quote reaching\n      // `presented` or `accepted`, and the bill came due one object over.\n      // `crm_contract.crm_contact` is `required` + `notNull`, so accepting such\n      // a quote made `quote_on_accepted` fail to draft the contract \u2014 since\n      // #714/#1013 that failure is honest and no longer swallows the close-won\n      // leg, but the hook is `async` + `onError: 'log'`, so the accepting write\n      // still answers 200 and the only evidence is a server log nobody reads.\n      // `requiredWhen` moves the same refusal to the synchronous, someone-is-\n      // watching moment: the rep is told on the write that turns the quote\n      // outward, against the field, with the quote still editable.\n      //\n      // WHY EXACTLY `presented` + `accepted`, and not the other two terminal\n      // states. Both of those are reachable WITHOUT the quote ever being sent\n      // (see the `quote_status_progression` transitions below):\n      //   \u2022 `expired` \u2014 the `quote_expiration` flow sweeps on `expiration_date`\n      //     alone and expires never-sent drafts as readily as presented ones.\n      //     Requiring a recipient there would make a nightly system write fail\n      //     on exactly the quotes that have no recipient BECAUSE nobody sent\n      //     them, and the sweep's `runAs: 'system'` would not exempt it \u2014 the\n      //     gate applies on write, not on actor.\n      //   \u2022 `rejected` \u2014 legal straight from `in_review`, i.e. a quote killed\n      //     internally before anyone saw it. Demanding a contact to file that\n      //     verdict asks for a recipient the quote never had.\n      // Neither state passes anything on to a contract, so neither needs one.\n      //\n      // \u26A0\uFE0F `has(record.status)` is load-bearing, not decoration \u2014 the same trap\n      // documented at `lead.object.ts`'s duplicate lookups: a bare\n      // `record.status == \"presented\"` aborts with `No such key` on any merged\n      // record that simply omits the column, and the engine's answer to a\n      // predicate that fails to evaluate is to SKIP it (\"requiredWhen for\n      // 'crm_contact' failed to evaluate \u2014 skipped\"). The rule would then read\n      // as enforced and require nothing at all.\n      //\n      // @objectstack 12: string[] `referenceFilters` is dead (not read by the\n      // picker); `dependsOn` is the live cascading form \u2014 scopes contacts to the\n      // quote's `crm_account` (ADR-0049).\n      dependsOn: ['crm_account'],\n      requiredWhen: P`has(record.status) && (record.status == \"presented\" || record.status == \"accepted\")`,\n      description:\n        'Required once the quote is Presented or Accepted \u2014 the drafted contract takes its Primary Contact from here.',\n    }),\n\n    crm_opportunity: Field.lookup('crm_opportunity', {\n      label: 'Opportunity',\n      group: 'basic',\n      // Scope opportunities to the quote's account (was dead referenceFilters).\n      dependsOn: ['crm_account'],\n    }),\n\n\n    // Status\n    status: Field.select({\n      label: 'Status',\n      group: 'basic',\n      options: [\n        { label: 'Draft', value: 'draft', color: '#999999', default: true },\n        { label: 'In Review', value: 'in_review', color: '#FFA500' },\n        { label: 'Presented', value: 'presented', color: '#4169E1' },\n        { label: 'Accepted', value: 'accepted', color: '#00AA00' },\n        { label: 'Rejected', value: 'rejected', color: '#FF0000' },\n        { label: 'Expired', value: 'expired', color: '#666666' },\n      ],\n      required: true,\n      storage: { notNull: true },\n      trackHistory: true,\n    }),\n    \n    // Dates\n    quote_date: Field.date({\n      label: 'Quote Date',\n      group: 'terms',\n      required: true,\n      storage: { notNull: true },\n      defaultValue: cel`today()`,\n    }),\n    \n    expiration_date: Field.date({\n      label: 'Expiration Date',\n      group: 'terms',\n      required: true,\n      storage: { notNull: true },\n    }),\n    \n    // Pricing\n    // subtotal/discount_amount/total_price are NOT `readonly`, and the writer\n    // that decides it is the LINE-ITEM ROLLUP \u2014 not the flow this note used to\n    // name. `quote_total_rollup` (`quote_line_item.hook.ts`) recomputes all\n    // three on every line insert/update/delete through\n    // `api.object('crm_quote').update(...)`: a cross-record write via `ctx.api`,\n    // which is a `ScopedContext` over the ACTING USER's context. The keys are\n    // therefore CALLER-supplied to a non-`isSystem` UPDATE, exactly what\n    // `stripReadonlyFields` deletes \u2014 with `readonly` on, a quote's totals would\n    // freeze at whatever the flow first seeded and never track its lines again.\n    // \u26A0\uFE0F `quote_generation` writes them too, but at CREATE time, and the strip\n    // is an UPDATE-path rule \u2014 that write would survive `readonly` untouched.\n    // The retired 16.x claim rested on that create-time write, which is how this\n    // note reached a right conclusion from the wrong writer.\n    // Measured in `test/readonly-write-semantics.test.ts` (insert is exempt) and\n    // `test/activity-recency.test.ts` (the `ctx.api` strip, on the real engine).\n    subtotal: Field.currency({ \n      label: 'Subtotal',\n      group: 'pricing',\n    }),\n    \n    discount: Field.percent({\n      label: 'Discount %',\n      group: 'pricing',\n      scale: 2,\n      min: 0,\n      max: 100,\n    }),\n    \n    discount_amount: Field.currency({ \n      label: 'Discount Amount',\n      group: 'pricing',\n    }),\n    \n    tax: Field.currency({ \n      label: 'Tax',\n      group: 'pricing',\n    }),\n    \n    shipping_handling: Field.currency({ \n      label: 'Shipping & Handling',\n      group: 'pricing',\n    }),\n    \n    total_price: Field.currency({ \n      label: 'Total Price',\n      group: 'pricing',\n    }),\n    \n    // Terms\n    payment_terms: Field.select({\n      label: 'Payment Terms',\n      group: 'terms',\n      // Canonical set shared with Contract (#490) \u2014 see _picklists.ts.\n      options: [...PAYMENT_TERMS_OPTIONS],\n    }),\n    \n    shipping_terms: Field.text({\n      label: 'Shipping Terms',\n      group: 'terms',\n      maxLength: 255,\n    }),\n    \n    // Billing & Shipping Address\n    billing_address: Field.address({\n      label: 'Billing Address',\n      group: 'address',\n    }),\n\n    shipping_address: Field.address({\n      label: 'Shipping Address',\n      group: 'address',\n    }),\n    \n    // Notes\n    description: Field.markdown({\n      label: 'Description',\n      group: 'basic',\n    }),\n    \n    internal_notes: Field.textarea({\n      label: 'Internal Notes',\n      group: 'system',\n    }),\n  },\n  \n  // Database indexes\n  indexes: [\n    { fields: ['crm_account'] },\n    { fields: ['crm_opportunity'] },\n    { fields: ['owner_id'] },\n    { fields: ['status'] },\n    { fields: ['quote_date'] },\n  ],\n  \n  // Enable advanced features\n  // API surface. History \u2192 Field.trackHistory (ADR-0052).\n  enable: {\n    apiEnabled: true,\n    apiMethods: ['get', 'list', 'create', 'update', 'delete'],\n    // #602 \u2014 the generated quote PDF and the customer's countersigned copy.\n    // See the canonical capability note in `src/sales/objects/index.ts`.\n    files: true,\n  },\n  \n  // Validation Rules\n  //\n  // Predicates below are TOTAL: every `record.x` read is `has()`-guarded, so the\n  // rule returns a verdict even when the merged record has no such key. See\n  // AGENTS.md \"Validation predicates must be TOTAL\" and\n  // test/object-validation-predicates.test.ts, which fails the build otherwise.\n  validations: [\n    {\n      name: 'expiration_after_quote',\n      type: 'script',\n      severity: 'error',\n      message: 'Expiration Date must be after Quote Date',\n      condition: P`has(record.expiration_date) && record.expiration_date != null && has(record.quote_date) && record.quote_date != null && record.expiration_date <= record.quote_date`,\n    },\n    {\n      // #599. The only discount constraint this object ever had was the field's\n      // own `max: 100` \u2014 the arithmetic domain of a percentage \u2014 so a rep could\n      // put 90% off a $99K deal on a quote and nothing anywhere objected: the\n      // approval flow keys on the opportunity's AMOUNT, and $99K is under the\n      // large-deal line. This is the policy ceiling that constraint never was.\n      //\n      // \u26A0\uFE0F A predicate of `record.discount > 100` here would be DEAD: field-level\n      // bounds are evaluated BEFORE object validations, so `discount: 150` is\n      // already refused by `max: 100` with `code: 'max_value'` and the message\n      // \"Discount % must be \u2264 100\", and the rule's own message is unreachable on\n      // every input that could reach it.\n      //\n      // ### Why a script validation and not a lower `max` on the field\n      //\n      // This is an INVARIANT \u2014 \"a quote's discount may never exceed the\n      // ceiling\" \u2014 not a transition condition, and #1069 is open on exactly\n      // that distinction for `requiredWhen`. Both instruments were measured\n      // against a row stored above the ceiling before the rule existed\n      // (`test/quote-discount-ceiling.test.ts` runs the measurement):\n      //\n      //   Field.percent({ max: 60 })   legacy row, unrelated edit \u2192 ADMITTED\n      //   this rule                    legacy row, unrelated edit \u2192 REFUSED\n      //\n      // A field bound checks the value being WRITTEN; a script validation is\n      // evaluated against the MERGED record on every write. So `max` carries\n      // the same silent legacy hole #1069 describes, in a second instrument,\n      // and the rule does not. The cost of the invariant, stated rather than\n      // hidden: an over-ceiling row is frozen to everything except the repair \u2014\n      // bringing the discount back under the ceiling is admitted, and is an\n      // ordinary edit. HotCRM ships no such row (deepest seeded discount: 20%).\n      //\n      // `max: 100` stays on the field as the domain of a percentage. The policy\n      // number lives in `_thresholds.ts`, interpolated into both the predicate\n      // and the message so the two cannot disagree.\n      name: 'discount_within_ceiling',\n      type: 'script',\n      severity: 'error',\n      message: `Discount cannot exceed ${QUOTE_DISCOUNT_CEILING}%`,\n      condition: P`has(record.discount) && record.discount != null && record.discount > ${QUOTE_DISCOUNT_CEILING}`,\n    },\n    {\n      // #575 B4. `crm_quote` had a full lifecycle vocabulary and no transition\n      // constraint whatsoever \u2014 nor a status guard in `quote.hook.ts` \u2014 so a\n      // quote could go straight from `draft` to `accepted`, which in CPQ terms\n      // is a signed number nobody reviewed or sent. `warning` severity matches\n      // the lead / opportunity / case machines: it flags the jump on the record\n      // without blocking a support-driven correction.\n      name: 'quote_status_progression',\n      type: 'state_machine',\n      severity: 'warning',\n      message: 'Invalid quote status transition',\n      field: 'status',\n      transitions: {\n        // `\u2192 expired` is legal from every UNSETTLED state: the quote_expiration\n        // flow sweeps on `expiration_date` alone and expires drafts that were\n        // never sent as readily as presented ones.\n        draft: ['in_review', 'expired'],\n        in_review: ['draft', 'presented', 'rejected', 'expired'],\n        presented: ['accepted', 'rejected', 'expired'],\n        // `accepted` and `expired` are terminal, and not only by convention \u2014\n        // `quote_pricing_guard` in quote.hook.ts freezes both, allowing edits\n        // to `internal_notes` and nothing else.\n        accepted: [],\n        expired: [],\n        // A rejected quote is not frozen: the rep revises the numbers and\n        // re-issues, which starts again at `draft`.\n        rejected: ['draft'],\n      },\n    },\n  ],\n  \n  // Workflow Rules\n  // \u26A0\uFE0F No `workflows[]` here, and none is possible: object `workflows[]` were\n  // removed from the platform. Field updates live in this object's `*.hook.ts`;\n  // scheduled status flips and notifications live in `src/*/flows/*.flow.ts`.\n});\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/sales/objects/_thresholds.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/sales/objects\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/sales/objects/_thresholds.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\n/**\n * Commercial governance thresholds \u2014 the money lines this app draws, authored\n * ONCE.\n *\n * \"What counts as a large deal\" is one business question with four consumers:\n * the approval entry gate and the won-deal alert (`src/sales/flows/`), and the\n * sales-director and executive rules (`src/sales/sharing/opportunity.sharing.ts`).\n * Each interpolates the constant below, and each cuts at `>=`.\n *\n * \u26D4 Both halves are load-bearing, and neither may drift. Four independent\n * literals mean a deployment that raises the bar in one place ships a product\n * where a deal is large enough for the director to *see* and not large enough\n * to *approve* \u2014 governance narrower than visibility, which is the\n * counter-intuitive direction the next author will assume the reverse of.\n * Maintainer ruling: **a deal at the line is a large deal**, so every site cuts\n * at `>=` rather than `>`. `test/deal-threshold-parity.test.ts` reads the\n * compiled CEL of every flow condition and sharing rule back out of the shipped\n * metadata and fails if any site stops agreeing on the number OR the operator.\n *\n * If a reason ever appears for leadership to see a deal that needs no approval,\n * that reason belongs **here**, next to the constant, and the split becomes a\n * design instead of drift. Nothing in this repo makes that argument today.\n *\n * `HIGH_VALUE_DEAL_AMOUNT` below is deliberately NOT part of that guarantee:\n * its `>` and `<=` halves are one branch stated in complementary polarity,\n * which must PARTITION rather than agree. Two operators there are the design.\n */\n\n/**\n * A \"large deal\" \u2014 the amount at which an opportunity stops being routine.\n *\n * Consumed by the approval entry gate, the won-deal alert and both large-deal\n * sharing rules. `src/docs/crm_sales.md` and `src/docs/crm_admin.md` publish\n * this number to users, and `test/docs-drift.test.ts` fails if they drift from\n * what the flows actually ship.\n */\nexport const LARGE_DEAL_AMOUNT = 100_000;\n\n/**\n * The second approval tier \u2014 above this a Sales Director signs off as well as\n * the manager. Consumed by the `check_high_value` branch of\n * `opportunity-approval.flow.ts`, in both polarities.\n */\nexport const HIGH_VALUE_DEAL_AMOUNT = 500_000;\n\n/**\n * The hard ceiling on a discount percentage, in percent \u2014 on a quote, and on\n * each of its line items.\n *\n * ### One number, two rules, because a quote's total has two multipliers\n *\n * `crm_quote.discount_within_ceiling` and\n * `crm_quote_line_item.discount_within_ceiling` both interpolate this constant.\n * The second is not a copy for symmetry's sake: the quote-level percentage and\n * the per-line percentage are INDEPENDENT inputs to the same total\n * (`quote_total_rollup` discounts each line, sums, then applies the quote's\n * percentage to the sum), so a quote at `discount: 0` with every line at 90%\n * clears the quote-level rule outright and still prices 90% below list.\n * Ceiling one multiplier and the other is the way around it.\n *\n * \u26A0\uFE0F What this constant does NOT settle is what the ceiling means once the two\n * multipliers COMPOUND \u2014 60% per line and 60% on the quote is ~84% effective.\n * That is an open business-policy question, and neither rule pretends to answer\n * it.\n *\n * ### Why 60, and why only one number\n *\n * The ceiling is ABSOLUTE \u2014 there is no approval path to unblock a quote above\n * it. A blocking rule with no override has to sit where refusing is\n * unambiguously right, not where reviewing would be useful. 30% would refuse\n * aggressive-but-real commercial deals outright and leave the rep nothing to do\n * about it; 60% refuses \"a rep can give 90% off a $99K deal and nothing reviews\n * it\" while leaving genuine strategic pricing alone. The stock catalogue\n * agrees: the deepest discount HotCRM seeds anywhere is 20%\n * (`src/<pkg>/data/*.seed.ts`).\n *\n * \u26D4 There is deliberately no SOFT ceiling constant beside it. A soft tier has\n * exactly one possible consumer \u2014 discount-triggered approval routing \u2014 which\n * does not exist yet, and \u26A0\uFE0F a `severity: 'warning'` script validation is\n * admitted by this platform with *no observable surface at all*: no warning on\n * the result, nothing in the envelope. Declaring the number now would add a\n * sixth entry to the \"declared and then not applied\" table in\n * `test/win-loss-capture.test.ts`. The soft tier returns with the routing that\n * gives it a job.\n *\n * ### Why this is a validation rule and not `Field.percent({ max })`\n *\n * \u26A0\uFE0F Platform constraint, measured both ways on a legacy row already above the\n * ceiling (`test/quote-discount-ceiling.test.ts`): a field-level `max`\n * validates the WRITTEN VALUE only, so a row stored above the ceiling before\n * the rule existed keeps accepting edits forever \u2014 the same silent legacy hole\n * `requiredWhen` has. A `type: 'script'` validation is evaluated against the\n * MERGED record on every write, so it is a true invariant. Both fields keep\n * `max: 100` as the arithmetic domain of a percentage; the policy line lives in\n * the rules.\n */\nexport const QUOTE_DISCOUNT_CEILING = 60;\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/revenue/objects/quote_line_item.object.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/revenue/objects\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/revenue/objects/quote_line_item.object.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport { ObjectSchema, Field } from '@objectstack/spec/data';\nimport { F, P } from '@objectstack/spec';\nimport { QUOTE_DISCOUNT_CEILING } from '../../sales/objects/_thresholds';\n\n/**\n * Quote Line Item\n *\n * Individual line on a Quote. Quotes generated from an Opportunity typically\n * clone its OpportunityLineItems into QuoteLineItems so pricing can diverge\n * after the quote is sent without affecting the underlying opportunity.\n */\nexport const QuoteLineItem = ObjectSchema.create({\n  name: 'crm_quote_line_item',\n  label: 'Quote Line Item',\n  pluralLabel: 'Quote Line Items',\n  icon: 'package',\n  description: 'A single product line on a Quote',\n\n  // OWD is an authored decision (ADR-0090 D1/D7). Record access DERIVES from\n  // the quote (ADR-0055).\n  //\n  // \u26A0\uFE0F Reads ARE filtered to lines whose `crm_quote` the caller can read, and\n  // \"can read\" resolves through the same paths a direct read of the quote takes\n  // \u2014 owner scope and `sys_record_share` grants included, NOT the master's\n  // row-level security policies alone. A rep who owns one quote reads that\n  // quote's lines and no others. The parent-write gate derives the same way: a\n  // line whose quote the caller cannot edit is refused with a\n  // `PermissionDeniedError` naming the master.\n  //\n  // `test/parent-derived-reach.test.ts` pins those semantics with positive\n  // controls, so a regression is caught in either direction \u2014 it was written to\n  // go red the day the platform widens them: with the derivation consulting\n  // master RLS policies only, under a SYSTEM context, and no policy authored on\n  // `crm_quote`, the master set is EVERY quote and a line item is readable \u2014\n  // and writable \u2014 by every holder of object-level read on this object. The\n  // relation resolver accepts a REQUIRED LOOKUP as the parent, so no\n  // master-detail conversion is needed.\n  //\n  // \u26D4 Not `private`: with no owner field on this object that resolves to the\n  // platform's auto-stamped `owner_id` \u2014 the row's inserter \u2014 so lines cloned\n  // onto a quote by the `quote_generation` flow are invisible to the rep who\n  // owns the quote.\n  sharingModel: 'controlled_by_parent',\n\n  // Per-field history is opt-in via `Field.trackHistory` (ADR-0052), set on\n  // quantity/unit_price/discount below. Master-detail children still inherit\n  // the master's sharing automatically.\n\n  highlightFields: ['crm_product', 'quantity', 'unit_price', 'total_price'],\n\n  // The same two-group split as `crm_opportunity_line_item` (#1453), derived\n  // from the ten fields declared here: every factor `total_price` multiplies\n  // is `pricing`, everything that says WHICH line this is is `basic`.\n  //\n  // \u26A0\uFE0F Neither group may be a subset of the highlight strip \u2014 see the twin\n  // object for the hoisting rule this satisfies.\n  fieldGroups: [\n    { key: 'basic',   label: 'Line Item', icon: 'package' },\n    { key: 'pricing', label: 'Pricing',   icon: 'dollar-sign' },\n  ],\n\n  fields: {\n    // The parent link \u2014 same decision, same reasoning, as\n    // `opportunity_line_item.crm_opportunity` (#727); read the long note there.\n    // In short: declaring nothing resolves to the spec default `set_null`, which\n    // the engine escalates to `restrict` on a REQUIRED lookup, so every quote\n    // that had been itemised refused to delete with a 409 quoting this field.\n    // A quote line is subordinate to its quote (`quote_line_item.hook.ts` rolls\n    // the quote's subtotal/total UP from these rows), so it goes with it.\n    crm_quote: Field.masterDetail('crm_quote', {\n      label: 'Quote',\n      group: 'basic',\n      required: true,\n      storage: { notNull: true },\n      deleteBehavior: 'cascade',\n\n      // Curates the line-items panel on a quote's detail page (#1199) \u2014 the\n      // mechanism that panel reads first (#944; the long note is on\n      // `crm_campaign_member.crm_campaign`). A SUPERSET of the fallback it\n      // replaces (`highlightFields` minus this lookup: Product / Quantity /\n      // Sales Price / Total) plus `subtotal`, the line's price after its own\n      // discount \u2014 the formula was evaluated on every read and shown in no list.\n      //\n      // \u26D4 Not added to `highlightFields`: the detail page hoists the first\n      // four of that strip, so a fifth entry never reaches the strip, and\n      // reordering it would evict `total_price` from the record's header.\n      relatedListColumns: ['crm_product', 'quantity', 'unit_price', 'subtotal', 'total_price'],\n    }),\n\n    // Left on the restricting default on purpose \u2014 see the twin object: a\n    // product's catalog entry must not take priced quote history with it.\n    crm_product: Field.lookup('crm_product', {\n      label: 'Product',\n      group: 'basic',\n      required: true,\n      storage: { notNull: true },\n    }),\n\n    description: Field.text({\n      label: 'Description',\n      group: 'basic',\n      maxLength: 500,\n    }),\n\n    quantity: Field.number({\n      label: 'Quantity',\n      group: 'pricing',\n      required: true,\n      storage: { notNull: true },\n      scale: 2,\n      min: 0,\n      defaultValue: 1,\n      trackHistory: true,\n    }),\n\n    list_price: Field.currency({\n      label: 'List Price',\n      group: 'pricing',\n      readonly: true,\n    }),\n\n    unit_price: Field.currency({\n      label: 'Sales Price',\n      group: 'pricing',\n      required: true,\n      storage: { notNull: true },\n      trackHistory: true,\n    }),\n\n    discount: Field.percent({\n      label: 'Discount %',\n      group: 'pricing',\n      scale: 2,\n      min: 0,\n      max: 100,\n      defaultValue: 0,\n      trackHistory: true,\n    }),\n\n    subtotal: Field.formula({\n      label: 'Subtotal',\n      group: 'pricing',\n      expression: F`record.quantity * record.unit_price * (1 - record.discount / 100)`,\n    }),\n\n    // A line carries no tax: tax is the quote's own amount (#2069), so Total is\n    // `subtotal`'s expression, not a read of `subtotal` \u2014 a formula reading a\n    // formula depends on hydration order (`lead.object.ts:61-64`).\n    total_price: Field.formula({\n      label: 'Total',\n      group: 'pricing',\n      expression: F`record.quantity * record.unit_price * (1 - record.discount / 100)`,\n    }),\n\n    line_number: Field.number({\n      label: 'Line #',\n      group: 'basic',\n      scale: 0,\n      readonly: true,\n    }),\n  },\n\n  // Predicates below are TOTAL: every `record.x` read is `has()`-guarded, so the\n  // rule returns a verdict even when the merged record has no such key. See\n  // AGENTS.md \"Validation predicates must be TOTAL\" and\n  // test/object-validation-predicates.test.ts, which fails the build otherwise.\n  validations: [\n    {\n      name: 'unit_price_positive',\n      type: 'script',\n      severity: 'error',\n      message: 'Sales price cannot be negative',\n      condition: P`has(record.unit_price) && record.unit_price != null && record.unit_price < 0`,\n    },\n    {\n      // #1086. The other half of #599's ceiling, and the reason that card's own\n      // acceptance criterion \u2014 \"a quote with a 90% line discount cannot reach\n      // `presented`\" \u2014 was not met by the quote-level rule alone.\n      //\n      // ### The walk-around this closes\n      //\n      // A quote's total has TWO independent discount multipliers, and\n      // `quote_total_rollup` composes them:\n      //\n      //   subtotal        = \u03A3 line (quantity \u00D7 unit_price \u00D7 (1 \u2212 LINE discount/100))\n      //   discount_amount = subtotal \u00D7 QUOTE discount%\n      //\n      // #599 put a ceiling on the second one only. So a quote at\n      // `discount: 0` \u2014 which clears `discount_within_ceiling` on `crm_quote`\n      // outright \u2014 with every line at `discount: 90` prices 90% below list, and\n      // nothing objected: this object's only discount constraint was the\n      // field's own `max: 100`, the arithmetic domain of a percentage. An\n      // invariant with a documented walk-around is worse than no invariant,\n      // because a reader (human or AI) cites the rule as the guarantee.\n      //\n      // ### Same constant, same instrument, deliberately\n      //\n      // The number is `QUOTE_DISCOUNT_CEILING` \u2014 imported, never retyped, so the\n      // two ceilings are one policy and cannot drift into two. The instrument is\n      // a `type: 'script'` validation for the reason #599 measured on the quote\n      // (and this card re-measured on this object, in\n      // `test/quote-discount-ceiling.test.ts`): a field-level `max` validates\n      // only the value being WRITTEN, so a line stored above the ceiling before\n      // the rule existed keeps accepting edits forever, while a script\n      // validation is evaluated against the MERGED record on every write and is\n      // therefore a true invariant. `max: 100` stays on the field as the domain\n      // of a percentage; the policy line lives here.\n      //\n      // ### What this rule does NOT decide\n      //\n      // 60% per line AND 60% on the quote still compounds to ~84% EFFECTIVE.\n      // Whether the ceiling should be read against the effective discount is a\n      // business-policy question with no answer in this codebase, and it is\n      // open as #1109 \u2014 deliberately not guessed here. A per-line ceiling is\n      // correct under either answer: it is the whole policy if the answer is\n      // per-line, and a component of it if the answer is effective.\n      name: 'discount_within_ceiling',\n      type: 'script',\n      severity: 'error',\n      // Names the LINE, because the quote carries a same-named rule with its\n      // own message: on a refused save the rep must be able to tell which of\n      // the two numbers the platform is objecting to.\n      message: `Line discount cannot exceed ${QUOTE_DISCOUNT_CEILING}%`,\n      condition: P`has(record.discount) && record.discount != null && record.discount > ${QUOTE_DISCOUNT_CEILING}`,\n    },\n  ],\n});\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/marketing/objects/index.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/marketing/objects\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/marketing/objects/index.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\n/**\n * Marketing object barrel.\n *\n * Re-exports this package's *.object.ts definitions; the `*.hook.ts` files\n * beside them register through `./hooks.ts`. The canonical note on the\n * collaboration capabilities (`enable.files`, `enable.feeds`) that every\n * object in this app points at is written once, in\n * `src/sales/objects/index.ts`.\n */\n\nexport { Campaign } from './campaign.object';\nexport { CampaignMember } from './campaign_member.object';\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/marketing/objects/campaign.object.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/marketing/objects\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/marketing/objects/campaign.object.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport { ObjectSchema, Field } from '@objectstack/spec/data';\nimport { F, P } from '@objectstack/spec';\n\n/**\n * Campaign Object\n * Represents marketing campaigns\n */\nexport const Campaign = ObjectSchema.create({\n  name: 'crm_campaign',\n  label: 'Campaign',\n  pluralLabel: 'Campaigns',\n  icon: 'megaphone',\n  description: 'Marketing campaigns and initiatives',\n\n  // ADR-0090 D1/D7: OWD is an authored decision. Campaign catalog is org-visible; only owners edit.\n  sharingModel: 'public_read',\n  // ADR-0079: render-only `titleFormat` retired in favor of `nameField`,\n  // which names a real field. The former template composed two local fields, so\n  // a `display_title` formula field reproduces it for the record title.\n  nameField: 'display_title',\n  // Explicit search targets (ADR-0061). REQUIRED because nameField is a\n  // FORMULA (display_title/full_name): without this, $search auto-defaults to\n  // the formula field, which isn't a real column, so the lookup picker + global\n  // search silently return zero. These are real, indexed columns.\n  searchableFields: ['name', 'campaign_code'],\n  highlightFields: ['campaign_code', 'name', 'type', 'status', 'start_date'],\n\n  // Every other business object with a detail page groups its fields; campaign\n  // was one of the two that did not, so its detail page fell back to one flat\n  // 30-field grid with the ROI formulas sitting next to the campaign name. The\n  // labels mirror the sections the campaign form uses (Campaign Information /\n  // Schedule / Budget & ROI / Performance) so the two surfaces agree \u2014 the\n  // form's old three-section shape buried the two manual-entry cost fields in a\n  // combined \"Schedule & Budget\" row and was split to match this one (#597).\n  fieldGroups: [\n    { key: 'basic',      label: 'Campaign Information', icon: 'megaphone' },\n    { key: 'schedule',   label: 'Schedule',             icon: 'calendar' },\n    { key: 'budget',     label: 'Budget & ROI',         icon: 'dollar-sign' },\n    { key: 'metrics',    label: 'Performance',          icon: 'bar-chart' },\n    { key: 'assignment', label: 'Ownership',            icon: 'user' },\n    { key: 'assets',     label: 'Campaign Assets',      icon: 'link', collapse: 'collapsed' },\n  ],\n\n  fields: {\n    // Platform ownership anchor \u2014 canonical note in `account.object.ts` (#548).\n    owner_id: Field.lookup('sys_user', {\n      label: 'Campaign Owner',\n      group: 'assignment',\n      system: true,\n      readonly: false,\n      trackHistory: true,\n    }),\n\n    // AutoNumber field\n    campaign_code: Field.autonumber({\n      group: 'basic',\n      label: 'Campaign Code',\n      format: 'CPG-{0000}',\n    }),\n    \n    // Basic Information\n    name: Field.text({\n      group: 'basic',\n      label: 'Campaign Name',\n      required: true,\n      storage: { notNull: true },\n      searchable: true,\n      maxLength: 255,\n    }),\n\n    // ADR-0079 record title (was titleFormat '{campaign_code} - {name}').\n    display_title: Field.formula({\n      group: 'basic',\n      label: 'Display Title',\n      expression: F`record.campaign_code + \" - \" + record.name`,\n    }),\n\n    description: Field.markdown({\n      group: 'basic',\n      label: 'Description',\n    }),\n    \n    // Type & Channel\n    type: Field.select({\n      group: 'basic',\n      label: 'Campaign Type',\n      options: [\n        { label: 'Email', value: 'email', default: true },\n        { label: 'Webinar', value: 'webinar' },\n        { label: 'Trade Show', value: 'trade_show' },\n        { label: 'Conference', value: 'conference' },\n        { label: 'Direct Mail', value: 'direct_mail' },\n        { label: 'Social Media', value: 'social_media' },\n        { label: 'Content Marketing', value: 'content' },\n        { label: 'Partner Marketing', value: 'partner' },\n      ]\n    }),\n    \n    channel: Field.select({\n      group: 'basic',\n      label: 'Primary Channel',\n      options: [\n        { label: 'Digital', value: 'digital' },\n        { label: 'Social', value: 'social' },\n        { label: 'Email', value: 'email' },\n        { label: 'Events', value: 'events' },\n        { label: 'Partner', value: 'partner' },\n      ]\n    }),\n    \n    // Status\n    status: Field.select({\n      group: 'basic',\n      label: 'Status',\n      options: [\n        { label: 'Planning', value: 'planning', color: '#999999', default: true },\n        { label: 'In Progress', value: 'in_progress', color: '#FFA500' },\n        { label: 'Completed', value: 'completed', color: '#00AA00' },\n        { label: 'Aborted', value: 'aborted', color: '#FF0000' },\n      ],\n      required: true,\n      storage: { notNull: true },\n      trackHistory: true,\n    }),\n    \n    // Dates\n    start_date: Field.date({\n      group: 'schedule',\n      label: 'Start Date',\n      required: true,\n      storage: { notNull: true },\n    }),\n    \n    end_date: Field.date({\n      group: 'schedule',\n      label: 'End Date',\n      required: true,\n      storage: { notNull: true },\n    }),\n    \n    // Budget & ROI\n    budgeted_cost: Field.currency({ \n      group: 'budget',\n      label: 'Budgeted Cost',\n      min: 0,\n    }),\n    \n    actual_cost: Field.currency({ \n      group: 'budget',\n      label: 'Actual Cost',\n      min: 0,\n    }),\n    \n    expected_revenue: Field.currency({ \n      group: 'budget',\n      label: 'Expected Revenue',\n      min: 0,\n    }),\n    \n    // \u26D4 NOT `readonly` (here and on the num_* snapshot fields below), and the\n    // reason holds on the pinned engine rather than on the retired 16.x claim\n    // this note used to carry. The metric block \u2014 `CAMPAIGN_METRIC_FIELDS` in\n    // `campaign.hook.ts` \u2014 is written by FOUR refresh hooks, not by the\n    // long-retired `campaign_snapshot_metrics`: `campaign_metrics_refresh`,\n    // `campaign_attribution_refresh`, `campaign_lead_conversion_refresh` and\n    // `campaign_member_metrics_refresh`. Every one of them writes\n    // `api.object('crm_campaign').update(...)`, and none declares `Hook.runAs`,\n    // which defaults to `'inherit'` \u2014 so `ctx.api` is a `ScopedContext` over the\n    // ACTING USER's context, and the keys are CALLER-supplied to a\n    // non-`isSystem` UPDATE, exactly what `stripReadonlyFields` deletes. Their\n    // least-privileged trigger is an ordinary user edit \u2014 a rep moving a\n    // campaign's status, saving an opportunity, enrolling a member \u2014 so\n    // `readonly` here would freeze the whole block at its seeded values.\n    // Measured in `test/activity-recency.test.ts`, which runs this same\n    // `ctx.api` shape through the real engine under a plain user context.\n    actual_revenue: Field.currency({ \n      group: 'budget',\n      label: 'Actual Revenue',\n      min: 0,\n    }),\n    \n    // Metrics\n    target_size: Field.number({\n      group: 'metrics',\n      label: 'Target Size',\n      description: 'Target number of leads/contacts',\n      min: 0,\n    }),\n    \n    // NOT `readonly`: written by the same four refresh hooks, and for the same\n    // reason \u2014 see the note on `actual_revenue` above.\n    // Definition: total members enrolled.\n    num_sent: Field.number({\n      group: 'metrics',\n      label: 'Number Sent',\n      min: 0,\n    }),\n    \n    num_responses: Field.number({\n      group: 'metrics',\n      label: 'Number of Responses',\n      min: 0,\n    }),\n    \n    num_leads: Field.number({\n      group: 'metrics',\n      label: 'Number of Leads',\n      min: 0,\n    }),\n    \n    num_converted_leads: Field.number({\n      group: 'metrics',\n      label: 'Converted Leads',\n      min: 0,\n    }),\n    \n    num_opportunities: Field.number({\n      group: 'metrics',\n      label: 'Opportunities Created',\n      min: 0,\n    }),\n    \n    num_won_opportunities: Field.number({\n      group: 'metrics',\n      label: 'Won Opportunities',\n      min: 0,\n    }),\n    \n    // Calculated Metrics (Formula Fields)\n    response_rate: Field.formula({\n      group: 'metrics',\n      label: 'Response Rate %',\n      expression: F`coalesce(record.num_sent, 0) > 0 ? (coalesce(record.num_responses, 0) * 100.0) / record.num_sent : 0.0`,\n      scale: 2,\n    }),\n    \n    roi: Field.formula({\n      group: 'budget',\n      label: 'ROI %',\n      expression: F`coalesce(record.actual_cost, 0) > 0 ? ((coalesce(record.actual_revenue, 0) - record.actual_cost) * 100.0) / record.actual_cost : 0.0`,\n      scale: 2,\n    }),\n    \n    // No `parent_campaign`. Campaign hierarchy was declared and never used: no\n    // page, doc or report mentioned it, and the honest consumer for it \u2014 a\n    // rolled-up ROI \u2014 cannot be one declaration. `roi` here is a formula over\n    // this campaign's OWN `actual_cost` / `actual_revenue`, so a hierarchy ROI\n    // would put a second, differently-scoped ROI on the same record and leave\n    // every reader to guess which one they were looking at.\n    \n    // Campaign Assets\n    landing_page_url: Field.url({\n      group: 'assets',\n      label: 'Landing Page',\n    }),\n    \n    is_active: Field.boolean({\n      group: 'assets',\n      label: 'Active',\n      defaultValue: true,\n    }),\n  },\n  \n  // Database indexes\n  indexes: [\n    { fields: ['name'] },\n    { fields: ['type'] },\n    { fields: ['status'] },\n    { fields: ['start_date'] },\n    { fields: ['owner_id'] },\n  ],\n  \n  // Enable advanced features\n  // API surface. History \u2192 Field.trackHistory (ADR-0052).\n  enable: {\n    apiEnabled: true,\n    apiMethods: ['get', 'list', 'create', 'update', 'delete'],\n  },\n  \n  // Validation Rules\n  //\n  // Predicates below are TOTAL: every `record.x` read is `has()`-guarded, so the\n  // rule returns a verdict even when the merged record has no such key. See\n  // AGENTS.md \"Validation predicates must be TOTAL\" and\n  // test/object-validation-predicates.test.ts, which fails the build otherwise.\n  validations: [\n    {\n      name: 'end_after_start',\n      type: 'script',\n      severity: 'error',\n      message: 'End Date must be after Start Date',\n      // `<=`, not `<`: the message promises \"after\", so a campaign that ends\n      // the day it starts is a violation. Matches `crm_contract`'s twin rule\n      // and `crm_forecast.period_end_after_start` (#514 item 12).\n      condition: P`has(record.end_date) && record.end_date != null && has(record.start_date) && record.start_date != null && record.end_date <= record.start_date`,\n    },\n    {\n      name: 'actual_cost_within_budget',\n      type: 'script',\n      severity: 'warning',\n      message: 'Actual Cost exceeds Budgeted Cost',\n      condition: P`has(record.actual_cost) && record.actual_cost != null && has(record.budgeted_cost) && record.budgeted_cost != null && record.actual_cost > record.budgeted_cost`,\n    },\n  ],\n  \n  // Workflow Rules\n  // \u26A0\uFE0F No `workflows[]` here, and none is possible: object `workflows[]` were\n  // removed from the platform. Field updates live in this object's `*.hook.ts`;\n  // scheduled status flips and notifications live in `src/*/flows/*.flow.ts`.\n});\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/marketing/objects/campaign_member.object.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/marketing/objects\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/marketing/objects/campaign_member.object.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport { ObjectSchema, Field } from '@objectstack/spec/data';\nimport { P } from '@objectstack/spec';\n\n/**\n * Campaign Member Object\n *\n * Links a Lead OR Contact to a Campaign and tracks the response\n * lifecycle `sent \u2192 responded / converted / unsubscribed`.\n * Used by the campaign-enrollment flow and by ROI dashboards.\n *\n * \u26A0\uFE0F The lifecycle stops where the platform's writers stop (#597). It used to\n * read `Sent \u2192 Opened \u2192 Clicked \u2192 Responded \u2192 Converted` with `bounced` beside\n * it, plus `first_opened_date` / `first_clicked_date` stamps \u2014 six values and\n * two columns that NOTHING in this app or on the platform could ever write.\n * `@objectstack/plugin-email` is \"transport-pluggable OUTBOUND delivery with\n * sys_email persistence\": its `sys_email.status` vocabulary is\n * `queued | sent | failed`, there is no open/click webhook, no bounce\n * ingestion, and no tracking pixel anywhere in the installed platform\n * (measured on 17.0.0-rc.6). So an author reading this object was promised\n * engagement tracking the product cannot deliver, and every one of those\n * values would have stayed at its default forever.\n *\n * Removed rather than wired, per ADR-0049's enforce-or-remove spirit: they\n * come back the day a real tracking integration exists to write them, and not\n * before. What survives is the part with a real writer \u2014 see the writer table\n * beside each field below.\n */\nexport const CampaignMember = ObjectSchema.create({\n  name: 'crm_campaign_member',\n  label: 'Campaign Member',\n  pluralLabel: 'Campaign Members',\n  icon: 'user-plus',\n  description: 'Membership and response tracking for marketing campaigns',\n\n  // ADR-0090 D1/D7: OWD is an authored decision. Membership is an attribute of\n  // the campaign, so record access DERIVES from it (ADR-0055). The relation\n  // resolver accepts the REQUIRED `crm_campaign` LOOKUP as the parent, so no\n  // master-detail conversion is needed.\n  //\n  // The derivation delivers exactly \"members whose `crm_campaign` the caller\n  // can read\". \u26A0\uFE0F Master accessibility resolves through the same paths a direct\n  // read of the campaign takes \u2014 ownership and `sys_record_share` grants folded\n  // in ALONGSIDE the master's row-level security policies, not the policies\n  // alone. `test/parent-derived-reach.test.ts` pins that, and was written to go\n  // red the day the platform changes it: an earlier version consulted master\n  // RLS ONLY, under a SYSTEM context, so with no policy narrowing a SELECT on\n  // `crm_campaign` a member row was readable by every holder of object-level\n  // read on this object.\n  //\n  // \u26A0\uFE0F The write side reaches further than reads: the platform's\n  // `member_default` set carries an owner-only-writes RLS policy on updates,\n  // and because the derivation folds master RLS in, that policy reaches through\n  // to member writes \u2014 see the `marketing_campaign_updates` note in\n  // `src/sales/profiles/marketing-user.profile.ts`.\n  //\n  // \u26D4 Not `private`: with no owner field on the junction row that resolves to\n  // \"whoever inserted it\", which is nobody's idea of campaign membership and\n  // hides rows written by the enrollment flow.\n  sharingModel: 'controlled_by_parent',\n\n  // Per-field history is opt-in via `Field.trackHistory` (ADR-0052), set on\n  // `status` below \u2014 there is no object-level history flag.\n\n  // ADR-0079: junction rows have no derivable text title; point the canonical\n  // nameField at the stored autonumber explicitly (autonumber is not in the\n  // auto-derivation whitelist).\n  nameField: 'member_number',\n\n  // Load-bearing on TWO surfaces, and the second one is why this list is not\n  // the side that gave way to fix `field-group-shadowed` below (#715). Besides the\n  // detail highlight strip, it is what curates the members panel on a\n  // campaign's detail page: a related list takes its columns from the child's\n  // `highlightFields` minus the lookup it is scoped by, and this object ships\n  // no view at all, so dropping `crm_lead`/`crm_contact` here would leave that\n  // panel showing Status / Response Date and no person \u2014 measured and pinned in\n  // `test/view-references.test.ts` (#944).\n  highlightFields: ['crm_campaign', 'crm_lead', 'crm_contact', 'status', 'response_date'],\n\n  // Both groups render on detail pages as well as on forms, and keeping them\n  // that way is a constraint on the two lists above, not a free choice (#715).\n  // A synthesized detail page hoists the record title plus the first four\n  // highlightFields out of the body, so a group whose every field is hoisted\n  // keeps its heading on forms and silently disappears from detail pages\n  // (`field-group-shadowed`).\n  // `basic` was exactly that: member_number is the title, and campaign/lead/\n  // contact are the first three of the strip. `added_date` \u2014 the enrollment\n  // stamp, which describes the MEMBERSHIP rather than the person's response \u2014\n  // sits here rather than under `response` so the group has something of its\n  // own to show. Same resolution as `crm_task`'s shadowed `assignment` group\n  // (#582): move the field to the group it reads under, leave the strip alone.\n  fieldGroups: [\n    { key: 'basic',    label: 'Basic Information', icon: 'info' },\n    { key: 'response', label: 'Response Tracking', icon: 'activity' },\n  ],\n\n  fields: {\n    member_number: Field.autonumber({\n      label: 'Member Number',\n      format: 'CM-{00000}',\n      group: 'basic',\n    }),\n\n    crm_campaign: Field.lookup('crm_campaign', {\n      label: 'Campaign',\n      required: true,\n      storage: { notNull: true },\n      group: 'basic',\n\n      // Curates the members panel on a campaign \u2014 and it is the ONE mechanism\n      // that actually reaches that panel. Measured in #944 and restated in\n      // `test/view-references.test.ts`: a detail-page related list reads\n      // `relatedListColumns` on the CHILD's lookup first, and only without it\n      // falls back to the child's `highlightFields` minus this lookup. The\n      // child's `list` view is never consulted, which is why authoring one\n      // here would not have shown anything.\n      //\n      // It is a SUPERSET of the fallback it replaces \u2014 Lead / Contact /\n      // Status / Response Date, in that order \u2014 plus the one column the panel\n      // was missing. `added_date` is the enrollment stamp: `readonly: true`\n      // (#1667) and written on every enrollment by the two elevated sub-flows\n      // #1807 built for it, so a marketer could see WHEN a member responded\n      // but not when they were added, on a register whose whole subject is\n      // the enrollment. It sits after the person and before the response\n      // lifecycle, which is the order the row happens in.\n      //\n      // \u26D4 Deliberately NOT solved by adding `added_date` to\n      // `highlightFields`: that strip is hoisted out of the detail body, and\n      // `added_date` is the only field in the `basic` group that is neither\n      // the record title nor already in the strip \u2014 hoisting it would leave\n      // the group with nothing of its own and silently vanish its heading\n      // from every detail page (`field-group-shadowed`, the trap the note\n      // above this object's `fieldGroups` records being rescued from).\n      relatedListColumns: ['crm_lead', 'crm_contact', 'added_date', 'status', 'response_date'],\n    }),\n\n    // `deleteBehavior: 'cascade'` on BOTH party lookups (#696). A lookup\n    // defaults to `set_null`, and that default made every enrolled person\n    // permanently undeletable: deleting the lead cleared this column, the\n    // cleared row instantly violated `lead_or_contact_required` below, and the\n    // whole delete rolled back with a 400 naming an object the caller never\n    // touched (\"A campaign member must reference either a Lead or a Contact\",\n    // `\"object\":\"crm_lead\"`). A GDPR \"delete this person\" request could not be\n    // served through the API or the UI.\n    //\n    // Cascade rather than `restrict`: this is a JUNCTION row whose entire\n    // meaning is \"this person is enrolled in this campaign\". Once the person is\n    // gone the row denotes nothing, so keeping it (restrict) would only trade\n    // one undeletable person for a manual un-enrol chore, and the impact this\n    // fixes is undeletable people, not a confusing message. Cascade also makes\n    // the object's own rule unfalsifiable by construction: there is no longer a\n    // reachable state in which a stored member row breaks it.\n    crm_lead: Field.lookup('crm_lead', {\n      label: 'Lead',\n      group: 'basic',\n      deleteBehavior: 'cascade',\n      description: 'Set when the member was a Lead at enrollment time',\n    }),\n\n    crm_contact: Field.lookup('crm_contact', {\n      label: 'Contact',\n      group: 'basic',\n      deleteBehavior: 'cascade',\n      description: 'Set when the member is an existing Contact',\n    }),\n\n    // \u2B50 `readonly: true` \u2014 DECLARED, and it still costs no writer its write,\n    // but the reason CHANGED on the @objectstack/* 17.4.0 migration. It used to\n    // be \"the strip is an UPDATE-path rule and every writer here is an INSERT\".\n    // objectql 17.4.0 retired that: a static readonly field is now stripped from\n    // a NON-SYSTEM caller's INSERT payload inside `engine.insert` too, so an\n    // ordinary user-context create no longer seeds this column.\n    //\n    // Every writer is therefore elevated now, and the elevation is scoped as\n    // narrowly as AGENTS.md house rule 9 requires \u2014 the `campaign_enrollment`\n    // SCREEN flow stays `runAs: 'user'` and hands only the insert to\n    // `campaign_lead_member_enroll` / `campaign_contact_member_enroll`\n    // (`runAs: 'system'`, one `create_record` each); the marketing seed is a\n    // system write already. Nothing updates it: there is no `update_record`\n    // node, no hook and no action that writes `added_date`. This column's own\n    // two halves are pinned in `test/audit-stamp-readonly.test.ts` \u2014 the\n    // enrollment writers still stamp it, and a user-context UPDATE is stripped.\n    // Ruled #1667 (director seat, decision batch #74, 2026-09-07): an\n    // enrollment stamp nobody is meant to hand-edit gets the declaration that\n    // says so. \u26D4 The 16.x claim this note used to carry (\"every member landed\n    // with a null Added Date while the flag was on\") described an engine this\n    // repo no longer runs; \u26D4 do not resurrect it as a reason to open the\n    // column back up.\n    //\n    // Grouped under `basic`, not `response` (#715): it records when the\n    // membership was created, which is a fact about the enrollment, not a step\n    // in the response lifecycle the other stamps track.\n    added_date: Field.datetime({\n      label: 'Added Date',\n      group: 'basic',\n      readonly: true,\n    }),\n\n    // Writers, one per surviving value (#597):\n    //   sent         \u2014 campaign_enrollment flow, `create_campaign` (leads) and\n    //                  `add_contact_to_campaign` (contacts) stamp it on insert.\n    //   responded    \u2014 the `mark_responded` action (src/marketing/actions/campaign.actions.ts).\n    //   converted    \u2014 the member's lead converting; `campaign_lead_conversion_refresh`\n    //                  (src/sales/objects/lead.campaign-metrics.hook.ts) promotes\n    //                  the row when `crm_lead.is_converted` flips.\n    //   unsubscribed \u2014 set by a rep (or an opt-out request) on the member row;\n    //                  `campaign_member_optout_sync` round-trips it to the\n    //                  lead/contact's `email_opt_out`, which is what makes the\n    //                  enrollment flow's opt-out filter honour it next run.\n    //\n    // `opened` / `clicked` / `bounced` were removed here \u2014 see the object\n    // docblock. Nothing on the platform can produce them.\n    status: Field.select({\n      label: 'Status',\n      required: true,\n      storage: { notNull: true },\n      group: 'response',\n      trackHistory: true,\n      options: [\n        { label: 'Sent',      value: 'sent',      default: true, color: '#A0A0A0' },\n        { label: 'Responded', value: 'responded', color: '#00AA00' },\n        { label: 'Converted', value: 'converted', color: '#7C3AED' },\n        { label: 'Unsubscribed', value: 'unsubscribed', color: '#FF0000' },\n      ],\n    }),\n\n    // Written by the `mark_responded` action, and by\n    // `campaign_member_lifecycle` when it back-fills a member whose response\n    // was recorded by flipping `status` directly.\n    response_date: Field.datetime({\n      label: 'Response Date',\n      group: 'response',\n    }),\n\n    // Kept in lockstep with `status == \"responded\"` by\n    // `campaign_member_lifecycle` (beforeInsert/beforeUpdate) \u2014 a boolean that\n    // disagrees with the status it summarises is the shape the response\n    // surfaces cannot render, and it is what `test/seed-consistency.test.ts`\n    // already pins on the seed side.\n    has_responded: Field.boolean({\n      label: 'Has Responded',\n      defaultValue: false,\n      group: 'response',\n    }),\n  },\n\n  // Predicates below are TOTAL: every `record.x` read is `has()`-guarded, so the\n  // rule returns a verdict even when the merged record has no such key. See\n  // AGENTS.md \"Validation predicates must be TOTAL\" and\n  // test/object-validation-predicates.test.ts, which fails the build otherwise.\n  validations: [\n    {\n      name: 'lead_or_contact_required',\n      type: 'script',\n      severity: 'error',\n      message: 'A campaign member must reference either a Lead or a Contact',\n      condition: P`(!has(record.crm_lead) || isBlank(record.crm_lead)) && (!has(record.crm_contact) || isBlank(record.crm_contact))`,\n    },\n  ],\n});\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/sales/actions/index.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/sales/actions\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/sales/actions/index.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\n/**\n * Action Definitions Barrel\n *\n * Exports CRM action metadata. Every action ships an inline metadata\n * `body` (sandboxed JS) so the AppPlugin auto-binds the handler at\n * boot \u2014 no imperative `engine.registerAction(...)` wiring is needed.\n *\n * `ConvertLeadAction` is the only exception: it is a `flow`-typed\n * action and the screen flow under `src/sales/flows/lead-conversion.flow.ts`\n * carries the implementation.\n */\nexport { AddContactToCampaignAction, MarkPrimaryContactAction, SendEmailAction } from './contact.actions';\n// Activity logging: one registration per (kind \u00D7 object). Every export\n// forwarded from here must be ONE Action \u2014 the stack is built from\n// `Object.values(actions)`, so an exported array arrives as a nested list and\n// fails the schema parse. \u26D4 Never re-export `activityActionsFor` (the factory)\n// from here; the `crm_case` triple it also builds is service's and is forwarded\n// by `src/service/actions/index.ts`.\nexport {\n  LeadLogCallAction, LeadLogMeetingAction, LeadScheduleMeetingAction,\n  ContactLogCallAction, ContactLogMeetingAction, ContactScheduleMeetingAction,\n  AccountLogCallAction, AccountLogMeetingAction, AccountScheduleMeetingAction,\n  OpportunityLogCallAction, OpportunityLogMeetingAction, OpportunityScheduleMeetingAction,\n} from './activity-actions';\nexport { ConvertLeadAction, CreateCampaignAction, ScheduleFollowUpAction } from './lead.actions';\nexport { CloneOpportunityAction, MassUpdateStageAction, GenerateQuoteAction } from './opportunity.actions';\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/sales/actions/contact.actions.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/sales/actions\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/sales/actions/contact.actions.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport type { Action } from '@objectstack/spec/ui';\nimport { P } from '@objectstack/spec';\nimport { ACTOR_NAME_RESOLUTION_SOURCE } from './activity-actions';\n\n/**\n * Mark Contact as Primary.\n *\n * Demonstrates the L2 metadata-body action shape. The `body.source` runs\n * in the QuickJS sandbox via `actionBodyRunnerFactory`. The script receives\n * `(input, ctx)` where `ctx.recordId` is the contact id from the action\n * URL and `ctx.api.object('crm_contact').update(...)` is gated by `api.write`.\n */\nexport const MarkPrimaryContactAction: Action = {\n  name: 'mark_primary',\n  label: 'Mark as Primary Contact',\n  objectName: 'crm_contact',\n  icon: 'star',\n  type: 'script',\n  body: {\n    language: 'js',\n    source: `\n      const id = ctx.recordId;\n      if (!id) throw new Error('mark_primary requires a recordId');\n      await ctx.api.object('crm_contact').update({ id, is_primary: true }, { where: { id } });\n      return { ok: true, id, is_primary: true };\n    `,\n    capabilities: ['api.write'],\n    timeoutMs: 2000,\n  },\n  locations: ['record_header', 'list_item'],\n  visible: P`has(record.is_primary) && record.is_primary == false`,\n  confirmText: 'Mark this contact as the primary contact for the account?',\n  successMessage: 'Contact marked as primary!',\n  refreshAfter: true,\n};\n\n/**\n * Add selected contacts to a Campaign.\n *\n * The contact-side mirror of `create_campaign` on `crm_lead`, and the only\n * writer of `crm_campaign_member.crm_contact` \u2014 the lookup that lets a campaign\n * reach existing customers and not only leads. Every design decision below is\n * copied deliberately from the lead action rather than re-derived, so the two\n * paths cannot drift:\n *\n *   - PER-RECORD dispatch. `src/sales/views/contact.view.ts` wires this as the\n *     BARE-STRING form (`bulkActions: ['add_contact_to_campaign']`), which the\n *     renderer fans out once per selected row with that row's `recordId` and NO\n *     selection array. The body reads `ctx.recordId` and nothing else. \u26D4 Never\n *     add an `input.selectedIds` read: only the aggregate contract injects the\n *     underscore-prefixed builtin, and the strict params gate (ADR-0104)\n *     refuses an undeclared `selectedIds` param outright.\n *   - `type: 'script'` + `params`, never `type: 'modal'` \u2014 a modal action has\n *     no server dispatch, so its body never runs.\n *   - The campaign param is FIELD-BACKED (`field` + `objectOverride`) so the\n *     console resolves a record picker from\n *     `crm_campaign_member.crm_campaign`. A bare `{ type: 'lookup' }` cannot\n *     resolve a target object and degrades to a paste-the-ID textbox.\n *\n * One deliberate difference: the dedupe read scopes on `crm_contact`, so a\n * person enrolled as a LEAD and again as a CONTACT is not treated as a\n * duplicate. Those are two different records of two different relationships,\n * and `crm_campaign_member` keys them separately (see the two seed datasets in\n * `src/marketing/data/marketing.seed.ts`).\n */\nexport const AddContactToCampaignAction: Action = {\n  name: 'add_contact_to_campaign',\n  label: 'Add to Campaign',\n  objectName: 'crm_contact',\n  icon: 'send',\n  type: 'script',\n  body: {\n    language: 'js',\n    source: `\n      // Value key = the param's field name ('crm_campaign') since the param\n      // omits an explicit 'name'. Insert uses the REAL lookup field names on\n      // crm_campaign_member (crm_campaign / crm_contact).\n      const campaignId = input.crm_campaign ?? null;\n      if (!campaignId) throw new Error('add_contact_to_campaign requires a campaign id');\n      const ids = ctx.recordId ? [ctx.recordId] : [];\n      if (!ids.length) throw new Error('add_contact_to_campaign: no contact selected');\n      const raw = await ctx.api.object('crm_campaign_member').find({\n        where: { crm_campaign: campaignId },\n        fields: ['crm_contact'],\n        top: 5000,\n      });\n      const existingRows = Array.isArray(raw) ? raw : (raw?.records ?? []);\n      const existing = new Set(existingRows.map((r) => r.crm_contact));\n      const inserted = [];\n      let skipped = 0;\n      for (const contactId of ids) {\n        if (existing.has(contactId)) { skipped++; continue; }\n        const row = await ctx.api.object('crm_campaign_member').insert({\n          crm_campaign: campaignId,\n          crm_contact: contactId,\n          status: 'sent',\n        });\n        inserted.push(row?.id ?? null);\n      }\n      return { campaignId, count: inserted.length, skipped, ids: inserted };\n    `,\n    capabilities: ['api.read', 'api.write'],\n    timeoutMs: 10000,\n  },\n  locations: ['list_toolbar', 'list_item'],\n  params: [\n    {\n      field: 'crm_campaign',\n      objectOverride: 'crm_campaign_member',\n      label: 'Campaign',\n      required: true,\n    },\n  ],\n  // An opted-out contact must not be added to a campaign by hand either \u2014 the\n  // enrollment flow already filters them out, and a manual add-to-campaign is\n  // the obvious way around a filter nobody remembers is there. Same predicate\n  // the `send_email` action uses.\n  visible: P`has(record.email_opt_out) && record.email_opt_out == false`,\n  successMessage: 'Contacts added to campaign!',\n  refreshAfter: true,\n};\n\n/**\n * Send Email to Contact.\n *\n * Modal-typed action: collects subject + body, then logs an `activity`\n * record via the metadata body. Runs sandboxed under `api.write`.\n */\nexport const SendEmailAction: Action = {\n  name: 'send_email',\n  label: 'Send Email',\n  objectName: 'crm_contact',\n  icon: 'mail',\n  // script, not modal: modal submits die on GET /api/v1/meta/object/<target>\n  // \u2192 400 in 16.1.0; script actions POST /api/v1/actions/... and execute.\n  type: 'script',\n  body: {\n    language: 'js',\n    source: `\n      const record = ctx.record ?? {};\n      const recipientId = ctx.recordId ?? record.id ?? null;\n      const to = record.email ? String(record.email) : '';\n      const from = ctx.user?.email ?? 'noreply@hotcrm.local';\n      const userId = ctx.user?.id ?? null;\n      const subject = input.subject ? String(input.subject) : ('Email to ' + to);\n      const body = input.body ? String(input.body) : '';\n      const email = await ctx.api.object('sys_email').insert({\n        from_address: from,\n        to_addresses: to,\n        subject,\n        body_text: body,\n        status: 'queued',\n        related_object: 'crm_contact',\n        related_id: recipientId,\n        sent_by: userId,\n      });\n\n      ${ACTOR_NAME_RESOLUTION_SOURCE}\n\n      // Surface the email on the contact's unified activity timeline\n      // (the audit writer only logs generic CRUD; this is the semantic event).\n      const activity = await ctx.api.object('sys_activity').insert({\n        type: 'completed',\n        summary: 'Email: ' + subject,\n        actor_id: userId,\n        actor_name: actorName,\n        object_name: 'crm_contact',\n        record_id: recipientId,\n        record_label: record.full_name ?? record.name ?? to,\n        // ADR-0052 ActivityPointer: structured pointer to the rich source entity\n        // (the sys_email row) so the timeline renders a \"View source \u2192\" drill to\n        // the full email \u2014 the queryable replacement for stashing the id in metadata.\n        source_object: 'sys_email',\n        source_id: email?.id ?? null,\n        metadata: JSON.stringify({ kind: 'email', to, subject }),\n      });\n      // #592 scope item 3: every activity writer bumps interaction recency.\n      // An email is an interaction but NOT a calendar slot, so it writes no\n      // \\`crm_event\\` \u2014 which means it cannot ride the event hook's bubble and\n      // has to stamp the two timestamps itself. Both columns are deliberately\n      // non-readonly (see crm_account.last_activity_date's note): a readonly\n      // field is stripped from any non-system write whose caller supplied the\n      // key (#2948), and an action body runs under the sending rep's context.\n      if (recipientId) {\n        const nowIso = new Date().toISOString();\n        try {\n          await ctx.api.object('crm_contact').update(\n            { id: recipientId, last_contacted_date: nowIso },\n            { where: { id: recipientId } },\n          );\n        } catch (e) { /* best-effort recency; never fail the send */ }\n        const accountId = record.crm_account ? String(record.crm_account) : null;\n        if (accountId) {\n          try {\n            await ctx.api.object('crm_account').update(\n              { id: accountId, last_activity_date: nowIso.slice(0, 10) },\n              { where: { id: accountId } },\n            );\n          } catch (e) { /* best-effort recency; never fail the send */ }\n        }\n      }\n      return { emailId: email?.id, activityId: activity?.id };\n    `,\n    capabilities: ['api.read', 'api.write'],\n    timeoutMs: 5000,\n  },\n  locations: ['record_header', 'list_item'],\n  visible: P`has(record.email_opt_out) && record.email_opt_out == false`,\n  params: [\n    { name: 'subject', label: 'Subject', type: 'text', required: true },\n    { name: 'body', label: 'Body', type: 'textarea', required: true },\n  ],\n  refreshAfter: false,\n};\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/sales/actions/lead.actions.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/sales/actions\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/sales/actions/lead.actions.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport type { Action } from '@objectstack/spec/ui';\nimport { P } from '@objectstack/spec';\n\n/**\n * Convert Lead to Account, Contact, and Opportunity.\n *\n * Flow-typed action: invocation is delegated to the `lead_conversion`\n * flow defined under `src/sales/flows/`. The flow engine handles the screen\n * + server steps; no metadata body is required here.\n */\nexport const ConvertLeadAction: Action = {\n  name: 'convert_lead',\n  label: 'Convert Lead',\n  objectName: 'crm_lead',\n  icon: 'arrow-right-circle',\n  type: 'flow',\n  target: 'lead_conversion',\n  locations: ['record_header', 'list_item'],\n  // Convert is the lead's most basic outcome \u2014 surface it on ANY open lead\n  // (new / contacted / qualified), not just qualified. Gating to qualified-only\n  // hid the button on most seeded leads, so it read as \"conversion is missing\".\n  // Only already-converted or disqualified leads hide it.\n  //\n  // TOTALITY (AGENTS.md \u2192 \"Validation predicates must be TOTAL\", #630): every\n  // `record.x` read carries a `has(record.x)`, and the guards are arranged to\n  // fail CLOSED \u2014 an unknown record hides the button. That arrangement is a\n  // MEASUREMENT, not a preference. Measured in the browser on console 17.4.0 by\n  // instrumenting the shipped predicate evaluator: the record page evaluates this\n  // predicate twice against an EMPTY record (`record` is `{}`, zero keys) before\n  // the row lands, then re-evaluates it against the full row. So an absent\n  // `status` here means \"no record yet\", never \"a lead with no status\" \u2014 a lead\n  // with no status cannot exist, since `status` is `required` with\n  // `storage: { notNull: true }` and `defaultValue: 'new'` (src/sales/objects/lead.object.ts),\n  // and the REST payload this surface reads carries every declared column.\n  // Fail-open (`!has(record.status) || \u2026`) would therefore buy nothing and cost\n  // something real: Convert would flash on a disqualified lead for the\n  // pre-hydration beat, on an IRREVERSIBLE action.\n  // Unguarded, strict CEL aborted the whole predicate on those two renders\n  // (`[runtime] No such key: status`) and object-ui fell back to its own\n  // `fallback: false`, so this spelling states the policy the error path was\n  // already applying \u2014 minus the console warning on every lead page load. (#1890)\n  //\n  // \u26A0\uFE0F The approval term is the ONE fail-OPEN read in this predicate, and the\n  // asymmetry is deliberate rather than an oversight in an otherwise\n  // fail-closed arrangement (REQ-0005 step 7). The two terms above fail closed\n  // because an absent `status` means \"no record yet\" \u2014 a lead with no status\n  // cannot exist, since `status` is `required` with a `defaultValue`. An absent\n  // `conversion_approval_status` means something else entirely: a lead written\n  // before the column existed, which must convert the way it always did. And\n  // the shipped `not_required` default is the gate's OFF position, so treating\n  // \"not one of the two refusing verdicts\" as convertible is what makes the\n  // default install behave exactly as it did before this field. `lead.hook.ts`\n  // and `lead-conversion.flow.ts`'s `decision_approval` carry the same polarity\n  // \u2014 the three surfaces have to agree about what \"off\" means, or the button\n  // disappears on leads the write path would happily convert.\n  //\n  // \u26D4 Hiding this button is NOT the gate. It is the courtesy half; the control\n  // is the `beforeUpdate` refusal in `lead.hook.ts`, which a REST caller cannot\n  // route around.\n  visible: P`has(record.is_converted) && record.is_converted == false && has(record.status) && record.status != \"unqualified\" && record.status != \"converted\"\n    && (!has(record.conversion_approval_status) || (record.conversion_approval_status != \"pending\" && record.conversion_approval_status != \"rejected\"))`,\n  // NO `confirmText`. A screen flow IS the confirmation, and this one opens\n  // `Conversion Details` \u2014 a screen carrying the decision (`Create\n  // Opportunity?`, and the deal's name and amount), a Cancel button, and the\n  // suspected-duplicate warning that says something TRUE about THIS lead. A\n  // dialog in front of it costs every conversion one extra click to answer a\n  // question it cannot help anyone answer. Confirms are for DESTRUCTIVE actions\n  // with no follow-up UI \u2014 `close_case` / `escalate_case` in `case.actions.ts`\n  // are the shape that still earns one.\n  //\n  // Mechanism, measured on the console this app pinned at that taking\n  // (@objectstack/console 17.3.0, `dist/assets/`; this bundle read was \u26D4 NOT\n  // re-taken on any later pin \u2014 17.4.0, PR #1814, or 17.5.0) rather than\n  // assumed: the runner gates the dialog on\n  // the key's presence alone \u2014\n  //     if (action.confirmText && !await confirmHandler(evaluate(action.confirmText)))\n  //         return { success: false, error: 'Action cancelled by user' };\n  // \u2014 so REMOVING the key is what removes the dialog; there is no `confirm:\n  // false` to write, and no other key re-raises it.\n  successMessage: 'Lead converted successfully!',\n  refreshAfter: true,\n  // ADR-0011 \u2014 opt this Action in to AI, which materialises the\n  // `action_convert_lead` tool the `lead_qualification` skill references.\n  // Flow-typed with a target, so it has a headless path. `requiresConfirmation`\n  // is the only key the AI path reads: `actionLooksDestructive` consults\n  // `ai.requiresConfirmation` and nothing else, and the console's\n  // confirm-dialog string reached no AI code \u2014 so dropping `confirmText` above\n  // leaves the AI approval signal exactly where it was. The flag is SURFACED,\n  // not enforced \u2014 `list_actions` reports `requiresConfirmation: true` and the\n  // calling client decides what to do with it, while `run_action` dispatches\n  // the flow with no server-side pause. It warns the caller that this is\n  // irreversible; it is not a lock.\n  ai: {\n    exposed: true,\n    requiresConfirmation: true,\n    description:\n      'Converts a qualified lead into an account, contact and opportunity. Irreversible \u2014 requires human approval before it runs.',\n  },\n};\n\n/**\n * Schedule the next follow-up on a lead.\n *\n * The gap this fills: `log_call` / `log_meeting` record what already happened\n * (a `sys_activity` timeline entry), but nothing put the NEXT touch on the\n * rep's list. Filing that follow-up meant leaving the lead, opening the\n * Related tab, finding the Tasks block, and hand-picking the lead back as the\n * parent \u2014 four steps for the single most common thing a rep does after a call.\n *\n * Flow-typed, not `type: 'modal'`: modal actions are non-functional in 16.1.0\n * (the console resolves the action's `target` as an object name, so submitting\n * one dies on `GET /api/v1/meta/object/<target>` \u2192 400 \u2014 reproducible on the\n * pre-existing `log_call` too). The screen flow under\n * `src/sales/flows/schedule-followup.flow.ts` collects the same fields and does the\n * write; that mechanism is proven by `convert_lead` above.\n */\nexport const ScheduleFollowUpAction: Action = {\n  name: 'schedule_followup',\n  label: 'Schedule Follow-up',\n  objectName: 'crm_lead',\n  icon: 'calendar-plus',\n  type: 'flow',\n  target: 'schedule_followup',\n  locations: ['record_header', 'list_item'],\n  // A converted or disqualified lead has no next touch to schedule.\n  visible: P`has(record.is_converted) && record.is_converted == false && has(record.status) && record.status != \"unqualified\" && record.status != \"converted\"`,\n  successMessage: 'Follow-up scheduled.',\n  refreshAfter: true,\n  // ADR-0011 \u2014 materialises `action_schedule_followup` for the\n  // `lead_qualification` skill. Additive and reversible, so no approval gate.\n  ai: {\n    exposed: true,\n    description:\n      'Schedules the next follow-up task on a lead, assigned to its owner, so the next touch lands on the rep list.',\n  },\n};\n\n/**\n * Add selected leads to a Campaign.\n *\n * Script-typed action: collects a campaign id (param dialog) then writes one\n * `crm_campaign_member` record for the dispatched lead, skipping leads already\n * on the campaign. The chosen campaign arrives as `input.crm_campaign`; the\n * lead arrives as `ctx.recordId`.\n *\n * PER-RECORD dispatch, deliberately. `src/sales/views/lead.view.ts` wires this as the\n * BARE-STRING form \u2014 `bulkActions: ['create_campaign']` \u2014 and that string is a\n * dispatch contract, not a spelling of the other one:\n *\n *   - bare string    \u2192 the renderer promotes the action to a def carrying its\n *     own label / icon / params / `visible` and dispatches it ONCE PER selected\n *     row, each call carrying that row's `recordId` and NO selection array. A\n *     10-lead selection is 10 dispatches through this body, one lead each.\n *   - `bulkActionDefs` + `execution: 'aggregate'` \u2192 ONE dispatch for the whole\n *     selection, every id in the builtin `params._selectedIds` and no\n *     `recordId` (see `mass_update_stage` in `opportunity.actions.ts`).\n *\n * So multi-select enrollment already works here \u2014 it just arrives one lead at a\n * time. This body reads `ctx.recordId` and nothing else, which is exactly what\n * the fan-out delivers.\n *\n * \u26D4 Never add an `input.selectedIds` read (no underscore). Nothing can deliver\n * that key on either contract, so it is dead code and not a fallback: a\n * top-level `selectedIds` is never merged into the params bag, and a\n * `params.selectedIds` is refused by the strict params gate (ADR-0104) with\n * `Unknown action param \"selectedIds\" \u2014 not declared on this action`. The only\n * selection channel is the underscore-prefixed builtin, and only the aggregate\n * contract injects it (`@objectstack/spec` `ui/action-params.zod.ts`,\n * `ACTION_PARAM_BUILTIN_KEYS`).\n *\n * Switching this action to the aggregate contract would be a PRODUCT change \u2014\n * one audit entry and one dedupe read per run instead of per lead, and\n * all-or-nothing failure semantics \u2014 so it needs `lead.view.ts` changed with it\n * and is deliberately not done here.\n */\nexport const CreateCampaignAction: Action = {\n  name: 'create_campaign',\n  label: 'Add to Campaign',\n  objectName: 'crm_lead',\n  icon: 'send',\n  // script, not modal \u2014 a `type: 'modal'` action has NO server dispatch at all:\n  // the renderer just opens its `target`, and the runtime refuses it over REST\n  // (`headlessActionTypeError`, 400 \"a client-side action with no server\n  // dispatch\"), so its `body` never runs. To collect input and then run\n  // server-side, the shape is `type: 'script'` + `params` \u2014 the runner collects\n  // the same dialog. See ScheduleFollowUpAction.\n  type: 'script',\n  body: {\n    language: 'js',\n    source: `\n      // Value key = the param's field name ('crm_campaign') since the param\n      // omits an explicit 'name'. Insert uses the REAL lookup field names on\n      // crm_campaign_member (crm_campaign / crm_lead) \u2014 not the generic\n      // campaign_id / lead_id an earlier revision of the doc example taught,\n      // which don't exist here and left crm_campaign null \u2192 'Campaign required'\n      // validation failure.\n      const campaignId = input.crm_campaign ?? null;\n      if (!campaignId) throw new Error('create_campaign requires a campaign id');\n      // One lead per dispatch \u2014 the bare-string \\`bulkActions\\` wiring fans this\n      // body out once per selected row (see the note above). \\`ids\\` stays a\n      // list so the dedupe + skip loop below reads the same on both contracts,\n      // should this action ever move to an aggregate def.\n      const ids = ctx.recordId ? [ctx.recordId] : [];\n      if (!ids.length) throw new Error('create_campaign: no lead selected');\n      // Skip leads already on this campaign \u2014 the modal copy promises\n      // duplicates are skipped, and re-running the action on the same\n      // selection must not double-count marketing touches.\n      const raw = await ctx.api.object('crm_campaign_member').find({\n        where: { crm_campaign: campaignId },\n        fields: ['crm_lead'],\n        top: 5000,\n      });\n      const existingRows = Array.isArray(raw) ? raw : (raw?.records ?? []);\n      const existing = new Set(existingRows.map((r) => r.crm_lead));\n      const inserted = [];\n      let skipped = 0;\n      for (const leadId of ids) {\n        if (existing.has(leadId)) { skipped++; continue; }\n        const row = await ctx.api.object('crm_campaign_member').insert({\n          crm_campaign: campaignId,\n          crm_lead: leadId,\n          status: 'sent',\n        });\n        inserted.push(row?.id ?? null);\n      }\n      return { campaignId, count: inserted.length, skipped, ids: inserted };\n    `,\n    capabilities: ['api.read', 'api.write'],\n    timeoutMs: 10000,\n  },\n  // list_item gives every row a working record-scoped entry point. The\n  // list_toolbar button is single-record by construction: with no `_selectedIds`\n  // in the bag the dispatcher resolves a recordId from the grid selection, and a\n  // multi-row selection there is ambiguous, so it is refused client-side with\n  // \"This action runs on a single record \u2014 select exactly one row.\"\n  // Multi-lead enrollment is the SELECTION-BAR button instead, which the view's\n  // `bulkActions: ['create_campaign']` produces and which fans out per row.\n  locations: ['list_toolbar', 'list_item'],\n  params: [\n    // Field-backed param: `field` + `objectOverride` make the console resolve\n    // the widget from crm_campaign_member.crm_campaign (a lookup \u2192 crm_campaign),\n    // rendering a RECORD PICKER. A bare `{ type:'lookup' }` with no field can't\n    // resolve a target object and silently falls back to a paste-the-ID textbox.\n    {\n      field: 'crm_campaign',\n      objectOverride: 'crm_campaign_member',\n      label: 'Campaign',\n      required: true,\n    }\n  ],\n  successMessage: 'Leads added to campaign!',\n  refreshAfter: true,\n};\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/sales/actions/opportunity.actions.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/sales/actions\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/sales/actions/opportunity.actions.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport type { Action } from '@objectstack/spec/ui';\nimport { P } from '@objectstack/spec';\nimport { OPPORTUNITY_STAGE_OPTIONS, plainOptions } from '../objects/_picklists';\n\n/**\n * Clone Opportunity.\n *\n * Script-typed action: clones the current record into a new\n * `prospecting`-stage opportunity. Runs sandboxed under `api.read`\n * (to fetch the source) and `api.write` (to write the copy).\n */\nexport const CloneOpportunityAction: Action = {\n  name: 'clone_opportunity',\n  label: 'Clone Opportunity',\n  objectName: 'crm_opportunity',\n  icon: 'copy',\n  type: 'script',\n  body: {\n    language: 'js',\n    source: `\n      const id = ctx.recordId;\n      if (!id) throw new Error('clone_opportunity requires a recordId');\n      // Read the source from ctx.record (seeded by the runner for record-scoped\n      // actions \u2014 same source send_email uses). This avoids the in-sandbox\n      // find() that previously faulted, WHILE still copying the REQUIRED fields\n      // (crm_account / amount / close_date). The old minimal insert set only\n      // name+stage, so every clone failed the object's required-field + amount>0\n      // validations at runtime and no opportunity was ever created.\n      const src = ctx.record ?? {};\n      if (!src.crm_account) {\n        throw new Error('clone_opportunity: source account not loaded; cannot clone.');\n      }\n      // Give the clone a fresh 90-day close horizon so a copied past date can't\n      // trip the \"close date in the past\" validation on a new prospecting deal.\n      //\n      // The step is on the UTC calendar because the render below is\n      // (\\`toISOString()\\`). The base is \\`new Date()\\` \u2014 an instant, not a\n      // stored \\`YYYY-MM-DD\\` \u2014 so unlike quote.hook/task.hook there is no\n      // UTC-midnight anchor being read back on the wrong calendar here; the\n      // only mixture was the step itself. A local \\`getDate\\`/\\`setDate\\` step\n      // preserves WALL-CLOCK time, so a 90-day window containing a DST\n      // transition is 23 h or 25 h long and the rendered UTC day lands one off\n      // whenever the clone instant is within an hour of a UTC day boundary.\n      const horizon = new Date();\n      horizon.setUTCDate(horizon.getUTCDate() + 90);\n      const inserted = await ctx.api.object('crm_opportunity').insert({\n        name: 'Copy of ' + (src.name ?? ('opportunity ' + id)),\n        crm_account: src.crm_account,\n        primary_contact: src.primary_contact ?? null,\n        amount: src.amount ?? 1,\n        stage: 'prospecting',\n        probability: 10,\n        close_date: horizon.toISOString().slice(0, 10),\n        type: src.type ?? null,\n        lead_source: src.lead_source ?? null,\n        crm_campaign: src.crm_campaign ?? null,\n        // Explicit because an action body runs \\`isSystem\\`, so nothing stamps\n        // \\`owner_id\\` for it \u2014 see the note in activity-actions.ts (#548).\n        owner_id: ctx.user?.id ?? null,\n      });\n      return { id: inserted?.id ?? null };\n    `,\n    capabilities: ['api.read', 'api.write'],\n    timeoutMs: 5000,\n  },\n  locations: ['record_header', 'record_more'],\n  successMessage: 'Opportunity cloned successfully!',\n  refreshAfter: true,\n};\n\n/**\n * Mass Update Opportunity Stage.\n *\n * Both invocation halves work:\n *\n *   - SINGLE record (row selection / toolbar with one row): the console POSTs\n *     `{ recordId, params: { stage } }` and the body reads `ctx.recordId`.\n *   - MULTI record: the selection arrives in the BUILT-IN `_selectedIds`\n *     param \u2014 leading underscore \u2014 injected by the grid renderer for the\n *     view's `bulkActionDefs` entry with `execution: 'aggregate'`, which\n *     dispatches this action ONCE for the whole selection (no `recordId`).\n *\n * That underscore is the whole of the contract. A script body's `input` IS the\n * action's params bag (`@objectstack/runtime` `sandbox/body-runner.ts:338`), and\n * `_selectedIds` is one of the params gate's builtin keys (`@objectstack/spec`\n * `ui/action-params.zod.ts:70`, alongside `recordId` / `objectName`). Every\n * other shape is undeclared and cannot arrive: a top-level `selectedIds` is\n * never merged into the bag, and a `params.selectedIds` without the underscore\n * is refused by the strict params gate (ADR-0104). The console's own \"select\n * exactly one row\" toast fires precisely when `_selectedIds` was NOT injected,\n * which is what happens to a view carrying no bulk declaration at all \u2014 read\n * that toast as a missing declaration on the view, never as a platform limit.\n *\n * \u26D4 Do NOT declare `_selectedIds` in `params` below: builtin keys are injected\n * by the renderer, and the gate admits them without a declaration (declaring one\n * is not a supported authoring move). \u26D4 Do NOT re-add a no-underscore\n * `input.selectedIds` read either \u2014 nothing can deliver that key, so it would\n * be a limb that only ever reads `undefined`.\n */\nexport const MassUpdateStageAction: Action = {\n  name: 'mass_update_stage',\n  label: 'Update Stage',\n  objectName: 'crm_opportunity',\n  icon: 'layers',\n  type: 'script',\n  body: {\n    language: 'js',\n    source: `\n      const newStage = input.stage ?? null;\n      if (!newStage) throw new Error('mass_update_stage requires a stage');\n      // Selection first, single record as the fallback. An aggregate dispatch\n      // carries the whole selection in \\`_selectedIds\\` and NO recordId; a\n      // single-record dispatch carries recordId and no selection. The two are\n      // never both present, so the order only decides which shape wins if the\n      // platform ever sends both.\n      const selected = Array.isArray(input._selectedIds) ? input._selectedIds : [];\n      const ids = selected.length ? selected : (ctx.recordId ? [ctx.recordId] : []);\n      if (!ids.length) throw new Error('mass_update_stage: no opportunity selected');\n      const missed = [];\n      let firstCause = '';\n      let updated = 0;\n      for (const id of ids) {\n        // \\`update(data, options)\\` \u2014 \\`ctx.api\\` is the engine repo facade, whose\n        // update takes a DOCUMENT, not an id. \\`updateById(id, data)\\` exists on\n        // ObjectRepository but NOT on the facade the runtime builds when it has\n        // no scoped context, so this spelling is the only one live on both.\n        //\n        // An id that matches no row is a MISS, not an abort, and the engine has\n        // answered it both ways: through @objectstack/* 17.0.0-rc.6 \\`update\\`\n        // RESOLVED WITH NULL, and from 17.0.0 it REJECTS (RECORD_NOT_FOUND /\n        // 404). Both are handled here, and neither may end the loop \u2014 an\n        // uncaught rejection on the first stale id would leave every id after\n        // it unattempted, so re-running the action over the same selection\n        // would fail at the same row forever and the live rows behind it could\n        // never be covered. That is strictly worse than the silent-success\n        // failure #588 pulled this button for, because it is unrecoverable\n        // from the UI. Collect the miss, keep going, reject once at the end.\n        //\n        // The catch is deliberately cause-AGNOSTIC \u2014 but NOT because the cause\n        // is invisible. Read on 17.4.0 (\\`hostErrorToVm\\`; not re-read on 17.5.0), a host\n        // rejection reaches a body as \\`name\\` and \\`message\\` plus, when the host\n        // error carries them, \\`code\\`, \\`status\\`, \\`fields\\` and \\`userMessage\\` \u2014\n        // nothing else, so a stale id arrives branchable as\n        // \\`code === 'RECORD_NOT_FOUND'\\` while \\`details\\` really is dropped. The\n        // branch is not taken because every cause has the same outcome here \u2014\n        // the row did not move, so collect it and keep going \u2014 and narrowing\n        // the catch to a roster of known codes would let an unlisted cause\n        // abort the loop, the failure the paragraph above forbids. Message text\n        // is engine wording and not contract, so \\`firstCause\\` is carried\n        // verbatim and never parsed.\n        let row = null;\n        try {\n          row = await ctx.api.object('crm_opportunity').update(\n            { id: id, stage: newStage },\n            { where: { id: id } },\n          );\n        } catch (err) {\n          row = null;\n          if (!firstCause) firstCause = (err && err.message) ? String(err.message) : String(err);\n        }\n        // Count only what came back: counting the ATTEMPT is how a stale or\n        // invisible id turns into a success toast for a write that never\n        // happened (#588).\n        if (row) { updated++; } else { missed.push(id); }\n      }\n      // Aggregate dispatch is all-or-nothing (objectui#3139): a handler that\n      // cannot cover the whole selection must reject rather than report partial\n      // work, because the bar offers no per-row retry \u2014 the retry IS re-running\n      // the action over the selection, which is safe here since setting a stage\n      // is idempotent. Rows already moved in this run keep the new stage; the\n      // error names the ones that did not so the rep can see the difference.\n      if (missed.length) {\n        throw new Error(\n          'mass_update_stage: ' + missed.length + ' of ' + ids.length\n          + ' selected opportunities could not be updated (' + missed.join(', ')\n          + '). Re-run the action on the selection to retry.'\n          + (firstCause ? ' First cause: ' + firstCause : '')\n        );\n      }\n      return { stage: newStage, updated };\n    `,\n    capabilities: ['api.write'],\n    timeoutMs: 10000,\n  },\n  locations: ['list_toolbar'],\n  params: [\n    {\n      name: 'stage',\n      label: 'New Stage',\n      type: 'select',\n      required: true,\n      // Mirrors crm_opportunity.stage exactly \u2014 see _picklists.ts.\n      options: plainOptions(OPPORTUNITY_STAGE_OPTIONS),\n    }\n  ],\n  successMessage: 'Opportunities updated successfully!',\n  refreshAfter: true,\n};\n\n/**\n * Generate a Quote from this Opportunity.\n *\n * Flow-typed action: launches the `quote_generation` screen flow (name,\n * validity, discount) which creates the draft crm_quote and moves the deal\n * to `proposal`. Without this action the flow was unreachable from the UI \u2014\n * the CPQ leg (opportunity \u2192 quote) had no entry point.\n */\nexport const GenerateQuoteAction: Action = {\n  name: 'generate_quote',\n  label: 'Generate Quote',\n  objectName: 'crm_opportunity',\n  icon: 'receipt',\n  type: 'flow',\n  target: 'quote_generation',\n  // Mirror clone_opportunity's placement (header + overflow menu) so the action\n  // is reachable both as a primary button and from the \"\u2026\" menu on narrow\n  // viewports where the header collapses.\n  locations: ['record_header', 'record_more', 'list_item'],\n  visible: P`has(record.stage) && record.stage != \"closed_won\" && record.stage != \"closed_lost\"`,\n  successMessage: 'Quote created from opportunity!',\n  refreshAfter: true,\n};\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/marketing/actions/index.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/marketing/actions\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/marketing/actions/index.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\n/**\n * Marketing action barrel.\n *\n * The doctrine for this metadata type is written once, in\n * `src/sales/actions/index.ts`; this file is the marketing package's half of\n * the same file-by-file registration.\n */\nexport { EnrollLeadsAction, MarkRespondedAction } from './campaign.actions';\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/marketing/actions/campaign.actions.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/marketing/actions\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/marketing/actions/campaign.actions.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport type { Action } from '@objectstack/spec/ui';\nimport { P } from '@objectstack/spec';\n\n/**\n * Enroll leads or contacts into this campaign.\n *\n * Flow-typed action: launches the `campaign_enrollment` screen flow (pick the\n * member side and its segment, enroll everyone eligible). This action is the\n * flow's entry point, following the proven `convert_lead` / `generate_quote`\n * pattern \u2014 the console's flow-action trigger sends `{ recordId, objectName }`.\n *\n * \u26D4 Never rename `enroll_leads` to match the \"Enroll Members\" label. An action\n * name is a dispatch identifier that views, docs and the audit trail reference\n * by string; the label already carries the word correctly.\n */\nexport const EnrollLeadsAction: Action = {\n  name: 'enroll_leads',\n  label: 'Enroll Members',\n  objectName: 'crm_campaign',\n  icon: 'user-plus',\n  type: 'flow',\n  target: 'campaign_enrollment',\n  locations: ['record_header', 'record_more'],\n  // Enrollment only makes sense while the campaign is open \u2014 the flow\n  // double-checks this server-side.\n  visible: P`has(record.status) && (record.status == \"planning\" || record.status == \"in_progress\")`,\n  successMessage: 'Eligible members enrolled in campaign.',\n  refreshAfter: true,\n};\n\n/**\n * Mark a campaign member as having responded.\n *\n * The writer for the `responded` status, on the member row rather than on the\n * campaign: a rep hears back from one person, and one membership changes.\n * `num_responses` and `response_rate` are computed off that status, so an app\n * with no writer for it reports a structural zero on every campaign.\n *\n * The body stamps all three response fields together, rather than relying on\n * `campaign_member_lifecycle` to back-fill two of them. Both paths are\n * exercised (a rep can also flip `status` on the record itself, which the hook\n * catches) but an action that writes a status and leaves the record internally\n * inconsistent for the length of a hook dispatch is a shape the detail page can\n * render mid-flight, and this one is cheap to get right at the source.\n *\n * `record_header` + `list_item`: `crm_campaign_member` ships no view of its\n * own \u2014 its rows are surfaced by the members related list on a campaign's\n * detail page (columns come from `highlightFields`), and `list_item` is the\n * per-row entry point there.\n */\nexport const MarkRespondedAction: Action = {\n  name: 'mark_responded',\n  label: 'Mark Responded',\n  objectName: 'crm_campaign_member',\n  icon: 'reply',\n  // script, not modal \u2014 a `type: 'modal'` action has no server dispatch at all\n  // and its body never runs (see `create_campaign`'s note in lead.actions.ts).\n  type: 'script',\n  body: {\n    language: 'js',\n    source: `\n      const id = ctx.recordId;\n      if (!id) throw new Error('mark_responded requires a recordId');\n      const respondedAt = new Date().toISOString();\n      await ctx.api.object('crm_campaign_member').update(\n        { id, status: 'responded', has_responded: true, response_date: respondedAt },\n        { where: { id } },\n      );\n      return { id, status: 'responded', response_date: respondedAt };\n    `,\n    capabilities: ['api.write'],\n    timeoutMs: 5000,\n  },\n  locations: ['record_header', 'list_item'],\n  // Already-responded and converted members have nothing to record; an\n  // unsubscribed member must not be dragged back into the funnel by a\n  // mis-click (`campaign_member_optout_sync` has already opted that person out\n  // of email, and this action would not undo that \u2014 leaving the two records\n  // disagreeing about the same person).\n  visible: P`has(record.status) && record.status == \"sent\"`,\n  successMessage: 'Response recorded on this campaign member.',\n  refreshAfter: true,\n};\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/sales/dashboards/index.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/sales/dashboards\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/sales/dashboards/index.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\n/**\n * Dashboard Definitions Barrel\n *\n * ## Two i18n surfaces on a dashboard, and only one of them resolves (#1822)\n *\n * `@objectstack/spec` types BOTH `GlobalFilterSchema.label` and\n * `ChartAxisSchema.title` as `I18nLabelSchema` \u2014 `z.union([z.string(),\n * InlineLocaleMapSchema])` \u2014 so both accept `{ en, 'zh-CN', \u2026 }`. Only the\n * filter half is resolved against the viewer's locale. Measured on\n * `@objectstack/console@17.4.0`, driving the real Console in Chromium, not\n * read off a docblock:\n *\n *   - FILTER `label` and static option `label` \u2192 locale-aware. The renderer\n *     calls the inline-map resolver with the active language, so `zh-CN`\n *     renders the `zh-CN` value and `ja-JP` the `ja-JP` one. This is the\n *     spelling every `globalFilters[]` entry in this folder uses.\n *   - AXIS `title` \u2192 NOT locale-aware on 17.4.0 (the axis normaliser took the\n *     map's FIRST value, whatever the viewer's locale). Since\n *     `@objectstack/spec@17.5.0` the question no longer arises for this\n *     folder: a dataset-bound widget's `chartConfig` refuses `type`, `xAxis`,\n *     `yAxis` and `series` (ADR-0021 \u00B7 ADR-0049 D2) \u2014 the widget's `type`,\n *     `dimensions` and `values` are the only binding \u2014 so no widget here\n *     carries an axis title any more.\n *\n * \u26A0\uFE0F `GlobalFilterSchema.object` \u2014 documented upstream as resolving a\n * filter's field and option labels through `fields.<object>.<field>` \u2014 is\n * INERT in this Console build. Measured: a filter carrying `object` and no\n * `label` rendered the raw field name (`type`, not \u7C7B\u578B) and left its option\n * labels English. The definition builder never copies `object` out of the\n * authored filter. \u26D4 Do not reach for it instead of an inline map.\n */\n\nexport { ActivityDashboard } from './activity.dashboard';\nexport { CrmOverviewDashboard } from './crm.dashboard';\nexport { ExecutiveDashboard } from './executive.dashboard';\nexport { SalesDashboard } from './sales.dashboard';\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/sales/dashboards/activity.dashboard.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/sales/dashboards\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/sales/dashboards/activity.dashboard.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport type { Dashboard } from '@objectstack/spec/ui';\n\n/**\n * Sales Activity & Customer Health Dashboard (#592).\n *\n * The app had **no activity metric of any kind**: calls per rep, meetings\n * booked and activity per deal were unanswerable because the only trace of an\n * interaction was a `sys_activity` row with the interesting part inside a JSON\n * string, and `task_metrics` had shipped with no widget using it at all. This\n * dashboard is what `crm_event` makes possible, and it is where the churn story\n * finally has numbers behind it.\n *\n * # No `dateRange`, deliberately \u2014 a design choice, not a blocked one\n *\n * `crm_event.start_datetime` is a `Field.datetime()`, the exact column shape\n * that once zeroed the Service dashboard (#460): `driver-sql` 16.1.0 coerced a\n * datetime filter bound to epoch-millisecond INTEGER while every datetime in\n * the database is ISO TEXT, and SQLite orders every INTEGER before every TEXT \u2014\n * so `$gte` matched every row (no floor) and `$lte` matched none (empty\n * dashboard). That is history, not a live constraint. Both named preconditions\n * are fixed and released: objectstack#3912 (the coercion) and objectstack#3777\n * (a bare-date `$lte` dropping same-day rows) \u2014 both under the **17.0.0**\n * heading of the installed `driver-sql` and `service-analytics` CHANGELOGs,\n * and every pin since 17.0.0 carries both. `service.dashboard.ts` records\n * the same two\n * closures, which is why #1157 restored the Service picker; the two files\n * agree, and neither states an upstream fix as an unmet precondition.\n *\n * The reason this dashboard still carries no picker is therefore a PRODUCT\n * one, and it stands on its own: both questions a date range would answer are\n * already answered here, by widgets a dashboard range would narrow rather than\n * serve \u2014 the runtime ANDs `dateRange` into every widget query.\n *\n *   - The trend is on an AXIS, not in a filter. `activity_by_week` groups on\n *     the `event_metrics.start_datetime` dimension, which declares\n *     `dateGranularity: 'week'`; \"is the team speeding up or going quiet?\" is\n *     read ACROSS the history, so a picker would truncate the axis that is the\n *     whole point of the chart.\n *   - Recency is already SELF-SCOPED. The three quiet-account tiles each carry\n *     their own window on `crm_account.last_activity_date` \u2014 `$lt`\n *     `{30_days_ago}` / `{60_days_ago}` / `{90_days_ago}` \u2014 and \"quiet for 90\n *     days\" means ninety days, not ninety days re-cut by whatever the picker\n *     says. On the sibling dashboards that DO have one, that is spelled\n *     `filterBindings: { dateRange: false }`; here it would have to be spelled\n *     on every tile that matters.\n *\n * \u21D2 Adding a picker is a product judgement to be made on its merits, not a\n * platform unblock to be collected. If it is ever made, the work is a\n * `dateRange` plus explicit `filterBindings` opt-outs on the widgets above.\n *\n * No KPI tile declares a `trend`: a period-over-period delta is a measurement\n * and has to come from a real comparison query, not from a number typed by\n * hand (#500, #587).\n */\nexport const ActivityDashboard: Dashboard = {\n  name: 'sales_activity_dashboard',\n  label: 'Sales Activity',\n  description: 'Who is talking to customers, how often, and which accounts have gone quiet',\n\n  columns: 12,\n  gap: 4,\n  refreshIntervalSeconds: 300,\n\n  header: {\n    showTitle: true,\n    showDescription: true,\n  },\n\n  globalFilters: [\n    {\n      field: 'owner_id',\n      label: { en: 'Rep', 'zh-CN': '\u9500\u552E\u4EE3\u8868', 'es-ES': 'Representante', 'ja-JP': '\u62C5\u5F53\u8005' },\n      type: 'lookup',\n      scope: 'dashboard',\n      optionsFrom: { object: 'sys_user', valueField: 'id', labelField: 'name' },\n    },\n  ],\n\n  widgets: [\n    // \u2500\u2500\u2500 Row 1: what happened, and what is booked \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n    {\n      id: 'interactions_held',\n      title: 'Interactions Logged',\n      description: 'Calls and meetings that actually happened',\n      type: 'metric',\n      filter: { status: 'held' },\n      colorVariant: 'success',\n      dataset: 'event_metrics', values: ['event_count'],\n      layout: { x: 0, y: 0, w: 3, h: 2 },\n    },\n    {\n      id: 'meetings_booked',\n      title: 'Meetings Booked',\n      description: 'Meetings on the calendar that have not happened yet',\n      type: 'metric',\n      filter: { status: 'planned', type: 'meeting' },\n      colorVariant: 'blue',\n      dataset: 'event_metrics', values: ['event_count'],\n      layout: { x: 3, y: 0, w: 3, h: 2 },\n    },\n    {\n      id: 'customer_minutes',\n      title: 'Customer Minutes',\n      description: 'Total time spent in front of customers',\n      type: 'metric',\n      filter: { status: 'held' },\n      colorVariant: 'purple',\n      dataset: 'event_metrics', values: ['total_minutes'],\n      layout: { x: 6, y: 0, w: 3, h: 2 },\n    },\n    {\n      // First widget in the app to use `task_metrics`. The dataset shipped with\n      // the \"My Day\" work and then had no consumer at all (#592) \u2014 a semantic\n      // layer nobody queries is a maintenance cost with no reader.\n      id: 'tasks_completed',\n      title: 'Tasks Completed',\n      description: 'Follow-ups closed out \u2014 the other half of activity',\n      type: 'metric',\n      filter: { is_completed: true },\n      colorVariant: 'orange',\n      dataset: 'task_metrics', values: ['task_count'],\n      layout: { x: 9, y: 0, w: 3, h: 2 },\n    },\n\n    // \u2500\u2500\u2500 Row 2: who, and when \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n    {\n      id: 'activity_by_rep',\n      title: 'Activity by Rep',\n      description: 'Logged interactions per owner \u2014 the coverage question',\n      type: 'bar',\n      filter: { status: 'held' },\n      colorVariant: 'success',\n      dataset: 'event_metrics', dimensions: ['owner'], values: ['event_count'],\n      layout: { x: 0, y: 2, w: 6, h: 4 },\n      chartConfig: {\n        showLegend: false,\n        showDataLabels: true,\n        colors: ['#10B981'],\n      },\n    },\n    {\n      id: 'activity_by_week',\n      title: 'Activity Volume by Week',\n      description: 'Interactions per week \u2014 is the team speeding up or going quiet?',\n      type: 'area',\n      filter: { status: 'held' },\n      colorVariant: 'blue',\n      // The week bucket lives on the DIMENSION, not in a filter \u2014 see the\n      // header note on why the trend belongs on an axis here. The datetime\n      // filter bound itself works (objectstack#3912 / #3777, 17.0.0); putting\n      // the trend in a filter would narrow it, which is a different objection.\n      dataset: 'event_metrics', dimensions: ['start_datetime'], values: ['event_count'],\n      layout: { x: 6, y: 2, w: 6, h: 4 },\n      chartConfig: {\n        showLegend: false,\n        showDataLabels: false,\n        colors: ['#0EA5E9'],\n        interaction: { tooltips: true, brush: true },\n      },\n    },\n\n    // \u2500\u2500\u2500 Row 3: what the activity is about \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n    {\n      id: 'activity_mix',\n      title: 'Activity Mix',\n      description: 'Calls vs meetings vs demos',\n      type: 'donut',\n      filter: { status: 'held' },\n      colorVariant: 'purple',\n      dataset: 'event_metrics', dimensions: ['type'], values: ['event_count'],\n      layout: { x: 0, y: 6, w: 4, h: 4 },\n      chartConfig: {\n        showLegend: true,\n        showDataLabels: true,\n        colors: ['#4169E1', '#10B981', '#8B5CF6', '#F59E0B', '#0EA5E9', '#94A3B8'],\n      },\n    },\n    {\n      id: 'activity_by_record_type',\n      title: 'Where the Activity Lands',\n      description: 'Which part of the funnel is getting attention',\n      type: 'bar',\n      filter: { status: 'held' },\n      colorVariant: 'blue',\n      dataset: 'event_metrics', dimensions: ['related_to_type'], values: ['event_count'],\n      layout: { x: 4, y: 6, w: 4, h: 4 },\n      chartConfig: {\n        showLegend: false,\n        showDataLabels: true,\n        colors: ['#4169E1'],\n      },\n    },\n    {\n      // \"Activity per open deal\" as two honest numbers rather than one\n      // fabricated ratio: the semantic layer has no cross-dataset calculated\n      // measure, so a single \"1.8 activities/deal\" tile would have to be\n      // computed by the renderer over two independent queries \u2014 which nothing\n      // does today. A manager reads the pair; a made-up quotient would read as\n      // measured. Filed as a follow-up rather than faked here.\n      id: 'deal_activity',\n      title: 'Interactions on Deals',\n      description: 'Logged interactions linked to an opportunity \u2014 read against Open Deals \u2192',\n      type: 'metric',\n      filter: { status: 'held', related_to_type: 'crm_opportunity' },\n      colorVariant: 'success',\n      dataset: 'event_metrics', values: ['event_count'],\n      layout: { x: 8, y: 6, w: 2, h: 4 },\n    },\n    {\n      id: 'open_deals_for_activity',\n      title: 'Open Deals',\n      description: 'Opportunities still in play',\n      type: 'metric',\n      filter: { stage: { $nin: ['closed_won', 'closed_lost'] } },\n      colorVariant: 'blue',\n      dataset: 'opportunity_metrics', values: ['opp_count'],\n      layout: { x: 10, y: 6, w: 2, h: 4 },\n    },\n\n    // \u2500\u2500\u2500 Row 4: the churn story, now backed by a real signal \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n    // These window `crm_account.last_activity_date`, which is a `Field.date()`\n    // (TEXT `YYYY-MM-DD`) \u2014 the same shape `customer_churn_signals` already\n    // filters safely. Until #592 the column was written by nothing at all: the\n    // bubble that fed it was silently discarded on every invocation because\n    // the field was `readonly` (#2948). These three tiles are the reason that\n    // mattered.\n    {\n      id: 'quiet_accounts_30',\n      title: 'Quiet 30+ Days',\n      description: 'Active accounts with no logged interaction in a month',\n      type: 'metric',\n      filter: { is_active: true, last_activity_date: { $lt: '{30_days_ago}' } },\n      colorVariant: 'warning',\n      dataset: 'account_metrics', values: ['account_count'],\n      layout: { x: 0, y: 10, w: 4, h: 2 },\n    },\n    {\n      id: 'quiet_accounts_60',\n      title: 'Quiet 60+ Days',\n      description: 'Two months of silence \u2014 the at-risk threshold',\n      type: 'metric',\n      filter: { is_active: true, last_activity_date: { $lt: '{60_days_ago}' } },\n      colorVariant: 'orange',\n      dataset: 'account_metrics', values: ['account_count'],\n      layout: { x: 4, y: 10, w: 4, h: 2 },\n    },\n    {\n      id: 'quiet_accounts_90',\n      title: 'Quiet 90+ Days',\n      description: 'A quarter with no contact \u2014 intervene or write it off',\n      type: 'metric',\n      filter: { is_active: true, last_activity_date: { $lt: '{90_days_ago}' } },\n      colorVariant: 'danger',\n      dataset: 'account_metrics', values: ['account_count'],\n      layout: { x: 8, y: 10, w: 4, h: 2 },\n    },\n  ],\n};\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/sales/dashboards/shared-widgets.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/sales/dashboards\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/sales/dashboards/shared-widgets.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport type { Dashboard } from '@objectstack/spec/ui';\n\ntype Widget = Dashboard['widgets'][number];\ntype WidgetLayout = Widget['layout'];\n\n/**\n * Widgets shared verbatim across dashboards.\n *\n * The pipeline funnel appeared word-for-word in the CRM, Sales and Executive\n * dashboards, and the avg-deal-size KPI in CRM and Sales \u2014 three copies of\n * \"what counts as open pipeline\" that could (and did) drift independently.\n * Each factory owns the semantic definition once; callers position it with\n * `layout` and may narrow presentation-only details via `overrides`.\n */\n\n/**\n * Open-pipeline funnel by sales stage \u2014 identical semantics everywhere.\n *\n * No `chartConfig`: a dataset-bound widget is painted with the console's own\n * theme tokens, so the palette this factory used to declare never applied.\n * Verified in the browser against 16.1.0 \u2014 every fill in the rendered funnel is\n * `hsl(var(--chart-1))` \u2026 `hsl(var(--chart-5))`, and none of the five hex colors\n * (`#0EA5E9` \u2026 `#22C55E`) reaches the DOM. Keeping the block would leave\n * decoration that reads as if it were in effect (#500).\n *\n * No `colorVariant` either, on the same evidence: the executive dashboard's KPI\n * tiles declare four different variants (`success`, `blue`, `purple`, `orange`)\n * and render with byte-identical background, border and value colours.\n */\nexport const pipelineByStageFunnelWidget = (layout: WidgetLayout): Widget => ({\n  id: 'pipeline_by_stage',\n  title: 'Pipeline by Stage',\n  description: 'Open opportunity value at each sales stage',\n  type: 'funnel',\n  filter: { stage: { $nin: ['closed_won', 'closed_lost'] } },\n  dataset: 'opportunity_metrics', dimensions: ['stage'], values: ['total_amount'],\n  layout,\n  suppressWarnings: ['chart-config-missing'], // intentional default rendering\n});\n\n/**\n * Avg-deal-size KPI over closed-won deals. The measure is fixed; the time\n * scoping legitimately differs per dashboard (CRM follows the dashboard date\n * picker, Sales pins itself to QTD), so callers pass it in.\n *\n * No drill-through: `/reports/avg-deal-size` matched no registered report, and\n * no report covers average deal size, so the button was dead on every dashboard\n * that used this factory (#527). Re-add one here when such a report ships \u2014\n * sharing the widget means sharing the fix.\n */\nexport const avgDealSizeMetricWidget = (\n  layout: WidgetLayout,\n  overrides: Partial<Widget> = {},\n): Widget => ({\n  id: 'avg_deal_size',\n  title: 'Avg Deal Size',\n  description: 'Average value of closed-won deals',\n  type: 'metric',\n  filter: { stage: 'closed_won' },\n  colorVariant: 'orange',\n  dataset: 'opportunity_metrics', values: ['avg_amount'],\n  layout,\n  ...overrides,\n});\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/sales/dashboards/crm.dashboard.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/sales/dashboards\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/sales/dashboards/crm.dashboard.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport type { Dashboard } from '@objectstack/spec/ui';\nimport { avgDealSizeMetricWidget, pipelineByStageFunnelWidget } from './shared-widgets';\n\n/**\n * CRM Overview Dashboard\n *\n * Single-page snapshot of revenue, pipeline, and customer activity. Designed\n * to mirror the polished CRM dashboard reference at\n * https://github.com/objectstack-ai/objectui/tree/main/examples/crm/src/dashboards\n * \u2014 KPI tiles, an area-chart revenue trend, a lead-source donut, a\n * pipeline funnel, and a recent-deals table.\n *\n * This dashboard intentionally uses the framework's first-class metadata fields\n * (colorVariant, chartConfig, header, dateRange, descriptions, action buttons)\n * rather than ad-hoc hex strings stuffed into `options.color`.\n *\n * No KPI tile declares a `trend`. A period-over-period delta is a measurement,\n * so it has to come from a real comparison query (widget `compareTo`) once the\n * renderer supports it for dataset metrics \u2014 the percentages this file used to\n * carry were typed by hand and recomputed by nothing, so they kept asserting\n * the same \"+12.5% vs last month\" on any data, including an empty database.\n * Same rule as the executive dashboard (#500, #587).\n */\nexport const CrmOverviewDashboard: Dashboard = {\n  name: 'crm_overview_dashboard',\n  label: 'CRM Overview',\n  description: 'Revenue metrics, pipeline analytics, and deal insights',\n\n  columns: 12,\n  gap: 4,\n  refreshIntervalSeconds: 300,\n\n  header: {\n    showTitle: true,\n    showDescription: true,\n    // Header action buttons removed: `create_opportunity` / `create_lead` are not\n    // defined actions and `/reports` is not an in-app view route \u2014 all three were\n    // dead. Re-add real, wired-up actions here when available.\n  },\n\n  dateRange: {\n    field: 'close_date',\n    defaultRange: 'this_quarter',\n    allowCustomRange: true,\n  },\n\n  globalFilters: [\n    {\n      field: 'owner_id',\n      label: { en: 'Owner', 'zh-CN': '\u8D1F\u8D23\u4EBA', 'es-ES': 'Responsable', 'ja-JP': '\u62C5\u5F53\u8005' },\n      type: 'lookup',\n      scope: 'dashboard',\n      optionsFrom: { object: 'sys_user', valueField: 'id', labelField: 'name' },\n    },\n  ],\n\n  widgets: [\n    // \u2500\u2500\u2500 KPI Row \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n    {\n      id: 'total_revenue',\n      title: 'Total Revenue',\n      description: 'Closed-won revenue this period',\n      type: 'metric',\n      filter: { stage: 'closed_won' },\n      colorVariant: 'success',\n      dataset: 'opportunity_metrics', values: ['total_amount'],\n      layout: { x: 0, y: 0, w: 3, h: 2 },\n    },\n    {\n      id: 'active_deals',\n      title: 'Active Deals',\n      description: 'Open opportunities in the pipeline',\n      type: 'metric',\n      filter: { stage: { $nin: ['closed_won', 'closed_lost'] } },\n      colorVariant: 'blue',\n      dataset: 'opportunity_metrics', values: ['opp_count'],\n      layout: { x: 3, y: 0, w: 3, h: 2 },\n    },\n    {\n      id: 'won_deals',\n      title: 'Won Deals',\n      description: 'Closed-won deals this period',\n      type: 'metric',\n      filter: { stage: 'closed_won' },\n      colorVariant: 'purple',\n      dataset: 'opportunity_metrics', values: ['opp_count'],\n      layout: { x: 6, y: 0, w: 3, h: 2 },\n    },\n    // No overrides left once the fabricated trend is gone.\n    avgDealSizeMetricWidget({ x: 9, y: 0, w: 3, h: 2 }),\n\n    // \u2500\u2500\u2500 Charts Row 1 \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n    {\n      id: 'revenue_trends',\n      title: 'Revenue Trends',\n      description: 'Closed-won revenue over the last 12 months',\n      type: 'area',\n      filter: { stage: 'closed_won', close_date: { $gte: '{12_months_ago}' } },\n      filterBindings: { dateRange: false }, // self-scoped to 12 months \u2014 the date picker must not narrow it\n      colorVariant: 'success',\n      dataset: 'opportunity_metrics', dimensions: ['close_date'], values: ['total_amount'],\n      layout: { x: 0, y: 2, w: 9, h: 4 },\n      chartConfig: {\n        showLegend: false,\n        showDataLabels: false,\n        colors: ['#10B981'],\n        interaction: { tooltips: true, brush: true },\n      },\n      options: { dateGranularity: 'month' },\n    },\n    {\n      id: 'lead_source',\n      title: 'Lead Source',\n      description: 'Pipeline value by acquisition channel',\n      type: 'donut',\n      colorVariant: 'purple',\n      dataset: 'opportunity_metrics', dimensions: ['lead_source'], values: ['total_amount'],\n      layout: { x: 9, y: 2, w: 3, h: 4 },\n      chartConfig: {\n        showLegend: true,\n        showDataLabels: true,\n        colors: ['#4F46E5', '#06B6D4', '#10B981', '#F59E0B', '#EF4444', '#8B5CF6'],\n      },\n    },\n\n    // \u2500\u2500\u2500 Charts Row 2 \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n    pipelineByStageFunnelWidget({ x: 0, y: 6, w: 6, h: 4 }),\n    {\n      id: 'top_products',\n      title: 'Top Products',\n      description: 'Total list-price revenue by product category',\n      type: 'bar',\n      colorVariant: 'blue',\n      // crm_product has no `close_date`, so the date picker would fail it with\n      // `no such column`. ObjectStack 15 (framework#2501) injects every dashboard\n      // filter (dateRange + globalFilters) into each widget's query.\n      // The `owner_id` opt-out is SEMANTIC, not structural: since #548 every\n      // business object carries the injected `owner_id`, so the filter would now\n      // resolve \u2014 it just means nothing on a shared product catalog, where the\n      // column records whoever created the entry.\n      filterBindings: { dateRange: false, owner_id: false },\n      dataset: 'product_metrics', dimensions: ['category'], values: ['list_price_sum'],\n      layout: { x: 6, y: 6, w: 6, h: 4 },\n      chartConfig: {\n        showLegend: false,\n        showDataLabels: true,\n        colors: ['#4F46E5'],\n      },\n    },\n\n    // \u2500\u2500\u2500 Pipeline by Owner \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n    // A dashboard `table` binds to an analytics dataset (a cube), so it must\n    // aggregate \u2014 it cannot list raw records (ADR-0021). The previous\n    // \"Recent Opportunities\" table selected only the `opp_count` measure with\n    // no dimension, which renders a single summary row, not a per-deal list.\n    // For a true per-record listing, surface an object-bound ListView through\n    // app navigation instead (ADR-0017). Here we group by owner for a rep\n    // pipeline breakdown that renders one row per owner.\n    {\n      id: 'pipeline_by_owner',\n      title: 'Pipeline by Owner',\n      description: 'Open pipeline value and deal count per sales rep',\n      type: 'table',\n      filter: { stage: { $nin: ['closed_won', 'closed_lost'] } },\n      colorVariant: 'default',\n      dataset: 'opportunity_metrics', dimensions: ['owner'], values: ['total_amount', 'opp_count', 'avg_amount'],\n      layout: { x: 0, y: 10, w: 12, h: 4 },\n      options: {\n        sortBy: 'total_amount',\n        sortOrder: 'desc',\n        limit: 10,\n      },\n    },\n  ],\n};\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/sales/dashboards/executive.dashboard.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/sales/dashboards\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/sales/dashboards/executive.dashboard.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport type { Dashboard, InlineLocaleMap } from '@objectstack/spec/ui';\nimport { LEAD_SOURCE_OPTIONS } from '../objects/_picklists';\nimport { pipelineByStageFunnelWidget } from './shared-widgets';\n\n/**\n * `lead_source` filter option labels, keyed by the CANONICAL stored value.\n *\n * Only the WORDING is written here. The ROSTER is derived below from\n * {@link LEAD_SOURCE_OPTIONS} \u2014 the one constant `crm_lead`, `crm_contact` and\n * `crm_opportunity` each spread into their own `lead_source` field \u2014 so this\n * control can only ever offer values a record can actually hold. It used to\n * hand-copy six of the twelve, and one of those six was spelled `advertising`\n * against a canonical `advertisement`: picking it ANDed a term no row matches\n * into every bound widget and the whole dashboard read zero with no error and\n * no empty state (#1849).\n *\n * A value added to the constant with no row here renders `label: undefined`,\n * which `pnpm validate` rejects by name \u2014 the roster cannot drift back\n * silently, which is the property a second hand-copy could not have.\n *\n * The strings are the language packs' own, copied from\n * `src/sales/translations/<locale>/objects.pipeline.ts`\n * (`crm_lead.fields.lead_source.options`; ja-JP resolves them through\n * `src/sales/translations/ja-JP/_shared.ts`), so the filter bar does not coin a\n * second vocabulary for a value the record page already labels. They are\n * spelled inline rather than reached through `GlobalFilterSchema.object`,\n * which is inert in this Console build \u2014 measured on #1822, see `./index.ts`.\n */\nconst LEAD_SOURCE_FILTER_LABELS: Record<\n  string,\n  InlineLocaleMap & Record<'en' | 'zh-CN' | 'es-ES' | 'ja-JP', string>\n> = {\n  web:             { en: 'Web',             'zh-CN': '\u7F51\u7AD9',      'es-ES': 'Web',                'ja-JP': '\u30A6\u30A7\u30D6' },\n  referral:        { en: 'Referral',        'zh-CN': '\u63A8\u8350',      'es-ES': 'Referencia',         'ja-JP': '\u7D39\u4ECB' },\n  event:           { en: 'Event / Trade Show', 'zh-CN': '\u6D3B\u52A8 / \u5C55\u4F1A', 'es-ES': 'Evento / Feria', 'ja-JP': '\u30A4\u30D9\u30F3\u30C8\u30FB\u5C55\u793A\u4F1A' },\n  webinar:         { en: 'Webinar',         'zh-CN': '\u7EBF\u4E0A\u7814\u8BA8\u4F1A', 'es-ES': 'Seminario Web',      'ja-JP': '\u30A6\u30A7\u30D3\u30CA\u30FC' },\n  partner:         { en: 'Partner',         'zh-CN': '\u5408\u4F5C\u4F19\u4F34',   'es-ES': 'Socio',              'ja-JP': '\u30D1\u30FC\u30C8\u30CA\u30FC' },\n  advertisement:   { en: 'Advertisement',   'zh-CN': '\u5E7F\u544A',      'es-ES': 'Publicidad',         'ja-JP': '\u5E83\u544A' },\n  paid_search:     { en: 'Paid Search',     'zh-CN': '\u4ED8\u8D39\u641C\u7D22',   'es-ES': 'B\u00FAsqueda de Pago',   'ja-JP': '\u6709\u6599\u691C\u7D22' },\n  social:          { en: 'Social Media',    'zh-CN': '\u793E\u4EA4\u5A92\u4F53',   'es-ES': 'Redes Sociales',     'ja-JP': '\u30BD\u30FC\u30B7\u30E3\u30EB\u30E1\u30C7\u30A3\u30A2' },\n  content:         { en: 'Content / Blog',  'zh-CN': '\u5185\u5BB9 / \u535A\u5BA2', 'es-ES': 'Contenido / Blog',  'ja-JP': '\u30B3\u30F3\u30C6\u30F3\u30C4\u30FB\u30D6\u30ED\u30B0' },\n  cold_call:       { en: 'Cold Call',       'zh-CN': '\u964C\u751F\u62DC\u8BBF',   'es-ES': 'Llamada en Fr\u00EDo',    'ja-JP': '\u30B3\u30FC\u30EB\u30C9\u30B3\u30FC\u30EB' },\n  email_campaign:  { en: 'Email Campaign',  'zh-CN': '\u90AE\u4EF6\u8425\u9500',   'es-ES': 'Campa\u00F1a de Email',   'ja-JP': '\u30E1\u30FC\u30EB\u30AD\u30E3\u30F3\u30DA\u30FC\u30F3' },\n  other:           { en: 'Other',           'zh-CN': '\u5176\u4ED6',      'es-ES': 'Otro',               'ja-JP': '\u305D\u306E\u4ED6' },\n};\n\n/**\n * Executive Overview Dashboard\n *\n * High-level revenue, customer, and pipeline KPIs for company leadership.\n *\n * Widgets here are dataset-bound (ADR-0021), and the console's dataset widget\n * reads ONLY: type, dataset, dimensions, values, filter, filterBindings, and\n * layout. It builds charts and tables from the dataset's own field metadata\n * (labels, formats), so per-widget `chartConfig`, `colorVariant`, widget-level\n * `action*`, and free-form `options` (icons, formats, static trends, table\n * column specs) are never read \u2014 don't re-add them. In particular, metric-tile\n * trend deltas must come from real comparison queries (widget `compareTo`)\n * once the renderer supports them for dataset metrics; hardcoded percentages\n * previously carried here were fabrications and were removed (#500).\n * Date bucketing is likewise server-side (a dataset dimension's\n * `dateGranularity`, not widget options) \u2014 but see the note in\n * `opportunity_metrics` for why the trend widgets still group by raw dates.\n */\nexport const ExecutiveDashboard: Dashboard = {\n  name: 'executive_dashboard',\n  label: 'Executive Overview',\n  description: 'High-level revenue, customer, and pipeline KPIs for leadership',\n\n  columns: 12,\n  gap: 4,\n  refreshIntervalSeconds: 300, // 5 minutes\n\n  header: {\n    showTitle: true,\n    showDescription: true,\n    // Header action buttons removed: they referenced actions/routes that were\n    // never implemented (`export_dashboard_pdf`, `schedule_dashboard_email`,\n    // `customize_dashboard` are not defined anywhere), so they rendered as dead\n    // buttons. Re-add real, wired-up actions here if these features land.\n  },\n\n  dateRange: {\n    field: 'close_date',\n    defaultRange: 'this_quarter',\n    allowCustomRange: true,\n  },\n\n  globalFilters: [\n    {\n      field: 'owner_id',\n      label: { en: 'Owner', 'zh-CN': '\u8D1F\u8D23\u4EBA', 'es-ES': 'Responsable', 'ja-JP': '\u62C5\u5F53\u8005' },\n      type: 'lookup',\n      scope: 'dashboard',\n      optionsFrom: { object: 'sys_user', valueField: 'id', labelField: 'name' },\n    },\n    {\n      field: 'lead_source',\n      label: { en: 'Lead Source', 'zh-CN': '\u7EBF\u7D22\u6765\u6E90', 'es-ES': 'Origen del Prospecto', 'ja-JP': '\u30EA\u30FC\u30C9\u30BD\u30FC\u30B9' },\n      type: 'select',\n      scope: 'dashboard',\n      // Roster derived, wording from the language packs \u2014 see\n      // LEAD_SOURCE_FILTER_LABELS above. Order follows the canonical constant.\n      options: LEAD_SOURCE_OPTIONS.map(({ value }) => ({\n        value,\n        label: LEAD_SOURCE_FILTER_LABELS[String(value)],\n      })),\n    },\n  ],\n\n  widgets: [\n    // \u2500\u2500\u2500 Row 1: Headline KPIs \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n    {\n      id: 'total_revenue_ytd',\n      title: 'Total Revenue (YTD)',\n      description: 'Closed-won revenue this year',\n      type: 'metric',\n      filter: { stage: 'closed_won', close_date: { $gte: '{current_year_start}' } },\n      // Self-scoped to YTD; without this the injected dashboard dateRange\n      // (default this_quarter) is ANDed in and the tile shows quarter revenue.\n      filterBindings: { dateRange: false },\n      dataset: 'opportunity_metrics', values: ['total_amount'],\n      layout: { x: 0, y: 0, w: 3, h: 2 },\n    },\n    {\n      id: 'total_accounts',\n      title: 'Active Accounts',\n      description: 'Customers with at least one active relationship',\n      type: 'metric',\n      filter: { is_active: true },\n      // crm_account has neither `close_date` nor `lead_source`; opt this widget\n      // out of both dashboard filters bound to those fields. ObjectStack 15\n      // (framework#2501) injects every dashboard filter (dateRange + globalFilters)\n      // into each widget's query, so a widget on an object lacking a filter field\n      // fails with `no such column`. crm_account DOES have `owner_id` (injected\n      // into every business object, #548), so the owner filter is left to apply.\n      filterBindings: { dateRange: false, lead_source: false },\n      dataset: 'account_metrics', values: ['account_count'],\n      layout: { x: 3, y: 0, w: 3, h: 2 },\n    },\n    {\n      id: 'total_contacts',\n      title: 'Total Contacts',\n      description: 'People in our address book',\n      type: 'metric',\n      filterBindings: { dateRange: false }, // crm_contact has no close_date \u2014 opt out of the date picker\n      dataset: 'contact_metrics', values: ['contact_count'],\n      layout: { x: 6, y: 0, w: 3, h: 2 },\n    },\n    {\n      id: 'open_leads',\n      title: 'Open Leads',\n      description: 'Unconverted leads in the funnel',\n      type: 'metric',\n      filter: { is_converted: false },\n      filterBindings: { dateRange: false }, // crm_lead has no close_date \u2014 opt out of the date picker\n      dataset: 'lead_metrics', values: ['lead_count'],\n      layout: { x: 9, y: 0, w: 3, h: 2 },\n    },\n\n    // \u2500\u2500\u2500 Row 2: Revenue Analysis \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n    {\n      id: 'revenue_trend',\n      title: 'Revenue Trend',\n      description: 'Closed-won revenue over the last 12 months',\n      type: 'area',\n      filter: { stage: 'closed_won', close_date: { $gte: '{12_months_ago}' } },\n      filterBindings: { dateRange: false }, // self-scoped to 12 months \u2014 the date picker must not narrow it\n      dataset: 'opportunity_metrics', dimensions: ['close_date'], values: ['total_amount'],\n      layout: { x: 0, y: 2, w: 8, h: 4 },\n      // Default rendering is intentional: the dataset widget plots the selected\n      // dimension \u00D7 values directly; a chartConfig would duplicate them inertly.\n      suppressWarnings: ['chart-config-missing'],\n    },\n    {\n      id: 'revenue_by_industry',\n      title: 'Revenue by Industry',\n      description: 'YTD closed-won revenue split by customer industry',\n      type: 'donut',\n      filter: { stage: 'closed_won', close_date: { $gte: '{current_year_start}' } },\n      filterBindings: { dateRange: false }, // self-scoped to YTD \u2014 the date picker must not narrow it\n      dataset: 'opportunity_metrics', dimensions: ['account_industry'], values: ['total_amount'],\n      layout: { x: 8, y: 2, w: 4, h: 4 },\n      suppressWarnings: ['chart-config-missing'], // intentional default rendering (see revenue_trend)\n    },\n\n    // \u2500\u2500\u2500 Row 3: Pipeline & Activity \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n    // The funnel now comes from the shared factory (#539); its remaining inert\n    // config lives in shared-widgets.ts and is out of this PR's scope.\n    pipelineByStageFunnelWidget({ x: 0, y: 6, w: 6, h: 4 }),\n    {\n      id: 'new_accounts_by_month',\n      title: 'New Accounts',\n      description: 'Account creation cadence \u2014 last 6 months',\n      type: 'bar',\n      filter: { created_at: { $gte: '{6_months_ago}' } },\n      filterBindings: { dateRange: false, lead_source: false }, // crm_account has no close_date/lead_source; scopes itself by created_at\n      dataset: 'account_metrics', dimensions: ['created_at'], values: ['account_count'],\n      layout: { x: 6, y: 6, w: 6, h: 4 },\n      suppressWarnings: ['chart-config-missing'], // intentional default rendering (see revenue_trend)\n    },\n\n    // \u2500\u2500\u2500 Row 4: Revenue by Industry \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n    // A dashboard `table` binds to an analytics cube, so it aggregates rather\n    // than listing raw accounts (ADR-0021). The previous \"Top Accounts by\n    // Revenue\" table selected only the `account_count` measure with no\n    // dimension \u2014 a single summary row, not a customer ranking. Grouping by\n    // industry gives a real multi-row breakdown of book-of-business by sector;\n    // for a per-account list, use an object-bound ListView (ADR-0017).\n    // Column headers and number formats come from the dataset's dimension and\n    // measure metadata.\n    {\n      id: 'accounts_by_industry',\n      title: 'Accounts by Industry',\n      description: 'Total annual revenue and account count per industry',\n      type: 'table',\n      filterBindings: { dateRange: false, lead_source: false }, // crm_account has no close_date/lead_source \u2014 opt out of both\n      dataset: 'account_metrics', dimensions: ['industry'], values: ['annual_revenue_sum', 'account_count'],\n      layout: { x: 0, y: 10, w: 12, h: 4 },\n    },\n  ],\n};\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/sales/dashboards/sales.dashboard.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/sales/dashboards\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/sales/dashboards/sales.dashboard.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport type { Dashboard } from '@objectstack/spec/ui';\nimport { avgDealSizeMetricWidget, pipelineByStageFunnelWidget } from './shared-widgets';\n\n/**\n * Sales Performance Dashboard\n *\n * Pipeline analytics, win rate trends, and rep performance for the sales team.\n * Modeled after the polished CRM dashboard reference at\n * https://github.com/objectstack-ai/objectui/tree/main/examples/crm.\n *\n * No KPI tile declares a `trend`. A period-over-period delta is a measurement,\n * so it has to come from a real comparison query (widget `compareTo`) once the\n * renderer supports it for dataset metrics \u2014 the percentages this file used to\n * carry were typed by hand and recomputed by nothing, so they kept asserting\n * the same \"+8.4% vs last quarter\" on any data, including an empty database.\n * Same rule as the executive dashboard (#500, #587).\n */\nexport const SalesDashboard: Dashboard = {\n  name: 'sales_dashboard',\n  label: 'Sales Performance',\n  description: 'Pipeline analytics, win rate trends, and rep performance',\n\n  columns: 12,\n  gap: 4,\n  refreshIntervalSeconds: 180, // 3 minutes\n\n  header: {\n    showTitle: true,\n    // Keep the opening KPI row in the first viewport for a live demo. The\n    // description remains available in dashboard metadata and translations.\n    showDescription: false,\n    // Header action buttons removed: `create_opportunity` / `export_dashboard_pdf`\n    // are not defined actions, and `/reports/forecast` matches no report route \u2014\n    // all three were dead. Re-add real, wired-up actions here when available.\n  },\n\n  dateRange: {\n    field: 'close_date',\n    defaultRange: 'this_quarter',\n    allowCustomRange: true,\n  },\n\n  globalFilters: [\n    {\n      field: 'owner_id',\n      label: { en: 'Sales Rep', 'zh-CN': '\u9500\u552E\u4EE3\u8868', 'es-ES': 'Representante de Ventas', 'ja-JP': '\u55B6\u696D\u62C5\u5F53\u8005' },\n      type: 'lookup',\n      scope: 'dashboard',\n      optionsFrom: { object: 'sys_user', valueField: 'id', labelField: 'name' },\n    },\n    {\n      field: 'type',\n      label: { en: 'Deal Type', 'zh-CN': '\u5546\u673A\u7C7B\u578B', 'es-ES': 'Tipo de Oportunidad', 'ja-JP': '\u5546\u8AC7\u30BF\u30A4\u30D7' },\n      type: 'select',\n      scope: 'dashboard',\n      options: [\n        { value: 'new_business',       label: { en: 'New Business', 'zh-CN': '\u65B0\u4E1A\u52A1', 'es-ES': 'Nuevo Negocio', 'ja-JP': '\u65B0\u898F\u30D3\u30B8\u30CD\u30B9' } },\n        { value: 'existing_upgrade',   label: { en: 'Existing Customer - Upgrade', 'zh-CN': '\u8001\u5BA2\u6237\u5347\u7EA7', 'es-ES': 'Cliente Existente - Mejora', 'ja-JP': '\u65E2\u5B58\u9867\u5BA2 - \u30A2\u30C3\u30D7\u30B0\u30EC\u30FC\u30C9' } },\n        { value: 'existing_renewal',   label: { en: 'Existing Customer - Renewal', 'zh-CN': '\u8001\u5BA2\u6237\u7EED\u7EA6', 'es-ES': 'Cliente Existente - Renovaci\u00F3n', 'ja-JP': '\u65E2\u5B58\u9867\u5BA2 - \u66F4\u65B0' } },\n        { value: 'existing_expansion', label: { en: 'Existing Customer - Expansion', 'zh-CN': '\u8001\u5BA2\u6237\u62D3\u5C55', 'es-ES': 'Cliente Existente - Expansi\u00F3n', 'ja-JP': '\u65E2\u5B58\u9867\u5BA2 - \u62E1\u5927' } },\n      ],\n    },\n  ],\n\n  widgets: [\n    // \u2500\u2500\u2500 Row 1: Pipeline KPIs \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n    {\n      id: 'total_pipeline_value',\n      title: 'Total Pipeline',\n      description: 'Sum of open opportunity value',\n      type: 'metric',\n      filter: { stage: { $nin: ['closed_won', 'closed_lost'] } },\n      colorVariant: 'blue',\n      dataset: 'opportunity_metrics', values: ['total_amount'],\n      layout: { x: 0, y: 0, w: 3, h: 2 },\n    },\n    {\n      id: 'closed_won_qtd',\n      title: 'Closed Won (QTD)',\n      description: 'Revenue closed this quarter',\n      type: 'metric',\n      filter: { stage: 'closed_won', close_date: { $gte: '{current_quarter_start}' } },\n      filterBindings: { dateRange: false }, // self-scoped to QTD \u2014 the date picker must not re-window it\n      colorVariant: 'success',\n      dataset: 'opportunity_metrics', values: ['total_amount'],\n      layout: { x: 3, y: 0, w: 3, h: 2 },\n    },\n    {\n      id: 'open_opportunities',\n      title: 'Open Opportunities',\n      description: 'Active deals in flight',\n      type: 'metric',\n      filter: { stage: { $nin: ['closed_won', 'closed_lost'] } },\n      colorVariant: 'orange',\n      dataset: 'opportunity_metrics', values: ['opp_count'],\n      layout: { x: 6, y: 0, w: 3, h: 2 },\n    },\n    avgDealSizeMetricWidget({ x: 9, y: 0, w: 3, h: 2 }, {\n      description: 'Average value of closed-won deals this quarter',\n      filter: { stage: 'closed_won', close_date: { $gte: '{current_quarter_start}' } },\n      filterBindings: { dateRange: false }, // self-scoped to QTD \u2014 the date picker must not re-window it\n      colorVariant: 'purple',\n    }),\n\n    // \u2500\u2500\u2500 Row 2: Win / Loss KPIs \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n    //\n    // The ratio and its two inputs sit side by side ON PURPOSE (#593). A win\n    // rate is the failure mode #614 shipped: a wrong denominator raises no\n    // error, it just prints a plausible percentage. Showing \"62%\" next to\n    // \"8 won\" and \"5 lost\" means a reader can check the arithmetic at a\n    // glance, and a half that silently loses its filter stops being invisible.\n    //\n    // All three windows are the same self-scoped 12 months (`dateRange: false`\n    // so the header's date picker cannot re-window one of them and not the\n    // others \u2014 three tiles over three different windows would be worse than\n    // no tiles at all).\n    {\n      // NOTE: no `stage` filter here, and that is deliberate. Both halves of\n      // the ratio come from the DATASET's own measure filters \u2014 `won_count`\n      // over closed_won, `decided_count` over closed_won + closed_lost \u2014 so\n      // open pipeline is excluded by the measures. A widget-level\n      // `stage: {$in: [...]}` filter would narrow numerator and denominator\n      // alike, which is how a ratio quietly becomes a division by itself.\n      id: 'win_rate_12m',\n      title: 'Win Rate (12M)',\n      description: 'Deals won as a share of all deals settled in the last 12 months',\n      type: 'metric',\n      filter: { close_date: { $gte: '{12_months_ago}' } },\n      filterBindings: { dateRange: false },\n      colorVariant: 'success',\n      dataset: 'opportunity_metrics', values: ['win_rate'],\n      layout: { x: 0, y: 2, w: 4, h: 2 },\n    },\n    {\n      id: 'won_deals_12m',\n      title: 'Deals Won (12M)',\n      description: 'The numerator of the win rate',\n      type: 'metric',\n      filter: { close_date: { $gte: '{12_months_ago}' } },\n      filterBindings: { dateRange: false },\n      colorVariant: 'blue',\n      dataset: 'opportunity_metrics', values: ['won_count'],\n      layout: { x: 4, y: 2, w: 4, h: 2 },\n    },\n    {\n      id: 'lost_deals_12m',\n      title: 'Deals Lost (12M)',\n      description: 'The other half of the win-rate denominator',\n      type: 'metric',\n      filter: { close_date: { $gte: '{12_months_ago}' } },\n      filterBindings: { dateRange: false },\n      colorVariant: 'orange',\n      dataset: 'opportunity_metrics', values: ['lost_count'],\n      layout: { x: 8, y: 2, w: 4, h: 2 },\n    },\n\n    // \u2500\u2500\u2500 Row 3: Pipeline & Trends \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n    pipelineByStageFunnelWidget({ x: 0, y: 4, w: 6, h: 4 }),\n    {\n      id: 'monthly_revenue_trend',\n      title: 'Monthly Revenue Trend',\n      description: 'Closed-won revenue, last 12 months',\n      type: 'area',\n      filter: { stage: 'closed_won', close_date: { $gte: '{12_months_ago}' } },\n      filterBindings: { dateRange: false }, // self-scoped to 12 months \u2014 the date picker must not narrow it\n      colorVariant: 'success',\n      dataset: 'opportunity_metrics', dimensions: ['close_date'], values: ['total_amount'],\n      layout: { x: 6, y: 4, w: 6, h: 4 },\n      chartConfig: {\n        showLegend: false,\n        showDataLabels: false,\n        colors: ['#10B981'],\n        // No quota annotation line: ChartAnnotationSchema only takes a STATIC\n        // value, and the real quotas live per-owner/per-period in\n        // crm_forecast.quota (seeded 500k\u20131.5M \u2014 the old hardcoded 100000 was\n        // fiction). Quota vs. actual is the quota_attainment_by_rep table\n        // below, bound to the forecast_metrics dataset.\n        interaction: { tooltips: true, brush: true },\n      },\n      options: { dateGranularity: 'month' },\n    },\n\n    // \u2500\u2500\u2500 Row 4: Performance Breakdown \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n    {\n      id: 'pipeline_by_forecast_category',\n      title: 'Pipeline by Forecast Category',\n      description: 'Open pipeline grouped by sales forecast category',\n      type: 'horizontal-bar',\n      filter: { stage: { $nin: ['closed_won', 'closed_lost'] } },\n      colorVariant: 'blue',\n      dataset: 'opportunity_metrics', dimensions: ['forecast_category'], values: ['total_amount'],\n      layout: { x: 0, y: 8, w: 6, h: 4 },\n      chartConfig: {\n        showLegend: false,\n        showDataLabels: true,\n        colors: ['#4F46E5'],\n      },\n    },\n    {\n      id: 'lead_source_breakdown',\n      title: 'Lead Source',\n      description: 'Where our pipeline is coming from',\n      type: 'donut',\n      filter: { stage: { $nin: ['closed_lost'] } },\n      colorVariant: 'purple',\n      dataset: 'opportunity_metrics', dimensions: ['lead_source'], values: ['total_amount'],\n      layout: { x: 6, y: 8, w: 6, h: 4 },\n      chartConfig: {\n        showLegend: true,\n        showDataLabels: true,\n        colors: ['#4F46E5', '#06B6D4', '#10B981', '#F59E0B', '#EF4444', '#8B5CF6'],\n      },\n    },\n\n    // \u2500\u2500\u2500 Row 5: Rep Leaderboard \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n    // A dashboard `table` binds to an analytics cube and aggregates; it cannot\n    // list raw deals (ADR-0021). The previous \"Top Open Opportunities\" table\n    // selected only `opp_count` with no dimension \u2014 one summary row, not a deal\n    // ranking. Grouping open pipeline by owner yields a rep leaderboard (one\n    // row per rep). For a per-deal list, surface an object-bound ListView\n    // through app navigation (ADR-0017).\n    {\n      id: 'open_pipeline_by_owner',\n      title: 'Open Pipeline by Owner',\n      description: 'In-flight pipeline value, deal count and avg win probability per rep',\n      type: 'table',\n      filter: { stage: { $nin: ['closed_won', 'closed_lost'] } },\n      colorVariant: 'default',\n      dataset: 'opportunity_metrics', dimensions: ['owner'], values: ['total_amount', 'opp_count', 'avg_probability'],\n      layout: { x: 0, y: 12, w: 12, h: 4 },\n      options: {\n        sortBy: 'total_amount',\n        sortOrder: 'desc',\n        limit: 10,\n      },\n    },\n\n    // \u2500\u2500\u2500 Row 6: Quota Attainment \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n    // The real per-rep quota data (crm_forecast.quota) surfaced as a table:\n    // dashboard chart annotations cannot reference a dataset (static values\n    // only), so quota vs. actual gets its own widget instead of a fake line.\n    {\n      id: 'quota_attainment_by_rep',\n      title: 'Quota Attainment by Rep',\n      description: 'Current-quarter quota, closed revenue and attainment per rep, from forecast snapshots',\n      type: 'table',\n      colorVariant: 'default',\n      // crm_forecast has neither `close_date` nor `type`; opt out of the\n      // dashboard filters bound to those fields (framework#2501 injects every\n      // dashboard filter into each widget query). `owner` exists and applies.\n      filterBindings: { dateRange: false, type: false },\n      // ONE period, or the numbers are nonsense (#614). `crm_forecast` holds a\n      // row per owner PER PERIOD, and `quota_sum` / `closed_sum` are plain\n      // `sum` measures \u2014 so an unpinned query adds this quarter's quota to this\n      // month's quota to every settled quarter's quota and labels the total\n      // \"Quota\". On the shipped seeds that turned a rep's real 1,500,000\n      // quarterly quota into 7,940,000, with attainment wrong by the same\n      // construction (89% instead of 55%).\n      //\n      // Both halves of the key are needed. `period: 'quarter'` alone still sums\n      // every quarter ever snapshotted; `period_start` alone still merges the\n      // quarter row with the month row that opens the same quarter (Q3 and July\n      // both start on the 1st). Together they name exactly one snapshot per\n      // owner \u2014 the same (owner, period, period_start) tuple the snapshot sweep\n      // upserts on and the object indexes.\n      //\n      // `{current_quarter_start}` is resolved by the ANALYTICS path, verified\n      // rather than assumed: `queryDataset` runs both the dataset filter and the\n      // widget's `runtimeFilter` through `resolveFilterTokens`, which\n      // understands `{(current|last|next)_(week|month|quarter|year)_(start|end)}`\n      // and throws `FILTER_TOKEN_UNKNOWN` on anything else.\n      //\n      // The LIST path resolves the same macros, and has since 17.0.0-rc.0:\n      // `resolveFilterTokens()` was wired into the ObjectQL READ path (objectql\n      // `feat(filters): evaluate {filter-token} placeholders server-side`,\n      // #3582) ahead of the middleware chain, covering `find` / `findOne` /\n      // `count` / `aggregate` \u2014 the one gate every server-side read passes\n      // through, saved-view filters included. So this widget's filter and a\n      // saved view's filter now read the same way, and the sibling\n      // `this_quarter_forecasts` in `src/sales/views/forecast.view.ts` pins this same\n      // quarter with this same macro. Measured, not inferred:\n      // `test/forecast-current-quarter-view.test.ts` runs both filter shapes \u2014\n      // the `period_start` equality (#730) and the `close_date` range (#743) \u2014\n      // through a real engine and pins a three-way outcome (current quarter\n      // only: not zero rows, not every quarter). First taken on 17.0.0-rc.2;\n      // RE-RUN 2026-09-03 on 17.2.0 (#1467), RE-RUN on 17.3.0 (#1676, the PR\n      // #1577 pin) and RE-RUN again on 17.4.0 (PR #1814, #1807) \u2014 green all\n      // four times, so the outcome held on every pin it was taken on, not\n      // only the first. Not yet re-run on 17.5.0.\n      //\n      // What stood here before described the two paths as asymmetric and told\n      // the next author not to generalise between them. That was true on\n      // @objectstack 16.1.0 and expired at rc.0 (#744).\n      //\n      // Cost of pinning to the CURRENT quarter rather than the latest one: for\n      // the few hours between a quarter boundary and the 03:00 sweep that opens\n      // the new row, the table is empty. Empty is the honest state \u2014 the\n      // alternative renders last quarter's attainment under a header that says\n      // this one.\n      filter: { period: 'quarter', period_start: '{current_quarter_start}' },\n      dataset: 'forecast_metrics', dimensions: ['owner'], values: ['quota_sum', 'closed_sum', 'attainment'],\n      layout: { x: 0, y: 16, w: 12, h: 4 },\n      options: {\n        sortBy: 'attainment',\n        sortOrder: 'desc',\n        limit: 10,\n      },\n    },\n\n    // \u2500\u2500\u2500 Row 7: Win / Loss analysis \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n    //\n    // Three widgets over the settled half of the pipeline (#593). Each of the\n    // two win-rate breakdowns is a TABLE, not a bar chart, and that is the\n    // whole design: a bar of \"67%\" is unfalsifiable, whereas a row reading\n    // \"Won 2 \u00B7 Lost 1 \u00B7 Settled 3 \u00B7 67%\" carries its own proof. Perturb either\n    // half \u2014 win a deal that was lost, or lose one that was won \u2014 and three of\n    // those four numbers move. `test/win-loss-capture.test.ts` does exactly\n    // that against the real dataset executor and the real seeds.\n    //\n    // Both tables opt out of the header's `close_date` window\n    // (`dateRange: false`) for the reason the quota table does: a win rate over\n    // \"this quarter\" on a demo database is computed from whichever one or two\n    // deals happen to have settled inside it, which is noise wearing the\n    // costume of a KPI. Twelve months is the same window the row-2 tiles and\n    // the revenue trend use, so the dashboard tells one consistent story.\n    {\n      id: 'win_rate_by_owner',\n      title: 'Win / Loss by Rep',\n      description: 'Deals won, deals lost and win rate per rep \u2014 last 12 months',\n      type: 'table',\n      filter: { close_date: { $gte: '{12_months_ago}' } },\n      filterBindings: { dateRange: false },\n      colorVariant: 'default',\n      dataset: 'opportunity_metrics',\n      dimensions: ['owner'],\n      values: ['won_count', 'lost_count', 'decided_count', 'win_rate', 'won_amount'],\n      layout: { x: 0, y: 20, w: 6, h: 4 },\n      options: {\n        sortBy: 'decided_count',\n        sortOrder: 'desc',\n        limit: 10,\n      },\n    },\n    {\n      id: 'win_rate_by_lead_source',\n      title: 'Win / Loss by Lead Source',\n      description: 'Which sources produce deals that actually close \u2014 last 12 months',\n      type: 'table',\n      filter: { close_date: { $gte: '{12_months_ago}' } },\n      filterBindings: { dateRange: false },\n      colorVariant: 'default',\n      dataset: 'opportunity_metrics',\n      dimensions: ['lead_source'],\n      values: ['won_count', 'lost_count', 'decided_count', 'win_rate', 'won_amount'],\n      layout: { x: 6, y: 20, w: 6, h: 4 },\n      options: {\n        sortBy: 'decided_count',\n        sortOrder: 'desc',\n        limit: 12,\n      },\n    },\n    {\n      // The loss-reason breakdown the fields were declared for and never got.\n      //\n      // `loss_reason` is mandatory on every `closed_lost` record (see\n      // crm_opportunity), so this chart has no \"unattributed\" slice to\n      // apologise for \u2014 an empty chart here means no losses in the window,\n      // never \"nobody filled the field in\".\n      //\n      // Counts, not amounts: the question a loss review asks is \"how often did\n      // we lose for this reason\", and one large lost deal should not outweigh\n      // five recurring feature gaps. `lost_amount` is declared on the dataset\n      // for the revenue view of the same question.\n      id: 'loss_reason_breakdown',\n      title: 'Why We Lose',\n      description: 'Lost deals by reason \u2014 last 12 months',\n      type: 'donut',\n      filter: { stage: 'closed_lost', close_date: { $gte: '{12_months_ago}' } },\n      filterBindings: { dateRange: false },\n      colorVariant: 'orange',\n      dataset: 'opportunity_metrics', dimensions: ['loss_reason'], values: ['opp_count'],\n      layout: { x: 0, y: 24, w: 12, h: 4 },\n      chartConfig: {\n        showLegend: true,\n        showDataLabels: true,\n        colors: ['#EF4444', '#F59E0B', '#8B5CF6', '#06B6D4', '#4F46E5', '#10B981', '#64748B'],\n      },\n    },\n\n    // \u2500\u2500\u2500 Row 9: Pivot \u2014 Stage \u00D7 Lead Source \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n    {\n      id: 'pipeline_stage_by_source',\n      title: 'Pipeline by Stage \u00D7 Lead Source',\n      description: 'Cross-tab of open opportunity amount by stage and source',\n      type: 'pivot',\n      filter: { stage: { $nin: ['closed_won', 'closed_lost'] } },\n      colorVariant: 'default',\n      dataset: 'opportunity_metrics', dimensions: ['stage', 'lead_source'], values: ['total_amount'],\n      layout: { x: 0, y: 28, w: 12, h: 4 },\n    },\n  ],\n};\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/sales/datasets/index.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/sales/datasets\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/sales/datasets/index.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\n/** Analytics dataset barrel (ADR-0021). */\n\nexport { OpportunityDataset } from './opportunity.dataset';\nexport { AccountDataset } from './account.dataset';\nexport { ContactDataset } from './contact.dataset';\nexport { LeadDataset } from './lead.dataset';\nexport { TaskDataset } from './task.dataset';\nexport { EventDataset } from './event.dataset';\nexport { ForecastDataset } from './forecast.dataset';\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/sales/datasets/opportunity.dataset.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/sales/datasets\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/sales/datasets/opportunity.dataset.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport { defineDataset } from '@objectstack/spec/ui';\n\n/**\n * Opportunity analytics dataset (ADR-0021).\n *\n * The single semantic source of truth for pipeline metrics across the Sales,\n * CRM and Executive dashboards. Widgets bind to this dataset and select\n * measures BY NAME (`total_amount`, `avg_amount`, `opp_count`) so \"pipeline\n * revenue\" means the same thing everywhere.\n */\nexport const OpportunityDataset = defineDataset({\n  name: 'opportunity_metrics',\n  label: 'Opportunity Metrics',\n  description: 'Semantic layer for sales-pipeline counts and amounts',\n  object: 'crm_opportunity',\n\n  // Include the account relationship so dimensions can traverse it (the join is\n  // derived from the `crm_account` lookup \u2014 no hand-written ON clause).\n  include: ['crm_account'],\n\n  dimensions: [\n    { name: 'stage', label: 'Stage', field: 'stage', type: 'string' },\n    { name: 'lead_source', label: 'Lead Source', field: 'lead_source', type: 'string' },\n    { name: 'forecast_category', label: 'Forecast Category', field: 'forecast_category', type: 'string' },\n    { name: 'type', label: 'Deal Type', field: 'type', type: 'string' },\n    // Semantic name `owner`; column `owner_id`, the platform anchor (#548).\n    { name: 'owner', label: 'Owner', field: 'owner_id', type: 'lookup' },\n    // Win/loss attribution (#593). Both columns are now mandatory at close\n    // (`requiredWhen` on crm_opportunity), so grouping by either one over\n    // settled deals has no \"unattributed\" bucket to explain away.\n    { name: 'win_reason', label: 'Win Reason', field: 'win_reason', type: 'string' },\n    { name: 'loss_reason', label: 'Loss Reason', field: 'loss_reason', type: 'string' },\n    // v17 fixes scoped aggregate execution and SQLite's epoch bucketing.\n    // Trends and quarter coverage need different buckets over the same field,\n    // so each one is its own semantic dimension.\n    { name: 'close_date', label: 'Close Date', field: 'close_date', type: 'date', dateGranularity: 'month' },\n    { name: 'close_quarter', label: 'Close Quarter', field: 'close_date', type: 'date', dateGranularity: 'quarter' },\n    // Cross-object dimension: account industry via the crm_account relationship.\n    { name: 'account_industry', label: 'Account Industry', field: 'crm_account.industry', type: 'string' },\n  ],\n\n  measures: [\n    { name: 'opp_count', label: 'Opportunities', aggregate: 'count' },\n    { name: 'total_amount', label: 'Total Amount', aggregate: 'sum', field: 'amount', format: '0,0' },\n    { name: 'avg_amount', label: 'Avg Deal Size', aggregate: 'avg', field: 'amount', format: '0,0' },\n    { name: 'avg_probability', label: 'Avg Probability', aggregate: 'avg', field: 'probability', format: '0%' },\n\n    // \u2500\u2500\u2500 Win rate (#593) \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n    //\n    // A ratio is the most dangerous kind of measure: a wrong denominator does\n    // not error, it returns a plausible number (#614 rendered a 1,500,000\n    // quota as 7,940,000 because a filter was missing one of its two halves).\n    // So the two halves are declared here, ONCE, as named measures \u2014 not\n    // improvised per widget \u2014 and every widget that shows `win_rate` also\n    // shows `won_count` and `lost_count` beside it, so the reader can check\n    // the arithmetic that produced the percentage.\n    //\n    // Each carries its OWN `filter`, which the executor honours by running\n    // that measure as its own sub-query and merging the result back on the\n    // selected dimensions. That is what lets one widget row hold \"won 2, lost\n    // 1, 67%\" \u2014 the counts are over different row sets, and only a\n    // measure-level filter can say so. A widget-level `filter` cannot: it\n    // narrows the whole row set at once, which is exactly how you end up\n    // dividing a number by itself.\n    //\n    // `decided_count` is deliberately its own filtered count and NOT\n    // `derived: { op: 'sum', of: ['won_count', 'lost_count'] }`. Measured on\n    // 17.0.0-rc.1: a filtered measure contributes NO row for a group its\n    // filter selects nothing in \u2014 the count comes back absent, not 0 \u2014 and a\n    // derived measure over an absent input evaluates to null. Summing the two\n    // would therefore blank the win rate of any rep who has never lost a deal\n    // (100%, the group you least want to hide). Counting the union directly\n    // keeps the denominator present whenever the group has any settled deal at\n    // all. The remaining asymmetry \u2014 a group with losses but NO wins reports a\n    // null win rate rather than 0% \u2014 is a platform behaviour, not something a\n    // widget can paper over; it is pinned by `test/win-loss-capture.test.ts`\n    // and filed as #656. The tables show `lost_count` next to `win_rate`\n    // precisely so that a blank rate reads as \"0 wins out of 3\", not as\n    // \"no data\".\n    { name: 'won_count', label: 'Won Deals', aggregate: 'count', filter: { stage: 'closed_won' } },\n    { name: 'lost_count', label: 'Lost Deals', aggregate: 'count', filter: { stage: 'closed_lost' } },\n    {\n      name: 'decided_count',\n      label: 'Settled Deals',\n      aggregate: 'count',\n      filter: { stage: { $in: ['closed_won', 'closed_lost'] } },\n    },\n    { name: 'won_amount', label: 'Won Revenue', aggregate: 'sum', field: 'amount', filter: { stage: 'closed_won' }, format: '0,0' },\n    { name: 'lost_amount', label: 'Lost Revenue', aggregate: 'sum', field: 'amount', filter: { stage: 'closed_lost' }, format: '0,0' },\n    { name: 'win_rate', label: 'Win Rate', derived: { op: 'ratio', of: ['won_count', 'decided_count'] }, format: '0%' },\n  ],\n});\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/sales/datasets/account.dataset.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/sales/datasets\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/sales/datasets/account.dataset.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport { defineDataset } from '@objectstack/spec/ui';\n\n/** Account analytics dataset (ADR-0021). */\nexport const AccountDataset = defineDataset({\n  name: 'account_metrics',\n  label: 'Account Metrics',\n  description: 'Semantic layer for account counts by industry / type',\n  object: 'crm_account',\n  dimensions: [\n    { name: 'industry', label: 'Industry', field: 'industry', type: 'string' },\n    { name: 'type', label: 'Type', field: 'type', type: 'string' },\n    { name: 'created_at', label: 'Created', field: 'created_at', type: 'date', dateGranularity: 'month' },\n  ],\n  measures: [\n    { name: 'account_count', label: 'Accounts', aggregate: 'count' },\n    { name: 'annual_revenue_sum', label: 'Annual Revenue', aggregate: 'sum', field: 'annual_revenue', format: '0,0' },\n  ],\n});\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/sales/datasets/contact.dataset.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/sales/datasets\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/sales/datasets/contact.dataset.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport { defineDataset } from '@objectstack/spec/ui';\n\n/** Contact analytics dataset (ADR-0021). */\nexport const ContactDataset = defineDataset({\n  name: 'contact_metrics',\n  label: 'Contact Metrics',\n  description: 'Semantic layer for contact counts',\n  object: 'crm_contact',\n  dimensions: [],\n  measures: [{ name: 'contact_count', label: 'Contacts', aggregate: 'count' }],\n});\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/sales/datasets/lead.dataset.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/sales/datasets\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/sales/datasets/lead.dataset.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport { defineDataset } from '@objectstack/spec/ui';\n\n/** Lead analytics dataset (ADR-0021). */\nexport const LeadDataset = defineDataset({\n  name: 'lead_metrics',\n  label: 'Lead Metrics',\n  description: 'Semantic layer for lead counts',\n  object: 'crm_lead',\n  dimensions: [\n    { name: 'status', label: 'Status', field: 'status', type: 'string' },\n    { name: 'lead_source', label: 'Source', field: 'lead_source', type: 'string' },\n    { name: 'created_at', label: 'Created', field: 'created_at', type: 'date' },\n    { name: 'last_contacted_date', label: 'Last Contacted', field: 'last_contacted_date', type: 'date', dateGranularity: 'month' },\n  ],\n  measures: [{ name: 'lead_count', label: 'Leads', aggregate: 'count' }],\n});\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/sales/datasets/task.dataset.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/sales/datasets\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/sales/datasets/task.dataset.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport { defineDataset } from '@objectstack/spec/ui';\n\n/**\n * Task analytics dataset (ADR-0021).\n *\n * Added for the \"My Day\" dashboard \u2014 `crm_task` had views, seed data and\n * automation but no semantic layer, so a rep's own workload could not be\n * counted or broken down anywhere.\n *\n * `priority_rank` is exposed alongside `priority` so a breakdown can be\n * ordered by urgency; sorting on the raw select compares option strings and\n * inverts it (normal > low > high > urgent).\n */\nexport const TaskDataset = defineDataset({\n  name: 'task_metrics',\n  label: 'Task Metrics',\n  description: 'Semantic layer for task workload and completion',\n  object: 'crm_task',\n  dimensions: [\n    { name: 'status', label: 'Status', field: 'status', type: 'string' },\n    { name: 'priority', label: 'Priority', field: 'priority', type: 'string' },\n    { name: 'priority_rank', label: 'Urgency', field: 'priority_rank', type: 'number' },\n    { name: 'type', label: 'Type', field: 'type', type: 'string' },\n    { name: 'due_date', label: 'Due Date', field: 'due_date', type: 'date' },\n    { name: 'is_overdue', label: 'Overdue', field: 'is_overdue', type: 'boolean' },\n    { name: 'is_completed', label: 'Completed', field: 'is_completed', type: 'boolean' },\n  ],\n  measures: [\n    { name: 'task_count', label: 'Tasks', aggregate: 'count' },\n    { name: 'avg_progress', label: 'Avg Progress', aggregate: 'avg', field: 'progress_percent', format: '0.0%' },\n  ],\n});\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/sales/datasets/event.dataset.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/sales/datasets\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/sales/datasets/event.dataset.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport { defineDataset } from '@objectstack/spec/ui';\n\n/**\n * Event analytics dataset (ADR-0021) \u2014 the semantic layer #592 needed.\n *\n * Before this, the app had NO activity metric of any kind: calls per rep,\n * meetings booked and activity per deal were all unanswerable, because the\n * only trace of an interaction was a `sys_activity` row with the interesting\n * part inside a JSON string. `crm_event` is a real object, so it gets a real\n * cube.\n *\n * `related_to_type` is a dimension and the `related_to_*` lookups are not:\n * grouping by a lookup id yields a column per raw id, which reads as noise on\n * a chart. \"Which deals are starved of activity\" is answered by filtering to\n * `related_to_type = crm_opportunity` and counting, not by grouping on the id.\n *\n * `start_datetime` declares `dateGranularity: 'week'`: every widget built on\n * it asks \"how much activity per week\", and on @objectstack 17 a bucketed\n * dimension is honoured (see `test/dataset-granularity.test.ts` for the 16.x\n * history and why the buckets could not be declared before).\n */\nexport const EventDataset = defineDataset({\n  name: 'event_metrics',\n  label: 'Activity Metrics',\n  description: 'Semantic layer for meetings, calls and interaction recency',\n  object: 'crm_event',\n  dimensions: [\n    { name: 'type', label: 'Activity Type', field: 'type', type: 'string' },\n    { name: 'status', label: 'Status', field: 'status', type: 'string' },\n    // `owner` is the SEMANTIC name every widget/report selects by; the column\n    // behind it is the platform ownership anchor `owner_id` (#548).\n    { name: 'owner', label: 'Owner', field: 'owner_id', type: 'string' },\n    { name: 'related_to_type', label: 'Related To', field: 'related_to_type', type: 'string' },\n    {\n      name: 'start_datetime',\n      label: 'Activity Week',\n      field: 'start_datetime',\n      type: 'date',\n      dateGranularity: 'week',\n    },\n  ],\n  measures: [\n    { name: 'event_count', label: 'Activities', aggregate: 'count' },\n    {\n      name: 'total_minutes',\n      label: 'Minutes',\n      aggregate: 'sum',\n      field: 'duration_minutes',\n      format: '0,0',\n    },\n    {\n      name: 'avg_minutes',\n      label: 'Avg Duration',\n      aggregate: 'avg',\n      field: 'duration_minutes',\n      format: '0,0',\n    },\n  ],\n});\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/sales/datasets/forecast.dataset.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/sales/datasets\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/sales/datasets/forecast.dataset.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport { defineDataset } from '@objectstack/spec/ui';\n\n/**\n * Forecast analytics dataset (ADR-0021).\n *\n * `crm_forecast` carries the real per-owner, per-period quota and attainment\n * snapshots, but had no semantic layer \u2014 which is how the Sales dashboard\n * ended up annotating its revenue chart with a hardcoded quota of 100000\n * while the seeded quotas run 500k\u20131.5M. Widgets that talk about quota must\n * bind here instead of inventing numbers.\n *\n * ## The measures are NOT additive across periods (#614)\n *\n * One row per owner per period, and the table deliberately holds several\n * periods at once (a current quarter, a current month, several settled ones).\n * `quota_sum` and friends are plain `sum`s, so a query that does not pin the\n * period adds a quarter's quota to a month's quota to last quarter's quota and\n * calls the result \"Quota\" \u2014 the defect that shipped on\n * `quota_attainment_by_rep` until #614.\n *\n * Every consumer must therefore make the period unambiguous, one of two ways:\n *\n *   \u2022 group by `period_label` (unique per period, so each row IS one period) \u2014\n *     the shape a quota-over-time trend wants; or\n *   \u2022 filter to a single snapshot with `period` + `period_start`\n *     (`{ period: 'quarter', period_start: '{current_quarter_start}' }`) \u2014\n *     the shape a \"where do we stand right now\" scoreboard wants.\n *\n * `test/forecast-period-scope.test.ts` fails the build for any widget or report\n * that does neither, so the trap cannot be walked into twice.\n *\n * This constraint is deliberately NOT a dataset-level `filter` pinning the\n * latest quarter. A dataset filter is invisible at the call site: it would make\n * the very trend the `period` / `period_label` dimensions exist to serve return\n * a single row, with nothing on the widget to explain why. The failure mode of\n * a missing widget filter is a loud test; the failure mode of a hidden dataset\n * filter is silently missing data.\n */\nexport const ForecastDataset = defineDataset({\n  name: 'forecast_metrics',\n  label: 'Forecast Metrics',\n  description: 'Semantic layer for per-owner quota, attainment and pipeline coverage',\n  object: 'crm_forecast',\n\n  dimensions: [\n    // Semantic name `owner`; column `owner_id`, the platform anchor (#548).\n    { name: 'owner', label: 'Owner', field: 'owner_id', type: 'lookup' },\n    { name: 'period', label: 'Period Type', field: 'period', type: 'string' },\n    { name: 'period_label', label: 'Period', field: 'period_label', type: 'string' },\n    { name: 'period_start', label: 'Period Start', field: 'period_start', type: 'date' },\n  ],\n\n  measures: [\n    { name: 'quota_sum', label: 'Quota', aggregate: 'sum', field: 'quota', format: '0,0' },\n    { name: 'closed_sum', label: 'Closed', aggregate: 'sum', field: 'closed_amount', format: '0,0' },\n    { name: 'pipeline_sum', label: 'Pipeline', aggregate: 'sum', field: 'pipeline_amount', format: '0,0' },\n    { name: 'commit_sum', label: 'Commit', aggregate: 'sum', field: 'commit_amount', format: '0,0' },\n    // Derived ratio (ADR-0021 Q1) rather than avg(attainment_pct): summing\n    // closed and quota before dividing weights every rep/period by quota\n    // size, where an average of per-row percentages would not.\n    { name: 'attainment', label: 'Attainment', derived: { op: 'ratio', of: ['closed_sum', 'quota_sum'] }, format: '0%' },\n  ],\n});\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/revenue/datasets/index.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/revenue/datasets\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/revenue/datasets/index.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\n/**\n * Revenue datasets barrel.\n *\n * The doctrine for this metadata type is written once, in\n * `src/sales/datasets/index.ts`; this file is the revenue package's half of\n * the same file-by-file registration.\n */\n\nexport { ProductDataset } from './product.dataset';\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/revenue/datasets/product.dataset.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/revenue/datasets\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/revenue/datasets/product.dataset.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport { defineDataset } from '@objectstack/spec/ui';\n\n/** Product analytics dataset (ADR-0021) \u2014 catalog list-price rollups. */\nexport const ProductDataset = defineDataset({\n  name: 'product_metrics',\n  label: 'Product Metrics',\n  description: 'Semantic layer for product catalog counts and list price',\n  object: 'crm_product',\n  dimensions: [\n    { name: 'category', label: 'Category', field: 'category', type: 'string' },\n  ],\n  measures: [\n    { name: 'product_count', label: 'Products', aggregate: 'count' },\n    { name: 'list_price_sum', label: 'Total List Price', aggregate: 'sum', field: 'list_price', format: '0,0' },\n  ],\n});\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/sales/reports/index.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/sales/reports\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/sales/reports/index.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\n/**\n * Report Definitions Barrel\n *\n * ## Why these files annotate with `Report`, not `ReportInput`\n *\n * ObjectStack 17.0.0-rc.6 retired the `ReportInput` export and moved the bare\n * name onto the authoring shape, under the ADR-0122 convention that `X` is the\n * INPUT type and `XParsed` the post-parse one (defaults applied, transforms\n * run). The underlying type is unchanged \u2014 `z.input<typeof ReportSchema>`,\n * exactly what `ReportInput` named \u2014 so the annotations below still mean\n * \"authoring shape: optional fields with defaults may be omitted\".\n *\n * The rename is worth writing down because on rc.5 the name `Report` meant the\n * OPPOSITE (`z.infer`, the parsed shape). Anything that was annotated `Report`\n * before the upgrade silently changed meaning instead of failing to compile;\n * only `ReportInput` \u2014 removed outright \u2014 announced itself, via\n * `tsc --noEmit`. The same swap applies to `Action`, `Dashboard` and `Page`,\n * which this app also imports from `@objectstack/spec/ui` and which are all\n * used on authoring literals, i.e. the side the swap made more correct.\n */\n\nexport { AccountsByIndustryTypeReport } from './account.report';\nexport { LeadInflowByMonthSourceReport } from './lead.report';\nexport {\n  OpportunitiesByStageReport,\n  WonOpportunitiesByOwnerReport,\n  PipelineCoverageByQuarterReport,\n  OpportunityFunnelByOwnerStageReport,\n} from './opportunity.report';\nexport { CustomerChurnSignalsReport } from './churn.report';\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/sales/reports/account.report.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/sales/reports\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/sales/reports/account.report.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport type { Report } from '@objectstack/spec/ui';\n\nexport const AccountsByIndustryTypeReport: Report = {\n  name: 'accounts_by_industry_type',\n  label: 'Accounts by Industry and Type',\n  description: 'Matrix report showing accounts by industry and type',\n  dataset: 'account_metrics', rows: ['industry'], columns: ['type'], values: ['account_count', 'annual_revenue_sum'],\n  type: 'matrix',\n  runtimeFilter: { is_active: true },\n};\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/sales/reports/lead.report.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/sales/reports\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/sales/reports/lead.report.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport type { Report } from '@objectstack/spec/ui';\n\n/**\n * Lead engagement trend \u2014 matrix over `last_contacted_date` (a user-managed\n * datetime, so it can be set in seed data and varied across months for a\n * realistic demo). Lets a marketing-ops lead spot which channels we're\n * actively working month-over-month.\n *\n * `lead_metrics.last_contacted_date` declares the month bucket, so each column\n * represents one calendar month instead of a raw timestamp.\n */\nexport const LeadInflowByMonthSourceReport: Report = {\n  name: 'lead_inflow_by_month_source',\n  label: 'Lead Engagement by Month \u00D7 Source',\n  description: 'Contacted-lead volume per month, broken down by acquisition channel',\n  dataset: 'lead_metrics', rows: ['lead_source'], columns: ['last_contacted_date'], values: ['lead_count'],\n  type: 'matrix',\n  // A never-contacted lead has no engagement month, and grouping it produced a\n  // headerless '\u2014' column next to the real ones. This report counts CONTACTED\n  // leads (see the label/description), so the empty bucket is excluded at the\n  // source rather than rendered as a mystery column.\n  runtimeFilter: { last_contacted_date: { $ne: null } },\n};\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/sales/reports/opportunity.report.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/sales/reports\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/sales/reports/opportunity.report.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport type { Report } from '@objectstack/spec/ui';\n\nexport const OpportunitiesByStageReport: Report = {\n  name: 'opportunities_by_stage',\n  label: 'Opportunities by Stage',\n  description: 'Summary of opportunities grouped by stage',\n  dataset: 'opportunity_metrics', rows: ['stage'], values: ['total_amount', 'avg_probability'],\n  type: 'summary',\n  // `{current_year_start}` is a spec date macro (DATE_MACRO_TOKENS) resolved\n  // per-query, so the YTD window rolls with time instead of freezing the year\n  // the artifact was built into dist/objectstack.json.\n  runtimeFilter: { stage: { $ne: 'closed_lost' }, close_date: { $gte: '{current_year_start}' } },\n  chart: { type: 'bar', title: 'Pipeline by Stage', showLegend: true, xAxis: 'stage', yAxis: 'total_amount' }\n};\n\nexport const WonOpportunitiesByOwnerReport: Report = {\n  name: 'won_opportunities_by_owner',\n  label: 'Won Opportunities by Owner',\n  description: 'Closed won opportunities grouped by owner',\n  dataset: 'opportunity_metrics', rows: ['owner'], values: ['total_amount'],\n  type: 'summary',\n  runtimeFilter: { stage: 'closed_won' },\n  chart: { type: 'column', title: 'Revenue by Sales Rep', showLegend: false, xAxis: 'owner', yAxis: 'total_amount' }\n};\n\n/**\n * Quarterly pipeline coverage \u2014 the matrix view that powers the classic\n * sales-ops \"pipeline coverage\" conversation: each forecast category against\n * the quarter the deal is expected to close in. `close_quarter` is a dedicated\n * quarterly dimension over the same field; the trend widgets keep their\n * monthly `close_date` dimension.\n */\nexport const PipelineCoverageByQuarterReport: Report = {\n  name: 'pipeline_coverage_by_quarter',\n  label: 'Pipeline Coverage by Forecast \u00D7 Quarter',\n  description: 'Open pipeline amount by forecast category, bucketed by close quarter',\n  dataset: 'opportunity_metrics', rows: ['forecast_category'], columns: ['close_quarter'], values: ['total_amount', 'opp_count'],\n  type: 'matrix',\n  runtimeFilter: { stage: { $nin: ['closed_won', 'closed_lost'] } },\n};\n\n/**\n * Sales-rep funnel \u2014 two-level summary that mirrors how reps drill into their\n * own book of business. Exercises multi-level `rows` grouping (owner \u2192 stage)\n * over the dataset's measures.\n */\nexport const OpportunityFunnelByOwnerStageReport: Report = {\n  name: 'opportunity_funnel_owner_stage',\n  label: 'Opportunity Funnel by Owner \u2192 Stage',\n  description: 'Per-rep stage-by-stage pipeline funnel',\n  dataset: 'opportunity_metrics', rows: ['owner', 'stage'], values: ['total_amount', 'opp_count', 'avg_probability'],\n  type: 'summary',\n  runtimeFilter: { stage: { $ne: 'closed_lost' } },\n  chart: { type: 'funnel', title: 'Pipeline Funnel', showLegend: false, xAxis: 'stage', yAxis: 'total_amount' },\n};\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/sales/reports/churn.report.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/sales/reports\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/sales/reports/churn.report.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport type { Report } from '@objectstack/spec/ui';\n\n/**\n * Customer Churn Signals \u2014 a \"joined\" report that gives a Customer Success\n * Manager a one-screen view of the four populations that matter for\n * proactive churn intervention:\n *\n *   1. CSM-Flagged          \u2014 accounts a human has marked at_risk / churning\n *   2. At-Risk Accounts     \u2014 active accounts with no activity in 60+ days\n *   3. Silent High-Value    \u2014 strategic/enterprise accounts gone quiet (90+ days)\n *   4. Recently Closed-Lost \u2014 opportunities lost in the last 30 days\n *\n * Each block is an independent sub-report; the joined renderer stacks them\n * vertically. There is no container-level filter on this report \u2014 each block\n * carries its own scope because they query different objects (`crm_account`,\n * `crm_opportunity`) at different time horizons.\n *\n * Block 1 is deliberately FIRST and deliberately not time-windowed. Blocks 2-4\n * are all derived signals: the clock stopped, the tier is quiet, the deal was\n * lost. `crm_account.health_score` is the only churn signal in the model a\n * person *asserts* \u2014 a CSM who has been in the room sets `at_risk` or\n * `churning` by hand \u2014 so it is the strongest evidence on the page and it is\n * independent of every window below it. An account that is being talked to\n * daily and is still churning is invisible to blocks 2-4 by construction, and\n * that account is the whole reason this block exists (#1186).\n *\n * Time windows use the spec's date-macro placeholders (`{60_days_ago}`, \u2026,\n * DATE_MACRO_TOKENS in @objectstack/spec/data), which resolve per-query.\n * Computing the dates at module load froze them into dist/objectstack.json,\n * so every window silently stopped rolling on the day the artifact was built.\n *\n * Joined Reports demonstrate the spec's M3 capability: multi-block analytic\n * surfaces with shared chrome but independent data binding.\n */\nexport const CustomerChurnSignalsReport: Report = {\n  name: 'customer_churn_signals',\n  label: 'Customer Churn Signals',\n  description:\n    'Three-panel early-warning view: at-risk customers, silent high-value accounts, and recently-lost opportunities.',\n  type: 'joined',\n  blocks: [\n    {\n      // Named for the ACTOR, not the value, because `at_risk` is also a\n      // `health_score` option and `at_risk_accounts` is already the block\n      // below (a time window, nothing to do with the field). The two are\n      // allowed to overlap: this one asks \"who did a human flag\", that one\n      // asks \"whose clock stopped\".\n      name: 'csm_flagged_accounts',\n      label: 'CSM-Flagged Accounts',\n      description:\n        'Accounts a CSM has hand-flagged as at-risk or churning, grouped by type \u2014 human judgement, independent of the activity clock.',\n      type: 'summary',\n      dataset: 'account_metrics', rows: ['type'], values: ['account_count'],\n      // No date term on purpose (see the header). `is_active` matches the two\n      // account blocks below: a deactivated account has already churned, so it\n      // is not a retention queue item. Grouping by `type` separates a flagged\n      // CUSTOMER (revenue at risk today) from a flagged prospect or partner,\n      // which the grid view `crm_account.at_risk_accounts` cannot show \u2014 it is\n      // scoped to `type: 'customer'` before anything else.\n      runtimeFilter: {\n        is_active: true,\n        health_score: { $in: ['at_risk', 'churning'] },\n      },\n    },\n    {\n      name: 'at_risk_accounts',\n      label: 'At-Risk Accounts',\n      description: 'Active accounts with no activity in 60+ days, grouped by industry.',\n      type: 'summary',\n      dataset: 'account_metrics', rows: ['industry'], values: ['account_count'],\n      runtimeFilter: {\n        is_active: true,\n        last_activity_date: { $lt: '{60_days_ago}' },\n      },\n    },\n    {\n      name: 'silent_high_value',\n      label: 'Silent High-Value Accounts',\n      description: 'Strategic and enterprise accounts gone quiet for 90+ days, grouped by type.',\n      type: 'summary',\n      dataset: 'account_metrics', rows: ['type'], values: ['account_count'],\n      // \"High-value\" is the account's tier, not a revenue threshold: the\n      // strategic/enterprise tiers are exactly the book the CSM team owns.\n      runtimeFilter: {\n        is_active: true,\n        tier: { $in: ['strategic', 'enterprise'] },\n        last_activity_date: { $lt: '{90_days_ago}' },\n      },\n    },\n    {\n      name: 'recently_closed_lost',\n      label: 'Recently Lost Opportunities',\n      description: 'Opportunities closed-lost in the last 30 days \u2014 investigate before the customer fully churns.',\n      type: 'summary',\n      dataset: 'opportunity_metrics', rows: ['owner'], values: ['total_amount', 'opp_count'],\n      runtimeFilter: {\n        stage: 'closed_lost',\n        close_date: { $gte: '{30_days_ago}' },\n      },\n    },\n  ],\n};\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/sales/mappings/index.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/sales/mappings\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/sales/mappings/index.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\n/**\n * Import mapping barrel.\n *\n * Each entry is a reusable, governed column\u2192field projection referenced by\n * name from the import endpoint (`mappingName: 'crm_account_import'`), so a\n * customer loading their own spreadsheet never has to map columns by hand.\n * Templates with the matching headers live in `assets/import-templates/`, and\n * the business-facing walkthrough is\n * `content/docs/guides/importing-your-data.mdx`.\n */\n\nexport { AccountImportMapping } from './account_import.mapping';\nexport { ContactImportMapping } from './contact_import.mapping';\nexport { LeadImportMapping } from './lead_import.mapping';\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/sales/mappings/account_import.mapping.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/sales/mappings\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/sales/mappings/account_import.mapping.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport { defineMapping } from '@objectstack/spec/data';\nimport { INDUSTRY_SYNONYMS } from './_shared';\n\n/**\n * Account import mapping \u2014 \"here is my accounts spreadsheet, load it\".\n *\n * Used by passing `mappingName: 'crm_account_import'` to the import endpoint\n * (`POST /api/v1/data/crm_account/import/jobs`) instead of hand-building a\n * per-column mapping in the request. The columns below are the ones a normal\n * CRM/spreadsheet export carries; `assets/import-templates/accounts.csv` is a\n * ready-made sheet with exactly these headers.\n *\n * Behaviour worth knowing before changing anything here:\n *\n * - **Strict projection.** A named mapping emits ONLY the targets listed\n *   below \u2014 every other column in the customer's file is dropped rather than\n *   passed through (`packages/rest/src/import-mapping.ts`). That is the point:\n *   an export from another system carries dozens of columns that must not\n *   reach the write path. It also means a field that is not listed here can\n *   never be imported through this mapping.\n * - **Upsert key.** `crm_account.name` carries a unique index, so it is the\n *   natural business key: re-running the same file updates rather than\n *   duplicates. Source names are matched verbatim \u2014 the import path has no\n *   case/whitespace normalisation step, so \"Acme Corp\" and \"ACME Corp\" are two\n *   accounts. `trimWhitespace` (on by default) removes padding only.\n * - **`mode` / `upsertKey` are DEFAULTS.** An explicit `writeMode` /\n *   `matchFields` in the request still wins.\n */\nexport const AccountImportMapping = defineMapping({\n  name: 'crm_account_import',\n  label: 'Account Import (CSV)',\n  targetObject: 'crm_account',\n  sourceFormat: 'csv', // also accepted for .xlsx uploads \u2014 both are tabular\n  mode: 'upsert',\n  upsertKey: ['name'],\n\n  fieldMapping: [\n    { source: 'Account Name', target: 'name' },\n\n    {\n      source: 'Account Type',\n      target: 'type',\n      transform: 'map',\n      params: {\n        valueMap: {\n          'Client': 'customer',\n          'Reseller': 'partner',\n          'Churned': 'former',\n          'Lost Customer': 'former',\n        },\n      },\n    },\n\n    {\n      source: 'Industry',\n      target: 'industry',\n      transform: 'map',\n      params: { valueMap: INDUSTRY_SYNONYMS },\n    },\n\n    // The account hook rejects a website that is not http(s) \u2014 keep full URLs\n    // in the source sheet (see `src/sales/objects/account.hook.ts`).\n    { source: 'Website', target: 'website' },\n    { source: 'Phone', target: 'phone' },\n    { source: 'Annual Revenue', target: 'annual_revenue' },\n    { source: 'Employees', target: 'number_of_employees' },\n    { source: 'Description', target: 'description' },\n\n    // Owner resolution. VERIFIED against the platform import path\n    // (`packages/rest/src/import-runner.ts` \u2192 `resolveRef`): a reference cell\n    // is resolved against the referenced object by `id`, the field's\n    // `displayField`, then `name` / `title` / `label` / `full_name` / `email` /\n    // `username`. `sys_user` has an `email` column, so an owner-email cell\n    // resolves to that user's id \u2014 no separate resolution step is needed here.\n    // An address that matches no user FAILS the row (`reference_not_found`);\n    // leaving the cell BLANK is the supported fallback \u2014 the security\n    // middleware's insert-time stamp then makes the importing user the owner\n    // (the import write carries the importer's context, not `isSystem`).\n    //\n    // The target is `owner_id`, the platform ownership anchor \u2014 #548 retired\n    // the app-authored `owner` lookup this used to name. A resolved cell is\n    // therefore an ownership TRANSFER: it plants the row under someone other\n    // than the importer, which the #3004 guard denies unless the importing user\n    // holds `allowTransfer` (system_admin / sales_manager do). That is the\n    // intended posture \u2014 a bulk file that silently reassigns the book is\n    // exactly what the grant exists to gate.\n    { source: 'Account Owner Email', target: 'owner_id', transform: 'lookup' },\n\n    // Self-reference: a parent named later in the same file still resolves \u2014\n    // the runner flushes buffered creates and retries once (framework#3148).\n    { source: 'Parent Account', target: 'parent_account', transform: 'lookup' },\n\n    // NOT MAPPED \u2014 `billing_address` / `office_location` are structured\n    // (json-backed `address` / `location`) fields. A joined string is not a\n    // way in: the engine rejects it per row \u2014 measured, `Billing Address has an\n    // invalid address value: Invalid input: expected object, received string`.\n    // (The dry run does NOT predict that rejection; it reports the row ok.\n    // Framework-side, filed as objectstack-ai/objectstack#4633.)\n    // Address columns are therefore left out of the account template. A target\n    // may now name a declared PART of a compound field \u2014 `contact_import.mapping.ts`\n    // maps five columns into `mailing_address.street` \u2026 `.country` (#1836) \u2014 so\n    // adding address columns here would be a template change, not a platform gap.\n  ],\n});\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/sales/mappings/_shared.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/sales/mappings\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/sales/mappings/_shared.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\n/**\n * Shared value maps for the import mappings.\n *\n * The import path already matches a picklist cell against the field's option\n * VALUE exactly and its LABEL case-insensitively (`import-coerce.ts` \u2192\n * `matchOption`), so \"Technology\" (label) and \"technology\" (value) both land\n * without any help from us \u2014 but an upper-cased value does NOT: \"HR\" is\n * neither the value `hr` nor the label \"Human Resources\" (#1998). These maps\n * exist only for the vocabulary a spreadsheet uses that matches no option \u2014\n * the words a Salesforce/HubSpot/Excel export writes that HotCRM has no option\n * for (\"SaaS\", \"Trade Show\", \"Client\"), and the abbreviations our own shipped\n * templates write (\"HR\"). Anything not listed here falls through\n * untouched and is matched normally; an unknown value fails its row with\n * `invalid_option` rather than being silently dropped.\n *\n * Keep these lists small and defensible. They are a translation table for\n * known synonyms, NOT a \"make any spreadsheet work\" fallback \u2014 every entry\n * here is a value a real export produces, and the row-level error is the\n * intended outcome for everything else.\n */\n\n/** Foreign spellings \u2192 `INDUSTRY_OPTIONS` values (`src/sales/objects/_picklists.ts`). */\nexport const INDUSTRY_SYNONYMS: Record<string, string> = {\n  'SaaS': 'software',\n  'Saas': 'software',\n  'IT': 'technology',\n  'Tech': 'technology',\n  'Information Technology': 'technology',\n  'Financial Services': 'finance',\n  'Banking': 'finance',\n  'Insurance': 'finance',\n  'Health Care': 'healthcare',\n  'Pharmaceuticals': 'healthcare',\n  'E-commerce': 'retail',\n  'Ecommerce': 'retail',\n  'Consumer Goods': 'retail',\n  'Transportation': 'logistics',\n  'Utilities': 'energy',\n  'Oil & Gas': 'energy',\n  'Public Sector': 'government',\n  'Non Profit': 'nonprofit',\n  'Non-Profit': 'nonprofit',\n  'NGO': 'nonprofit',\n  'Travel & Hospitality': 'hospitality',\n};\n\n/** Foreign spellings \u2192 `LEAD_SOURCE_OPTIONS` values. */\nexport const LEAD_SOURCE_SYNONYMS: Record<string, string> = {\n  'Website': 'web',\n  'Web Site': 'web',\n  'Inbound': 'web',\n  'Word of mouth': 'referral',\n  'Customer Referral': 'referral',\n  'Trade Show': 'event',\n  'Conference': 'event',\n  'Seminar': 'webinar',\n  'Partner Referral': 'partner',\n  'Google Ads': 'paid_search',\n  'AdWords': 'paid_search',\n  'SEM': 'paid_search',\n  'LinkedIn': 'social',\n  'Facebook': 'social',\n  'X': 'social',\n  'Twitter': 'social',\n  'Blog': 'content',\n  'Whitepaper': 'content',\n  'Phone Inquiry': 'cold_call',\n  'Outbound': 'cold_call',\n  'Email': 'email_campaign',\n  'Newsletter': 'email_campaign',\n};\n\n/**\n * Spellings \u2192 `crm_contact.department` option values. The shipped\n * `assets/import-templates/contacts.csv` writes eight departments; seven are\n * option labels and land unaided, \"HR\" is the one that matches nothing (#1998).\n * \u26D4 The template is a customer-facing contract (#1836) \u2014 the fix lives here,\n * not in the file.\n */\nexport const DEPARTMENT_SYNONYMS: Record<string, string> = {\n  'HR': 'hr',\n};\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/sales/mappings/contact_import.mapping.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/sales/mappings\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/sales/mappings/contact_import.mapping.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport { defineMapping } from '@objectstack/spec/data';\nimport { DEPARTMENT_SYNONYMS, LEAD_SOURCE_SYNONYMS } from './_shared';\n\n/**\n * Contact import mapping \u2014 see `account_import.mapping.ts` for the shared\n * notes on strict projection and on `mode` / `upsertKey` acting as defaults.\n *\n * Contact-specific things to know:\n *\n * - **Accounts first.** `crm_contact.crm_account` is a REQUIRED master-detail\n *   link, so the \"Account Name\" column must name an account that already\n *   exists. Import accounts before contacts; a row whose account cannot be\n *   resolved fails with `reference_not_found` and nothing is written for it.\n * - **Email is the business key.** It is `required` + `unique` on the object,\n *   and `crm_contact`'s hook lowercases it and rejects a second contact with\n *   the same address \u2014 so `upsertKey: ['email']` matches how the object\n *   already behaves rather than inventing a second notion of identity.\n * - Address: the template's five `Mailing \u2026` columns stay as they are, and\n *   each one targets a part of the structured `mailing_address` field\n *   (`mailing_address.street`, \u2026) \u2014 the customer's file did not change when\n *   the five flat `mailing_*` fields became one `Field.address()` (#1836).\n */\nexport const ContactImportMapping = defineMapping({\n  name: 'crm_contact_import',\n  label: 'Contact Import (CSV)',\n  targetObject: 'crm_contact',\n  sourceFormat: 'csv',\n  mode: 'upsert',\n  upsertKey: ['email'],\n\n  fieldMapping: [\n    { source: 'Salutation', target: 'salutation' },\n    { source: 'First Name', target: 'first_name' },\n    { source: 'Last Name', target: 'last_name' },\n\n    // Required master-detail parent; resolved by account name.\n    { source: 'Account Name', target: 'crm_account', transform: 'lookup' },\n\n    { source: 'Title', target: 'title' },\n    {\n      source: 'Department',\n      target: 'department',\n      transform: 'map',\n      params: { valueMap: DEPARTMENT_SYNONYMS },\n    },\n    { source: 'Email', target: 'email' },\n    { source: 'Phone', target: 'phone' },\n    { source: 'Mobile', target: 'mobile' },\n\n    // Five template columns, one structured field: each column names a part\n    // of `mailing_address`, and the import assembles the parts one row maps\n    // into that field's single value.\n    { source: 'Mailing Street', target: 'mailing_address.street' },\n    { source: 'Mailing City', target: 'mailing_address.city' },\n    { source: 'Mailing State', target: 'mailing_address.state' },\n    { source: 'Mailing Postal Code', target: 'mailing_address.postalCode' },\n    { source: 'Mailing Country', target: 'mailing_address.country' },\n\n    {\n      source: 'Lead Source',\n      target: 'lead_source',\n      transform: 'map',\n      params: { valueMap: LEAD_SOURCE_SYNONYMS },\n    },\n\n    { source: 'Description', target: 'description' },\n\n    // Owner-email resolution, the blank-cell fallback, and why a filled cell\n    // needs `allowTransfer`: see the long note in `account_import.mapping.ts`.\n    { source: 'Contact Owner Email', target: 'owner_id', transform: 'lookup' },\n  ],\n});\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/sales/mappings/lead_import.mapping.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/sales/mappings\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/sales/mappings/lead_import.mapping.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport { defineMapping } from '@objectstack/spec/data';\nimport { INDUSTRY_SYNONYMS, LEAD_SOURCE_SYNONYMS } from './_shared';\n\n/**\n * Lead import mapping \u2014 see `account_import.mapping.ts` for the shared notes\n * on strict projection and on `mode` / `upsertKey` acting as defaults.\n *\n * Lead-specific things to know:\n *\n * - **Email is the business key** (`required` on the object), so a re-run of\n *   the same file updates the existing lead instead of creating a twin.\n * - **`status` has a default of `new`** \u2014 leave the column blank and the lead\n *   lands as New. `crm_lead`'s state machine only accepts an initial status,\n *   so importing a mid-lifecycle status is a normal write here, not a\n *   transition.\n * - **A blank owner lands with the IMPORTER, not with auto-assignment.**\n *   `lead_auto_assign` (`src/sales/objects/lead.hook.ts`) only routes a lead whose\n *   `owner_id` is still empty when the hook runs \u2014 and the import write carries\n *   the importer's own context, so the security middleware has ALREADY stamped\n *   `owner_id` to them by the time `beforeInsert` runs (the guard is an\n *   operation middleware, outside the hook phase). Measured on a real import\n *   before #548, when a field `defaultValue` produced the same outcome one step\n *   earlier: all 50 template rows landed owned by the importing user, none by\n *   the round-robin. Fill \"Lead Owner Email\" when the source file knows who\n *   owns the lead; otherwise reassign after the import.\n */\nexport const LeadImportMapping = defineMapping({\n  name: 'crm_lead_import',\n  label: 'Lead Import (CSV)',\n  targetObject: 'crm_lead',\n  sourceFormat: 'csv',\n  mode: 'upsert',\n  upsertKey: ['email'],\n\n  fieldMapping: [\n    { source: 'Salutation', target: 'salutation' },\n    { source: 'First Name', target: 'first_name' },\n    { source: 'Last Name', target: 'last_name' },\n    { source: 'Company', target: 'company' },\n    { source: 'Title', target: 'title' },\n\n    {\n      source: 'Industry',\n      target: 'industry',\n      transform: 'map',\n      params: { valueMap: INDUSTRY_SYNONYMS },\n    },\n\n    { source: 'Email', target: 'email' },\n    { source: 'Phone', target: 'phone' },\n    { source: 'Mobile', target: 'mobile' },\n    { source: 'Website', target: 'website' },\n\n    {\n      source: 'Lead Status',\n      target: 'status',\n      transform: 'map',\n      params: {\n        valueMap: {\n          'Open': 'new',\n          'Working': 'contacted',\n          'In Progress': 'contacted',\n          'Nurturing': 'contacted',\n          'Disqualified': 'unqualified',\n          'Closed - Not Converted': 'unqualified',\n        },\n      },\n    },\n\n    {\n      source: 'Lead Source',\n      target: 'lead_source',\n      transform: 'map',\n      params: { valueMap: LEAD_SOURCE_SYNONYMS },\n    },\n\n    { source: 'Annual Revenue', target: 'annual_revenue' },\n    { source: 'Employees', target: 'number_of_employees' },\n    { source: 'Description', target: 'description' },\n\n    // Owner-email resolution and the `allowTransfer` gate on a filled cell:\n    // see the long note in `account_import.mapping.ts`. The blank-cell\n    // behaviour differs \u2014 see the header comment above.\n    { source: 'Lead Owner Email', target: 'owner_id', transform: 'lookup' },\n\n    // NOT MAPPED \u2014 `crm_lead.address` is a structured (json-backed) `address`\n    // field; the import path cannot compose one from separate street/city/\n    // postcode columns, and a joined string is rejected per row. Same\n    // reasoning, and the same measurement, as the account mapping.\n  ],\n});\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/sales/apps/index.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/sales/apps\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/sales/apps/index.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\n/**\n * App Definitions Barrel\n */\n\nexport { CrmApp } from './crm.app';\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/sales/apps/crm.app.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/sales/apps\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/sales/apps/crm.app.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport { App } from '@objectstack/spec/ui';\n\n// The brand mark, inlined as a `data:` URI of `assets/icon.svg` (#2051), so it\n// travels inside the published artifact. The path it replaces,\n// `/runtime/assets/icon.svg` (#731), resolves only under `objectstack serve`\n// run from this repo \u2014 the CLI's `createRuntimeAssetsPlugin` mounts the\n// project's `assets/` there. A hosted install runs the artifact, which carried\n// the path but not the file, and its runtime mounts no `/runtime/assets/`: the\n// logo answered 404 on every hosted environment. The SVG's own bytes, with only\n// `%`, `#` and line breaks percent-encoded: a raw `#` would start a URL fragment\n// and a raw newline is stripped by the URL parser. `assets/icon.svg` stays the\n// single source \u2014 `test/app-branding-icon.test.ts` decodes this URI as a browser\n// does and requires the file's exact bytes back, so edit the file, then this.\nconst HOTCRM_ICON =\n  'data:image/svg+xml,' +\n  '<svg width=\"256\" height=\"256\" viewBox=\"0 0 256 256\" fill=\"none\" xmlns=\"http://www.w3.org/2000/svg\" role=\"img\" aria-label=\"HotCRM\">%0A' +\n  '  <rect x=\"16\" y=\"16\" width=\"224\" height=\"224\" rx=\"56\" fill=\"%23EA580C\"/>%0A' +\n  '  <path d=\"M76 64h40v52h24V64h40v128h-40v-52h-24v52H76z\" fill=\"%23FFFFFF\"/>%0A' +\n  '</svg>%0A';\n\n/**\n * HotCRM \u2014 navigation.\n *\n * Intentionally narrow. The app sells one story: \"the CRM that rewrites\n * itself when your business changes,\" and `content/docs/whats-new.mdx`\n * promises a nav \"a new user can find their way around in 30 seconds.\"\n *\n * ## One entry per destination, one exemplar per nav-item type (#1259)\n *\n * The sidebar had grown to 7 groups / 31 items, almost entirely through one\n * pattern: the same object surfaced again and again through its own views \u2014\n * `crm_event` had four entries, `crm_opportunity` three \u2014 while every list\n * page already carries a view-switcher tab strip that reaches all of them.\n * Those redundant view entries are gone; each removed destination stays one\n * click away on its object's tab strip \u2014 which the console builds from the\n * VIEW DESCRIPTORS in `src/<pkg>/views/*.view.ts`: the primary `list` plus every\n * `listViews` entry, one tab each, carrying that view's own `label`. So\n * reachability needs nothing authored; a `listViews` entry is on the strip by\n * existing. What `test/view-references.test.ts` \u2192 \"every named list view is\n * reachable\" holds is the half that CAN dangle \u2014 a navigation entry naming a\n * view no view file defines.\n *\n * What is NOT trimmed is the demonstration. This is the exemplar app, and\n * nav items come in six kinds \u2014 plain `object`, object + `viewName` (a view\n * entry), `page`, `dashboard`, `report`, `component`. **Every kind keeps at\n * least one entry**, because showing an author what each kind looks like is\n * part of what this app is for. `test/app-navigation-shape.test.ts` pins that\n * floor, so a future slimming pass cannot delete the last exemplar of a kind\n * without going red.\n *\n * Personalisation rides the platform's pin + recent mechanisms rather than\n * pre-materialising every possible entry for every user.\n */\nexport const CrmApp = App.create({\n  name: 'crm_enterprise',\n  label: 'HotCRM',\n  icon: 'briefcase',\n  // ADR-0063 \u00A71/\u00A72 \u2014 `defaultAgent` is a surface binding, not a custom-agent\n  // slot: the only resolvable values are the two PLATFORM agents, `ask` (data\n  // surface) and `build` (authoring surface). HotCRM is a data surface, so it\n  // binds `ask`; the app's own AI capability ships as skills (`src/*/skills/`),\n  // which attach to the platform agents by `surface` affinity. The app-authored\n  // agents this key used to name were retired in #512.\n  defaultAgent: 'ask',\n  // `logo` and `favicon` are the inlined `HOTCRM_ICON` above (#2051), never a\n  // server path: an install serves only what the artifact carries. The console\n  // passes each value through untouched \u2014 `logo` as the sidebar's `<img src>`,\n  // `favicon` as the favicon `link.href` \u2014 and a `data:` URI renders in both.\n  // `primaryColor` is the icon's tile fill (#2066): the mark and the theme are one orange.\n  branding: {\n    primaryColor: '#EA580C',\n    logo: HOTCRM_ICON,\n    favicon: HOTCRM_ICON,\n  },\n\n  navigation: [\n    // Pinned landing \u2014 single executive view, single click from launcher.\n    {\n      id: 'nav_home',\n      type: 'dashboard',\n      dashboardName: 'executive_dashboard',\n      label: 'Home',\n      icon: 'home',\n    },\n\n    {\n      id: 'group_sales',\n      type: 'group',\n      label: 'Sales',\n      icon: 'chart-line',\n      expanded: true,\n      children: [\n        { id: 'nav_lead',        type: 'object', objectName: 'crm_lead',        label: 'Leads',         icon: 'user-plus' },\n        { id: 'nav_account',     type: 'object', objectName: 'crm_account',     label: 'Accounts',      icon: 'building' },\n        // ADR-0047 interface page \u2014 the curated counterpart to the Accounts\n        // object entry (quick filters only; activates with spec > 9.2.0).\n        { id: 'nav_account_workbench', type: 'page', pageName: 'account_workbench', label: 'Account Workbench', icon: 'sliders-horizontal' },\n        { id: 'nav_contact',     type: 'object', objectName: 'crm_contact',     label: 'Contacts',      icon: 'user' },\n        // No separate \"Pipeline\" entry: the kanban board is another tab on\n        // this same list page \u2014 `pipeline_kanban` in\n        // `OpportunityViews.listViews`, which the switcher puts on the strip\n        // under its own label, *Sales Pipeline* \u2014 one click from here and\n        // zero clicks further than a second sidebar row. The\n        // view-entry exemplar duty this item used to carry now sits with the\n        // \"My Work\" items below, which are all object + `viewName`.\n        { id: 'nav_opportunity', type: 'object', objectName: 'crm_opportunity', label: 'Opportunities', icon: 'target' },\n        { id: 'nav_quote',       type: 'object', objectName: 'crm_quote',       label: 'Quotes',        icon: 'receipt' },\n        // Contracts close the sales cycle: quote \u2192 signed agreement \u2192 renewal.\n        // The object, its views and its renewal automation all shipped, but\n        // there was no way to reach any of it from the app.\n        { id: 'nav_contract',    type: 'object', objectName: 'crm_contract',    label: 'Contracts',     icon: 'file-signature' },\n        // Products sit here, not under Marketing (#1259): they are the\n        // revenue master data every quote line and opportunity line item\n        // points at \u2014 a sales object that happened to be filed next to\n        // campaigns.\n        { id: 'nav_product',     type: 'object', objectName: 'crm_product',     label: 'Products',      icon: 'package' },\n        { id: 'nav_sales_dashboard', type: 'dashboard', dashboardName: 'sales_dashboard', label: 'Sales Performance', icon: 'chart-line' },\n      ],\n    },\n\n    {\n      // Everything a rep owes someone. `crm_task` had views, seed data, a\n      // recurrence hook and two reminder flows, and no entry point \u2014 the only\n      // way to see a task was to open the record it hung off.\n      id: 'group_work',\n      type: 'group',\n      label: 'My Work',\n      icon: 'list-checks',\n      expanded: true,\n      // These are ListViews: they list the records themselves, which a\n      // dashboard widget (an aggregate over a dataset, ADR-0021) cannot. Both\n      // surfaces resolve `{current_user_id}` since objectstack#12230 \u2014 the\n      // Service dashboard's \"My Open Cases by Priority\" is the aggregate\n      // counterpart of \"My Cases\" (#510).\n      //\n      // Every item here is object + `viewName`, which makes this group the\n      // app's view-entry exemplar since #1259 retired the \"Pipeline\" row.\n      // The one exception is the approvals Inbox at the bottom \u2014 a\n      // `component` entry, and the app's only one.\n      children: [\n        { id: 'nav_my_tasks', type: 'object', objectName: 'crm_task', viewName: 'my_open_tasks', label: 'My Tasks', icon: 'circle-check' },\n        { id: 'nav_my_deals', type: 'object', objectName: 'crm_opportunity', viewName: 'my_open_deals', label: 'My Deals', icon: 'target' },\n        { id: 'nav_my_leads', type: 'object', objectName: 'crm_lead', viewName: 'my_leads', label: 'My Leads', icon: 'user-plus' },\n        // #592 \u2014 the rep's own calendar: a list of events, so a view, not a\n        // dashboard.\n        { id: 'nav_my_calendar', type: 'object', objectName: 'crm_event', viewName: 'my_events', label: 'My Calendar', icon: 'calendar-days' },\n        // No \"All Tasks\" entry: \"My Tasks\" opens the `crm_task` list page,\n        // whose tab strip leads with *All Tasks* \u2014 `TaskViews.list`, name\n        // `all_tasks`. It leads because it is the object's PRIMARY list: the\n        // switcher moves the primary to the front of the strip and marks it\n        // default, so nothing has to be authored to say so. The whole book is\n        // one tab away, and the sidebar keeps one row per object instead of\n        // two.\n        //\n        // \u2500\u2500 The approvals Inbox lives here, not in a group of its own (#1259)\n        //\n        // It used to be the single child of an \"Approvals\" group. Its content\n        // is a personal queue \u2014 the things waiting on *you* \u2014 which is what\n        // this group is; a one-item group next to it was structure without a\n        // distinction. Dissolving that group is why this entry moved, not any\n        // rule against single-item groups (Marketing is one and stays one).\n        //\n        // \"Inbox\" (zh-CN \u5F85\u6211\u5BA1\u6279) must land somewhere an approver can actually\n        // approve. It used to be `type: 'object'` on `sys_approval_request` \u2014\n        // the approvals plugin's raw request table, which is read-only: no row\n        // actions, no approve/reject, only Share on the record detail. The label\n        // promised an action the destination could not perform (#1123).\n        //\n        // `component` \u2014 not `url`. The platform's approval centre is a\n        // first-party console surface registered in the ComponentRegistry as\n        // `approvals:inbox` (registered by @objectstack/console itself, source\n        // `@object-ui/console`, rendering ApprovalsInboxPage) \u2014 exactly what the\n        // spec documents `component` for: \"a first-party UI shipped with the\n        // platform \u2014 typically admin/setup surfaces that have no row in any data\n        // store\". `url` is documented as the *external link* type, and taking it\n        // would mean hard-coding a console-internal route plus this app's own\n        // name (`/apps/crm_enterprise/system/approvals`) into metadata. A\n        // `componentRef` instead resolves against the *current* app base, so the\n        // entry keeps the user inside HotCRM's shell without naming the app, and\n        // a ref that ever stops resolving renders a loud \"Component not\n        // registered\" panel rather than silently bouncing to the console home.\n        //\n        // The read-only object list is not kept as a second \"history\" entry: the\n        // approval centre already subsumes it \u2014 My Pending / Submitted by me /\n        // All tabs plus a status filter (Pending / Approved / Rejected /\n        // Recalled / Returned for revision) \u2014 so a second entry would add a\n        // strictly weaker view of the same rows.\n        //\n        // `requiresObject` is retained: it is a base nav-item field on every\n        // item type, so the entry still hides itself on installs where\n        // @objectstack/plugin-approvals is absent and no approval exists to act\n        // on.\n        //\n        // There is no \"Processes\" item either: @objectstack/plugin-approvals\n        // registers sys_approval_request / sys_approval_action /\n        // sys_approval_approver / sys_approval_delegation \u2014 but neither a bare\n        // `sys_approval` nor a `sys_approval_process` object exists in any\n        // installed plugin (measured on the 17.2.0 rosters),\n        // so the old item's requiresObject guard hid it on every install,\n        // forever.\n        { id: 'nav_approval_requests', type: 'component', componentRef: 'approvals:inbox', label: 'Inbox', icon: 'inbox', requiresObject: 'sys_approval_request' },\n      ],\n    },\n\n    {\n      // #592 \u2014 activity was the app's largest blind spot: `crm_event` and its\n      // attendee rows had nowhere to be seen, and no dashboard anywhere counted\n      // an interaction. Kept as its own group rather than buried under Sales,\n      // because \"what happened with this customer, and when?\" is the question\n      // the whole batch was about.\n      id: 'group_activity',\n      type: 'group',\n      label: 'Activity',\n      icon: 'calendar-days',\n      expanded: true,\n      children: [\n        // One row for the object, one for the dashboard. The calendar and the\n        // interaction history are two more tabs on this same list page \u2014\n        // `event_calendar` and `held_events` in `EventViews.listViews`, which\n        // the switcher puts on the strip under each view's own label \u2014 #1259\n        // removed the sidebar duplicates, not the surfaces. `crm_event` had\n        // four sidebar rows;\n        // it was the single largest source of the nav's growth.\n        { id: 'nav_event',          type: 'object',    objectName: 'crm_event',   label: 'Events',          icon: 'calendar-days' },\n        { id: 'nav_activity_dashboard', type: 'dashboard', dashboardName: 'sales_activity_dashboard', label: 'Sales Activity', icon: 'activity' },\n      ],\n    },\n\n    {\n      // Campaigns drive lead_source and the campaign-member records that\n      // \"Add to Campaign\" writes \u2014 with no nav entry the marketing half of\n      // the data model was invisible.\n      //\n      // A single-item group on purpose (#1259). Marketing is a domain of its\n      // own, and a reader scanning the sidebar for \"where does campaign work\n      // live\" finds it by name. Item-count symmetry is not the goal; the\n      // Approvals group was dissolved because its item *was* personal work,\n      // not because one child is too few.\n      id: 'group_marketing',\n      type: 'group',\n      label: 'Marketing',\n      icon: 'megaphone',\n      children: [\n        { id: 'nav_campaign', type: 'object', objectName: 'crm_campaign', label: 'Campaigns', icon: 'megaphone' },\n      ],\n    },\n\n    {\n      id: 'group_service',\n      type: 'group',\n      label: 'Service',\n      icon: 'headset',\n      expanded: true,\n      // EMPTY ON PURPOSE \u2014 this group is a CONTAINER, not a menu.\n      //\n      // `crm_case`, `crm_knowledge_article`, `service_dashboard` and\n      // `sla_performance` belong to `app.objectstack.hotcrm.service`, and an\n      // app's own `navigation` may not name another package's object (ADR-0130\n      // \u00A71.5): the entry fails at author time with \"references object\n      // `crm_case` which is not defined in objects\". The module puts all three\n      // back through `navigationContributions` (ADR-0029 D7), and it can only\n      // aim at a group the app DECLARES \u2014 a module cannot create one inside an\n      // app it does not own. So the app publishes the anchor and the module\n      // fills it; `src/service/index.ts` holds the other half, and the two\n      // service items of *My Work* and *Insights* come back the same way.\n      //\n      // \u26D4 Do not \"tidy\" the group away: deleting it relocates all three\n      // contributed items to the app's top level with a\n      // `nav_contribution_group_missing` warning.\n      children: [],\n    },\n\n    {\n      id: 'group_insights',\n      type: 'group',\n      label: 'Insights',\n      icon: 'sparkles',\n      children: [\n        // Trimmed to three high-signal reports. Full report catalogue still\n        // ships as metadata; admins can pin more from the report picker.\n        { id: 'nav_crm_dashboard',            type: 'dashboard', dashboardName: 'crm_overview_dashboard', label: 'CRM Overview',      icon: 'layout-dashboard' },\n        { id: 'nav_forecast',                 type: 'object', objectName: 'crm_forecast',                 label: 'Forecasts',         icon: 'trending-up' },\n        { id: 'nav_report_pipeline_coverage', type: 'report', reportName: 'pipeline_coverage_by_quarter', label: 'Pipeline Coverage', icon: 'columns-3' },\n        { id: 'nav_report_lead_inflow',       type: 'report', reportName: 'lead_inflow_by_month_source',  label: 'Lead Inflow',       icon: 'trending-up' },\n      ],\n    },\n\n  ],\n});\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/sales/profiles/index.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/sales/profiles\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/sales/profiles/index.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\n/**\n * Profile Definitions Barrel\n *\n * \u2500\u2500\u2500 `allowExport` \u2014 the opt-in bulk-egress axis (@objectstack 17, #3544) \u2500\u2500\u2500\n *\n * This is the canonical note; the profiles point here.\n *\n * Before 17.0 the export axis was advisory: an unset `allowExport` inherited\n * read, so \"can list \u21D2 can export\" and the bit only ever hid a button. 17.0\n * makes it a real gate and inverts the default \u2014 `resolveUserExportAllowed`\n * (plugin-security) returns true only for an explicit `allowExport: true`, and\n * neither `viewAllRecords` nor `modifyAllRecords` substitutes for it. An unset\n * bit now DENIES.\n *\n * WHERE it is enforced, measured on a running dev server (#798). One route\n * carries bulk egress in this app: `GET /api/v1/data/:object/export`\n * (`csv` / `xlsx` / `json`), gated by `enforceExportPermission` \u2192\n * `security.canExport` in `@objectstack/rest`. A principal holding the grant\n * gets 200 and the rows; one without it gets 403 `EXPORT_NOT_PERMITTED`.\n *\n * A list view's `exportOptions` is NOT a second door \u2014 it declares which\n * formats the toolbar's Export button offers, and that button calls the very\n * same route. So the gate is object-wide and reachable with `curl`, which is\n * exactly why it has to be enforced server-side rather than by hiding a button.\n *\n * SHAPE (@objectstack/spec 17.0.0, #8010, maintainer ruling 2026-08-12): the\n * declaration is the OBJECT form `exportOptions: { formats: ['csv', 'xlsx'] }`.\n * The bare array this app used through 17.0.0-rc.6 is the legacy spelling; it\n * still parses and LIFTS to `{ formats: [...] }`, so `z.input` accepts both\n * while `z.output` \u2014 everything that reads loaded metadata, this app's own\n * guards included \u2014 only ever sees the object. That asymmetry is why the bump\n * to 17.0.0 blinded the guard below rather than failing it: the views still\n * declared their surfaces, and a reader testing the legacy array's `.length`\n * silently measured `undefined` on every one of them. Read `.formats`.\n * `'pdf'` left the format enum in the same change (#1301 NOT_PLANNED); this\n * app never declared it.\n *\n * `ReportService.assertExportAllowed` is a genuinely separate gate, but it\n * belongs to the `reports` capability (saved reports + emailed digests over\n * `sys_saved_report`), which this app does not require \u2014 `/api/v1/reports`\n * answers 501 on a default boot, and the Console's report page ships no export\n * affordance either way. It is not what any grant below lands on. Do not read\n * the rule below as depending on it: #798 was filed on exactly that reading.\n *\n * So the grants below are authored, not inherited. The rule, pinned by\n * `test/authorization-coverage.test.ts`:\n *\n *   a profile grants `allowExport` on an object IFF it already holds\n *   `allowRead` there AND the app ships an export surface for that object \u2014\n *   that is, a list view declaring `exportOptions`.\n *\n * That rule is an AUTHORING DISCIPLINE about which affordances this app ships,\n * not a statement about reachability: the export route exists for every\n * API-exposed object, so a grant on any of them would work. The discipline\n * keeps the grant list to objects a user can actually reach an export from,\n * so the permission table stays a description of the product rather than of\n * the platform. Reachability is pinned separately, by the `enable` guard at\n * the end of that same test file.\n *\n * That union is exactly `crm_account`, `crm_case`, `crm_contact`, `crm_lead`,\n * `crm_opportunity` today, each behind the `exportOptions` on its own list\n * view. Adding `exportOptions` to a view means adding the matching grant here\n * in the same change \u2014 the guard fails otherwise, which is the point: a\n * surface nobody can use is the failure this axis exists to make loud instead\n * of silent.\n *\n * A REPORT IS NOT AN EXPORT SURFACE. The Console's report page renders a chart\n * and a data table and offers no download (measured on a running server in\n * #798), and `ReportService`'s own export gate belongs to the `reports`\n * capability above. Until #817 the guard counted reports anyway, and\n * `crm_case` hung off that leg alone: the grant was live but reachable only by\n * `curl`, and deleting the case reports would have made the guard demand this\n * useful grant be deleted with them. #817 gave the Cases list view its own\n * `exportOptions` and retired the report leg, so a report over some future\n * dataset no longer conjures a grant requirement out of a page with no\n * download button.\n *\n * Export is READ-DERIVED (`export \u2286 list`), so the grant opens the door but\n * does not widen the rows: record scope, RLS and sharing still apply on top. A\n * `sales_rep` exporting `crm_opportunity` gets their own book, not the org's.\n *\n * `guest_portal` deliberately carries none. Per ADR-0090 D9 a set holding\n * `allowExport` is high-privilege and cannot be bound to the `everyone` or\n * `guest` anchors at all \u2014 granting it there would both hand anonymous\n * visitors bulk table egress and make the set unbindable.\n */\n/**\n * \u2500\u2500\u2500 `allowTransfer` \u2014 the ownership-transfer axis (#548) \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n *\n * This is the canonical note; the profiles point here.\n *\n * HotCRM has ONE owner column: the platform's `owner_id`, injected into every\n * business object by the registry (`applySystemFields`) and auto-stamped to the\n * inserting user. It is the column OWD, sharing rules, owner-scope widening and\n * the `is_private` row filter all read \u2014 so whoever can write it decides who may\n * see and edit the row.\n *\n * The app used to author its own `owner` lookup beside it. Reassigning that\n * field moved the record in every list and report and moved NO access at all,\n * and it did so for any user with plain edit rights \u2014 a transfer with none of\n * the transfer semantics. #548 removed it.\n *\n * With one column, ownership writes go through the platform's gate: an\n * insert planting a record under another user, or an update reassigning /\n * disowning one, is DENIED unless the caller holds `allowTransfer` \u2014 enforced\n * today through the ordinary insert/update door, not merely declared\n * (`@objectstack/spec` `permission.zod.ts`, the #3004 owner_id guard).\n * `modifyAllRecords` implies it. Two writes are deliberately NOT transfers and\n * need no grant: an insert leaving `owner_id` empty (auto-stamped to the\n * caller) and a form save echoing the unchanged owner back.\n *\n * The rule the grants below follow, pinned by\n * `test/authorization-coverage.test.ts`:\n *\n *   `allowTransfer` is granted IFF the set already holds `allowEdit` on that\n *   object, and only to `system_admin` (every business object) and\n *   `sales_manager` (exactly the objects it holds `modifyAllRecords` on \u2014 the\n *   sales book it owns the number for).\n *\n * On those objects `modifyAllRecords` already implies the bit, so authoring it\n * grants nothing new. It is authored anyway, for the same reason `allowExport`\n * is: the capability a persona is meant to have should be readable in the\n * profile, and it must survive a future narrowing of `modifyAllRecords` rather\n * than disappearing with it. Reps and service agents hold no transfer grant \u2014\n * for them ownership is assigned, never taken.\n */\n\nexport { GuestPortalProfile } from './guest-portal.profile';\nexport { MarketingUserProfile } from './marketing-user.profile';\nexport { SalesManagerProfile } from './sales-manager.profile';\nexport { SalesRepProfile } from './sales-rep.profile';\nexport { ServiceAgentProfile } from './service-agent.profile';\nexport { ServiceManagerProfile } from './service-agent.profile';\nexport { SystemAdminProfile } from './system-admin.profile';\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/sales/profiles/guest-portal.profile.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/sales/profiles\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/sales/profiles/guest-portal.profile.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\n/**\n * Guest Portal Profile\n *\n * Permission set applied to anonymous (unauthenticated) visitors who submit\n * the public Web-to-Lead and Web-to-Case forms.\n *\n * IRON-CLAD RULE: guests must NEVER be able to read existing CRM data.\n * The only thing they can do is INSERT a new `crm_lead` or `crm_case` row through\n * the form views whose `sharing.allowAnonymous = true`.\n *\n * Any new object added to the CRM stack is implicitly DENIED for guests \u2014\n * profile permissions are explicit-allow only.\n *\n * That includes every object granted to internal profiles by #488. In\n * particular `crm_knowledge_article` stays denied even though its `audience`\n * field marks some articles public: a customer-facing article surface would be\n * served by a portal view with `sharing.allowAnonymous`, never by widening the\n * guest set to read a CRM object.\n */\nexport const GuestPortalProfile = {\n  name: 'guest_portal',\n  label: 'Guest (Public Forms)',\n  description:\n    'Anonymous visitors submitting public Web-to-Lead / Web-to-Case forms. ' +\n    'INSERT-only on lead and case; no read/edit/delete on any object.',\n  // No `allowExport` anywhere below, deliberately: this set is bound to the\n  // `guest` anchor, and ADR-0090 D9 classes `allowExport` as a high-privilege\n  // bit no anchor may confer \u2014 the set would stop binding at all, on top of\n  // handing anonymous visitors bulk table egress. See `src/sales/profiles/index.ts`.\n  objects: {\n    crm_lead: {\n      allowCreate: true,\n      allowRead: false,\n      allowEdit: false,\n      allowDelete: false,\n      viewAllRecords: false,\n      modifyAllRecords: false,\n    },\n    crm_case: {\n      allowCreate: true,\n      allowRead: false,\n      allowEdit: false,\n      allowDelete: false,\n      viewAllRecords: false,\n      modifyAllRecords: false,\n    },\n  },\n};\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/sales/profiles/marketing-user.profile.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/sales/profiles\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/sales/profiles/marketing-user.profile.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nexport const MarketingUserProfile = {\n  name: 'marketing_user',\n  label: 'Marketing User',\n  objects: {\n    // `allowExport` where an export surface exists \u2014 canonical note in\n    // `src/sales/profiles/index.ts`. Lead and contact list exports are marketing's\n    // core targeting workflow; account/opportunity back the campaign-ROI\n    // reports. No `crm_case` grant here, so no export bit for it either.\n    crm_lead:        { allowCreate: true,  allowRead: true,  allowEdit: true,  allowDelete: false, viewAllRecords: true,  modifyAllRecords: false, allowExport: true },\n    crm_account:     { allowCreate: false, allowRead: true,  allowEdit: false, allowDelete: false, viewAllRecords: true,  modifyAllRecords: false, allowExport: true },\n    crm_contact:     { allowCreate: true,  allowRead: true,  allowEdit: true,  allowDelete: false, viewAllRecords: true,  modifyAllRecords: false, allowExport: true },\n    crm_campaign:    { allowCreate: true,  allowRead: true,  allowEdit: true,  allowDelete: false, viewAllRecords: true,  modifyAllRecords: false },\n    // Org-wide read: marketing attributes campaign \u2192 pipeline ROI, which needs\n    // every opportunity, not just self-owned. viewAllRecords was false here\n    // while every other object on this set is true \u2014 an oversight that hid all\n    // pipeline from marketing (and tripped security-private-no-readscope).\n    crm_opportunity: { allowCreate: false, allowRead: true,  allowEdit: false, allowDelete: false, viewAllRecords: true,  modifyAllRecords: false, allowExport: true },\n    // Campaign membership is THIS profile's core write surface: the\n    // \"Add to Campaign\" action (`src/sales/actions/lead.actions.ts`) inserts\n    // `crm_campaign_member` rows, and before #488 no permission set granted the\n    // object \u2014 the action failed for the only persona meant to run it. Rows\n    // derive from the campaign (controlled_by_parent), so there is no record\n    // scope to author \u2014 and as of 17.0.0-rc.4 that derivation does follow the\n    // campaign grant: MEASURED and pinned by\n    // `test/parent-derived-reach.test.ts`, master accessibility resolves through\n    // the same paths a direct read of the campaign takes, ownership and\n    // `sys_record_share` grants included. For THIS profile the delta is small \u2014\n    // `crm_campaign` is `public_read` and this set holds org-wide campaign read,\n    // so the rows are the same either way \u2014 but the grant is now scope that\n    // follows the campaigns above, not org-wide read in fact as it was through\n    // 17.0.0-rc.3 (objectstack-ai/objectstack#5386, #694).\n    // Deleting membership history stays a manager/admin privilege, matching\n    // every other object here.\n    crm_campaign_member: { allowCreate: true, allowRead: true, allowEdit: true, allowDelete: false, viewAllRecords: false, modifyAllRecords: false },\n    // Read-only reference: knowledge articles for campaign copy\n    // (public_read catalog).\n    // Reads the KB and may rate it; cannot author articles (#601).\n    crm_article_feedback: { allowCreate: true, allowRead: true, allowEdit: true, allowDelete: false, viewAllRecords: true, modifyAllRecords: false },\n    crm_knowledge_article: { allowCreate: false, allowRead: true, allowEdit: false, allowDelete: false, viewAllRecords: true, modifyAllRecords: false },\n    // The record Attachments panel, READ only: canonical note on `enable.files`\n    // in `src/sales/objects/index.ts` (#2029). Which attachments it lists\n    // derives from the parent record; upload and delete wait upstream.\n    sys_attachment: { allowCreate: false, allowRead: true, allowEdit: false, allowDelete: false, viewAllRecords: false, modifyAllRecords: false },\n    // The record Discussion panel, comments and activity: canonical note on\n    // `enable.feeds` in `src/sales/objects/index.ts` (#2029). Which threads it\n    // reaches derives from the parent record; deleting a comment waits upstream.\n    sys_comment:  { allowCreate: true,  allowRead: true, allowEdit: true,  allowDelete: false, viewAllRecords: false, modifyAllRecords: false },\n    sys_activity: { allowCreate: false, allowRead: true, allowEdit: false, allowDelete: false, viewAllRecords: false, modifyAllRecords: false },\n  },\n  fields: {\n    // Marketing reads pipeline for campaign ROI but never prices a deal, and\n    // account health is the renewal team's call \u2014 read, never write (#488).\n    'crm_opportunity.amount':   { readable: true, editable: false },\n    'crm_account.health_score': { readable: true, editable: false },\n  },\n  // The same private-deal row filter the sales_manager set carries: this\n  // profile also holds org-wide opportunity read, so it is one of the readers\n  // `crm_opportunity.is_private` has to hold back. See sales-manager.profile.ts\n  // for the full rationale.\n  rowLevelSecurity: [\n    {\n      name: 'opportunity_private_owner_only_marketing',\n      // A deal flagged Private is visible only to its owner, even to holders of\n      // org-wide opportunity read. (`rowLevelSecurity[].label` / `description`\n      // are display copy \u2014 the 17.7.0 liveness ledger marks both live: the\n      // permission editor draws them on the policy card. This policy authors\n      // neither, so its intent lives in this comment.)\n      object: 'crm_opportunity',\n      operation: 'select' as const,\n      using: 'is_private == false || owner_id == current_user.id',\n    },\n    // The platform's `member_default` set carries a wildcard owner-only-writes\n    // policy (`created_by == current_user.id` on update), and RLS policies are\n    // OR-combined \u2014 so without a policy of its own, this set's allowEdit on\n    // campaigns only reaches campaigns the user personally created. That also\n    // silently broke \"Add to Campaign\": enrolling a member is a write DERIVED\n    // from the campaign (controlled_by_parent), so it requires campaign edit at\n    // the row level. This is the one direction in which the ADR-0055 derivation\n    // really does narrow: a master RLS policy is exactly what it folds in, while\n    // ownership and `sys_record_share` grants are not (which is why the READ\n    // side of these member rows is org-wide \u2014 see the `crm_campaign_member`\n    // grant above and objectstack-ai/objectstack#5386, #694). This policy widens\n    // campaign updates to every holder of the set \u2014 exactly what the object\n    // grant above already declares. `id != null`\n    // is the pushdown-safe \"all rows\" predicate (verified: compiles to\n    // `{id: {$null: false}}`).\n    {\n      name: 'marketing_campaign_updates',\n      // Marketing users edit any campaign (and thereby enrol members into it),\n      // not only campaigns they created.\n      object: 'crm_campaign',\n      operation: 'update' as const,\n      using: 'id != null',\n    },\n    // Same widening for the member rows themselves: response tracking means\n    // updating rows the enrollment flow (system context) created, which the\n    // default owner-only-writes policy would otherwise deny.\n    {\n      name: 'marketing_campaign_member_updates',\n      // Marketing users update member response state on rows they did not\n      // personally create.\n      object: 'crm_campaign_member',\n      operation: 'update' as const,\n      using: 'id != null',\n    },\n  ],\n};\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/sales/profiles/sales-manager.profile.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/sales/profiles\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/sales/profiles/sales-manager.profile.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\n/**\n * Sales Manager Profile\n *\n * Org-wide on the sales stack: a manager owns the number, so they read and\n * modify every rep's record rather than only their own.\n */\nexport const SalesManagerProfile = {\n  name: 'sales_manager',\n  label: 'Sales Manager',\n  objects: {\n    // `allowTransfer` on exactly the objects this set holds `modifyAllRecords`\n    // on \u2014 the sales book a manager reassigns. Canonical note in\n    // `src/sales/profiles/index.ts`.\n    // `allowExport` where an export surface exists \u2014 canonical note in\n    // `src/sales/profiles/index.ts`. A manager owns the number, so the pipeline and\n    // book exports that feed offline forecasting are part of the job.\n    crm_lead:        { allowCreate: true,  allowRead: true, allowEdit: true,  allowDelete: true,  viewAllRecords: true,  modifyAllRecords: true, allowTransfer: true, allowExport: true },\n    crm_account:     { allowCreate: true,  allowRead: true, allowEdit: true,  allowDelete: true,  viewAllRecords: true,  modifyAllRecords: true, allowTransfer: true, allowExport: true },\n    crm_contact:     { allowCreate: true,  allowRead: true, allowEdit: true,  allowDelete: true,  viewAllRecords: true,  modifyAllRecords: true, allowTransfer: true, allowExport: true },\n    crm_opportunity: { allowCreate: true,  allowRead: true, allowEdit: true,  allowDelete: true,  viewAllRecords: true,  modifyAllRecords: true, allowTransfer: true, allowExport: true },\n    crm_quote:       { allowCreate: true,  allowRead: true, allowEdit: true,  allowDelete: true,  viewAllRecords: true,  modifyAllRecords: true, allowTransfer: true },\n    // No writeScope: `crm_contract` is `controlled_by_parent` under\n    // `crm_account` (#549), so a scope here would be inert \u2014 the write gate\n    // asks for EDIT on the account instead, which this set holds org-wide\n    // (`modifyAllRecords` above). That retires the #880 gap on BOTH editions:\n    // the contract an accepted quote drafts hangs under the rep, and the\n    // manager edits it because they can edit its account, not because of a\n    // hierarchy depth. `own_and_reports` was the app's only authored hierarchy\n    // scope; `requires: ['hierarchy-security']` stays declared (#1378 ruling).\n    // `allowDelete: false` must keep holding; `modifyAllRecords: false` keeps\n    // this off the super-user bypass. `test/contract-write-depth.test.ts`.\n    crm_contract:    { allowCreate: true,  allowRead: true, allowEdit: true,  allowDelete: false, viewAllRecords: true,  modifyAllRecords: false },\n    crm_product:     { allowCreate: true,  allowRead: true, allowEdit: true,  allowDelete: false, viewAllRecords: true,  modifyAllRecords: false },\n    crm_campaign:    { allowCreate: true,  allowRead: true, allowEdit: true,  allowDelete: false, viewAllRecords: true,  modifyAllRecords: false },\n    crm_case:        { allowCreate: false, allowRead: true, allowEdit: false, allowDelete: false, viewAllRecords: true,  modifyAllRecords: false, allowExport: true },\n    crm_task:        { allowCreate: true,  allowRead: true, allowEdit: true,  allowDelete: true,  viewAllRecords: true,  modifyAllRecords: true, allowTransfer: true },\n    // A manager coaches on activity, so this is org-wide read AND write on a\n    // private object \u2014 the same shape their `crm_task` grant already has.\n    // `crm_event_attendee` is `controlled_by_parent` (ADR-0055): no scope to\n    // author \u2014 one would be inert metadata. It narrows to the events this set\n    // can read, which is every event: `viewAllRecords` on `crm_event` above puts\n    // the whole activity stack in reach, so the derived attendee rows follow.\n    // MEASURED on 17.0.0-rc.4 and pinned by `test/parent-derived-reach.test.ts`,\n    // master accessibility resolves through the same paths a direct read of the\n    // event takes \u2014 ownership and `sys_record_share` grants folded in, not the\n    // master's row-level security policies alone. Until 17.0.0-rc.3 this grant\n    // was org-wide in FACT rather than by derivation, whatever the event grants\n    // said (#694); objectstack-ai/objectstack#5386 fixed that upstream and it\n    // shipped in rc.4. Same note in `sales-rep.profile.ts`.\n    crm_event:       { allowCreate: true,  allowRead: true, allowEdit: true,  allowDelete: true,  viewAllRecords: true,  modifyAllRecords: true, allowTransfer: true },\n    crm_event_attendee: { allowCreate: true, allowRead: true, allowEdit: true, allowDelete: true, viewAllRecords: false, modifyAllRecords: false },\n    // The forecast IS the manager's job: they read every rep's snapshot and\n    // adjust the committed number, so this is org-wide read AND write on a\n    // private object (#488 \u2014 the object had no grant at all).\n    crm_forecast:    { allowCreate: true,  allowRead: true, allowEdit: true,  allowDelete: false, viewAllRecords: true,  modifyAllRecords: true, allowTransfer: true },\n    // Knowledge is service-authored; sales reads it (public_read OWD).\n    // Reads the KB and may rate it; cannot author articles (#601).\n    crm_article_feedback: { allowCreate: true, allowRead: true, allowEdit: true, allowDelete: false, viewAllRecords: true, modifyAllRecords: false },\n    crm_knowledge_article: { allowCreate: false, allowRead: true, allowEdit: false, allowDelete: false, viewAllRecords: true, modifyAllRecords: false },\n    // Enrollment is marketing's job; a manager only reads the membership rows\n    // behind campaign ROI. `crm_campaign_member` is `controlled_by_parent`, so\n    // no readScope/viewAllRecords applies (ADR-0055) \u2014 but the rows do not\n    // \"follow the campaign\": the derivation resolves the master set through the\n    // master's RLS policies only (none narrow a select on `crm_campaign`), so\n    // this is org-wide read on every member row. The practical delta is small\n    // here \u2014 `crm_campaign` is `public_read` and this set reads every campaign\n    // anyway \u2014 so the intended derivation would return the same rows. See\n    // `campaign_member.object.ts` and objectstack-ai/objectstack#5386 (#694).\n    crm_campaign_member:   { allowCreate: false, allowRead: true, allowEdit: false, allowDelete: false, viewAllRecords: false, modifyAllRecords: false },\n    // Line items: full CRUD so a manager can fix pricing on any rep's deal or\n    // quote. Both objects are `controlled_by_parent`, so there is no scope to\n    // author \u2014 but that derivation does not narrow these rows to the deals and\n    // quotes the manager can read. MEASURED (see the note in\n    // `sales-rep.profile.ts` and `test/parent-derived-reach.test.ts`): the master\n    // set comes from the master's RLS policies only, never from ownership or a\n    // share. This set authors one such policy \u2014 the private-deal filter on\n    // `crm_opportunity` below \u2014 and none on `crm_quote`, so quote lines are\n    // org-wide, and opportunity lines are bounded by that policy and nothing\n    // else (the guard test pins the quote chain; the opportunity side follows\n    // from the same measured mechanism). Upstream gap:\n    // objectstack-ai/objectstack#5386 (#694).\n    crm_opportunity_line_item: { allowCreate: true, allowRead: true, allowEdit: true, allowDelete: true, viewAllRecords: false, modifyAllRecords: false },\n    crm_quote_line_item:       { allowCreate: true, allowRead: true, allowEdit: true, allowDelete: true, viewAllRecords: false, modifyAllRecords: false },\n    // The record Attachments panel, READ only: canonical note on `enable.files`\n    // in `src/sales/objects/index.ts` (#2029). Which attachments it lists\n    // derives from the parent record; upload and delete wait upstream.\n    sys_attachment: { allowCreate: false, allowRead: true, allowEdit: false, allowDelete: false, viewAllRecords: false, modifyAllRecords: false },\n    // The record Discussion panel, comments and activity: canonical note on\n    // `enable.feeds` in `src/sales/objects/index.ts` (#2029). Which threads it\n    // reaches derives from the parent record; deleting a comment waits upstream.\n    sys_comment:  { allowCreate: true,  allowRead: true, allowEdit: true,  allowDelete: false, viewAllRecords: false, modifyAllRecords: false },\n    sys_activity: { allowCreate: false, allowRead: true, allowEdit: false, allowDelete: false, viewAllRecords: false, modifyAllRecords: false },\n  },\n  fields: {\n    // Sensitive fields a manager must see in full. Authored explicitly rather\n    // than left absent: these are the fields other sets mask, and an unauthored\n    // grant reads as an oversight instead of a decision (#488).\n    'crm_opportunity.amount':   { readable: true, editable: true },\n    'crm_account.health_score': { readable: true, editable: true },\n    'crm_quote.internal_notes': { readable: true, editable: true },\n    // Case internal notes are the service team's working memory: a sales\n    // manager reads them for account context but never edits them.\n    'crm_case.internal_notes':  { readable: true, editable: false },\n  },\n  // ADR-0058: `crm_opportunity.is_private` is settable in the opportunity form\n  // (`opportunity.view.ts`) and, before this rule, was read by nothing \u2014 a\n  // checkbox that promised confidentiality and delivered none. Org-wide readers\n  // are exactly who it has to hold back, so the set that grants\n  // `viewAllRecords` on opportunities also carries the row filter that honours\n  // it. Compiles to `{ $or: [{ is_private: false }, { owner_id: <caller> }] }`.\n  //\n  // `owner_id`, not the app-authored `owner` lookup this used to name: #548\n  // retired that field. The predicate now keys on the SAME column the OWD /\n  // sharing owner-match reads, so \"its owner\" means one thing app-wide.\n  rowLevelSecurity: [\n    {\n      name: 'opportunity_private_owner_only',\n      // A deal flagged Private is visible only to its owner, even to holders of\n      // org-wide opportunity read. (`rowLevelSecurity[].label` / `description`\n      // are display copy \u2014 the 17.7.0 liveness ledger marks both live: the\n      // permission editor draws them on the policy card. This policy authors\n      // neither, so its intent lives in this comment.)\n      object: 'crm_opportunity',\n      operation: 'select' as const,\n      using: 'is_private == false || owner_id == current_user.id',\n    },\n  ],\n};\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/sales/profiles/sales-rep.profile.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/sales/profiles\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/sales/profiles/sales-rep.profile.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nexport const SalesRepProfile = {\n  name: 'sales_rep',\n  label: 'Sales Representative',\n  // A rep's book of business is private by design (own records + whatever a\n  // sharing rule or team grant extends). The objects below carry an explicit\n  // `readScope: 'own'` so the intent is authored, not inferred \u2014 this both\n  // silences the `security-private-no-readscope` liveness warning and pins the\n  // behavior: without it, a private-OWD object with allowRead but no scope is\n  // an under-specified grant the engine reads as \"own only\" anyway.\n  //\n  // What widens that scope today is narrower than it sounds: the territory /\n  // account-team rules are authored on `crm_account` ONLY, and a sharing rule\n  // widens the object it names \u2014 not the records hanging off it. So a rep who\n  // receives an account through a territory rule reads that account, while the\n  // tasks on it stay own-only and opportunities widen only through the\n  // >= $100k leadership rules. Quotes and contracts are the exception since\n  // #549 (ruling 2026-08-31): both are `controlled_by_parent` under the\n  // account, so they arrive with it \u2014 the same derivation as contacts.\n  //\n  // The `controlled_by_parent` grants below read as narrow, and as of\n  // 17.0.0-rc.4 they ARE. MEASURED and pinned by\n  // `test/parent-derived-reach.test.ts`: the ADR-0055 derivation resolves master\n  // accessibility through the same paths a direct read of the master takes \u2014\n  // owner scope AND `sys_record_share` grants, not the master's row-level\n  // security policies alone. A rep holding ONE account through a territory rule\n  // reads that account's contacts and no others, and reads line items only under\n  // the quotes they can reach. Writes derive the same way: a child of a master\n  // the rep cannot edit is refused. So each grant below is bounded by the\n  // parent's sharing, which is what it looks like.\n  //\n  // Until 17.0.0-rc.3 the same grants were org-wide reads and this note said so\n  // (#694): the derivation consulted master RLS policies only, and HotCRM\n  // authors none, so the master set was every record.\n  // objectstack-ai/objectstack#5386 fixed that upstream and it shipped in rc.4.\n  objects: {\n    // `allowExport` where an export surface exists \u2014 canonical note in\n    // `src/sales/profiles/index.ts`. Safe alongside `readScope: 'own'`: export is\n    // read-derived, so a rep's CSV carries their own book, not the org's.\n    crm_lead:        { allowCreate: true,  allowRead: true,  allowEdit: true,  allowDelete: false, viewAllRecords: false, modifyAllRecords: false, readScope: 'own' as const, allowExport: true },\n    crm_account:     { allowCreate: true,  allowRead: true,  allowEdit: true,  allowDelete: false, viewAllRecords: false, modifyAllRecords: false, readScope: 'own' as const, allowExport: true },\n    // NO readScope: `crm_contact` is `controlled_by_parent` (master-detail to\n    // crm_account), so a `readScope` here is inert \u2014 the sharing service only\n    // applies owner scope to `private` objects \u2014 and it read as a promise the\n    // engine never kept: it said \"own contacts only\" while access derived from\n    // the parent (#488). That derivation now delivers exactly \"the accounts the\n    // rep can read\": measured on 17.0.0-rc.4, a rep holding one territory\n    // account reads THAT account's contacts and no others (see the note at the\n    // top of this file, #694).\n    crm_contact:     { allowCreate: true,  allowRead: true,  allowEdit: true,  allowDelete: false, viewAllRecords: false, modifyAllRecords: false, allowExport: true },\n    crm_opportunity: { allowCreate: true,  allowRead: true,  allowEdit: true,  allowDelete: false, viewAllRecords: false, modifyAllRecords: false, readScope: 'own' as const, allowExport: true },\n    // NO readScope on quote/contract either: both are `controlled_by_parent`\n    // under `crm_account` (#549), so a scope here would be inert. A rep reads\n    // the quotes and contracts of every account they can reach, edits the\n    // quotes of accounts they can edit, and never edits a contract (object\n    // gate). `test/parent-derived-reach.test.ts` measures both levels.\n    crm_quote:       { allowCreate: true,  allowRead: true,  allowEdit: true,  allowDelete: false, viewAllRecords: false, modifyAllRecords: false },\n    crm_contract:    { allowCreate: false, allowRead: true,  allowEdit: false, allowDelete: false, viewAllRecords: false, modifyAllRecords: false },\n    crm_product:     { allowCreate: false, allowRead: true,  allowEdit: false, allowDelete: false, viewAllRecords: true,  modifyAllRecords: false },\n    crm_campaign:    { allowCreate: false, allowRead: true,  allowEdit: false, allowDelete: false, viewAllRecords: true,  modifyAllRecords: false },\n    crm_case:        { allowCreate: false, allowRead: true,  allowEdit: false, allowDelete: false, viewAllRecords: false, modifyAllRecords: false, readScope: 'own' as const, allowExport: true },\n    crm_task:        { allowCreate: true,  allowRead: true,  allowEdit: true,  allowDelete: true,  viewAllRecords: false, modifyAllRecords: false, readScope: 'own' as const },\n\n    // \u2500\u2500\u2500 Activity (#592) \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n    // `crm_event` is `private` like `crm_task` \u2014 a personal activity record \u2014\n    // so an explicit record scope is required alongside allowRead (an omitted\n    // scope silently means \"own only\" and reads as an unmade decision).\n    // `crm_event_attendee` is `controlled_by_parent`, so authoring a readScope\n    // here would be inert metadata the engine never applies. Its rows narrow to\n    // the events the rep can read \u2014 which, `crm_event` being private and\n    // own-scoped, is their own calendar (see the note at the top of this file,\n    // #694).\n    crm_event:       { allowCreate: true,  allowRead: true,  allowEdit: true,  allowDelete: true,  viewAllRecords: false, modifyAllRecords: false, readScope: 'own' as const },\n    crm_event_attendee: { allowCreate: true, allowRead: true, allowEdit: true, allowDelete: true, viewAllRecords: false, modifyAllRecords: false },\n    // Reference catalog (public_read OWD): reps read knowledge articles, which\n    // are authored by service.\n    // Reads the KB and may rate it; cannot author articles (#601).\n    crm_article_feedback: { allowCreate: true, allowRead: true, allowEdit: true, allowDelete: false, viewAllRecords: true, modifyAllRecords: false },\n    crm_knowledge_article: { allowCreate: false, allowRead: true, allowEdit: false, allowDelete: false, viewAllRecords: true,  modifyAllRecords: false },\n    // Forecast snapshots are written by the nightly `forecast.hook` job and the\n    // `revenue_forecasting` skill, never by hand \u2014 read-only, and only the rep's\n    // own snapshots (private OWD + explicit own scope, as above).\n    crm_forecast:          { allowCreate: false, allowRead: true, allowEdit: false, allowDelete: false, viewAllRecords: false, modifyAllRecords: false, readScope: 'own' as const },\n    // Product lines on deals and quotes. Both objects are\n    // `controlled_by_parent`, so there is no readScope to author \u2014 one would be\n    // inert metadata. That derivation scopes a rep to the lines under the deals\n    // and quotes they can reach: measured on 17.0.0-rc.4, a rep reads the lines\n    // of the one quote they own and none of the others (see the note at the top\n    // of this file, #694). Without these grants the opportunity \"Products\"\n    // related list and the whole CPQ path were denied for every non-admin user\n    // (#488).\n    crm_opportunity_line_item: { allowCreate: true, allowRead: true, allowEdit: true, allowDelete: true, viewAllRecords: false, modifyAllRecords: false },\n    crm_quote_line_item:       { allowCreate: true, allowRead: true, allowEdit: true, allowDelete: true, viewAllRecords: false, modifyAllRecords: false },\n    // Which campaign sourced a lead \u2014 read-only context, derived from the\n    // campaign (controlled_by_parent). Enrollment belongs to marketing_user.\n    crm_campaign_member:       { allowCreate: false, allowRead: true, allowEdit: false, allowDelete: false, viewAllRecords: false, modifyAllRecords: false },\n    // The record Attachments panel, READ only: canonical note on `enable.files`\n    // in `src/sales/objects/index.ts` (#2029). Which attachments it lists\n    // derives from the parent record; upload and delete wait upstream.\n    sys_attachment: { allowCreate: false, allowRead: true, allowEdit: false, allowDelete: false, viewAllRecords: false, modifyAllRecords: false },\n    // The record Discussion panel, comments and activity: canonical note on\n    // `enable.feeds` in `src/sales/objects/index.ts` (#2029). Which threads it\n    // reaches derives from the parent record; deleting a comment waits upstream.\n    sys_comment:  { allowCreate: true,  allowRead: true, allowEdit: true,  allowDelete: false, viewAllRecords: false, modifyAllRecords: false },\n    sys_activity: { allowCreate: false, allowRead: true, allowEdit: false, allowDelete: false, viewAllRecords: false, modifyAllRecords: false },\n  },\n  fields: {\n    'crm_account.annual_revenue':     { readable: true, editable: false },\n    'crm_account.description':        { readable: true, editable: true },\n    'crm_opportunity.amount':         { readable: true, editable: true },\n    'crm_opportunity.probability':    { readable: true, editable: true },\n    // Health score drives the renewal book and the at-risk views: reps see it,\n    // the renewal/CS process sets it. Readable (the `at_risk_accounts` view\n    // filters and sorts on it, and a masked field cannot be filtered) but never\n    // rep-editable \u2014 it was previously unauthored on every set (#488).\n    'crm_account.health_score':       { readable: true, editable: false },\n    // Quote internal notes stay rep-editable: `quote.hook` deliberately keeps\n    // them writable after a quote is sent, when nothing else is.\n    'crm_quote.internal_notes':       { readable: true, editable: true },\n    // Case internal notes are the service team's private working notes. A rep\n    // reads the case (own scope) for account context; the agent-only commentary\n    // inside it is masked \u2014 no view filters or sorts on this field, so masking\n    // costs nothing but the value itself.\n    'crm_case.internal_notes':        { readable: false, editable: false },\n  },\n};\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/sales/profiles/service-agent.profile.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/sales/profiles\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/sales/profiles/service-agent.profile.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nexport const ServiceAgentProfile = {\n  name: 'service_agent',\n  label: 'Service Agent',\n  objects: {\n    // Reference context an agent needs to work ANY ticket \u2014 a customer's cases\n    // are meaningless without seeing the account/contact behind them, so these\n    // are org-visible reads (viewAllRecords: true), NOT own-only. This was the\n    // security-private-no-readscope warning's real signal: allowRead on a\n    // private object with no scope had silently locked agents out of every\n    // account they didn't personally own.\n    // `allowExport` where an export surface exists \u2014 canonical note in\n    // `src/sales/profiles/index.ts`. `crm_opportunity` carries no export bit: this\n    // set has no read on it at all, and the axis never widens read.\n    crm_lead:        { allowCreate: false, allowRead: true,  allowEdit: false, allowDelete: false, viewAllRecords: true,  modifyAllRecords: false, allowExport: true },\n    crm_account:     { allowCreate: false, allowRead: true,  allowEdit: false, allowDelete: false, viewAllRecords: true,  modifyAllRecords: false, allowExport: true },\n    crm_contact:     { allowCreate: false, allowRead: true,  allowEdit: true,  allowDelete: false, viewAllRecords: true,  modifyAllRecords: false, allowExport: true },\n    crm_opportunity: { allowCreate: false, allowRead: false, allowEdit: false, allowDelete: false, viewAllRecords: false, modifyAllRecords: false },\n    // Cases + tasks: an agent's own queue by default (readScope: 'own').\n    // Cross-agent visibility exists for CASES only \u2014 the escalation rules widen\n    // open critical cases to service_manager / service_director. `crm_task` has\n    // no sharing rule at all, so an agent reading an account org-wide still\n    // sees only their own tasks on it (#549).\n    crm_case:        { allowCreate: true,  allowRead: true,  allowEdit: true,  allowDelete: false, viewAllRecords: false, modifyAllRecords: false, readScope: 'own' as const, allowExport: true },\n    // `allowTransfer` on `crm_task` ONLY \u2014 canonical note in\n    // `src/sales/profiles/index.ts`. Narrow and load-bearing: escalating a case fires\n    // `case_status_side_effects`, which opens the follow-up task OWNED BY the\n    // account owner (`case.hook.ts`). That insert runs on `ctx.api` with the\n    // agent's own context, so planting it under another user is a transfer and\n    // is denied without this bit \u2014 the case update would fail with it. This is\n    // \"assign work to a colleague\", not \"reassign the ticket\": the agent holds\n    // no transfer grant on `crm_case` or any customer record.\n    //\n    // \u26A0\uFE0F Escalation DOES now move a case to the `service_manager` pool (#1070),\n    // and it does so with no `crm_case` grant here \u2014 deliberately. That\n    // hand-off runs on the `beforeUpdate` seam, which the #3004 guard cannot\n    // see (measured, three readings, in `_case-assignment.ts`'s header and\n    // pinned in `test/case-assignment.test.ts`), so the case moves as part of\n    // the escalation write the automation is already performing rather than as\n    // an agent-initiated transfer. Doing it the other way \u2014 a `ctx.api` write\n    // from `afterUpdate` \u2014 WOULD need `crm_case.allowTransfer` here, which\n    // would let an agent reassign any case they can edit. That is a\n    // permission-model decision and is not being taken as a side effect of a\n    // hook: this line stays `crm_task` only.\n    crm_task:        { allowCreate: true,  allowRead: true,  allowEdit: true,  allowDelete: true,  viewAllRecords: false, modifyAllRecords: false, readScope: 'own' as const, allowTransfer: true },\n    // #592 \u2014 `log_call` / `log_meeting` are scoped to `crm_case` too, and an\n    // agent who cannot INSERT a `crm_event` gets a button that 403s. Same\n    // own-scoped shape as their tasks.\n    crm_event:       { allowCreate: true,  allowRead: true,  allowEdit: true,  allowDelete: true,  viewAllRecords: false, modifyAllRecords: false, readScope: 'own' as const },\n    crm_event_attendee: { allowCreate: true, allowRead: true, allowEdit: true, allowDelete: true, viewAllRecords: false, modifyAllRecords: false },\n    crm_product:     { allowCreate: false, allowRead: true,  allowEdit: false, allowDelete: false, viewAllRecords: true,  modifyAllRecords: false },\n    // The knowledge base is this team's own surface: agents draft and revise\n    // articles (draft \u2192 in_review \u2192 published is enforced by the KB flow, not by\n    // CRUD), and read every published article regardless of author. Archiving\n    // is destructive-by-policy, so deletion stays with admins. Before #488 the\n    // object had no grant at all \u2014 the \"Knowledge\" nav item was denied for\n    // everyone, including the agents it was built for.\n    // Agents rate the articles they use to close cases (#601). Create + edit\n    // their OWN row (`modifyAllRecords: false` keeps them off everyone else's\n    // vote); no delete \u2014 a withdrawn opinion is a changed verdict, not an\n    // erased one.\n    crm_article_feedback: { allowCreate: true, allowRead: true, allowEdit: true, allowDelete: false, viewAllRecords: true, modifyAllRecords: false },\n    crm_knowledge_article: { allowCreate: true, allowRead: true, allowEdit: true, allowDelete: false, viewAllRecords: true, modifyAllRecords: false },\n    // The record Attachments panel, READ only: canonical note on `enable.files`\n    // in `src/sales/objects/index.ts` (#2029). Which attachments it lists\n    // derives from the parent record; upload and delete wait upstream.\n    sys_attachment: { allowCreate: false, allowRead: true, allowEdit: false, allowDelete: false, viewAllRecords: false, modifyAllRecords: false },\n    // The record Discussion panel, comments and activity: canonical note on\n    // `enable.feeds` in `src/sales/objects/index.ts` (#2029). Which threads it\n    // reaches derives from the parent record; deleting a comment waits upstream.\n    sys_comment:  { allowCreate: true,  allowRead: true, allowEdit: true,  allowDelete: false, viewAllRecords: false, modifyAllRecords: false },\n    sys_activity: { allowCreate: false, allowRead: true, allowEdit: false, allowDelete: false, viewAllRecords: false, modifyAllRecords: false },\n  },\n  fields: {\n    'crm_case.is_sla_violated':        { readable: true, editable: false },\n    'crm_case.resolution_time_hours':  { readable: true, editable: false },\n    // Internal notes are the agent's working memory on a ticket \u2014 full access\n    // here, read-only for sales_manager, masked for sales_rep (#488).\n    'crm_case.internal_notes':         { readable: true, editable: true },\n    // Account health is renewal-team data an agent reads for context only.\n    'crm_account.health_score':        { readable: true, editable: false },\n  },\n};\n\n/**\n * The SERVICE MANAGER binding (#1779) \u2014 the same set, under the position's name.\n *\n * ### What was ruled\n *\n * `service_manager` is a declared position (`src/sales/sharing/positions.ts`) that\n * `case_escalation_sharing` names and that `case_escalation_reassign` routes\n * escalating cases to \u2014 measured, 35 of them on a demo box \u2014 and no permission\n * set reached it, so the persona was denied every CRM object (403). Director\n * seat, decision batch #92, 2026-09-08, under the maintainer's standing\n * \u300C\u7EE7\u7EED\u51B3\u7B56\u300D delegation: bind the EXISTING `service_agent` set to the\n * `service_manager` position. \u26D4 B (author a manager-specific profile) was\n * refused \u2014 no measured puller for a manager-only grant. \u26D4 C (reroute the\n * escalation pool) was refused \u2014 it deletes the persona's reason to exist.\n *\n * ### Why the binding is a NAME and not a key \u2014 measured, not inferred\n *\n * There is no authorable binding on either side. `PermissionSetSchema` rejects\n * `profiles` / `roles` / `users`, and `PositionSchema` rejects `permissionSets`\n * with its own prescription: capability reaches a position ONLY through\n * `sys_position_permission_set` rows, \"created in Setup or by an app's\n * `kernel:ready` binder\" \u2014 and a pure-metadata app ships neither.\n *\n * What it ships instead is a name. Measured on a fresh 17.3.0 SQLite box:\n * `sys_position_permission_set` holds exactly ONE row (`everyone` \u2192\n * `member_default`, the ADR-0090 D5 baseline the platform binds itself), and\n * yet `POST /api/v1/security/explain` for a `service_agent` position holder\n * answers `permissionSets: [service_agent, member_default]`, crediting the\n * object-level grant to `[service_agent]` `via: position:service_agent`. The\n * resolver is `resolvePermissionSets()` in `@objectstack/plugin-security`: it\n * matches the caller's POSITION NAMES against declared `PermissionSet.name`,\n * so a set named for a position is bound to it with no row at all.\n *\n * \u21D2 For this app, \"bind set X to position P\" has exactly one spelling: declare\n * X's grants under the name P. Hence this export rather than a new file.\n *\n * ### Why a spread and not a copy\n *\n * `objects` and `fields` are carried by REFERENCE, so the two personas share\n * one grant table and cannot drift: nothing here can widen the agent's grants,\n * and a future edit to them lands on both at once. That is the ruling's own\n * finding \u2014 escalation handling is the same object access as working a ticket \u2014\n * expressed in a way the next reader cannot half-apply. \u26D4 Do not expand this\n * into a literal second grant table to \"make it explicit\"; that would be\n * option B, refused, and it would let the two silently diverge.\n *\n * ### Reversal (ruling item 4)\n *\n * If a customer needs a manager grant that DIFFERS from an agent's, it comes\n * back as a product card with the puller named \u2014 and only then does this become\n * an authored set of its own.\n */\nexport const ServiceManagerProfile = {\n  ...ServiceAgentProfile,\n  name: 'service_manager',\n  label: 'Service Manager',\n};\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/sales/profiles/system-admin.profile.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/sales/profiles\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/sales/profiles/system-admin.profile.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\n/**\n * System Administrator Profile\n *\n * The admin set must cover EVERY business object this app ships. Permission\n * sets are explicit-allow only (see `guest-portal.profile.ts`), so an object\n * missing from this map is permission-denied for admins too: the object-level\n * CRUD gate rejects the call before OWD, sharing or `view_all_data` is ever\n * consulted. `test/authorization-coverage.test.ts` pins that coverage so a new\n * object cannot ship without landing here.\n */\nexport const SystemAdminProfile = {\n  name: 'system_admin',\n  label: 'System Administrator',\n  objects: {\n    // `allowTransfer` on every object \u2014 canonical note in `src/sales/profiles/index.ts`.\n    // The admin is the persona that reassigns ownership when someone leaves.\n    // `allowExport` on the five objects with an export surface \u2014 see the\n    // canonical note in `src/sales/profiles/index.ts`. It is authored even here:\n    // 17.0 gates export on the explicit bit, and `modifyAllRecords` does not\n    // stand in for it, so without these an admin cannot export either.\n    crm_lead:        { allowCreate: true, allowRead: true, allowEdit: true, allowDelete: true, viewAllRecords: true, modifyAllRecords: true, allowTransfer: true, allowExport: true },\n    crm_account:     { allowCreate: true, allowRead: true, allowEdit: true, allowDelete: true, viewAllRecords: true, modifyAllRecords: true, allowTransfer: true, allowExport: true },\n    crm_contact:     { allowCreate: true, allowRead: true, allowEdit: true, allowDelete: true, viewAllRecords: true, modifyAllRecords: true, allowTransfer: true, allowExport: true },\n    crm_opportunity: { allowCreate: true, allowRead: true, allowEdit: true, allowDelete: true, viewAllRecords: true, modifyAllRecords: true, allowTransfer: true, allowExport: true },\n    crm_quote:       { allowCreate: true, allowRead: true, allowEdit: true, allowDelete: true, viewAllRecords: true, modifyAllRecords: true, allowTransfer: true },\n    crm_contract:    { allowCreate: true, allowRead: true, allowEdit: true, allowDelete: true, viewAllRecords: true, modifyAllRecords: true, allowTransfer: true },\n    crm_product:     { allowCreate: true, allowRead: true, allowEdit: true, allowDelete: true, viewAllRecords: true, modifyAllRecords: true, allowTransfer: true },\n    crm_campaign:    { allowCreate: true, allowRead: true, allowEdit: true, allowDelete: true, viewAllRecords: true, modifyAllRecords: true, allowTransfer: true },\n    crm_case:        { allowCreate: true, allowRead: true, allowEdit: true, allowDelete: true, viewAllRecords: true, modifyAllRecords: true, allowTransfer: true, allowExport: true },\n    crm_task:        { allowCreate: true, allowRead: true, allowEdit: true, allowDelete: true, viewAllRecords: true, modifyAllRecords: true, allowTransfer: true },\n    crm_event:       { allowCreate: true, allowRead: true, allowEdit: true, allowDelete: true, viewAllRecords: true, modifyAllRecords: true, allowTransfer: true },\n    crm_event_attendee: { allowCreate: true, allowRead: true, allowEdit: true, allowDelete: true, viewAllRecords: true, modifyAllRecords: true, allowTransfer: true },\n    // The objects below shipped with navigation, views, hooks and seed data\n    // but no grant in ANY permission set (#488): \"Knowledge\" and \"Forecasts\"\n    // were permission-denied nav items for every user, admins included.\n    crm_forecast:              { allowCreate: true, allowRead: true, allowEdit: true, allowDelete: true, viewAllRecords: true, modifyAllRecords: true, allowTransfer: true },\n    crm_article_feedback:      { allowCreate: true, allowRead: true, allowEdit: true, allowDelete: true, viewAllRecords: true, modifyAllRecords: true, allowTransfer: true },\n    crm_knowledge_article:     { allowCreate: true, allowRead: true, allowEdit: true, allowDelete: true, viewAllRecords: true, modifyAllRecords: true, allowTransfer: true },\n    // Detail rows. Their RECORD-level access derives from the master\n    // (ADR-0055 `controlled_by_parent`), but object-level CRUD is a separate\n    // gate that is never derived \u2014 it has to be granted explicitly here.\n    crm_opportunity_line_item: { allowCreate: true, allowRead: true, allowEdit: true, allowDelete: true, viewAllRecords: true, modifyAllRecords: true, allowTransfer: true },\n    crm_quote_line_item:       { allowCreate: true, allowRead: true, allowEdit: true, allowDelete: true, viewAllRecords: true, modifyAllRecords: true, allowTransfer: true },\n    crm_campaign_member:       { allowCreate: true, allowRead: true, allowEdit: true, allowDelete: true, viewAllRecords: true, modifyAllRecords: true, allowTransfer: true },\n    // The record Attachments panel, READ only: canonical note on `enable.files`\n    // in `src/sales/objects/index.ts` (#2029). Which attachments it lists\n    // derives from the parent record; upload and delete wait upstream.\n    sys_attachment: { allowCreate: false, allowRead: true, allowEdit: false, allowDelete: false, viewAllRecords: false, modifyAllRecords: false },\n    // The record Discussion panel, comments and activity: canonical note on\n    // `enable.feeds` in `src/sales/objects/index.ts` (#2029). Which threads it\n    // reaches derives from the parent record; deleting a comment waits upstream.\n    sys_comment:  { allowCreate: true,  allowRead: true, allowEdit: true,  allowDelete: false, viewAllRecords: false, modifyAllRecords: false },\n    sys_activity: { allowCreate: false, allowRead: true, allowEdit: false, allowDelete: false, viewAllRecords: false, modifyAllRecords: false },\n  },\n  systemPermissions: [\n    'view_setup', 'manage_users', 'customize_application',\n    'view_all_data', 'modify_all_data', 'manage_profiles',\n    'manage_roles', 'manage_sharing',\n  ],\n};\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/sales/translations/index.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/sales/translations\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/sales/translations/index.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\n/**\n * Translation Definitions Barrel\n */\n\nexport { CrmTranslations } from './crm.translation';\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/sales/translations/en/app.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/sales/translations/en\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/sales/translations/en/app.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport type { TranslationData } from '@objectstack/spec/system';\n\n/**\n * English (en) \u2014 every translation namespace EXCEPT `objects`:\n * `apps`, `messages`, `dashboards`, `pages`.\n *\n * SPLIT AXIS (#1311): translation NAMESPACE first, then CRM DOMAIN FAMILY.\n * Everything that is not `objects` lives in `./app.ts`; `objects` \u2014 69-78% of\n * every bundle \u2014 is one file per CRM domain family, and a detail object\n * follows its master. A new row goes in the file for ITS family, never in\n * whichever file is already open: that is how one file re-grows past the 70%\n * advisory band `pnpm hygiene` prints. Full rule and rationale:\n * `src/sales/translations/en.ts`.\n *\n * A namespace `TranslationData` gains later lands here too, and the room is\n * measured: this file is the smaller half of the bundle, and the schema bounds\n * how many namespaces can ever arrive.\n */\nexport const appSurface: Omit<TranslationData, 'objects'> = {\n  apps: {\n    crm_enterprise: {\n      label: 'HotCRM',\n      description: 'Customer relationship management for sales, service, and marketing',\n      navigation: {\n        group_activity: { label: 'Activity' },\n        group_sales: { label: 'Sales' },\n        group_service: { label: 'Service' },\n        group_marketing: { label: 'Marketing' },\n      },\n    },\n  },\n  messages: {\n    'common.save': 'Save',\n    'common.cancel': 'Cancel',\n    'common.delete': 'Delete',\n    'common.edit': 'Edit',\n    'common.create': 'Create',\n    'common.search': 'Search',\n    'common.filter': 'Filter',\n    'common.export': 'Export',\n    'common.back': 'Back',\n    'common.confirm': 'Confirm',\n    'nav.sales': 'Sales',\n    'nav.service': 'Service',\n    'nav.marketing': 'Marketing',\n    'nav.products': 'Products',\n    'nav.analytics': 'Analytics',\n    'success.saved': 'Record saved successfully',\n    'success.converted': 'Lead converted successfully',\n    'confirm.delete': 'Are you sure you want to delete this record?',\n    'confirm.convert_lead': 'Convert this lead to account, contact, and opportunity?',\n    'error.required': 'This field is required',\n    'error.load_failed': 'Failed to load data',\n  },\n  dashboards: {\n    sales_activity_dashboard: {\n      label: 'Sales Activity',\n      description: 'Who is talking to customers, how often, and which accounts have gone quiet',\n      widgets: {\n        interactions_held: { title: 'Interactions Logged', description: 'Calls and meetings that actually happened' },\n        meetings_booked: { title: 'Meetings Booked', description: 'Meetings on the calendar that have not happened yet' },\n        customer_minutes: { title: 'Customer Minutes', description: 'Total time spent in front of customers' },\n        tasks_completed: { title: 'Tasks Completed', description: 'Follow-ups closed out \u2014 the other half of activity' },\n        activity_by_rep: { title: 'Activity by Rep', description: 'Logged interactions per owner' },\n        activity_by_week: { title: 'Activity Volume by Week', description: 'Interactions per week' },\n        activity_mix: { title: 'Activity Mix', description: 'Calls vs meetings vs demos' },\n        activity_by_record_type: { title: 'Where the Activity Lands', description: 'Which part of the funnel is getting attention' },\n        deal_activity: { title: 'Interactions on Deals', description: 'Logged interactions linked to an opportunity' },\n        open_deals_for_activity: { title: 'Open Deals', description: 'Opportunities still in play' },\n        quiet_accounts_30: { title: 'Quiet 30+ Days', description: 'Active accounts with no logged interaction in a month' },\n        quiet_accounts_60: { title: 'Quiet 60+ Days', description: 'Two months of silence \u2014 the at-risk threshold' },\n        quiet_accounts_90: { title: 'Quiet 90+ Days', description: 'A quarter with no contact' },\n      },\n    },\n    crm_overview_dashboard: {\n      label: 'CRM Overview',\n      description: 'Revenue metrics, pipeline analytics, and deal insights',\n      widgets: {\n        total_revenue: { title: 'Total Revenue', description: 'Closed-won revenue this period' },\n        active_deals: { title: 'Active Deals', description: 'Open opportunities in the pipeline' },\n        won_deals: { title: 'Won Deals', description: 'Closed-won deals this period' },\n        avg_deal_size: { title: 'Avg Deal Size', description: 'Average value of closed-won deals' },\n        revenue_trends: { title: 'Revenue Trends', description: 'Closed-won revenue over the last 12 months' },\n        lead_source: { title: 'Lead Source', description: 'Pipeline value by acquisition channel' },\n        pipeline_by_stage: { title: 'Pipeline by Stage', description: 'Open opportunity value at each sales stage' },\n        top_products: { title: 'Top Products', description: 'Total list-price revenue by product category' },\n        pipeline_by_owner: { title: 'Pipeline by Owner', description: 'Open pipeline value and deal count per sales rep' },\n      },\n    },\n    executive_dashboard: {\n      label: 'Executive Overview',\n      description: 'High-level revenue, customer, and pipeline KPIs for leadership',\n      widgets: {\n        total_revenue_ytd: { title: 'Total Revenue (YTD)', description: 'Closed-won revenue this year' },\n        total_accounts: { title: 'Active Accounts', description: 'Customers with at least one active relationship' },\n        total_contacts: { title: 'Total Contacts', description: 'People in our address book' },\n        open_leads: { title: 'Open Leads', description: 'Unconverted leads in the funnel' },\n        revenue_trend: { title: 'Revenue Trend', description: 'Closed-won revenue over the last 12 months' },\n        revenue_by_industry: { title: 'Revenue by Industry', description: 'YTD closed-won revenue split by customer industry' },\n        pipeline_by_stage: { title: 'Pipeline by Stage', description: 'Open opportunity value at each sales stage' },\n        new_accounts_by_month: { title: 'New Accounts', description: 'Account creation cadence \u2014 last 6 months' },\n        accounts_by_industry: { title: 'Accounts by Industry', description: 'Total annual revenue and account count per industry' },\n      },\n    },\n    sales_dashboard: {\n      label: 'Sales Performance',\n      description: 'Pipeline analytics, win rate trends, and rep performance',\n      widgets: {\n        total_pipeline_value: { title: 'Total Pipeline', description: 'Sum of open opportunity value' },\n        closed_won_qtd: { title: 'Closed Won (QTD)', description: 'Revenue closed this quarter' },\n        open_opportunities: { title: 'Open Opportunities', description: 'Active deals in flight' },\n        avg_deal_size: { title: 'Avg Deal Size', description: 'Average value of closed-won deals this quarter' },\n        pipeline_by_stage: { title: 'Pipeline by Stage', description: 'Open opportunity value at each sales stage' },\n        monthly_revenue_trend: { title: 'Monthly Revenue Trend', description: 'Closed-won revenue, last 12 months' },\n        pipeline_by_forecast_category: { title: 'Pipeline by Forecast Category', description: 'Open pipeline grouped by sales forecast category' },\n        lead_source_breakdown: { title: 'Lead Source', description: 'Where our pipeline is coming from' },\n        open_pipeline_by_owner: { title: 'Open Pipeline by Owner', description: 'In-flight pipeline value, deal count and avg win probability per rep' },\n        quota_attainment_by_rep: { title: 'Quota Attainment by Rep', description: 'Current-quarter quota, closed revenue and attainment per rep, from forecast snapshots' },\n        pipeline_stage_by_source: { title: 'Pipeline by Stage \u00D7 Lead Source', description: 'Cross-tab of open opportunity amount by stage and source' },\n        win_rate_12m: { title: 'Win Rate (12M)', description: 'Deals won as a share of all deals settled in the last 12 months' },\n        won_deals_12m: { title: 'Deals Won (12M)', description: 'The numerator of the win rate' },\n        lost_deals_12m: { title: 'Deals Lost (12M)', description: 'The other half of the win-rate denominator' },\n        win_rate_by_owner: { title: 'Win / Loss by Rep', description: 'Deals won, deals lost and win rate per rep \u2014 last 12 months' },\n        win_rate_by_lead_source: { title: 'Win / Loss by Lead Source', description: 'Which sources produce deals that actually close \u2014 last 12 months' },\n        loss_reason_breakdown: { title: 'Why We Lose', description: 'Lost deals by reason \u2014 last 12 months' },\n      },\n    },\n    service_dashboard: {\n      label: 'Customer Service',\n      description: 'Case load, SLA health, and resolution performance',\n      widgets: {\n        open_cases: { title: 'Open Cases', description: 'Cases that are not yet closed' },\n        critical_cases: { title: 'Critical Cases', description: 'Open cases marked as critical priority' },\n        avg_resolution_time: { title: 'Avg Resolution Time', description: 'Mean time to close, in hours' },\n        sla_violations: { title: 'SLA Violations', description: 'Cases that breached their SLA' },\n        cases_by_status: { title: 'Cases by Status', description: 'Workload distribution across the pipeline' },\n        cases_by_priority: { title: 'Cases by Priority', description: 'Open case mix by urgency' },\n        cases_by_origin: { title: 'Cases by Origin', description: 'Where our cases are coming from' },\n        daily_case_volume: { title: 'Daily Case Volume', description: 'New cases created over the last 30 days' },\n        sla_compliance_gauge: { title: 'SLA Compliance', description: 'Percent of cases resolved within SLA this period' },\n        kb_deflection_rate: { title: 'KB Deflection Rate', description: 'Share of closed cases resolved with a knowledge article' },\n        kb_resolved_cases: { title: 'Resolved by KB', description: 'Closed cases pointing at the article that resolved them' },\n        closed_cases_total: { title: 'Closed Cases', description: 'The denominator behind the deflection rate' },\n        top_resolving_articles: { title: 'Top Resolving Articles', description: 'Knowledge articles ranked by the closed cases they resolved' },\n        my_open_cases_by_priority: { title: 'My Open Cases by Priority', description: 'Your open cases and their SLA-violation rate, broken down by priority' },\n      },\n    },\n  },\n  pages: {\n    account_detail_page: {\n      label: 'Account Detail',\n      description: 'Slotted account record page \u2014 custom header + persistent discussion feed.',\n      // Required, though it equals the page source: a missing `title` falls\n      // back to `label`, and the header then read \"Account Detail\" instead of\n      // the account's name (#2042).\n      title: '{name}',\n      subtitle: '{industry} \u00B7 {type}',\n    },\n    account_workbench: {\n      label: 'Account Workbench',\n      description: 'Curated account list for the sales team: quick filters only, no view management.',\n    },\n    app_launcher_page: {\n      label: 'App Launcher',\n      description: 'Central hub for accessing all applications',\n      subtitle: 'Select an app to get started',\n      components: {\n        app_search: { label: 'Search Apps' },\n        app_grid: { label: 'Application Grid' },\n      },\n    },\n    case_detail_page: {\n      label: 'Case Detail',\n      description: 'Service-agent case record: highlights, SLA path, details and activity timeline.',\n      title: '{case_number} \u00B7 {subject}',\n      subtitle: '{crm_account}',\n      components: {\n        case_highlights: { label: 'Key Information' },\n        case_status_path: { label: 'Case Status Path' },\n      },\n    },\n    lead_detail_page: {\n      label: 'Lead Detail',\n      description: 'Comprehensive lead detail page with highlights, details, and related information',\n      title: '{first_name} {last_name}',\n      subtitle: '{company}',\n      components: {\n        lead_duplicate_alert_confirmed: { label: 'Confirmed Duplicate Alert' },\n        lead_duplicate_alert_suspected: { label: 'Suspected Duplicate Alert' },\n        lead_highlights: { label: 'Key Information' },\n        lead_path: { label: 'Lead Status Path' },\n        main_tabs: { label: 'Lead Information Tabs' },\n      },\n    },\n    opportunity_detail_page: {\n      label: 'Opportunity Detail',\n      description:\n        'Comprehensive opportunity detail page with path, highlights, details, and related lists',\n      title: '{name}',\n      subtitle: '{crm_account}',\n      components: {\n        opp_highlights: { label: 'Key Information' },\n        opp_stage_path: { label: 'Opportunity Stage Path' },\n      },\n    },\n    sales_home_page: {\n      label: 'Sales Home',\n      description: 'Sales team home page with key metrics and quick actions',\n      title: 'Sales Dashboard',\n      subtitle: 'Welcome back',\n      components: {\n        quick_create: { title: 'Quick Create', label: 'Quick Create' },\n        key_metrics: { title: 'Key Performance Indicators', label: 'Key Metrics' },\n        home_tabs: { label: 'Home Tabs' },\n        ai_briefing: {\n          title: 'Ask the AI Assistant',\n          label: 'Today with the AI Assistant',\n        },\n        upcoming_events: { title: 'Upcoming Events', label: 'Upcoming Events' },\n      },\n    },\n    utility_bar_page: {\n      label: 'Utility Bar',\n      description: 'Quick access utility bar with floating tools',\n      components: {\n        notifications_panel: { label: 'Notifications' },\n        quick_notes: { title: 'Quick Notes', label: 'Quick Notes' },\n        quick_search: { label: 'Quick Search' },\n      },\n    },\n  },\n};\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/sales/translations/en/_shared.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/sales/translations/en\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/sales/translations/en/_shared.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\n/**\n * English (en) \u2014 values shared by more than one part of this bundle.\n *\n * SPLIT AXIS (#1311): translation NAMESPACE first, then CRM DOMAIN FAMILY.\n * Everything that is not `objects` lives in `./app.ts`; `objects` \u2014 69-78% of\n * every bundle \u2014 is one file per CRM domain family, and a detail object\n * follows its master. A new row goes in the file for ITS family, never in\n * whichever file is already open: that is how one file re-grows past the 70%\n * advisory band `pnpm hygiene` prints. Full rule and rationale:\n * `src/sales/translations/en.ts`.\n *\n * Every constant here is spread into object rows that live in MORE THAN ONE\n * family file, so it cannot sit in any one of them. A value used by exactly\n * one family lives in that family's file instead \u2014 that split is mechanical,\n * not a judgement call.\n */\n\n/**\n * The activity family (#592) \u2014 `log_call`, `log_meeting` and\n * `schedule_meeting` are registered once PER OBJECT (lead, contact, account,\n * opportunity, case), because a body action with no `objectName` lands under a\n * dispatcher key nothing probes (#509). The labels are identical on every one\n * of them, so they are declared once here and spread into each object's\n * `_actions` \u2014 fifteen hand-copied blocks per locale is how a translation set\n * drifts.\n */\nexport const activityActions = {\n  log_call: {\n    label: 'Log a Call',\n    successMessage: 'Call logged successfully!',\n    params: {\n      subject: { label: 'Call Subject' },\n      duration: { label: 'Duration (minutes)' },\n      attendee_contacts: { label: 'Contact Attendees' },\n      attendee_users: { label: 'Internal Attendees' },\n      notes: { label: 'Call Notes' },\n    },\n  },\n  log_meeting: {\n    label: 'Log a Meeting',\n    successMessage: 'Meeting logged successfully!',\n    params: {\n      subject: { label: 'Meeting Subject' },\n      duration: { label: 'Duration (minutes)' },\n      attendee_contacts: { label: 'Contact Attendees' },\n      attendee_users: { label: 'Internal Attendees' },\n      notes: { label: 'Meeting Notes' },\n    },\n  },\n  schedule_meeting: {\n    label: 'Schedule a Meeting',\n    successMessage: 'Meeting scheduled!',\n    params: {\n      subject: { label: 'Meeting Subject' },\n      start_date: { label: 'Start Date (UTC)' },\n      start_time: { label: 'Start Time (UTC)' },\n      location: { label: 'Location' },\n      duration: { label: 'Duration (minutes)' },\n      attendee_contacts: { label: 'Contact Attendees' },\n      attendee_users: { label: 'Internal Attendees' },\n      notes: { label: 'Agenda' },\n    },\n  },\n};\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/sales/translations/en/objects.customer.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/sales/translations/en\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/sales/translations/en/objects.customer.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport type { ObjectTranslationData } from '@objectstack/spec/system';\n\nimport { activityActions } from './_shared';\n\n/**\n * English (en) \u2014 `objects` translations for the CUSTOMER family:\n * the customer record itself \u2014 accounts and the people at them.\n *\n * Roster: `crm_account`, `crm_contact`.\n *\n * SPLIT AXIS (#1311): translation NAMESPACE first, then CRM DOMAIN FAMILY.\n * Everything that is not `objects` lives in `./app.ts`; `objects` \u2014 69-78% of\n * every bundle \u2014 is one file per CRM domain family, and a detail object\n * follows its master. A new row goes in the file for ITS family, never in\n * whichever file is already open: that is how one file re-grows past the 70%\n * advisory band `pnpm hygiene` prints. Full rule and rationale:\n * `src/sales/translations/en.ts`.\n */\nexport const customer: Record<string, ObjectTranslationData> = {\n  crm_account: {\n    label: 'Account',\n    pluralLabel: 'Accounts',\n    fields: {\n      account_number: { label: 'Account Number' },\n      registration_number: {\n        label: 'Registration Number',\n        help: \"The counterparty's registered identity as issued by its own government registry. Not the Account Number, which we issue.\",\n      },\n      commercial_capability: {\n        label: 'Commercial Capability',\n        help: 'Whether new business may be opened against this account. Settlement Only accounts stay usable for billing and payment, but no new opportunity may be linked to them.',\n        options: { full: 'Full', settlement_only: 'Settlement Only' },\n      },\n      incumbent_vendor: { label: 'Incumbent Vendor', help: 'The supplier currently holding this account for the spend we are chasing.' },\n      annual_purchasing_budget: { label: 'Annual Purchasing Budget', help: 'What this account expects to spend with vendors this year \u2014 not its own revenue.' },\n      payment_cycle: {\n        label: 'Payment Cycle',\n        options: { prepaid: 'Prepaid', net_30: 'Net 30', net_60: 'Net 60', net_90: 'Net 90' },\n      },\n      approval_status: {\n        label: 'Approval Status',\n        help: 'Where this account stands in its sign-off. A new account starts Pending and is decided in the approval inbox.',\n        options: { pending: 'Pending', approved: 'Approved', rejected: 'Rejected' },\n      },\n      name: { label: 'Account Name', help: 'Legal name of the company or organization' },\n      type: {\n        label: 'Type',\n        options: { prospect: 'Prospect', customer: 'Customer', partner: 'Partner', former: 'Former Customer' },\n      },\n      industry: {\n        label: 'Industry',\n        options: {\n          technology: 'Technology', software: 'Software / SaaS', finance: 'Finance',\n          healthcare: 'Healthcare', retail: 'Retail', manufacturing: 'Manufacturing',\n          education: 'Education', real_estate: 'Real Estate', media: 'Media & Entertainment',\n          logistics: 'Logistics', hospitality: 'Hospitality', energy: 'Energy & Utilities',\n          government: 'Government', nonprofit: 'Non-profit', other: 'Other',\n        },\n      },\n      annual_revenue: { label: 'Annual Revenue' },\n      child_account_revenue: { label: 'Child Account Revenue', help: 'Sum of the annual revenue of the direct children of this account.' },\n      number_of_employees: { label: 'Number of Employees' },\n      phone: { label: 'Phone' },\n      website: { label: 'Website' },\n      billing_address: { label: 'Billing Address' },\n      billing_country: {\n        label: 'Billing Country',\n        help: 'Derived from Billing Address \u2014 the country exactly as entered, trimmed and upper-cased.',\n      },\n      territory: {\n        label: 'Territory',\n        help: 'Derived from Billing Address \u2014 the sales territory the sharing rules match on. Accounts outside the staffed territories are Other.',\n        options: { na: 'North America', emea: 'EMEA', other: 'Other' },\n      },\n      office_location: { label: 'Office Location' },\n      owner_id: { label: 'Account Owner' },\n      parent_account: { label: 'Parent Account', help: 'Parent company in hierarchy' },\n      description: { label: 'Description' },\n      is_active: { label: 'Active' },\n      last_activity_date: { label: 'Last Activity Date' },\n      brand_color: { label: 'Brand Color' },\n      logo: { label: 'Company Logo' },\n      tier: {\n        label: 'Customer Tier',\n        options: { strategic: 'Strategic', enterprise: 'Enterprise', mid_market: 'Mid-Market', smb: 'SMB' },\n      },\n      segment: {\n        label: 'Segment',\n        options: { net_new: 'Net New', growth: 'Growth', at_risk: 'At Risk', stable: 'Stable' },\n      },\n      health_score: {\n        label: 'Health Score',\n        help: 'CSM-maintained health indicator',\n        options: { healthy: 'Healthy', watching: 'Watching', at_risk: 'At Risk', churning: 'Churning' },\n      },\n      name_normalized: {\n        label: 'Account Name (Normalized)',\n        help: 'Match key for lead conversion: Account Name lower-cased, trimmed, with internal whitespace collapsed. Maintained by the account_protection hook \u2014 never edit directly.',\n      },\n      display_title: { label: 'Display Title' },\n    },\n    _views: {\n      all_accounts: { label: 'All Accounts', description: 'Primary account list with revenue & industry summaries' },\n      account_gallery: { label: 'Account Cards', description: 'Branded account cards with brand-color highlights' },\n      account_map: { label: 'Accounts by Location', description: 'Geospatial distribution of accounts' },\n      enterprise_accounts: { label: 'Enterprise Accounts', description: 'Accounts with the highest annual revenue' },\n      my_accounts: { label: 'My Accounts', description: 'Accounts owned by the current user' },\n      at_risk_accounts: { label: '\u26A0\uFE0F At-Risk Accounts' },\n    },\n    _sections: {\n      basic: { label: 'Basic Information' },\n      financials: { label: 'Financials' },\n      business_profile: { label: 'Business Profile' },\n      contact_info: { label: 'Contact Information' },\n      ownership: { label: 'Ownership & Status' },\n      branding: { label: 'Branding' },\n      system: { label: 'System' },\n      // Form section names on account.view.ts (#1100)\n      profile: { label: 'Profile' },\n      customer_success: { label: 'Customer Success' },\n      locations: { label: 'Locations' },\n      description: { label: 'Description' },\n    },\n    _actions: { ...activityActions },\n  },\n  crm_contact: {\n    label: 'Contact',\n    pluralLabel: 'Contacts',\n    fields: {\n      salutation: {\n        label: 'Salutation',\n        options: { mr: 'Mr.', ms: 'Ms.', mrs: 'Mrs.', dr: 'Dr.', prof: 'Prof.' },\n      },\n      first_name: { label: 'First Name' },\n      last_name: { label: 'Last Name' },\n      full_name: { label: 'Full Name' },\n      crm_account: { label: 'Account' },\n      email: { label: 'Email' },\n      phone: { label: 'Phone' },\n      mobile: { label: 'Mobile' },\n      title: { label: 'Title' },\n      department: {\n        label: 'Department',\n        options: {\n          executive: 'Executive', sales: 'Sales', marketing: 'Marketing',\n          engineering: 'Engineering', support: 'Support', finance: 'Finance',\n          hr: 'Human Resources', operations: 'Operations',\n        },\n      },\n      // Buying centre (REQ-0004) \u2014 the decision map. English is the source\n      // wording for the option VALUES; every other pack translates these.\n      buying_function: {\n        label: 'Buying Function',\n        options: {\n          decision_maker: 'Decision Maker', economic_buyer: 'Economic Buyer',\n          technical_evaluator: 'Technical Evaluator', user: 'User',\n          influencer: 'Influencer', gatekeeper: 'Gatekeeper',\n        },\n      },\n      attitude: {\n        label: 'Attitude to Us',\n        options: {\n          champion: 'Champion', supportive: 'Supportive', neutral: 'Neutral',\n          skeptical: 'Skeptical', blocker: 'Blocker',\n        },\n      },\n      relationship_strength: {\n        label: 'Relationship Strength',\n        options: {\n          distant: 'Distant', acquaintance: 'Acquaintance', working: 'Working Relationship',\n          strong: 'Strong', trusted_advisor: 'Trusted Advisor',\n        },\n      },\n      owner_id: { label: 'Contact Owner' },\n      description: { label: 'Description' },\n      is_primary: { label: 'Primary Contact', help: 'Is this the main contact for the account?' },\n      avatar: { label: 'Profile Picture' },\n      mailing_address: { label: 'Mailing Address' },\n      lead_source: {\n        label: 'Lead Source',\n        options: {\n          web: 'Web', referral: 'Referral', event: 'Event / Trade Show',\n          webinar: 'Webinar', partner: 'Partner', advertisement: 'Advertisement',\n          paid_search: 'Paid Search', social: 'Social Media', content: 'Content / Blog',\n          cold_call: 'Cold Call', email_campaign: 'Email Campaign', other: 'Other',\n        },\n      },\n      do_not_call: { label: 'Do Not Call' },\n      email_opt_out: { label: 'Email Opt Out' },\n      last_contacted_date: { label: 'Last Contacted' },\n    },\n    _views: {\n      all_contacts: { label: 'All Contacts' },\n      contact_directory: { label: 'People Directory' },\n      primary_contacts: { label: 'Primary Contacts' },\n    },\n    _sections: {\n      identity: { label: 'Identity' },\n      account_info: { label: 'Account & Title' },\n      buying_centre: { label: 'Buying Centre' },\n      contact_info: { label: 'Contact Information' },\n      mailing_address: { label: 'Mailing Address' },\n      additional: { label: 'Additional Info' },\n      preferences: { label: 'Communication Preferences' },\n      // Form section names on contact.view.ts (#1100). `contact_details` /\n      // `comm_preferences`, not `contact_info` / `preferences` \u2014 those are\n      // already fieldGroup keys with their own (longer) wording above.\n      contact_details: { label: 'Contact Info' },\n      comm_preferences: { label: 'Preferences' },\n    },\n    _actions: {\n      ...activityActions,\n      mark_primary: {\n        label: 'Mark as Primary Contact',\n        confirmText: 'Mark this contact as the primary contact for the account?',\n        successMessage: 'Contact marked as primary!',\n      },\n      send_email: {\n        label: 'Send Email',\n        params: {\n          subject: { label: 'Subject' },\n          body: { label: 'Body' },\n        },\n      },\n      add_contact_to_campaign: {\n        label: 'Add to Campaign',\n        successMessage: 'Contacts added to campaign!',\n        params: {\n          crm_campaign: { label: 'Campaign' },\n        },\n      },\n    },\n  },\n};\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/sales/translations/en/objects.pipeline.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/sales/translations/en\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/sales/translations/en/objects.pipeline.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport type { ObjectTranslationData } from '@objectstack/spec/system';\n\nimport { activityActions } from './_shared';\n\n/**\n * English (en) \u2014 `objects` translations for the PIPELINE family:\n * demand and the deals it becomes, plus the roll-up that forecasts them.\n *\n * Roster: `crm_lead`, `crm_opportunity`, `crm_opportunity_line_item`, `crm_forecast`.\n *\n * SPLIT AXIS (#1311): translation NAMESPACE first, then CRM DOMAIN FAMILY.\n * Everything that is not `objects` lives in `./app.ts`; `objects` \u2014 69-78% of\n * every bundle \u2014 is one file per CRM domain family, and a detail object\n * follows its master. A new row goes in the file for ITS family, never in\n * whichever file is already open: that is how one file re-grows past the 70%\n * advisory band `pnpm hygiene` prints. Full rule and rationale:\n * `src/sales/translations/en.ts`.\n */\nexport const pipeline: Record<string, ObjectTranslationData> = {\n  crm_lead: {\n    label: 'Lead',\n    pluralLabel: 'Leads',\n    fields: {\n      first_name: { label: 'First Name' },\n      last_name: { label: 'Last Name' },\n      company: { label: 'Company' },\n      title: { label: 'Title' },\n      email: { label: 'Email' },\n      phone: { label: 'Phone' },\n      status: {\n        label: 'Status',\n        options: {\n          new: 'New', contacted: 'Contacted', qualified: 'Qualified',\n          unqualified: 'Unqualified', converted: 'Converted',\n        },\n      },\n      lead_source: {\n        label: 'Lead Source',\n        options: {\n          web: 'Web', referral: 'Referral', event: 'Event / Trade Show',\n          webinar: 'Webinar', partner: 'Partner', advertisement: 'Advertisement',\n          paid_search: 'Paid Search', social: 'Social Media', content: 'Content / Blog',\n          cold_call: 'Cold Call', email_campaign: 'Email Campaign', other: 'Other',\n        },\n      },\n      owner_id: { label: 'Lead Owner' },\n      is_converted: { label: 'Converted' },\n      description: { label: 'Description' },\n      salutation: {\n        label: 'Salutation',\n        options: { mr: 'Mr.', ms: 'Ms.', mrs: 'Mrs.', dr: 'Dr.', prof: 'Prof.' },\n      },\n      full_name: { label: 'Full Name' },\n      industry: {\n        label: 'Industry',\n        options: {\n          technology: 'Technology', software: 'Software / SaaS', finance: 'Finance',\n          healthcare: 'Healthcare', retail: 'Retail', manufacturing: 'Manufacturing',\n          education: 'Education', real_estate: 'Real Estate', media: 'Media & Entertainment',\n          logistics: 'Logistics', hospitality: 'Hospitality', energy: 'Energy & Utilities',\n          government: 'Government', nonprofit: 'Non-profit', other: 'Other',\n        },\n      },\n      mobile: { label: 'Mobile' },\n      website: { label: 'Website' },\n      rating: { label: 'Lead Score', help: 'Lead quality score (1-5 stars)' },\n      converted_account: { label: 'Converted Account' },\n      converted_contact: { label: 'Converted Contact' },\n      converted_opportunity: { label: 'Converted Opportunity' },\n      converted_date: { label: 'Converted Date' },\n      address: { label: 'Address' },\n      annual_revenue: { label: 'Annual Revenue' },\n      number_of_employees: { label: 'Number of Employees' },\n      notes: { label: 'Notes', help: 'Working notes on this lead \u2014 supports formatting.' },\n      do_not_call: { label: 'Do Not Call' },\n      email_opt_out: { label: 'Email Opt Out' },\n      disqualification_reason: {\n        label: 'Disqualification Reason',\n        help: 'Required when status is Unqualified',\n        options: {\n          not_a_fit: 'Not a Fit', no_budget: 'No Budget', wrong_persona: 'Wrong Persona',\n          unreachable: 'Unreachable', duplicate: 'Duplicate', competitor: 'Competitor',\n          other: 'Other',\n        },\n      },\n      duplicate_of_type: {\n        label: 'Duplicate Of',\n        help: 'Which object holds the surviving record this lead repeats.',\n        // `erased` is a tombstone, not a choice: the form does not offer it\n        // (see `src/sales/views/lead.view.ts`), but a lead whose survivor was\n        // deleted carries it, so it needs a label wherever the record is\n        // READ \u2014 detail page, list column, export. Untranslated it would\n        // render as the raw `erased`.\n        options: { crm_lead: 'Lead', crm_contact: 'Contact', erased: 'Erased Record' },\n      },\n      duplicate_of_lead: { label: 'Duplicate Of Lead' },\n      duplicate_of_contact: { label: 'Duplicate Of Contact' },\n      duplicate_status: {\n        label: 'Duplicate Status',\n        help: 'Suspected = flagged automatically at intake. Confirmed = a human verified the match.',\n        options: { suspected: 'Suspected', confirmed: 'Confirmed' },\n      },\n      display_title: { label: 'Display Title' },\n      company_normalized: {\n        label: 'Company (Normalized)',\n        help: 'Match key for lead conversion: Company lower-cased, trimmed, with internal whitespace collapsed. Maintained by the lead_duplicate_check hook \u2014 never edit directly.',\n      },\n      next_followup_date: { label: 'Next Follow-up Date' },\n      last_contacted_date: { label: 'Last Contacted' },\n      need_type: {\n        label: 'Need Type',\n        help: 'What this prospect is asking for. Routing, prioritisation and demand reporting read this.',\n        options: {\n          new_implementation: 'New Implementation', expansion: 'Expansion',\n          replacement: 'Replacement', renewal: 'Renewal', consulting: 'Consulting',\n          support: 'Support & Maintenance', other: 'Other',\n        },\n      },\n      estimated_amount: {\n        label: 'Estimated Amount',\n        help: 'Estimated value of this demand, before qualification. Prefills the deal amount at conversion.',\n      },\n      conversion_approval_status: {\n        label: 'Conversion Approval',\n        help: 'Whether this lead has been signed off for conversion. Not Required means no approval is asked for \u2014 the shipped default.',\n        options: {\n          not_required: 'Not Required', pending: 'Pending',\n          approved: 'Approved', rejected: 'Rejected',\n        },\n      },\n    },\n    _views: {\n      all_leads: {\n        label: 'All Leads',\n        emptyState: { title: 'No Leads Yet', message: 'Get started by creating your first lead' },\n      },\n      kanban_by_status: { label: 'Lead Pipeline' },\n      calendar_by_created: { label: 'Lead Calendar' },\n      gallery_view: { label: 'Lead Cards' },\n      my_leads: { label: 'My Leads' },\n      high_priority: { label: 'High Priority' },\n      hot_leads: { label: '\uD83D\uDD25 Hot Leads' },\n      suspected_duplicates: {\n        label: 'Suspected Duplicates',\n        emptyState: {\n          title: 'No Suspected Duplicates',\n          message: 'Nothing to review \u2014 every re-captured email has been checked.',\n        },\n      },\n    },\n    _sections: {\n      identity: { label: 'Identity' },\n      company_info: { label: 'Company Information' },\n      contact_info: { label: 'Contact Information' },\n      qualification: { label: 'Qualification' },\n      assignment: { label: 'Assignment' },\n      address: { label: 'Address' },\n      additional: { label: 'Additional Info' },\n      preferences: { label: 'Communication Preferences' },\n      conversion: { label: 'Conversion' },\n      duplicates: { label: 'Duplicate Management' },\n      // The detail page's sections reference the groups above (#806), so it\n      // has no section names of its own.\n      // Form section names on lead.view.ts (#1100). The sections of the\n      // default form and of every named formView live here \u2014 add a form\n      // there, add its section names here. `address` / `qualification` above\n      // are reused (identical fieldGroup wording); every other name here is new.\n      contact_information: { label: 'Contact Information' },\n      lead_classification: { label: 'Lead Classification' },\n      company_information: { label: 'Company Information' },\n      additional_information: { label: 'Additional Information' },\n      privacy: { label: 'Privacy' },\n      general: { label: 'General' },\n      details: { label: 'Details' },\n      step_1_contact_details: { label: 'Step 1: Contact Details' },\n      step_2_company_information: { label: 'Step 2: Company Information' },\n      step_3_qualification: { label: 'Step 3: Qualification' },\n      step_4_review_and_convert: { label: 'Step 4: Review & Convert' },\n      primary_information: { label: 'Primary Information' },\n      extended_details: { label: 'Extended Details' },\n      quick_edit: { label: 'Quick Edit' },\n      update_lead_status: { label: 'Update Lead Status' },\n      tell_us_about_yourself: { label: 'Tell us about yourself' },\n      about_your_company: { label: 'About your company' },\n      how_can_we_help: { label: 'How can we help?' },\n      lead_information: { label: 'Lead Information' },\n      address_information: { label: 'Address Information' },\n      privacy_preferences: { label: 'Privacy Preferences' },\n    },\n    _actions: {\n      ...activityActions,\n      convert_lead: {\n        label: 'Convert Lead',\n        successMessage: 'Lead converted successfully!',\n      },\n      create_campaign: {\n        label: 'Add to Campaign',\n        successMessage: 'Leads added to campaign!',\n        params: {\n          crm_campaign: { label: 'Campaign' },\n        },\n      },\n      schedule_followup: {\n        label: 'Schedule Follow-up',\n        successMessage: 'Follow-up scheduled.',\n      },\n    },\n  },\n  crm_opportunity: {\n    label: 'Opportunity',\n    pluralLabel: 'Opportunities',\n    fields: {\n      name: { label: 'Opportunity Name' },\n      crm_account: { label: 'Account' },\n      primary_contact: { label: 'Primary Contact' },\n      owner_id: { label: 'Opportunity Owner' },\n      amount: { label: 'Amount' },\n      expected_revenue: { label: 'Expected Revenue' },\n      stage: {\n        label: 'Stage',\n        options: {\n          prospecting: 'Prospecting', qualification: 'Qualification',\n          needs_analysis: 'Needs Analysis', proposal: 'Proposal',\n          negotiation: 'Negotiation', closed_won: 'Closed Won', closed_lost: 'Closed Lost',\n        },\n      },\n      probability: { label: 'Probability (%)' },\n      close_date: { label: 'Close Date' },\n      type: {\n        label: 'Type',\n        options: {\n          new_business: 'New Business',\n          existing_upgrade: 'Existing Customer - Upgrade',\n          existing_renewal: 'Existing Customer - Renewal',\n          existing_expansion: 'Existing Customer - Expansion',\n        },\n      },\n      forecast_category: {\n        label: 'Forecast Category',\n        options: {\n          pipeline: 'Pipeline', best_case: 'Best Case',\n          commit: 'Commit', omitted: 'Omitted', closed: 'Closed',\n        },\n      },\n      description: { label: 'Description' },\n      next_step: { label: 'Next Step' },\n      lead_source: {\n        label: 'Lead Source',\n        options: {\n          web: 'Web', referral: 'Referral', event: 'Event / Trade Show',\n          webinar: 'Webinar', partner: 'Partner', advertisement: 'Advertisement',\n          paid_search: 'Paid Search', social: 'Social Media', content: 'Content / Blog',\n          cold_call: 'Cold Call', email_campaign: 'Email Campaign', other: 'Other',\n        },\n      },\n      crm_campaign: { label: 'Campaign', help: 'Marketing campaign that generated this opportunity' },\n      days_in_stage: { label: 'Days in Current Stage' },\n      stage_entry_date: {\n        label: 'Stage Entry Date',\n        help: 'Date this opportunity entered its current stage.',\n      },\n      is_private: { label: 'Private' },\n      approval_status: {\n        label: 'Approval Status',\n        options: { not_required: 'Not Required', pending: 'Pending', approved: 'Approved', rejected: 'Rejected' },\n      },\n      approved_date: { label: 'Approved Date' },\n      win_reason: {\n        label: 'Win Reason',\n        help: 'Why this deal was won. Required to close an opportunity as Won.',\n        options: {\n          better_product: 'Better Product', better_price: 'Better Price', relationship: 'Existing Relationship',\n          better_support: 'Better Support', best_fit: 'Best Fit / Features',\n          quote_accepted: 'Quote Accepted', other: 'Other',\n        },\n      },\n      loss_reason: {\n        label: 'Loss Reason',\n        help: 'Why this deal was lost. Required to close an opportunity as Lost.',\n        options: {\n          price: 'Price Too High', competitor: 'Lost to Competitor', no_budget: 'No Budget',\n          no_decision: 'No Decision', timing: 'Bad Timing', features: 'Missing Features', other: 'Other',\n        },\n      },\n      loss_details: {\n        label: 'Loss/Win Details',\n        help: 'Free-text context behind the win or loss reason.',\n      },\n      // REQ-0006 \u2014 qualification, the customer's procurement calendar, the\n      // deal narrative, the business line and the status-change gate.\n      will_bid: {\n        label: 'Will Bid',\n        help: 'Whether we intend to bid. Unset means the decision is open.',\n      },\n      controllability: { label: 'Controllability', options: { high: 'High', medium: 'Medium', low: 'Low' } },\n      priority: { label: 'Priority', options: { high: 'High', medium: 'Medium', low: 'Low' } },\n      deal_level: { label: 'Deal Level', options: { strategic: 'Strategic', key: 'Key', standard: 'Standard' } },\n      is_subcontracted: { label: 'Involves Subcontracting' },\n      subcontracting_note: { label: 'Subcontracting Note' },\n      customer_initiation_date: { label: 'Customer Initiation Date' },\n      expected_tender_date: { label: 'Expected Tender Date' },\n      expected_signing_date: { label: 'Expected Signing Date' },\n      expected_tender_amount: { label: 'Expected Tender Amount' },\n      expected_signing_amount: { label: 'Expected Signing Amount' },\n      business_line: {\n        label: 'Business Line',\n        options: {\n          product: 'Product', services: 'Professional Services', consulting: 'Consulting',\n          support: 'Support & Maintenance', other: 'Other',\n        },\n      },\n      customer_background: { label: 'Customer Background' },\n      project_background: { label: 'Project Background' },\n      risk_analysis: { label: 'Risk Analysis' },\n      payment_terms: { label: 'Payment Terms' },\n      requested_status: { label: 'Requested Status', options: { closed_won: 'Won', closed_lost: 'Lost' } },\n      status_change_approval_status: {\n        label: 'Status Change Approval',\n        options: { not_required: 'Not Required', pending: 'Pending', approved: 'Approved', rejected: 'Rejected' },\n      },\n      // REQ-0006 step 11 \u2014 the \u7ACB\u9879 (qualification) approval gate.\n      qualification_requested: {\n        label: 'Request Qualification Approval',\n        help: 'Tick to send this deal for qualification approval. A rejection clears it; tick it again to ask again.',\n      },\n      qualification_approval_status: {\n        label: 'Qualification Approval',\n        options: { not_required: 'Not Required', pending: 'Pending', approved: 'Approved', rejected: 'Rejected' },\n      },\n    },\n    _views: {\n      tender_this_quarter: {\n        label: 'Tender This Quarter',\n        emptyState: {\n          title: 'No Tenders Expected This Quarter',\n          message: 'This tab lists open deals whose customer-side tender date falls inside the current quarter. Record Expected Tender Date on a deal to see it here.',\n        },\n      },\n      open_opportunities: { label: 'Open Deals' },\n      all_opportunities: { label: 'All Opportunities' },\n      pipeline_kanban: { label: 'Sales Pipeline' },\n      close_date_calendar: { label: 'Forecast Calendar' },\n      deal_timeline: { label: 'Deal Timeline' },\n      deal_gallery: { label: 'Deal Cards' },\n      my_open_deals: { label: 'My Open Deals' },\n      stale_opportunities: { label: '\u26A0\uFE0F Stale Opportunities \u00B7 Longest in Stage First' },\n      closing_this_quarter: {\n        label: 'Closing This Quarter',\n        emptyState: {\n          title: 'No Deals Closing This Quarter',\n          message: 'This tab lists open commit and best-case deals with a close date inside the current quarter. Nothing matches right now \u2014 deals closing later are on the Open Deals tab.',\n        },\n      },\n    },\n    _sections: {\n      basic: { label: 'Basic Information' },\n      financials: { label: 'Financials' },\n      sales_process: { label: 'Sales Process' },\n      classification: { label: 'Classification' },\n      campaign: { label: 'Campaigns' },\n      notes: { label: 'Notes & Next Steps' },\n      qualification: { label: 'Qualification' },\n      narrative: { label: 'Deal Narrative' },\n      crm_forecast: { label: 'Forecast & Metrics' },\n      // The detail page's sections reference the groups above (#1452), so it\n      // has no section names of its own.\n      // Form section names on opportunity.view.ts (#1100)\n      overview: { label: 'Overview' },\n      forecast: { label: 'Forecast' },\n      sales_strategy: { label: 'Sales Strategy' },\n      win_loss: { label: 'Win / Loss' },\n    },\n    _actions: {\n      ...activityActions,\n      clone_opportunity: {\n        label: 'Clone Opportunity',\n        successMessage: 'Opportunity cloned successfully!',\n      },\n      mass_update_stage: {\n        label: 'Update Stage',\n        successMessage: 'Opportunities updated successfully!',\n        params: {\n          stage: { label: 'New Stage' },\n        },\n      },\n      generate_quote: {\n        label: 'Generate Quote',\n        successMessage: 'Quote created from opportunity!',\n      },\n    },\n  },\n  crm_opportunity_line_item: {\n    label: 'Opportunity Line Item',\n    pluralLabel: 'Opportunity Line Items',\n    description: 'Per-product pricing lines under an opportunity',\n    fields: {\n      crm_opportunity: { label: 'Opportunity' },\n      crm_product: { label: 'Product' },\n      description: { label: 'Description' },\n      quantity: { label: 'Quantity' },\n      list_price: { label: 'List Price', help: \"Auto-populated from the product's List Price.\" },\n      unit_price: {\n        label: 'Sales Price',\n        help: 'Negotiated unit price (may differ from list price)',\n      },\n      discount: { label: 'Discount %' },\n      total_price: { label: 'Total' },\n      line_number: { label: 'Line #' },\n    },\n    _sections: {\n      basic: { label: 'Line Item' },\n      pricing: { label: 'Pricing' },\n    },\n  },\n  crm_forecast: {\n    label: 'Forecast',\n    pluralLabel: 'Forecasts',\n    description: 'Periodic pipeline snapshot by owner used for revenue forecasting',\n    fields: {\n      owner_id: { label: 'Owner' },\n      period: { label: 'Period', options: { month: 'Month', quarter: 'Quarter' } },\n      period_start: {\n        label: 'Period Start',\n        help: 'Must be the first day of the period \u2014 e.g. 2026-08-01 for Aug 2026. A quarterly forecast must additionally start on a quarter boundary: January 1, April 1, July 1 or October 1.',\n      },\n      period_end: {\n        label: 'Period End',\n        help: 'Normally derived automatically from Period and Period Start. If set by hand, it must be the last day of that period \u2014 e.g. 2026-09-30 for a quarter starting 2026-07-01, or 2026-08-31 for Aug 2026.',\n      },\n      period_label: { label: 'Period', help: 'Human-friendly label, e.g. \"Q3 2026\" or \"Aug 2026\".' },\n      snapshot_date: { label: 'Snapshot Date', help: 'The day this snapshot was captured.' },\n      source: {\n        label: 'Source',\n        options: { scheduled: 'Scheduled snapshot', ai: 'AI skill', manual: 'Manual entry' },\n      },\n      quota: { label: 'Quota' },\n      pipeline_amount: {\n        label: 'Pipeline',\n        help: 'Sum of all open opportunities closing in this period (any stage).',\n      },\n      best_case_amount: {\n        label: 'Best Case',\n        help: 'Open opportunities in the Best Case or Commit forecast category.',\n      },\n      commit_amount: {\n        label: 'Commit',\n        help: 'Open opportunities in the Commit forecast category (owner-committed).',\n      },\n      closed_amount: { label: 'Closed Won', help: 'Already-closed-won amount in this period.' },\n      expected_amount: {\n        label: 'Expected',\n        help: 'Closed Won + Commit \u2014 what the owner reasonably expects to land.',\n      },\n      attainment_pct: { label: 'Attainment %', help: 'Closed Won \u00F7 Quota \u00D7 100. Reads 0% until a positive quota is set.' },\n      coverage_ratio: {\n        label: 'Coverage',\n        help: 'Pipeline \u00F7 (Quota \u2212 Closed Won) \u2014 whether enough pipeline remains to cover the gap. Reads 0 once the quota is already met.',\n      },\n      notes: { label: 'Notes' },\n      display_title: { label: 'Display Title' },\n      seed_key: {\n        label: 'Seed Key',\n        help: 'Demo-fixture identity. Written only by the seed loader; empty on every real snapshot.',\n      },\n    },\n    _views: {\n      all_forecasts: { label: 'All Forecasts' },\n      this_quarter_forecasts: {\n        label: 'This Quarter',\n        emptyState: {\n          title: 'This Quarter Has No Snapshots Yet',\n          message: 'Quarterly snapshots are written by the nightly forecast sweep. Until it has run once for the current quarter this view is empty \u2014 settled quarters are on the All tab.',\n        },\n      },\n      my_forecast: { label: 'My Forecast' },\n    },\n    _sections: {\n      basic: { label: 'Snapshot' },\n      amounts: { label: 'Amounts' },\n      meta: { label: 'Source' },\n      // Form section names on forecast.view.ts (#1100). `basic`'s label\n      // matches \"Snapshot\" but its key does not, so this form section\n      // needs its own entry; `notes` has no fieldGroup counterpart at all.\n      snapshot: { label: 'Snapshot' },\n      notes: { label: 'Notes' },\n    },\n  },\n};\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/sales/translations/en/objects.commerce.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/sales/translations/en\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/sales/translations/en/objects.commerce.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport type { ObjectTranslationData } from '@objectstack/spec/system';\n\n/**\n * English (en) \u2014 `objects` translations for the COMMERCE family:\n * what gets sold and on what paper \u2014 quotes, contracts, products.\n *\n * Roster: `crm_quote`, `crm_quote_line_item`, `crm_contract`, `crm_product`.\n *\n * SPLIT AXIS (#1311): translation NAMESPACE first, then CRM DOMAIN FAMILY.\n * Everything that is not `objects` lives in `./app.ts`; `objects` \u2014 69-78% of\n * every bundle \u2014 is one file per CRM domain family, and a detail object\n * follows its master. A new row goes in the file for ITS family, never in\n * whichever file is already open: that is how one file re-grows past the 70%\n * advisory band `pnpm hygiene` prints. Full rule and rationale:\n * `src/sales/translations/en.ts`.\n */\nexport const commerce: Record<string, ObjectTranslationData> = {\n  crm_quote: {\n    label: 'Quote',\n    pluralLabel: 'Quotes',\n    fields: {\n      quote_number: { label: 'Quote Number' },\n      name: { label: 'Quote Name' },\n      crm_account: { label: 'Account' },\n      crm_contact: {\n        label: 'Contact',\n        help: 'Required once the quote is Presented or Accepted \u2014 the drafted contract takes its Primary Contact from here.',\n      },\n      crm_opportunity: { label: 'Opportunity' },\n      owner_id: { label: 'Quote Owner' },\n      status: {\n        label: 'Status',\n        options: {\n          draft: 'Draft', in_review: 'In Review', presented: 'Presented',\n          accepted: 'Accepted', rejected: 'Rejected', expired: 'Expired',\n        },\n      },\n      quote_date: { label: 'Quote Date' },\n      expiration_date: { label: 'Expiration Date' },\n      subtotal: { label: 'Subtotal' },\n      discount: { label: 'Discount %' },\n      discount_amount: { label: 'Discount Amount' },\n      tax: { label: 'Tax' },\n      shipping_handling: { label: 'Shipping & Handling' },\n      total_price: { label: 'Total Price' },\n      payment_terms: {\n        label: 'Payment Terms',\n        options: {\n          net_15: 'Net 15', net_30: 'Net 30', net_60: 'Net 60',\n          net_90: 'Net 90', due_on_receipt: 'Due on Receipt',\n        },\n      },\n      shipping_terms: { label: 'Shipping Terms' },\n      billing_address: { label: 'Billing Address' },\n      shipping_address: { label: 'Shipping Address' },\n      description: { label: 'Description' },\n      internal_notes: { label: 'Internal Notes' },\n      display_title: { label: 'Display Title' },\n    },\n    _views: {\n      all_quotes: { label: 'All Quotes' },\n      quote_pipeline: { label: 'Quote Pipeline' },\n      quote_calendar: { label: 'Quote Calendar' },\n    },\n    _sections: {\n      basic: { label: 'Quote Information' },\n      pricing: { label: 'Pricing' },\n      terms: { label: 'Terms & Validity' },\n      address: { label: 'Addresses' },\n      system: { label: 'System' },\n      // Form section names on quote.view.ts (#1100). `quote_terms`, not\n      // `terms` \u2014 `terms` is already the fieldGroup key for \"Terms & Validity\".\n      quote: { label: 'Quote' },\n      totals: { label: 'Totals' },\n      quote_terms: { label: 'Terms' },\n      addresses_and_notes: { label: 'Addresses & Notes' },\n    },\n  },\n  crm_quote_line_item: {\n    label: 'Quote Line Item',\n    pluralLabel: 'Quote Line Items',\n    description: 'Per-product pricing lines under a quote',\n    fields: {\n      crm_quote: { label: 'Quote' },\n      crm_product: { label: 'Product' },\n      description: { label: 'Description' },\n      quantity: { label: 'Quantity' },\n      list_price: { label: 'List Price' },\n      unit_price: { label: 'Sales Price' },\n      discount: { label: 'Discount %' },\n      subtotal: { label: 'Subtotal' },\n      total_price: { label: 'Total' },\n      line_number: { label: 'Line #' },\n    },\n    _sections: {\n      basic: { label: 'Line Item' },\n      pricing: { label: 'Pricing' },\n    },\n  },\n  crm_contract: {\n    label: 'Contract',\n    pluralLabel: 'Contracts',\n    fields: {\n      contract_number: { label: 'Contract Number' },\n      crm_account: { label: 'Account' },\n      crm_contact: { label: 'Primary Contact' },\n      crm_opportunity: { label: 'Related Opportunity' },\n      owner_id: { label: 'Contract Owner' },\n      status: {\n        label: 'Status',\n        options: {\n          draft: 'Draft', in_approval: 'In Approval', activated: 'Activated',\n          expired: 'Expired', terminated: 'Terminated',\n        },\n      },\n      contract_term_months: { label: 'Contract Term (Months)' },\n      start_date: { label: 'Start Date' },\n      end_date: { label: 'End Date' },\n      contract_value: { label: 'Contract Value' },\n      billing_frequency: {\n        label: 'Billing Frequency',\n        options: {\n          monthly: 'Monthly', quarterly: 'Quarterly',\n          annually: 'Annually', one_time: 'One-time',\n        },\n      },\n      payment_terms: {\n        label: 'Payment Terms',\n        options: {\n          net_15: 'Net 15', net_30: 'Net 30', net_60: 'Net 60',\n          net_90: 'Net 90', due_on_receipt: 'Due on Receipt',\n        },\n      },\n      auto_renewal: { label: 'Auto Renewal' },\n      renewal_notice_days: { label: 'Renewal Notice (Days)' },\n      contract_type: {\n        label: 'Contract Type',\n        options: {\n          subscription: 'Subscription', service: 'Service Agreement', license: 'License',\n          partnership: 'Partnership', nda: 'NDA', msa: 'MSA',\n        },\n      },\n      signed_date: { label: 'Signed Date' },\n      signed_by: { label: 'Signed By' },\n      document_url: { label: 'Contract Document' },\n      special_terms: { label: 'Special Terms' },\n      description: { label: 'Description' },\n      billing_address: { label: 'Billing Address' },\n    },\n    _views: {\n      all_contracts: { label: 'All Contracts' },\n      renewal_calendar: { label: 'Renewal Calendar' },\n      contract_gantt: { label: 'Contract Terms' },\n      contract_timeline: { label: 'Contract Timeline' },\n    },\n    _sections: {\n      basic: { label: 'Contract Information' },\n      parties: { label: 'Parties' },\n      terms: { label: 'Terms & Dates' },\n      value: { label: 'Contract Value' },\n      status: { label: 'Status & Approval' },\n      renewal: { label: 'Renewal' },\n      // Form section names on contract.view.ts (#1100). `contract_terms`,\n      // not `terms` \u2014 `terms` is already the fieldGroup key for \"Terms & Dates\".\n      contract_terms: { label: 'Terms' },\n      signing_and_documents: { label: 'Signing & Documents' },\n      notes: { label: 'Notes' },\n    },\n  },\n  crm_product: {\n    label: 'Product',\n    pluralLabel: 'Products',\n    fields: {\n      product_code: { label: 'Product Code' },\n      name: { label: 'Product Name' },\n      description: { label: 'Description' },\n      category: {\n        label: 'Category',\n        options: {\n          software: 'Software', hardware: 'Hardware', service: 'Service',\n          subscription: 'Subscription', support: 'Support',\n        },\n      },\n      family: {\n        label: 'Product Family',\n        options: {\n          enterprise: 'Enterprise Solutions', smb: 'SMB Solutions',\n          services: 'Professional Services', cloud: 'Cloud Services',\n        },\n      },\n      list_price: { label: 'List Price' },\n      cost: { label: 'Cost' },\n      sku: { label: 'SKU' },\n      is_active: { label: 'Active' },\n      product_manager: { label: 'Product Manager' },\n      image: { label: 'Product Image' },\n      datasheet: { label: 'Datasheet' },\n      display_title: { label: 'Display Title' },\n    },\n    _views: {\n      all_products: { label: 'All Products' },\n      product_catalog: { label: 'Product Catalog' },\n    },\n    _sections: {\n      basic: { label: 'Product Information' },\n      pricing: { label: 'Pricing' },\n      metadata: { label: 'Resources' },\n      // Form section names on product.view.ts (#1100)\n      product_info: { label: 'Product Info' },\n      pricing_info: { label: 'Pricing' },\n      media: { label: 'Media' },\n    },\n  },\n};\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/sales/translations/en/objects.service.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/sales/translations/en\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/sales/translations/en/objects.service.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport type { ObjectTranslationData } from '@objectstack/spec/system';\n\nimport { activityActions } from './_shared';\n\n/**\n * English (en) \u2014 `objects` translations for the SERVICE family:\n * post-sale support \u2014 cases and the knowledge that deflects them.\n *\n * Roster: `crm_case`, `crm_knowledge_article`, `crm_article_feedback`.\n *\n * SPLIT AXIS (#1311): translation NAMESPACE first, then CRM DOMAIN FAMILY.\n * Everything that is not `objects` lives in `./app.ts`; `objects` \u2014 69-78% of\n * every bundle \u2014 is one file per CRM domain family, and a detail object\n * follows its master. A new row goes in the file for ITS family, never in\n * whichever file is already open: that is how one file re-grows past the 70%\n * advisory band `pnpm hygiene` prints. Full rule and rationale:\n * `src/sales/translations/en.ts`.\n */\nexport const service: Record<string, ObjectTranslationData> = {\n  crm_case: {\n    label: 'Case',\n    pluralLabel: 'Cases',\n    fields: {\n      case_number: { label: 'Case Number' },\n      subject: { label: 'Subject' },\n      description: { label: 'Description' },\n      crm_account: { label: 'Account' },\n      crm_contact: { label: 'Contact' },\n      status: {\n        label: 'Status',\n        options: {\n          new: 'New', in_progress: 'In Progress', waiting_customer: 'Waiting on Customer',\n          waiting_support: 'Waiting on Support', escalated: 'Escalated',\n          resolved: 'Resolved', closed: 'Closed',\n        },\n      },\n      priority: {\n        label: 'Priority',\n        options: { low: 'Low', medium: 'Medium', high: 'High', critical: 'Critical' },\n      },\n      type: {\n        label: 'Case Type',\n        options: {\n          question: 'Question', problem: 'Problem',\n          feature_request: 'Feature Request', bug: 'Bug',\n        },\n      },\n      origin: {\n        label: 'Case Origin',\n        options: { email: 'Email', phone: 'Phone', web: 'Web', chat: 'Chat', social_media: 'Social Media' },\n      },\n      owner_id: { label: 'Case Owner' },\n      closed_date: { label: 'Closed Date' },\n      first_response_date: { label: 'First Response Date' },\n      resolution_time_hours: { label: 'Resolution Time (Hours)' },\n      sla_due_date: { label: 'SLA Due Date', help: 'Set from the case priority and the account\u2019s Customer Tier, in calendar hours: nights, weekends and holidays count.' },\n      is_sla_violated: { label: 'SLA Violated' },\n      is_escalated: { label: 'Escalated' },\n      escalation_reason: { label: 'Escalation Reason' },\n      resolution: { label: 'Resolution' },\n      resolved_by_article: { label: 'Resolved by Article', help: 'Knowledge article that resolved this case \u2014 the deflection signal.' },\n      internal_notes: { label: 'Internal Notes', help: 'Internal notes; not visible to the customer.' },\n      is_closed: { label: 'Is Closed' },\n      display_title: { label: 'Display Title' },\n      priority_rank: { label: 'Priority Rank' },\n      escalated_date: { label: 'Escalated Date' },\n    },\n    _views: {\n      all_cases: { label: 'All Cases' },\n      case_workflow: { label: 'Service Workflow' },\n      sla_calendar: { label: 'SLA Calendar' },\n      case_timeline: { label: 'Case Timeline' },\n      unassigned_triage: {\n        label: 'Unassigned \u2014 triage',\n        emptyState: {\n          title: 'Nothing waiting for triage',\n          message: 'Every case has an owner. Cases appear here when they arrive with no owner \u2014 typically a web-to-case submission that arrived while nobody held the Service Agent position.',\n        },\n      },\n      escalated_cases: { label: 'Escalated Cases' },\n      my_open_cases: { label: 'My Open Cases' },\n      sla_at_risk: { label: '\u23F0 SLA at Risk' },\n    },\n    _sections: {\n      basic: { label: 'Case Information' },\n      origin: { label: 'Origin & Routing' },\n      sla: { label: 'SLA & Priority' },\n      resolution: { label: 'Resolution' },\n      escalation: { label: 'Escalation' },\n      system: { label: 'System' },\n      // The detail page's sections reference the groups above (#970), so it\n      // has no section names of its own.\n      // Form section names on case.view.ts (#1100).\n      case: { label: 'Case' },\n      how_can_we_help: { label: 'How can we help?' },\n    },\n    _actions: {\n      ...activityActions,\n      escalate_case: {\n        label: 'Escalate Case',\n        confirmText: 'This will escalate the case to the escalation team. Continue?',\n        successMessage: 'Case escalated successfully!',\n      },\n      close_case: {\n        label: 'Close Case',\n        confirmText: 'Are you sure you want to close this case?',\n        successMessage: 'Case closed successfully!',\n      },\n      claim_case: {\n        label: 'Claim Case',\n        successMessage: 'Case claimed \u2014 it is yours now.',\n      },\n    },\n  },\n  crm_knowledge_article: {\n    label: 'Knowledge Article',\n    pluralLabel: 'Knowledge Base',\n    description: 'Reusable answers and how-to guides for customers and agents',\n    fields: {\n      article_number: { label: 'Article #' },\n      title: { label: 'Title' },\n      summary: { label: 'Summary', help: 'One-paragraph TL;DR shown in search results and AI citations.' },\n      body: { label: 'Body', help: 'Full article content (Markdown).' },\n      category: {\n        label: 'Category',\n        options: {\n          getting_started: 'Getting Started', how_to: 'How-To',\n          troubleshooting: 'Troubleshooting', billing: 'Billing & Pricing', api: 'API & Integrations',\n          release_notes: 'Release Notes', policy: 'Policy',\n        },\n      },\n      tags: {\n        label: 'Tags',\n        options: {\n          auth: 'Auth', sso: 'SSO', mobile: 'Mobile', email: 'Email',\n          reports: 'Reports', performance: 'Performance', data_import: 'Data Import',\n          webhooks: 'Webhooks',\n        },\n      },\n      status: {\n        label: 'Status',\n        options: { draft: 'Draft', in_review: 'In Review', published: 'Published', archived: 'Archived' },\n      },\n      audience: {\n        label: 'Audience',\n        help: 'Public articles are visible in the customer portal; internal articles are agent-only.',\n        options: { public: 'Public', internal: 'Internal' },\n      },\n      language: {\n        label: 'Language',\n        options: { en: 'English', zh_cn: 'Simplified Chinese', es_es: 'Spanish', ja_jp: 'Japanese' },\n      },\n      owner_id: { label: 'Owner' },\n      related_to_case: { label: 'Source Case', help: 'Case this article was authored from (optional).' },\n      published_at: { label: 'Published At' },\n      last_reviewed_at: { label: 'Last Reviewed' },\n      helpful_count: { label: 'Helpful', help: 'Recounted from crm_article_feedback \u2014 never typed in.' },\n      not_helpful_count: { label: 'Not Helpful', help: 'Recounted from crm_article_feedback \u2014 never typed in.' },\n      display_title: { label: 'Display Title' },\n    },\n    _views: {\n      all_articles: { label: 'All Articles' },\n      published_articles: { label: 'Published' },\n      my_drafts: { label: 'My Drafts' },\n    },\n    _sections: {\n      basic: { label: 'Article Information' },\n      content: { label: 'Content' },\n      taxonomy: { label: 'Categorization' },\n      metrics: { label: 'Engagement' },\n      engagement: { label: 'Engagement' },\n      // Form section name on knowledge_article.view.ts (#1100)\n      article: { label: 'Article' },\n    },\n    _actions: {\n      mark_article_helpful: {\n        label: 'Helpful',\n        successMessage: 'Thanks \u2014 recorded as helpful.',\n      },\n      mark_article_not_helpful: {\n        label: 'Not Helpful',\n        successMessage: 'Thanks \u2014 recorded as not helpful.',\n      },\n    },\n  },\n  crm_article_feedback: {\n    label: 'Article Feedback',\n    pluralLabel: 'Article Feedback',\n    description: 'One reader\u2019s helpful / not-helpful verdict on a knowledge article',\n    fields: {\n      feedback_number: { label: 'Feedback #' },\n      owner_id: { label: 'Reader' },\n      crm_knowledge_article: { label: 'Article', help: 'Knowledge article this feedback is about.' },\n      verdict: {\n        label: 'Verdict',\n        options: { helpful: 'Helpful', not_helpful: 'Not Helpful' },\n      },\n      comment: { label: 'Comment', help: 'Optional note explaining the verdict \u2014 read by the article\u2019s author.' },\n    },\n    _sections: {\n      basic: { label: 'Feedback' },\n    },\n  },\n};\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/sales/translations/en/objects.activity.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/sales/translations/en\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/sales/translations/en/objects.activity.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport type { ObjectTranslationData } from '@objectstack/spec/system';\n\n/**\n * English (en) \u2014 `objects` translations for the ACTIVITY family:\n * the interaction log \u2014 tasks, events, and who attended.\n *\n * Roster: `crm_task`, `crm_event`, `crm_event_attendee`.\n *\n * SPLIT AXIS (#1311): translation NAMESPACE first, then CRM DOMAIN FAMILY.\n * Everything that is not `objects` lives in `./app.ts`; `objects` \u2014 69-78% of\n * every bundle \u2014 is one file per CRM domain family, and a detail object\n * follows its master. A new row goes in the file for ITS family, never in\n * whichever file is already open: that is how one file re-grows past the 70%\n * advisory band `pnpm hygiene` prints. Full rule and rationale:\n * `src/sales/translations/en.ts`.\n */\nexport const activity: Record<string, ObjectTranslationData> = {\n  crm_task: {\n    label: 'Task',\n    pluralLabel: 'Tasks',\n    fields: {\n      subject: { label: 'Subject' },\n      description: { label: 'Description' },\n      status: {\n        label: 'Status',\n        options: {\n          not_started: 'Not Started', in_progress: 'In Progress', waiting: 'Waiting',\n          completed: 'Completed', deferred: 'Deferred',\n        },\n      },\n      priority: {\n        label: 'Priority',\n        options: { low: 'Low', normal: 'Normal', high: 'High', urgent: 'Urgent' },\n      },\n      type: {\n        label: 'Task Type',\n        options: {\n          call: 'Call', email: 'Email', meeting: 'Meeting',\n          follow_up: 'Follow-up', demo: 'Demo', other: 'Other',\n        },\n      },\n      due_date: { label: 'Due Date' },\n      reminder_date: { label: 'Reminder Date/Time' },\n      completed_date: { label: 'Completed Date' },\n      owner_id: { label: 'Assigned To' },\n      related_to_type: {\n        label: 'Related To Type',\n        options: {\n          crm_account: 'Account', crm_contact: 'Contact', crm_opportunity: 'Opportunity',\n          crm_lead: 'Lead', crm_case: 'Case',\n        },\n      },\n      related_to_account: { label: 'Related Account' },\n      related_to_contact: { label: 'Related Contact' },\n      related_to_opportunity: { label: 'Related Opportunity' },\n      related_to_lead: { label: 'Related Lead' },\n      related_to_case: { label: 'Related Case' },\n      is_recurring: { label: 'Recurring Task' },\n      recurrence_type: {\n        label: 'Recurrence Type',\n        options: { daily: 'Daily', weekly: 'Weekly', monthly: 'Monthly', yearly: 'Yearly' },\n      },\n      recurrence_interval: { label: 'Recurrence Interval' },\n      recurrence_end_date: { label: 'Recurrence End Date' },\n      is_completed: { label: 'Is Completed' },\n      is_overdue: { label: 'Is Overdue' },\n      progress_percent: { label: 'Progress (%)' },\n      priority_rank: { label: 'Priority Rank' },\n      reminder_sent: { label: 'Reminder Sent' },\n    },\n    _views: {\n      all_tasks: { label: 'All Tasks' },\n      task_board: { label: 'Task Board' },\n      task_calendar: { label: 'Task Schedule' },\n      task_gantt: { label: 'Execution Plan' },\n      task_timeline: { label: 'Worklog Timeline' },\n      my_open_tasks: { label: 'My Open Tasks' },\n      todays_tasks: { label: '\uD83D\uDCC5 My Priority Tasks' },\n      overdue_tasks: { label: '\u23F0 Open Tasks \u00B7 Most Overdue First' },\n    },\n    _sections: {\n      basic: { label: 'Task Information' },\n      scheduling: { label: 'Scheduling' },\n      related: { label: 'Related Records' },\n      recurrence: { label: 'Recurrence' },\n      effort: { label: 'Progress & Effort' },\n      system: { label: 'System' },\n      // Form section names on task.view.ts (#1100)\n      task: { label: 'Task' },\n      related_records: { label: 'Related Records' },\n      recurrence_and_effort: { label: 'Recurrence & Effort' },\n    },\n  },\n  crm_event: {\n    label: 'Event',\n    pluralLabel: 'Events',\n    description: 'Meetings, calls and other scheduled interactions with customers',\n    fields: {\n      subject: { label: 'Subject' },\n      description: { label: 'Description' },\n      type: {\n        label: 'Event Type',\n        options: {\n          meeting: 'Meeting', call: 'Call', demo: 'Demo',\n          webinar: 'Webinar', onsite_visit: 'Onsite Visit', other: 'Other',\n        },\n      },\n      status: {\n        label: 'Status',\n        options: {\n          planned: 'Planned', held: 'Held', cancelled: 'Cancelled', no_show: 'No Show',\n        },\n      },\n      owner_id: { label: 'Assigned To' },\n      start_datetime: { label: 'Start' },\n      end_datetime: { label: 'End' },\n      all_day: { label: 'All Day Event' },\n      duration_minutes: { label: 'Duration (minutes)' },\n      location: { label: 'Location', help: 'Room, address, or meeting link' },\n      related_to_type: {\n        label: 'Related To Type',\n        options: {\n          crm_account: 'Account', crm_contact: 'Contact', crm_opportunity: 'Opportunity',\n          crm_lead: 'Lead', crm_case: 'Case',\n        },\n      },\n      related_to_account: { label: 'Related Account' },\n      related_to_contact: { label: 'Related Contact' },\n      related_to_opportunity: { label: 'Related Opportunity' },\n      related_to_lead: { label: 'Related Lead' },\n      related_to_case: { label: 'Related Case' },\n      outcome_notes: { label: 'Outcome Notes', help: 'What was agreed, and what happens next' },\n    },\n    _views: {\n      all_events: { label: 'All Events' },\n      event_calendar: { label: 'Event Calendar' },\n      event_timeline: { label: 'Team Schedule' },\n      my_events: { label: 'My Calendar' },\n      upcoming_events: { label: '\uD83D\uDCC5 Upcoming \u00B7 Soonest First' },\n      held_events: { label: '\u2705 Interaction History' },\n    },\n    _sections: {\n      basic: { label: 'Event Information' },\n      schedule: { label: 'Schedule' },\n      related: { label: 'Related Records' },\n      outcome: { label: 'Outcome' },\n      // Form section names on event.view.ts (#1100). `related_records`,\n      // not `related` \u2014 `related` is already the fieldGroup key above.\n      event: { label: 'Event' },\n      related_records: { label: 'Related Records' },\n    },\n  },\n  crm_event_attendee: {\n    label: 'Event Attendee',\n    pluralLabel: 'Event Attendees',\n    description: 'A person invited to or present at an event',\n    fields: {\n      attendee_number: { label: 'Attendee Number' },\n      crm_event: { label: 'Event' },\n      attendee_type: {\n        label: 'Attendee Type',\n        options: { contact: 'Contact', lead: 'Lead', user: 'User', external: 'External' },\n      },\n      crm_contact: { label: 'Contact', help: 'Set when the attendee is an existing customer contact' },\n      crm_lead: { label: 'Lead', help: 'Set when the attendee is still an unconverted lead' },\n      sys_user: { label: 'User', help: 'Set when the attendee is a colleague' },\n      external_name: {\n        label: 'External Attendee',\n        help: 'Name of an attendee who is in no CRM object \u2014 set when Attendee Type is External',\n      },\n      response: {\n        label: 'Response',\n        options: {\n          no_response: 'No Response', accepted: 'Accepted',\n          declined: 'Declined', tentative: 'Tentative',\n        },\n      },\n      is_organizer: { label: 'Organizer' },\n      invited_date: { label: 'Invited' },\n    },\n    _views: {\n      all_event_attendees: { label: 'Event Attendees' },\n    },\n    _sections: {\n      basic: { label: 'Attendee' },\n      response: { label: 'Invitation' },\n      // Form section names on event_attendee.view.ts (#1100) \u2014 same English\n      // text as the fieldGroups above, but a distinct key: `attendee` /\n      // `invitation` are not `basic` / `response`.\n      attendee: { label: 'Attendee' },\n      invitation: { label: 'Invitation' },\n    },\n  },\n};\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/sales/translations/en/objects.marketing.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/sales/translations/en\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/sales/translations/en/objects.marketing.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport type { ObjectTranslationData } from '@objectstack/spec/system';\n\n/**\n * English (en) \u2014 `objects` translations for the MARKETING family:\n * demand generation \u2014 campaigns and their membership.\n *\n * Roster: `crm_campaign`, `crm_campaign_member`.\n *\n * SPLIT AXIS (#1311): translation NAMESPACE first, then CRM DOMAIN FAMILY.\n * Everything that is not `objects` lives in `./app.ts`; `objects` \u2014 69-78% of\n * every bundle \u2014 is one file per CRM domain family, and a detail object\n * follows its master. A new row goes in the file for ITS family, never in\n * whichever file is already open: that is how one file re-grows past the 70%\n * advisory band `pnpm hygiene` prints. Full rule and rationale:\n * `src/sales/translations/en.ts`.\n */\nexport const marketing: Record<string, ObjectTranslationData> = {\n  crm_campaign: {\n    label: 'Campaign',\n    pluralLabel: 'Campaigns',\n    fields: {\n      campaign_code: { label: 'Campaign Code' },\n      name: { label: 'Campaign Name' },\n      description: { label: 'Description' },\n      type: {\n        label: 'Campaign Type',\n        options: {\n          email: 'Email', webinar: 'Webinar', trade_show: 'Trade Show',\n          conference: 'Conference', direct_mail: 'Direct Mail', social_media: 'Social Media',\n          content: 'Content Marketing', partner: 'Partner Marketing',\n        },\n      },\n      channel: {\n        label: 'Primary Channel',\n        options: {\n          digital: 'Digital', social: 'Social', email: 'Email',\n          events: 'Events', partner: 'Partner',\n        },\n      },\n      status: {\n        label: 'Status',\n        options: {\n          planning: 'Planning', in_progress: 'In Progress',\n          completed: 'Completed', aborted: 'Aborted',\n        },\n      },\n      start_date: { label: 'Start Date' },\n      end_date: { label: 'End Date' },\n      budgeted_cost: { label: 'Budgeted Cost' },\n      actual_cost: { label: 'Actual Cost' },\n      expected_revenue: { label: 'Expected Revenue' },\n      actual_revenue: { label: 'Actual Revenue' },\n      target_size: { label: 'Target Size', help: 'Target number of leads/contacts' },\n      num_sent: { label: 'Number Sent' },\n      num_responses: { label: 'Number of Responses' },\n      num_leads: { label: 'Number of Leads' },\n      num_converted_leads: { label: 'Converted Leads' },\n      num_opportunities: { label: 'Opportunities Created' },\n      num_won_opportunities: { label: 'Won Opportunities' },\n      response_rate: { label: 'Response Rate %' },\n      roi: { label: 'ROI %' },\n      owner_id: { label: 'Campaign Owner' },\n      landing_page_url: { label: 'Landing Page' },\n      is_active: { label: 'Active' },\n      display_title: { label: 'Display Title' },\n    },\n    _views: {\n      all_campaigns: { label: 'All Campaigns' },\n      campaign_gantt: { label: 'Campaign Schedule' },\n      campaign_calendar: { label: 'Launch Calendar' },\n      campaign_timeline: { label: 'Marketing Timeline' },\n    },\n    _sections: {\n      basic: { label: 'Campaign Information' },\n      schedule: { label: 'Schedule' },\n      budget: { label: 'Budget & ROI' },\n      metrics: { label: 'Performance' },\n      assignment: { label: 'Ownership' },\n      assets: { label: 'Campaign Assets' },\n    },\n    _actions: {\n      enroll_leads: {\n        label: 'Enroll Members',\n        successMessage: 'Eligible members enrolled in campaign.',\n      },\n    },\n  },\n  crm_campaign_member: {\n    label: 'Campaign Member',\n    pluralLabel: 'Campaign Members',\n    description: 'Leads and contacts touched by a campaign, with response status',\n    fields: {\n      member_number: { label: 'Member Number' },\n      crm_campaign: { label: 'Campaign' },\n      crm_lead: { label: 'Lead', help: 'Set when the member was a Lead at enrollment time' },\n      crm_contact: { label: 'Contact', help: 'Set when the member is an existing Contact' },\n      status: {\n        label: 'Status',\n        options: {\n          sent: 'Sent', responded: 'Responded',\n          converted: 'Converted', unsubscribed: 'Unsubscribed',\n        },\n      },\n      added_date: { label: 'Added Date' },\n      response_date: { label: 'Response Date' },\n      has_responded: { label: 'Has Responded' },\n    },\n    _sections: {\n      basic: { label: 'Basic Information' },\n      response: { label: 'Response Tracking' },\n    },\n    _actions: {\n      mark_responded: {\n        label: 'Mark Responded',\n        successMessage: 'Response recorded on this campaign member.',\n      },\n    },\n  },\n};\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/sales/translations/en.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/sales/translations\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/sales/translations/en.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport type { TranslationData } from '@objectstack/spec/system';\n\nimport { appSurface } from './en/app';\nimport { customer } from './en/objects.customer';\nimport { pipeline } from './en/objects.pipeline';\nimport { commerce } from './en/objects.commerce';\nimport { service } from './en/objects.service';\nimport { activity } from './en/objects.activity';\nimport { marketing } from './en/objects.marketing';\n\n/**\n * English (en) \u2014 CRM App Translations\n *\n * Per-locale file: one file per language, following the `per_locale` convention.\n * Each file exports a single `TranslationData` object for its locale.\n *\n * SPLIT AXIS (#1311): translation NAMESPACE first, then CRM DOMAIN FAMILY.\n *\n * This bundle was one file and it had reached 88.6% of the 100KB source cap\n * `pnpm hygiene` enforces, growing ~1.2KB a day. It is now assembled from\n * `./<locale>/`, on an axis measured rather than guessed:\n *\n *   - every namespace that is NOT `objects` \u2014 `apps`, `messages`,\n *     `dashboards`, `datasets`, `pages`, and any namespace `TranslationData`\n *     gains later \u2014 lives in `app.ts`. Measured: those namespaces together\n *     are under a quarter of the bundle, and the schema bounds how many can\n *     ever arrive, so one file holds them with room left;\n *   - `objects` is 69-78% of every bundle, so it is partitioned again, one\n *     file per CRM domain family \u2014 `customer`, `pipeline`, `commerce`,\n *     `service`, `activity`, `marketing` \u2014 and a DETAIL object follows its\n *     master: line items follow their quote or opportunity,\n *     `crm_event_attendee` follows `crm_event`, `crm_campaign_member`\n *     follows `crm_campaign`, `crm_article_feedback` follows\n *     `crm_knowledge_article`.\n *\n * A namespace axis ALONE was measured and rejected: it leaves `objects` at\n * 65.7KB, 3.9KB under the advisory band, which `objects` growth crosses in\n * about nine days. The family axis puts the largest part at 24.2% of the cap.\n *\n * \u26A0\uFE0F A new object translation belongs in the file for ITS family. Do not add\n * it to whichever file is already open \u2014 that is how one file re-grows past\n * the band, which is what split this bundle in the first place.\n *\n * \u26A0\uFE0F A value used by more than one family lives in `<locale>/_shared.ts`. A\n * value used by exactly one family lives in that family's file.\n *\n * \u26A0\uFE0F The key order below is LOAD-BEARING, not cosmetic. `objectstack build`\n * serialises this object into `dist/objectstack.json` in insertion order and\n * never sorts it, so listing the rows here \u2014 rather than spreading the family\n * files \u2014 is what keeps the built artifact byte-identical across the split.\n * The order is this bundle's own historical accretion order and differs\n * between locales; reordering it rewrites the artifact.\n */\nexport const en: TranslationData = {\n  objects: {\n    crm_account: customer.crm_account,\n    crm_contact: customer.crm_contact,\n    crm_knowledge_article: service.crm_knowledge_article,\n    crm_forecast: pipeline.crm_forecast,\n    crm_lead: pipeline.crm_lead,\n    crm_opportunity: pipeline.crm_opportunity,\n    crm_case: service.crm_case,\n    crm_contract: commerce.crm_contract,\n    crm_product: commerce.crm_product,\n    crm_quote: commerce.crm_quote,\n    crm_task: activity.crm_task,\n    crm_campaign: marketing.crm_campaign,\n    crm_event: activity.crm_event,\n    crm_event_attendee: activity.crm_event_attendee,\n    crm_article_feedback: service.crm_article_feedback,\n    crm_campaign_member: marketing.crm_campaign_member,\n    crm_opportunity_line_item: pipeline.crm_opportunity_line_item,\n    crm_quote_line_item: commerce.crm_quote_line_item,\n  },\n  ...appSurface,\n};\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/sales/translations/zh-CN/app.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/sales/translations/zh-CN\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/sales/translations/zh-CN/app.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport type { TranslationData } from '@objectstack/spec/system';\n\nimport { QUOTE_DISCOUNT_CEILING } from '../../objects/_thresholds';\n\n/**\n * \u7B80\u4F53\u4E2D\u6587 (zh-CN) \u2014 every translation namespace EXCEPT `objects`:\n * `apps`, `messages`, `dashboards`, `datasets`, `pages`, `flows`.\n *\n * SPLIT AXIS (#1311): translation NAMESPACE first, then CRM DOMAIN FAMILY.\n * Everything that is not `objects` lives in `./app.ts`; `objects` \u2014 69-78% of\n * every bundle \u2014 is one file per CRM domain family, and a detail object\n * follows its master. A new row goes in the file for ITS family, never in\n * whichever file is already open: that is how one file re-grows past the 70%\n * advisory band `pnpm hygiene` prints. Full rule and rationale:\n * `src/sales/translations/zh-CN.ts`.\n *\n * A namespace `TranslationData` gains later lands here too, and the room is\n * measured: this file is the smaller half of the bundle, and the schema bounds\n * how many namespaces can ever arrive.\n */\nexport const appSurface: Omit<TranslationData, 'objects'> = {\n  apps: {\n    crm_enterprise: {\n      label: 'HotCRM',\n      description: '\u6DB5\u76D6\u9500\u552E\u3001\u670D\u52A1\u548C\u5E02\u573A\u8425\u9500\u7684\u5BA2\u6237\u5173\u7CFB\u7BA1\u7406\u7CFB\u7EDF',\n      // Keyed by navigation-node `id` (a flat keyspace regardless of depth).\n      navigation: {\n        group_activity: { label: '\u6D3B\u52A8' },\n        nav_event: { label: '\u6D3B\u52A8' },\n        nav_activity_dashboard: { label: '\u9500\u552E\u6D3B\u52A8' },\n        nav_my_calendar: { label: '\u6211\u7684\u65E5\u5386' },\n        nav_home: { label: '\u9996\u9875' },\n\n        group_sales: { label: '\u9500\u552E' },\n        nav_lead: { label: '\u7EBF\u7D22' },\n        nav_account: { label: '\u5BA2\u6237' },\n        nav_account_workbench: { label: '\u5BA2\u6237\u5DE5\u4F5C\u53F0' },\n        nav_contact: { label: '\u8054\u7CFB\u4EBA' },\n        nav_opportunity: { label: '\u5546\u673A' },\n        nav_quote: { label: '\u62A5\u4EF7' },\n        nav_contract: { label: '\u5408\u540C' },\n        nav_product: { label: '\u4EA7\u54C1' },\n        nav_sales_dashboard: { label: '\u9500\u552E\u4E1A\u7EE9' },\n\n        group_work: { label: '\u6211\u7684\u5DE5\u4F5C' },\n        nav_my_tasks: { label: '\u6211\u7684\u4EFB\u52A1' },\n        nav_my_deals: { label: '\u6211\u7684\u5546\u673A' },\n        nav_my_leads: { label: '\u6211\u7684\u7EBF\u7D22' },\n        nav_my_cases: { label: '\u6211\u7684\u5DE5\u5355' },\n        nav_approval_requests: { label: '\u5F85\u6211\u5BA1\u6279' },\n\n        group_marketing: { label: '\u5E02\u573A\u8425\u9500' },\n        nav_campaign: { label: '\u8425\u9500\u6D3B\u52A8' },\n\n        group_service: { label: '\u670D\u52A1' },\n        nav_case: { label: '\u5DE5\u5355' },\n        nav_knowledge: { label: '\u77E5\u8BC6\u5E93' },\n        nav_service_dashboard: { label: '\u670D\u52A1\u6982\u89C8' },\n\n        group_insights: { label: '\u6570\u636E\u6D1E\u5BDF' },\n        nav_crm_dashboard: { label: 'CRM \u603B\u89C8' },\n        nav_forecast: { label: '\u9500\u552E\u9884\u6D4B' },\n        nav_report_pipeline_coverage: { label: '\u7BA1\u9053\u8986\u76D6\u7387' },\n        nav_report_lead_inflow: { label: '\u7EBF\u7D22\u6D41\u5165' },\n        nav_report_sla: { label: 'SLA \u8FBE\u6210' },\n      },\n    },\n  },\n  messages: {\n    'common.save': '\u4FDD\u5B58',\n    'common.cancel': '\u53D6\u6D88',\n    'common.delete': '\u5220\u9664',\n    'common.edit': '\u7F16\u8F91',\n    'common.create': '\u65B0\u5EFA',\n    'common.search': '\u641C\u7D22',\n    'common.filter': '\u7B5B\u9009',\n    'common.export': '\u5BFC\u51FA',\n    'common.back': '\u8FD4\u56DE',\n    'common.confirm': '\u786E\u8BA4',\n    'nav.sales': '\u9500\u552E',\n    'nav.service': '\u670D\u52A1',\n    'nav.marketing': '\u8425\u9500',\n    'nav.products': '\u4EA7\u54C1',\n    'nav.analytics': '\u6570\u636E\u5206\u6790',\n    'success.saved': '\u8BB0\u5F55\u4FDD\u5B58\u6210\u529F',\n    'success.converted': '\u7EBF\u7D22\u8F6C\u5316\u6210\u529F',\n    'confirm.delete': '\u786E\u5B9A\u8981\u5220\u9664\u6B64\u8BB0\u5F55\u5417\uFF1F',\n    'confirm.convert_lead': '\u5C06\u6B64\u7EBF\u7D22\u8F6C\u5316\u4E3A\u5BA2\u6237\u3001\u8054\u7CFB\u4EBA\u548C\u5546\u673A\uFF1F',\n    'error.required': '\u6B64\u5B57\u6BB5\u4E3A\u5FC5\u586B\u9879',\n    'error.load_failed': '\u6570\u636E\u52A0\u8F7D\u5931\u8D25',\n  },\n  dashboards: {\n    sales_activity_dashboard: {\n      label: '\u9500\u552E\u6D3B\u52A8',\n      description: '\u8C01\u5728\u548C\u5BA2\u6237\u6C9F\u901A\u3001\u9891\u7387\u5982\u4F55\uFF0C\u4EE5\u53CA\u54EA\u4E9B\u5BA2\u6237\u5DF2\u7ECF\u6C89\u9ED8',\n      widgets: {\n        interactions_held: { title: '\u5DF2\u8BB0\u5F55\u4E92\u52A8', description: '\u771F\u5B9E\u53D1\u751F\u8FC7\u7684\u901A\u8BDD\u4E0E\u4F1A\u8BAE' },\n        meetings_booked: { title: '\u5DF2\u9884\u7EA6\u4F1A\u8BAE', description: '\u5DF2\u6392\u5165\u65E5\u5386\u4F46\u5C1A\u672A\u4E3E\u884C\u7684\u4F1A\u8BAE' },\n        customer_minutes: { title: '\u5BA2\u6237\u63A5\u89E6\u5206\u949F\u6570', description: '\u9762\u5411\u5BA2\u6237\u7684\u603B\u65F6\u957F' },\n        tasks_completed: { title: '\u5DF2\u5B8C\u6210\u4EFB\u52A1', description: '\u5DF2\u95ED\u73AF\u7684\u8DDF\u8FDB\u4E8B\u9879\u2014\u2014\u6D3B\u52A8\u7684\u53E6\u4E00\u534A' },\n        activity_by_rep: { title: '\u6309\u9500\u552E\u4EE3\u8868\u7EDF\u8BA1\u7684\u6D3B\u52A8', description: '\u6BCF\u4F4D\u8D1F\u8D23\u4EBA\u8BB0\u5F55\u7684\u4E92\u52A8\u6570' },\n        activity_by_week: { title: '\u6BCF\u5468\u6D3B\u52A8\u91CF', description: '\u6BCF\u5468\u4E92\u52A8\u6570' },\n        activity_mix: { title: '\u6D3B\u52A8\u6784\u6210', description: '\u901A\u8BDD\u3001\u4F1A\u8BAE\u4E0E\u6F14\u793A\u7684\u5360\u6BD4' },\n        activity_by_record_type: { title: '\u6D3B\u52A8\u843D\u5728\u54EA\u91CC', description: '\u6F0F\u6597\u7684\u54EA\u4E2A\u73AF\u8282\u83B7\u5F97\u4E86\u5173\u6CE8' },\n        deal_activity: { title: '\u5546\u673A\u4E0A\u7684\u4E92\u52A8', description: '\u5173\u8054\u5230\u5546\u673A\u7684\u5DF2\u8BB0\u5F55\u4E92\u52A8' },\n        open_deals_for_activity: { title: '\u8FDB\u884C\u4E2D\u7684\u5546\u673A', description: '\u4ECD\u5728\u63A8\u8FDB\u7684\u5546\u673A\u6570' },\n        quiet_accounts_30: { title: '\u6C89\u9ED8 30 \u5929\u4EE5\u4E0A', description: '\u4E00\u4E2A\u6708\u5185\u6CA1\u6709\u4EFB\u4F55\u4E92\u52A8\u8BB0\u5F55\u7684\u6D3B\u8DC3\u5BA2\u6237' },\n        quiet_accounts_60: { title: '\u6C89\u9ED8 60 \u5929\u4EE5\u4E0A', description: '\u4E24\u4E2A\u6708\u65E0\u8054\u7CFB\u2014\u2014\u98CE\u9669\u9608\u503C' },\n        quiet_accounts_90: { title: '\u6C89\u9ED8 90 \u5929\u4EE5\u4E0A', description: '\u6574\u6574\u4E00\u4E2A\u5B63\u5EA6\u6CA1\u6709\u8054\u7CFB' },\n      },\n    },\n    crm_overview_dashboard: {\n      label: 'CRM \u603B\u89C8',\n      description: '\u6536\u5165\u6307\u6807\u3001\u7BA1\u9053\u5206\u6790\u4E0E\u5546\u673A\u6D1E\u5BDF',\n      widgets: {\n        total_revenue: { title: '\u603B\u6536\u5165', description: '\u672C\u671F\u5DF2\u6210\u4EA4\u6536\u5165' },\n        active_deals: { title: '\u6D3B\u8DC3\u5546\u673A', description: '\u7BA1\u9053\u4E2D\u8FDB\u884C\u4E2D\u7684\u5546\u673A' },\n        won_deals: { title: '\u8D62\u5355\u6570', description: '\u672C\u671F\u5DF2\u7ED3\u6848\u5546\u673A\u4E2D\u8D62\u5355\u7684\u603B\u6570' },\n        avg_deal_size: { title: '\u5E73\u5747\u8BA2\u5355\u91D1\u989D', description: '\u5DF2\u6210\u4EA4\u5546\u673A\u7684\u5E73\u5747\u91D1\u989D' },\n        revenue_trends: { title: '\u6536\u5165\u8D8B\u52BF', description: '\u8FC7\u53BB 12 \u4E2A\u6708\u7684\u5DF2\u6210\u4EA4\u6536\u5165' },\n        lead_source: { title: '\u7EBF\u7D22\u6765\u6E90', description: '\u6309\u83B7\u5BA2\u6E20\u9053\u7EDF\u8BA1\u7684\u7BA1\u9053\u91D1\u989D' },\n        pipeline_by_stage: { title: '\u9636\u6BB5\u7BA1\u9053\u5206\u5E03', description: '\u6309\u9636\u6BB5\u7EDF\u8BA1\u7684\u8FDB\u884C\u4E2D\u5546\u673A\u91D1\u989D' },\n        top_products: { title: '\u70ED\u95E8\u4EA7\u54C1', description: '\u6309\u4EA7\u54C1\u7C7B\u522B\u7EDF\u8BA1\u7684\u76EE\u5F55\u4EF7\u6536\u5165' },\n        pipeline_by_owner: { title: '\u6309\u8D1F\u8D23\u4EBA\u7EDF\u8BA1\u7BA1\u9053', description: '\u5404\u9500\u552E\u8D1F\u8D23\u4EBA\u7684\u8FDB\u884C\u4E2D\u7BA1\u9053\u91D1\u989D\u4E0E\u5546\u673A\u6570' },\n      },\n    },\n    executive_dashboard: {\n      label: '\u9AD8\u7BA1\u603B\u89C8',\n      description: '\u9762\u5411\u7BA1\u7406\u5C42\u7684\u6536\u5165\u3001\u5BA2\u6237\u4E0E\u7BA1\u9053\u9AD8\u9636\u6307\u6807',\n      widgets: {\n        total_revenue_ytd: { title: '\u5E74\u5EA6\u7D2F\u8BA1\u6536\u5165', description: '\u672C\u5E74\u5EA6\u5DF2\u6210\u4EA4\u6536\u5165' },\n        total_accounts: { title: '\u6D3B\u8DC3\u5BA2\u6237', description: '\u81F3\u5C11\u5B58\u5728\u4E00\u9879\u6D3B\u8DC3\u5173\u7CFB\u7684\u5BA2\u6237' },\n        total_contacts: { title: '\u8054\u7CFB\u4EBA\u603B\u6570', description: '\u901A\u8BAF\u5F55\u4E2D\u7684\u8054\u7CFB\u4EBA' },\n        open_leads: { title: '\u672A\u8F6C\u5316\u7EBF\u7D22', description: '\u6F0F\u6597\u4E2D\u5C1A\u672A\u8F6C\u5316\u7684\u7EBF\u7D22' },\n        revenue_trend: { title: '\u6536\u5165\u8D8B\u52BF', description: '\u8FC7\u53BB 12 \u4E2A\u6708\u7684\u5DF2\u6210\u4EA4\u6536\u5165' },\n        revenue_by_industry: { title: '\u884C\u4E1A\u6536\u5165\u5206\u5E03', description: '\u672C\u5E74\u5EA6\u5DF2\u6210\u4EA4\u6536\u5165\u6309\u5BA2\u6237\u884C\u4E1A\u62C6\u5206' },\n        pipeline_by_stage: { title: '\u9636\u6BB5\u7BA1\u9053\u5206\u5E03', description: '\u6309\u9636\u6BB5\u7EDF\u8BA1\u7684\u8FDB\u884C\u4E2D\u5546\u673A\u91D1\u989D' },\n        new_accounts_by_month: { title: '\u65B0\u589E\u5BA2\u6237', description: '\u8FC7\u53BB 6 \u4E2A\u6708\u7684\u5BA2\u6237\u521B\u5EFA\u8282\u594F' },\n        accounts_by_industry: { title: '\u6309\u884C\u4E1A\u7EDF\u8BA1\u5BA2\u6237', description: '\u5404\u884C\u4E1A\u7684\u5E74\u8425\u6536\u603B\u989D\u4E0E\u5BA2\u6237\u6570' },\n      },\n    },\n    sales_dashboard: {\n      label: '\u9500\u552E\u4E1A\u7EE9',\n      description: '\u7BA1\u9053\u5206\u6790\u3001\u8D62\u7387\u8D8B\u52BF\u53CA\u9500\u552E\u4EE3\u8868\u7EE9\u6548',\n      widgets: {\n        total_pipeline_value: { title: '\u7BA1\u9053\u603B\u989D', description: '\u6240\u6709\u8FDB\u884C\u4E2D\u5546\u673A\u91D1\u989D\u5408\u8BA1' },\n        closed_won_qtd: { title: '\u672C\u5B63\u5EA6\u5DF2\u6210\u4EA4', description: '\u672C\u5B63\u5EA6\u5DF2\u8D62\u5F97\u7684\u6536\u5165' },\n        open_opportunities: { title: '\u8FDB\u884C\u4E2D\u5546\u673A', description: '\u6B63\u5728\u63A8\u8FDB\u7684\u6D3B\u8DC3\u5546\u673A' },\n        avg_deal_size: { title: '\u5E73\u5747\u8BA2\u5355\u91D1\u989D', description: '\u672C\u5B63\u5EA6\u5DF2\u6210\u4EA4\u5546\u673A\u7684\u5E73\u5747\u91D1\u989D' },\n        pipeline_by_stage: { title: '\u9636\u6BB5\u7BA1\u9053\u5206\u5E03', description: '\u6309\u9636\u6BB5\u7EDF\u8BA1\u7684\u8FDB\u884C\u4E2D\u5546\u673A\u91D1\u989D' },\n        monthly_revenue_trend: { title: '\u6708\u5EA6\u6536\u5165\u8D8B\u52BF', description: '\u8FC7\u53BB 12 \u4E2A\u6708\u7684\u5DF2\u6210\u4EA4\u6536\u5165' },\n        pipeline_by_forecast_category: { title: '\u9884\u6D4B\u7C7B\u522B\u7BA1\u9053\u5206\u5E03', description: '\u6309\u9884\u6D4B\u7C7B\u522B\u7EDF\u8BA1\u7684\u8FDB\u884C\u4E2D\u7BA1\u9053\u91D1\u989D' },\n        lead_source_breakdown: { title: '\u7EBF\u7D22\u6765\u6E90\u5206\u5E03', description: '\u6309\u6765\u6E90\u7EDF\u8BA1\u7684\u7EBF\u7D22\u6570\u91CF' },\n        open_pipeline_by_owner: { title: '\u6309\u8D1F\u8D23\u4EBA\u7EDF\u8BA1\u8FDB\u884C\u4E2D\u7BA1\u9053', description: '\u5404\u9500\u552E\u8D1F\u8D23\u4EBA\u7684\u8FDB\u884C\u4E2D\u7BA1\u9053\u91D1\u989D\u3001\u5546\u673A\u6570\u4E0E\u5E73\u5747\u8D62\u5355\u6982\u7387' },\n        quota_attainment_by_rep: { title: '\u6309\u9500\u552E\u4EE3\u8868\u7EDF\u8BA1\u914D\u989D\u8FBE\u6210', description: '\u6765\u81EA\u9884\u6D4B\u5FEB\u7167\u7684\u5404\u9500\u552E\u4EE3\u8868\u672C\u5B63\u5EA6\u914D\u989D\u3001\u5DF2\u6210\u4EA4\u6536\u5165\u4E0E\u8FBE\u6210\u7387' },\n        pipeline_stage_by_source: { title: '\u9636\u6BB5 \u00D7 \u7EBF\u7D22\u6765\u6E90', description: '\u6309\u9636\u6BB5\u548C\u6765\u6E90\u4EA4\u53C9\u7EDF\u8BA1\u8FDB\u884C\u4E2D\u5546\u673A\u91D1\u989D' },\n        win_rate_12m: { title: '\u8D62\u7387\uFF08\u8FD1 12 \u4E2A\u6708\uFF09', description: '\u8FD1 12 \u4E2A\u6708\u5DF2\u7ED3\u5355\u5546\u673A\u4E2D\u8D62\u5355\u6240\u5360\u7684\u6BD4\u4F8B' },\n        won_deals_12m: { title: '\u8D62\u5355\u6570\uFF08\u8FD1 12 \u4E2A\u6708\uFF09', description: '\u8D62\u7387\u7684\u5206\u5B50' },\n        lost_deals_12m: { title: '\u4E22\u5355\u6570\uFF08\u8FD1 12 \u4E2A\u6708\uFF09', description: '\u8D62\u7387\u5206\u6BCD\u7684\u53E6\u4E00\u534A' },\n        win_rate_by_owner: { title: '\u6309\u9500\u552E\u4EE3\u8868\u7EDF\u8BA1\u8D62/\u4E22\u5355', description: '\u8FD1 12 \u4E2A\u6708\u5404\u9500\u552E\u4EE3\u8868\u7684\u8D62\u5355\u6570\u3001\u4E22\u5355\u6570\u4E0E\u8D62\u7387' },\n        win_rate_by_lead_source: { title: '\u6309\u7EBF\u7D22\u6765\u6E90\u7EDF\u8BA1\u8D62/\u4E22\u5355', description: '\u8FD1 12 \u4E2A\u6708\u54EA\u4E9B\u6765\u6E90\u5E26\u6765\u7684\u5546\u673A\u771F\u6B63\u6210\u4EA4' },\n        loss_reason_breakdown: { title: '\u4E22\u5355\u539F\u56E0\u5206\u6790', description: '\u8FD1 12 \u4E2A\u6708\u4E22\u5355\u6309\u539F\u56E0\u5206\u5E03' },\n      },\n    },\n    service_dashboard: {\n      label: '\u5BA2\u6237\u670D\u52A1',\n      description: '\u5DE5\u5355\u8D1F\u8F7D\u3001SLA \u5065\u5EB7\u5EA6\u4E0E\u5904\u7406\u7EE9\u6548',\n      widgets: {\n        open_cases: { title: '\u672A\u5173\u95ED\u5DE5\u5355', description: '\u5C1A\u672A\u5173\u95ED\u7684\u5DE5\u5355' },\n        critical_cases: { title: '\u4E25\u91CD\u5DE5\u5355', description: '\u6807\u8BB0\u4E3A\u4E25\u91CD\u4F18\u5148\u7EA7\u7684\u672A\u5173\u95ED\u5DE5\u5355' },\n        avg_resolution_time: { title: '\u5E73\u5747\u89E3\u51B3\u65F6\u957F', description: '\u5173\u95ED\u5DE5\u5355\u7684\u5E73\u5747\u5904\u7406\u65F6\u957F\uFF08\u5C0F\u65F6\uFF09' },\n        sla_violations: { title: 'SLA \u8FDD\u7EA6', description: '\u5DF2\u8D85\u51FA SLA \u7684\u5DE5\u5355' },\n        cases_by_status: { title: '\u6309\u72B6\u6001\u5206\u5E03', description: '\u5DE5\u5355\u5728\u5404\u5904\u7406\u9636\u6BB5\u7684\u5206\u5E03' },\n        cases_by_priority: { title: '\u6309\u4F18\u5148\u7EA7\u5206\u5E03', description: '\u672A\u5173\u95ED\u5DE5\u5355\u6309\u7D27\u6025\u7A0B\u5EA6\u7684\u5206\u5E03' },\n        cases_by_origin: { title: '\u6309\u6765\u6E90\u5206\u5E03', description: '\u5DE5\u5355\u7684\u6765\u6E90\u6E20\u9053' },\n        daily_case_volume: { title: '\u6BCF\u65E5\u5DE5\u5355\u91CF', description: '\u8FC7\u53BB 30 \u5929\u7684\u65B0\u5EFA\u5DE5\u5355' },\n        sla_compliance_gauge: { title: 'SLA \u8FBE\u6210\u7387', description: '\u672C\u671F SLA \u5185\u89E3\u51B3\u5DE5\u5355\u7684\u5360\u6BD4' },\n        kb_deflection_rate: { title: '\u77E5\u8BC6\u5E93\u8F6C\u79FB\u7387', description: '\u5DF2\u5173\u95ED\u5DE5\u5355\u4E2D\u7531\u77E5\u8BC6\u6587\u7AE0\u89E3\u51B3\u7684\u5360\u6BD4' },\n        kb_resolved_cases: { title: '\u77E5\u8BC6\u5E93\u89E3\u51B3\u6570', description: '\u5DF2\u5173\u8054\u89E3\u51B3\u6587\u7AE0\u7684\u5DF2\u5173\u95ED\u5DE5\u5355' },\n        closed_cases_total: { title: '\u5DF2\u5173\u95ED\u5DE5\u5355', description: '\u8F6C\u79FB\u7387\u7684\u5206\u6BCD' },\n        top_resolving_articles: { title: '\u89E3\u51B3\u5DE5\u5355\u6700\u591A\u7684\u6587\u7AE0', description: '\u6309\u89E3\u51B3\u7684\u5DF2\u5173\u95ED\u5DE5\u5355\u6570\u6392\u540D\u7684\u77E5\u8BC6\u6587\u7AE0' },\n        my_open_cases_by_priority: { title: '\u6211\u7684\u672A\u5173\u95ED\u5DE5\u5355\uFF08\u6309\u4F18\u5148\u7EA7\uFF09', description: '\u4F60\u7684\u672A\u5173\u95ED\u5DE5\u5355\u53CA\u5176 SLA \u8FDD\u7EA6\u7387\uFF0C\u6309\u4F18\u5148\u7EA7\u7EC6\u5206' },\n      },\n    },\n  },\n  // `title` / `subtitle` translate the page's `page:header`; `title` falls back\n  // to `label` when omitted, so it is authored only where the two differ.\n  // Header strings carrying `{field}` tokens keep the token spelling verbatim \u2014\n  // the console substitutes on the raw key, so a translated token resolves to\n  // nothing and the header renders blank.\n  datasets: {\n    account_metrics: {\n      label: '\u5BA2\u6237\u6307\u6807',\n      description: '\u6309\u884C\u4E1A\u4E0E\u7C7B\u578B\u7EDF\u8BA1\u5BA2\u6237\u6570\u91CF\u7684\u8BED\u4E49\u5C42',\n      dimensions: {\n        industry: {\n          label: '\u884C\u4E1A',\n        },\n        type: {\n          label: '\u7C7B\u578B',\n        },\n        created_at: {\n          label: '\u521B\u5EFA\u65F6\u95F4',\n        },\n      },\n      measures: {\n        account_count: {\n          label: '\u5BA2\u6237\u6570',\n        },\n        annual_revenue_sum: {\n          label: '\u5E74\u8425\u6536',\n        },\n      },\n    },\n    case_metrics: {\n      label: '\u5DE5\u5355\u6307\u6807',\n      description: '\u7EDF\u8BA1\u5DE5\u5355\u6570\u91CF\u3001\u89E3\u51B3\u65F6\u957F\u4E0E SLA \u7684\u8BED\u4E49\u5C42',\n      dimensions: {\n        created_at: {\n          label: '\u521B\u5EFA\u65F6\u95F4',\n        },\n        origin: {\n          label: '\u6765\u6E90',\n        },\n        priority: {\n          label: '\u4F18\u5148\u7EA7',\n        },\n        resolved_article: {\n          label: '\u89E3\u51B3\u7528\u77E5\u8BC6\u6587\u7AE0',\n        },\n        status: {\n          label: '\u72B6\u6001',\n        },\n        type: {\n          label: '\u7C7B\u578B',\n        },\n      },\n      measures: {\n        avg_resolution: {\n          label: '\u5E73\u5747\u89E3\u51B3\u65F6\u957F\uFF08\u5C0F\u65F6\uFF09',\n        },\n        avg_sla_violated: {\n          label: 'SLA \u8FDD\u7EA6\u7387',\n        },\n        case_count: {\n          label: '\u5DE5\u5355\u6570',\n        },\n        closed_count: {\n          label: '\u5DF2\u5173\u95ED\u5DE5\u5355',\n        },\n        kb_deflection_rate: {\n          label: '\u77E5\u8BC6\u5E93\u81EA\u52A9\u89E3\u51B3\u7387',\n        },\n        kb_resolved_count: {\n          label: '\u77E5\u8BC6\u5E93\u89E3\u51B3\u6570',\n        },\n        sla_compliance_rate: {\n          label: 'SLA \u8FBE\u6807\u7387',\n        },\n        sla_met_count: {\n          label: 'SLA \u8FBE\u6807\u5DE5\u5355',\n        },\n      },\n    },\n    contact_metrics: {\n      label: '\u8054\u7CFB\u4EBA\u6307\u6807',\n      description: '\u7EDF\u8BA1\u8054\u7CFB\u4EBA\u6570\u91CF\u7684\u8BED\u4E49\u5C42',\n      measures: {\n        contact_count: {\n          label: '\u8054\u7CFB\u4EBA\u6570',\n        },\n      },\n    },\n    event_metrics: {\n      label: '\u6D3B\u52A8\u6307\u6807',\n      description: '\u7EDF\u8BA1\u4F1A\u8BAE\u3001\u901A\u8BDD\u4E0E\u4E92\u52A8\u65B0\u8FD1\u5EA6\u7684\u8BED\u4E49\u5C42',\n      dimensions: {\n        owner: {\n          label: '\u8D1F\u8D23\u4EBA',\n        },\n        related_to_type: {\n          label: '\u5173\u8054\u5BF9\u8C61',\n        },\n        start_datetime: {\n          label: '\u6D3B\u52A8\u5468',\n        },\n        status: {\n          label: '\u72B6\u6001',\n        },\n        type: {\n          label: '\u6D3B\u52A8\u7C7B\u578B',\n        },\n      },\n      measures: {\n        avg_minutes: {\n          label: '\u5E73\u5747\u65F6\u957F',\n        },\n        event_count: {\n          label: '\u6D3B\u52A8\u6570',\n        },\n        total_minutes: {\n          label: '\u603B\u5206\u949F\u6570',\n        },\n      },\n    },\n    forecast_metrics: {\n      label: '\u9500\u552E\u9884\u6D4B\u6307\u6807',\n      description: '\u6309\u8D1F\u8D23\u4EBA\u7EDF\u8BA1\u914D\u989D\u3001\u8FBE\u6210\u7387\u4E0E\u7BA1\u9053\u8986\u76D6\u500D\u6570\u7684\u8BED\u4E49\u5C42',\n      dimensions: {\n        owner: {\n          label: '\u8D1F\u8D23\u4EBA',\n        },\n        period: {\n          label: '\u5468\u671F\u7C7B\u578B',\n        },\n        period_label: {\n          label: '\u5468\u671F',\n        },\n        period_start: {\n          label: '\u5468\u671F\u5F00\u59CB',\n        },\n      },\n      measures: {\n        attainment: {\n          label: '\u8FBE\u6210\u7387',\n        },\n        closed_sum: {\n          label: '\u5DF2\u6210\u4EA4',\n        },\n        commit_sum: {\n          label: '\u627F\u8BFA',\n        },\n        pipeline_sum: {\n          label: '\u9500\u552E\u7BA1\u9053',\n        },\n        quota_sum: {\n          label: '\u914D\u989D',\n        },\n      },\n    },\n    lead_metrics: {\n      label: '\u7EBF\u7D22\u6307\u6807',\n      description: '\u7EDF\u8BA1\u7EBF\u7D22\u6570\u91CF\u7684\u8BED\u4E49\u5C42',\n      dimensions: {\n        created_at: {\n          label: '\u521B\u5EFA\u65F6\u95F4',\n        },\n        last_contacted_date: {\n          label: '\u6700\u8FD1\u8054\u7CFB',\n        },\n        lead_source: {\n          label: '\u6765\u6E90',\n        },\n        status: {\n          label: '\u72B6\u6001',\n        },\n      },\n      measures: {\n        lead_count: {\n          label: '\u7EBF\u7D22\u6570',\n        },\n      },\n    },\n    opportunity_metrics: {\n      label: '\u5546\u673A\u6307\u6807',\n      description: '\u7EDF\u8BA1\u9500\u552E\u7BA1\u9053\u6570\u91CF\u4E0E\u91D1\u989D\u7684\u8BED\u4E49\u5C42',\n      dimensions: {\n        account_industry: {\n          label: '\u5BA2\u6237\u884C\u4E1A',\n        },\n        close_date: {\n          label: '\u9884\u8BA1\u6210\u4EA4\u65E5',\n        },\n        close_quarter: {\n          label: '\u6210\u4EA4\u5B63\u5EA6',\n        },\n        forecast_category: {\n          label: '\u9884\u6D4B\u7C7B\u522B',\n        },\n        lead_source: {\n          label: '\u7EBF\u7D22\u6765\u6E90',\n        },\n        loss_reason: {\n          label: '\u5931\u5355\u539F\u56E0',\n        },\n        owner: {\n          label: '\u8D1F\u8D23\u4EBA',\n        },\n        stage: {\n          label: '\u9636\u6BB5',\n        },\n        type: {\n          label: '\u5546\u673A\u7C7B\u578B',\n        },\n        win_reason: {\n          label: '\u8D62\u5355\u539F\u56E0',\n        },\n      },\n      measures: {\n        avg_amount: {\n          label: '\u5E73\u5747\u5355\u7B14\u91D1\u989D',\n        },\n        avg_probability: {\n          label: '\u5E73\u5747\u8D62\u5355\u6982\u7387',\n        },\n        decided_count: {\n          label: '\u5DF2\u5B9A\u5C40\u5546\u673A',\n        },\n        lost_amount: {\n          label: '\u5931\u5355\u91D1\u989D',\n        },\n        lost_count: {\n          label: '\u5931\u5355\u6570',\n        },\n        opp_count: {\n          label: '\u5546\u673A\u6570',\n        },\n        total_amount: {\n          label: '\u603B\u91D1\u989D',\n        },\n        win_rate: {\n          label: '\u8D62\u5355\u7387',\n        },\n        won_amount: {\n          label: '\u8D62\u5355\u91D1\u989D',\n        },\n        won_count: {\n          label: '\u8D62\u5355\u6570',\n        },\n      },\n    },\n    product_metrics: {\n      label: '\u4EA7\u54C1\u6307\u6807',\n      description: '\u7EDF\u8BA1\u4EA7\u54C1\u76EE\u5F55\u6570\u91CF\u4E0E\u6807\u4EF7\u7684\u8BED\u4E49\u5C42',\n      dimensions: {\n        category: {\n          label: '\u7C7B\u522B',\n        },\n      },\n      measures: {\n        list_price_sum: {\n          label: '\u6807\u4EF7\u5408\u8BA1',\n        },\n        product_count: {\n          label: '\u4EA7\u54C1\u6570',\n        },\n      },\n    },\n    task_metrics: {\n      label: '\u4EFB\u52A1\u6307\u6807',\n      description: '\u7EDF\u8BA1\u4EFB\u52A1\u5DE5\u4F5C\u91CF\u4E0E\u5B8C\u6210\u60C5\u51B5\u7684\u8BED\u4E49\u5C42',\n      dimensions: {\n        due_date: {\n          label: '\u622A\u6B62\u65E5\u671F',\n        },\n        is_completed: {\n          label: '\u5DF2\u5B8C\u6210',\n        },\n        is_overdue: {\n          label: '\u5DF2\u903E\u671F',\n        },\n        priority: {\n          label: '\u4F18\u5148\u7EA7',\n        },\n        priority_rank: {\n          label: '\u7D27\u6025\u5EA6',\n        },\n        status: {\n          label: '\u72B6\u6001',\n        },\n        type: {\n          label: '\u7C7B\u578B',\n        },\n      },\n      measures: {\n        avg_progress: {\n          label: '\u5E73\u5747\u8FDB\u5EA6',\n        },\n        task_count: {\n          label: '\u4EFB\u52A1\u6570',\n        },\n      },\n    },\n  },\n  pages: {\n    account_detail_page: {\n      label: '\u5BA2\u6237\u8BE6\u60C5',\n      description: '\u63D2\u69FD\u5F0F\u5BA2\u6237\u8BB0\u5F55\u9875\u2014\u2014\u81EA\u5B9A\u4E49\u9875\u5934 + \u5E38\u9A7B\u8BA8\u8BBA\u533A\u3002',\n      title: '{name}',\n      subtitle: '{industry} \u00B7 {type}',\n      components: {\n        account_chatter: { label: '\u8BA8\u8BBA' },\n      },\n    },\n    account_workbench: {\n      label: '\u5BA2\u6237\u5DE5\u4F5C\u53F0',\n      description: '\u9762\u5411\u9500\u552E\u56E2\u961F\u7684\u7CBE\u9009\u5BA2\u6237\u5217\u8868\uFF1A\u4EC5\u63D0\u4F9B\u5FEB\u6377\u7B5B\u9009\uFF0C\u4E0D\u542B\u89C6\u56FE\u7BA1\u7406\u3002',\n    },\n    app_launcher_page: {\n      label: '\u5E94\u7528\u4E2D\u5FC3',\n      description: '\u8BBF\u95EE\u5168\u90E8\u5E94\u7528\u7684\u7EDF\u4E00\u5165\u53E3',\n      subtitle: '\u9009\u62E9\u4E00\u4E2A\u5E94\u7528\u5F00\u59CB\u4F7F\u7528',\n      components: {\n        app_search: { label: '\u641C\u7D22\u5E94\u7528' },\n        app_grid: { label: '\u5E94\u7528\u7F51\u683C' },\n      },\n    },\n    case_detail_page: {\n      label: '\u5DE5\u5355\u8BE6\u60C5',\n      description: '\u5BA2\u670D\u5DE5\u5355\u8BB0\u5F55\u9875\uFF1A\u5173\u952E\u4FE1\u606F\u3001SLA \u8FDB\u5EA6\u3001\u660E\u7EC6\u4E0E\u6D3B\u52A8\u65F6\u95F4\u7EBF\u3002',\n      title: '{case_number} \u00B7 {subject}',\n      subtitle: '{crm_account}',\n      components: {\n        case_highlights: { label: '\u5173\u952E\u4FE1\u606F' },\n        case_status_path: { label: '\u5DE5\u5355\u72B6\u6001\u8FDB\u5EA6' },\n        case_details: { label: '\u5DE5\u5355\u660E\u7EC6' },\n      },\n    },\n    lead_detail_page: {\n      label: '\u7EBF\u7D22\u8BE6\u60C5',\n      description: '\u5B8C\u6574\u7684\u7EBF\u7D22\u8BE6\u60C5\u9875\uFF0C\u5305\u542B\u5173\u952E\u4FE1\u606F\u3001\u660E\u7EC6\u4E0E\u76F8\u5173\u8BB0\u5F55\u3002',\n      title: '{first_name} {last_name}',\n      subtitle: '{company}',\n      components: {\n        lead_duplicate_alert_confirmed: { label: '\u5DF2\u786E\u8BA4\u91CD\u590D\u63D0\u9192' },\n        lead_duplicate_alert_suspected: { label: '\u7591\u4F3C\u91CD\u590D\u63D0\u9192' },\n        lead_highlights: { label: '\u5173\u952E\u4FE1\u606F' },\n        lead_path: { label: '\u7EBF\u7D22\u72B6\u6001\u8FDB\u5EA6' },\n        main_tabs: { label: '\u7EBF\u7D22\u4FE1\u606F\u6807\u7B7E\u9875' },\n        lead_details: { label: '\u7EBF\u7D22\u660E\u7EC6' },\n        related_accordion: { label: '\u76F8\u5173\u8BB0\u5F55' },\n        related_tasks: { title: '\u5F85\u529E\u4EFB\u52A1', label: '\u4EFB\u52A1' },\n        lead_activity: { label: '\u6D3B\u52A8\u65F6\u95F4\u7EBF' },\n        lead_history: { label: '\u5B57\u6BB5\u5386\u53F2' },\n      },\n    },\n    opportunity_detail_page: {\n      label: '\u5546\u673A\u8BE6\u60C5',\n      description: '\u5B8C\u6574\u7684\u5546\u673A\u8BE6\u60C5\u9875\uFF0C\u5305\u542B\u9636\u6BB5\u8FDB\u5EA6\u3001\u5173\u952E\u4FE1\u606F\u3001\u660E\u7EC6\u4E0E\u76F8\u5173\u5217\u8868\u3002',\n      title: '{name}',\n      subtitle: '{crm_account}',\n      components: {\n        opp_highlights: { label: '\u5173\u952E\u4FE1\u606F' },\n        opp_stage_path: { label: '\u5546\u673A\u9636\u6BB5\u8FDB\u5EA6' },\n        opp_details: { label: '\u5546\u673A\u660E\u7EC6' },\n      },\n    },\n    sales_home_page: {\n      label: '\u9500\u552E\u4E3B\u9875',\n      description: '\u9500\u552E\u56E2\u961F\u4E3B\u9875\uFF0C\u6C47\u603B\u5173\u952E\u6307\u6807\u4E0E\u5FEB\u6377\u64CD\u4F5C',\n      title: '\u9500\u552E\u770B\u677F',\n      subtitle: '\u6B22\u8FCE\u56DE\u6765',\n      components: {\n        kpi_revenue_won: {\n          label: '\u8D62\u5355\u8425\u6536',\n        },\n        kpi_deals_won: {\n          label: '\u8D62\u5355\u6570',\n        },\n        kpi_pipeline_value: {\n          label: '\u9500\u552E\u7BA1\u9053\u91D1\u989D',\n        },\n        kpi_open_leads: {\n          label: '\u5F00\u653E\u7EBF\u7D22',\n        },\n        home_upcoming_events: {\n          label: '\uD83D\uDCC5 \u5373\u5C06\u5F00\u59CB \u00B7 \u6700\u8FD1\u4F18\u5148',\n        },\n        quick_create: { title: '\u5FEB\u901F\u521B\u5EFA', label: '\u5FEB\u901F\u521B\u5EFA' },\n        key_metrics: { title: '\u5173\u952E\u7EE9\u6548\u6307\u6807', label: '\u5173\u952E\u6307\u6807' },\n        home_tabs: { label: '\u4E3B\u9875\u6807\u7B7E\u9875' },\n        home_my_leads: { label: '\u6211\u7684\u7EBF\u7D22' },\n        home_my_deals: { label: '\u6211\u7684\u8FDB\u884C\u4E2D\u5546\u673A' },\n        home_my_tasks: { label: '\u6211\u7684\u5F85\u529E\u4EFB\u52A1' },\n        ai_briefing: {\n          title: '\u8BE2\u95EE AI \u52A9\u624B',\n          label: 'AI \u52A9\u624B\u4ECA\u65E5\u901F\u89C8',\n        },\n        upcoming_events: { title: '\u5373\u5C06\u5F00\u59CB\u7684\u6D3B\u52A8', label: '\u5373\u5C06\u5F00\u59CB\u7684\u6D3B\u52A8' },\n      },\n    },\n    utility_bar_page: {\n      label: '\u5DE5\u5177\u680F',\n      description: '\u60AC\u6D6E\u5DE5\u5177\u7684\u5FEB\u6377\u8BBF\u95EE\u680F',\n      components: {\n        notifications_panel: { label: '\u901A\u77E5' },\n        quick_notes: { title: '\u5FEB\u901F\u7B14\u8BB0', label: '\u5FEB\u901F\u7B14\u8BB0' },\n        quick_search: { label: '\u5FEB\u901F\u641C\u7D22' },\n      },\n    },\n  },\n  // Screen-flow copy (#1210, #1975). Keyed `flows.<flow>.label`,\n  // `screens.<node>.title` and `screens.<node>.fields.<field>.{label,placeholder}`\n  // \u2014 the keys `os lint`'s `i18n/missing-flow` names, read by the console's\n  // flow runner since @objectstack 17.7.0 (the spec's `flows` liveness row is\n  // `live` there). A screen with no authored `title` shows its flow's label in\n  // every locale, so each `screen_1.title` repeats the flow label. Since\n  // 18.0.0-next.0 three more surfaces are keys the engine reads in the run's\n  // locale, and `i18n/missing-flow` names each missing one: a select field's\n  // `options.<value>` (worded as the object field's own option in this pack),\n  // an authored screen `description`, and a refusing `end` node's\n  // `refusals.<node>.message`. A translated description or message is a text\n  // slot like the one it translates, so a hole in it is `{{ }}`.\n  // The discount ceiling is interpolated from `QUOTE_DISCOUNT_CEILING`, never\n  // retyped: the number lives in `_thresholds.ts` alone (#1711).\n  flows: {\n    campaign_enrollment: {\n      label: '\u5C06\u6210\u5458\u52A0\u5165\u8425\u9500\u6D3B\u52A8',\n      screens: {\n        screen_1: {\n          title: '\u5C06\u6210\u5458\u52A0\u5165\u8425\u9500\u6D3B\u52A8',\n          fields: {\n            memberSource: { label: '\u52A0\u5165\u7684\u6210\u5458\u7C7B\u578B', options: { leads: '\u7EBF\u7D22', contacts: '\u8054\u7CFB\u4EBA' } },\n            leadStatus: { label: '\u52A0\u5165\u4EE5\u4E0B\u72B6\u6001\u7684\u7EBF\u7D22', options: { new: '\u65B0\u5EFA', contacted: '\u5DF2\u8054\u7CFB', qualified: '\u5DF2\u786E\u8BA4' } },\n            contactDepartment: {\n              label: '\u52A0\u5165\u4EE5\u4E0B\u90E8\u95E8\u7684\u8054\u7CFB\u4EBA',\n              options: { executive: '\u7BA1\u7406\u5C42', sales: '\u9500\u552E\u90E8', marketing: '\u5E02\u573A\u90E8', engineering: '\u5DE5\u7A0B\u90E8', support: '\u652F\u6301\u90E8', finance: '\u8D22\u52A1\u90E8', hr: '\u4EBA\u529B\u8D44\u6E90', operations: '\u8FD0\u8425\u90E8' },\n            },\n          },\n        },\n      },\n    },\n    escalate_case: {\n      label: '\u5347\u7EA7\u5DE5\u5355',\n      screens: { screen_1: { title: '\u5347\u7EA7\u5DE5\u5355', fields: { reason: { label: '\u5347\u7EA7\u539F\u56E0' } } } },\n    },\n    close_case: {\n      label: '\u5173\u95ED\u5DE5\u5355',\n      screens: {\n        screen_1: {\n          title: '\u5173\u95ED\u5DE5\u5355',\n          fields: {\n            resolution: { label: '\u89E3\u51B3\u65B9\u6848' },\n            resolved_by_article: { label: '\u901A\u8FC7\u77E5\u8BC6\u6587\u7AE0\u89E3\u51B3\uFF08\u53EF\u9009\uFF09' },\n          },\n        },\n      },\n    },\n    claim_case: {\n      label: '\u8BA4\u9886\u5DE5\u5355',\n      screens: {\n        screen_1: {\n          title: '\u8BA4\u9886\u5DE5\u5355',\n          fields: {\n            claimStatus: {\n              label: '\u5904\u7406\u72B6\u6001',\n              options: { in_progress: '\u5904\u7406\u4E2D', waiting_customer: '\u7B49\u5F85\u5BA2\u6237\u56DE\u590D', waiting_support: '\u7B49\u5F85\u652F\u6301\u56DE\u590D' },\n            },\n          },\n        },\n      },\n    },\n    lead_conversion: {\n      label: '\u7EBF\u7D22\u8F6C\u5316\u6D41\u7A0B',\n      screens: {\n        screen_1: {\n          title: '\u7EBF\u7D22\u8F6C\u5316\u6D41\u7A0B',\n          // The duplicate warning's text is a variable the flow assigns; this\n          // key can only carry the hole that shows it.\n          description: '{{duplicateWarning}}',\n          fields: {\n            createOpportunity: { label: '\u662F\u5426\u521B\u5EFA\u5546\u673A\uFF1F' },\n            opportunityName: { label: '\u5546\u673A\u540D\u79F0' },\n            opportunityAmount: { label: '\u5546\u673A\u91D1\u989D' },\n            closeDate: { label: '\u9884\u8BA1\u6210\u4EA4\u65E5\u671F' },\n          },\n        },\n        refuse_confirmed_duplicate: {\n          title: '\u8F6C\u5316\u88AB\u62D2\u7EDD',\n          description:\n            '\u8BE5\u7EBF\u7D22\u7684\u300C\u91CD\u590D\u72B6\u6001\u300D\u4E3A\u300C\u5DF2\u786E\u8BA4\u91CD\u590D\u300D\uFF1A\u5BA1\u6838\u4EBA\u5DF2\u5C06\u5176\u4E0E\u73B0\u6709\u8BB0\u5F55\u6BD4\u5BF9\uFF0C\u5E76\u8BB0\u5F55\u4E3A\u91CD\u590D\u3002\u8F6C\u5316\u4F1A\u4E3A\u540C\u4E00\u4E70\u5BB6\u518D\u521B\u5EFA\u4E00\u4E2A\u5BA2\u6237\u3001\u8054\u7CFB\u4EBA\u548C\u5546\u673A\u3002\u672C\u7EBF\u7D22\u7684\u300C\u91CD\u590D\u7EBF\u7D22\u7BA1\u7406\u300D\u90E8\u5206\u5217\u51FA\u4E86\u4FDD\u7559\u7684\u8BB0\u5F55\uFF1B\u8BF7\u6539\u4E3A\u4EE5\u91CD\u590D\u4E3A\u7531\u5C06\u6B64\u7EBF\u7D22\u8BBE\u4E3A\u300C\u672A\u901A\u8FC7\u300D\u3002\u53EA\u6709\u5BA1\u6838\u4EBA\u4FEE\u6539\u8BE5\u7ED3\u8BBA\u540E\u624D\u80FD\u91CD\u65B0\u8F6C\u5316\u3002',\n        },\n        refuse_unapproved: {\n          title: '\u8F6C\u5316\u88AB\u62D2\u7EDD',\n          description:\n            '\u8BE5\u7EBF\u7D22\u5C1A\u672A\u83B7\u51C6\u8F6C\u5316\u3002\u5FC5\u987B\u7531\u5BA1\u6279\u4EBA\u6279\u51C6\u540E\uFF0C\u624D\u80FD\u8F6C\u5316\u4E3A\u5BA2\u6237\u3001\u8054\u7CFB\u4EBA\u548C\u5546\u673A\uFF1B\u7EBF\u7D22\u4E0A\u7684\u300C\u8F6C\u5316\u5BA1\u6279\u300D\u5B57\u6BB5\u663E\u793A\u8BE5\u51B3\u5B9A\u4ECD\u5728\u5F85\u5BA1\u6279\u8FD8\u662F\u5DF2\u88AB\u9A73\u56DE\u3002\u5728\u6B64\u671F\u95F4\u8BF7\u7EE7\u7EED\u8DDF\u8FDB\u8BE5\u7EBF\u7D22\u2014\u2014\u5B83\u7684\u4EFB\u4F55\u5185\u5BB9\u90FD\u6CA1\u6709\u88AB\u51BB\u7ED3\u3002',\n        },\n        refuse_no_match_key: {\n          title: '\u8F6C\u5316\u88AB\u62D2\u7EDD',\n          description:\n            '\u8BE5\u7EBF\u7D22\u7684\u516C\u53F8\u6CA1\u6709\u5339\u914D\u952E\uFF0C\u56E0\u6B64\u8F6C\u5316\u65E0\u6CD5\u5224\u65AD\u5B83\u5C5E\u4E8E\u54EA\u4E2A\u5BA2\u6237\uFF0C\u4E5F\u4E0D\u4F1A\u53BB\u731C\u6D4B\uFF1A\u731C\u6D4B\u53EF\u80FD\u4F1A\u628A\u8054\u7CFB\u4EBA\u548C\u5546\u673A\u5F52\u5230\u53E6\u4E00\u4E2A\u5BA2\u6237\u540D\u4E0B\u3002\u4FDD\u5B58\u7EBF\u7D22\u7684\u300C\u516C\u53F8\u300D\u4F1A\u91CD\u65B0\u751F\u6210\u5339\u914D\u952E\uFF0C\u8BF7\u91CD\u65B0\u4FDD\u5B58\u540E\u518D\u8F6C\u5316\u3002\u5C1A\u672A\u521B\u5EFA\u4EFB\u4F55\u8BB0\u5F55\u3002',\n        },\n      },\n    },\n    schedule_followup: {\n      label: '\u5B89\u6392\u8DDF\u8FDB',\n      screens: {\n        screen_1: {\n          title: '\u5B89\u6392\u8DDF\u8FDB',\n          fields: {\n            subject: { label: '\u4E0B\u4E00\u6B65\u505A\u4EC0\u4E48\uFF1F' },\n            dueDate: { label: '\u622A\u6B62\u65E5\u671F' },\n            activityType: {\n              label: '\u6D3B\u52A8\u7C7B\u578B',\n              options: { call: '\u7535\u8BDD', email: '\u90AE\u4EF6', meeting: '\u4F1A\u8BAE', follow_up: '\u8DDF\u8FDB', demo: '\u6F14\u793A', other: '\u5176\u4ED6' },\n            },\n            priority: { label: '\u4F18\u5148\u7EA7', options: { low: '\u4F4E', normal: '\u666E\u901A', high: '\u9AD8', urgent: '\u7D27\u6025' } },\n            notes: { label: '\u5907\u6CE8' },\n          },\n        },\n      },\n    },\n    quote_generation: {\n      label: '\u4ECE\u5546\u673A\u751F\u6210\u62A5\u4EF7\u5355',\n      refusals: { refuse_held: { message: '\u9700\u5148\u5B8C\u6210\u7ACB\u9879\u5BA1\u6279\uFF1A\u8BF7\u52FE\u9009\u300C\u7533\u8BF7\u7ACB\u9879\u5BA1\u6279\u300D\u3002\u5C1A\u672A\u521B\u5EFA\u4EFB\u4F55\u5185\u5BB9\u3002' } },\n      screens: {\n        screen_1: {\n          title: '\u4ECE\u5546\u673A\u751F\u6210\u62A5\u4EF7\u5355',\n          fields: {\n            quoteName: { label: '\u62A5\u4EF7\u540D\u79F0' },\n            expirationDays: { label: '\u6709\u6548\u671F\uFF08\u5929\uFF09' },\n            discount: { label: `\u6298\u6263 % (\u2264 ${QUOTE_DISCOUNT_CEILING})`, placeholder: `0-${QUOTE_DISCOUNT_CEILING}` },\n          },\n        },\n      },\n    },\n  },\n};\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/sales/translations/zh-CN/_shared.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/sales/translations/zh-CN\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/sales/translations/zh-CN/_shared.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\n/**\n * \u7B80\u4F53\u4E2D\u6587 (zh-CN) \u2014 values shared by more than one part of this bundle.\n *\n * SPLIT AXIS (#1311): translation NAMESPACE first, then CRM DOMAIN FAMILY.\n * Everything that is not `objects` lives in `./app.ts`; `objects` \u2014 69-78% of\n * every bundle \u2014 is one file per CRM domain family, and a detail object\n * follows its master. A new row goes in the file for ITS family, never in\n * whichever file is already open: that is how one file re-grows past the 70%\n * advisory band `pnpm hygiene` prints. Full rule and rationale:\n * `src/sales/translations/zh-CN.ts`.\n *\n * Every constant here is spread into object rows that live in MORE THAN ONE\n * family file, so it cannot sit in any one of them. A value used by exactly\n * one family lives in that family's file instead \u2014 that split is mechanical,\n * not a judgement call.\n */\n\n/**\n * \u6D3B\u52A8\u52A8\u4F5C\u65CF\uFF08#592\uFF09\uFF1A`log_call` / `log_meeting` / `schedule_meeting` \u5728\n * \u7EBF\u7D22\u3001\u8054\u7CFB\u4EBA\u3001\u5BA2\u6237\u3001\u5546\u673A\u3001\u5DE5\u5355\u4E0A\u5404\u6CE8\u518C\u4E00\u6B21\uFF08\u65E0 `objectName` \u7684\u811A\u672C\u52A8\u4F5C\u4F1A\u843D\u5230\n * \u8C03\u5EA6\u5668\u4ECE\u4E0D\u63A2\u6D4B\u7684\u952E\u4E0A\u2014\u2014\u89C1 #509\uFF09\u3002\u4E94\u4E2A\u5BF9\u8C61\u7684\u6587\u6848\u5B8C\u5168\u76F8\u540C\uFF0C\u56E0\u6B64\u5728\u6B64\u58F0\u660E\u4E00\u6B21\u5E76\n * \u5C55\u5F00\u5230\u5404\u5BF9\u8C61\u7684 `_actions`\uFF1A\u6BCF\u4E2A\u8BED\u8A00\u624B\u6284\u5341\u4E94\u4EFD\u6B63\u662F\u8BD1\u6587\u8D70\u6837\u7684\u5F00\u7AEF\u3002\n */\nexport const activityActions = {\n  log_call: {\n    label: '\u8BB0\u5F55\u901A\u8BDD',\n    successMessage: '\u901A\u8BDD\u8BB0\u5F55\u6210\u529F\uFF01',\n    params: {\n      subject: { label: '\u901A\u8BDD\u4E3B\u9898' },\n      duration: { label: '\u65F6\u957F\uFF08\u5206\u949F\uFF09' },\n      attendee_contacts: { label: '\u8054\u7CFB\u4EBA\u53C2\u4E0E\u8005' },\n      attendee_users: { label: '\u5185\u90E8\u53C2\u4E0E\u8005' },\n      notes: { label: '\u901A\u8BDD\u8BB0\u5F55' },\n    },\n  },\n  log_meeting: {\n    label: '\u8BB0\u5F55\u4F1A\u8BAE',\n    successMessage: '\u4F1A\u8BAE\u8BB0\u5F55\u6210\u529F\uFF01',\n    params: {\n      subject: { label: '\u4F1A\u8BAE\u4E3B\u9898' },\n      duration: { label: '\u65F6\u957F\uFF08\u5206\u949F\uFF09' },\n      attendee_contacts: { label: '\u8054\u7CFB\u4EBA\u53C2\u4F1A\u4EBA' },\n      attendee_users: { label: '\u5185\u90E8\u53C2\u4F1A\u4EBA' },\n      notes: { label: '\u4F1A\u8BAE\u7EAA\u8981' },\n    },\n  },\n  schedule_meeting: {\n    label: '\u5B89\u6392\u4F1A\u8BAE',\n    successMessage: '\u4F1A\u8BAE\u5DF2\u5B89\u6392\uFF01',\n    params: {\n      subject: { label: '\u4F1A\u8BAE\u4E3B\u9898' },\n      start_date: { label: '\u5F00\u59CB\u65E5\u671F\uFF08UTC\uFF09' },\n      start_time: { label: '\u5F00\u59CB\u65F6\u95F4\uFF08UTC\uFF09' },\n      location: { label: '\u5730\u70B9' },\n      duration: { label: '\u65F6\u957F\uFF08\u5206\u949F\uFF09' },\n      attendee_contacts: { label: '\u8054\u7CFB\u4EBA\u53C2\u4F1A\u4EBA' },\n      attendee_users: { label: '\u5185\u90E8\u53C2\u4F1A\u4EBA' },\n      notes: { label: '\u4F1A\u8BAE\u8BAE\u7A0B' },\n    },\n  },\n};\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/sales/translations/zh-CN/objects.customer.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/sales/translations/zh-CN\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/sales/translations/zh-CN/objects.customer.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport type { ObjectTranslationData } from '@objectstack/spec/system';\n\nimport { activityActions } from './_shared';\n\n/**\n * \u7B80\u4F53\u4E2D\u6587 (zh-CN) \u2014 `objects` translations for the CUSTOMER family:\n * the customer record itself \u2014 accounts and the people at them.\n *\n * Roster: `crm_account`, `crm_contact`.\n *\n * SPLIT AXIS (#1311): translation NAMESPACE first, then CRM DOMAIN FAMILY.\n * Everything that is not `objects` lives in `./app.ts`; `objects` \u2014 69-78% of\n * every bundle \u2014 is one file per CRM domain family, and a detail object\n * follows its master. A new row goes in the file for ITS family, never in\n * whichever file is already open: that is how one file re-grows past the 70%\n * advisory band `pnpm hygiene` prints. Full rule and rationale:\n * `src/sales/translations/zh-CN.ts`.\n */\nexport const customer: Record<string, ObjectTranslationData> = {\n  crm_account: {\n    label: '\u5BA2\u6237',\n    pluralLabel: '\u5BA2\u6237',\n    description: '\u4E0E\u6211\u4EEC\u6709\u4E1A\u52A1\u5F80\u6765\u7684\u516C\u53F8\u548C\u7EC4\u7EC7',\n    fields: {\n      account_number: { label: '\u5BA2\u6237\u7F16\u53F7' },\n      registration_number: {\n        label: '\u767B\u8BB0\u8BC1\u4EF6\u53F7',\n        help: '\u5BF9\u65B9\u5728\u5176\u6240\u5C5E\u653F\u5E9C\u767B\u8BB0\u673A\u5173\u53D6\u5F97\u7684\u767B\u8BB0\u6807\u8BC6\u3002\u4E0D\u540C\u4E8E\u7531\u6211\u65B9\u53D1\u653E\u7684\u5BA2\u6237\u7F16\u53F7\u3002',\n      },\n      commercial_capability: {\n        label: '\u5546\u52A1\u80FD\u529B',\n        help: '\u8BE5\u5BA2\u6237\u662F\u5426\u53EF\u4EE5\u627F\u63A5\u65B0\u4E1A\u52A1\u3002\u4EC5\u7ED3\u7B97\u7C7B\u5BA2\u6237\u4F9D\u7136\u53EF\u7528\u4E8E\u5F00\u7968\u4E0E\u6536\u4ED8\u6B3E\uFF0C\u4F46\u4E0D\u80FD\u5173\u8054\u65B0\u7684\u5546\u673A\u3002',\n        options: { full: '\u5B8C\u6574', settlement_only: '\u4EC5\u7ED3\u7B97' },\n      },\n      incumbent_vendor: { label: '\u73B0\u6709\u4F9B\u5E94\u5546', help: '\u5F53\u524D\u627F\u63A5\u8BE5\u5BA2\u6237\u8FD9\u90E8\u5206\u652F\u51FA\u7684\u4F9B\u5E94\u5546\u3002' },\n      annual_purchasing_budget: { label: '\u5E74\u5EA6\u91C7\u8D2D\u9884\u7B97', help: '\u8BE5\u5BA2\u6237\u672C\u5E74\u5EA6\u9884\u8BA1\u5411\u4F9B\u5E94\u5546\u652F\u51FA\u7684\u91D1\u989D\uFF0C\u800C\u975E\u5176\u81EA\u8EAB\u8425\u6536\u3002' },\n      payment_cycle: {\n        label: '\u4ED8\u6B3E\u5468\u671F',\n        options: { prepaid: '\u9884\u4ED8', net_30: '30 \u5929', net_60: '60 \u5929', net_90: '90 \u5929' },\n      },\n      approval_status: {\n        label: '\u5BA1\u6279\u72B6\u6001',\n        help: '\u8BE5\u5BA2\u6237\u7684\u5BA1\u6279\u8FDB\u5C55\u3002\u65B0\u5EFA\u5BA2\u6237\u521D\u59CB\u4E3A\u5F85\u5BA1\u6279\uFF0C\u5E76\u5728\u5BA1\u6279\u6536\u4EF6\u7BB1\u4E2D\u88C1\u5B9A\u3002',\n        options: { pending: '\u5F85\u5BA1\u6279', approved: '\u5DF2\u901A\u8FC7', rejected: '\u5DF2\u9A73\u56DE' },\n      },\n      name: { label: '\u5BA2\u6237\u540D\u79F0', help: '\u516C\u53F8\u6216\u7EC4\u7EC7\u7684\u6CD5\u5B9A\u540D\u79F0' },\n      type: {\n        label: '\u7C7B\u578B',\n        options: { prospect: '\u6F5C\u5728\u5BA2\u6237', customer: '\u6B63\u5F0F\u5BA2\u6237', partner: '\u5408\u4F5C\u4F19\u4F34', former: '\u524D\u5BA2\u6237' },\n      },\n      industry: {\n        label: '\u884C\u4E1A',\n        options: {\n          technology: '\u79D1\u6280', software: '\u8F6F\u4EF6 / SaaS', finance: '\u91D1\u878D',\n          healthcare: '\u533B\u7597', retail: '\u96F6\u552E', manufacturing: '\u5236\u9020',\n          education: '\u6559\u80B2', real_estate: '\u623F\u5730\u4EA7', media: '\u4F20\u5A92\u5A31\u4E50',\n          logistics: '\u7269\u6D41', hospitality: '\u9152\u5E97\u65C5\u6E38', energy: '\u80FD\u6E90\u516C\u7528\u4E8B\u4E1A',\n          government: '\u653F\u5E9C', nonprofit: '\u975E\u8425\u5229', other: '\u5176\u4ED6',\n        },\n      },\n      annual_revenue: { label: '\u5E74\u8425\u6536' },\n      child_account_revenue: { label: '\u5B50\u516C\u53F8\u5E74\u8425\u6536\u5408\u8BA1', help: '\u672C\u5BA2\u6237\u76F4\u5C5E\u5B50\u516C\u53F8\u7684\u5E74\u8425\u6536\u5408\u8BA1\u3002' },\n      number_of_employees: { label: '\u5458\u5DE5\u4EBA\u6570' },\n      phone: { label: '\u7535\u8BDD' },\n      website: { label: '\u7F51\u7AD9' },\n      billing_address: { label: '\u8D26\u5355\u5730\u5740' },\n      billing_country: {\n        label: '\u8D26\u5355\u56FD\u5BB6',\n        help: '\u7531\u8D26\u5355\u5730\u5740\u63A8\u5BFC\u2014\u2014\u6309\u5F55\u5165\u539F\u6837\u53BB\u9664\u9996\u5C3E\u7A7A\u683C\u5E76\u8F6C\u4E3A\u5927\u5199\u3002',\n      },\n      territory: {\n        label: '\u9500\u552E\u533A\u57DF',\n        help: '\u7531\u8D26\u5355\u5730\u5740\u63A8\u5BFC\u2014\u2014\u533A\u57DF\u5171\u4EAB\u89C4\u5219\u636E\u6B64\u5339\u914D\u3002\u4E0D\u5C5E\u4E8E\u5DF2\u914D\u7F6E\u533A\u57DF\u7684\u5BA2\u6237\u4E3A\u201C\u5176\u4ED6\u201D\u3002',\n        options: { na: '\u5317\u7F8E', emea: '\u6B27\u6D32\u3001\u4E2D\u4E1C\u4E0E\u975E\u6D32', other: '\u5176\u4ED6' },\n      },\n      office_location: { label: '\u529E\u516C\u5730\u70B9' },\n      owner_id: { label: '\u5BA2\u6237\u8D1F\u8D23\u4EBA' },\n      parent_account: { label: '\u6BCD\u516C\u53F8', help: '\u5C42\u7EA7\u7ED3\u6784\u4E2D\u7684\u6BCD\u516C\u53F8' },\n      description: { label: '\u63CF\u8FF0' },\n      is_active: { label: '\u662F\u5426\u6D3B\u8DC3' },\n      last_activity_date: { label: '\u6700\u8FD1\u6D3B\u52A8\u65E5\u671F' },\n      brand_color: { label: '\u54C1\u724C\u8272' },\n      logo: { label: '\u516C\u53F8\u6807\u8BC6' },\n      tier: {\n        label: '\u5BA2\u6237\u5206\u5C42',\n        options: { strategic: '\u6218\u7565\u5BA2\u6237', enterprise: '\u4F01\u4E1A\u5BA2\u6237', mid_market: '\u4E2D\u578B\u5BA2\u6237', smb: '\u4E2D\u5C0F\u5BA2\u6237' },\n      },\n      segment: {\n        label: '\u5BA2\u6237\u7EC6\u5206',\n        options: { net_new: '\u5168\u65B0\u5BA2\u6237', growth: '\u589E\u957F\u5BA2\u6237', at_risk: '\u98CE\u9669\u5BA2\u6237', stable: '\u7A33\u5B9A\u5BA2\u6237' },\n      },\n      health_score: {\n        label: '\u5065\u5EB7\u5EA6',\n        help: '\u5BA2\u6237\u6210\u529F\u7ECF\u7406\u7EF4\u62A4\u7684\u5065\u5EB7\u5EA6\u6307\u6807',\n        options: { healthy: '\u5065\u5EB7', watching: '\u5173\u6CE8', at_risk: '\u98CE\u9669', churning: '\u6D41\u5931\u4E2D' },\n      },\n      name_normalized: { label: '\u5BA2\u6237\u540D\u79F0\uFF08\u89C4\u8303\u5316\uFF09', help: '\u7EBF\u7D22\u8F6C\u5316\u7684\u5339\u914D\u952E\uFF1A\u5BA2\u6237\u540D\u79F0\u8F6C\u5C0F\u5199\u3001\u53BB\u9664\u9996\u5C3E\u7A7A\u683C\u3001\u5185\u90E8\u8FDE\u7EED\u7A7A\u767D\u5408\u5E76\u4E3A\u4E00\u4E2A\u7A7A\u683C\u3002\u7531 account_protection \u94A9\u5B50\u7EF4\u62A4\u2014\u2014\u8BF7\u52FF\u76F4\u63A5\u7F16\u8F91\u3002' },\n      display_title: { label: '\u663E\u793A\u540D\u79F0' },\n    },\n    _views: {\n      all_accounts: {\n        label: '\u5168\u90E8\u5BA2\u6237', description: '\u5BA2\u6237\u4E3B\u5217\u8868\uFF0C\u5305\u542B\u8425\u6536\u4E0E\u884C\u4E1A\u6458\u8981',\n        bulkActions: {\n          delete: {\n            label: '\u5220\u9664',\n            confirmLabel: '\u5220\u9664',\n            confirmText: '\u786E\u5B9A\u8981\u6C38\u4E45\u5220\u9664 {{count}} \u4E2A\u5BA2\u6237\u5417\uFF1F\u6B64\u64CD\u4F5C\u65E0\u6CD5\u64A4\u9500\u3002',\n          },\n          transfer_owner: {\n            label: '\u8F6C\u79FB\u8D1F\u8D23\u4EBA',\n            confirmText: '\u786E\u5B9A\u8981\u8F6C\u79FB {{count}} \u4E2A\u5BA2\u6237\u7684\u8D1F\u8D23\u4EBA\u5417\uFF1F',\n            params: {\n              owner_id: {\n                label: '\u65B0\u8D1F\u8D23\u4EBA',\n              },\n            },\n          },\n          update_tier: {\n            label: '\u66F4\u65B0\u5BA2\u6237\u7B49\u7EA7',\n            confirmText: '\u786E\u5B9A\u8981\u5C06 {{count}} \u4E2A\u5BA2\u6237\u7684\u7B49\u7EA7\u66F4\u65B0\u4E3A {{tier}} \u5417\uFF1F',\n            params: {\n              tier: {\n                label: '\u5BA2\u6237\u7B49\u7EA7',\n              },\n            },\n          },\n        },\n      },\n      account_gallery: { label: '\u5BA2\u6237\u5361\u7247', description: '\u4F7F\u7528\u54C1\u724C\u8272\u9AD8\u4EAE\u7684\u5BA2\u6237\u5361\u7247\u89C6\u56FE' },\n      account_map: { label: '\u5BA2\u6237\u5730\u56FE', description: '\u5BA2\u6237\u7684\u5730\u7406\u5206\u5E03' },\n      enterprise_accounts: { label: '\u4F01\u4E1A\u5BA2\u6237', description: '\u5E74\u8425\u6536\u6700\u9AD8\u7684\u5927\u5BA2\u6237' },\n      my_accounts: { label: '\u6211\u7684\u5BA2\u6237', description: '\u7531\u5F53\u524D\u7528\u6237\u8D1F\u8D23\u7684\u5BA2\u6237' },\n      at_risk_accounts: { label: '\u26A0\uFE0F \u98CE\u9669\u5BA2\u6237' },\n    },\n    _sections: {\n      basic: { label: '\u57FA\u672C\u4FE1\u606F' },\n      financials: { label: '\u8D22\u52A1\u4FE1\u606F' },\n      business_profile: { label: '\u4E1A\u52A1\u4FE1\u606F' },\n      contact_info: { label: '\u8054\u7CFB\u4FE1\u606F' },\n      ownership: { label: '\u5F52\u5C5E\u4E0E\u72B6\u6001' },\n      branding: { label: '\u54C1\u724C' },\n      system: { label: '\u7CFB\u7EDF' },\n      // account.view.ts \u8868\u5355\u533A\u5757\u540D\u79F0 (#1100)\n      profile: { label: '\u8D44\u6599' },\n      customer_success: { label: '\u5BA2\u6237\u6210\u529F' },\n      locations: { label: '\u5730\u5740\u4FE1\u606F' },\n      description: { label: '\u63CF\u8FF0' },\n    },\n    _actions: { ...activityActions },\n  },\n  crm_contact: {\n    label: '\u8054\u7CFB\u4EBA',\n    pluralLabel: '\u8054\u7CFB\u4EBA',\n    description: '\u5BA2\u6237\u4E0E\u5546\u673A\u7684\u5173\u952E\u4EBA\u7269\u8054\u7CFB\u4EBA',\n    fields: {\n      salutation: {\n        label: '\u79F0\u8C13',\n        options: { mr: '\u5148\u751F', ms: '\u5973\u58EB', mrs: '\u592B\u4EBA', dr: '\u535A\u58EB', prof: '\u6559\u6388' },\n      },\n      first_name: { label: '\u540D' },\n      last_name: { label: '\u59D3' },\n      full_name: { label: '\u5168\u540D' },\n      crm_account: { label: '\u6240\u5C5E\u5BA2\u6237' },\n      email: { label: '\u90AE\u7BB1' },\n      phone: { label: '\u7535\u8BDD' },\n      mobile: { label: '\u624B\u673A' },\n      title: { label: '\u804C\u4F4D' },\n      department: {\n        label: '\u90E8\u95E8',\n        options: {\n          executive: '\u7BA1\u7406\u5C42', sales: '\u9500\u552E\u90E8', marketing: '\u5E02\u573A\u90E8',\n          engineering: '\u5DE5\u7A0B\u90E8', support: '\u652F\u6301\u90E8', finance: '\u8D22\u52A1\u90E8',\n          hr: '\u4EBA\u529B\u8D44\u6E90', operations: '\u8FD0\u8425\u90E8',\n        },\n      },\n      // \u91C7\u8D2D\u51B3\u7B56\u5708 (REQ-0004)\u3002\u82F1\u6587\u6807\u7B7E\u662F 'Buying Function' \u800C\u975E 'Buying Role'\uFF1A\n      // \u5E73\u53F0\u7684 security-role-word \u89C4\u5219\u5728\u5BF9\u8C61\u58F0\u660E\u4E0A\u4FDD\u7559\u4E86\u82F1\u6587 role \u4E00\u8BCD\uFF08ADR-0090 D3\uFF09\u3002\n      // \u8BE5\u89C4\u5219\u53EA\u5339\u914D\u82F1\u6587\uFF0C\u4E0D\u8BFB\u8BED\u8A00\u5305\uFF0C\u6240\u4EE5\u4E2D\u6587\u8FD9\u91CC\u7528\u672C\u5730\u8BFB\u8005\u771F\u6B63\u5728\u8BF4\u7684\u8BCD\u3002\n      buying_function: {\n        label: '\u91C7\u8D2D\u89D2\u8272',\n        options: {\n          decision_maker: '\u51B3\u7B56\u8005', economic_buyer: '\u9884\u7B97\u51B3\u7B56\u4EBA',\n          technical_evaluator: '\u6280\u672F\u8BC4\u4F30\u4EBA', user: '\u4F7F\u7528\u8005',\n          influencer: '\u5F71\u54CD\u8005', gatekeeper: '\u5B88\u95E8\u4EBA',\n        },\n      },\n      attitude: {\n        label: '\u5BF9\u6211\u53F8\u6001\u5EA6',\n        options: {\n          champion: '\u62E5\u62A4\u8005', supportive: '\u652F\u6301', neutral: '\u4E2D\u7ACB',\n          skeptical: '\u5B58\u7591', blocker: '\u53CD\u5BF9\u8005',\n        },\n      },\n      relationship_strength: {\n        label: '\u4E0E\u9500\u552E\u5173\u7CFB\u5F3A\u5EA6',\n        options: {\n          distant: '\u758F\u8FDC', acquaintance: '\u4E00\u822C\u8BA4\u8BC6', working: '\u5DE5\u4F5C\u5F80\u6765',\n          strong: '\u5173\u7CFB\u7D27\u5BC6', trusted_advisor: '\u53EF\u4FE1\u987E\u95EE',\n        },\n      },\n      owner_id: { label: '\u8054\u7CFB\u4EBA\u8D1F\u8D23\u4EBA' },\n      description: { label: '\u63CF\u8FF0' },\n      is_primary: { label: '\u4E3B\u8981\u8054\u7CFB\u4EBA', help: '\u662F\u5426\u4E3A\u8BE5\u5BA2\u6237\u7684\u4E3B\u8981\u8054\u7CFB\u4EBA\uFF1F' },\n      mailing_address: { label: '\u90AE\u5BC4\u5730\u5740' },\n      lead_source: {\n        label: '\u7EBF\u7D22\u6765\u6E90',\n        options: {\n          web: '\u7F51\u7AD9', referral: '\u63A8\u8350', event: '\u6D3B\u52A8 / \u5C55\u4F1A',\n          webinar: '\u7EBF\u4E0A\u7814\u8BA8\u4F1A', partner: '\u5408\u4F5C\u4F19\u4F34', advertisement: '\u5E7F\u544A',\n          paid_search: '\u4ED8\u8D39\u641C\u7D22', social: '\u793E\u4EA4\u5A92\u4F53', content: '\u5185\u5BB9 / \u535A\u5BA2',\n          cold_call: '\u964C\u751F\u62DC\u8BBF', email_campaign: '\u90AE\u4EF6\u8425\u9500', other: '\u5176\u4ED6',\n        },\n      },\n      do_not_call: { label: '\u7981\u6B62\u81F4\u7535' },\n      email_opt_out: { label: '\u62D2\u7EDD\u90AE\u4EF6' },\n      last_contacted_date: { label: '\u6700\u8FD1\u8054\u7CFB\u65F6\u95F4' },\n      avatar: { label: '\u5934\u50CF' },\n    },\n    _views: {\n      all_contacts: { label: '\u5168\u90E8\u8054\u7CFB\u4EBA' },\n      contact_directory: { label: '\u8054\u7CFB\u4EBA\u76EE\u5F55' },\n      primary_contacts: { label: '\u4E3B\u8981\u8054\u7CFB\u4EBA' },\n    },\n    _actions: {\n      ...activityActions,\n      mark_primary: {\n        label: '\u8BBE\u4E3A\u4E3B\u8981\u8054\u7CFB\u4EBA',\n        confirmText: '\u662F\u5426\u5C06\u6B64\u8054\u7CFB\u4EBA\u8BBE\u4E3A\u8BE5\u5BA2\u6237\u7684\u4E3B\u8981\u8054\u7CFB\u4EBA\uFF1F',\n        successMessage: '\u5DF2\u8BBE\u4E3A\u4E3B\u8981\u8054\u7CFB\u4EBA\uFF01',\n      },\n      send_email: {\n        label: '\u53D1\u9001\u90AE\u4EF6',\n        params: {\n          subject: { label: '\u4E3B\u9898' },\n          body: { label: '\u6B63\u6587' },\n        },\n      },\n      add_contact_to_campaign: {\n        label: '\u52A0\u5165\u8425\u9500\u6D3B\u52A8',\n        successMessage: '\u8054\u7CFB\u4EBA\u5DF2\u52A0\u5165\u8425\u9500\u6D3B\u52A8\uFF01',\n        params: {\n          crm_campaign: { label: '\u8425\u9500\u6D3B\u52A8' },\n        },\n      },\n    },\n    _sections: {\n      identity: { label: '\u8EAB\u4EFD\u4FE1\u606F' },\n      account_info: { label: '\u5BA2\u6237\u4E0E\u804C\u52A1' },\n      buying_centre: { label: '\u91C7\u8D2D\u51B3\u7B56\u5708' },\n      contact_info: { label: '\u8054\u7CFB\u65B9\u5F0F' },\n      mailing_address: { label: '\u90AE\u5BC4\u5730\u5740' },\n      additional: { label: '\u9644\u52A0\u4FE1\u606F' },\n      preferences: { label: '\u6C9F\u901A\u504F\u597D' },\n      // contact.view.ts \u8868\u5355\u533A\u5757\u540D\u79F0 (#1100)\n      contact_details: { label: '\u8054\u7CFB\u4FE1\u606F' },\n      comm_preferences: { label: '\u504F\u597D\u8BBE\u7F6E' },\n    },\n  },\n};\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/sales/translations/zh-CN/objects.pipeline.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/sales/translations/zh-CN\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/sales/translations/zh-CN/objects.pipeline.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport type { ObjectTranslationData } from '@objectstack/spec/system';\n\nimport { activityActions } from './_shared';\n\n/**\n * \u7B80\u4F53\u4E2D\u6587 (zh-CN) \u2014 `objects` translations for the PIPELINE family:\n * demand and the deals it becomes, plus the roll-up that forecasts them.\n *\n * Roster: `crm_lead`, `crm_opportunity`, `crm_opportunity_line_item`, `crm_forecast`.\n *\n * SPLIT AXIS (#1311): translation NAMESPACE first, then CRM DOMAIN FAMILY.\n * Everything that is not `objects` lives in `./app.ts`; `objects` \u2014 69-78% of\n * every bundle \u2014 is one file per CRM domain family, and a detail object\n * follows its master. A new row goes in the file for ITS family, never in\n * whichever file is already open: that is how one file re-grows past the 70%\n * advisory band `pnpm hygiene` prints. Full rule and rationale:\n * `src/sales/translations/zh-CN.ts`.\n */\nexport const pipeline: Record<string, ObjectTranslationData> = {\n  crm_lead: {\n    _validations: {\n      disqualification_reason_required: {\n        message: '\u7EBF\u7D22\u6807\u8BB0\u4E3A\u4E0D\u5408\u683C\u65F6\u5FC5\u987B\u586B\u5199\u53D6\u6D88\u8D44\u683C\u539F\u56E0',\n      },\n      duplicate_disqualification_requires_survivor: {\n        message: '\u4EE5\u91CD\u590D\u4E3A\u7531\u53D6\u6D88\u7EBF\u7D22\u8D44\u683C\u65F6\uFF0C\u5FC5\u987B\u6307\u660E\u4FDD\u7559\u7684\u8BB0\u5F55\u5E76\u5C06\u91CD\u590D\u72B6\u6001\u8BBE\u4E3A\u5DF2\u786E\u8BA4',\n      },\n      email_required: {\n        message: '\u7535\u5B50\u90AE\u4EF6\u4E3A\u5FC5\u586B\u9879',\n      },\n      lead_status_progression: {\n        message: '\u65E0\u6548\u7684\u7EBF\u7D22\u72B6\u6001\u6D41\u8F6C',\n      },\n    },\n    label: '\u7EBF\u7D22',\n    pluralLabel: '\u7EBF\u7D22',\n    description: '\u5C1A\u672A\u786E\u8BA4\u7684\u6F5C\u5728\u5BA2\u6237',\n    fields: {\n      salutation: {\n        label: '\u79F0\u8C13',\n        options: { mr: '\u5148\u751F', ms: '\u5973\u58EB', mrs: '\u592B\u4EBA', dr: '\u535A\u58EB', prof: '\u6559\u6388' },\n      },\n      first_name: { label: '\u540D' },\n      last_name: { label: '\u59D3' },\n      full_name: { label: '\u5168\u540D' },\n      company: { label: '\u516C\u53F8' },\n      title: { label: '\u804C\u4F4D' },\n      email: { label: '\u90AE\u7BB1' },\n      phone: { label: '\u7535\u8BDD' },\n      industry: {\n        label: '\u884C\u4E1A',\n        options: {\n          technology: '\u79D1\u6280', software: '\u8F6F\u4EF6 / SaaS', finance: '\u91D1\u878D',\n          healthcare: '\u533B\u7597', retail: '\u96F6\u552E', manufacturing: '\u5236\u9020',\n          education: '\u6559\u80B2', real_estate: '\u623F\u5730\u4EA7', media: '\u4F20\u5A92\u5A31\u4E50',\n          logistics: '\u7269\u6D41', hospitality: '\u9152\u5E97\u65C5\u6E38', energy: '\u80FD\u6E90\u516C\u7528\u4E8B\u4E1A',\n          government: '\u653F\u5E9C', nonprofit: '\u975E\u8425\u5229', other: '\u5176\u4ED6',\n        },\n      },\n      status: {\n        label: '\u72B6\u6001',\n        options: {\n          // \u5DF2\u786E\u8BA4 / \u672A\u901A\u8FC7 \u662F\u540C\u4E00\u4E2A\u52A8\u4F5C(\u7EBF\u7D22\u786E\u8BA4)\u7684\u6B63\u53CD\u4E24\u9762;\u539F\u5148\u7684\n          // \u5DF2\u786E\u8BA4 / \u4E0D\u5408\u683C \u51FA\u81EA\u4E24\u5957\u8BF4\u6CD5,\u5728\u72B6\u6001\u6761\u4E0A\u5E76\u6392\u65F6\u8BFB\u8D77\u6765\u4E0D\u6210\u5BF9\u3002\n          new: '\u65B0\u5EFA', contacted: '\u5DF2\u8054\u7CFB', qualified: '\u5DF2\u786E\u8BA4',\n          unqualified: '\u672A\u901A\u8FC7', converted: '\u5DF2\u8F6C\u5316',\n        },\n      },\n      lead_source: {\n        label: '\u7EBF\u7D22\u6765\u6E90',\n        options: {\n          web: '\u7F51\u7AD9', referral: '\u63A8\u8350', event: '\u6D3B\u52A8 / \u5C55\u4F1A',\n          webinar: '\u7EBF\u4E0A\u7814\u8BA8\u4F1A', partner: '\u5408\u4F5C\u4F19\u4F34', advertisement: '\u5E7F\u544A',\n          paid_search: '\u4ED8\u8D39\u641C\u7D22', social: '\u793E\u4EA4\u5A92\u4F53', content: '\u5185\u5BB9 / \u535A\u5BA2',\n          cold_call: '\u964C\u751F\u62DC\u8BBF', email_campaign: '\u90AE\u4EF6\u8425\u9500', other: '\u5176\u4ED6',\n        },\n      },\n      owner_id: { label: '\u7EBF\u7D22\u8D1F\u8D23\u4EBA' },\n      is_converted: { label: '\u5DF2\u8F6C\u5316' },\n      description: { label: '\u63CF\u8FF0' },\n      mobile: { label: '\u624B\u673A' },\n      website: { label: '\u7F51\u7AD9' },\n      rating: { label: '\u7EBF\u7D22\u8BC4\u5206', help: '\u7EBF\u7D22\u8D28\u91CF\u8BC4\u5206\uFF081-5 \u661F\uFF09' },\n      converted_account: { label: '\u8F6C\u5316\u5BA2\u6237' },\n      converted_contact: { label: '\u8F6C\u5316\u8054\u7CFB\u4EBA' },\n      converted_opportunity: { label: '\u8F6C\u5316\u5546\u673A' },\n      converted_date: { label: '\u8F6C\u5316\u65E5\u671F' },\n      address: { label: '\u5730\u5740' },\n      annual_revenue: { label: '\u5E74\u8425\u6536' },\n      number_of_employees: { label: '\u5458\u5DE5\u4EBA\u6570' },\n      notes: { label: '\u5907\u6CE8', help: '\u672C\u7EBF\u7D22\u7684\u5DE5\u4F5C\u5907\u6CE8\u2014\u2014\u652F\u6301\u683C\u5F0F\u6392\u7248\u3002' },\n      do_not_call: { label: '\u7981\u6B62\u81F4\u7535' },\n      email_opt_out: { label: '\u62D2\u6536\u90AE\u4EF6' },\n      disqualification_reason: {\n        // \u72B6\u6001\u91CC\u7684 unqualified \u8BD1\u4F5C\u300C\u672A\u901A\u8FC7\u300D,\u6240\u4EE5\u8FD9\u91CC\u8DDF\u7740\u53EB\u300C\u672A\u901A\u8FC7\u539F\u56E0\u300D\n        // \u800C\u4E0D\u662F\u300C\u53D6\u6D88\u8D44\u683C\u539F\u56E0\u300D\u2014\u2014 \u4E24\u4E2A\u5B57\u6BB5\u5728\u540C\u4E00\u5F20\u8868\u5355\u4E0A\u4E0B\u76F8\u90BB,\u7528\u8BCD\u5FC5\u987B\u6210\u5BF9\u3002\n        label: '\u672A\u901A\u8FC7\u539F\u56E0',\n        help: '\u72B6\u6001\u4E3A\u300C\u672A\u901A\u8FC7\u300D\u65F6\u5FC5\u586B',\n        options: {\n          not_a_fit: '\u9700\u6C42\u4E0D\u5339\u914D', no_budget: '\u9884\u7B97\u4E0D\u8DB3', wrong_persona: '\u8054\u7CFB\u4EBA\u89D2\u8272\u4E0D\u7B26',\n          unreachable: '\u65E0\u6CD5\u8054\u7CFB', duplicate: '\u91CD\u590D\u7EBF\u7D22', competitor: '\u9009\u62E9\u4E86\u7ADE\u4E89\u5BF9\u624B',\n          other: '\u5176\u4ED6',\n        },\n      },\n      duplicate_of_type: {\n        help: '\u4FDD\u7559\u4E0B\u6765\u7684\u90A3\u6761\u8BB0\u5F55\u6240\u5C5E\u7684\u5BF9\u8C61\u7C7B\u578B\u3002',\n        label: '\u91CD\u590D\u4E8E',\n        // `erased` \u662F\u5893\u7891\u503C\uFF0C\u4E0D\u662F\u53EF\u9009\u9879\uFF1A\u8868\u5355\u4E0D\u63D0\u4F9B\u5B83\uFF08\u89C1\n        // `src/sales/views/lead.view.ts`\uFF09\uFF0C\u4F46\u5E78\u5B58\u8BB0\u5F55\u88AB\u5220\u9664\u540E\u7EBF\u7D22\u4F1A\u5E26\u7740\u5B83\uFF0C\n        // \u6240\u4EE5\u51E1\u662F\u8BFB\u53D6\u8BB0\u5F55\u7684\u5730\u65B9\u90FD\u9700\u8981\u6807\u7B7E\uFF0C\u5426\u5219\u4F1A\u663E\u793A\u539F\u59CB\u503C `erased`\u3002\n        options: { crm_lead: '\u7EBF\u7D22', crm_contact: '\u8054\u7CFB\u4EBA', erased: '\u8BB0\u5F55\u5DF2\u5220\u9664' },\n      },\n      duplicate_of_lead: { label: '\u91CD\u590D\u7684\u7EBF\u7D22' },\n      duplicate_of_contact: { label: '\u91CD\u590D\u7684\u8054\u7CFB\u4EBA' },\n      duplicate_status: {\n        help: '\u7591\u4F3C = \u5F55\u5165\u65F6\u81EA\u52A8\u6807\u8BB0\uFF1B\u5DF2\u786E\u8BA4 = \u4EBA\u5DE5\u6838\u5B9E\u8FC7\u5339\u914D\u3002',\n        // \u7591\u4F3C = \u5F55\u5165\u65F6\u81EA\u52A8\u6807\u8BB0;\u5DF2\u786E\u8BA4 = \u4EBA\u5DE5\u6838\u5BF9\u540E\u7684\u5224\u5B9A\u3002\u4E24\u8005\u662F\u540C\u4E00\n        // \u5224\u65AD\u7684\u4E24\u4E2A\u9636\u6BB5,\u6240\u4EE5\u5171\u7528\u4E00\u4E2A\u5B57\u6BB5\u800C\u4E0D\u662F\u5404\u5360\u4E00\u5957\u94FE\u63A5\u5B57\u6BB5\u3002\n        label: '\u91CD\u590D\u72B6\u6001',\n        options: { suspected: '\u7591\u4F3C\u91CD\u590D', confirmed: '\u5DF2\u786E\u8BA4\u91CD\u590D' },\n      },\n      display_title: { label: '\u663E\u793A\u540D\u79F0' },\n      company_normalized: { label: '\u516C\u53F8\u540D\u79F0\uFF08\u89C4\u8303\u5316\uFF09', help: '\u7EBF\u7D22\u8F6C\u5316\u7684\u5339\u914D\u952E\uFF1A\u516C\u53F8\u540D\u79F0\u8F6C\u5C0F\u5199\u3001\u53BB\u9664\u9996\u5C3E\u7A7A\u683C\u3001\u5185\u90E8\u8FDE\u7EED\u7A7A\u767D\u5408\u5E76\u4E3A\u4E00\u4E2A\u7A7A\u683C\u3002\u7531 lead_duplicate_check \u94A9\u5B50\u7EF4\u62A4\u2014\u2014\u8BF7\u52FF\u76F4\u63A5\u7F16\u8F91\u3002' },\n      next_followup_date: { label: '\u4E0B\u6B21\u8DDF\u8FDB\u65E5\u671F' },\n      last_contacted_date: { label: '\u6700\u8FD1\u8054\u7CFB\u65F6\u95F4' },\n      need_type: {\n        label: '\u9700\u6C42\u7C7B\u578B',\n        help: '\u5BA2\u6237\u60F3\u8981\u4EC0\u4E48\u3002\u7EBF\u7D22\u5206\u6D3E\u3001\u4F18\u5148\u7EA7\u6392\u5E8F\u548C\u9700\u6C42\u5206\u6790\u90FD\u8BFB\u8FD9\u4E2A\u5B57\u6BB5\u3002',\n        options: {\n          new_implementation: '\u65B0\u5EFA\u5B9E\u65BD', expansion: '\u6269\u5BB9\u589E\u8D2D',\n          replacement: '\u66FF\u6362\u8FC1\u79FB', renewal: '\u7EED\u7EA6', consulting: '\u54A8\u8BE2\u670D\u52A1',\n          support: '\u8FD0\u7EF4\u652F\u6301', other: '\u5176\u4ED6',\n        },\n      },\n      estimated_amount: {\n        label: '\u9884\u8BA1\u91D1\u989D',\n        help: '\u8D44\u683C\u5224\u5B9A\u4E4B\u524D\u5BF9\u8BE5\u9700\u6C42\u91D1\u989D\u7684\u4F30\u7B97\u3002\u8F6C\u5316\u65F6\u7528\u4E8E\u9884\u586B\u5546\u673A\u91D1\u989D\u3002',\n      },\n      conversion_approval_status: {\n        label: '\u8F6C\u5316\u5BA1\u6279',\n        help: '\u8BE5\u7EBF\u7D22\u662F\u5426\u5DF2\u83B7\u51C6\u8F6C\u5316\u3002\u300C\u65E0\u9700\u5BA1\u6279\u300D\u8868\u793A\u4E0D\u8D70\u5BA1\u6279\u6D41\u7A0B\u2014\u2014\u8FD9\u662F\u4EA7\u54C1\u7684\u51FA\u5382\u9ED8\u8BA4\u503C\u3002',\n        options: {\n          not_required: '\u65E0\u9700\u5BA1\u6279', pending: '\u5F85\u5BA1\u6279',\n          approved: '\u5BA1\u6279\u901A\u8FC7', rejected: '\u5BA1\u6279\u9A73\u56DE',\n        },\n      },\n    },\n    _views: {\n      all_leads: {\n        label: '\u5168\u90E8\u7EBF\u7D22',\n        emptyState: { title: '\u8FD8\u6CA1\u6709\u7EBF\u7D22', message: '\u521B\u5EFA\u7B2C\u4E00\u6761\u7EBF\u7D22\uFF0C\u4ECE\u8FD9\u91CC\u5F00\u59CB' },\n      },\n      kanban_by_status: { label: '\u7EBF\u7D22\u6D41\u6C34\u7EBF' },\n      calendar_by_created: { label: '\u7EBF\u7D22\u65E5\u5386' },\n      gallery_view: { label: '\u7EBF\u7D22\u5361\u7247' },\n      my_leads: { label: '\u6211\u7684\u7EBF\u7D22' },\n      high_priority: { label: '\u9AD8\u4F18\u5148\u7EA7' },\n      hot_leads: { label: '\uD83D\uDD25 \u9AD8\u70ED\u5EA6\u7EBF\u7D22' },\n      suspected_duplicates: {\n        label: '\u7591\u4F3C\u91CD\u590D\u7EBF\u7D22',\n        emptyState: { title: '\u6CA1\u6709\u7591\u4F3C\u91CD\u590D', message: '\u65E0\u9700\u590D\u6838\u2014\u2014\u6BCF\u4E2A\u91CD\u590D\u5F55\u5165\u7684\u90AE\u7BB1\u90FD\u5DF2\u68C0\u67E5\u8FC7\u3002' },\n      },\n    },\n    _sections: {\n      // Object-level section keys (lead.object.ts), used by record forms and\n      // by the detail page, whose sections reference these groups (#806)\n      address: { label: '\u5730\u5740' },\n      identity: { label: '\u8EAB\u4EFD\u4FE1\u606F' },\n      company_info: { label: '\u516C\u53F8\u4FE1\u606F' },\n      contact_info: { label: '\u8054\u7CFB\u65B9\u5F0F' },\n      qualification: { label: '\u8D44\u683C\u8BC4\u4F30' },\n      assignment: { label: '\u5206\u914D' },\n      additional: { label: '\u9644\u52A0\u4FE1\u606F' },\n      preferences: { label: '\u6C9F\u901A\u504F\u597D' },\n      conversion: { label: '\u8F6C\u5316' },\n      duplicates: { label: '\u91CD\u590D\u7EBF\u7D22\u7BA1\u7406' },\n      // lead.view.ts \u8868\u5355\u533A\u5757\u540D\u79F0 (#1100) \u2014\u2014 \u9ED8\u8BA4\u8868\u5355\u4E0E\u6BCF\u4E00\u4E2A\u5177\u540D formView\n      // \u7684\u533A\u5757\u540D\u5B57\u90FD\u4F4F\u5728\u8FD9\u91CC\uFF1A\u90A3\u8FB9\u65B0\u589E\u4E00\u4E2A\u8868\u5355\uFF0C\u8FD9\u91CC\u5C31\u8865\u4E0A\u5B83\u7684\u533A\u5757\u540D\u3002\n      contact_information: { label: '\u8054\u7CFB\u4FE1\u606F' },\n      lead_classification: { label: '\u7EBF\u7D22\u5206\u7C7B' },\n      company_information: { label: '\u516C\u53F8\u4FE1\u606F' },\n      additional_information: { label: '\u9644\u52A0\u4FE1\u606F' },\n      privacy: { label: '\u9690\u79C1' },\n      general: { label: '\u5E38\u89C4\u4FE1\u606F' },\n      details: { label: '\u8BE6\u60C5' },\n      step_1_contact_details: { label: '\u7B2C\u4E00\u6B65\uFF1A\u8054\u7CFB\u65B9\u5F0F' },\n      step_2_company_information: { label: '\u7B2C\u4E8C\u6B65\uFF1A\u516C\u53F8\u4FE1\u606F' },\n      step_3_qualification: { label: '\u7B2C\u4E09\u6B65\uFF1A\u8D44\u8D28\u5BA1\u6838' },\n      step_4_review_and_convert: { label: '\u7B2C\u56DB\u6B65\uFF1A\u5BA1\u6838\u5E76\u8F6C\u5316' },\n      primary_information: { label: '\u4E3B\u8981\u4FE1\u606F' },\n      extended_details: { label: '\u6269\u5C55\u4FE1\u606F' },\n      quick_edit: { label: '\u5FEB\u901F\u7F16\u8F91' },\n      update_lead_status: { label: '\u66F4\u65B0\u7EBF\u7D22\u72B6\u6001' },\n      tell_us_about_yourself: { label: '\u8BF7\u4ECB\u7ECD\u4E00\u4E0B\u60A8\u81EA\u5DF1' },\n      about_your_company: { label: '\u60A8\u7684\u516C\u53F8\u4FE1\u606F' },\n      how_can_we_help: { label: '\u6211\u4EEC\u80FD\u5E2E\u60A8\u4EC0\u4E48\uFF1F' },\n      lead_information: { label: '\u7EBF\u7D22\u4FE1\u606F' },\n      address_information: { label: '\u5730\u5740\u4FE1\u606F' },\n      privacy_preferences: { label: '\u9690\u79C1\u504F\u597D' },\n    },\n    _actions: {\n      ...activityActions,\n      convert_lead: {\n        label: '\u8F6C\u5316\u7EBF\u7D22',\n        successMessage: '\u7EBF\u7D22\u8F6C\u5316\u6210\u529F\uFF01',\n      },\n      create_campaign: {\n        label: '\u52A0\u5165\u8425\u9500\u6D3B\u52A8',\n        successMessage: '\u5DF2\u5C06\u7EBF\u7D22\u52A0\u5165\u8425\u9500\u6D3B\u52A8\uFF01',\n        params: {\n          crm_campaign: { label: '\u8425\u9500\u6D3B\u52A8' },\n        },\n      },\n      schedule_followup: {\n        label: '\u5B89\u6392\u8DDF\u8FDB',\n        successMessage: '\u8DDF\u8FDB\u4EFB\u52A1\u5DF2\u521B\u5EFA\u3002',\n      },\n    },\n  },\n  crm_opportunity: {\n    _validations: {\n      amount_positive: {\n        message: '\u91D1\u989D\u5FC5\u987B\u5927\u4E8E\u96F6',\n      },\n      close_date_future: {\n        message: '\u9664\u975E\u5546\u673A\u5DF2\u7ED3\u675F\uFF0C\u5426\u5219\u9884\u8BA1\u6210\u4EA4\u65E5\u4E0D\u5E94\u65E9\u4E8E\u4ECA\u5929',\n      },\n      opportunity_stage_progression: {\n        message: '\u65E0\u6548\u7684\u5546\u673A\u9636\u6BB5\u6D41\u8F6C',\n      },\n    },\n    label: '\u5546\u673A',\n    pluralLabel: '\u5546\u673A',\n    description: '\u9500\u552E\u6D41\u7A0B\u4E2D\u7684\u5546\u673A\u4E0E\u4EA4\u6613',\n    fields: {\n      name: { label: '\u5546\u673A\u540D\u79F0' },\n      crm_account: { label: '\u6240\u5C5E\u5BA2\u6237' },\n      primary_contact: { label: '\u4E3B\u8981\u8054\u7CFB\u4EBA' },\n      owner_id: { label: '\u5546\u673A\u8D1F\u8D23\u4EBA' },\n      amount: { label: '\u91D1\u989D' },\n      expected_revenue: { label: '\u9884\u671F\u6536\u5165' },\n      stage: {\n        label: '\u9636\u6BB5',\n        options: {\n          prospecting: '\u5BFB\u627E\u5BA2\u6237', qualification: '\u8D44\u683C\u5BA1\u67E5',\n          needs_analysis: '\u9700\u6C42\u5206\u6790', proposal: '\u63D0\u6848',\n          negotiation: '\u8C08\u5224', closed_won: '\u6210\u4EA4', closed_lost: '\u5931\u8D25',\n        },\n      },\n      probability: { label: '\u6210\u4EA4\u6982\u7387 (%)' },\n      close_date: { label: '\u9884\u8BA1\u6210\u4EA4\u65E5\u671F' },\n      type: {\n        label: '\u7C7B\u578B',\n        options: {\n          new_business: '\u65B0\u4E1A\u52A1',\n          existing_upgrade: '\u8001\u5BA2\u6237\u5347\u7EA7',\n          existing_renewal: '\u8001\u5BA2\u6237\u7EED\u7EA6',\n          existing_expansion: '\u8001\u5BA2\u6237\u62D3\u5C55',\n        },\n      },\n      forecast_category: {\n        label: '\u9884\u6D4B\u7C7B\u522B',\n        options: {\n          pipeline: '\u7BA1\u9053', best_case: '\u6700\u4F73\u60C5\u51B5',\n          commit: '\u627F\u8BFA', omitted: '\u5DF2\u6392\u9664', closed: '\u5DF2\u5173\u95ED',\n        },\n      },\n      description: { label: '\u63CF\u8FF0' },\n      next_step: { label: '\u4E0B\u4E00\u6B65' },\n      lead_source: {\n        label: '\u7EBF\u7D22\u6765\u6E90',\n        options: {\n          web: '\u7F51\u7AD9', referral: '\u63A8\u8350', event: '\u6D3B\u52A8 / \u5C55\u4F1A',\n          webinar: '\u7EBF\u4E0A\u7814\u8BA8\u4F1A', partner: '\u5408\u4F5C\u4F19\u4F34', advertisement: '\u5E7F\u544A',\n          paid_search: '\u4ED8\u8D39\u641C\u7D22', social: '\u793E\u4EA4\u5A92\u4F53', content: '\u5185\u5BB9 / \u535A\u5BA2',\n          cold_call: '\u964C\u751F\u62DC\u8BBF', email_campaign: '\u90AE\u4EF6\u8425\u9500', other: '\u5176\u4ED6',\n        },\n      },\n      crm_campaign: { label: '\u8425\u9500\u6D3B\u52A8', help: '\u5E26\u6765\u6B64\u5546\u673A\u7684\u8425\u9500\u6D3B\u52A8' },\n      days_in_stage: { label: '\u5F53\u524D\u9636\u6BB5\u5929\u6570' },\n      stage_entry_date: { label: '\u8FDB\u5165\u5F53\u524D\u9636\u6BB5\u65E5\u671F', help: '\u672C\u5546\u673A\u8FDB\u5165\u5F53\u524D\u9636\u6BB5\u7684\u65E5\u671F\u3002' },\n      is_private: { label: '\u79C1\u5BC6' },\n      approval_status: {\n        label: '\u5BA1\u6279\u72B6\u6001',\n        options: { not_required: '\u65E0\u9700\u5BA1\u6279', pending: '\u5BA1\u6279\u4E2D', approved: '\u5DF2\u6279\u51C6', rejected: '\u5DF2\u9A73\u56DE' },\n      },\n      approved_date: { label: '\u6279\u51C6\u65F6\u95F4' },\n      win_reason: {\n        help: '\u8D62\u5355\u539F\u56E0\u3002\u5C06\u5546\u673A\u5173\u95ED\u4E3A\"\u6210\u4EA4\"\u65F6\u5FC5\u586B\u3002',\n        label: '\u8D62\u5355\u539F\u56E0',\n        options: {\n          better_product: '\u4EA7\u54C1\u66F4\u4F18', better_price: '\u4EF7\u683C\u66F4\u4F18', relationship: '\u5BA2\u6237\u5173\u7CFB',\n          better_support: '\u652F\u6301\u66F4\u597D', best_fit: '\u6700\u4F73\u5951\u5408',\n          quote_accepted: '\u62A5\u4EF7\u88AB\u63A5\u53D7', other: '\u5176\u4ED6',\n        },\n      },\n      loss_reason: {\n        help: '\u4E22\u5355\u539F\u56E0\u3002\u5C06\u5546\u673A\u5173\u95ED\u4E3A\"\u5931\u8D25\"\u65F6\u5FC5\u586B\u3002',\n        label: '\u4E22\u5355\u539F\u56E0',\n        options: {\n          price: '\u4EF7\u683C\u8FC7\u9AD8', competitor: '\u8F93\u7ED9\u7ADE\u4E89\u5BF9\u624B', no_budget: '\u65E0\u9884\u7B97',\n          no_decision: '\u672A\u51B3\u7B56', timing: '\u65F6\u673A\u4E0D\u5408\u9002', features: '\u529F\u80FD\u7F3A\u5931', other: '\u5176\u4ED6',\n        },\n      },\n      loss_details: { label: '\u8D62/\u4E22\u5355\u8BE6\u60C5', help: '\u8D62\u5355\u6216\u4E22\u5355\u539F\u56E0\u7684\u8865\u5145\u8BF4\u660E\u3002' },\n      // REQ-0006 \u2014 \u8D44\u683C\u8BC4\u4F30\u3001\u5BA2\u6237\u4FA7\u91C7\u8D2D\u65E5\u7A0B\u3001\u5546\u673A\u53D9\u8FF0\u3001\u4E1A\u52A1\u7EBF\u4E0E\u72B6\u6001\u53D8\u66F4\u5BA1\u6279\u3002\n      will_bid: { label: '\u662F\u5426\u6295\u6807', help: '\u6211\u65B9\u662F\u5426\u6253\u7B97\u6295\u6807\u3002\u7559\u7A7A\u8868\u793A\u5C1A\u672A\u51B3\u5B9A\u3002' },\n      controllability: { label: '\u53EF\u63A7\u6027', options: { high: '\u9AD8', medium: '\u4E2D', low: '\u4F4E' } },\n      priority: { label: '\u4F18\u5148\u7EA7', options: { high: '\u9AD8', medium: '\u4E2D', low: '\u4F4E' } },\n      deal_level: { label: '\u5546\u673A\u7EA7\u522B', options: { strategic: '\u6218\u7565\u7EA7', key: '\u91CD\u70B9', standard: '\u666E\u901A' } },\n      is_subcontracted: { label: '\u6D89\u53CA\u5206\u5305' },\n      subcontracting_note: { label: '\u5206\u5305\u8BF4\u660E' },\n      customer_initiation_date: { label: '\u5BA2\u6237\u7ACB\u9879\u65E5\u671F' },\n      expected_tender_date: { label: '\u9884\u8BA1\u62DB\u6807\u65E5\u671F' },\n      expected_signing_date: { label: '\u9884\u8BA1\u7B7E\u7EA6\u65E5\u671F' },\n      expected_tender_amount: { label: '\u9884\u8BA1\u62DB\u6807\u91D1\u989D' },\n      expected_signing_amount: { label: '\u9884\u8BA1\u7B7E\u7EA6\u91D1\u989D' },\n      business_line: {\n        label: '\u4E1A\u52A1\u7EBF',\n        options: { product: '\u4EA7\u54C1', services: '\u4E13\u4E1A\u670D\u52A1', consulting: '\u54A8\u8BE2\u670D\u52A1', support: '\u8FD0\u7EF4\u652F\u6301', other: '\u5176\u4ED6' },\n      },\n      customer_background: { label: '\u5BA2\u6237\u7B80\u4ECB' },\n      project_background: { label: '\u9879\u76EE\u80CC\u666F' },\n      risk_analysis: { label: '\u98CE\u9669\u5206\u6790' },\n      payment_terms: { label: '\u4ED8\u6B3E\u6761\u6B3E' },\n      requested_status: { label: '\u7533\u8BF7\u53D8\u66F4\u72B6\u6001', options: { closed_won: '\u8D62\u5355', closed_lost: '\u4E22\u5355' } },\n      status_change_approval_status: {\n        label: '\u72B6\u6001\u53D8\u66F4\u5BA1\u6279',\n        options: { not_required: '\u65E0\u9700\u5BA1\u6279', pending: '\u5BA1\u6279\u4E2D', approved: '\u5DF2\u6279\u51C6', rejected: '\u5DF2\u9A73\u56DE' },\n      },\n      // REQ-0006 \u7B2C 11 \u6B65 \u2014 \u7ACB\u9879\u5BA1\u6279\u3002\n      qualification_requested: {\n        label: '\u7533\u8BF7\u7ACB\u9879\u5BA1\u6279',\n        help: '\u52FE\u9009\u540E\u63D0\u4EA4\u7ACB\u9879\u5BA1\u6279\u3002\u5BA1\u6279\u88AB\u9A73\u56DE\u65F6\u4F1A\u81EA\u52A8\u53D6\u6D88\u52FE\u9009\uFF1B\u518D\u6B21\u52FE\u9009\u5373\u53EF\u91CD\u65B0\u7533\u8BF7\u3002',\n      },\n      qualification_approval_status: {\n        label: '\u7ACB\u9879\u5BA1\u6279',\n        options: { not_required: '\u65E0\u9700\u5BA1\u6279', pending: '\u5BA1\u6279\u4E2D', approved: '\u5DF2\u6279\u51C6', rejected: '\u5DF2\u9A73\u56DE' },\n      },\n    },\n    _views: {\n      tender_this_quarter: {\n        label: '\u672C\u5B63\u5EA6\u9884\u8BA1\u62DB\u6807',\n        emptyState: {\n          title: '\u672C\u5B63\u5EA6\u6682\u65E0\u9884\u8BA1\u62DB\u6807\u7684\u5546\u673A',\n          message: '\u672C\u6807\u7B7E\u9875\u5217\u51FA\u5BA2\u6237\u4FA7\u9884\u8BA1\u62DB\u6807\u65E5\u671F\u843D\u5728\u5F53\u524D\u5B63\u5EA6\u5185\u7684\u8FDB\u884C\u4E2D\u5546\u673A\u3002\u5728\u5546\u673A\u4E0A\u586B\u5199\u201C\u9884\u8BA1\u62DB\u6807\u65E5\u671F\u201D\u540E\uFF0C\u5B83\u5C31\u4F1A\u51FA\u73B0\u5728\u8FD9\u91CC\u3002',\n        },\n      },\n      open_opportunities: { label: '\u8FDB\u884C\u4E2D\u5546\u673A' },\n      all_opportunities: { label: '\u5168\u90E8\u5546\u673A' },\n      pipeline_kanban: { label: '\u9500\u552E\u6D41\u6C34\u7EBF' },\n      close_date_calendar: { label: '\u9884\u6D4B\u65E5\u5386' },\n      deal_timeline: { label: '\u5546\u673A\u65F6\u95F4\u7EBF' },\n      deal_gallery: { label: '\u5546\u673A\u5361\u7247' },\n      my_open_deals: { label: '\u6211\u7684\u8FDB\u884C\u4E2D\u5546\u673A' },\n      stale_opportunities: { label: '\u26A0\uFE0F \u505C\u6EDE\u5546\u673A \u00B7 \u6309\u9636\u6BB5\u505C\u7559\u65F6\u95F4\u6392\u5E8F' },\n      closing_this_quarter: {\n        label: '\u672C\u5B63\u5EA6\u5F85\u6210\u4EA4\u5546\u673A',\n        emptyState: {\n          title: '\u672C\u5B63\u5EA6\u6682\u65E0\u5F85\u6210\u4EA4\u5546\u673A',\n          message: '\u672C\u6807\u7B7E\u9875\u5217\u51FA\u9884\u8BA1\u6210\u4EA4\u65E5\u671F\u843D\u5728\u5F53\u524D\u5B63\u5EA6\u5185\u3001\u4E14\u5904\u4E8E\u627F\u8BFA\uFF08Commit\uFF09\u6216\u6700\u4F73\u53EF\u80FD\uFF08Best Case\uFF09\u7684\u8FDB\u884C\u4E2D\u5546\u673A\u3002\u5F53\u524D\u6CA1\u6709\u7B26\u5408\u6761\u4EF6\u7684\u8BB0\u5F55\u2014\u2014\u9884\u8BA1\u6210\u4EA4\u65E5\u671F\u66F4\u665A\u7684\u5546\u673A\u8BF7\u89C1\u201C\u8FDB\u884C\u4E2D\u5546\u673A\u201D\u6807\u7B7E\u9875\u3002',\n        },\n      },\n    },\n    _sections: {\n      // Object-level section keys (opportunity.object.ts), used by record forms\n      // and by the detail page, whose sections reference these groups (#1452)\n      crm_forecast: { label: '\u9636\u6BB5\u4E0E\u9884\u6D4B' },\n      basic: { label: '\u57FA\u672C\u4FE1\u606F' },\n      financials: { label: '\u8D22\u52A1\u4FE1\u606F' },\n      sales_process: { label: '\u9500\u552E\u6D41\u7A0B' },\n      classification: { label: '\u5206\u7C7B' },\n      campaign: { label: '\u8425\u9500\u6D3B\u52A8' },\n      notes: { label: '\u5907\u6CE8\u4E0E\u4E0B\u4E00\u6B65' },\n      qualification: { label: '\u8D44\u683C\u8BC4\u4F30' },\n      narrative: { label: '\u5546\u673A\u53D9\u8FF0' },\n      // opportunity.view.ts \u8868\u5355\u533A\u5757\u540D\u79F0 (#1100)\n      overview: { label: '\u6982\u89C8' },\n      forecast: { label: '\u9884\u6D4B' },\n      sales_strategy: { label: '\u9500\u552E\u7B56\u7565' },\n      win_loss: { label: '\u8D62\u5355/\u8F93\u5355' },\n    },\n    _actions: {\n      ...activityActions,\n      clone_opportunity: {\n        label: '\u514B\u9686\u5546\u673A',\n        successMessage: '\u5546\u673A\u514B\u9686\u6210\u529F\uFF01',\n      },\n      generate_quote: {\n        label: '\u751F\u6210\u62A5\u4EF7\u5355',\n        successMessage: '\u5DF2\u6839\u636E\u5546\u673A\u521B\u5EFA\u62A5\u4EF7\u5355\uFF01',\n      },\n      mass_update_stage: {\n        label: '\u66F4\u65B0\u9636\u6BB5',\n        successMessage: '\u5546\u673A\u9636\u6BB5\u5DF2\u66F4\u65B0\uFF01',\n        params: {\n          stage: {\n            label: '\u65B0\u9636\u6BB5',\n            options: {\n              prospecting: '\u5BFB\u627E\u5BA2\u6237', qualification: '\u8D44\u683C\u5BA1\u67E5',\n              needs_analysis: '\u9700\u6C42\u5206\u6790', proposal: '\u63D0\u6848',\n              negotiation: '\u8C08\u5224', closed_won: '\u6210\u4EA4', closed_lost: '\u5931\u8D25',\n            },\n          },\n        },\n      },\n    },\n  },\n  crm_opportunity_line_item: {\n    _validations: {\n      unit_price_positive: {\n        message: '\u9500\u552E\u4EF7\u683C\u4E0D\u80FD\u4E3A\u8D1F\u6570',\n      },\n    },\n    label: '\u5546\u673A\u4EA7\u54C1\u660E\u7EC6',\n    pluralLabel: '\u5546\u673A\u4EA7\u54C1\u660E\u7EC6',\n    description: '\u5546\u673A\u4E0B\u6309\u4EA7\u54C1\u62C6\u5206\u7684\u62A5\u4EF7\u884C',\n    fields: {\n      crm_opportunity: { label: '\u5173\u8054\u5546\u673A' },\n      crm_product: { label: '\u4EA7\u54C1' },\n      description: { label: '\u63CF\u8FF0' },\n      quantity: { label: '\u6570\u91CF' },\n      list_price: { label: '\u6807\u4EF7', help: '\u81EA\u52A8\u53D6\u81EA\u4EA7\u54C1\u7684\u76EE\u5F55\u4EF7' },\n      unit_price: { label: '\u9500\u552E\u5355\u4EF7', help: '\u534F\u5546\u540E\u7684\u5355\u4EF7\uFF08\u53EF\u4E0E\u76EE\u5F55\u4EF7\u4E0D\u540C\uFF09' },\n      discount: { label: '\u6298\u6263\uFF08%\uFF09' },\n      total_price: { label: '\u603B\u8BA1' },\n      line_number: { label: '\u884C\u53F7' },\n    },\n    _sections: {\n      basic: { label: '\u660E\u7EC6\u884C' },\n      pricing: { label: '\u4EF7\u683C' },\n    },\n  },\n  crm_forecast: {\n    _validations: {\n      period_end_after_start: {\n        message: '\u5468\u671F\u7ED3\u675F\u5FC5\u987B\u665A\u4E8E\u5468\u671F\u5F00\u59CB\u3002',\n      },\n      period_end_matches_calendar_period: {\n        message: '\u5468\u671F\u7ED3\u675F\u5FC5\u987B\u662F\u8BE5\u5468\u671F\u7684\u6700\u540E\u4E00\u5929\u2014\u2014\u4F8B\u5982\u4EE5 2026-07-01 \u5F00\u59CB\u7684\u5B63\u5EA6\u5BF9\u5E94 2026-09-30\uFF0C2026 \u5E74 8 \u6708\u5BF9\u5E94 2026-08-31\u3002',\n      },\n      period_start_first_of_period: {\n        message: '\u5468\u671F\u5F00\u59CB\u5FC5\u987B\u662F\u8BE5\u5468\u671F\u7684\u7B2C\u4E00\u5929\u2014\u2014\u4F8B\u5982 2026 \u5E74 8 \u6708\u5BF9\u5E94 2026-08-01\u3002',\n      },\n      quarter_starts_on_quarter_boundary: {\n        message: '\u5B63\u5EA6\u9884\u6D4B\u5FC5\u987B\u4ECE\u5B63\u5EA6\u8FB9\u754C\u5F00\u59CB\u2014\u20141 \u6708 1 \u65E5\u30014 \u6708 1 \u65E5\u30017 \u6708 1 \u65E5\u6216 10 \u6708 1 \u65E5\u3002',\n      },\n      snapshot_amounts_non_negative: {\n        message: '\u5FEB\u7167\u91D1\u989D\u4E0D\u80FD\u4E3A\u8D1F\u6570\u3002',\n      },\n    },\n    label: '\u9500\u552E\u9884\u6D4B',\n    pluralLabel: '\u9500\u552E\u9884\u6D4B',\n    description: '\u6309\u9500\u552E\u8D1F\u8D23\u4EBA\u5B9A\u671F\u8BB0\u5F55\u7684\u7BA1\u9053\u5FEB\u7167\uFF0C\u7528\u4E8E\u6536\u5165\u9884\u6D4B',\n    fields: {\n      owner_id: { label: '\u8D1F\u8D23\u4EBA' },\n      period: { label: '\u5468\u671F', options: { month: '\u6708\u5EA6', quarter: '\u5B63\u5EA6' } },\n      period_start: {\n        label: '\u5468\u671F\u8D77\u59CB',\n        help: '\u5FC5\u987B\u662F\u6240\u5728\u5468\u671F\u7684\u7B2C\u4E00\u5929\u2014\u2014\u4F8B\u5982 2026 \u5E74 8 \u6708\u5BF9\u5E94 2026-08-01\u3002\u5B63\u5EA6\u9884\u6D4B\u8FD8\u5FC5\u987B\u843D\u5728\u5B63\u5EA6\u8FB9\u754C\u4E0A\uFF1A1 \u6708 1 \u65E5\u30014 \u6708 1 \u65E5\u30017 \u6708 1 \u65E5\u6216 10 \u6708 1 \u65E5\u3002',\n      },\n      period_end: {\n        label: '\u5468\u671F\u622A\u6B62',\n        help: '\u901A\u5E38\u6839\u636E\"\u5468\u671F\"\u548C\"\u5468\u671F\u8D77\u59CB\"\u81EA\u52A8\u63A8\u7B97\u3002\u5982\u624B\u52A8\u586B\u5199\uFF0C\u5FC5\u987B\u662F\u8BE5\u5468\u671F\u7684\u6700\u540E\u4E00\u5929\u2014\u2014\u4F8B\u5982\u8D77\u59CB\u4E3A 2026-07-01 \u7684\u5B63\u5EA6\u5BF9\u5E94 2026-09-30\uFF0C2026 \u5E74 8 \u6708\u5BF9\u5E94 2026-08-31\u3002',\n      },\n      period_label: { label: '\u5468\u671F\u6807\u7B7E', help: '\u6613\u8BFB\u7684\u5468\u671F\u6807\u7B7E\uFF0C\u4F8B\u5982\"2026 \u5E74\u7B2C\u4E09\u5B63\u5EA6\"\u6216\"2026 \u5E74 8 \u6708\"\u3002' },\n      snapshot_date: { label: '\u5FEB\u7167\u65E5\u671F', help: '\u672C\u6B21\u5FEB\u7167\u7684\u91C7\u96C6\u65E5\u671F\u3002' },\n      source: {\n        label: '\u6765\u6E90',\n        options: { scheduled: '\u5B9A\u65F6\u5FEB\u7167', ai: 'AI \u6280\u80FD', manual: '\u624B\u5DE5\u5F55\u5165' },\n      },\n      quota: { label: '\u914D\u989D' },\n      pipeline_amount: { label: '\u7BA1\u9053\u91D1\u989D', help: '\u672C\u5468\u671F\u5185\u6240\u6709\u9884\u8BA1\u7ED3\u5355\u7684\u8FDB\u884C\u4E2D\u5546\u673A\u91D1\u989D\u5408\u8BA1\uFF08\u4E0D\u9650\u9636\u6BB5\uFF09\u3002' },\n      best_case_amount: { label: '\u6700\u4F73\u60C5\u51B5', help: '\u9884\u6D4B\u7C7B\u522B\u4E3A\"\u6700\u4F73\u60C5\u51B5\"\u6216\"\u627F\u8BFA\"\u7684\u8FDB\u884C\u4E2D\u5546\u673A\u3002' },\n      commit_amount: { label: '\u627F\u8BFA\u91D1\u989D', help: '\u9884\u6D4B\u7C7B\u522B\u4E3A\"\u627F\u8BFA\"\u7684\u8FDB\u884C\u4E2D\u5546\u673A\uFF08\u8D1F\u8D23\u4EBA\u5DF2\u627F\u8BFA\uFF09\u3002' },\n      closed_amount: { label: '\u5DF2\u6210\u4EA4\u91D1\u989D', help: '\u672C\u5468\u671F\u5185\u5DF2\u8D62\u5355\u7684\u91D1\u989D\u3002' },\n      expected_amount: { label: '\u9884\u671F\u91D1\u989D', help: '\u5DF2\u6210\u4EA4 + \u627F\u8BFA\u2014\u2014\u8D1F\u8D23\u4EBA\u5408\u7406\u9884\u671F\u80FD\u62FF\u4E0B\u7684\u91D1\u989D\u3002' },\n      attainment_pct: { label: '\u8FBE\u6210\u7387\uFF08%\uFF09', help: '\u5DF2\u6210\u4EA4 \u00F7 \u914D\u989D \u00D7 100\u3002\u914D\u989D\u4E3A\u6B63\u6570\u4E4B\u524D\u663E\u793A 0%\u3002' },\n      coverage_ratio: { label: '\u8986\u76D6\u500D\u6570', help: '\u7BA1\u9053\u91D1\u989D \u00F7\uFF08\u914D\u989D \u2212 \u5DF2\u6210\u4EA4\uFF09\u2014\u2014\u5224\u65AD\u5269\u4F59\u7F3A\u53E3\u662F\u5426\u6709\u8DB3\u591F\u7BA1\u9053\u8986\u76D6\u3002\u914D\u989D\u5DF2\u8FBE\u6210\u65F6\u663E\u793A 0\u3002' },\n      notes: { label: '\u5907\u6CE8' },\n      display_title: { label: '\u663E\u793A\u540D\u79F0' },\n      seed_key: { label: '\u79CD\u5B50\u6807\u8BC6', help: '\u6F14\u793A\u6570\u636E\u6807\u8BC6\u3002\u4EC5\u7531\u79CD\u5B50\u52A0\u8F7D\u5668\u5199\u5165\uFF1B\u771F\u5B9E\u5FEB\u7167\u4E0A\u59CB\u7EC8\u4E3A\u7A7A\u3002' },\n    },\n    _views: {\n      all_forecasts: { label: '\u5168\u90E8\u9884\u6D4B' },\n      this_quarter_forecasts: {\n        label: '\u672C\u5B63\u5EA6',\n        emptyState: {\n          title: '\u672C\u5B63\u5EA6\u5C1A\u65E0\u5FEB\u7167',\n          message: '\u5B63\u5EA6\u5FEB\u7167\u7531\u6BCF\u665A\u7684\u9884\u6D4B\u626B\u63CF\u4EFB\u52A1\u5199\u5165\u3002\u5728\u5B83\u4E3A\u5F53\u524D\u5B63\u5EA6\u9996\u6B21\u8DD1\u5B8C\u4E4B\u524D\uFF0C\u672C\u89C6\u56FE\u4E3A\u7A7A\u2014\u2014\u5DF2\u7ED3\u675F\u7684\u5B63\u5EA6\u8BF7\u89C1\u201C\u5168\u90E8\u201D\u6807\u7B7E\u9875\u3002',\n        },\n      },\n      my_forecast: { label: '\u6211\u7684\u9884\u6D4B' },\n    },\n    _sections: {\n      basic: { label: '\u5FEB\u7167' },\n      amounts: { label: '\u91D1\u989D' },\n      meta: { label: '\u6765\u6E90' },\n      // forecast.view.ts \u8868\u5355\u533A\u5757\u540D\u79F0 (#1100)\n      snapshot: { label: '\u5FEB\u7167' },\n      notes: { label: '\u5907\u6CE8' },\n    },\n  },\n};\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/sales/translations/zh-CN/objects.commerce.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/sales/translations/zh-CN\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/sales/translations/zh-CN/objects.commerce.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport type { ObjectTranslationData } from '@objectstack/spec/system';\n\n/**\n * \u7B80\u4F53\u4E2D\u6587 (zh-CN) \u2014 `objects` translations for the COMMERCE family:\n * what gets sold and on what paper \u2014 quotes, contracts, products.\n *\n * Roster: `crm_quote`, `crm_quote_line_item`, `crm_contract`, `crm_product`.\n *\n * SPLIT AXIS (#1311): translation NAMESPACE first, then CRM DOMAIN FAMILY.\n * Everything that is not `objects` lives in `./app.ts`; `objects` \u2014 69-78% of\n * every bundle \u2014 is one file per CRM domain family, and a detail object\n * follows its master. A new row goes in the file for ITS family, never in\n * whichever file is already open: that is how one file re-grows past the 70%\n * advisory band `pnpm hygiene` prints. Full rule and rationale:\n * `src/sales/translations/zh-CN.ts`.\n */\nexport const commerce: Record<string, ObjectTranslationData> = {\n  crm_quote: {\n    _validations: {\n      discount_within_ceiling: {\n        message: '\u6298\u6263\u4E0D\u80FD\u8D85\u8FC7 60%',\n      },\n      expiration_after_quote: {\n        message: '\u5931\u6548\u65E5\u671F\u5FC5\u987B\u665A\u4E8E\u62A5\u4EF7\u65E5\u671F',\n      },\n      quote_status_progression: {\n        message: '\u65E0\u6548\u7684\u62A5\u4EF7\u5355\u72B6\u6001\u6D41\u8F6C',\n      },\n    },\n    label: '\u62A5\u4EF7\u5355',\n    pluralLabel: '\u62A5\u4EF7\u5355',\n    description: '\u53D1\u9001\u7ED9\u5BA2\u6237\u7684\u4EF7\u683C\u62A5\u4EF7',\n    fields: {\n      quote_number: { label: '\u62A5\u4EF7\u5355\u7F16\u53F7' },\n      name: { label: '\u62A5\u4EF7\u540D\u79F0' },\n      crm_account: { label: '\u6240\u5C5E\u5BA2\u6237' },\n      crm_opportunity: { label: '\u5173\u8054\u5546\u673A' },\n      status: {\n        label: '\u72B6\u6001',\n        options: {\n          draft: '\u8349\u7A3F', in_review: '\u5BA1\u6838\u4E2D', presented: '\u5DF2\u63D0\u4EA4', accepted: '\u5DF2\u63A5\u53D7',\n          rejected: '\u5DF2\u62D2\u7EDD', expired: '\u5DF2\u8FC7\u671F',\n        },\n      },\n      total_price: { label: '\u603B\u91D1\u989D' },\n      discount: { label: '\u6298\u6263 (%)' },\n      expiration_date: { label: '\u5230\u671F\u65E5\u671F' },\n      description: { label: '\u63CF\u8FF0' },\n      crm_contact: {\n        label: '\u8054\u7CFB\u4EBA',\n        help: '\u62A5\u4EF7\u8FDB\u5165\u300C\u5DF2\u63D0\u4EA4\u300D\u6216\u300C\u5DF2\u63A5\u53D7\u300D\u540E\u5FC5\u586B \u2014\u2014 \u8D77\u8349\u7684\u5408\u540C\u4ECE\u8FD9\u91CC\u53D6\u4E3B\u8981\u8054\u7CFB\u4EBA\u3002',\n      },\n      owner_id: { label: '\u62A5\u4EF7\u8D1F\u8D23\u4EBA' },\n      quote_date: { label: '\u62A5\u4EF7\u65E5\u671F' },\n      subtotal: { label: '\u5C0F\u8BA1' },\n      discount_amount: { label: '\u6298\u6263\u91D1\u989D' },\n      tax: { label: '\u7A0E\u989D' },\n      shipping_handling: { label: '\u8FD0\u8D39\u53CA\u624B\u7EED\u8D39' },\n      payment_terms: {\n        label: '\u4ED8\u6B3E\u6761\u6B3E',\n        options: {\n          net_15: '15 \u5929\u8D26\u671F', net_30: '30 \u5929\u8D26\u671F', net_60: '60 \u5929\u8D26\u671F',\n          net_90: '90 \u5929\u8D26\u671F', due_on_receipt: '\u8D27\u5230\u4ED8\u6B3E',\n        },\n      },\n      shipping_terms: { label: '\u8FD0\u8F93\u6761\u6B3E' },\n      billing_address: { label: '\u8D26\u5355\u5730\u5740' },\n      shipping_address: { label: '\u6536\u8D27\u5730\u5740' },\n      internal_notes: { label: '\u5185\u90E8\u5907\u6CE8' },\n      display_title: { label: '\u663E\u793A\u540D\u79F0' },\n    },\n    _views: {\n      all_quotes: { label: '\u5168\u90E8\u62A5\u4EF7\u5355' },\n      quote_pipeline: { label: '\u62A5\u4EF7\u6D41\u6C34\u7EBF' },\n      quote_calendar: { label: '\u62A5\u4EF7\u65E5\u5386' },\n    },\n    _sections: {\n      basic: { label: '\u62A5\u4EF7\u4FE1\u606F' },\n      pricing: { label: '\u4EF7\u683C' },\n      terms: { label: '\u6761\u6B3E\u4E0E\u6709\u6548\u671F' },\n      address: { label: '\u5730\u5740' },\n      system: { label: '\u7CFB\u7EDF' },\n      // quote.view.ts \u8868\u5355\u533A\u5757\u540D\u79F0 (#1100)\n      quote: { label: '\u62A5\u4EF7\u5355' },\n      totals: { label: '\u5408\u8BA1' },\n      quote_terms: { label: '\u6761\u6B3E' },\n      addresses_and_notes: { label: '\u5730\u5740\u4E0E\u5907\u6CE8' },\n    },\n  },\n  crm_quote_line_item: {\n    _validations: {\n      discount_within_ceiling: {\n        message: '\u884C\u6298\u6263\u4E0D\u80FD\u8D85\u8FC7 60%',\n      },\n      unit_price_positive: {\n        message: '\u9500\u552E\u4EF7\u683C\u4E0D\u80FD\u4E3A\u8D1F\u6570',\n      },\n    },\n    label: '\u62A5\u4EF7\u5355\u660E\u7EC6',\n    pluralLabel: '\u62A5\u4EF7\u5355\u660E\u7EC6',\n    description: '\u62A5\u4EF7\u5355\u4E0B\u6309\u4EA7\u54C1\u62C6\u5206\u7684\u62A5\u4EF7\u884C',\n    fields: {\n      crm_quote: { label: '\u5173\u8054\u62A5\u4EF7\u5355' },\n      crm_product: { label: '\u4EA7\u54C1' },\n      description: { label: '\u63CF\u8FF0' },\n      quantity: { label: '\u6570\u91CF' },\n      list_price: { label: '\u6807\u4EF7' },\n      unit_price: { label: '\u9500\u552E\u5355\u4EF7' },\n      discount: { label: '\u6298\u6263\uFF08%\uFF09' },\n      subtotal: { label: '\u5C0F\u8BA1' },\n      total_price: { label: '\u603B\u8BA1' },\n      line_number: { label: '\u884C\u53F7' },\n    },\n    _sections: {\n      basic: { label: '\u660E\u7EC6\u884C' },\n      pricing: { label: '\u4EF7\u683C' },\n    },\n  },\n  crm_contract: {\n    _validations: {\n      end_after_start: {\n        message: '\u7ED3\u675F\u65E5\u671F\u5FC5\u987B\u665A\u4E8E\u5F00\u59CB\u65E5\u671F',\n      },\n      contract_status_progression: {\n        message: '\u65E0\u6548\u7684\u5408\u540C\u72B6\u6001\u6D41\u8F6C',\n      },\n    },\n    label: '\u5408\u540C',\n    pluralLabel: '\u5408\u540C',\n    description: '\u4E0E\u5BA2\u6237\u7B7E\u7F72\u7684\u6CD5\u5F8B\u5408\u540C',\n    fields: {\n      contract_number: { label: '\u5408\u540C\u7F16\u53F7' },\n      crm_account: { label: '\u6240\u5C5E\u5BA2\u6237' },\n      status: {\n        label: '\u72B6\u6001',\n        options: {\n          draft: '\u8349\u7A3F', in_approval: '\u5BA1\u6279\u4E2D', activated: '\u5DF2\u6FC0\u6D3B',\n          expired: '\u5DF2\u8FC7\u671F', terminated: '\u5DF2\u7EC8\u6B62',\n        },\n      },\n      start_date: { label: '\u5F00\u59CB\u65E5\u671F' },\n      end_date: { label: '\u7ED3\u675F\u65E5\u671F' },\n      contract_value: { label: '\u5408\u540C\u91D1\u989D' },\n      description: { label: '\u63CF\u8FF0' },\n      crm_contact: { label: '\u4E3B\u8981\u8054\u7CFB\u4EBA' },\n      crm_opportunity: { label: '\u5173\u8054\u5546\u673A' },\n      owner_id: { label: '\u5408\u540C\u8D1F\u8D23\u4EBA' },\n      contract_term_months: { label: '\u5408\u540C\u671F\u9650\uFF08\u6708\uFF09' },\n      billing_frequency: {\n        label: '\u8BA1\u8D39\u5468\u671F',\n        options: { monthly: '\u6309\u6708', quarterly: '\u6309\u5B63\u5EA6', annually: '\u6309\u5E74', one_time: '\u4E00\u6B21\u6027' },\n      },\n      payment_terms: {\n        label: '\u4ED8\u6B3E\u6761\u6B3E',\n        options: {\n          net_15: '15 \u5929\u8D26\u671F', net_30: '30 \u5929\u8D26\u671F', net_60: '60 \u5929\u8D26\u671F',\n          net_90: '90 \u5929\u8D26\u671F', due_on_receipt: '\u8D27\u5230\u4ED8\u6B3E',\n        },\n      },\n      auto_renewal: { label: '\u81EA\u52A8\u7EED\u7EA6' },\n      renewal_notice_days: { label: '\u7EED\u7EA6\u901A\u77E5\uFF08\u5929\uFF09' },\n      contract_type: {\n        label: '\u5408\u540C\u7C7B\u578B',\n        options: {\n          subscription: '\u8BA2\u9605\u5408\u540C', service: '\u670D\u52A1\u534F\u8BAE', license: '\u6388\u6743\u8BB8\u53EF',\n          partnership: '\u5408\u4F5C\u534F\u8BAE', nda: '\u4FDD\u5BC6\u534F\u8BAE', msa: '\u4E3B\u670D\u52A1\u534F\u8BAE',\n        },\n      },\n      signed_date: { label: '\u7B7E\u7F72\u65E5\u671F' },\n      signed_by: { label: '\u7B7E\u7F72\u4EBA' },\n      document_url: { label: '\u5408\u540C\u6587\u6863' },\n      special_terms: { label: '\u7279\u6B8A\u6761\u6B3E' },\n      billing_address: { label: '\u8D26\u5355\u5730\u5740' },\n    },\n    _views: {\n      all_contracts: { label: '\u5168\u90E8\u5408\u540C' },\n      renewal_calendar: { label: '\u7EED\u7EA6\u65E5\u5386' },\n      contract_gantt: { label: '\u5408\u540C\u6761\u6B3E' },\n      contract_timeline: { label: '\u5408\u540C\u65F6\u95F4\u7EBF' },\n    },\n    _sections: {\n      basic: { label: '\u5408\u540C\u4FE1\u606F' },\n      parties: { label: '\u7B7E\u7EA6\u65B9' },\n      terms: { label: '\u6761\u6B3E\u4E0E\u65E5\u671F' },\n      value: { label: '\u5408\u540C\u91D1\u989D' },\n      status: { label: '\u72B6\u6001\u4E0E\u5BA1\u6279' },\n      renewal: { label: '\u7EED\u7EA6' },\n      // contract.view.ts \u8868\u5355\u533A\u5757\u540D\u79F0 (#1100)\n      contract_terms: { label: '\u6761\u6B3E' },\n      signing_and_documents: { label: '\u7B7E\u7F72\u4E0E\u6587\u4EF6' },\n      notes: { label: '\u5907\u6CE8' },\n    },\n  },\n  crm_product: {\n    _validations: {\n      cost_less_than_price: {\n        message: '\u6210\u672C\u5E94\u4F4E\u4E8E\u6807\u4EF7',\n      },\n      price_positive: {\n        message: '\u6807\u4EF7\u5FC5\u987B\u4E3A\u6B63\u6570',\n      },\n    },\n    label: '\u4EA7\u54C1',\n    pluralLabel: '\u4EA7\u54C1',\n    description: '\u516C\u53F8\u63D0\u4F9B\u7684\u4EA7\u54C1\u4E0E\u670D\u52A1',\n    fields: {\n      product_code: { label: '\u4EA7\u54C1\u4EE3\u7801' },\n      name: { label: '\u4EA7\u54C1\u540D\u79F0' },\n      category: {\n        label: '\u4EA7\u54C1\u7C7B\u522B',\n        options: {\n          software: '\u8F6F\u4EF6', hardware: '\u786C\u4EF6', service: '\u670D\u52A1',\n          subscription: '\u8BA2\u9605', support: '\u652F\u6301\u670D\u52A1',\n        },\n      },\n      cost: { label: '\u6210\u672C' },\n      is_active: { label: '\u662F\u5426\u542F\u7528' },\n      description: { label: '\u63CF\u8FF0' },\n      family: {\n        label: '\u4EA7\u54C1\u7CFB\u5217',\n        options: {\n          enterprise: '\u4F01\u4E1A\u7EA7\u65B9\u6848', smb: '\u4E2D\u5C0F\u4F01\u4E1A\u65B9\u6848',\n          services: '\u4E13\u4E1A\u670D\u52A1', cloud: '\u4E91\u670D\u52A1',\n        },\n      },\n      list_price: { label: '\u6807\u4EF7' },\n      sku: { label: 'SKU' },\n      product_manager: { label: '\u4EA7\u54C1\u7ECF\u7406' },\n      image: { label: '\u4EA7\u54C1\u56FE\u7247' },\n      datasheet: { label: '\u89C4\u683C\u4E66' },\n      display_title: { label: '\u663E\u793A\u540D\u79F0' },\n    },\n    _views: {\n      all_products: { label: '\u5168\u90E8\u4EA7\u54C1' },\n      product_catalog: { label: '\u4EA7\u54C1\u76EE\u5F55' },\n    },\n    _sections: {\n      basic: { label: '\u4EA7\u54C1\u4FE1\u606F' },\n      pricing: { label: '\u4EF7\u683C' },\n      metadata: { label: '\u8D44\u6E90' },\n      // product.view.ts \u8868\u5355\u533A\u5757\u540D\u79F0 (#1100)\n      product_info: { label: '\u4EA7\u54C1\u4FE1\u606F' },\n      pricing_info: { label: '\u5B9A\u4EF7' },\n      media: { label: '\u5A92\u4F53' },\n    },\n  },\n};\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/sales/translations/zh-CN/objects.service.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/sales/translations/zh-CN\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/sales/translations/zh-CN/objects.service.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport type { ObjectTranslationData } from '@objectstack/spec/system';\n\nimport { activityActions } from './_shared';\n\n/**\n * \u7B80\u4F53\u4E2D\u6587 (zh-CN) \u2014 `objects` translations for the SERVICE family:\n * post-sale support \u2014 cases and the knowledge that deflects them.\n *\n * Roster: `crm_case`, `crm_knowledge_article`, `crm_article_feedback`.\n *\n * SPLIT AXIS (#1311): translation NAMESPACE first, then CRM DOMAIN FAMILY.\n * Everything that is not `objects` lives in `./app.ts`; `objects` \u2014 69-78% of\n * every bundle \u2014 is one file per CRM domain family, and a detail object\n * follows its master. A new row goes in the file for ITS family, never in\n * whichever file is already open: that is how one file re-grows past the 70%\n * advisory band `pnpm hygiene` prints. Full rule and rationale:\n * `src/sales/translations/zh-CN.ts`.\n */\nexport const service: Record<string, ObjectTranslationData> = {\n  crm_case: {\n    _validations: {\n      resolution_required_for_closed: {\n        message: '\u5173\u95ED\u5DE5\u5355\u65F6\u5FC5\u987B\u586B\u5199\u89E3\u51B3\u65B9\u6848',\n      },\n      escalation_reason_required: {\n        message: '\u5347\u7EA7\u5DE5\u5355\u65F6\u5FC5\u987B\u586B\u5199\u5347\u7EA7\u539F\u56E0',\n      },\n      case_status_progression: {\n        message: '\u65E0\u6548\u7684\u72B6\u6001\u6D41\u8F6C',\n      },\n    },\n    label: '\u5DE5\u5355',\n    pluralLabel: '\u5DE5\u5355',\n    description: '\u5BA2\u6237\u652F\u6301\u5DE5\u5355\u4E0E\u670D\u52A1\u8BF7\u6C42',\n    fields: {\n      case_number: { label: '\u5DE5\u5355\u7F16\u53F7' },\n      subject: { label: '\u4E3B\u9898' },\n      description: { label: '\u63CF\u8FF0' },\n      crm_account: { label: '\u6240\u5C5E\u5BA2\u6237' },\n      crm_contact: { label: '\u8054\u7CFB\u4EBA' },\n      status: {\n        label: '\u72B6\u6001',\n        options: {\n          new: '\u65B0\u5EFA', in_progress: '\u5904\u7406\u4E2D',\n          waiting_customer: '\u7B49\u5F85\u5BA2\u6237\u56DE\u590D', waiting_support: '\u7B49\u5F85\u652F\u6301\u56DE\u590D',\n          escalated: '\u5DF2\u5347\u7EA7', resolved: '\u5DF2\u89E3\u51B3', closed: '\u5DF2\u5173\u95ED',\n        },\n      },\n      priority: {\n        // `critical` MUST NOT render \u7D27\u6025 \u2014 that word belongs to\n        // `crm_task.priority.urgent`, and the two vocabularies are different\n        // sets (case: low/medium/high/critical \u00B7 task: low/normal/high/urgent).\n        // When both rendered \u7D27\u6025 the screen showed one word for two values the\n        // model treats as distinct, which is how a case value ends up in a task\n        // predicate (`src/sales/views/task.view.ts` carries the tombstone of that\n        // crossing). Maintainer ruling 2026-08-31, #1342: case `critical` is\n        // \u4E25\u91CD, task `urgent` keeps \u7D27\u6025. en/es-ES/ja-JP already separate them\n        // (Critical/Urgent \u00B7 Cr\u00EDtica/Urgente \u00B7 \u91CD\u5927/\u7DCA\u6025); zh-CN was the outlier.\n        label: '\u4F18\u5148\u7EA7',\n        options: { low: '\u4F4E', medium: '\u4E2D', high: '\u9AD8', critical: '\u4E25\u91CD' },\n      },\n      type: {\n        label: '\u7C7B\u578B',\n        options: {\n          question: '\u54A8\u8BE2', problem: '\u6545\u969C', feature_request: '\u529F\u80FD\u9700\u6C42', bug: '\u7F3A\u9677',\n        },\n      },\n      owner_id: { label: '\u8D1F\u8D23\u4EBA' },\n      origin: {\n        label: '\u5DE5\u5355\u6765\u6E90',\n        options: { email: '\u90AE\u4EF6', phone: '\u7535\u8BDD', web: '\u7F51\u7AD9', chat: '\u5728\u7EBF\u5BA2\u670D', social_media: '\u793E\u4EA4\u5A92\u4F53' },\n      },\n      closed_date: { label: '\u5173\u95ED\u65E5\u671F' },\n      first_response_date: { label: '\u9996\u6B21\u54CD\u5E94\u65E5\u671F' },\n      resolution_time_hours: { label: '\u89E3\u51B3\u8017\u65F6\uFF08\u5C0F\u65F6\uFF09' },\n      sla_due_date: { label: 'SLA \u5230\u671F', help: '\u6309\u5DE5\u5355\u4F18\u5148\u7EA7\u4E0E\u6240\u5C5E\u5BA2\u6237\u7684\u5BA2\u6237\u5206\u5C42\u8BBE\u5B9A\uFF0C\u4EE5\u65E5\u5386\u5C0F\u65F6\u8BA1\uFF1A\u591C\u95F4\u3001\u5468\u672B\u4E0E\u8282\u5047\u65E5\u90FD\u8BA1\u5165\u3002' },\n      is_sla_violated: { label: 'SLA \u8FDD\u53CD' },\n      is_escalated: { label: '\u5DF2\u5347\u7EA7' },\n      escalation_reason: { label: '\u5347\u7EA7\u539F\u56E0' },\n      resolution: { label: '\u89E3\u51B3\u65B9\u6848' },\n      resolved_by_article: { label: '\u89E3\u51B3\u8BE5\u5DE5\u5355\u7684\u77E5\u8BC6\u6587\u7AE0', help: '\u89E3\u51B3\u6B64\u5DE5\u5355\u7684\u77E5\u8BC6\u5E93\u6587\u7AE0 \u2014\u2014 \u8F6C\u79FB\u7387\u7684\u7EDF\u8BA1\u53E3\u5F84\u3002' },\n      internal_notes: { label: '\u5185\u90E8\u5907\u6CE8', help: '\u5185\u90E8\u5907\u6CE8\uFF0C\u5BA2\u6237\u4E0D\u53EF\u89C1' },\n      is_closed: { label: '\u662F\u5426\u5173\u95ED' },\n      display_title: { label: '\u663E\u793A\u540D\u79F0' },\n      priority_rank: { label: '\u4F18\u5148\u7EA7\u6392\u5E8F' },\n      escalated_date: { label: '\u5347\u7EA7\u65E5\u671F' },\n    },\n    _views: {\n      all_cases: { label: '\u5168\u90E8\u5DE5\u5355' },\n      case_workflow: { label: '\u670D\u52A1\u6D41\u8F6C' },\n      sla_calendar: { label: 'SLA \u65E5\u5386' },\n      case_timeline: { label: '\u5DE5\u5355\u65F6\u95F4\u7EBF' },\n      unassigned_triage: {\n        label: '\u672A\u5206\u6D3E \u2014 \u5F85\u5206\u8BCA',\n        emptyState: {\n          title: '\u6CA1\u6709\u5F85\u5206\u8BCA\u7684\u5DE5\u5355',\n          message: '\u6240\u6709\u5DE5\u5355\u90FD\u6709\u8D1F\u8D23\u4EBA\u3002\u5F53\u5DE5\u5355\u5230\u8FBE\u65F6\u6CA1\u6709\u8D1F\u8D23\u4EBA\uFF0C\u5C31\u4F1A\u51FA\u73B0\u5728\u8FD9\u91CC \u2014\u2014 \u901A\u5E38\u662F\u5728\u65E0\u4EBA\u62C5\u4EFB\u300C\u5BA2\u670D\u4E13\u5458\u300D\u804C\u4F4D\u671F\u95F4\u63D0\u4EA4\u7684\u7F51\u9875\u8F6C\u5DE5\u5355\u3002',\n        },\n      },\n      escalated_cases: { label: '\u5DF2\u5347\u7EA7\u5DE5\u5355' },\n      my_open_cases: { label: '\u6211\u7684\u5F85\u5904\u7406\u5DE5\u5355' },\n      sla_at_risk: { label: '\u23F0 SLA \u98CE\u9669\u9884\u8B66' },\n    },\n    _actions: {\n      ...activityActions,\n      escalate_case: {\n        label: '\u5347\u7EA7\u5DE5\u5355',\n        confirmText: '\u6B64\u64CD\u4F5C\u4F1A\u5C06\u5DE5\u5355\u5347\u7EA7\u5230\u5347\u7EA7\u5904\u7406\u56E2\u961F\uFF0C\u662F\u5426\u7EE7\u7EED\uFF1F',\n        successMessage: '\u5DE5\u5355\u5347\u7EA7\u6210\u529F\uFF01',\n      },\n      close_case: {\n        label: '\u5173\u95ED\u5DE5\u5355',\n        confirmText: '\u786E\u5B9A\u8981\u5173\u95ED\u6B64\u5DE5\u5355\u5417\uFF1F',\n        successMessage: '\u5DE5\u5355\u5DF2\u6210\u529F\u5173\u95ED\uFF01',\n      },\n      claim_case: {\n        label: '\u8BA4\u9886\u5DE5\u5355',\n        successMessage: '\u5DE5\u5355\u5DF2\u8BA4\u9886\uFF0C\u73B0\u5728\u5F52\u4F60\u8D1F\u8D23\u3002',\n      },\n    },\n    _sections: {\n      // case.view.ts \u8868\u5355\u533A\u5757\u540D\u79F0 (#1100)\u3002\n      case: { label: '\u5DE5\u5355' },\n      how_can_we_help: { label: '\u6211\u4EEC\u80FD\u5E2E\u60A8\u4EC0\u4E48\uFF1F' },\n      // Object-level section keys (case.object.ts), used by record forms and\n      // by the detail page, whose sections reference these groups (#970)\n      basic: { label: '\u5DE5\u5355\u4FE1\u606F' },\n      origin: { label: '\u6765\u6E90\u4E0E\u8DEF\u7531' },\n      sla: { label: 'SLA \u4E0E\u4F18\u5148\u7EA7' },\n      resolution: { label: '\u89E3\u51B3\u65B9\u6848' },\n      escalation: { label: '\u5347\u7EA7' },\n      system: { label: '\u7CFB\u7EDF' },\n    },\n  },\n  crm_knowledge_article: {\n    _validations: {\n      published_requires_body: {\n        message: '\u6CA1\u6709\u6B63\u6587\u7684\u6587\u7AE0\u65E0\u6CD5\u53D1\u5E03\u3002',\n      },\n      published_requires_summary: {\n        message: '\u5DF2\u53D1\u5E03\u7684\u6587\u7AE0\u5E94\u586B\u5199\u6458\u8981\uFF0C\u4F9B\u641C\u7D22\u7ED3\u679C\u4E0E AI \u5F15\u7528\u4F7F\u7528\u3002',\n      },\n    },\n    label: '\u77E5\u8BC6\u6587\u7AE0',\n    pluralLabel: '\u77E5\u8BC6\u5E93',\n    description: '\u9762\u5411\u5BA2\u6237\u548C\u5750\u5E2D\u7684\u53EF\u590D\u7528\u95EE\u7B54\u4E0E\u64CD\u4F5C\u6307\u5357',\n    fields: {\n      article_number: { label: '\u6587\u7AE0\u7F16\u53F7' },\n      title: { label: '\u6807\u9898' },\n      summary: { label: '\u6458\u8981', help: '\u4E00\u6BB5\u8BDD\u6458\u8981\uFF0C\u663E\u793A\u5728\u641C\u7D22\u7ED3\u679C\u548C AI \u5F15\u7528\u4E2D\u3002' },\n      body: { label: '\u6B63\u6587', help: '\u6587\u7AE0\u6B63\u6587\uFF08Markdown\uFF09\u3002' },\n      category: {\n        label: '\u5206\u7C7B',\n        options: {\n          getting_started: '\u5165\u95E8\u6307\u5357', how_to: '\u64CD\u4F5C\u6307\u5357',\n          troubleshooting: '\u6545\u969C\u6392\u67E5', billing: '\u8D26\u52A1\u4E0E\u4EF7\u683C', api: 'API \u4E0E\u96C6\u6210',\n          release_notes: '\u7248\u672C\u8BF4\u660E',\n          policy: '\u653F\u7B56\u5236\u5EA6',\n        },\n      },\n      tags: {\n        label: '\u6807\u7B7E',\n        options: {\n          auth: '\u8EAB\u4EFD\u8BA4\u8BC1', sso: '\u5355\u70B9\u767B\u5F55', mobile: '\u79FB\u52A8\u7AEF', email: '\u90AE\u4EF6',\n          reports: '\u62A5\u8868', performance: '\u6027\u80FD', data_import: '\u6570\u636E\u5BFC\u5165', webhooks: 'Webhook',\n        },\n      },\n      status: {\n        label: '\u72B6\u6001',\n        options: { draft: '\u8349\u7A3F', in_review: '\u5BA1\u6838\u4E2D', published: '\u5DF2\u53D1\u5E03', archived: '\u5DF2\u5F52\u6863' },\n      },\n      audience: { label: '\u53D7\u4F17', options: { public: '\u516C\u5F00', internal: '\u4EC5\u5185\u90E8' }, help: '\u516C\u5F00\u6587\u7AE0\u5728\u5BA2\u6237\u95E8\u6237\u53EF\u89C1\uFF1B\u5185\u90E8\u6587\u7AE0\u4EC5\u5BA2\u670D\u53EF\u89C1\u3002' },\n      language: {\n        label: '\u8BED\u8A00',\n        options: { en: '\u82F1\u8BED', zh_cn: '\u7B80\u4F53\u4E2D\u6587', es_es: '\u897F\u73ED\u7259\u8BED', ja_jp: '\u65E5\u8BED' },\n      },\n      owner_id: { label: '\u8D1F\u8D23\u4EBA' },\n      related_to_case: { label: '\u6765\u6E90\u5DE5\u5355', help: '\u672C\u6587\u6240\u4F9D\u636E\u7684\u5DE5\u5355\uFF08\u53EF\u9009\uFF09\u3002' },\n      published_at: { label: '\u53D1\u5E03\u65F6\u95F4' },\n      last_reviewed_at: { label: '\u6700\u8FD1\u590D\u6838' },\n      helpful_count: { label: '\u6709\u7528', help: '\u7531 crm_article_feedback \u91CD\u65B0\u7EDF\u8BA1\u5F97\u51FA\uFF0C\u4E0D\u53EF\u624B\u5DE5\u586B\u5199\u3002' },\n      not_helpful_count: { label: '\u6CA1\u7528', help: '\u7531 crm_article_feedback \u91CD\u65B0\u7EDF\u8BA1\u5F97\u51FA\uFF0C\u4E0D\u53EF\u624B\u5DE5\u586B\u5199\u3002' },\n      display_title: { label: '\u663E\u793A\u540D\u79F0' },\n    },\n    _views: {\n      all_articles: { label: '\u5168\u90E8\u6587\u7AE0' },\n      published_articles: { label: '\u5DF2\u53D1\u5E03' },\n      my_drafts: { label: '\u6211\u7684\u8349\u7A3F' },\n    },\n    _sections: {\n      basic: { label: '\u6587\u7AE0\u4FE1\u606F' },\n      content: { label: '\u5185\u5BB9' },\n      taxonomy: { label: '\u5206\u7C7B' },\n      metrics: { label: '\u4E92\u52A8\u6570\u636E' },\n      engagement: { label: '\u4E92\u52A8\u6570\u636E' },\n      // knowledge_article.view.ts \u8868\u5355\u533A\u5757\u540D\u79F0 (#1100)\n      article: { label: '\u6587\u7AE0' },\n    },\n    _actions: {\n      mark_article_helpful: {\n        label: '\u6709\u7528',\n        successMessage: '\u5DF2\u8BB0\u5F55\u4E3A\u300C\u6709\u7528\u300D\uFF0C\u8C22\u8C22\u53CD\u9988\u3002',\n      },\n      mark_article_not_helpful: {\n        label: '\u6CA1\u7528',\n        successMessage: '\u5DF2\u8BB0\u5F55\u4E3A\u300C\u6CA1\u7528\u300D\uFF0C\u8C22\u8C22\u53CD\u9988\u3002',\n      },\n    },\n  },\n  crm_article_feedback: {\n    label: '\u6587\u7AE0\u53CD\u9988',\n    pluralLabel: '\u6587\u7AE0\u53CD\u9988',\n    description: '\u8BFB\u8005\u5BF9\u67D0\u7BC7\u77E5\u8BC6\u6587\u7AE0\u7684\u300C\u6709\u7528 / \u6CA1\u7528\u300D\u8BC4\u4EF7',\n    fields: {\n      feedback_number: { label: '\u53CD\u9988\u7F16\u53F7' },\n      owner_id: { label: '\u8BFB\u8005' },\n      crm_knowledge_article: { label: '\u6587\u7AE0', help: '\u672C\u6761\u53CD\u9988\u9488\u5BF9\u7684\u77E5\u8BC6\u6587\u7AE0\u3002' },\n      verdict: {\n        label: '\u8BC4\u4EF7',\n        options: { helpful: '\u6709\u7528', not_helpful: '\u6CA1\u7528' },\n      },\n      comment: { label: '\u5907\u6CE8', help: '\u53EF\u9009\u8BF4\u660E\uFF0C\u4F5C\u8005\u53EF\u89C1\u3002' },\n    },\n    _sections: {\n      basic: { label: '\u53CD\u9988' },\n    },\n  },\n};\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/sales/translations/zh-CN/objects.activity.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/sales/translations/zh-CN\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/sales/translations/zh-CN/objects.activity.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport type { ObjectTranslationData } from '@objectstack/spec/system';\n\n/**\n * \u7B80\u4F53\u4E2D\u6587 (zh-CN) \u2014 `objects` translations for the ACTIVITY family:\n * the interaction log \u2014 tasks, events, and who attended.\n *\n * Roster: `crm_task`, `crm_event`, `crm_event_attendee`.\n *\n * SPLIT AXIS (#1311): translation NAMESPACE first, then CRM DOMAIN FAMILY.\n * Everything that is not `objects` lives in `./app.ts`; `objects` \u2014 69-78% of\n * every bundle \u2014 is one file per CRM domain family, and a detail object\n * follows its master. A new row goes in the file for ITS family, never in\n * whichever file is already open: that is how one file re-grows past the 70%\n * advisory band `pnpm hygiene` prints. Full rule and rationale:\n * `src/sales/translations/zh-CN.ts`.\n */\nexport const activity: Record<string, ObjectTranslationData> = {\n  crm_task: {\n    _validations: {\n      completed_date_required: {\n        message: '\u72B6\u6001\u4E3A\u5DF2\u5B8C\u6210\u65F6\u5FC5\u987B\u586B\u5199\u5B8C\u6210\u65E5\u671F',\n      },\n      recurrence_fields_required: {\n        message: '\u91CD\u590D\u4EFB\u52A1\u5FC5\u987B\u586B\u5199\u91CD\u590D\u7C7B\u578B',\n      },\n      related_to_required: {\n        message: '\u81F3\u5C11\u9700\u8981\u9009\u62E9\u4E00\u6761\u5173\u8054\u8BB0\u5F55',\n      },\n    },\n    label: '\u4EFB\u52A1',\n    pluralLabel: '\u4EFB\u52A1',\n    description: '\u6D3B\u52A8\u4E0E\u5F85\u529E\u4E8B\u9879',\n    fields: {\n      subject: { label: '\u4E3B\u9898' },\n      description: { label: '\u63CF\u8FF0' },\n      status: {\n        label: '\u72B6\u6001',\n        options: {\n          not_started: '\u672A\u5F00\u59CB', in_progress: '\u8FDB\u884C\u4E2D', waiting: '\u7B49\u5F85\u4E2D',\n          completed: '\u5DF2\u5B8C\u6210', deferred: '\u5DF2\u63A8\u8FDF',\n        },\n      },\n      priority: {\n        // `urgent` KEEPS \u7D27\u6025, and \u26D4 nothing may re-point it at `crm_case`'s\n        // top value: the two vocabularies are different sets (task:\n        // low/normal/high/urgent \u00B7 case: low/medium/high/critical), so the two\n        // zh-CN words must stay different or the screen stops distinguishing\n        // two values the model treats as distinct \u2014 the crossing\n        // `src/sales/views/task.view.ts` carries the tombstone of. Maintainer ruling\n        // 2026-08-31, #1342: \u7D27\u6025 stays here (urgent is this object's literal\n        // word) and case `critical` moved to \u4E25\u91CD.\n        label: '\u4F18\u5148\u7EA7',\n        options: { low: '\u4F4E', normal: '\u666E\u901A', high: '\u9AD8', urgent: '\u7D27\u6025' },\n      },\n      due_date: { label: '\u622A\u6B62\u65E5\u671F' },\n      type: {\n        label: '\u4EFB\u52A1\u7C7B\u578B',\n        options: {\n          call: '\u7535\u8BDD', email: '\u90AE\u4EF6', meeting: '\u4F1A\u8BAE',\n          follow_up: '\u8DDF\u8FDB', demo: '\u6F14\u793A', other: '\u5176\u4ED6',\n        },\n      },\n      reminder_date: { label: '\u63D0\u9192\u65F6\u95F4' },\n      completed_date: { label: '\u5B8C\u6210\u65E5\u671F' },\n      owner_id: { label: '\u8D1F\u8D23\u4EBA' },\n      related_to_type: {\n        label: '\u5173\u8054\u5BF9\u8C61\u7C7B\u578B',\n        options: {\n          crm_account: '\u5BA2\u6237', crm_contact: '\u8054\u7CFB\u4EBA', crm_opportunity: '\u5546\u673A',\n          crm_lead: '\u7EBF\u7D22', crm_case: '\u5DE5\u5355',\n        },\n      },\n      related_to_account: { label: '\u5173\u8054\u5BA2\u6237' },\n      related_to_contact: { label: '\u5173\u8054\u8054\u7CFB\u4EBA' },\n      related_to_opportunity: { label: '\u5173\u8054\u5546\u673A' },\n      related_to_lead: { label: '\u5173\u8054\u7EBF\u7D22' },\n      related_to_case: { label: '\u5173\u8054\u5DE5\u5355' },\n      is_recurring: { label: '\u91CD\u590D\u4EFB\u52A1' },\n      recurrence_type: {\n        label: '\u91CD\u590D\u7C7B\u578B',\n        options: { daily: '\u6BCF\u65E5', weekly: '\u6BCF\u5468', monthly: '\u6BCF\u6708', yearly: '\u6BCF\u5E74' },\n      },\n      recurrence_interval: { label: '\u91CD\u590D\u95F4\u9694' },\n      recurrence_end_date: { label: '\u91CD\u590D\u7ED3\u675F\u65E5\u671F' },\n      is_completed: { label: '\u662F\u5426\u5B8C\u6210' },\n      is_overdue: { label: '\u662F\u5426\u903E\u671F' },\n      progress_percent: { label: '\u8FDB\u5EA6\uFF08%\uFF09' },\n      priority_rank: { label: '\u4F18\u5148\u7EA7\u6392\u5E8F' },\n      reminder_sent: { label: '\u63D0\u9192\u5DF2\u53D1\u9001' },\n    },\n    _sections: {\n      basic: { label: '\u4EFB\u52A1\u4FE1\u606F' },\n      scheduling: { label: '\u65E5\u7A0B\u5B89\u6392' },\n      related: { label: '\u5173\u8054\u8BB0\u5F55' },\n      recurrence: { label: '\u91CD\u590D\u89C4\u5219' },\n      system: { label: '\u7CFB\u7EDF' },\n      effort: { label: '\u8FDB\u5EA6\u4E0E\u5DE5\u65F6' },\n      // task.view.ts \u8868\u5355\u533A\u5757\u540D\u79F0 (#1100)\n      task: { label: '\u4EFB\u52A1' },\n      related_records: { label: '\u5173\u8054\u8BB0\u5F55' },\n      recurrence_and_effort: { label: '\u91CD\u590D\u4E0E\u5DE5\u65F6' },\n    },\n    _views: {\n      all_tasks: { label: '\u5168\u90E8\u4EFB\u52A1' },\n      task_board: { label: '\u4EFB\u52A1\u770B\u677F' },\n      task_calendar: { label: '\u4EFB\u52A1\u65E5\u7A0B' },\n      task_gantt: { label: '\u6267\u884C\u8BA1\u5212' },\n      task_timeline: { label: '\u5DE5\u65F6\u65F6\u95F4\u7EBF' },\n      my_open_tasks: { label: '\u6211\u7684\u5F85\u529E\u4EFB\u52A1' },\n      todays_tasks: { label: '\uD83D\uDCC5 \u6211\u7684\u4F18\u5148\u4EFB\u52A1' },\n      overdue_tasks: { label: '\u23F0 \u5F85\u529E\u4EFB\u52A1 \u00B7 \u6309\u903E\u671F\u65F6\u957F\u6392\u5E8F' },\n    },\n  },\n  crm_event: {\n    _validations: {\n      end_after_start: {\n        message: '\u7ED3\u675F\u65F6\u95F4\u5FC5\u987B\u665A\u4E8E\u5F00\u59CB\u65F6\u95F4',\n      },\n      related_to_required: {\n        message: '\u81F3\u5C11\u9700\u8981\u9009\u62E9\u4E00\u6761\u5173\u8054\u8BB0\u5F55',\n      },\n    },\n    label: '\u6D3B\u52A8',\n    pluralLabel: '\u6D3B\u52A8',\n    description: '\u4E0E\u5BA2\u6237\u7684\u4F1A\u8BAE\u3001\u901A\u8BDD\u53CA\u5176\u4ED6\u5DF2\u5B89\u6392\u7684\u4E92\u52A8',\n    fields: {\n      subject: { label: '\u4E3B\u9898' },\n      description: { label: '\u63CF\u8FF0' },\n      type: {\n        label: '\u6D3B\u52A8\u7C7B\u578B',\n        options: {\n          meeting: '\u4F1A\u8BAE', call: '\u7535\u8BDD', demo: '\u6F14\u793A',\n          webinar: '\u7EBF\u4E0A\u7814\u8BA8\u4F1A', onsite_visit: '\u4E0A\u95E8\u62DC\u8BBF', other: '\u5176\u4ED6',\n        },\n      },\n      status: {\n        label: '\u72B6\u6001',\n        options: {\n          planned: '\u5DF2\u8BA1\u5212', held: '\u5DF2\u4E3E\u884C', cancelled: '\u5DF2\u53D6\u6D88', no_show: '\u5BA2\u6237\u672A\u5230',\n        },\n      },\n      owner_id: { label: '\u8D1F\u8D23\u4EBA' },\n      start_datetime: { label: '\u5F00\u59CB\u65F6\u95F4' },\n      end_datetime: { label: '\u7ED3\u675F\u65F6\u95F4' },\n      all_day: { label: '\u5168\u5929\u6D3B\u52A8' },\n      duration_minutes: { label: '\u65F6\u957F\uFF08\u5206\u949F\uFF09' },\n      location: { label: '\u5730\u70B9', help: '\u4F1A\u8BAE\u5BA4\u3001\u5730\u5740\u6216\u4F1A\u8BAE\u94FE\u63A5' },\n      related_to_type: {\n        label: '\u5173\u8054\u5BF9\u8C61\u7C7B\u578B',\n        options: {\n          crm_account: '\u5BA2\u6237', crm_contact: '\u8054\u7CFB\u4EBA', crm_opportunity: '\u5546\u673A',\n          crm_lead: '\u7EBF\u7D22', crm_case: '\u5DE5\u5355',\n        },\n      },\n      related_to_account: { label: '\u5173\u8054\u5BA2\u6237' },\n      related_to_contact: { label: '\u5173\u8054\u8054\u7CFB\u4EBA' },\n      related_to_opportunity: { label: '\u5173\u8054\u5546\u673A' },\n      related_to_lead: { label: '\u5173\u8054\u7EBF\u7D22' },\n      related_to_case: { label: '\u5173\u8054\u5DE5\u5355' },\n      outcome_notes: { label: '\u4F1A\u540E\u7EAA\u8981', help: '\u8FBE\u6210\u4E86\u4EC0\u4E48\u5171\u8BC6\uFF0C\u4E0B\u4E00\u6B65\u505A\u4EC0\u4E48' },\n    },\n    _sections: {\n      basic: { label: '\u6D3B\u52A8\u4FE1\u606F' },\n      schedule: { label: '\u65E5\u7A0B\u5B89\u6392' },\n      related: { label: '\u5173\u8054\u8BB0\u5F55' },\n      outcome: { label: '\u7ED3\u679C' },\n      // event.view.ts \u8868\u5355\u533A\u5757\u540D\u79F0 (#1100)\n      event: { label: '\u6D3B\u52A8' },\n      related_records: { label: '\u5173\u8054\u8BB0\u5F55' },\n    },\n    _views: {\n      all_events: { label: '\u5168\u90E8\u6D3B\u52A8' },\n      event_calendar: { label: '\u6D3B\u52A8\u65E5\u5386' },\n      event_timeline: { label: '\u56E2\u961F\u65E5\u7A0B' },\n      my_events: { label: '\u6211\u7684\u65E5\u5386' },\n      upcoming_events: { label: '\uD83D\uDCC5 \u5373\u5C06\u5F00\u59CB \u00B7 \u6309\u65F6\u95F4\u5347\u5E8F' },\n      held_events: { label: '\u2705 \u4E92\u52A8\u5386\u53F2' },\n    },\n  },\n  crm_event_attendee: {\n    _validations: {\n      attendee_resolves: {\n        message: '\u53C2\u4E0E\u8005\u5FC5\u987B\u586B\u5199\u5176\u53C2\u4E0E\u8005\u7C7B\u578B\u6240\u6307\u7684\u4E00\u65B9\u2014\u2014\u8054\u7CFB\u4EBA\u7C7B\u578B\u9700\u8981\u586B\u5199\u8054\u7CFB\u4EBA\uFF0C\u5916\u90E8\u7C7B\u578B\u9700\u8981\u586B\u5199\u5916\u90E8\u53C2\u4E0E\u8005\u59D3\u540D',\n      },\n      attendee_type_exclusive: {\n        message: '\u53C2\u4E0E\u8005\u53EA\u80FD\u6307\u5B9A\u4E00\u65B9\u2014\u2014\u8BF7\u6E05\u7A7A\u5176\u53C2\u4E0E\u8005\u7C7B\u578B\u672A\u6307\u660E\u7684\u6240\u6709\u5B57\u6BB5',\n      },\n    },\n    label: '\u6D3B\u52A8\u53C2\u4E0E\u8005',\n    pluralLabel: '\u6D3B\u52A8\u53C2\u4E0E\u8005',\n    description: '\u53D7\u9080\u53C2\u52A0\u6216\u5B9E\u9645\u51FA\u5E2D\u6D3B\u52A8\u7684\u4EBA\u5458',\n    fields: {\n      attendee_number: { label: '\u53C2\u4E0E\u8005\u7F16\u53F7' },\n      crm_event: { label: '\u6D3B\u52A8' },\n      attendee_type: {\n        label: '\u53C2\u4E0E\u8005\u7C7B\u578B',\n        options: { contact: '\u8054\u7CFB\u4EBA', lead: '\u7EBF\u7D22', user: '\u5185\u90E8\u7528\u6237', external: '\u5916\u90E8\u6765\u5BBE' },\n      },\n      crm_contact: { label: '\u8054\u7CFB\u4EBA', help: '\u53C2\u4E0E\u8005\u662F\u5DF2\u6709\u5BA2\u6237\u8054\u7CFB\u4EBA\u65F6\u586B\u5199' },\n      crm_lead: { label: '\u7EBF\u7D22', help: '\u53C2\u4E0E\u8005\u4ECD\u662F\u672A\u8F6C\u5316\u7EBF\u7D22\u65F6\u586B\u5199' },\n      sys_user: { label: '\u5185\u90E8\u7528\u6237', help: '\u53C2\u4E0E\u8005\u662F\u540C\u4E8B\u65F6\u586B\u5199' },\n      external_name: { label: '\u5916\u90E8\u53C2\u4E0E\u8005', help: '\u4E0D\u5728\u4EFB\u4F55 CRM \u5BF9\u8C61\u4E2D\u7684\u53C2\u4E0E\u8005\u59D3\u540D\u2014\u2014\u53C2\u4E0E\u8005\u7C7B\u578B\u4E3A\u300C\u5916\u90E8\u6765\u5BBE\u300D\u65F6\u586B\u5199' },\n      response: {\n        label: '\u56DE\u590D',\n        options: {\n          no_response: '\u672A\u56DE\u590D', accepted: '\u5DF2\u63A5\u53D7',\n          declined: '\u5DF2\u62D2\u7EDD', tentative: '\u5F85\u5B9A',\n        },\n      },\n      is_organizer: { label: '\u7EC4\u7EC7\u8005' },\n      invited_date: { label: '\u9080\u8BF7\u65F6\u95F4' },\n    },\n    _sections: {\n      basic: { label: '\u53C2\u4E0E\u8005' },\n      response: { label: '\u9080\u8BF7' },\n      // event_attendee.view.ts \u8868\u5355\u533A\u5757\u540D\u79F0 (#1100)\n      attendee: { label: '\u53C2\u4E0E\u8005' },\n      invitation: { label: '\u9080\u8BF7' },\n    },\n    _views: {\n      all_event_attendees: { label: '\u6D3B\u52A8\u53C2\u4E0E\u8005' },\n    },\n  },\n};\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/sales/translations/zh-CN/objects.marketing.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/sales/translations/zh-CN\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/sales/translations/zh-CN/objects.marketing.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport type { ObjectTranslationData } from '@objectstack/spec/system';\n\n/**\n * \u7B80\u4F53\u4E2D\u6587 (zh-CN) \u2014 `objects` translations for the MARKETING family:\n * demand generation \u2014 campaigns and their membership.\n *\n * Roster: `crm_campaign`, `crm_campaign_member`.\n *\n * SPLIT AXIS (#1311): translation NAMESPACE first, then CRM DOMAIN FAMILY.\n * Everything that is not `objects` lives in `./app.ts`; `objects` \u2014 69-78% of\n * every bundle \u2014 is one file per CRM domain family, and a detail object\n * follows its master. A new row goes in the file for ITS family, never in\n * whichever file is already open: that is how one file re-grows past the 70%\n * advisory band `pnpm hygiene` prints. Full rule and rationale:\n * `src/sales/translations/zh-CN.ts`.\n */\nexport const marketing: Record<string, ObjectTranslationData> = {\n  crm_campaign: {\n    _validations: {\n      end_after_start: {\n        message: '\u7ED3\u675F\u65E5\u671F\u5FC5\u987B\u665A\u4E8E\u5F00\u59CB\u65E5\u671F',\n      },\n      actual_cost_within_budget: {\n        message: '\u5B9E\u9645\u6210\u672C\u8D85\u51FA\u9884\u7B97\u6210\u672C',\n      },\n    },\n    label: '\u8425\u9500\u6D3B\u52A8',\n    pluralLabel: '\u8425\u9500\u6D3B\u52A8',\n    description: '\u5E02\u573A\u8425\u9500\u6D3B\u52A8\u4E0E\u63A8\u5E7F',\n    fields: {\n      campaign_code: { label: '\u6D3B\u52A8\u4EE3\u7801' },\n      name: { label: '\u6D3B\u52A8\u540D\u79F0' },\n      type: {\n        label: '\u7C7B\u578B',\n        options: {\n          email: '\u90AE\u4EF6\u8425\u9500', webinar: '\u7EBF\u4E0A\u7814\u8BA8\u4F1A', trade_show: '\u5C55\u4F1A',\n          conference: '\u884C\u4E1A\u4F1A\u8BAE', direct_mail: '\u76F4\u90AE', social_media: '\u793E\u4EA4\u5A92\u4F53',\n          content: '\u5185\u5BB9\u8425\u9500', partner: '\u4F19\u4F34\u8054\u5408\u8425\u9500',\n        },\n      },\n      status: {\n        label: '\u72B6\u6001',\n        options: {\n          planning: '\u89C4\u5212\u4E2D', in_progress: '\u8FDB\u884C\u4E2D',\n          completed: '\u5DF2\u5B8C\u6210', aborted: '\u5DF2\u4E2D\u6B62',\n        },\n      },\n      start_date: { label: '\u5F00\u59CB\u65E5\u671F' },\n      end_date: { label: '\u7ED3\u675F\u65E5\u671F' },\n      expected_revenue: { label: '\u9884\u671F\u6536\u5165' },\n      description: { label: '\u63CF\u8FF0' },\n      channel: {\n        label: '\u4E3B\u8981\u6E20\u9053',\n        options: { digital: '\u6570\u5B57\u6E20\u9053', social: '\u793E\u4EA4\u5A92\u4F53', email: '\u90AE\u4EF6', events: '\u7EBF\u4E0B\u6D3B\u52A8', partner: '\u5408\u4F5C\u4F19\u4F34' },\n      },\n      budgeted_cost: { label: '\u9884\u7B97\u6210\u672C' },\n      actual_cost: { label: '\u5B9E\u9645\u6210\u672C' },\n      actual_revenue: { label: '\u5B9E\u9645\u6536\u5165' },\n      target_size: { label: '\u76EE\u6807\u4EBA\u6570', help: '\u76EE\u6807\u7EBF\u7D22/\u8054\u7CFB\u4EBA\u6570\u91CF' },\n      num_sent: { label: '\u53D1\u9001\u6570\u91CF' },\n      num_responses: { label: '\u54CD\u5E94\u6570\u91CF' },\n      num_leads: { label: '\u7EBF\u7D22\u6570\u91CF' },\n      num_converted_leads: { label: '\u5DF2\u8F6C\u5316\u7EBF\u7D22\u6570' },\n      num_opportunities: { label: '\u5DF2\u521B\u5EFA\u5546\u673A\u6570' },\n      num_won_opportunities: { label: '\u5DF2\u8D62\u5F97\u5546\u673A' },\n      response_rate: { label: '\u54CD\u5E94\u7387\uFF08%\uFF09' },\n      roi: { label: '\u6295\u8D44\u56DE\u62A5\u7387\uFF08%\uFF09' },\n      owner_id: { label: '\u6D3B\u52A8\u8D1F\u8D23\u4EBA' },\n      landing_page_url: { label: '\u7740\u9646\u9875' },\n      is_active: { label: '\u662F\u5426\u542F\u7528' },\n      display_title: { label: '\u663E\u793A\u540D\u79F0' },\n    },\n    _sections: {\n      basic: { label: '\u6D3B\u52A8\u4FE1\u606F' },\n      schedule: { label: '\u65E5\u7A0B\u5B89\u6392' },\n      budget: { label: '\u9884\u7B97\u4E0E\u6295\u8D44\u56DE\u62A5' },\n      metrics: { label: '\u6548\u679C\u6570\u636E' },\n      assignment: { label: '\u5F52\u5C5E' },\n      assets: { label: '\u6D3B\u52A8\u7D20\u6750' },\n    },\n    _views: {\n      all_campaigns: { label: '\u5168\u90E8\u8425\u9500\u6D3B\u52A8' },\n      campaign_gantt: { label: '\u6D3B\u52A8\u6392\u671F' },\n      campaign_calendar: { label: '\u6D3B\u52A8\u65E5\u5386' },\n      campaign_timeline: { label: '\u8425\u9500\u65F6\u95F4\u7EBF' },\n    },\n    _actions: {\n      enroll_leads: {\n        label: '\u6279\u91CF\u52A0\u5165\u6210\u5458',\n        successMessage: '\u7B26\u5408\u6761\u4EF6\u7684\u6210\u5458\u5DF2\u52A0\u5165\u8425\u9500\u6D3B\u52A8\u3002',\n      },\n    },\n  },\n  crm_campaign_member: {\n    _validations: {\n      lead_or_contact_required: {\n        message: '\u8425\u9500\u6D3B\u52A8\u6210\u5458\u5FC5\u987B\u5173\u8054\u7EBF\u7D22\u6216\u8054\u7CFB\u4EBA\u4E4B\u4E00',\n      },\n    },\n    // \u300C\u8425\u9500\u6D3B\u52A8\u6210\u5458\u300D, not \u300C\u6D3B\u52A8\u6210\u5458\u300D: this object's master is `crm_campaign`\n    // (\u8425\u9500\u6D3B\u52A8), while \u300C\u6D3B\u52A8\u300D is already this pack's label for `crm_event` and\n    // \u300C\u6D3B\u52A8\u53C2\u4E0E\u8005\u300D its child `crm_event_attendee`. Dropping \u300C\u8425\u9500\u300D put a\n    // marketing object inside the calendar family's name space (#810).\n    label: '\u8425\u9500\u6D3B\u52A8\u6210\u5458',\n    pluralLabel: '\u8425\u9500\u6D3B\u52A8\u6210\u5458',\n    description: '\u8425\u9500\u6D3B\u52A8\u6240\u89E6\u8FBE\u7684\u7EBF\u7D22\u4E0E\u8054\u7CFB\u4EBA\u53CA\u5176\u54CD\u5E94\u72B6\u6001',\n    fields: {\n      member_number: { label: '\u6210\u5458\u7F16\u53F7' },\n      crm_campaign: { label: '\u8425\u9500\u6D3B\u52A8' },\n      crm_lead: { label: '\u7EBF\u7D22', help: '\u6210\u5458\u52A0\u5165\u65F6\u8EAB\u4EFD\u4E3A\u7EBF\u7D22\u7684\uFF0C\u8BB0\u5F55\u5728\u6B64' },\n      crm_contact: { label: '\u8054\u7CFB\u4EBA', help: '\u6210\u5458\u4E3A\u5DF2\u6709\u8054\u7CFB\u4EBA\u7684\uFF0C\u8BB0\u5F55\u5728\u6B64' },\n      status: {\n        label: '\u72B6\u6001',\n        options: {\n          sent: '\u5DF2\u53D1\u9001', responded: '\u5DF2\u54CD\u5E94',\n          converted: '\u5DF2\u8F6C\u5316', unsubscribed: '\u5DF2\u9000\u8BA2',\n        },\n      },\n      added_date: { label: '\u52A0\u5165\u65F6\u95F4' },\n      response_date: { label: '\u54CD\u5E94\u65F6\u95F4' },\n      has_responded: { label: '\u5DF2\u54CD\u5E94' },\n    },\n    _sections: {\n      basic: { label: '\u57FA\u672C\u4FE1\u606F' },\n      response: { label: '\u54CD\u5E94\u8DDF\u8E2A' },\n    },\n    _actions: {\n      mark_responded: {\n        label: '\u6807\u8BB0\u4E3A\u5DF2\u54CD\u5E94',\n        successMessage: '\u5DF2\u8BB0\u5F55\u8BE5\u8425\u9500\u6D3B\u52A8\u6210\u5458\u7684\u54CD\u5E94\u3002',\n      },\n    },\n  },\n};\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/sales/translations/zh-CN.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/sales/translations\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/sales/translations/zh-CN.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport type { TranslationData } from '@objectstack/spec/system';\n\nimport { appSurface } from './zh-CN/app';\nimport { customer } from './zh-CN/objects.customer';\nimport { pipeline } from './zh-CN/objects.pipeline';\nimport { commerce } from './zh-CN/objects.commerce';\nimport { service } from './zh-CN/objects.service';\nimport { activity } from './zh-CN/objects.activity';\nimport { marketing } from './zh-CN/objects.marketing';\n\n/**\n * \u7B80\u4F53\u4E2D\u6587 (zh-CN) \u2014 CRM App Translations\n *\n * Per-locale file: one file per language, following the `per_locale` convention.\n *\n * SPLIT AXIS (#1311): translation NAMESPACE first, then CRM DOMAIN FAMILY.\n *\n * This bundle was one file and it had reached 88.6% of the 100KB source cap\n * `pnpm hygiene` enforces, growing ~1.2KB a day. It is now assembled from\n * `./<locale>/`, on an axis measured rather than guessed:\n *\n *   - every namespace that is NOT `objects` \u2014 `apps`, `messages`,\n *     `dashboards`, `datasets`, `pages`, and any namespace `TranslationData`\n *     gains later \u2014 lives in `app.ts`. Measured: those namespaces together\n *     are under a quarter of the bundle, and the schema bounds how many can\n *     ever arrive, so one file holds them with room left;\n *   - `objects` is 69-78% of every bundle, so it is partitioned again, one\n *     file per CRM domain family \u2014 `customer`, `pipeline`, `commerce`,\n *     `service`, `activity`, `marketing` \u2014 and a DETAIL object follows its\n *     master: line items follow their quote or opportunity,\n *     `crm_event_attendee` follows `crm_event`, `crm_campaign_member`\n *     follows `crm_campaign`, `crm_article_feedback` follows\n *     `crm_knowledge_article`.\n *\n * A namespace axis ALONE was measured and rejected: it leaves `objects` at\n * 65.7KB, 3.9KB under the advisory band, which `objects` growth crosses in\n * about nine days. The family axis puts the largest part at 24.2% of the cap.\n *\n * \u26A0\uFE0F A new object translation belongs in the file for ITS family. Do not add\n * it to whichever file is already open \u2014 that is how one file re-grows past\n * the band, which is what split this bundle in the first place.\n *\n * \u26A0\uFE0F A value used by more than one family lives in `<locale>/_shared.ts`. A\n * value used by exactly one family lives in that family's file.\n *\n * \u26A0\uFE0F The key order below is LOAD-BEARING, not cosmetic. `objectstack build`\n * serialises this object into `dist/objectstack.json` in insertion order and\n * never sorts it, so listing the rows here \u2014 rather than spreading the family\n * files \u2014 is what keeps the built artifact byte-identical across the split.\n * The order is this bundle's own historical accretion order and differs\n * between locales; reordering it rewrites the artifact.\n */\nexport const zhCN: TranslationData = {\n  objects: {\n    crm_account: customer.crm_account,\n    crm_contact: customer.crm_contact,\n    crm_knowledge_article: service.crm_knowledge_article,\n    crm_forecast: pipeline.crm_forecast,\n    crm_lead: pipeline.crm_lead,\n    crm_quote: commerce.crm_quote,\n    crm_contract: commerce.crm_contract,\n    crm_case: service.crm_case,\n    crm_task: activity.crm_task,\n    crm_campaign: marketing.crm_campaign,\n    crm_product: commerce.crm_product,\n    crm_opportunity: pipeline.crm_opportunity,\n    crm_event: activity.crm_event,\n    crm_event_attendee: activity.crm_event_attendee,\n    crm_article_feedback: service.crm_article_feedback,\n    crm_campaign_member: marketing.crm_campaign_member,\n    crm_opportunity_line_item: pipeline.crm_opportunity_line_item,\n    crm_quote_line_item: commerce.crm_quote_line_item,\n  },\n  ...appSurface,\n};\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/sales/translations/ja-JP/app.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/sales/translations/ja-JP\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/sales/translations/ja-JP/app.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport type { TranslationData } from '@objectstack/spec/system';\n\nimport { QUOTE_DISCOUNT_CEILING } from '../../objects/_thresholds';\n\n/**\n * \u65E5\u672C\u8A9E (ja-JP) \u2014 every translation namespace EXCEPT `objects`:\n * `apps`, `messages`, `dashboards`, `datasets`, `pages`, `flows`.\n *\n * SPLIT AXIS (#1311): translation NAMESPACE first, then CRM DOMAIN FAMILY.\n * Everything that is not `objects` lives in `./app.ts`; `objects` \u2014 69-78% of\n * every bundle \u2014 is one file per CRM domain family, and a detail object\n * follows its master. A new row goes in the file for ITS family, never in\n * whichever file is already open: that is how one file re-grows past the 70%\n * advisory band `pnpm hygiene` prints. Full rule and rationale:\n * `src/sales/translations/ja-JP.ts`.\n *\n * A namespace `TranslationData` gains later lands here too, and the room is\n * measured: this file is the smaller half of the bundle, and the schema bounds\n * how many namespaces can ever arrive.\n */\nexport const appSurface: Omit<TranslationData, 'objects'> = {\n  apps: {\n    crm_enterprise: {\n      label: 'HotCRM',\n      description: '\u55B6\u696D\u30FB\u30B5\u30FC\u30D3\u30B9\u30FB\u30DE\u30FC\u30B1\u30C6\u30A3\u30F3\u30B0\u5411\u3051\u9867\u5BA2\u95A2\u4FC2\u7BA1\u7406\u30B7\u30B9\u30C6\u30E0',\n      // Keyed by navigation-node `id` (a flat keyspace regardless of depth).\n      navigation: {\n        nav_home: { label: '\u30DB\u30FC\u30E0' },\n\n        group_sales: { label: '\u55B6\u696D' },\n        nav_lead: { label: '\u30EA\u30FC\u30C9' },\n        nav_account: { label: '\u53D6\u5F15\u5148' },\n        nav_account_workbench: { label: '\u53D6\u5F15\u5148\u30EF\u30FC\u30AF\u30D9\u30F3\u30C1' },\n        nav_contact: { label: '\u53D6\u5F15\u5148\u8CAC\u4EFB\u8005' },\n        nav_opportunity: { label: '\u5546\u8AC7' },\n        nav_quote: { label: '\u898B\u7A4D' },\n        nav_contract: { label: '\u5951\u7D04' },\n        nav_product: { label: '\u88FD\u54C1' },\n        nav_sales_dashboard: { label: '\u55B6\u696D\u5B9F\u7E3E' },\n\n        group_work: { label: '\u30DE\u30A4\u30EF\u30FC\u30AF' },\n        nav_my_tasks: { label: '\u79C1\u306E\u30BF\u30B9\u30AF' },\n        nav_my_deals: { label: '\u79C1\u306E\u5546\u8AC7' },\n        nav_my_leads: { label: '\u79C1\u306E\u30EA\u30FC\u30C9' },\n        nav_my_cases: { label: '\u79C1\u306E\u30B1\u30FC\u30B9' },\n        nav_my_calendar: { label: '\u30DE\u30A4\u30AB\u30EC\u30F3\u30C0\u30FC' },\n        nav_approval_requests: { label: '\u53D7\u4FE1\u30C8\u30EC\u30A4' },\n\n        group_activity: { label: '\u6D3B\u52D5' },\n        nav_event: { label: '\u30A4\u30D9\u30F3\u30C8' },\n        nav_activity_dashboard: { label: '\u55B6\u696D\u6D3B\u52D5' },\n\n        group_marketing: { label: '\u30DE\u30FC\u30B1\u30C6\u30A3\u30F3\u30B0' },\n        nav_campaign: { label: '\u30AD\u30E3\u30F3\u30DA\u30FC\u30F3' },\n\n        group_service: { label: '\u30B5\u30FC\u30D3\u30B9' },\n        nav_case: { label: '\u30B1\u30FC\u30B9' },\n        nav_knowledge: { label: '\u30CA\u30EC\u30C3\u30B8\u30D9\u30FC\u30B9' },\n        nav_service_dashboard: { label: '\u30B5\u30FC\u30D3\u30B9\u6982\u8981' },\n\n        group_insights: { label: '\u30A4\u30F3\u30B5\u30A4\u30C8' },\n        nav_crm_dashboard: { label: 'CRM \u6982\u8981' },\n        nav_forecast: { label: '\u30D5\u30A9\u30FC\u30AD\u30E3\u30B9\u30C8' },\n        nav_report_pipeline_coverage: { label: '\u30D1\u30A4\u30D7\u30E9\u30A4\u30F3\u30AB\u30D0\u30EC\u30C3\u30B8' },\n        nav_report_lead_inflow: { label: '\u30EA\u30FC\u30C9\u6D41\u5165' },\n        nav_report_sla: { label: 'SLA \u5B9F\u7E3E' },\n      },\n    },\n  },\n  messages: {\n    'common.save': '\u4FDD\u5B58',\n    'common.cancel': '\u30AD\u30E3\u30F3\u30BB\u30EB',\n    'common.delete': '\u524A\u9664',\n    'common.edit': '\u7DE8\u96C6',\n    'common.create': '\u65B0\u898F\u4F5C\u6210',\n    'common.search': '\u691C\u7D22',\n    'common.filter': '\u30D5\u30A3\u30EB\u30BF\u30FC',\n    'common.export': '\u30A8\u30AF\u30B9\u30DD\u30FC\u30C8',\n    'common.back': '\u623B\u308B',\n    'common.confirm': '\u78BA\u8A8D',\n    'nav.sales': '\u55B6\u696D',\n    'nav.service': '\u30B5\u30FC\u30D3\u30B9',\n    'nav.marketing': '\u30DE\u30FC\u30B1\u30C6\u30A3\u30F3\u30B0',\n    'nav.products': '\u88FD\u54C1',\n    'nav.analytics': '\u30A2\u30CA\u30EA\u30C6\u30A3\u30AF\u30B9',\n    'success.saved': '\u30EC\u30B3\u30FC\u30C9\u3092\u4FDD\u5B58\u3057\u307E\u3057\u305F',\n    'success.converted': '\u30EA\u30FC\u30C9\u3092\u5909\u63DB\u3057\u307E\u3057\u305F',\n    'confirm.delete': '\u3053\u306E\u30EC\u30B3\u30FC\u30C9\u3092\u524A\u9664\u3057\u3066\u3082\u3088\u308D\u3057\u3044\u3067\u3059\u304B\uFF1F',\n    'confirm.convert_lead': '\u3053\u306E\u30EA\u30FC\u30C9\u3092\u53D6\u5F15\u5148\u30FB\u53D6\u5F15\u5148\u8CAC\u4EFB\u8005\u30FB\u5546\u8AC7\u306B\u5909\u63DB\u3057\u307E\u3059\u304B\uFF1F',\n    'error.required': '\u3053\u306E\u9805\u76EE\u306F\u5FC5\u9808\u3067\u3059',\n    'error.load_failed': '\u30C7\u30FC\u30BF\u306E\u8AAD\u307F\u8FBC\u307F\u306B\u5931\u6557\u3057\u307E\u3057\u305F',\n  },\n  dashboards: {\n    sales_activity_dashboard: {\n      label: '\u55B6\u696D\u6D3B\u52D5',\n      description: '\u8AB0\u304C\u3069\u308C\u3060\u3051\u9867\u5BA2\u3068\u8A71\u3057\u3066\u3044\u308B\u304B\u3001\u3069\u306E\u53D6\u5F15\u5148\u304C\u6C88\u9ED9\u3057\u3066\u3044\u308B\u304B',\n      widgets: {\n        interactions_held: { title: '\u8A18\u9332\u6E08\u307F\u306E\u5BFE\u8A71', description: '\u5B9F\u969B\u306B\u884C\u308F\u308C\u305F\u96FB\u8A71\u3068\u4F1A\u8B70' },\n        meetings_booked: { title: '\u8A2D\u5B9A\u6E08\u307F\u306E\u4F1A\u8B70', description: '\u30AB\u30EC\u30F3\u30C0\u30FC\u4E0A\u306B\u3042\u308A\u672A\u5B9F\u65BD\u306E\u4F1A\u8B70' },\n        customer_minutes: { title: '\u9867\u5BA2\u63A5\u89E6\u6642\u9593\uFF08\u5206\uFF09', description: '\u9867\u5BA2\u3068\u5411\u304D\u5408\u3063\u305F\u7DCF\u6642\u9593' },\n        tasks_completed: { title: '\u5B8C\u4E86\u30BF\u30B9\u30AF', description: '\u30AF\u30ED\u30FC\u30BA\u3057\u305F\u30D5\u30A9\u30ED\u30FC\u30A2\u30C3\u30D7' },\n        activity_by_rep: { title: '\u62C5\u5F53\u8005\u5225\u306E\u6D3B\u52D5', description: '\u62C5\u5F53\u8005\u3054\u3068\u306E\u8A18\u9332\u6E08\u307F\u5BFE\u8A71\u6570' },\n        activity_by_week: { title: '\u9031\u6B21\u306E\u6D3B\u52D5\u91CF', description: '\u9031\u3042\u305F\u308A\u306E\u5BFE\u8A71\u6570' },\n        activity_mix: { title: '\u6D3B\u52D5\u306E\u5185\u8A33', description: '\u96FB\u8A71\u30FB\u4F1A\u8B70\u30FB\u30C7\u30E2\u306E\u6BD4\u7387' },\n        activity_by_record_type: { title: '\u6D3B\u52D5\u306E\u5BFE\u8C61', description: '\u30D5\u30A1\u30CD\u30EB\u306E\u3069\u3053\u306B\u6CE8\u529B\u3057\u3066\u3044\u308B\u304B' },\n        deal_activity: { title: '\u5546\u8AC7\u4E0A\u306E\u5BFE\u8A71', description: '\u5546\u8AC7\u306B\u7D10\u3065\u304F\u8A18\u9332\u6E08\u307F\u5BFE\u8A71' },\n        open_deals_for_activity: { title: '\u30AA\u30FC\u30D7\u30F3\u5546\u8AC7', description: '\u9032\u884C\u4E2D\u306E\u5546\u8AC7\u6570' },\n        quiet_accounts_30: { title: '30 \u65E5\u4EE5\u4E0A\u6C88\u9ED9', description: '1 \u304B\u6708\u9593\u5BFE\u8A71\u8A18\u9332\u306E\u306A\u3044\u30A2\u30AF\u30C6\u30A3\u30D6\u53D6\u5F15\u5148' },\n        quiet_accounts_60: { title: '60 \u65E5\u4EE5\u4E0A\u6C88\u9ED9', description: '2 \u304B\u6708\u306E\u6C88\u9ED9 \u2014 \u30EA\u30B9\u30AF\u95BE\u5024' },\n        quiet_accounts_90: { title: '90 \u65E5\u4EE5\u4E0A\u6C88\u9ED9', description: '\u56DB\u534A\u671F\u306B\u308F\u305F\u308A\u63A5\u89E6\u306A\u3057' },\n      },\n    },\n    crm_overview_dashboard: {\n      label: 'CRM \u6982\u8981',\n      description: '\u58F2\u4E0A\u6307\u6A19\u3001\u30D1\u30A4\u30D7\u30E9\u30A4\u30F3\u5206\u6790\u3001\u5546\u8AC7\u30A4\u30F3\u30B5\u30A4\u30C8',\n      widgets: {\n        total_revenue: { title: '\u7DCF\u58F2\u4E0A', description: '\u5F53\u671F\u306E\u6210\u7ACB\u6E08\u307F\u58F2\u4E0A' },\n        active_deals: { title: '\u9032\u884C\u4E2D\u306E\u5546\u8AC7', description: '\u30D1\u30A4\u30D7\u30E9\u30A4\u30F3\u4E0A\u306E\u30AA\u30FC\u30D7\u30F3\u5546\u8AC7' },\n        won_deals: { title: '\u6210\u7ACB\u5546\u8AC7\u6570', description: '\u5F53\u671F\u306B\u6210\u7ACB\u3057\u305F\u5546\u8AC7\u306E\u7DCF\u6570' },\n        avg_deal_size: { title: '\u5E73\u5747\u5546\u8AC7\u898F\u6A21', description: '\u6210\u7ACB\u6E08\u307F\u5546\u8AC7\u306E\u5E73\u5747\u91D1\u984D' },\n        revenue_trends: { title: '\u58F2\u4E0A\u30C8\u30EC\u30F3\u30C9', description: '\u904E\u53BB12\u304B\u6708\u306E\u6210\u7ACB\u6E08\u307F\u58F2\u4E0A' },\n        lead_source: { title: '\u30EA\u30FC\u30C9\u30BD\u30FC\u30B9', description: '\u7372\u5F97\u30C1\u30E3\u30CD\u30EB\u5225\u306E\u30D1\u30A4\u30D7\u30E9\u30A4\u30F3\u91D1\u984D' },\n        pipeline_by_stage: { title: '\u30B9\u30C6\u30FC\u30B8\u5225\u30D1\u30A4\u30D7\u30E9\u30A4\u30F3', description: '\u5404\u55B6\u696D\u30B9\u30C6\u30FC\u30B8\u306E\u30AA\u30FC\u30D7\u30F3\u5546\u8AC7\u91D1\u984D' },\n        top_products: { title: '\u58F2\u308C\u7B4B\u88FD\u54C1', description: '\u88FD\u54C1\u30AB\u30C6\u30B4\u30EA\u5225\u306E\u5B9A\u4FA1\u30D9\u30FC\u30B9\u58F2\u4E0A' },\n        pipeline_by_owner: { title: '\u62C5\u5F53\u8005\u5225\u30D1\u30A4\u30D7\u30E9\u30A4\u30F3', description: '\u55B6\u696D\u62C5\u5F53\u8005\u3054\u3068\u306E\u30AA\u30FC\u30D7\u30F3\u30D1\u30A4\u30D7\u30E9\u30A4\u30F3\u91D1\u984D\u3068\u5546\u8AC7\u6570' },\n      },\n    },\n    executive_dashboard: {\n      label: '\u30A8\u30B0\u30BC\u30AF\u30C6\u30A3\u30D6\u6982\u8981',\n      description: '\u7D4C\u55B6\u5C64\u5411\u3051\u306E\u58F2\u4E0A\u30FB\u9867\u5BA2\u30FB\u30D1\u30A4\u30D7\u30E9\u30A4\u30F3\u306E\u4E3B\u8981KPI',\n      widgets: {\n        total_revenue_ytd: { title: '\u5E74\u5EA6\u7D2F\u8A08\u58F2\u4E0A', description: '\u672C\u5E74\u5EA6\u306E\u6210\u7ACB\u6E08\u307F\u58F2\u4E0A' },\n        total_accounts: { title: '\u30A2\u30AF\u30C6\u30A3\u30D6\u53D6\u5F15\u5148', description: '\u5C11\u306A\u304F\u3068\u30821\u3064\u306E\u6709\u52B9\u306A\u95A2\u4FC2\u3092\u6301\u3064\u9867\u5BA2' },\n        total_contacts: { title: '\u53D6\u5F15\u5148\u8CAC\u4EFB\u8005\u6570', description: '\u540D\u7C3F\u306B\u767B\u9332\u3055\u308C\u305F\u53D6\u5F15\u5148\u8CAC\u4EFB\u8005' },\n        open_leads: { title: '\u30AA\u30FC\u30D7\u30F3\u30EA\u30FC\u30C9', description: '\u672A\u5909\u63DB\u306E\u30EA\u30FC\u30C9' },\n        revenue_trend: { title: '\u58F2\u4E0A\u30C8\u30EC\u30F3\u30C9', description: '\u904E\u53BB12\u304B\u6708\u306E\u6210\u7ACB\u6E08\u307F\u58F2\u4E0A' },\n        revenue_by_industry: { title: '\u696D\u7A2E\u5225\u58F2\u4E0A', description: '\u672C\u5E74\u5EA6\u306E\u6210\u7ACB\u6E08\u307F\u58F2\u4E0A\u3092\u696D\u7A2E\u5225\u306B\u5206\u985E' },\n        pipeline_by_stage: { title: '\u30B9\u30C6\u30FC\u30B8\u5225\u30D1\u30A4\u30D7\u30E9\u30A4\u30F3', description: '\u5404\u55B6\u696D\u30B9\u30C6\u30FC\u30B8\u306E\u30AA\u30FC\u30D7\u30F3\u5546\u8AC7\u91D1\u984D' },\n        new_accounts_by_month: { title: '\u65B0\u898F\u53D6\u5F15\u5148', description: '\u904E\u53BB6\u304B\u6708\u306E\u53D6\u5F15\u5148\u4F5C\u6210\u30DA\u30FC\u30B9' },\n        accounts_by_industry: { title: '\u696D\u7A2E\u5225\u53D6\u5F15\u5148', description: '\u696D\u7A2E\u3054\u3068\u306E\u5E74\u9593\u58F2\u4E0A\u5408\u8A08\u3068\u53D6\u5F15\u5148\u6570' },\n      },\n    },\n    sales_dashboard: {\n      label: '\u55B6\u696D\u5B9F\u7E3E',\n      description: '\u30D1\u30A4\u30D7\u30E9\u30A4\u30F3\u5206\u6790\u3001\u52DD\u7387\u30C8\u30EC\u30F3\u30C9\u3001\u62C5\u5F53\u8005\u5225\u30D1\u30D5\u30A9\u30FC\u30DE\u30F3\u30B9',\n      widgets: {\n        total_pipeline_value: { title: '\u30D1\u30A4\u30D7\u30E9\u30A4\u30F3\u5408\u8A08', description: '\u30AA\u30FC\u30D7\u30F3\u5546\u8AC7\u91D1\u984D\u306E\u5408\u8A08' },\n        closed_won_qtd: { title: '\u4ECA\u56DB\u534A\u671F\u6210\u7ACB\u984D', description: '\u4ECA\u56DB\u534A\u671F\u306B\u6210\u7ACB\u3057\u305F\u58F2\u4E0A' },\n        open_opportunities: { title: '\u30AA\u30FC\u30D7\u30F3\u5546\u8AC7', description: '\u9032\u884C\u4E2D\u306E\u30A2\u30AF\u30C6\u30A3\u30D6\u5546\u8AC7' },\n        avg_deal_size: { title: '\u5E73\u5747\u5546\u8AC7\u898F\u6A21', description: '\u4ECA\u56DB\u534A\u671F\u306E\u6210\u7ACB\u6E08\u307F\u5546\u8AC7\u306E\u5E73\u5747\u91D1\u984D' },\n        pipeline_by_stage: { title: '\u30B9\u30C6\u30FC\u30B8\u5225\u30D1\u30A4\u30D7\u30E9\u30A4\u30F3', description: '\u5404\u55B6\u696D\u30B9\u30C6\u30FC\u30B8\u306E\u30AA\u30FC\u30D7\u30F3\u5546\u8AC7\u91D1\u984D' },\n        monthly_revenue_trend: { title: '\u6708\u6B21\u58F2\u4E0A\u30C8\u30EC\u30F3\u30C9', description: '\u904E\u53BB12\u304B\u6708\u306E\u6210\u7ACB\u6E08\u307F\u58F2\u4E0A' },\n        pipeline_by_forecast_category: { title: '\u4E88\u6E2C\u30AB\u30C6\u30B4\u30EA\u5225\u30D1\u30A4\u30D7\u30E9\u30A4\u30F3', description: '\u58F2\u4E0A\u4E88\u6E2C\u30AB\u30C6\u30B4\u30EA\u5225\u306E\u30AA\u30FC\u30D7\u30F3\u30D1\u30A4\u30D7\u30E9\u30A4\u30F3\u91D1\u984D' },\n        lead_source_breakdown: { title: '\u30EA\u30FC\u30C9\u30BD\u30FC\u30B9', description: '\u30D1\u30A4\u30D7\u30E9\u30A4\u30F3\u306E\u6D41\u5165\u5143' },\n        open_pipeline_by_owner: { title: '\u62C5\u5F53\u8005\u5225\u30AA\u30FC\u30D7\u30F3\u30D1\u30A4\u30D7\u30E9\u30A4\u30F3', description: '\u55B6\u696D\u62C5\u5F53\u8005\u3054\u3068\u306E\u9032\u884C\u4E2D\u30D1\u30A4\u30D7\u30E9\u30A4\u30F3\u91D1\u984D\u30FB\u5546\u8AC7\u6570\u30FB\u5E73\u5747\u52DD\u7387' },\n        quota_attainment_by_rep: { title: '\u62C5\u5F53\u8005\u5225\u30CE\u30EB\u30DE\u9054\u6210\u72B6\u6CC1', description: '\u4E88\u6E2C\u30B9\u30CA\u30C3\u30D7\u30B7\u30E7\u30C3\u30C8\u306B\u57FA\u3065\u304F\u62C5\u5F53\u8005\u5225\u306E\u4ECA\u56DB\u534A\u671F\u30CE\u30EB\u30DE\u30FB\u6210\u7D04\u53CE\u76CA\u30FB\u9054\u6210\u7387' },\n        pipeline_stage_by_source: { title: '\u30B9\u30C6\u30FC\u30B8 \u00D7 \u30EA\u30FC\u30C9\u30BD\u30FC\u30B9', description: '\u30B9\u30C6\u30FC\u30B8\u3068\u30BD\u30FC\u30B9\u5225\u306E\u9032\u884C\u4E2D\u5546\u8AC7\u91D1\u984D\u306E\u30AF\u30ED\u30B9\u96C6\u8A08' },\n        win_rate_12m: { title: '\u52DD\u7387\uFF08\u76F4\u8FD112\u304B\u6708\uFF09', description: '\u76F4\u8FD112\u304B\u6708\u306B\u6C7A\u7740\u3057\u305F\u5546\u8AC7\u306E\u3046\u3061\u6210\u7ACB\u3057\u305F\u5272\u5408' },\n        won_deals_12m: { title: '\u6210\u7ACB\u5546\u8AC7\u6570\uFF08\u76F4\u8FD112\u304B\u6708\uFF09', description: '\u52DD\u7387\u306E\u5206\u5B50' },\n        lost_deals_12m: { title: '\u5931\u6CE8\u5546\u8AC7\u6570\uFF08\u76F4\u8FD112\u304B\u6708\uFF09', description: '\u52DD\u7387\u306E\u5206\u6BCD\u306E\u3082\u3046\u534A\u5206' },\n        win_rate_by_owner: { title: '\u62C5\u5F53\u8005\u5225 \u53D7\u6CE8\uFF0F\u5931\u6CE8', description: '\u76F4\u8FD112\u304B\u6708\u306E\u62C5\u5F53\u8005\u3054\u3068\u306E\u6210\u7ACB\u6570\u30FB\u5931\u6CE8\u6570\u30FB\u52DD\u7387' },\n        win_rate_by_lead_source: { title: '\u30EA\u30FC\u30C9\u30BD\u30FC\u30B9\u5225 \u53D7\u6CE8\uFF0F\u5931\u6CE8', description: '\u5B9F\u969B\u306B\u6210\u7ACB\u306B\u3064\u306A\u304C\u308B\u306E\u306F\u3069\u306E\u30BD\u30FC\u30B9\u304B \u2014 \u76F4\u8FD112\u304B\u6708' },\n        loss_reason_breakdown: { title: '\u5931\u6CE8\u306E\u7406\u7531', description: '\u76F4\u8FD112\u304B\u6708\u306E\u5931\u6CE8\u5546\u8AC7\u3092\u7406\u7531\u5225\u306B\u96C6\u8A08' },\n      },\n    },\n    service_dashboard: {\n      label: '\u30AB\u30B9\u30BF\u30DE\u30FC\u30B5\u30FC\u30D3\u30B9',\n      description: '\u30B1\u30FC\u30B9\u8CA0\u8377\u3001SLA\u5065\u5168\u6027\u3001\u89E3\u6C7A\u30D1\u30D5\u30A9\u30FC\u30DE\u30F3\u30B9',\n      widgets: {\n        open_cases: { title: '\u30AA\u30FC\u30D7\u30F3\u30B1\u30FC\u30B9', description: '\u307E\u3060\u30AF\u30ED\u30FC\u30BA\u3055\u308C\u3066\u3044\u306A\u3044\u30B1\u30FC\u30B9' },\n        critical_cases: { title: '\u91CD\u5927\u30B1\u30FC\u30B9', description: '\u512A\u5148\u5EA6\u300C\u91CD\u5927\u300D\u306E\u30AA\u30FC\u30D7\u30F3\u30B1\u30FC\u30B9' },\n        avg_resolution_time: { title: '\u5E73\u5747\u89E3\u6C7A\u6642\u9593', description: '\u30AF\u30ED\u30FC\u30BA\u307E\u3067\u306E\u5E73\u5747\u6642\u9593\uFF08\u6642\uFF09' },\n        sla_violations: { title: 'SLA \u9055\u53CD', description: 'SLA \u3092\u8D85\u904E\u3057\u305F\u30B1\u30FC\u30B9' },\n        cases_by_status: { title: '\u30B9\u30C6\u30FC\u30BF\u30B9\u5225\u30B1\u30FC\u30B9', description: '\u30D1\u30A4\u30D7\u30E9\u30A4\u30F3\u5168\u4F53\u306E\u30EF\u30FC\u30AF\u30ED\u30FC\u30C9\u5206\u5E03' },\n        cases_by_priority: { title: '\u512A\u5148\u5EA6\u5225\u30B1\u30FC\u30B9', description: '\u7DCA\u6025\u5EA6\u5225\u306E\u30AA\u30FC\u30D7\u30F3\u30B1\u30FC\u30B9\u69CB\u6210' },\n        cases_by_origin: { title: '\u767A\u751F\u6E90\u5225\u30B1\u30FC\u30B9', description: '\u30B1\u30FC\u30B9\u306E\u6D41\u5165\u30C1\u30E3\u30CD\u30EB' },\n        daily_case_volume: { title: '\u65E5\u6B21\u30B1\u30FC\u30B9\u4EF6\u6570', description: '\u904E\u53BB30\u65E5\u9593\u306E\u65B0\u898F\u30B1\u30FC\u30B9' },\n        sla_compliance_gauge: { title: 'SLA \u9054\u6210\u7387', description: '\u5F53\u671F SLA \u5185\u306B\u89E3\u6C7A\u3057\u305F\u30B1\u30FC\u30B9\u306E\u5272\u5408' },\n        kb_deflection_rate: { title: '\u30CA\u30EC\u30C3\u30B8\u89E3\u6C7A\u7387', description: '\u30AF\u30ED\u30FC\u30BA\u3057\u305F\u30B1\u30FC\u30B9\u306E\u3046\u3061\u30CA\u30EC\u30C3\u30B8\u8A18\u4E8B\u3067\u89E3\u6C7A\u3057\u305F\u5272\u5408' },\n        kb_resolved_cases: { title: '\u30CA\u30EC\u30C3\u30B8\u3067\u89E3\u6C7A', description: '\u89E3\u6C7A\u3057\u305F\u8A18\u4E8B\u304C\u7D10\u3065\u304F\u30AF\u30ED\u30FC\u30BA\u6E08\u307F\u30B1\u30FC\u30B9' },\n        closed_cases_total: { title: '\u30AF\u30ED\u30FC\u30BA\u6E08\u307F\u30B1\u30FC\u30B9', description: '\u30CA\u30EC\u30C3\u30B8\u89E3\u6C7A\u7387\u306E\u5206\u6BCD' },\n        top_resolving_articles: { title: '\u89E3\u6C7A\u4EF6\u6570\u306E\u591A\u3044\u8A18\u4E8B', description: '\u89E3\u6C7A\u3057\u305F\u30AF\u30ED\u30FC\u30BA\u6E08\u307F\u30B1\u30FC\u30B9\u6570\u3067\u4E26\u3079\u305F\u30CA\u30EC\u30C3\u30B8\u8A18\u4E8B' },\n        my_open_cases_by_priority: { title: '\u512A\u5148\u5EA6\u5225\u306E\u79C1\u306E\u30AA\u30FC\u30D7\u30F3\u30B1\u30FC\u30B9', description: '\u3042\u306A\u305F\u306E\u30AA\u30FC\u30D7\u30F3\u30B1\u30FC\u30B9\u3068\u305D\u306ESLA\u9055\u53CD\u7387\u3092\u512A\u5148\u5EA6\u5225\u306B\u96C6\u8A08' },\n      },\n    },\n  },\n  // `title` / `subtitle` translate the page's `page:header`; `title` falls back\n  // to `label` when omitted, so it is authored only where the two differ.\n  // Header strings carrying `{field}` tokens keep the token spelling verbatim \u2014\n  // the console substitutes on the raw key, so a translated token resolves to\n  // nothing and the header renders blank.\n  datasets: {\n    account_metrics: {\n      label: '\u53D6\u5F15\u5148\u6307\u6A19',\n      description: '\u696D\u7A2E\u30FB\u7A2E\u5225\u3054\u3068\u306B\u53D6\u5F15\u5148\u6570\u3092\u96C6\u8A08\u3059\u308B\u30BB\u30DE\u30F3\u30C6\u30A3\u30C3\u30AF\u30EC\u30A4\u30E4\u30FC',\n      dimensions: {\n        industry: {\n          label: '\u696D\u7A2E',\n        },\n        type: {\n          label: '\u7A2E\u5225',\n        },\n        created_at: {\n          label: '\u4F5C\u6210\u65E5',\n        },\n      },\n      measures: {\n        account_count: {\n          label: '\u53D6\u5F15\u5148\u6570',\n        },\n        annual_revenue_sum: {\n          label: '\u5E74\u9593\u58F2\u4E0A',\n        },\n      },\n    },\n    case_metrics: {\n      label: '\u30B1\u30FC\u30B9\u6307\u6A19',\n      description: '\u30B1\u30FC\u30B9\u6570\u30FB\u89E3\u6C7A\u6642\u9593\u30FBSLA \u3092\u96C6\u8A08\u3059\u308B\u30BB\u30DE\u30F3\u30C6\u30A3\u30C3\u30AF\u30EC\u30A4\u30E4\u30FC',\n      dimensions: {\n        created_at: {\n          label: '\u4F5C\u6210\u65E5',\n        },\n        origin: {\n          label: '\u767A\u751F\u5143',\n        },\n        priority: {\n          label: '\u512A\u5148\u5EA6',\n        },\n        resolved_article: {\n          label: '\u89E3\u6C7A\u306B\u4F7F\u7528\u3057\u305F\u30CA\u30EC\u30C3\u30B8\u8A18\u4E8B',\n        },\n        status: {\n          label: '\u30B9\u30C6\u30FC\u30BF\u30B9',\n        },\n        type: {\n          label: '\u7A2E\u5225',\n        },\n      },\n      measures: {\n        avg_resolution: {\n          label: '\u5E73\u5747\u89E3\u6C7A\u6642\u9593\uFF08\u6642\u9593\uFF09',\n        },\n        avg_sla_violated: {\n          label: 'SLA \u9055\u53CD\u7387',\n        },\n        case_count: {\n          label: '\u30B1\u30FC\u30B9\u6570',\n        },\n        closed_count: {\n          label: '\u30AF\u30ED\u30FC\u30BA\u6E08\u307F\u30B1\u30FC\u30B9',\n        },\n        kb_deflection_rate: {\n          label: '\u30CA\u30EC\u30C3\u30B8\u30D9\u30FC\u30B9\u81EA\u5DF1\u89E3\u6C7A\u7387',\n        },\n        kb_resolved_count: {\n          label: '\u30CA\u30EC\u30C3\u30B8\u30D9\u30FC\u30B9\u3067\u89E3\u6C7A\u3057\u305F\u4EF6\u6570',\n        },\n        sla_compliance_rate: {\n          label: 'SLA \u9075\u5B88\u7387',\n        },\n        sla_met_count: {\n          label: 'SLA \u3092\u6E80\u305F\u3057\u305F\u30B1\u30FC\u30B9',\n        },\n      },\n    },\n    contact_metrics: {\n      label: '\u53D6\u5F15\u5148\u8CAC\u4EFB\u8005\u6307\u6A19',\n      description: '\u53D6\u5F15\u5148\u8CAC\u4EFB\u8005\u6570\u3092\u96C6\u8A08\u3059\u308B\u30BB\u30DE\u30F3\u30C6\u30A3\u30C3\u30AF\u30EC\u30A4\u30E4\u30FC',\n      measures: {\n        contact_count: {\n          label: '\u53D6\u5F15\u5148\u8CAC\u4EFB\u8005\u6570',\n        },\n      },\n    },\n    event_metrics: {\n      label: '\u6D3B\u52D5\u6307\u6A19',\n      description: '\u4F1A\u8B70\u30FB\u901A\u8A71\u30FB\u63A5\u89E6\u306E\u65B0\u3057\u3055\u3092\u96C6\u8A08\u3059\u308B\u30BB\u30DE\u30F3\u30C6\u30A3\u30C3\u30AF\u30EC\u30A4\u30E4\u30FC',\n      dimensions: {\n        owner: {\n          label: '\u6240\u6709\u8005',\n        },\n        related_to_type: {\n          label: '\u95A2\u9023\u5148',\n        },\n        start_datetime: {\n          label: '\u6D3B\u52D5\u9031',\n        },\n        status: {\n          label: '\u30B9\u30C6\u30FC\u30BF\u30B9',\n        },\n        type: {\n          label: '\u6D3B\u52D5\u7A2E\u5225',\n        },\n      },\n      measures: {\n        avg_minutes: {\n          label: '\u5E73\u5747\u6240\u8981\u6642\u9593',\n        },\n        event_count: {\n          label: '\u6D3B\u52D5\u4EF6\u6570',\n        },\n        total_minutes: {\n          label: '\u5408\u8A08\u5206\u6570',\n        },\n      },\n    },\n    forecast_metrics: {\n      label: '\u30D5\u30A9\u30FC\u30AD\u30E3\u30B9\u30C8\u6307\u6A19',\n      description: '\u62C5\u5F53\u8005\u3054\u3068\u306E\u76EE\u6A19\u30FB\u9054\u6210\u7387\u30FB\u30D1\u30A4\u30D7\u30E9\u30A4\u30F3\u30AB\u30D0\u30EC\u30C3\u30B8\u3092\u96C6\u8A08\u3059\u308B\u30BB\u30DE\u30F3\u30C6\u30A3\u30C3\u30AF\u30EC\u30A4\u30E4\u30FC',\n      dimensions: {\n        owner: {\n          label: '\u6240\u6709\u8005',\n        },\n        period: {\n          label: '\u671F\u9593\u7A2E\u5225',\n        },\n        period_label: {\n          label: '\u671F\u9593',\n        },\n        period_start: {\n          label: '\u671F\u9593\u958B\u59CB',\n        },\n      },\n      measures: {\n        attainment: {\n          label: '\u9054\u6210\u7387',\n        },\n        closed_sum: {\n          label: '\u30AF\u30ED\u30FC\u30BA\u6E08\u307F',\n        },\n        commit_sum: {\n          label: '\u30B3\u30DF\u30C3\u30C8',\n        },\n        pipeline_sum: {\n          label: '\u30D1\u30A4\u30D7\u30E9\u30A4\u30F3',\n        },\n        quota_sum: {\n          label: '\u76EE\u6A19',\n        },\n      },\n    },\n    lead_metrics: {\n      label: '\u30EA\u30FC\u30C9\u6307\u6A19',\n      description: '\u30EA\u30FC\u30C9\u6570\u3092\u96C6\u8A08\u3059\u308B\u30BB\u30DE\u30F3\u30C6\u30A3\u30C3\u30AF\u30EC\u30A4\u30E4\u30FC',\n      dimensions: {\n        created_at: {\n          label: '\u4F5C\u6210\u65E5',\n        },\n        last_contacted_date: {\n          label: '\u6700\u7D42\u63A5\u89E6\u65E5',\n        },\n        lead_source: {\n          label: '\u30BD\u30FC\u30B9',\n        },\n        status: {\n          label: '\u30B9\u30C6\u30FC\u30BF\u30B9',\n        },\n      },\n      measures: {\n        lead_count: {\n          label: '\u30EA\u30FC\u30C9\u6570',\n        },\n      },\n    },\n    opportunity_metrics: {\n      label: '\u5546\u8AC7\u6307\u6A19',\n      description: '\u55B6\u696D\u30D1\u30A4\u30D7\u30E9\u30A4\u30F3\u306E\u4EF6\u6570\u3068\u91D1\u984D\u3092\u96C6\u8A08\u3059\u308B\u30BB\u30DE\u30F3\u30C6\u30A3\u30C3\u30AF\u30EC\u30A4\u30E4\u30FC',\n      dimensions: {\n        account_industry: {\n          label: '\u53D6\u5F15\u5148\u306E\u696D\u7A2E',\n        },\n        close_date: {\n          label: '\u5B8C\u4E86\u4E88\u5B9A\u65E5',\n        },\n        close_quarter: {\n          label: '\u5B8C\u4E86\u56DB\u534A\u671F',\n        },\n        forecast_category: {\n          label: '\u30D5\u30A9\u30FC\u30AD\u30E3\u30B9\u30C8\u533A\u5206',\n        },\n        lead_source: {\n          label: '\u30EA\u30FC\u30C9\u30BD\u30FC\u30B9',\n        },\n        loss_reason: {\n          label: '\u5931\u6CE8\u7406\u7531',\n        },\n        owner: {\n          label: '\u6240\u6709\u8005',\n        },\n        stage: {\n          label: '\u30B9\u30C6\u30FC\u30B8',\n        },\n        type: {\n          label: '\u5546\u8AC7\u7A2E\u5225',\n        },\n        win_reason: {\n          label: '\u53D7\u6CE8\u7406\u7531',\n        },\n      },\n      measures: {\n        avg_amount: {\n          label: '\u5E73\u5747\u5546\u8AC7\u91D1\u984D',\n        },\n        avg_probability: {\n          label: '\u5E73\u5747\u78BA\u5EA6',\n        },\n        decided_count: {\n          label: '\u6C7A\u7740\u3057\u305F\u5546\u8AC7',\n        },\n        lost_amount: {\n          label: '\u5931\u6CE8\u91D1\u984D',\n        },\n        lost_count: {\n          label: '\u5931\u6CE8\u4EF6\u6570',\n        },\n        opp_count: {\n          label: '\u5546\u8AC7\u6570',\n        },\n        total_amount: {\n          label: '\u5408\u8A08\u91D1\u984D',\n        },\n        win_rate: {\n          label: '\u53D7\u6CE8\u7387',\n        },\n        won_amount: {\n          label: '\u53D7\u6CE8\u91D1\u984D',\n        },\n        won_count: {\n          label: '\u53D7\u6CE8\u4EF6\u6570',\n        },\n      },\n    },\n    product_metrics: {\n      label: '\u88FD\u54C1\u6307\u6A19',\n      description: '\u88FD\u54C1\u30AB\u30BF\u30ED\u30B0\u306E\u4EF6\u6570\u3068\u5B9A\u4FA1\u3092\u96C6\u8A08\u3059\u308B\u30BB\u30DE\u30F3\u30C6\u30A3\u30C3\u30AF\u30EC\u30A4\u30E4\u30FC',\n      dimensions: {\n        category: {\n          label: '\u30AB\u30C6\u30B4\u30EA',\n        },\n      },\n      measures: {\n        list_price_sum: {\n          label: '\u5B9A\u4FA1\u5408\u8A08',\n        },\n        product_count: {\n          label: '\u88FD\u54C1\u6570',\n        },\n      },\n    },\n    task_metrics: {\n      label: '\u30BF\u30B9\u30AF\u6307\u6A19',\n      description: '\u30BF\u30B9\u30AF\u306E\u4F5C\u696D\u91CF\u3068\u5B8C\u4E86\u72B6\u6CC1\u3092\u96C6\u8A08\u3059\u308B\u30BB\u30DE\u30F3\u30C6\u30A3\u30C3\u30AF\u30EC\u30A4\u30E4\u30FC',\n      dimensions: {\n        due_date: {\n          label: '\u671F\u9650',\n        },\n        is_completed: {\n          label: '\u5B8C\u4E86\u6E08\u307F',\n        },\n        is_overdue: {\n          label: '\u671F\u9650\u8D85\u904E',\n        },\n        priority: {\n          label: '\u512A\u5148\u5EA6',\n        },\n        priority_rank: {\n          label: '\u7DCA\u6025\u5EA6',\n        },\n        status: {\n          label: '\u30B9\u30C6\u30FC\u30BF\u30B9',\n        },\n        type: {\n          label: '\u7A2E\u5225',\n        },\n      },\n      measures: {\n        avg_progress: {\n          label: '\u5E73\u5747\u9032\u6357',\n        },\n        task_count: {\n          label: '\u30BF\u30B9\u30AF\u6570',\n        },\n      },\n    },\n  },\n  pages: {\n    account_detail_page: {\n      label: '\u53D6\u5F15\u5148\u8A73\u7D30',\n      description: '\u30B9\u30ED\u30C3\u30C8\u69CB\u6210\u306E\u53D6\u5F15\u5148\u30EC\u30B3\u30FC\u30C9\u30DA\u30FC\u30B8 \u2014 \u30AB\u30B9\u30BF\u30E0\u30D8\u30C3\u30C0\u30FC\u3068\u5E38\u8A2D\u306E\u30C7\u30A3\u30B9\u30AB\u30C3\u30B7\u30E7\u30F3\u30D5\u30A3\u30FC\u30C9\u3002',\n      title: '{name}',\n      subtitle: '{industry} \u00B7 {type}',\n      components: {\n        account_chatter: { label: '\u30C7\u30A3\u30B9\u30AB\u30C3\u30B7\u30E7\u30F3' },\n      },\n    },\n    account_workbench: {\n      label: '\u53D6\u5F15\u5148\u30EF\u30FC\u30AF\u30D9\u30F3\u30C1',\n      description: '\u55B6\u696D\u30C1\u30FC\u30E0\u5411\u3051\u306B\u53B3\u9078\u3057\u305F\u53D6\u5F15\u5148\u30EA\u30B9\u30C8\u3002\u30AF\u30A4\u30C3\u30AF\u30D5\u30A3\u30EB\u30BF\u30FC\u306E\u307F\u3067\u3001\u30D3\u30E5\u30FC\u7BA1\u7406\u306F\u884C\u3044\u307E\u305B\u3093\u3002',\n    },\n    app_launcher_page: {\n      label: '\u30A2\u30D7\u30EA\u30E9\u30F3\u30C1\u30E3\u30FC',\n      description: '\u3059\u3079\u3066\u306E\u30A2\u30D7\u30EA\u30B1\u30FC\u30B7\u30E7\u30F3\u306B\u30A2\u30AF\u30BB\u30B9\u3059\u308B\u305F\u3081\u306E\u7D71\u5408\u30CF\u30D6',\n      subtitle: '\u958B\u59CB\u3059\u308B\u30A2\u30D7\u30EA\u3092\u9078\u629E\u3057\u3066\u304F\u3060\u3055\u3044',\n      components: {\n        app_search: { label: '\u30A2\u30D7\u30EA\u3092\u691C\u7D22' },\n        app_grid: { label: '\u30A2\u30D7\u30EA\u30B0\u30EA\u30C3\u30C9' },\n      },\n    },\n    case_detail_page: {\n      label: '\u30B1\u30FC\u30B9\u8A73\u7D30',\n      description: '\u30B5\u30FC\u30D3\u30B9\u62C5\u5F53\u8005\u5411\u3051\u306E\u30B1\u30FC\u30B9\u30EC\u30B3\u30FC\u30C9\u30DA\u30FC\u30B8\uFF1A\u30CF\u30A4\u30E9\u30A4\u30C8\u3001SLA \u30D1\u30B9\u3001\u8A73\u7D30\u3001\u6D3B\u52D5\u30BF\u30A4\u30E0\u30E9\u30A4\u30F3\u3002',\n      title: '{case_number} \u00B7 {subject}',\n      subtitle: '{crm_account}',\n      components: {\n        case_highlights: { label: '\u91CD\u8981\u60C5\u5831' },\n        case_status_path: { label: '\u30B1\u30FC\u30B9\u30B9\u30C6\u30FC\u30BF\u30B9\u306E\u9032\u6357' },\n        case_details: { label: '\u30B1\u30FC\u30B9\u8A73\u7D30\u60C5\u5831' },\n      },\n    },\n    lead_detail_page: {\n      label: '\u30EA\u30FC\u30C9\u8A73\u7D30',\n      description: '\u30CF\u30A4\u30E9\u30A4\u30C8\u30FB\u8A73\u7D30\u30FB\u95A2\u9023\u60C5\u5831\u3092\u5099\u3048\u305F\u30EA\u30FC\u30C9\u306E\u7DCF\u5408\u8A73\u7D30\u30DA\u30FC\u30B8\u3002',\n      title: '{first_name} {last_name}',\n      subtitle: '{company}',\n      components: {\n        lead_duplicate_alert_confirmed: { label: '\u91CD\u8907\u78BA\u5B9A\u306E\u8B66\u544A' },\n        lead_duplicate_alert_suspected: { label: '\u91CD\u8907\u306E\u7591\u3044\u306E\u8B66\u544A' },\n        lead_highlights: { label: '\u91CD\u8981\u60C5\u5831' },\n        lead_path: { label: '\u30EA\u30FC\u30C9\u30B9\u30C6\u30FC\u30BF\u30B9\u306E\u9032\u6357' },\n        main_tabs: { label: '\u30EA\u30FC\u30C9\u60C5\u5831\u30BF\u30D6' },\n        lead_details: { label: '\u30EA\u30FC\u30C9\u8A73\u7D30\u60C5\u5831' },\n        related_accordion: { label: '\u95A2\u9023\u30EC\u30B3\u30FC\u30C9' },\n        related_tasks: { title: '\u672A\u5B8C\u4E86\u306E\u30BF\u30B9\u30AF', label: '\u30BF\u30B9\u30AF' },\n        lead_activity: { label: '\u6D3B\u52D5\u30BF\u30A4\u30E0\u30E9\u30A4\u30F3' },\n        lead_history: { label: '\u9805\u76EE\u5C65\u6B74' },\n      },\n    },\n    opportunity_detail_page: {\n      label: '\u5546\u8AC7\u8A73\u7D30',\n      description: '\u30B9\u30C6\u30FC\u30B8\u30D1\u30B9\u30FB\u30CF\u30A4\u30E9\u30A4\u30C8\u30FB\u8A73\u7D30\u30FB\u95A2\u9023\u30EA\u30B9\u30C8\u3092\u5099\u3048\u305F\u5546\u8AC7\u306E\u7DCF\u5408\u8A73\u7D30\u30DA\u30FC\u30B8\u3002',\n      title: '{name}',\n      subtitle: '{crm_account}',\n      components: {\n        opp_highlights: { label: '\u91CD\u8981\u60C5\u5831' },\n        opp_stage_path: { label: '\u5546\u8AC7\u30B9\u30C6\u30FC\u30B8\u306E\u9032\u6357' },\n        opp_details: { label: '\u5546\u8AC7\u8A73\u7D30\u60C5\u5831' },\n      },\n    },\n    sales_home_page: {\n      label: '\u55B6\u696D\u30DB\u30FC\u30E0',\n      description: '\u4E3B\u8981\u6307\u6A19\u3068\u30AF\u30A4\u30C3\u30AF\u30A2\u30AF\u30B7\u30E7\u30F3\u3092\u307E\u3068\u3081\u305F\u55B6\u696D\u30C1\u30FC\u30E0\u306E\u30DB\u30FC\u30E0\u30DA\u30FC\u30B8',\n      title: '\u55B6\u696D\u30C0\u30C3\u30B7\u30E5\u30DC\u30FC\u30C9',\n      subtitle: '\u304A\u304B\u3048\u308A\u306A\u3055\u3044',\n      components: {\n        kpi_revenue_won: {\n          label: '\u53D7\u6CE8\u58F2\u4E0A',\n        },\n        kpi_deals_won: {\n          label: '\u53D7\u6CE8\u4EF6\u6570',\n        },\n        kpi_pipeline_value: {\n          label: '\u30D1\u30A4\u30D7\u30E9\u30A4\u30F3\u91D1\u984D',\n        },\n        kpi_open_leads: {\n          label: '\u30AA\u30FC\u30D7\u30F3\u30EA\u30FC\u30C9',\n        },\n        home_upcoming_events: {\n          label: '\uD83D\uDCC5 \u958B\u50AC\u4E88\u5B9A \u00B7 \u76F4\u8FD1\u9806',\n        },\n        quick_create: { title: '\u30AF\u30A4\u30C3\u30AF\u4F5C\u6210', label: '\u30AF\u30A4\u30C3\u30AF\u4F5C\u6210' },\n        key_metrics: { title: '\u4E3B\u8981\u696D\u7E3E\u8A55\u4FA1\u6307\u6A19', label: '\u4E3B\u8981\u6307\u6A19' },\n        home_tabs: { label: '\u30DB\u30FC\u30E0\u30BF\u30D6' },\n        home_my_leads: { label: '\u79C1\u306E\u30EA\u30FC\u30C9' },\n        home_my_deals: { label: '\u79C1\u306E\u30AA\u30FC\u30D7\u30F3\u5546\u8AC7' },\n        home_my_tasks: { label: '\u79C1\u306E\u30AA\u30FC\u30D7\u30F3\u30BF\u30B9\u30AF' },\n        ai_briefing: {\n          title: 'AI \u30A2\u30B7\u30B9\u30BF\u30F3\u30C8\u306B\u8CEA\u554F',\n          label: '\u4ECA\u65E5\u306E AI \u30A2\u30B7\u30B9\u30BF\u30F3\u30C8',\n        },\n        upcoming_events: { title: '\u4ECA\u5F8C\u306E\u4E88\u5B9A', label: '\u4ECA\u5F8C\u306E\u4E88\u5B9A' },\n      },\n    },\n    utility_bar_page: {\n      label: '\u30E6\u30FC\u30C6\u30A3\u30EA\u30C6\u30A3\u30D0\u30FC',\n      description: '\u30D5\u30ED\u30FC\u30C6\u30A3\u30F3\u30B0\u30C4\u30FC\u30EB\u3078\u306E\u30AF\u30A4\u30C3\u30AF\u30A2\u30AF\u30BB\u30B9\u30D0\u30FC',\n      components: {\n        notifications_panel: { label: '\u901A\u77E5' },\n        quick_notes: { title: '\u30AF\u30A4\u30C3\u30AF\u30E1\u30E2', label: '\u30AF\u30A4\u30C3\u30AF\u30E1\u30E2' },\n        quick_search: { label: '\u30AF\u30A4\u30C3\u30AF\u691C\u7D22' },\n      },\n    },\n  },\n  // Screen-flow copy (#1210, #1975). Keyed `flows.<flow>.label`,\n  // `screens.<node>.title` and `screens.<node>.fields.<field>.{label,placeholder}`\n  // \u2014 the keys `os lint`'s `i18n/missing-flow` names, read by the console's\n  // flow runner since @objectstack 17.7.0 (the spec's `flows` liveness row is\n  // `live` there). A screen with no authored `title` shows its flow's label in\n  // every locale, so each `screen_1.title` repeats the flow label. Since\n  // 18.0.0-next.0 three more surfaces are keys the engine reads in the run's\n  // locale, and `i18n/missing-flow` names each missing one: a select field's\n  // `options.<value>` (worded as the object field's own option in this pack),\n  // an authored screen `description`, and a refusing `end` node's\n  // `refusals.<node>.message`. A translated description or message is a text\n  // slot like the one it translates, so a hole in it is `{{ }}`.\n  // The discount ceiling is interpolated from `QUOTE_DISCOUNT_CEILING`, never\n  // retyped: the number lives in `_thresholds.ts` alone (#1711).\n  flows: {\n    campaign_enrollment: {\n      label: '\u30AD\u30E3\u30F3\u30DA\u30FC\u30F3\u306B\u30E1\u30F3\u30D0\u30FC\u3092\u767B\u9332',\n      screens: {\n        screen_1: {\n          title: '\u30AD\u30E3\u30F3\u30DA\u30FC\u30F3\u306B\u30E1\u30F3\u30D0\u30FC\u3092\u767B\u9332',\n          fields: {\n            memberSource: { label: '\u767B\u9332\u3059\u308B\u30E1\u30F3\u30D0\u30FC\u306E\u7A2E\u985E', options: { leads: '\u30EA\u30FC\u30C9', contacts: '\u53D6\u5F15\u5148\u8CAC\u4EFB\u8005' } },\n            leadStatus: { label: '\u767B\u9332\u3059\u308B\u30EA\u30FC\u30C9\u306E\u30B9\u30C6\u30FC\u30BF\u30B9', options: { new: '\u65B0\u898F', contacted: '\u30B3\u30F3\u30BF\u30AF\u30C8\u6E08\u307F', qualified: '\u9069\u683C' } },\n            contactDepartment: {\n              label: '\u767B\u9332\u3059\u308B\u53D6\u5F15\u5148\u8CAC\u4EFB\u8005\u306E\u90E8\u9580',\n              options: { executive: '\u7D4C\u55B6\u5C64', sales: '\u55B6\u696D\u90E8', marketing: '\u30DE\u30FC\u30B1\u30C6\u30A3\u30F3\u30B0\u90E8', engineering: '\u30A8\u30F3\u30B8\u30CB\u30A2\u30EA\u30F3\u30B0\u90E8', support: '\u30B5\u30DD\u30FC\u30C8\u90E8', finance: '\u7D4C\u7406\u90E8', hr: '\u4EBA\u4E8B\u90E8', operations: '\u30AA\u30DA\u30EC\u30FC\u30B7\u30E7\u30F3\u90E8' },\n            },\n          },\n        },\n      },\n    },\n    escalate_case: {\n      label: '\u30B1\u30FC\u30B9\u3092\u30A8\u30B9\u30AB\u30EC\u30FC\u30C8',\n      screens: { screen_1: { title: '\u30B1\u30FC\u30B9\u3092\u30A8\u30B9\u30AB\u30EC\u30FC\u30C8', fields: { reason: { label: '\u30A8\u30B9\u30AB\u30EC\u30FC\u30B7\u30E7\u30F3\u7406\u7531' } } } },\n    },\n    close_case: {\n      label: '\u30B1\u30FC\u30B9\u3092\u30AF\u30ED\u30FC\u30BA',\n      screens: {\n        screen_1: {\n          title: '\u30B1\u30FC\u30B9\u3092\u30AF\u30ED\u30FC\u30BA',\n          fields: {\n            resolution: { label: '\u89E3\u6C7A\u5185\u5BB9' },\n            resolved_by_article: { label: '\u89E3\u6C7A\u306B\u4F7F\u3063\u305F\u30CA\u30EC\u30C3\u30B8\u8A18\u4E8B\uFF08\u4EFB\u610F\uFF09' },\n          },\n        },\n      },\n    },\n    claim_case: {\n      label: '\u30B1\u30FC\u30B9\u3092\u5F15\u304D\u53D7\u3051\u308B',\n      screens: {\n        screen_1: {\n          title: '\u30B1\u30FC\u30B9\u3092\u5F15\u304D\u53D7\u3051\u308B',\n          fields: {\n            claimStatus: {\n              label: '\u5BFE\u5FDC\u72B6\u6CC1',\n              options: { in_progress: '\u5BFE\u5FDC\u4E2D', waiting_customer: '\u9867\u5BA2\u306E\u56DE\u7B54\u5F85\u3061', waiting_support: '\u30B5\u30DD\u30FC\u30C8\u306E\u56DE\u7B54\u5F85\u3061' },\n            },\n          },\n        },\n      },\n    },\n    lead_conversion: {\n      label: '\u30EA\u30FC\u30C9\u5909\u63DB\u30D7\u30ED\u30BB\u30B9',\n      screens: {\n        screen_1: {\n          title: '\u30EA\u30FC\u30C9\u5909\u63DB\u30D7\u30ED\u30BB\u30B9',\n          // The duplicate warning's text is a variable the flow assigns; this\n          // key can only carry the hole that shows it.\n          description: '{{duplicateWarning}}',\n          fields: {\n            createOpportunity: { label: '\u5546\u8AC7\u3092\u4F5C\u6210\u3057\u307E\u3059\u304B\uFF1F' },\n            opportunityName: { label: '\u5546\u8AC7\u540D' },\n            opportunityAmount: { label: '\u5546\u8AC7\u91D1\u984D' },\n            closeDate: { label: '\u5B8C\u4E86\u4E88\u5B9A\u65E5' },\n          },\n        },\n        refuse_confirmed_duplicate: {\n          title: '\u5909\u63DB\u306F\u62D2\u5426\u3055\u308C\u307E\u3057\u305F',\n          description:\n            '\u3053\u306E\u30EA\u30FC\u30C9\u306E\u91CD\u8907\u30B9\u30C6\u30FC\u30BF\u30B9\u306F\u300C\u91CD\u8907\u78BA\u5B9A\u300D\u3067\u3059\u3002\u30EC\u30D3\u30E5\u30FC\u62C5\u5F53\u8005\u304C\u65E2\u5B58\u306E\u30EC\u30B3\u30FC\u30C9\u3068\u7167\u5408\u3057\u3001\u91CD\u8907\u3067\u3042\u308B\u3068\u8A18\u9332\u3057\u307E\u3057\u305F\u3002\u5909\u63DB\u3059\u308B\u3068\u3001\u540C\u3058\u8CFC\u5165\u8005\u306B\u5BFE\u3057\u3066\u53D6\u5F15\u5148\u30FB\u53D6\u5F15\u5148\u8CAC\u4EFB\u8005\u30FB\u5546\u8AC7\u304C\u3082\u3046 1 \u4EF6\u305A\u3064\u4F5C\u6210\u3055\u308C\u307E\u3059\u3002\u6B8B\u3059\u30EC\u30B3\u30FC\u30C9\u306F\u3053\u306E\u30EA\u30FC\u30C9\u306E\u300C\u91CD\u8907\u7BA1\u7406\u300D\u30BB\u30AF\u30B7\u30E7\u30F3\u306B\u8868\u793A\u3055\u308C\u3066\u3044\u307E\u3059\u3002\u4EE3\u308F\u308A\u306B\u3001\u3053\u306E\u30EA\u30FC\u30C9\u3092\u91CD\u8907\u3068\u3057\u3066\u4E0D\u9069\u683C\u306B\u3057\u3066\u304F\u3060\u3055\u3044\u3002\u5909\u63DB\u3092\u518D\u3073\u53EF\u80FD\u306B\u3067\u304D\u308B\u306E\u306F\u3001\u305D\u306E\u5224\u5B9A\u3092\u898B\u76F4\u3059\u30EC\u30D3\u30E5\u30FC\u62C5\u5F53\u8005\u3060\u3051\u3067\u3059\u3002',\n        },\n        refuse_unapproved: {\n          title: '\u5909\u63DB\u306F\u62D2\u5426\u3055\u308C\u307E\u3057\u305F',\n          description:\n            '\u3053\u306E\u30EA\u30FC\u30C9\u306F\u307E\u3060\u5909\u63DB\u306E\u627F\u8A8D\u3092\u5F97\u3066\u3044\u307E\u305B\u3093\u3002\u53D6\u5F15\u5148\u30FB\u53D6\u5F15\u5148\u8CAC\u4EFB\u8005\u30FB\u5546\u8AC7\u306B\u5909\u63DB\u3059\u308B\u306B\u306F\u3001\u5148\u306B\u627F\u8A8D\u8005\u306E\u627F\u8A8D\u304C\u5FC5\u8981\u3067\u3059\u3002\u30EA\u30FC\u30C9\u306E\u300C\u30B3\u30F3\u30D0\u30FC\u30B8\u30E7\u30F3\u627F\u8A8D\u300D\u9805\u76EE\u3067\u3001\u5224\u65AD\u304C\u307E\u3060\u627F\u8A8D\u5F85\u3061\u304B\u3001\u5374\u4E0B\u3055\u308C\u305F\u304B\u3092\u78BA\u8A8D\u3067\u304D\u307E\u3059\u3002\u305D\u308C\u307E\u3067\u306E\u9593\u3082\u30EA\u30FC\u30C9\u3078\u306E\u5BFE\u5FDC\u306F\u7D9A\u3051\u3066\u304F\u3060\u3055\u3044\u3002\u51CD\u7D50\u3055\u308C\u308B\u3082\u306E\u306F\u3042\u308A\u307E\u305B\u3093\u3002',\n        },\n        refuse_no_match_key: {\n          title: '\u5909\u63DB\u306F\u62D2\u5426\u3055\u308C\u307E\u3057\u305F',\n          description:\n            '\u3053\u306E\u30EA\u30FC\u30C9\u306E\u4F1A\u793E\u540D\u306B\u306F\u7167\u5408\u30AD\u30FC\u304C\u306A\u3044\u305F\u3081\u3001\u5909\u63DB\u3067\u306F\u3069\u306E\u53D6\u5F15\u5148\u306B\u5C5E\u3059\u308B\u304B\u3092\u5224\u65AD\u3067\u304D\u305A\u3001\u63A8\u6E2C\u3082\u3057\u307E\u305B\u3093\u3002\u63A8\u6E2C\u3059\u308B\u3068\u3001\u53D6\u5F15\u5148\u8CAC\u4EFB\u8005\u3068\u5546\u8AC7\u304C\u5225\u306E\u9867\u5BA2\u306E\u4E0B\u306B\u767B\u9332\u3055\u308C\u308B\u304A\u305D\u308C\u304C\u3042\u308A\u307E\u3059\u3002\u30EA\u30FC\u30C9\u306E\u300C\u4F1A\u793E\u540D\u300D\u3092\u4FDD\u5B58\u3059\u308B\u3068\u30AD\u30FC\u304C\u518D\u4F5C\u6210\u3055\u308C\u308B\u306E\u3067\u3001\u3082\u3046\u4E00\u5EA6\u4FDD\u5B58\u3057\u3066\u304B\u3089\u5909\u63DB\u3057\u3066\u304F\u3060\u3055\u3044\u3002\u4F55\u3082\u4F5C\u6210\u3055\u308C\u3066\u3044\u307E\u305B\u3093\u3002',\n        },\n      },\n    },\n    schedule_followup: {\n      label: '\u30D5\u30A9\u30ED\u30FC\u30A2\u30C3\u30D7\u3092\u8A2D\u5B9A',\n      screens: {\n        screen_1: {\n          title: '\u30D5\u30A9\u30ED\u30FC\u30A2\u30C3\u30D7\u3092\u8A2D\u5B9A',\n          fields: {\n            subject: { label: '\u6B21\u306E\u30B9\u30C6\u30C3\u30D7\u306F\uFF1F' },\n            dueDate: { label: '\u671F\u9650' },\n            activityType: {\n              label: '\u6D3B\u52D5\u7A2E\u5225',\n              options: { call: '\u96FB\u8A71', email: '\u30E1\u30FC\u30EB', meeting: '\u4F1A\u8B70', follow_up: '\u30D5\u30A9\u30ED\u30FC\u30A2\u30C3\u30D7', demo: '\u30C7\u30E2', other: '\u305D\u306E\u4ED6' },\n            },\n            priority: { label: '\u512A\u5148\u5EA6', options: { low: '\u4F4E', normal: '\u901A\u5E38', high: '\u9AD8', urgent: '\u7DCA\u6025' } },\n            notes: { label: '\u30E1\u30E2' },\n          },\n        },\n      },\n    },\n    quote_generation: {\n      label: '\u5546\u8AC7\u304B\u3089\u898B\u7A4D\u3092\u4F5C\u6210',\n      refusals: { refuse_held: { message: '\u5148\u306B\u6848\u4EF6\u5316\u627F\u8A8D\u304C\u5FC5\u8981\u3067\u3059\u3002\u300C\u6848\u4EF6\u5316\u627F\u8A8D\u3092\u7533\u8ACB\u300D\u306B\u30C1\u30A7\u30C3\u30AF\u3092\u5165\u308C\u3066\u304F\u3060\u3055\u3044\u3002\u4F55\u3082\u4F5C\u6210\u3055\u308C\u3066\u3044\u307E\u305B\u3093\u3002' } },\n      screens: {\n        screen_1: {\n          title: '\u5546\u8AC7\u304B\u3089\u898B\u7A4D\u3092\u4F5C\u6210',\n          fields: {\n            quoteName: { label: '\u898B\u7A4D\u540D' },\n            expirationDays: { label: '\u6709\u52B9\u671F\u9593\uFF08\u65E5\uFF09' },\n            discount: { label: `\u5272\u5F15\u7387 % (\u2264 ${QUOTE_DISCOUNT_CEILING})`, placeholder: `0-${QUOTE_DISCOUNT_CEILING}` },\n          },\n        },\n      },\n    },\n  },\n};\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/sales/translations/ja-JP/_shared.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/sales/translations/ja-JP\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/sales/translations/ja-JP/_shared.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\n/**\n * \u65E5\u672C\u8A9E (ja-JP) \u2014 values shared by more than one part of this bundle.\n *\n * SPLIT AXIS (#1311): translation NAMESPACE first, then CRM DOMAIN FAMILY.\n * Everything that is not `objects` lives in `./app.ts`; `objects` \u2014 69-78% of\n * every bundle \u2014 is one file per CRM domain family, and a detail object\n * follows its master. A new row goes in the file for ITS family, never in\n * whichever file is already open: that is how one file re-grows past the 70%\n * advisory band `pnpm hygiene` prints. Full rule and rationale:\n * `src/sales/translations/ja-JP.ts`.\n *\n * Every constant here is spread into object rows that live in MORE THAN ONE\n * family file, so it cannot sit in any one of them. A value used by exactly\n * one family lives in that family's file instead \u2014 that split is mechanical,\n * not a judgement call.\n */\n\n/**\n * \u6D3B\u52D5\u30A2\u30AF\u30B7\u30E7\u30F3\u7FA4\uFF08#592\uFF09: `log_call` / `log_meeting` / `schedule_meeting` \u306F\n * \u30EA\u30FC\u30C9\u30FB\u53D6\u5F15\u5148\u8CAC\u4EFB\u8005\u30FB\u53D6\u5F15\u5148\u30FB\u5546\u8AC7\u30FB\u30B1\u30FC\u30B9\u306E\u5404\u30AA\u30D6\u30B8\u30A7\u30AF\u30C8\u3054\u3068\u306B\u767B\u9332\u3055\u308C\u308B\n * \uFF08`objectName` \u3092\u6301\u305F\u306A\u3044\u30B9\u30AF\u30EA\u30D7\u30C8\u30A2\u30AF\u30B7\u30E7\u30F3\u306F\u30C7\u30A3\u30B9\u30D1\u30C3\u30C1\u30E3\u304C\u53C2\u7167\u3057\u306A\u3044\n * \u30AD\u30FC\u306B\u767B\u9332\u3055\u308C\u308B\u305F\u3081 \u2014 #509\uFF09\u3002\u6587\u8A00\u306F 5 \u30AA\u30D6\u30B8\u30A7\u30AF\u30C8\u3067\u540C\u4E00\u306A\u306E\u3067\u3001\u3053\u3053\u3067\n * \u4E00\u5EA6\u3060\u3051\u5B9A\u7FA9\u3057\u3066\u5404 `_actions` \u306B\u5C55\u958B\u3059\u308B\u3002\n */\nexport const activityActions = {\n  log_call: {\n    label: '\u96FB\u8A71\u3092\u8A18\u9332',\n    successMessage: '\u96FB\u8A71\u3092\u8A18\u9332\u3057\u307E\u3057\u305F\uFF01',\n    params: {\n      subject: { label: '\u96FB\u8A71\u306E\u4EF6\u540D' },\n      duration: { label: '\u6240\u8981\u6642\u9593\uFF08\u5206\uFF09' },\n      attendee_contacts: { label: '\u53D6\u5F15\u5148\u8CAC\u4EFB\u8005\u306E\u53C2\u52A0\u8005' },\n      attendee_users: { label: '\u793E\u5185\u53C2\u52A0\u8005' },\n      notes: { label: '\u901A\u8A71\u30E1\u30E2' },\n    },\n  },\n  log_meeting: {\n    label: '\u4F1A\u8B70\u3092\u8A18\u9332',\n    successMessage: '\u4F1A\u8B70\u3092\u8A18\u9332\u3057\u307E\u3057\u305F\uFF01',\n    params: {\n      subject: { label: '\u4F1A\u8B70\u306E\u4EF6\u540D' },\n      duration: { label: '\u6240\u8981\u6642\u9593\uFF08\u5206\uFF09' },\n      attendee_contacts: { label: '\u53D6\u5F15\u5148\u8CAC\u4EFB\u8005\u306E\u53C2\u52A0\u8005' },\n      attendee_users: { label: '\u793E\u5185\u53C2\u52A0\u8005' },\n      notes: { label: '\u8B70\u4E8B\u30E1\u30E2' },\n    },\n  },\n  schedule_meeting: {\n    label: '\u4F1A\u8B70\u3092\u8A2D\u5B9A',\n    successMessage: '\u4F1A\u8B70\u3092\u8A2D\u5B9A\u3057\u307E\u3057\u305F\uFF01',\n    params: {\n      subject: { label: '\u4F1A\u8B70\u306E\u4EF6\u540D' },\n      start_date: { label: '\u958B\u59CB\u65E5 (UTC)' },\n      start_time: { label: '\u958B\u59CB\u6642\u523B (UTC)' },\n      location: { label: '\u5834\u6240' },\n      duration: { label: '\u6240\u8981\u6642\u9593\uFF08\u5206\uFF09' },\n      attendee_contacts: { label: '\u53D6\u5F15\u5148\u8CAC\u4EFB\u8005\u306E\u53C2\u52A0\u8005' },\n      attendee_users: { label: '\u793E\u5185\u53C2\u52A0\u8005' },\n      notes: { label: '\u30A2\u30B8\u30A7\u30F3\u30C0' },\n    },\n  },\n};\n\n/**\n * \u5171\u6709\u30D4\u30C3\u30AF\u30EA\u30B9\u30C8\uFF08`_picklists.ts`\uFF09\u306F\u8907\u6570\u30AA\u30D6\u30B8\u30A7\u30AF\u30C8\u3067\u540C\u4E00\u306E\u5024\u96C6\u5408\u3092\u6301\u3064\u3002\n * \u8A33\u8A9E\u304C\u30AA\u30D6\u30B8\u30A7\u30AF\u30C8\u3054\u3068\u306B\u3076\u308C\u308B\u3068\u3001\u540C\u3058\u30D4\u30C3\u30AF\u30EA\u30B9\u30C8\u304C\u753B\u9762\u306B\u3088\u3063\u3066\u5225\u306E\u8A00\u8449\u3067\n * \u8868\u793A\u3055\u308C\u308B\u4E0D\u5177\u5408\u306B\u306A\u308B\uFF08#494\uFF09\u3002\u3053\u3053\u3067\u4E00\u5EA6\u3060\u3051\u5B9A\u7FA9\u3057\u3066\u5404\u6240\u306B\u5C55\u958B\u3059\u308B\u3002\n * \u30AD\u30FC\u306F\u8868\u793A\u30E9\u30D9\u30EB\u3067\u306F\u306A\u304F **\u4FDD\u5B58\u5024** \u3067\u3042\u308B\u3053\u3068\u306B\u6CE8\u610F\uFF08#494 \u306E\u4E3B\u56E0\uFF09\u3002\n */\nexport const salutationOptions = { mr: 'Mr.', ms: 'Ms.', mrs: 'Mrs.', dr: '\u535A\u58EB', prof: '\u6559\u6388' };\n\nexport const industryOptions = {\n  technology: '\u30C6\u30AF\u30CE\u30ED\u30B8\u30FC', software: '\u30BD\u30D5\u30C8\u30A6\u30A7\u30A2 / SaaS', finance: '\u91D1\u878D',\n  healthcare: '\u30D8\u30EB\u30B9\u30B1\u30A2', retail: '\u5C0F\u58F2', manufacturing: '\u88FD\u9020',\n  education: '\u6559\u80B2', real_estate: '\u4E0D\u52D5\u7523', media: '\u30E1\u30C7\u30A3\u30A2\u30FB\u30A8\u30F3\u30BF\u30E1',\n  logistics: '\u7269\u6D41', hospitality: '\u30DB\u30B9\u30D4\u30BF\u30EA\u30C6\u30A3', energy: '\u30A8\u30CD\u30EB\u30AE\u30FC\u30FB\u516C\u76CA',\n  government: '\u653F\u5E9C\u30FB\u884C\u653F', nonprofit: '\u975E\u55B6\u5229', other: '\u305D\u306E\u4ED6',\n};\n\nexport const leadSourceOptions = {\n  web: '\u30A6\u30A7\u30D6', referral: '\u7D39\u4ECB', event: '\u30A4\u30D9\u30F3\u30C8\u30FB\u5C55\u793A\u4F1A',\n  webinar: '\u30A6\u30A7\u30D3\u30CA\u30FC', partner: '\u30D1\u30FC\u30C8\u30CA\u30FC', advertisement: '\u5E83\u544A',\n  paid_search: '\u6709\u6599\u691C\u7D22', social: '\u30BD\u30FC\u30B7\u30E3\u30EB\u30E1\u30C7\u30A3\u30A2', content: '\u30B3\u30F3\u30C6\u30F3\u30C4\u30FB\u30D6\u30ED\u30B0',\n  cold_call: '\u30B3\u30FC\u30EB\u30C9\u30B3\u30FC\u30EB', email_campaign: '\u30E1\u30FC\u30EB\u30AD\u30E3\u30F3\u30DA\u30FC\u30F3', other: '\u305D\u306E\u4ED6',\n};\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/sales/translations/ja-JP/objects.customer.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/sales/translations/ja-JP\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/sales/translations/ja-JP/objects.customer.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport type { ObjectTranslationData } from '@objectstack/spec/system';\n\nimport { activityActions, salutationOptions, industryOptions, leadSourceOptions } from './_shared';\n\n/**\n * \u65E5\u672C\u8A9E (ja-JP) \u2014 `objects` translations for the CUSTOMER family:\n * the customer record itself \u2014 accounts and the people at them.\n *\n * Roster: `crm_account`, `crm_contact`.\n *\n * SPLIT AXIS (#1311): translation NAMESPACE first, then CRM DOMAIN FAMILY.\n * Everything that is not `objects` lives in `./app.ts`; `objects` \u2014 69-78% of\n * every bundle \u2014 is one file per CRM domain family, and a detail object\n * follows its master. A new row goes in the file for ITS family, never in\n * whichever file is already open: that is how one file re-grows past the 70%\n * advisory band `pnpm hygiene` prints. Full rule and rationale:\n * `src/sales/translations/ja-JP.ts`.\n */\nexport const customer: Record<string, ObjectTranslationData> = {\n  crm_account: {\n    label: '\u53D6\u5F15\u5148',\n    pluralLabel: '\u53D6\u5F15\u5148',\n    description: '\u5F53\u793E\u3068\u53D6\u5F15\u306E\u3042\u308B\u4F01\u696D\u30FB\u7D44\u7E54',\n    fields: {\n      account_number: { label: '\u53D6\u5F15\u5148\u756A\u53F7' },\n      registration_number: {\n        label: '\u767B\u8A18\u756A\u53F7',\n        help: '\u53D6\u5F15\u5148\u304C\u81EA\u56FD\u306E\u767B\u8A18\u6A5F\u95A2\u304B\u3089\u4EA4\u4ED8\u3055\u308C\u305F\u767B\u8A18\u4E0A\u306E\u8B58\u5225\u756A\u53F7\u3002\u5F53\u793E\u304C\u63A1\u756A\u3059\u308B\u53D6\u5F15\u5148\u756A\u53F7\u3068\u306F\u7570\u306A\u308A\u307E\u3059\u3002',\n      },\n      commercial_capability: {\n        label: '\u5546\u8AC7\u53EF\u5426\u533A\u5206',\n        help: '\u3053\u306E\u53D6\u5F15\u5148\u306B\u5BFE\u3057\u3066\u65B0\u898F\u306E\u5546\u8AC7\u3092\u958B\u59CB\u3067\u304D\u308B\u304B\u3069\u3046\u304B\u3002\u6C7A\u6E08\u306E\u307F\u306E\u53D6\u5F15\u5148\u306F\u8ACB\u6C42\u30FB\u5165\u91D1\u306B\u306F\u5F15\u304D\u7D9A\u304D\u5229\u7528\u3067\u304D\u307E\u3059\u304C\u3001\u65B0\u898F\u5546\u8AC7\u3092\u95A2\u9023\u4ED8\u3051\u308B\u3053\u3068\u306F\u3067\u304D\u307E\u305B\u3093\u3002',\n        options: { full: '\u5236\u9650\u306A\u3057', settlement_only: '\u6C7A\u6E08\u306E\u307F' },\n      },\n      incumbent_vendor: { label: '\u73FE\u884C\u30D9\u30F3\u30C0\u30FC', help: '\u5F53\u793E\u304C\u72D9\u3063\u3066\u3044\u308B\u652F\u51FA\u3092\u73FE\u5728\u53D7\u6CE8\u3057\u3066\u3044\u308B\u30D9\u30F3\u30C0\u30FC\u3002' },\n      annual_purchasing_budget: { label: '\u5E74\u9593\u8ABF\u9054\u4E88\u7B97', help: '\u3053\u306E\u53D6\u5F15\u5148\u304C\u4ECA\u5E74\u5EA6\u30D9\u30F3\u30C0\u30FC\u306B\u652F\u51FA\u3059\u308B\u898B\u8FBC\u307F\u984D\u3067\u3042\u308A\u3001\u81EA\u793E\u306E\u58F2\u4E0A\u9AD8\u3067\u306F\u3042\u308A\u307E\u305B\u3093\u3002' },\n      payment_cycle: {\n        label: '\u652F\u6255\u30B5\u30A4\u30AF\u30EB',\n        options: { prepaid: '\u524D\u6255\u3044', net_30: '30\u65E5', net_60: '60\u65E5', net_90: '90\u65E5' },\n      },\n      approval_status: {\n        label: '\u627F\u8A8D\u30B9\u30C6\u30FC\u30BF\u30B9',\n        help: '\u3053\u306E\u53D6\u5F15\u5148\u306E\u627F\u8A8D\u72B6\u6CC1\u3002\u65B0\u898F\u53D6\u5F15\u5148\u306F\u627F\u8A8D\u5F85\u3061\u3067\u4F5C\u6210\u3055\u308C\u3001\u627F\u8A8D\u30C8\u30EC\u30A4\u3067\u5224\u65AD\u3055\u308C\u307E\u3059\u3002',\n        options: { pending: '\u627F\u8A8D\u5F85\u3061', approved: '\u627F\u8A8D\u6E08\u307F', rejected: '\u5374\u4E0B' },\n      },\n      name: { label: '\u53D6\u5F15\u5148\u540D', help: '\u4F1A\u793E\u307E\u305F\u306F\u7D44\u7E54\u306E\u6B63\u5F0F\u540D\u79F0' },\n      name_normalized: {\n        label: '\u53D6\u5F15\u5148\u540D\uFF08\u6B63\u898F\u5316\uFF09',\n        help: '\u30EA\u30FC\u30C9\u5909\u63DB\u306E\u7167\u5408\u30AD\u30FC\u3002\u53D6\u5F15\u5148\u540D\u3092\u5C0F\u6587\u5B57\u5316\u3057\u3001\u524D\u5F8C\u306E\u7A7A\u767D\u3092\u9664\u53BB\u3057\u3066\u3001\u5185\u90E8\u306E\u9023\u7D9A\u3059\u308B\u7A7A\u767D\u3092 1 \u3064\u306B\u307E\u3068\u3081\u305F\u3082\u306E\u3002account_protection \u30D5\u30C3\u30AF\u304C\u81EA\u52D5\u3067\u7DAD\u6301\u3057\u307E\u3059 \u2014 \u76F4\u63A5\u7DE8\u96C6\u3057\u306A\u3044\u3067\u304F\u3060\u3055\u3044\u3002',\n      },\n      display_title: { label: '\u8868\u793A\u540D' },\n      type: {\n        label: '\u30BF\u30A4\u30D7',\n        options: { prospect: '\u898B\u8FBC\u307F\u5BA2', customer: '\u9867\u5BA2', partner: '\u30D1\u30FC\u30C8\u30CA\u30FC', former: '\u904E\u53BB\u306E\u53D6\u5F15\u5148' },\n      },\n      industry: {\n        label: '\u696D\u7A2E',\n        options: { ...industryOptions },\n      },\n      annual_revenue: { label: '\u5E74\u9593\u58F2\u4E0A' },\n      child_account_revenue: { label: '\u5B50\u4F1A\u793E\u5E74\u9593\u58F2\u4E0A\u5408\u8A08', help: '\u76F4\u5C5E\u306E\u5B50\u53D6\u5F15\u5148\u306E\u5E74\u9593\u58F2\u4E0A\u306E\u5408\u8A08\u3002' },\n      number_of_employees: { label: '\u5F93\u696D\u54E1\u6570' },\n      phone: { label: '\u96FB\u8A71\u756A\u53F7' },\n      website: { label: 'Web\u30B5\u30A4\u30C8' },\n      billing_address: { label: '\u8ACB\u6C42\u5148\u4F4F\u6240' },\n      billing_country: {\n        label: '\u8ACB\u6C42\u5148\u56FD',\n        help: '\u8ACB\u6C42\u5148\u4F4F\u6240\u304B\u3089\u5C0E\u51FA \u2014 \u5165\u529B\u3055\u308C\u305F\u56FD\u540D\u3092\u305D\u306E\u307E\u307E\u3001\u524D\u5F8C\u306E\u7A7A\u767D\u3092\u9664\u53BB\u3057\u5927\u6587\u5B57\u5316\u3057\u305F\u5024\u3002',\n      },\n      territory: {\n        label: '\u30C6\u30EA\u30C8\u30EA\u30FC',\n        help: '\u8ACB\u6C42\u5148\u4F4F\u6240\u304B\u3089\u5C0E\u51FA \u2014 \u30C6\u30EA\u30C8\u30EA\u30FC\u5171\u6709\u30EB\u30FC\u30EB\u304C\u7167\u5408\u3059\u308B\u55B6\u696D\u30C6\u30EA\u30C8\u30EA\u30FC\u3002\u62C5\u5F53\u30C1\u30FC\u30E0\u306E\u306A\u3044\u30C6\u30EA\u30C8\u30EA\u30FC\u306E\u53D6\u5F15\u5148\u306F\u300C\u305D\u306E\u4ED6\u300D\u3002',\n        options: { na: '\u5317\u7C73', emea: 'EMEA', other: '\u305D\u306E\u4ED6' },\n      },\n      office_location: { label: '\u30AA\u30D5\u30A3\u30B9\u6240\u5728\u5730' },\n      owner_id: { label: '\u53D6\u5F15\u5148\u6240\u6709\u8005' },\n      parent_account: { label: '\u89AA\u53D6\u5F15\u5148', help: '\u968E\u5C64\u69CB\u9020\u306B\u304A\u3051\u308B\u89AA\u4F1A\u793E' },\n      description: { label: '\u8AAC\u660E' },\n      is_active: { label: '\u6709\u52B9' },\n      last_activity_date: { label: '\u6700\u7D42\u6D3B\u52D5\u65E5' },\n      brand_color: { label: '\u30D6\u30E9\u30F3\u30C9\u30AB\u30E9\u30FC' },\n      logo: { label: '\u4F1A\u793E\u30ED\u30B4' },\n      tier: {\n        label: '\u9867\u5BA2\u30E9\u30F3\u30AF',\n        options: {\n          strategic: '\u6226\u7565\u9867\u5BA2', enterprise: '\u30A8\u30F3\u30BF\u30FC\u30D7\u30E9\u30A4\u30BA',\n          mid_market: '\u30DF\u30C3\u30C9\u30DE\u30FC\u30B1\u30C3\u30C8', smb: '\u4E2D\u5C0F\u4F01\u696D',\n        },\n      },\n      segment: {\n        label: '\u9867\u5BA2\u30BB\u30B0\u30E1\u30F3\u30C8',\n        options: { net_new: '\u65B0\u898F\u7372\u5F97', growth: '\u6210\u9577', at_risk: '\u30EA\u30B9\u30AF\u3042\u308A', stable: '\u5B89\u5B9A' },\n      },\n      health_score: {\n        label: '\u30D8\u30EB\u30B9\u30B9\u30B3\u30A2',\n        help: '\u30AB\u30B9\u30BF\u30DE\u30FC\u30B5\u30AF\u30BB\u30B9\u62C5\u5F53\uFF08CSM\uFF09\u304C\u7BA1\u7406\u3059\u308B\u5065\u5168\u6027\u306E\u6307\u6A19',\n        options: { healthy: '\u826F\u597D', watching: '\u8981\u89B3\u5BDF', at_risk: '\u30EA\u30B9\u30AF\u3042\u308A', churning: '\u89E3\u7D04\u9032\u884C\u4E2D' },\n      },\n    },\n    _views: {\n      all_accounts: {\n        label: '\u5168\u53D6\u5F15\u5148', description: '\u58F2\u4E0A\u3068\u696D\u7A2E\u3092\u542B\u3080\u53D6\u5F15\u5148\u306E\u4E00\u89A7',\n        bulkActions: {\n          delete: {\n            label: '\u524A\u9664',\n            confirmLabel: '\u524A\u9664',\n            confirmText: '{{count}} \u4EF6\u306E\u53D6\u5F15\u5148\u3092\u5B8C\u5168\u306B\u524A\u9664\u3057\u307E\u3059\u304B\uFF1F\u3053\u306E\u64CD\u4F5C\u306F\u53D6\u308A\u6D88\u305B\u307E\u305B\u3093\u3002',\n          },\n          transfer_owner: {\n            label: '\u6240\u6709\u8005\u306E\u5909\u66F4',\n            confirmText: '{{count}} \u4EF6\u306E\u53D6\u5F15\u5148\u306E\u6240\u6709\u8005\u3092\u5909\u66F4\u3057\u307E\u3059\u304B\uFF1F',\n            params: {\n              owner_id: {\n                label: '\u65B0\u3057\u3044\u6240\u6709\u8005',\n              },\n            },\n          },\n          update_tier: {\n            label: '\u9867\u5BA2\u30E9\u30F3\u30AF\u306E\u66F4\u65B0',\n            confirmText: '{{count}} \u4EF6\u306E\u53D6\u5F15\u5148\u306E\u9867\u5BA2\u30E9\u30F3\u30AF\u3092 {{tier}} \u306B\u66F4\u65B0\u3057\u307E\u3059\u304B\uFF1F',\n            params: {\n              tier: {\n                label: '\u9867\u5BA2\u30E9\u30F3\u30AF',\n              },\n            },\n          },\n        },\n      },\n      account_gallery: { label: '\u53D6\u5F15\u5148\u30AB\u30FC\u30C9', description: '\u30D6\u30E9\u30F3\u30C9\u30AB\u30E9\u30FC\u4ED8\u304D\u306E\u30AB\u30FC\u30C9\u30D3\u30E5\u30FC' },\n      account_map: { label: '\u53D6\u5F15\u5148\u30DE\u30C3\u30D7', description: '\u53D6\u5F15\u5148\u306E\u5730\u7406\u7684\u5206\u5E03' },\n      enterprise_accounts: { label: '\u30A8\u30F3\u30BF\u30FC\u30D7\u30E9\u30A4\u30BA\u53D6\u5F15\u5148', description: '\u5E74\u5546\u6700\u4E0A\u4F4D\u306E\u4E3B\u8981\u9867\u5BA2' },\n      my_accounts: { label: '\u79C1\u306E\u53D6\u5F15\u5148', description: '\u81EA\u5206\u304C\u6240\u6709\u3059\u308B\u53D6\u5F15\u5148' },\n      at_risk_accounts: { label: '\u26A0\uFE0F \u30EA\u30B9\u30AF\u306E\u3042\u308B\u53D6\u5F15\u5148' },\n    },\n    _sections: {\n      basic: { label: '\u57FA\u672C\u60C5\u5831' },\n      financials: { label: '\u8CA1\u52D9\u60C5\u5831' },\n      business_profile: { label: '\u30D3\u30B8\u30CD\u30B9\u60C5\u5831' },\n      contact_info: { label: '\u9023\u7D61\u5148\u60C5\u5831' },\n      ownership: { label: '\u6240\u6709\u8005\u30FB\u30B9\u30C6\u30FC\u30BF\u30B9' },\n      branding: { label: '\u30D6\u30E9\u30F3\u30C7\u30A3\u30F3\u30B0' },\n      system: { label: '\u30B7\u30B9\u30C6\u30E0' },\n      // account.view.ts \u306E\u30D5\u30A9\u30FC\u30E0\u30BB\u30AF\u30B7\u30E7\u30F3\u540D (#1100)\n      profile: { label: '\u30D7\u30ED\u30D5\u30A3\u30FC\u30EB' },\n      customer_success: { label: '\u30AB\u30B9\u30BF\u30DE\u30FC\u30B5\u30AF\u30BB\u30B9' },\n      locations: { label: '\u6240\u5728\u5730' },\n      description: { label: '\u8AAC\u660E' },\n    },\n    _actions: { ...activityActions },\n  },\n  crm_contact: {\n    label: '\u53D6\u5F15\u5148\u8CAC\u4EFB\u8005',\n    pluralLabel: '\u53D6\u5F15\u5148\u8CAC\u4EFB\u8005',\n    description: '\u53D6\u5F15\u5148\u306B\u6240\u5C5E\u3059\u308B\u62C5\u5F53\u8005',\n    fields: {\n      salutation: { label: '\u656C\u79F0', options: { ...salutationOptions } },\n      first_name: { label: '\u540D' },\n      last_name: { label: '\u59D3' },\n      full_name: { label: '\u6C0F\u540D' },\n      crm_account: { label: '\u53D6\u5F15\u5148' },\n      email: { label: '\u30E1\u30FC\u30EB' },\n      phone: { label: '\u96FB\u8A71' },\n      mobile: { label: '\u643A\u5E2F\u96FB\u8A71' },\n      title: { label: '\u5F79\u8077' },\n      department: {\n        label: '\u90E8\u9580',\n        options: {\n          executive: '\u7D4C\u55B6\u5C64', sales: '\u55B6\u696D\u90E8', marketing: '\u30DE\u30FC\u30B1\u30C6\u30A3\u30F3\u30B0\u90E8',\n          engineering: '\u30A8\u30F3\u30B8\u30CB\u30A2\u30EA\u30F3\u30B0\u90E8', support: '\u30B5\u30DD\u30FC\u30C8\u90E8', finance: '\u7D4C\u7406\u90E8',\n          hr: '\u4EBA\u4E8B\u90E8', operations: '\u30AA\u30DA\u30EC\u30FC\u30B7\u30E7\u30F3\u90E8',\n        },\n      },\n      // \u30D0\u30A4\u30A4\u30F3\u30B0\u30BB\u30F3\u30BF\u30FC (REQ-0004) \u2014 \u610F\u601D\u6C7A\u5B9A\u306E\u30DE\u30C3\u30D7\u3002\u82F1\u8A9E\u30E9\u30D9\u30EB\u306F\n      // 'Buying Role' \u3067\u306F\u306A\u304F 'Buying Function'\uFF1Asecurity-role-word \u30EB\u30FC\u30EB\u304C\n      // \u5BA3\u8A00\u5074\u3067\u82F1\u5358\u8A9E role \u3092\u4E88\u7D04\u3057\u3066\u3044\u308B (ADR-0090 D3)\u3002\u540C\u30EB\u30FC\u30EB\u306F\u82F1\u8A9E\u306E\u307F\u3092\n      // \u8AAD\u307F\u8A00\u8A9E\u30D1\u30C3\u30AF\u306B\u306F\u53CA\u3070\u306A\u3044\u305F\u3081\u3001\u3053\u3053\u3067\u306F\u65E5\u672C\u8A9E\u3068\u3057\u3066\u81EA\u7136\u306A\u8A9E\u3092\u4F7F\u3046\u3002\n      buying_function: {\n        label: '\u8CFC\u8CB7\u5F79\u5272',\n        options: {\n          decision_maker: '\u6C7A\u88C1\u8005', economic_buyer: '\u4E88\u7B97\u6C7A\u88C1\u8005',\n          technical_evaluator: '\u6280\u8853\u8A55\u4FA1\u8005', user: '\u5229\u7528\u8005',\n          influencer: '\u5F71\u97FF\u8005', gatekeeper: '\u30B2\u30FC\u30C8\u30AD\u30FC\u30D1\u30FC',\n        },\n      },\n      attitude: {\n        label: '\u81EA\u793E\u3078\u306E\u614B\u5EA6',\n        options: {\n          champion: '\u63A8\u9032\u8005', supportive: '\u597D\u610F\u7684', neutral: '\u4E2D\u7ACB',\n          skeptical: '\u61D0\u7591\u7684', blocker: '\u53CD\u5BFE\u8005',\n        },\n      },\n      relationship_strength: {\n        label: '\u95A2\u4FC2\u306E\u5F37\u3055',\n        options: {\n          distant: '\u758E\u9060', acquaintance: '\u9854\u898B\u77E5\u308A', working: '\u696D\u52D9\u4E0A\u306E\u95A2\u4FC2',\n          strong: '\u5F37\u3044', trusted_advisor: '\u4FE1\u983C\u3055\u308C\u308B\u30A2\u30C9\u30D0\u30A4\u30B6\u30FC',\n        },\n      },\n      owner_id: { label: '\u53D6\u5F15\u5148\u8CAC\u4EFB\u8005\u306E\u6240\u6709\u8005' },\n      description: { label: '\u8AAC\u660E' },\n      is_primary: { label: '\u4E3B\u62C5\u5F53\u8005', help: '\u3053\u306E\u53D6\u5F15\u5148\u306E\u4E3B\u62C5\u5F53\u8005\u304B\u3069\u3046\u304B' },\n      avatar: { label: '\u30D7\u30ED\u30D5\u30A3\u30FC\u30EB\u753B\u50CF' },\n      mailing_address: { label: '\u90F5\u9001\u5148\u4F4F\u6240' },\n      lead_source: { label: '\u30EA\u30FC\u30C9\u30BD\u30FC\u30B9', options: { ...leadSourceOptions } },\n      do_not_call: { label: '\u96FB\u8A71\u62D2\u5426' },\n      email_opt_out: { label: '\u30E1\u30FC\u30EB\u914D\u4FE1\u505C\u6B62' },\n      last_contacted_date: { label: '\u6700\u7D42\u63A5\u89E6\u65E5\u6642' },\n    },\n    _views: {\n      all_contacts: { label: '\u5168\u53D6\u5F15\u5148\u8CAC\u4EFB\u8005' },\n      contact_directory: { label: '\u8CAC\u4EFB\u8005\u30C7\u30A3\u30EC\u30AF\u30C8\u30EA' },\n      primary_contacts: { label: '\u4E3B\u62C5\u5F53\u8005' },\n    },\n    _sections: {\n      identity: { label: '\u57FA\u672C\u60C5\u5831' },\n      account_info: { label: '\u53D6\u5F15\u5148\u30FB\u5F79\u8077' },\n      buying_centre: { label: '\u30D0\u30A4\u30A4\u30F3\u30B0\u30BB\u30F3\u30BF\u30FC' },\n      contact_info: { label: '\u9023\u7D61\u5148\u60C5\u5831' },\n      mailing_address: { label: '\u90F5\u9001\u5148\u4F4F\u6240' },\n      additional: { label: '\u305D\u306E\u4ED6\u306E\u60C5\u5831' },\n      preferences: { label: '\u30B3\u30DF\u30E5\u30CB\u30B1\u30FC\u30B7\u30E7\u30F3\u8A2D\u5B9A' },\n      // contact.view.ts \u306E\u30D5\u30A9\u30FC\u30E0\u30BB\u30AF\u30B7\u30E7\u30F3\u540D (#1100)\n      contact_details: { label: '\u9023\u7D61\u5148\u60C5\u5831' },\n      comm_preferences: { label: '\u8A2D\u5B9A' },\n    },\n    _actions: {\n      ...activityActions,\n      mark_primary: {\n        label: '\u4E3B\u62C5\u5F53\u8005\u306B\u8A2D\u5B9A',\n        confirmText: '\u3053\u306E\u8CAC\u4EFB\u8005\u3092\u53D6\u5F15\u5148\u306E\u4E3B\u62C5\u5F53\u8005\u306B\u8A2D\u5B9A\u3057\u307E\u3059\u304B\uFF1F',\n        successMessage: '\u4E3B\u62C5\u5F53\u8005\u306B\u8A2D\u5B9A\u3057\u307E\u3057\u305F\uFF01',\n      },\n      send_email: {\n        label: '\u30E1\u30FC\u30EB\u9001\u4FE1',\n        params: {\n          subject: { label: '\u4EF6\u540D' },\n          body: { label: '\u672C\u6587' },\n        },\n      },\n      add_contact_to_campaign: {\n        label: '\u30AD\u30E3\u30F3\u30DA\u30FC\u30F3\u306B\u8FFD\u52A0',\n        successMessage: '\u53D6\u5F15\u5148\u8CAC\u4EFB\u8005\u3092\u30AD\u30E3\u30F3\u30DA\u30FC\u30F3\u306B\u8FFD\u52A0\u3057\u307E\u3057\u305F\uFF01',\n        params: {\n          crm_campaign: { label: '\u30AD\u30E3\u30F3\u30DA\u30FC\u30F3' },\n        },\n      },\n    },\n  },\n};\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/sales/translations/ja-JP/objects.pipeline.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/sales/translations/ja-JP\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/sales/translations/ja-JP/objects.pipeline.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport type { ObjectTranslationData } from '@objectstack/spec/system';\n\nimport { activityActions, salutationOptions, industryOptions, leadSourceOptions } from './_shared';\n\n/**\n * \u65E5\u672C\u8A9E (ja-JP) \u2014 `objects` translations for the PIPELINE family:\n * demand and the deals it becomes, plus the roll-up that forecasts them.\n *\n * Roster: `crm_lead`, `crm_opportunity`, `crm_opportunity_line_item`, `crm_forecast`.\n *\n * SPLIT AXIS (#1311): translation NAMESPACE first, then CRM DOMAIN FAMILY.\n * Everything that is not `objects` lives in `./app.ts`; `objects` \u2014 69-78% of\n * every bundle \u2014 is one file per CRM domain family, and a detail object\n * follows its master. A new row goes in the file for ITS family, never in\n * whichever file is already open: that is how one file re-grows past the 70%\n * advisory band `pnpm hygiene` prints. Full rule and rationale:\n * `src/sales/translations/ja-JP.ts`.\n */\nconst opportunityStageOptions = {\n  prospecting: '\u898B\u8FBC\u307F\u8ABF\u67FB', qualification: '\u9078\u5B9A',\n  needs_analysis: '\u30CB\u30FC\u30BA\u5206\u6790', proposal: '\u63D0\u6848',\n  negotiation: '\u4EA4\u6E09', closed_won: '\u6210\u7ACB', closed_lost: '\u4E0D\u6210\u7ACB',\n};\n\nexport const pipeline: Record<string, ObjectTranslationData> = {\n  crm_lead: {\n    _validations: {\n      disqualification_reason_required: {\n        message: '\u30EA\u30FC\u30C9\u3092\u300C\u5BFE\u8C61\u5916\u300D\u306B\u3059\u308B\u5834\u5408\u306F\u5931\u683C\u7406\u7531\u304C\u5FC5\u8981\u3067\u3059',\n      },\n      duplicate_disqualification_requires_survivor: {\n        message: '\u91CD\u8907\u3092\u7406\u7531\u306B\u30EA\u30FC\u30C9\u3092\u5931\u683C\u3068\u3059\u308B\u5834\u5408\u306F\u3001\u6B8B\u3059\u30EC\u30B3\u30FC\u30C9\u3092\u6307\u5B9A\u3057\u3001\u91CD\u8907\u30B9\u30C6\u30FC\u30BF\u30B9\u3092\u300C\u78BA\u8A8D\u6E08\u307F\u300D\u306B\u3059\u308B\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059',\n      },\n      email_required: {\n        message: '\u30E1\u30FC\u30EB\u30A2\u30C9\u30EC\u30B9\u306F\u5FC5\u9808\u3067\u3059',\n      },\n      lead_status_progression: {\n        message: '\u7121\u52B9\u306A\u30EA\u30FC\u30C9\u30B9\u30C6\u30FC\u30BF\u30B9\u9077\u79FB\u3067\u3059',\n      },\n    },\n    label: '\u30EA\u30FC\u30C9',\n    pluralLabel: '\u30EA\u30FC\u30C9',\n    description: '\u307E\u3060\u9069\u683C\u5224\u5B9A\u3092\u53D7\u3051\u3066\u3044\u306A\u3044\u898B\u8FBC\u307F\u5BA2',\n    fields: {\n      salutation: { label: '\u656C\u79F0', options: { ...salutationOptions } },\n      first_name: { label: '\u540D' },\n      last_name: { label: '\u59D3' },\n      full_name: { label: '\u6C0F\u540D' },\n      display_title: { label: '\u8868\u793A\u540D' },\n      company: { label: '\u4F1A\u793E\u540D' },\n      company_normalized: {\n        label: '\u4F1A\u793E\u540D\uFF08\u6B63\u898F\u5316\uFF09',\n        help: '\u30EA\u30FC\u30C9\u5909\u63DB\u306E\u7167\u5408\u30AD\u30FC\u3002\u4F1A\u793E\u540D\u3092\u5C0F\u6587\u5B57\u5316\u3057\u3001\u524D\u5F8C\u306E\u7A7A\u767D\u3092\u9664\u53BB\u3057\u3066\u3001\u5185\u90E8\u306E\u9023\u7D9A\u3059\u308B\u7A7A\u767D\u3092 1 \u3064\u306B\u307E\u3068\u3081\u305F\u3082\u306E\u3002lead_duplicate_check \u30D5\u30C3\u30AF\u304C\u81EA\u52D5\u3067\u7DAD\u6301\u3057\u307E\u3059 \u2014 \u76F4\u63A5\u7DE8\u96C6\u3057\u306A\u3044\u3067\u304F\u3060\u3055\u3044\u3002',\n      },\n      title: { label: '\u5F79\u8077' },\n      email: { label: '\u30E1\u30FC\u30EB' },\n      phone: { label: '\u96FB\u8A71' },\n      industry: {\n        label: '\u696D\u7A2E',\n        options: { ...industryOptions },\n      },\n      status: {\n        label: '\u30B9\u30C6\u30FC\u30BF\u30B9',\n        options: {\n          new: '\u65B0\u898F', contacted: '\u30B3\u30F3\u30BF\u30AF\u30C8\u6E08\u307F', qualified: '\u9069\u683C',\n          unqualified: '\u4E0D\u9069\u683C', converted: '\u5909\u63DB\u6E08\u307F',\n        },\n      },\n      lead_source: { label: '\u30EA\u30FC\u30C9\u30BD\u30FC\u30B9', options: { ...leadSourceOptions } },\n      owner_id: { label: '\u30EA\u30FC\u30C9\u6240\u6709\u8005' },\n      is_converted: { label: '\u5909\u63DB\u6E08\u307F' },\n      description: { label: '\u8AAC\u660E' },\n      mobile: { label: '\u643A\u5E2F\u96FB\u8A71' },\n      website: { label: 'Web\u30B5\u30A4\u30C8' },\n      rating: { label: '\u30EA\u30FC\u30C9\u30B9\u30B3\u30A2', help: '\u30EA\u30FC\u30C9\u306E\u54C1\u8CEA\u30B9\u30B3\u30A2\uFF081\u301C5 \u6BB5\u968E\uFF09' },\n      converted_account: { label: '\u5909\u63DB\u5F8C\u306E\u53D6\u5F15\u5148' },\n      converted_contact: { label: '\u5909\u63DB\u5F8C\u306E\u53D6\u5F15\u5148\u8CAC\u4EFB\u8005' },\n      converted_opportunity: { label: '\u5909\u63DB\u5F8C\u306E\u5546\u8AC7' },\n      converted_date: { label: '\u5909\u63DB\u65E5' },\n      address: { label: '\u4F4F\u6240' },\n      annual_revenue: { label: '\u5E74\u9593\u58F2\u4E0A' },\n      number_of_employees: { label: '\u5F93\u696D\u54E1\u6570' },\n      notes: { label: '\u30E1\u30E2', help: '\u3053\u306E\u30EA\u30FC\u30C9\u306B\u95A2\u3059\u308B\u4F5C\u696D\u30E1\u30E2 \u2014 \u66F8\u5F0F\u8A2D\u5B9A\u306B\u5BFE\u5FDC\u3002' },\n      do_not_call: { label: '\u96FB\u8A71\u62D2\u5426' },\n      email_opt_out: { label: '\u30E1\u30FC\u30EB\u914D\u4FE1\u505C\u6B62' },\n      next_followup_date: { label: '\u6B21\u56DE\u30D5\u30A9\u30ED\u30FC\u30A2\u30C3\u30D7\u65E5' },\n      last_contacted_date: { label: '\u6700\u7D42\u63A5\u89E6\u65E5\u6642' },\n      need_type: {\n        label: '\u30CB\u30FC\u30BA\u7A2E\u5225',\n        help: '\u3053\u306E\u898B\u8FBC\u5BA2\u304C\u4F55\u3092\u6C42\u3081\u3066\u3044\u308B\u304B\u3002\u5272\u308A\u5F53\u3066\u30FB\u512A\u5148\u9806\u4F4D\u4ED8\u3051\u30FB\u9700\u8981\u5206\u6790\u304C\u3053\u306E\u9805\u76EE\u3092\u53C2\u7167\u3057\u307E\u3059\u3002',\n        options: {\n          new_implementation: '\u65B0\u898F\u5C0E\u5165', expansion: '\u62E1\u5F35\u30FB\u8FFD\u52A0',\n          replacement: '\u5165\u308C\u66FF\u3048\u30FB\u79FB\u884C', renewal: '\u66F4\u65B0', consulting: '\u30B3\u30F3\u30B5\u30EB\u30C6\u30A3\u30F3\u30B0',\n          support: '\u4FDD\u5B88\u30FB\u30B5\u30DD\u30FC\u30C8', other: '\u305D\u306E\u4ED6',\n        },\n      },\n      estimated_amount: {\n        label: '\u4E88\u60F3\u91D1\u984D',\n        help: '\u30AF\u30AA\u30EA\u30D5\u30A3\u30B1\u30FC\u30B7\u30E7\u30F3\u524D\u306E\u9700\u8981\u91D1\u984D\u306E\u898B\u7A4D\u308A\u3002\u30B3\u30F3\u30D0\u30FC\u30B8\u30E7\u30F3\u6642\u306B\u5546\u8AC7\u91D1\u984D\u3078\u521D\u671F\u5024\u3068\u3057\u3066\u5165\u308A\u307E\u3059\u3002',\n      },\n      conversion_approval_status: {\n        label: '\u30B3\u30F3\u30D0\u30FC\u30B8\u30E7\u30F3\u627F\u8A8D',\n        help: '\u3053\u306E\u898B\u8FBC\u5BA2\u304C\u30B3\u30F3\u30D0\u30FC\u30B8\u30E7\u30F3\u306E\u627F\u8A8D\u3092\u5F97\u3066\u3044\u308B\u304B\u3002\u300C\u627F\u8A8D\u4E0D\u8981\u300D\u306F\u627F\u8A8D\u3092\u6C42\u3081\u306A\u3044\u72B6\u614B\u3067\u3001\u51FA\u8377\u6642\u306E\u65E2\u5B9A\u5024\u3067\u3059\u3002',\n        options: {\n          not_required: '\u627F\u8A8D\u4E0D\u8981', pending: '\u627F\u8A8D\u5F85\u3061',\n          approved: '\u627F\u8A8D\u6E08\u307F', rejected: '\u5374\u4E0B',\n        },\n      },\n      disqualification_reason: {\n        label: '\u4E0D\u9069\u683C\u7406\u7531',\n        help: '\u30B9\u30C6\u30FC\u30BF\u30B9\u304C\u300C\u4E0D\u9069\u683C\u300D\u306E\u5834\u5408\u306F\u5FC5\u9808',\n        options: {\n          not_a_fit: '\u30CB\u30FC\u30BA\u304C\u5408\u308F\u306A\u3044', no_budget: '\u4E88\u7B97\u306A\u3057', wrong_persona: '\u62C5\u5F53\u8005\u304C\u7570\u306A\u308B',\n          unreachable: '\u9023\u7D61\u4E0D\u80FD', duplicate: '\u91CD\u8907\u30EA\u30FC\u30C9', competitor: '\u7AF6\u5408\u4ED6\u793E\u306B\u6C7A\u5B9A',\n          other: '\u305D\u306E\u4ED6',\n        },\n      },\n      duplicate_of_type: {\n        label: '\u91CD\u8907\u5BFE\u8C61',\n        help: '\u91CD\u8907\u5143\u3068\u3057\u3066\u6B8B\u308B\u30EC\u30B3\u30FC\u30C9\u304C\u5C5E\u3059\u308B\u30AA\u30D6\u30B8\u30A7\u30AF\u30C8\u306E\u7A2E\u5225\u3002',\n        // `erased` \u306F\u5893\u7891\u5024\u3067\u3042\u308A\u9078\u629E\u80A2\u3067\u306F\u306A\u3044\u3002\u30D5\u30A9\u30FC\u30E0\u306B\u306F\u8868\u793A\u3057\u306A\u3044\n        // \uFF08`src/sales/views/lead.view.ts` \u3092\u53C2\u7167\uFF09\u304C\u3001\u6B8B\u5B58\u30EC\u30B3\u30FC\u30C9\u304C\u524A\u9664\u3055\u308C\u305F\n        // \u30EA\u30FC\u30C9\u306F\u3053\u306E\u5024\u3092\u4FDD\u6301\u3059\u308B\u305F\u3081\u3001\u30EC\u30B3\u30FC\u30C9\u3092\u8AAD\u3080\u5834\u6240\u3067\u306F\u30E9\u30D9\u30EB\u304C\u8981\u308B\u3002\n        options: { crm_lead: '\u30EA\u30FC\u30C9', crm_contact: '\u53D6\u5F15\u5148\u8CAC\u4EFB\u8005', erased: '\u524A\u9664\u6E08\u307F\u30EC\u30B3\u30FC\u30C9' },\n      },\n      duplicate_of_lead: { label: '\u91CD\u8907\u3059\u308B\u30EA\u30FC\u30C9' },\n      duplicate_of_contact: { label: '\u91CD\u8907\u3059\u308B\u53D6\u5F15\u5148\u8CAC\u4EFB\u8005' },\n      duplicate_status: {\n        label: '\u91CD\u8907\u30B9\u30C6\u30FC\u30BF\u30B9',\n        help: '\u300C\u91CD\u8907\u306E\u7591\u3044\u300D= \u767B\u9332\u6642\u306B\u81EA\u52D5\u3067\u4ED8\u4E0E\u3002\u300C\u91CD\u8907\u78BA\u5B9A\u300D= \u62C5\u5F53\u8005\u304C\u4E00\u81F4\u3092\u78BA\u8A8D\u6E08\u307F\u3002',\n        options: { suspected: '\u91CD\u8907\u306E\u7591\u3044', confirmed: '\u91CD\u8907\u78BA\u5B9A' },\n      },\n    },\n    _views: {\n      all_leads: {\n        label: '\u5168\u30EA\u30FC\u30C9',\n        emptyState: { title: '\u30EA\u30FC\u30C9\u304C\u307E\u3060\u3042\u308A\u307E\u305B\u3093', message: '\u6700\u521D\u306E\u30EA\u30FC\u30C9\u3092\u4F5C\u6210\u3057\u3066\u59CB\u3081\u307E\u3057\u3087\u3046' },\n      },\n      kanban_by_status: { label: '\u30EA\u30FC\u30C9\u30D1\u30A4\u30D7\u30E9\u30A4\u30F3' },\n      calendar_by_created: { label: '\u30EA\u30FC\u30C9\u30AB\u30EC\u30F3\u30C0\u30FC' },\n      gallery_view: { label: '\u30EA\u30FC\u30C9\u30AB\u30FC\u30C9' },\n      my_leads: { label: '\u79C1\u306E\u30EA\u30FC\u30C9' },\n      high_priority: { label: '\u512A\u5148\u5EA6\u9AD8' },\n      hot_leads: { label: '\uD83D\uDD25 \u30DB\u30C3\u30C8\u30EA\u30FC\u30C9' },\n      suspected_duplicates: {\n        label: '\u91CD\u8907\u306E\u7591\u3044\u304C\u3042\u308B\u30EA\u30FC\u30C9',\n        emptyState: {\n          title: '\u91CD\u8907\u306E\u7591\u3044\u306F\u3042\u308A\u307E\u305B\u3093',\n          message: '\u78BA\u8A8D\u306F\u4E0D\u8981\u3067\u3059 \u2014 \u518D\u767B\u9332\u3055\u308C\u305F\u30E1\u30FC\u30EB\u30A2\u30C9\u30EC\u30B9\u306F\u3059\u3079\u3066\u30C1\u30A7\u30C3\u30AF\u6E08\u307F\u3067\u3059\u3002',\n        },\n      },\n    },\n    _sections: {\n      // \u30AA\u30D6\u30B8\u30A7\u30AF\u30C8\u5B9A\u7FA9\u306E\u30BB\u30AF\u30B7\u30E7\u30F3\u30AD\u30FC\uFF08lead.object.ts\uFF09\u2014 \u5165\u529B\u30D5\u30A9\u30FC\u30E0\u3068\u3001\n      // \u3053\u308C\u3089\u306E\u30B0\u30EB\u30FC\u30D7\u3092\u53C2\u7167\u3059\u308B\u8A73\u7D30\u30DA\u30FC\u30B8\u306E\u30BB\u30AF\u30B7\u30E7\u30F3\uFF08#806\uFF09\u3067\u4F7F\u7528\n      address: { label: '\u4F4F\u6240' },\n      identity: { label: '\u57FA\u672C\u60C5\u5831' },\n      company_info: { label: '\u4F1A\u793E\u60C5\u5831' },\n      contact_info: { label: '\u9023\u7D61\u5148\u60C5\u5831' },\n      qualification: { label: '\u9069\u683C\u5224\u5B9A' },\n      assignment: { label: '\u62C5\u5F53\u8005' },\n      additional: { label: '\u305D\u306E\u4ED6\u306E\u60C5\u5831' },\n      preferences: { label: '\u30B3\u30DF\u30E5\u30CB\u30B1\u30FC\u30B7\u30E7\u30F3\u8A2D\u5B9A' },\n      conversion: { label: '\u5909\u63DB' },\n      duplicates: { label: '\u91CD\u8907\u7BA1\u7406' },\n      // lead.view.ts \u306E\u30D5\u30A9\u30FC\u30E0\u30BB\u30AF\u30B7\u30E7\u30F3\u540D (#1100) \u2014 \u30C7\u30D5\u30A9\u30EB\u30C8\u30D5\u30A9\u30FC\u30E0\u3068\n      // \u540D\u524D\u4ED8\u304D formView \u3059\u3079\u3066\u306E\u30BB\u30AF\u30B7\u30E7\u30F3\u540D\u304C\u3053\u3053\u306B\u96C6\u307E\u308B\u3002\u3042\u3061\u3089\u306B\u30D5\u30A9\u30FC\u30E0\u3092\n      // \u8FFD\u52A0\u3057\u305F\u3089\u3001\u305D\u306E\u30BB\u30AF\u30B7\u30E7\u30F3\u540D\u3092\u3053\u3053\u306B\u8FFD\u52A0\u3059\u308B\u3002\n      contact_information: { label: '\u9023\u7D61\u5148\u60C5\u5831' },\n      lead_classification: { label: '\u30EA\u30FC\u30C9\u5206\u985E' },\n      company_information: { label: '\u4F1A\u793E\u60C5\u5831' },\n      additional_information: { label: '\u8FFD\u52A0\u60C5\u5831' },\n      privacy: { label: '\u30D7\u30E9\u30A4\u30D0\u30B7\u30FC' },\n      general: { label: '\u4E00\u822C' },\n      details: { label: '\u8A73\u7D30' },\n      step_1_contact_details: { label: '\u30B9\u30C6\u30C3\u30D71\uFF1A\u9023\u7D61\u5148\u60C5\u5831' },\n      step_2_company_information: { label: '\u30B9\u30C6\u30C3\u30D72\uFF1A\u4F1A\u793E\u60C5\u5831' },\n      step_3_qualification: { label: '\u30B9\u30C6\u30C3\u30D73\uFF1A\u8CC7\u683C\u8A55\u4FA1' },\n      step_4_review_and_convert: { label: '\u30B9\u30C6\u30C3\u30D74\uFF1A\u78BA\u8A8D\u3068\u5909\u63DB' },\n      primary_information: { label: '\u4E3B\u8981\u60C5\u5831' },\n      extended_details: { label: '\u8A73\u7D30\u60C5\u5831' },\n      quick_edit: { label: '\u30AF\u30A4\u30C3\u30AF\u7DE8\u96C6' },\n      update_lead_status: { label: '\u30EA\u30FC\u30C9\u30B9\u30C6\u30FC\u30BF\u30B9\u3092\u66F4\u65B0' },\n      tell_us_about_yourself: { label: '\u3042\u306A\u305F\u306B\u3064\u3044\u3066\u6559\u3048\u3066\u304F\u3060\u3055\u3044' },\n      about_your_company: { label: '\u8CB4\u793E\u306B\u3064\u3044\u3066' },\n      how_can_we_help: { label: '\u3069\u306E\u3088\u3046\u306A\u3054\u7528\u4EF6\u3067\u3057\u3087\u3046\u304B\uFF1F' },\n      lead_information: { label: '\u30EA\u30FC\u30C9\u60C5\u5831' },\n      address_information: { label: '\u4F4F\u6240\u60C5\u5831' },\n      privacy_preferences: { label: '\u30D7\u30E9\u30A4\u30D0\u30B7\u30FC\u8A2D\u5B9A' },\n    },\n    _actions: {\n      ...activityActions,\n      convert_lead: {\n        label: '\u30EA\u30FC\u30C9\u5909\u63DB',\n        successMessage: '\u30EA\u30FC\u30C9\u306E\u5909\u63DB\u306B\u6210\u529F\u3057\u307E\u3057\u305F\uFF01',\n      },\n      create_campaign: {\n        label: '\u30AD\u30E3\u30F3\u30DA\u30FC\u30F3\u306B\u8FFD\u52A0',\n        successMessage: '\u30AD\u30E3\u30F3\u30DA\u30FC\u30F3\u306B\u8FFD\u52A0\u3057\u307E\u3057\u305F\uFF01',\n        params: {\n          crm_campaign: { label: '\u30AD\u30E3\u30F3\u30DA\u30FC\u30F3' },\n        },\n      },\n      schedule_followup: {\n        label: '\u30D5\u30A9\u30ED\u30FC\u30A2\u30C3\u30D7\u3092\u8A2D\u5B9A',\n        successMessage: '\u30D5\u30A9\u30ED\u30FC\u30A2\u30C3\u30D7\u3092\u8A2D\u5B9A\u3057\u307E\u3057\u305F\u3002',\n      },\n    },\n  },\n  crm_opportunity: {\n    _validations: {\n      amount_positive: {\n        message: '\u91D1\u984D\u306F 0 \u3088\u308A\u5927\u304D\u3044\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059',\n      },\n      close_date_future: {\n        message: '\u5546\u8AC7\u304C\u30AF\u30ED\u30FC\u30BA\u3057\u3066\u3044\u308B\u5834\u5408\u3092\u9664\u304D\u3001\u5B8C\u4E86\u4E88\u5B9A\u65E5\u3092\u904E\u53BB\u306B\u8A2D\u5B9A\u3059\u308B\u3053\u3068\u306F\u3067\u304D\u307E\u305B\u3093',\n      },\n      opportunity_stage_progression: {\n        message: '\u7121\u52B9\u306A\u5546\u8AC7\u30B9\u30C6\u30FC\u30B8\u9077\u79FB\u3067\u3059',\n      },\n    },\n    label: '\u5546\u8AC7',\n    pluralLabel: '\u5546\u8AC7',\n    description: '\u30D1\u30A4\u30D7\u30E9\u30A4\u30F3\u4E0A\u306E\u5546\u8AC7\u30FB\u6848\u4EF6',\n    fields: {\n      name: { label: '\u5546\u8AC7\u540D' },\n      crm_account: { label: '\u53D6\u5F15\u5148' },\n      primary_contact: { label: '\u4E3B\u62C5\u5F53\u8005' },\n      owner_id: { label: '\u5546\u8AC7\u6240\u6709\u8005' },\n      amount: { label: '\u91D1\u984D' },\n      expected_revenue: { label: '\u671F\u5F85\u53CE\u76CA' },\n      stage: {\n        label: '\u30B9\u30C6\u30FC\u30B8',\n        options: { ...opportunityStageOptions },\n      },\n      probability: { label: '\u78BA\u5EA6 (%)' },\n      close_date: { label: '\u5B8C\u4E86\u4E88\u5B9A\u65E5' },\n      type: {\n        label: '\u30BF\u30A4\u30D7',\n        options: {\n          new_business: '\u65B0\u898F\u30D3\u30B8\u30CD\u30B9',\n          existing_upgrade: '\u65E2\u5B58\u9867\u5BA2 - \u30A2\u30C3\u30D7\u30B0\u30EC\u30FC\u30C9',\n          existing_renewal: '\u65E2\u5B58\u9867\u5BA2 - \u66F4\u65B0',\n          existing_expansion: '\u65E2\u5B58\u9867\u5BA2 - \u62E1\u5927',\n        },\n      },\n      forecast_category: {\n        label: '\u58F2\u4E0A\u4E88\u6E2C\u30AB\u30C6\u30B4\u30EA',\n        options: {\n          pipeline: '\u30D1\u30A4\u30D7\u30E9\u30A4\u30F3', best_case: '\u30D9\u30B9\u30C8\u30B1\u30FC\u30B9',\n          commit: '\u30B3\u30DF\u30C3\u30C8', omitted: '\u9664\u5916', closed: '\u5B8C\u4E86',\n        },\n      },\n      description: { label: '\u8AAC\u660E' },\n      next_step: { label: '\u6B21\u306E\u30B9\u30C6\u30C3\u30D7' },\n      lead_source: { label: '\u30EA\u30FC\u30C9\u30BD\u30FC\u30B9', options: { ...leadSourceOptions } },\n      crm_campaign: { label: '\u30AD\u30E3\u30F3\u30DA\u30FC\u30F3', help: '\u3053\u306E\u5546\u8AC7\u3092\u751F\u307F\u51FA\u3057\u305F\u30DE\u30FC\u30B1\u30C6\u30A3\u30F3\u30B0\u30AD\u30E3\u30F3\u30DA\u30FC\u30F3' },\n      days_in_stage: { label: '\u73FE\u30B9\u30C6\u30FC\u30B8\u6EDE\u5728\u65E5\u6570' },\n      stage_entry_date: { label: '\u30B9\u30C6\u30FC\u30B8\u958B\u59CB\u65E5', help: '\u3053\u306E\u5546\u8AC7\u304C\u73FE\u5728\u306E\u30B9\u30C6\u30FC\u30B8\u306B\u5165\u3063\u305F\u65E5\u3002' },\n      is_private: { label: '\u975E\u516C\u958B' },\n      approval_status: {\n        label: '\u627F\u8A8D\u30B9\u30C6\u30FC\u30BF\u30B9',\n        options: { not_required: '\u627F\u8A8D\u4E0D\u8981', pending: '\u627F\u8A8D\u5F85\u3061', approved: '\u627F\u8A8D\u6E08\u307F', rejected: '\u5374\u4E0B' },\n      },\n      approved_date: { label: '\u627F\u8A8D\u65E5' },\n      // #593 \u2014 \u5546\u8AC7\u30AF\u30ED\u30FC\u30BA\u6642\u306B\u5FC5\u9808\u3002\u5931\u6CE8\u7406\u7531\u306F\u55B6\u696D\u30C0\u30C3\u30B7\u30E5\u30DC\u30FC\u30C9\u306E\n      // \u5185\u8A33\u30A6\u30A3\u30B8\u30A7\u30C3\u30C8\u306B\u3082\u51FA\u308B\u305F\u3081\u3001\u4FDD\u5B58\u5024\u304C\u305D\u306E\u307E\u307E\u753B\u9762\u306B\u51FA\u3066\u306F\u3044\u3051\u306A\u3044\u3002\n      win_reason: {\n        label: '\u53D7\u6CE8\u7406\u7531',\n        help: '\u53D7\u6CE8\u306B\u81F3\u3063\u305F\u7406\u7531\u3002\u5546\u8AC7\u3092\u300C\u6210\u7ACB\u300D\u3067\u30AF\u30ED\u30FC\u30BA\u3059\u308B\u969B\u306B\u5FC5\u9808\u3067\u3059\u3002',\n        options: {\n          better_product: '\u88FD\u54C1\u304C\u512A\u308C\u3066\u3044\u308B', better_price: '\u4FA1\u683C\u304C\u512A\u308C\u3066\u3044\u308B',\n          relationship: '\u65E2\u5B58\u306E\u95A2\u4FC2', better_support: '\u30B5\u30DD\u30FC\u30C8\u304C\u512A\u308C\u3066\u3044\u308B',\n          best_fit: '\u6700\u9069\u306A\u6A5F\u80FD\u30FB\u9069\u5408\u6027',\n          quote_accepted: '\u898B\u7A4D\u627F\u8A8D', other: '\u305D\u306E\u4ED6',\n        },\n      },\n      loss_reason: {\n        label: '\u5931\u6CE8\u7406\u7531',\n        help: '\u5931\u6CE8\u3057\u305F\u7406\u7531\u3002\u5546\u8AC7\u3092\u300C\u4E0D\u6210\u7ACB\u300D\u3067\u30AF\u30ED\u30FC\u30BA\u3059\u308B\u969B\u306B\u5FC5\u9808\u3067\u3059\u3002',\n        options: {\n          price: '\u4FA1\u683C\u304C\u9AD8\u3059\u304E\u308B', competitor: '\u7AF6\u5408\u4ED6\u793E\u306B\u6557\u5317',\n          no_budget: '\u4E88\u7B97\u306A\u3057', no_decision: '\u610F\u601D\u6C7A\u5B9A\u306A\u3057',\n          timing: '\u30BF\u30A4\u30DF\u30F3\u30B0\u4E0D\u9069', features: '\u6A5F\u80FD\u4E0D\u8DB3', other: '\u305D\u306E\u4ED6',\n        },\n      },\n      loss_details: { label: '\u53D7\u6CE8\u30FB\u5931\u6CE8\u306E\u8A73\u7D30', help: '\u53D7\u6CE8\u30FB\u5931\u6CE8\u7406\u7531\u306E\u88DC\u8DB3\u8AAC\u660E\uFF08\u81EA\u7531\u8A18\u8FF0\uFF09\u3002' },\n      // REQ-0006 \u2014 \u9069\u683C\u5224\u5B9A\u3001\u9867\u5BA2\u5074\u306E\u8ABF\u9054\u30B9\u30B1\u30B8\u30E5\u30FC\u30EB\u3001\u5546\u8AC7\u306E\u7D4C\u7DEF\u3001\u4E8B\u696D\u533A\u5206\u3001\u30B9\u30C6\u30FC\u30BF\u30B9\u5909\u66F4\u627F\u8A8D\u3002\n      will_bid: { label: '\u5165\u672D\u4E88\u5B9A', help: '\u5165\u672D\u3059\u308B\u610F\u5411\u304C\u3042\u308B\u304B\u3069\u3046\u304B\u3002\u672A\u8A2D\u5B9A\u306F\u5224\u65AD\u304C\u4FDD\u7559\u4E2D\u3067\u3042\u308B\u3053\u3068\u3092\u793A\u3057\u307E\u3059\u3002' },\n      controllability: { label: '\u30B3\u30F3\u30C8\u30ED\u30FC\u30EB\u5EA6', options: { high: '\u9AD8', medium: '\u4E2D', low: '\u4F4E' } },\n      priority: { label: '\u512A\u5148\u5EA6', options: { high: '\u9AD8', medium: '\u4E2D', low: '\u4F4E' } },\n      deal_level: { label: '\u5546\u8AC7\u30E9\u30F3\u30AF', options: { strategic: '\u6226\u7565', key: '\u91CD\u70B9', standard: '\u6A19\u6E96' } },\n      is_subcontracted: { label: '\u5916\u6CE8\u3042\u308A' },\n      subcontracting_note: { label: '\u5916\u6CE8\u30E1\u30E2' },\n      customer_initiation_date: { label: '\u9867\u5BA2\u306E\u6848\u4EF6\u5316\u65E5' },\n      expected_tender_date: { label: '\u5165\u672D\u4E88\u5B9A\u65E5' },\n      expected_signing_date: { label: '\u5951\u7D04\u7DE0\u7D50\u4E88\u5B9A\u65E5' },\n      expected_tender_amount: { label: '\u5165\u672D\u4E88\u5B9A\u91D1\u984D' },\n      expected_signing_amount: { label: '\u5951\u7D04\u4E88\u5B9A\u91D1\u984D' },\n      business_line: {\n        label: '\u4E8B\u696D\u533A\u5206',\n        options: {\n          product: '\u88FD\u54C1', services: '\u30D7\u30ED\u30D5\u30A7\u30C3\u30B7\u30E7\u30CA\u30EB\u30B5\u30FC\u30D3\u30B9', consulting: '\u30B3\u30F3\u30B5\u30EB\u30C6\u30A3\u30F3\u30B0',\n          support: '\u4FDD\u5B88\u30FB\u30B5\u30DD\u30FC\u30C8', other: '\u305D\u306E\u4ED6',\n        },\n      },\n      customer_background: { label: '\u9867\u5BA2\u6982\u8981' },\n      project_background: { label: '\u30D7\u30ED\u30B8\u30A7\u30AF\u30C8\u80CC\u666F' },\n      risk_analysis: { label: '\u30EA\u30B9\u30AF\u5206\u6790' },\n      payment_terms: { label: '\u652F\u6255\u6761\u4EF6' },\n      requested_status: { label: '\u7533\u8ACB\u30B9\u30C6\u30FC\u30BF\u30B9', options: { closed_won: '\u53D7\u6CE8', closed_lost: '\u5931\u6CE8' } },\n      status_change_approval_status: {\n        label: '\u30B9\u30C6\u30FC\u30BF\u30B9\u5909\u66F4\u627F\u8A8D',\n        options: { not_required: '\u627F\u8A8D\u4E0D\u8981', pending: '\u627F\u8A8D\u5F85\u3061', approved: '\u627F\u8A8D\u6E08\u307F', rejected: '\u5374\u4E0B' },\n      },\n      // REQ-0006 \u30B9\u30C6\u30C3\u30D7 11 \u2014 \u6848\u4EF6\u5316\uFF08\u7ACB\u9879\uFF09\u627F\u8A8D\u3002\n      qualification_requested: {\n        label: '\u6848\u4EF6\u5316\u627F\u8A8D\u3092\u7533\u8ACB',\n        help: '\u30C1\u30A7\u30C3\u30AF\u3059\u308B\u3068\u3053\u306E\u5546\u8AC7\u3092\u6848\u4EF6\u5316\u627F\u8A8D\u306B\u56DE\u3057\u307E\u3059\u3002\u5374\u4E0B\u3055\u308C\u308B\u3068\u30C1\u30A7\u30C3\u30AF\u304C\u5916\u308C\u307E\u3059\u3002\u518D\u5EA6\u30C1\u30A7\u30C3\u30AF\u3059\u308B\u3068\u6539\u3081\u3066\u7533\u8ACB\u3067\u304D\u307E\u3059\u3002',\n      },\n      qualification_approval_status: {\n        label: '\u6848\u4EF6\u5316\u627F\u8A8D',\n        options: { not_required: '\u627F\u8A8D\u4E0D\u8981', pending: '\u627F\u8A8D\u5F85\u3061', approved: '\u627F\u8A8D\u6E08\u307F', rejected: '\u5374\u4E0B' },\n      },\n    },\n    _views: {\n      tender_this_quarter: {\n        label: '\u4ECA\u56DB\u534A\u671F\u306B\u5165\u672D\u4E88\u5B9A',\n        emptyState: {\n          title: '\u4ECA\u56DB\u534A\u671F\u306B\u5165\u672D\u4E88\u5B9A\u306E\u5546\u8AC7\u306F\u3042\u308A\u307E\u305B\u3093',\n          message: '\u3053\u306E\u30BF\u30D6\u306B\u306F\u3001\u9867\u5BA2\u5074\u306E\u5165\u672D\u4E88\u5B9A\u65E5\u304C\u4ECA\u56DB\u534A\u671F\u5185\u306B\u3042\u308B\u30AA\u30FC\u30D7\u30F3\u5546\u8AC7\u304C\u8868\u793A\u3055\u308C\u307E\u3059\u3002\u5546\u8AC7\u306B\u300C\u5165\u672D\u4E88\u5B9A\u65E5\u300D\u3092\u5165\u529B\u3059\u308B\u3068\u3001\u3053\u3053\u306B\u8868\u793A\u3055\u308C\u307E\u3059\u3002',\n        },\n      },\n      open_opportunities: { label: '\u9032\u884C\u4E2D\u306E\u5546\u8AC7' },\n      all_opportunities: { label: '\u5168\u5546\u8AC7' },\n      pipeline_kanban: { label: '\u30BB\u30FC\u30EB\u30B9\u30D1\u30A4\u30D7\u30E9\u30A4\u30F3' },\n      close_date_calendar: { label: '\u4E88\u6E2C\u30AB\u30EC\u30F3\u30C0\u30FC' },\n      deal_timeline: { label: '\u5546\u8AC7\u30BF\u30A4\u30E0\u30E9\u30A4\u30F3' },\n      deal_gallery: { label: '\u5546\u8AC7\u30AB\u30FC\u30C9' },\n      my_open_deals: { label: '\u79C1\u306E\u30AA\u30FC\u30D7\u30F3\u5546\u8AC7' },\n      stale_opportunities: { label: '\u26A0\uFE0F \u505C\u6EDE\u5546\u8AC7 \u00B7 \u30B9\u30C6\u30FC\u30B8\u6EDE\u5728\u304C\u9577\u3044\u9806' },\n      closing_this_quarter: {\n        label: '\u4ECA\u56DB\u534A\u671F\u306B\u30AF\u30ED\u30FC\u30BA\u4E88\u5B9A',\n        emptyState: {\n          title: '\u4ECA\u56DB\u534A\u671F\u306B\u30AF\u30ED\u30FC\u30BA\u4E88\u5B9A\u306E\u5546\u8AC7\u306F\u3042\u308A\u307E\u305B\u3093',\n          message: '\u3053\u306E\u30BF\u30D6\u306B\u306F\u3001\u5B8C\u4E86\u4E88\u5B9A\u65E5\u304C\u4ECA\u56DB\u534A\u671F\u5185\u306B\u3042\u308B\u30B3\u30DF\u30C3\u30C8\uFF0F\u30D9\u30B9\u30C8\u30B1\u30FC\u30B9\u306E\u30AA\u30FC\u30D7\u30F3\u5546\u8AC7\u304C\u8868\u793A\u3055\u308C\u307E\u3059\u3002\u73FE\u5728\u8A72\u5F53\u3059\u308B\u5546\u8AC7\u306F\u3042\u308A\u307E\u305B\u3093\u3002\u305D\u308C\u4EE5\u964D\u306B\u30AF\u30ED\u30FC\u30BA\u3059\u308B\u5546\u8AC7\u306F\u300C\u30AA\u30FC\u30D7\u30F3\u5546\u8AC7\u300D\u30BF\u30D6\u306B\u3042\u308A\u307E\u3059\u3002',\n        },\n      },\n    },\n    _sections: {\n      // \u30AA\u30D6\u30B8\u30A7\u30AF\u30C8\u5B9A\u7FA9\u306E\u30BB\u30AF\u30B7\u30E7\u30F3\u30AD\u30FC\uFF08opportunity.object.ts\uFF09\u2014 \u5165\u529B\u30D5\u30A9\u30FC\u30E0\u3068\u3001\n      // \u3053\u308C\u3089\u306E\u30B0\u30EB\u30FC\u30D7\u3092\u53C2\u7167\u3059\u308B\u8A73\u7D30\u30DA\u30FC\u30B8\u306E\u30BB\u30AF\u30B7\u30E7\u30F3\uFF08#1452\uFF09\u3067\u4F7F\u7528\n      crm_forecast: { label: '\u30B9\u30C6\u30FC\u30B8\u30FB\u58F2\u4E0A\u4E88\u6E2C' },\n      basic: { label: '\u57FA\u672C\u60C5\u5831' },\n      financials: { label: '\u8CA1\u52D9\u60C5\u5831' },\n      sales_process: { label: '\u55B6\u696D\u30D7\u30ED\u30BB\u30B9' },\n      classification: { label: '\u5206\u985E' },\n      campaign: { label: '\u30AD\u30E3\u30F3\u30DA\u30FC\u30F3' },\n      notes: { label: '\u30E1\u30E2\u30FB\u6B21\u306E\u30B9\u30C6\u30C3\u30D7' },\n      qualification: { label: '\u9069\u683C\u5224\u5B9A' },\n      narrative: { label: '\u5546\u8AC7\u306E\u7D4C\u7DEF' },\n      // opportunity.view.ts \u306E\u30D5\u30A9\u30FC\u30E0\u30BB\u30AF\u30B7\u30E7\u30F3\u540D (#1100)\n      overview: { label: '\u6982\u8981' },\n      forecast: { label: '\u4E88\u6E2C' },\n      sales_strategy: { label: '\u55B6\u696D\u6226\u7565' },\n      win_loss: { label: '\u53D7\u6CE8\uFF0F\u5931\u6CE8' },\n    },\n    _actions: {\n      ...activityActions,\n      clone_opportunity: {\n        label: '\u5546\u8AC7\u3092\u8907\u88FD',\n        successMessage: '\u5546\u8AC7\u3092\u8907\u88FD\u3057\u307E\u3057\u305F\uFF01',\n      },\n      mass_update_stage: {\n        label: '\u30B9\u30C6\u30FC\u30B8\u66F4\u65B0',\n        successMessage: '\u5546\u8AC7\u30B9\u30C6\u30FC\u30B8\u3092\u66F4\u65B0\u3057\u307E\u3057\u305F\uFF01',\n        params: {\n          stage: {\n            label: '\u65B0\u3057\u3044\u30B9\u30C6\u30FC\u30B8',\n            options: { ...opportunityStageOptions },\n          },\n        },\n      },\n      generate_quote: {\n        label: '\u898B\u7A4D\u3092\u4F5C\u6210',\n        successMessage: '\u5546\u8AC7\u304B\u3089\u898B\u7A4D\u3092\u4F5C\u6210\u3057\u307E\u3057\u305F\uFF01',\n      },\n    },\n  },\n  crm_opportunity_line_item: {\n    _validations: {\n      unit_price_positive: {\n        message: '\u8CA9\u58F2\u4FA1\u683C\u3092\u8CA0\u306E\u5024\u306B\u3059\u308B\u3053\u3068\u306F\u3067\u304D\u307E\u305B\u3093',\n      },\n    },\n    label: '\u5546\u8AC7\u5546\u54C1\u660E\u7D30',\n    pluralLabel: '\u5546\u8AC7\u5546\u54C1\u660E\u7D30',\n    description: '\u5546\u8AC7\u914D\u4E0B\u306E\u88FD\u54C1\u5225\u4FA1\u683C\u660E\u7D30\u884C',\n    fields: {\n      crm_opportunity: { label: '\u5546\u8AC7' },\n      crm_product: { label: '\u88FD\u54C1' },\n      description: { label: '\u8AAC\u660E' },\n      quantity: { label: '\u6570\u91CF' },\n      list_price: { label: '\u5B9A\u4FA1', help: '\u88FD\u54C1\u306E\u30AB\u30BF\u30ED\u30B0\u4FA1\u683C\u304B\u3089\u81EA\u52D5\u5165\u529B\u3055\u308C\u307E\u3059' },\n      unit_price: { label: '\u8CA9\u58F2\u4FA1\u683C', help: '\u4EA4\u6E09\u5F8C\u306E\u5358\u4FA1\uFF08\u5B9A\u4FA1\u3068\u7570\u306A\u308B\u5834\u5408\u304C\u3042\u308A\u307E\u3059\uFF09' },\n      discount: { label: '\u5272\u5F15\u7387\uFF08%\uFF09' },\n      total_price: { label: '\u5408\u8A08' },\n      line_number: { label: '\u884C\u756A\u53F7' },\n    },\n    _sections: {\n      basic: { label: '\u660E\u7D30\u884C' },\n      pricing: { label: '\u4FA1\u683C' },\n    },\n  },\n  crm_forecast: {\n    _validations: {\n      period_end_after_start: {\n        message: '\u671F\u9593\u7D42\u4E86\u306F\u671F\u9593\u958B\u59CB\u3088\u308A\u5F8C\u3067\u3042\u308B\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059\u3002',\n      },\n      period_end_matches_calendar_period: {\n        message: '\u671F\u9593\u7D42\u4E86\u306F\u305D\u306E\u671F\u9593\u306E\u6700\u7D42\u65E5\u3067\u3042\u308B\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059\u3002\u4F8B\uFF1A2026-07-01 \u958B\u59CB\u306E\u56DB\u534A\u671F\u306A\u3089 2026-09-30\u30012026 \u5E74 8 \u6708\u306A\u3089 2026-08-31\u3002',\n      },\n      period_start_first_of_period: {\n        message: '\u671F\u9593\u958B\u59CB\u306F\u305D\u306E\u671F\u9593\u306E\u521D\u65E5\u3067\u3042\u308B\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059\u3002\u4F8B\uFF1A2026 \u5E74 8 \u6708\u306A\u3089 2026-08-01\u3002',\n      },\n      quarter_starts_on_quarter_boundary: {\n        message: '\u56DB\u534A\u671F\u30D5\u30A9\u30FC\u30AD\u30E3\u30B9\u30C8\u306F\u56DB\u534A\u671F\u306E\u5883\u754C\uFF081 \u6708 1 \u65E5\u30014 \u6708 1 \u65E5\u30017 \u6708 1 \u65E5\u300110 \u6708 1 \u65E5\uFF09\u304B\u3089\u958B\u59CB\u3059\u308B\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059\u3002',\n      },\n      snapshot_amounts_non_negative: {\n        message: '\u30B9\u30CA\u30C3\u30D7\u30B7\u30E7\u30C3\u30C8\u91D1\u984D\u306F\u8CA0\u306E\u5024\u306B\u3067\u304D\u307E\u305B\u3093\u3002',\n      },\n    },\n    label: '\u30D5\u30A9\u30FC\u30AD\u30E3\u30B9\u30C8',\n    pluralLabel: '\u30D5\u30A9\u30FC\u30AD\u30E3\u30B9\u30C8',\n    description: '\u62C5\u5F53\u8005\u3054\u3068\u306E\u5B9A\u671F\u30D1\u30A4\u30D7\u30E9\u30A4\u30F3\u30B9\u30CA\u30C3\u30D7\u30B7\u30E7\u30C3\u30C8\u3067\u53CE\u76CA\u4E88\u6E2C\u306B\u4F7F\u7528',\n    fields: {\n      owner_id: { label: '\u62C5\u5F53\u8005' },\n      period: { label: '\u671F\u9593', options: { month: '\u6708\u6B21', quarter: '\u56DB\u534A\u671F' } },\n      period_start: {\n        label: '\u671F\u9593\u958B\u59CB',\n        help: '\u671F\u9593\u306E\u521D\u65E5\u3067\u3042\u308B\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059 \u2014 \u4F8B: 2026 \u5E74 8 \u6708\u306A\u3089 2026-08-01\u3002\u56DB\u534A\u671F\u306E\u30D5\u30A9\u30FC\u30AD\u30E3\u30B9\u30C8\u306F\u3055\u3089\u306B\u56DB\u534A\u671F\u306E\u5883\u754C\uFF081 \u6708 1 \u65E5\u30FB4 \u6708 1 \u65E5\u30FB7 \u6708 1 \u65E5\u30FB10 \u6708 1 \u65E5\uFF09\u3067\u958B\u59CB\u3059\u308B\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059\u3002',\n      },\n      period_end: {\n        label: '\u671F\u9593\u7D42\u4E86',\n        help: '\u901A\u5E38\u306F\u300C\u671F\u9593\u300D\u3068\u300C\u671F\u9593\u958B\u59CB\u300D\u304B\u3089\u81EA\u52D5\u7684\u306B\u7B97\u51FA\u3055\u308C\u307E\u3059\u3002\u624B\u52D5\u3067\u5165\u529B\u3059\u308B\u5834\u5408\u306F\u3001\u305D\u306E\u671F\u9593\u306E\u6700\u7D42\u65E5\u3067\u3042\u308B\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059 \u2014 \u4F8B: 2026-07-01 \u958B\u59CB\u306E\u56DB\u534A\u671F\u306A\u3089 2026-09-30\u30012026 \u5E74 8 \u6708\u306A\u3089 2026-08-31\u3002',\n      },\n      period_label: {\n        label: '\u671F\u9593',\n        help: '\u300C2026 \u5E74\u7B2C 3 \u56DB\u534A\u671F\u300D\u300C2026 \u5E74 8 \u6708\u300D\u306E\u3088\u3046\u306A\u8AAD\u307F\u3084\u3059\u3044\u671F\u9593\u30E9\u30D9\u30EB\u3002',\n      },\n      display_title: { label: '\u8868\u793A\u540D' },\n      snapshot_date: { label: '\u30B9\u30CA\u30C3\u30D7\u30B7\u30E7\u30C3\u30C8\u65E5', help: '\u3053\u306E\u30B9\u30CA\u30C3\u30D7\u30B7\u30E7\u30C3\u30C8\u3092\u53D6\u5F97\u3057\u305F\u65E5\u3002' },\n      source: {\n        label: '\u30BD\u30FC\u30B9',\n        options: { scheduled: '\u5B9A\u671F\u30B9\u30CA\u30C3\u30D7\u30B7\u30E7\u30C3\u30C8', ai: 'AI \u30B9\u30AD\u30EB', manual: '\u624B\u52D5\u5165\u529B' },\n      },\n      quota: { label: '\u30AF\u30A9\u30FC\u30BF' },\n      pipeline_amount: {\n        label: '\u30D1\u30A4\u30D7\u30E9\u30A4\u30F3',\n        help: '\u3053\u306E\u671F\u9593\u306B\u30AF\u30ED\u30FC\u30BA\u4E88\u5B9A\u306E\u30AA\u30FC\u30D7\u30F3\u5546\u8AC7\u306E\u5408\u8A08\u91D1\u984D\uFF08\u30B9\u30C6\u30FC\u30B8\u3092\u554F\u308F\u306A\u3044\uFF09\u3002',\n      },\n      best_case_amount: {\n        label: '\u30D9\u30B9\u30C8\u30B1\u30FC\u30B9',\n        help: '\u58F2\u4E0A\u4E88\u6E2C\u30AB\u30C6\u30B4\u30EA\u304C\u300C\u30D9\u30B9\u30C8\u30B1\u30FC\u30B9\u300D\u307E\u305F\u306F\u300C\u30B3\u30DF\u30C3\u30C8\u300D\u306E\u30AA\u30FC\u30D7\u30F3\u5546\u8AC7\u3002',\n      },\n      commit_amount: {\n        label: '\u30B3\u30DF\u30C3\u30C8',\n        help: '\u58F2\u4E0A\u4E88\u6E2C\u30AB\u30C6\u30B4\u30EA\u304C\u300C\u30B3\u30DF\u30C3\u30C8\u300D\u306E\u30AA\u30FC\u30D7\u30F3\u5546\u8AC7\uFF08\u62C5\u5F53\u8005\u304C\u30B3\u30DF\u30C3\u30C8\u6E08\u307F\uFF09\u3002',\n      },\n      closed_amount: { label: '\u30AF\u30ED\u30FC\u30BA', help: '\u3053\u306E\u671F\u9593\u306B\u3059\u3067\u306B\u6210\u7ACB\u3057\u305F\u91D1\u984D\u3002' },\n      expected_amount: {\n        label: '\u4E88\u60F3',\n        help: '\u30AF\u30ED\u30FC\u30BA + \u30B3\u30DF\u30C3\u30C8 \u2014 \u62C5\u5F53\u8005\u304C\u7121\u7406\u306A\u304F\u7740\u5730\u3092\u898B\u8FBC\u3081\u308B\u91D1\u984D\u3002',\n      },\n      attainment_pct: {\n        label: '\u9054\u6210\u7387 %',\n        help: '\u30AF\u30ED\u30FC\u30BA \u00F7 \u30AF\u30A9\u30FC\u30BF \u00D7 100\u3002\u30AF\u30A9\u30FC\u30BF\u304C\u6B63\u306E\u5024\u306B\u306A\u308B\u307E\u3067\u306F 0% \u3068\u8868\u793A\u3055\u308C\u307E\u3059\u3002',\n      },\n      coverage_ratio: {\n        label: '\u30AB\u30D0\u30EC\u30C3\u30B8',\n        help: '\u30D1\u30A4\u30D7\u30E9\u30A4\u30F3 \u00F7\uFF08\u30AF\u30A9\u30FC\u30BF \u2212 \u30AF\u30ED\u30FC\u30BA\uFF09\u2014 \u6B8B\u308A\u306E\u5DEE\u5206\u3092\u57CB\u3081\u308B\u30D1\u30A4\u30D7\u30E9\u30A4\u30F3\u304C\u5341\u5206\u304B\u3069\u3046\u304B\u3002\u30AF\u30A9\u30FC\u30BF\u9054\u6210\u6E08\u307F\u306E\u5834\u5408\u306F 0 \u3068\u8868\u793A\u3055\u308C\u307E\u3059\u3002',\n      },\n      notes: { label: '\u30E1\u30E2' },\n      seed_key: {\n        label: '\u30B7\u30FC\u30C9\u30AD\u30FC',\n        help: '\u30C7\u30E2\u30C7\u30FC\u30BF\u306E\u8B58\u5225\u5B50\u3002\u30B7\u30FC\u30C9\u30ED\u30FC\u30C0\u30FC\u3060\u3051\u304C\u66F8\u304D\u8FBC\u307F\u3001\u5B9F\u969B\u306E\u30B9\u30CA\u30C3\u30D7\u30B7\u30E7\u30C3\u30C8\u3067\u306F\u5E38\u306B\u7A7A\u3067\u3059\u3002',\n      },\n    },\n    _views: {\n      all_forecasts: { label: '\u3059\u3079\u3066\u306E\u30D5\u30A9\u30FC\u30AD\u30E3\u30B9\u30C8' },\n      this_quarter_forecasts: {\n        label: '\u4ECA\u56DB\u534A\u671F',\n        emptyState: {\n          title: '\u4ECA\u56DB\u534A\u671F\u306E\u30B9\u30CA\u30C3\u30D7\u30B7\u30E7\u30C3\u30C8\u306F\u307E\u3060\u3042\u308A\u307E\u305B\u3093',\n          message: '\u56DB\u534A\u671F\u30B9\u30CA\u30C3\u30D7\u30B7\u30E7\u30C3\u30C8\u306F\u591C\u9593\u306E\u30D5\u30A9\u30FC\u30AD\u30E3\u30B9\u30C8\u96C6\u8A08\u304C\u66F8\u304D\u8FBC\u307F\u307E\u3059\u3002\u4ECA\u56DB\u534A\u671F\u5206\u304C\u4E00\u5EA6\u5B9F\u884C\u3055\u308C\u308B\u307E\u3067\u3053\u306E\u30D3\u30E5\u30FC\u306F\u7A7A\u3067\u3059\u3002\u78BA\u5B9A\u6E08\u307F\u306E\u56DB\u534A\u671F\u306F\u300C\u3059\u3079\u3066\u300D\u30BF\u30D6\u306B\u3042\u308A\u307E\u3059\u3002',\n        },\n      },\n      my_forecast: { label: '\u81EA\u5206\u306E\u30D5\u30A9\u30FC\u30AD\u30E3\u30B9\u30C8' },\n    },\n    _sections: {\n      basic: { label: '\u30B9\u30CA\u30C3\u30D7\u30B7\u30E7\u30C3\u30C8' },\n      amounts: { label: '\u91D1\u984D' },\n      meta: { label: '\u30BD\u30FC\u30B9' },\n      // forecast.view.ts \u306E\u30D5\u30A9\u30FC\u30E0\u30BB\u30AF\u30B7\u30E7\u30F3\u540D (#1100)\n      snapshot: { label: '\u30B9\u30CA\u30C3\u30D7\u30B7\u30E7\u30C3\u30C8' },\n      notes: { label: '\u30E1\u30E2' },\n    },\n  },\n};\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/sales/translations/ja-JP/objects.commerce.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/sales/translations/ja-JP\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/sales/translations/ja-JP/objects.commerce.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport type { ObjectTranslationData } from '@objectstack/spec/system';\n\n/**\n * \u65E5\u672C\u8A9E (ja-JP) \u2014 `objects` translations for the COMMERCE family:\n * what gets sold and on what paper \u2014 quotes, contracts, products.\n *\n * Roster: `crm_quote`, `crm_quote_line_item`, `crm_contract`, `crm_product`.\n *\n * SPLIT AXIS (#1311): translation NAMESPACE first, then CRM DOMAIN FAMILY.\n * Everything that is not `objects` lives in `./app.ts`; `objects` \u2014 69-78% of\n * every bundle \u2014 is one file per CRM domain family, and a detail object\n * follows its master. A new row goes in the file for ITS family, never in\n * whichever file is already open: that is how one file re-grows past the 70%\n * advisory band `pnpm hygiene` prints. Full rule and rationale:\n * `src/sales/translations/ja-JP.ts`.\n */\nconst paymentTermsOptions = {\n  net_15: '15 \u65E5\u4EE5\u5185\u6255\u3044', net_30: '30 \u65E5\u4EE5\u5185\u6255\u3044', net_60: '60 \u65E5\u4EE5\u5185\u6255\u3044',\n  net_90: '90 \u65E5\u4EE5\u5185\u6255\u3044', due_on_receipt: '\u8ACB\u6C42\u66F8\u53D7\u9818\u6642\u6255\u3044',\n};\n\nexport const commerce: Record<string, ObjectTranslationData> = {\n  crm_quote: {\n    _validations: {\n      discount_within_ceiling: {\n        message: '\u5272\u5F15\u7387\u306F 60% \u3092\u8D85\u3048\u3089\u308C\u307E\u305B\u3093',\n      },\n      expiration_after_quote: {\n        message: '\u6709\u52B9\u671F\u9650\u306F\u898B\u7A4D\u65E5\u3088\u308A\u5F8C\u3067\u3042\u308B\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059',\n      },\n      quote_status_progression: {\n        message: '\u7121\u52B9\u306A\u898B\u7A4D\u30B9\u30C6\u30FC\u30BF\u30B9\u9077\u79FB\u3067\u3059',\n      },\n    },\n    label: '\u898B\u7A4D',\n    pluralLabel: '\u898B\u7A4D',\n    description: '\u9867\u5BA2\u306B\u63D0\u793A\u3059\u308B\u4FA1\u683C\u898B\u7A4D',\n    fields: {\n      quote_number: { label: '\u898B\u7A4D\u756A\u53F7' },\n      name: { label: '\u898B\u7A4D\u540D' },\n      display_title: { label: '\u8868\u793A\u540D' },\n      crm_account: { label: '\u53D6\u5F15\u5148' },\n      crm_contact: {\n        label: '\u53D6\u5F15\u5148\u8CAC\u4EFB\u8005',\n        help: '\u898B\u7A4D\u304C\u300C\u63D0\u793A\u6E08\u307F\u300D\u307E\u305F\u306F\u300C\u627F\u8A8D\u6E08\u307F\u300D\u306B\u306A\u3063\u305F\u6642\u70B9\u3067\u5FC5\u9808\u3067\u3059\u3002\u4F5C\u6210\u3055\u308C\u308B\u5951\u7D04\u306E\u4E3B\u62C5\u5F53\u8005\u306F\u3053\u3053\u304B\u3089\u5F15\u304D\u7D99\u304C\u308C\u307E\u3059\u3002',\n      },\n      crm_opportunity: { label: '\u5546\u8AC7' },\n      owner_id: { label: '\u898B\u7A4D\u62C5\u5F53\u8005' },\n      status: {\n        label: '\u30B9\u30C6\u30FC\u30BF\u30B9',\n        options: {\n          draft: '\u4E0B\u66F8\u304D', in_review: '\u30EC\u30D3\u30E5\u30FC\u4E2D', presented: '\u63D0\u793A\u6E08\u307F',\n          accepted: '\u627F\u8A8D\u6E08\u307F', rejected: '\u5374\u4E0B', expired: '\u671F\u9650\u5207\u308C',\n        },\n      },\n      quote_date: { label: '\u898B\u7A4D\u65E5' },\n      expiration_date: { label: '\u6709\u52B9\u671F\u9650' },\n      subtotal: { label: '\u5C0F\u8A08' },\n      discount: { label: '\u5272\u5F15\u7387(%)' },\n      discount_amount: { label: '\u5272\u5F15\u984D' },\n      tax: { label: '\u7A0E\u984D' },\n      shipping_handling: { label: '\u914D\u9001\u30FB\u624B\u6570\u6599' },\n      total_price: { label: '\u5408\u8A08\u91D1\u984D' },\n      payment_terms: { label: '\u652F\u6255\u6761\u4EF6', options: { ...paymentTermsOptions } },\n      shipping_terms: { label: '\u914D\u9001\u6761\u4EF6' },\n      billing_address: { label: '\u8ACB\u6C42\u5148\u4F4F\u6240' },\n      shipping_address: { label: '\u914D\u9001\u5148\u4F4F\u6240' },\n      description: { label: '\u8AAC\u660E' },\n      internal_notes: { label: '\u5185\u90E8\u30E1\u30E2' },\n    },\n    _views: {\n      all_quotes: { label: '\u5168\u898B\u7A4D' },\n      quote_pipeline: { label: '\u898B\u7A4D\u30D1\u30A4\u30D7\u30E9\u30A4\u30F3' },\n      quote_calendar: { label: '\u898B\u7A4D\u30AB\u30EC\u30F3\u30C0\u30FC' },\n    },\n    _sections: {\n      basic: { label: '\u898B\u7A4D\u60C5\u5831' },\n      pricing: { label: '\u4FA1\u683C' },\n      terms: { label: '\u6761\u4EF6\u30FB\u6709\u52B9\u671F\u9650' },\n      address: { label: '\u4F4F\u6240' },\n      system: { label: '\u30B7\u30B9\u30C6\u30E0' },\n      // quote.view.ts \u306E\u30D5\u30A9\u30FC\u30E0\u30BB\u30AF\u30B7\u30E7\u30F3\u540D (#1100)\n      quote: { label: '\u898B\u7A4D\u66F8' },\n      totals: { label: '\u5408\u8A08' },\n      quote_terms: { label: '\u5951\u7D04\u6761\u4EF6' },\n      addresses_and_notes: { label: '\u4F4F\u6240\u3068\u5099\u8003' },\n    },\n  },\n  crm_quote_line_item: {\n    _validations: {\n      discount_within_ceiling: {\n        message: '\u660E\u7D30\u306E\u5272\u5F15\u7387\u306F 60% \u3092\u8D85\u3048\u3089\u308C\u307E\u305B\u3093',\n      },\n      unit_price_positive: {\n        message: '\u8CA9\u58F2\u4FA1\u683C\u3092\u8CA0\u306E\u5024\u306B\u3059\u308B\u3053\u3068\u306F\u3067\u304D\u307E\u305B\u3093',\n      },\n    },\n    label: '\u898B\u7A4D\u660E\u7D30',\n    pluralLabel: '\u898B\u7A4D\u660E\u7D30',\n    description: '\u898B\u7A4D\u914D\u4E0B\u306E\u88FD\u54C1\u5225\u4FA1\u683C\u660E\u7D30\u884C',\n    fields: {\n      crm_quote: { label: '\u898B\u7A4D' },\n      crm_product: { label: '\u88FD\u54C1' },\n      description: { label: '\u8AAC\u660E' },\n      quantity: { label: '\u6570\u91CF' },\n      list_price: { label: '\u5B9A\u4FA1' },\n      unit_price: { label: '\u8CA9\u58F2\u4FA1\u683C' },\n      discount: { label: '\u5272\u5F15\u7387\uFF08%\uFF09' },\n      subtotal: { label: '\u5C0F\u8A08' },\n      total_price: { label: '\u5408\u8A08' },\n      line_number: { label: '\u884C\u756A\u53F7' },\n    },\n    _sections: {\n      basic: { label: '\u660E\u7D30\u884C' },\n      pricing: { label: '\u4FA1\u683C' },\n    },\n  },\n  crm_contract: {\n    _validations: {\n      end_after_start: {\n        message: '\u7D42\u4E86\u65E5\u306F\u958B\u59CB\u65E5\u3088\u308A\u5F8C\u3067\u3042\u308B\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059',\n      },\n      contract_status_progression: {\n        message: '\u7121\u52B9\u306A\u5951\u7D04\u30B9\u30C6\u30FC\u30BF\u30B9\u9077\u79FB\u3067\u3059',\n      },\n    },\n    label: '\u5951\u7D04',\n    pluralLabel: '\u5951\u7D04',\n    description: '\u9867\u5BA2\u3068\u7DE0\u7D50\u3057\u305F\u6CD5\u7684\u306A\u5951\u7D04\u30FB\u5408\u610F',\n    fields: {\n      contract_number: { label: '\u5951\u7D04\u756A\u53F7' },\n      crm_account: { label: '\u53D6\u5F15\u5148' },\n      crm_contact: { label: '\u4E3B\u62C5\u5F53\u8005' },\n      crm_opportunity: { label: '\u95A2\u9023\u5546\u8AC7' },\n      owner_id: { label: '\u5951\u7D04\u62C5\u5F53\u8005' },\n      status: {\n        label: '\u30B9\u30C6\u30FC\u30BF\u30B9',\n        options: {\n          draft: '\u4E0B\u66F8\u304D', in_approval: '\u627F\u8A8D\u4E2D', activated: '\u6709\u52B9',\n          expired: '\u671F\u9650\u5207\u308C', terminated: '\u89E3\u7D04',\n        },\n      },\n      contract_term_months: { label: '\u5951\u7D04\u671F\u9593\uFF08\u6708\uFF09' },\n      start_date: { label: '\u958B\u59CB\u65E5' },\n      end_date: { label: '\u7D42\u4E86\u65E5' },\n      contract_value: { label: '\u5951\u7D04\u91D1\u984D' },\n      billing_frequency: {\n        label: '\u8ACB\u6C42\u983B\u5EA6',\n        options: { monthly: '\u6708\u6B21', quarterly: '\u56DB\u534A\u671F', annually: '\u5E74\u6B21', one_time: '\u4E00\u62EC' },\n      },\n      payment_terms: { label: '\u652F\u6255\u6761\u4EF6', options: { ...paymentTermsOptions } },\n      auto_renewal: { label: '\u81EA\u52D5\u66F4\u65B0' },\n      renewal_notice_days: { label: '\u66F4\u65B0\u901A\u77E5\uFF08\u65E5\uFF09' },\n      contract_type: {\n        label: '\u5951\u7D04\u7A2E\u5225',\n        options: {\n          subscription: '\u30B5\u30D6\u30B9\u30AF\u30EA\u30D7\u30B7\u30E7\u30F3\u5951\u7D04', service: '\u30B5\u30FC\u30D3\u30B9\u5951\u7D04',\n          license: '\u30E9\u30A4\u30BB\u30F3\u30B9\u5951\u7D04', partnership: '\u30D1\u30FC\u30C8\u30CA\u30FC\u30B7\u30C3\u30D7\u5951\u7D04',\n          nda: '\u79D8\u5BC6\u4FDD\u6301\u5951\u7D04 (NDA)', msa: '\u57FA\u672C\u5951\u7D04 (MSA)',\n        },\n      },\n      signed_date: { label: '\u7F72\u540D\u65E5' },\n      signed_by: { label: '\u7F72\u540D\u8005' },\n      document_url: { label: '\u5951\u7D04\u66F8\u985E' },\n      special_terms: { label: '\u7279\u7D04\u4E8B\u9805' },\n      description: { label: '\u8AAC\u660E' },\n      billing_address: { label: '\u8ACB\u6C42\u5148\u4F4F\u6240' },\n    },\n    _views: {\n      all_contracts: { label: '\u5168\u5951\u7D04' },\n      renewal_calendar: { label: '\u66F4\u65B0\u30AB\u30EC\u30F3\u30C0\u30FC' },\n      contract_gantt: { label: '\u5951\u7D04\u671F\u9593' },\n      contract_timeline: { label: '\u5951\u7D04\u30BF\u30A4\u30E0\u30E9\u30A4\u30F3' },\n    },\n    _sections: {\n      basic: { label: '\u5951\u7D04\u60C5\u5831' },\n      parties: { label: '\u5951\u7D04\u5F53\u4E8B\u8005' },\n      terms: { label: '\u5951\u7D04\u6761\u4EF6\u30FB\u671F\u9593' },\n      value: { label: '\u5951\u7D04\u91D1\u984D' },\n      status: { label: '\u30B9\u30C6\u30FC\u30BF\u30B9\u30FB\u627F\u8A8D' },\n      renewal: { label: '\u66F4\u65B0' },\n      // contract.view.ts \u306E\u30D5\u30A9\u30FC\u30E0\u30BB\u30AF\u30B7\u30E7\u30F3\u540D (#1100)\n      contract_terms: { label: '\u5951\u7D04\u6761\u4EF6' },\n      signing_and_documents: { label: '\u7F72\u540D\u3068\u66F8\u985E' },\n      notes: { label: '\u5099\u8003' },\n    },\n  },\n  crm_product: {\n    _validations: {\n      cost_less_than_price: {\n        message: '\u539F\u4FA1\u306F\u5B9A\u4FA1\u3088\u308A\u4F4E\u304F\u3057\u3066\u304F\u3060\u3055\u3044',\n      },\n      price_positive: {\n        message: '\u5B9A\u4FA1\u306F\u6B63\u306E\u5024\u3067\u3042\u308B\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059',\n      },\n    },\n    label: '\u88FD\u54C1',\n    pluralLabel: '\u88FD\u54C1',\n    description: '\u81EA\u793E\u304C\u63D0\u4F9B\u3059\u308B\u88FD\u54C1\u30FB\u30B5\u30FC\u30D3\u30B9',\n    fields: {\n      product_code: { label: '\u88FD\u54C1\u30B3\u30FC\u30C9' },\n      name: { label: '\u88FD\u54C1\u540D' },\n      display_title: { label: '\u8868\u793A\u540D' },\n      description: { label: '\u8AAC\u660E' },\n      category: {\n        label: '\u30AB\u30C6\u30B4\u30EA',\n        options: {\n          software: '\u30BD\u30D5\u30C8\u30A6\u30A7\u30A2', hardware: '\u30CF\u30FC\u30C9\u30A6\u30A7\u30A2', service: '\u30B5\u30FC\u30D3\u30B9',\n          subscription: '\u30B5\u30D6\u30B9\u30AF\u30EA\u30D7\u30B7\u30E7\u30F3', support: '\u30B5\u30DD\u30FC\u30C8',\n        },\n      },\n      family: {\n        label: '\u88FD\u54C1\u30D5\u30A1\u30DF\u30EA',\n        options: {\n          enterprise: '\u30A8\u30F3\u30BF\u30FC\u30D7\u30E9\u30A4\u30BA\u5411\u3051\u30BD\u30EA\u30E5\u30FC\u30B7\u30E7\u30F3', smb: '\u4E2D\u5C0F\u4F01\u696D\u5411\u3051\u30BD\u30EA\u30E5\u30FC\u30B7\u30E7\u30F3',\n          services: '\u30D7\u30ED\u30D5\u30A7\u30C3\u30B7\u30E7\u30CA\u30EB\u30B5\u30FC\u30D3\u30B9', cloud: '\u30AF\u30E9\u30A6\u30C9\u30B5\u30FC\u30D3\u30B9',\n        },\n      },\n      list_price: { label: '\u5B9A\u4FA1' },\n      cost: { label: '\u30B3\u30B9\u30C8' },\n      sku: { label: 'SKU' },\n      is_active: { label: '\u6709\u52B9' },\n      product_manager: { label: '\u30D7\u30ED\u30C0\u30AF\u30C8\u30DE\u30CD\u30FC\u30B8\u30E3\u30FC' },\n      image: { label: '\u88FD\u54C1\u753B\u50CF' },\n      datasheet: { label: '\u30C7\u30FC\u30BF\u30B7\u30FC\u30C8' },\n    },\n    _views: {\n      all_products: { label: '\u5168\u88FD\u54C1' },\n      product_catalog: { label: '\u88FD\u54C1\u30AB\u30BF\u30ED\u30B0' },\n    },\n    _sections: {\n      basic: { label: '\u88FD\u54C1\u60C5\u5831' },\n      pricing: { label: '\u4FA1\u683C' },\n      metadata: { label: '\u95A2\u9023\u8CC7\u6599' },\n      // product.view.ts \u306E\u30D5\u30A9\u30FC\u30E0\u30BB\u30AF\u30B7\u30E7\u30F3\u540D (#1100)\n      product_info: { label: '\u88FD\u54C1\u60C5\u5831' },\n      pricing_info: { label: '\u4FA1\u683C' },\n      media: { label: '\u30E1\u30C7\u30A3\u30A2' },\n    },\n  },\n};\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/sales/translations/ja-JP/objects.service.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/sales/translations/ja-JP\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/sales/translations/ja-JP/objects.service.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport type { ObjectTranslationData } from '@objectstack/spec/system';\n\nimport { activityActions } from './_shared';\n\n/**\n * \u65E5\u672C\u8A9E (ja-JP) \u2014 `objects` translations for the SERVICE family:\n * post-sale support \u2014 cases and the knowledge that deflects them.\n *\n * Roster: `crm_case`, `crm_knowledge_article`, `crm_article_feedback`.\n *\n * SPLIT AXIS (#1311): translation NAMESPACE first, then CRM DOMAIN FAMILY.\n * Everything that is not `objects` lives in `./app.ts`; `objects` \u2014 69-78% of\n * every bundle \u2014 is one file per CRM domain family, and a detail object\n * follows its master. A new row goes in the file for ITS family, never in\n * whichever file is already open: that is how one file re-grows past the 70%\n * advisory band `pnpm hygiene` prints. Full rule and rationale:\n * `src/sales/translations/ja-JP.ts`.\n */\nexport const service: Record<string, ObjectTranslationData> = {\n  crm_case: {\n    _validations: {\n      resolution_required_for_closed: {\n        message: '\u30B1\u30FC\u30B9\u3092\u30AF\u30ED\u30FC\u30BA\u3059\u308B\u306B\u306F\u89E3\u6C7A\u5185\u5BB9\u304C\u5FC5\u8981\u3067\u3059',\n      },\n      escalation_reason_required: {\n        message: '\u30B1\u30FC\u30B9\u3092\u30A8\u30B9\u30AB\u30EC\u30FC\u30B7\u30E7\u30F3\u3059\u308B\u306B\u306F\u7406\u7531\u304C\u5FC5\u8981\u3067\u3059',\n      },\n      case_status_progression: {\n        message: '\u7121\u52B9\u306A\u30B9\u30C6\u30FC\u30BF\u30B9\u9077\u79FB\u3067\u3059',\n      },\n    },\n    label: '\u30B1\u30FC\u30B9',\n    pluralLabel: '\u30B1\u30FC\u30B9',\n    description: '\u30AB\u30B9\u30BF\u30DE\u30FC\u30B5\u30DD\u30FC\u30C8\u306E\u30B1\u30FC\u30B9\u3068\u30B5\u30FC\u30D3\u30B9\u4F9D\u983C',\n    fields: {\n      case_number: { label: '\u30B1\u30FC\u30B9\u756A\u53F7' },\n      subject: { label: '\u4EF6\u540D' },\n      display_title: { label: '\u8868\u793A\u540D' },\n      description: { label: '\u8AAC\u660E' },\n      crm_account: { label: '\u53D6\u5F15\u5148' },\n      crm_contact: { label: '\u53D6\u5F15\u5148\u8CAC\u4EFB\u8005' },\n      status: {\n        label: '\u30B9\u30C6\u30FC\u30BF\u30B9',\n        options: {\n          new: '\u65B0\u898F', in_progress: '\u5BFE\u5FDC\u4E2D',\n          waiting_customer: '\u9867\u5BA2\u306E\u56DE\u7B54\u5F85\u3061', waiting_support: '\u30B5\u30DD\u30FC\u30C8\u306E\u56DE\u7B54\u5F85\u3061',\n          escalated: '\u30A8\u30B9\u30AB\u30EC\u30FC\u30B7\u30E7\u30F3\u6E08', resolved: '\u89E3\u6C7A\u6E08', closed: '\u30AF\u30ED\u30FC\u30BA\u6E08',\n        },\n      },\n      priority: {\n        label: '\u512A\u5148\u5EA6',\n        options: { low: '\u4F4E', medium: '\u4E2D', high: '\u9AD8', critical: '\u91CD\u5927' },\n      },\n      priority_rank: { label: '\u512A\u5148\u5EA6\u30E9\u30F3\u30AF' },\n      type: {\n        label: '\u30B1\u30FC\u30B9\u7A2E\u5225',\n        options: {\n          question: '\u554F\u3044\u5408\u308F\u305B', problem: '\u4E0D\u5177\u5408',\n          feature_request: '\u6A5F\u80FD\u8981\u671B', bug: '\u30D0\u30B0',\n        },\n      },\n      origin: {\n        label: '\u30B1\u30FC\u30B9\u767A\u751F\u5143',\n        options: { email: '\u30E1\u30FC\u30EB', phone: '\u96FB\u8A71', web: '\u30A6\u30A7\u30D6', chat: '\u30C1\u30E3\u30C3\u30C8', social_media: '\u30BD\u30FC\u30B7\u30E3\u30EB\u30E1\u30C7\u30A3\u30A2' },\n      },\n      owner_id: { label: '\u30B1\u30FC\u30B9\u62C5\u5F53\u8005' },\n      closed_date: { label: '\u30AF\u30ED\u30FC\u30BA\u65E5' },\n      first_response_date: { label: '\u521D\u56DE\u5FDC\u7B54\u65E5' },\n      resolution_time_hours: { label: '\u89E3\u6C7A\u6642\u9593\uFF08\u6642\u9593\uFF09' },\n      sla_due_date: { label: 'SLA\u671F\u9650', help: '\u30B1\u30FC\u30B9\u306E\u512A\u5148\u5EA6\u3068\u53D6\u5F15\u5148\u306E\u9867\u5BA2\u30E9\u30F3\u30AF\u304B\u3089\u8A2D\u5B9A\u3055\u308C\u3001\u66A6\u6642\u9593\u3067\u6570\u3048\u307E\u3059\u3002\u591C\u9593\u30FB\u9031\u672B\u30FB\u795D\u65E5\u3082\u3059\u3079\u3066\u542B\u307E\u308C\u307E\u3059\u3002' },\n      is_sla_violated: { label: 'SLA\u9055\u53CD' },\n      is_escalated: { label: '\u30A8\u30B9\u30AB\u30EC\u30FC\u30B7\u30E7\u30F3\u6E08' },\n      escalated_date: { label: '\u30A8\u30B9\u30AB\u30EC\u30FC\u30B7\u30E7\u30F3\u65E5' },\n      escalation_reason: { label: '\u30A8\u30B9\u30AB\u30EC\u30FC\u30B7\u30E7\u30F3\u7406\u7531' },\n      resolution: { label: '\u89E3\u6C7A\u5185\u5BB9' },\n      resolved_by_article: { label: '\u89E3\u6C7A\u3057\u305F\u30CA\u30EC\u30C3\u30B8\u8A18\u4E8B', help: '\u3053\u306E\u30B1\u30FC\u30B9\u3092\u89E3\u6C7A\u3057\u305F\u30CA\u30EC\u30C3\u30B8\u8A18\u4E8B \u2014 \u9038\u3089\u3057\u7387\u306E\u6307\u6A19\u3002' },\n      internal_notes: { label: '\u5185\u90E8\u30E1\u30E2', help: '\u9867\u5BA2\u306B\u306F\u8868\u793A\u3055\u308C\u306A\u3044\u793E\u5185\u5411\u3051\u30E1\u30E2' },\n      is_closed: { label: '\u30AF\u30ED\u30FC\u30BA\u6E08' },\n    },\n    _views: {\n      all_cases: { label: '\u5168\u30B1\u30FC\u30B9' },\n      case_workflow: { label: '\u30B5\u30FC\u30D3\u30B9\u30D5\u30ED\u30FC' },\n      sla_calendar: { label: 'SLA \u30AB\u30EC\u30F3\u30C0\u30FC' },\n      case_timeline: { label: '\u30B1\u30FC\u30B9\u30BF\u30A4\u30E0\u30E9\u30A4\u30F3' },\n      unassigned_triage: {\n        label: '\u672A\u5272\u308A\u5F53\u3066 \u2014 \u30C8\u30EA\u30A2\u30FC\u30B8',\n        emptyState: {\n          title: '\u30C8\u30EA\u30A2\u30FC\u30B8\u5F85\u3061\u306F\u3042\u308A\u307E\u305B\u3093',\n          message: '\u3059\u3079\u3066\u306E\u30B1\u30FC\u30B9\u306B\u6240\u6709\u8005\u304C\u3044\u307E\u3059\u3002\u6240\u6709\u8005\u306E\u306A\u3044\u30B1\u30FC\u30B9\u306F\u3053\u3053\u306B\u8868\u793A\u3055\u308C\u307E\u3059 \u2014 \u901A\u5E38\u306F\u3001\u30B5\u30FC\u30D3\u30B9\u30A8\u30FC\u30B8\u30A7\u30F3\u30C8\u306E\u8077\u4F4D\u3092\u8AB0\u3082\u4FDD\u6301\u3057\u3066\u3044\u306A\u3044\u9593\u306B\u5C4A\u3044\u305F Web-to-Case \u306E\u9001\u4FE1\u3067\u3059\u3002',\n        },\n      },\n      escalated_cases: { label: '\u30A8\u30B9\u30AB\u30EC\u30FC\u30C8\u3057\u305F\u30B1\u30FC\u30B9' },\n      my_open_cases: { label: '\u79C1\u306E\u30AA\u30FC\u30D7\u30F3\u30B1\u30FC\u30B9' },\n      sla_at_risk: { label: '\u23F0 SLA \u30EA\u30B9\u30AF\u3042\u308A' },\n    },\n    _sections: {\n      // case.view.ts \u306E\u30D5\u30A9\u30FC\u30E0\u30BB\u30AF\u30B7\u30E7\u30F3\u540D (#1100)\u3002\n      case: { label: '\u30B1\u30FC\u30B9' },\n      how_can_we_help: { label: '\u3069\u306E\u3088\u3046\u306A\u3054\u7528\u4EF6\u3067\u3057\u3087\u3046\u304B\uFF1F' },\n      // \u30AA\u30D6\u30B8\u30A7\u30AF\u30C8\u5B9A\u7FA9\u306E\u30BB\u30AF\u30B7\u30E7\u30F3\u30AD\u30FC\uFF08case.object.ts\uFF09\u2014 \u5165\u529B\u30D5\u30A9\u30FC\u30E0\u3068\u3001\n      // \u3053\u308C\u3089\u306E\u30B0\u30EB\u30FC\u30D7\u3092\u53C2\u7167\u3059\u308B\u8A73\u7D30\u30DA\u30FC\u30B8\u306E\u30BB\u30AF\u30B7\u30E7\u30F3\uFF08#970\uFF09\u3067\u4F7F\u7528\n      basic: { label: '\u30B1\u30FC\u30B9\u60C5\u5831' },\n      origin: { label: '\u767A\u751F\u5143\u30FB\u632F\u308A\u5206\u3051' },\n      sla: { label: 'SLA\u30FB\u512A\u5148\u5EA6' },\n      resolution: { label: '\u89E3\u6C7A' },\n      escalation: { label: '\u30A8\u30B9\u30AB\u30EC\u30FC\u30B7\u30E7\u30F3' },\n      system: { label: '\u30B7\u30B9\u30C6\u30E0' },\n    },\n    _actions: {\n      ...activityActions,\n      escalate_case: {\n        label: '\u30B1\u30FC\u30B9\u3092\u30A8\u30B9\u30AB\u30EC\u30FC\u30C8',\n        confirmText: '\u3053\u306E\u30B1\u30FC\u30B9\u3092\u30A8\u30B9\u30AB\u30EC\u30FC\u30B7\u30E7\u30F3\u30C1\u30FC\u30E0\u3078\u5F15\u304D\u7D99\u304E\u307E\u3059\u3002\u7D9A\u884C\u3057\u307E\u3059\u304B\uFF1F',\n        successMessage: '\u30B1\u30FC\u30B9\u3092\u30A8\u30B9\u30AB\u30EC\u30FC\u30C8\u3057\u307E\u3057\u305F\uFF01',\n      },\n      close_case: {\n        label: '\u30B1\u30FC\u30B9\u3092\u30AF\u30ED\u30FC\u30BA',\n        confirmText: '\u3053\u306E\u30B1\u30FC\u30B9\u3092\u30AF\u30ED\u30FC\u30BA\u3057\u3066\u3082\u3088\u308D\u3057\u3044\u3067\u3059\u304B\uFF1F',\n        successMessage: '\u30B1\u30FC\u30B9\u3092\u30AF\u30ED\u30FC\u30BA\u3057\u307E\u3057\u305F\uFF01',\n      },\n      claim_case: {\n        label: '\u30B1\u30FC\u30B9\u3092\u5F15\u304D\u53D7\u3051\u308B',\n        successMessage: '\u30B1\u30FC\u30B9\u3092\u5F15\u304D\u53D7\u3051\u307E\u3057\u305F\u3002\u62C5\u5F53\u8005\u306F\u3042\u306A\u305F\u3067\u3059\u3002',\n      },\n    },\n  },\n  crm_knowledge_article: {\n    _validations: {\n      published_requires_body: {\n        message: '\u672C\u6587\u306E\u306A\u3044\u8A18\u4E8B\u306F\u516C\u958B\u3067\u304D\u307E\u305B\u3093\u3002',\n      },\n      published_requires_summary: {\n        message: '\u516C\u958B\u6E08\u307F\u306E\u8A18\u4E8B\u306B\u306F\u3001\u691C\u7D22\u7D50\u679C\u3068 AI \u306E\u5F15\u7528\u306E\u305F\u3081\u306B\u6982\u8981\u3092\u8A18\u8F09\u3057\u3066\u304F\u3060\u3055\u3044\u3002',\n      },\n    },\n    label: '\u30CA\u30EC\u30C3\u30B8\u8A18\u4E8B',\n    pluralLabel: '\u30CA\u30EC\u30C3\u30B8\u30D9\u30FC\u30B9',\n    description: '\u9867\u5BA2\u3068\u30A8\u30FC\u30B8\u30A7\u30F3\u30C8\u304C\u518D\u5229\u7528\u3067\u304D\u308B\u56DE\u7B54\u3068\u30CF\u30A6\u30C4\u30FC\u30AC\u30A4\u30C9',\n    fields: {\n      article_number: { label: '\u8A18\u4E8B\u756A\u53F7' },\n      title: { label: '\u30BF\u30A4\u30C8\u30EB' },\n      display_title: { label: '\u8868\u793A\u540D' },\n      summary: { label: '\u8981\u7D04', help: '\u691C\u7D22\u7D50\u679C\u3084 AI \u306E\u5F15\u7528\u306B\u8868\u793A\u3055\u308C\u308B 1 \u6BB5\u843D\u306E\u8981\u7D04\u3002' },\n      body: { label: '\u672C\u6587', help: '\u8A18\u4E8B\u306E\u672C\u6587\uFF08Markdown\uFF09\u3002' },\n      category: {\n        label: '\u30AB\u30C6\u30B4\u30EA',\n        options: {\n          getting_started: '\u306F\u3058\u3081\u306B', how_to: '\u30CF\u30A6\u30C4\u30FC',\n          troubleshooting: '\u30C8\u30E9\u30D6\u30EB\u30B7\u30E5\u30FC\u30C6\u30A3\u30F3\u30B0', billing: '\u8ACB\u6C42\u3068\u6599\u91D1', api: 'API \u3068\u9023\u643A',\n          release_notes: '\u30EA\u30EA\u30FC\u30B9\u30CE\u30FC\u30C8', policy: '\u30DD\u30EA\u30B7\u30FC',\n        },\n      },\n      tags: {\n        label: '\u30BF\u30B0',\n        options: {\n          auth: '\u8A8D\u8A3C', sso: 'SSO', mobile: '\u30E2\u30D0\u30A4\u30EB', email: '\u30E1\u30FC\u30EB',\n          reports: '\u30EC\u30DD\u30FC\u30C8', performance: '\u30D1\u30D5\u30A9\u30FC\u30DE\u30F3\u30B9',\n          data_import: '\u30C7\u30FC\u30BF\u30A4\u30F3\u30DD\u30FC\u30C8', webhooks: 'Webhook',\n        },\n      },\n      status: {\n        label: '\u30B9\u30C6\u30FC\u30BF\u30B9',\n        options: { draft: '\u4E0B\u66F8\u304D', in_review: '\u30EC\u30D3\u30E5\u30FC\u4E2D', published: '\u516C\u958B\u6E08\u307F', archived: '\u30A2\u30FC\u30AB\u30A4\u30D6' },\n      },\n      audience: {\n        label: '\u5BFE\u8C61',\n        help: '\u516C\u958B\u8A18\u4E8B\u306F\u30AB\u30B9\u30BF\u30DE\u30FC\u30DD\u30FC\u30BF\u30EB\u306B\u8868\u793A\u3055\u308C\u3001\u793E\u5185\u8A18\u4E8B\u306F\u30A8\u30FC\u30B8\u30A7\u30F3\u30C8\u306E\u307F\u304C\u95B2\u89A7\u3067\u304D\u307E\u3059\u3002',\n        options: { public: '\u516C\u958B', internal: '\u793E\u5185' },\n      },\n      language: {\n        label: '\u8A00\u8A9E',\n        options: { en: '\u82F1\u8A9E', zh_cn: '\u7C21\u4F53\u5B57\u4E2D\u56FD\u8A9E', es_es: '\u30B9\u30DA\u30A4\u30F3\u8A9E', ja_jp: '\u65E5\u672C\u8A9E' },\n      },\n      owner_id: { label: '\u6240\u6709\u8005' },\n      related_to_case: { label: '\u5143\u306E\u30B1\u30FC\u30B9', help: '\u3053\u306E\u8A18\u4E8B\u306E\u5143\u306B\u306A\u3063\u305F\u30B1\u30FC\u30B9\uFF08\u4EFB\u610F\uFF09\u3002' },\n      published_at: { label: '\u516C\u958B\u65E5\u6642' },\n      last_reviewed_at: { label: '\u6700\u7D42\u30EC\u30D3\u30E5\u30FC' },\n      helpful_count: { label: '\u5F79\u306B\u7ACB\u3063\u305F', help: 'crm_article_feedback \u304B\u3089\u518D\u96C6\u8A08\u3055\u308C\u307E\u3059\u3002\u624B\u5165\u529B\u306F\u3067\u304D\u307E\u305B\u3093\u3002' },\n      not_helpful_count: { label: '\u5F79\u306B\u7ACB\u305F\u306A\u304B\u3063\u305F', help: 'crm_article_feedback \u304B\u3089\u518D\u96C6\u8A08\u3055\u308C\u307E\u3059\u3002\u624B\u5165\u529B\u306F\u3067\u304D\u307E\u305B\u3093\u3002' },\n    },\n    _views: {\n      all_articles: { label: '\u3059\u3079\u3066\u306E\u8A18\u4E8B' },\n      published_articles: { label: '\u516C\u958B\u6E08\u307F' },\n      my_drafts: { label: '\u81EA\u5206\u306E\u4E0B\u66F8\u304D' },\n    },\n    _sections: {\n      basic: { label: '\u8A18\u4E8B\u60C5\u5831' },\n      content: { label: '\u30B3\u30F3\u30C6\u30F3\u30C4' },\n      taxonomy: { label: '\u5206\u985E' },\n      metrics: { label: '\u5229\u7528\u72B6\u6CC1' },\n      engagement: { label: '\u5229\u7528\u72B6\u6CC1' },\n      // knowledge_article.view.ts \u306E\u30D5\u30A9\u30FC\u30E0\u30BB\u30AF\u30B7\u30E7\u30F3\u540D (#1100)\n      article: { label: '\u8A18\u4E8B' },\n    },\n    _actions: {\n      mark_article_helpful: {\n        label: '\u5F79\u306B\u7ACB\u3063\u305F',\n        successMessage: '\u300C\u5F79\u306B\u7ACB\u3063\u305F\u300D\u3068\u3057\u3066\u8A18\u9332\u3057\u307E\u3057\u305F\u3002\u3042\u308A\u304C\u3068\u3046\u3054\u3056\u3044\u307E\u3059\u3002',\n      },\n      mark_article_not_helpful: {\n        label: '\u5F79\u306B\u7ACB\u305F\u306A\u304B\u3063\u305F',\n        successMessage: '\u300C\u5F79\u306B\u7ACB\u305F\u306A\u304B\u3063\u305F\u300D\u3068\u3057\u3066\u8A18\u9332\u3057\u307E\u3057\u305F\u3002\u3042\u308A\u304C\u3068\u3046\u3054\u3056\u3044\u307E\u3059\u3002',\n      },\n    },\n  },\n  crm_article_feedback: {\n    label: '\u8A18\u4E8B\u30D5\u30A3\u30FC\u30C9\u30D0\u30C3\u30AF',\n    pluralLabel: '\u8A18\u4E8B\u30D5\u30A3\u30FC\u30C9\u30D0\u30C3\u30AF',\n    description: '\u30CA\u30EC\u30C3\u30B8\u8A18\u4E8B\u306B\u5BFE\u3059\u308B\u8AAD\u8005\u306E\u300C\u5F79\u306B\u7ACB\u3063\u305F / \u5F79\u306B\u7ACB\u305F\u306A\u304B\u3063\u305F\u300D\u8A55\u4FA1',\n    fields: {\n      feedback_number: { label: '\u30D5\u30A3\u30FC\u30C9\u30D0\u30C3\u30AF\u756A\u53F7' },\n      owner_id: { label: '\u8AAD\u8005' },\n      crm_knowledge_article: { label: '\u8A18\u4E8B', help: '\u3053\u306E\u30D5\u30A3\u30FC\u30C9\u30D0\u30C3\u30AF\u306E\u5BFE\u8C61\u3068\u306A\u308B\u30CA\u30EC\u30C3\u30B8\u8A18\u4E8B\u3002' },\n      verdict: {\n        label: '\u8A55\u4FA1',\n        options: { helpful: '\u5F79\u306B\u7ACB\u3063\u305F', not_helpful: '\u5F79\u306B\u7ACB\u305F\u306A\u304B\u3063\u305F' },\n      },\n      comment: { label: '\u30B3\u30E1\u30F3\u30C8', help: '\u8A55\u4FA1\u306E\u7406\u7531\uFF08\u4EFB\u610F\uFF09 \u2014 \u8A18\u4E8B\u306E\u4F5C\u6210\u8005\u304C\u8AAD\u307F\u307E\u3059\u3002' },\n    },\n    _sections: {\n      basic: { label: '\u30D5\u30A3\u30FC\u30C9\u30D0\u30C3\u30AF' },\n    },\n  },\n};\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/sales/translations/ja-JP/objects.activity.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/sales/translations/ja-JP\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/sales/translations/ja-JP/objects.activity.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport type { ObjectTranslationData } from '@objectstack/spec/system';\n\n/**\n * \u65E5\u672C\u8A9E (ja-JP) \u2014 `objects` translations for the ACTIVITY family:\n * the interaction log \u2014 tasks, events, and who attended.\n *\n * Roster: `crm_task`, `crm_event`, `crm_event_attendee`.\n *\n * SPLIT AXIS (#1311): translation NAMESPACE first, then CRM DOMAIN FAMILY.\n * Everything that is not `objects` lives in `./app.ts`; `objects` \u2014 69-78% of\n * every bundle \u2014 is one file per CRM domain family, and a detail object\n * follows its master. A new row goes in the file for ITS family, never in\n * whichever file is already open: that is how one file re-grows past the 70%\n * advisory band `pnpm hygiene` prints. Full rule and rationale:\n * `src/sales/translations/ja-JP.ts`.\n */\nconst relatedToTypeOptions = {\n  crm_account: '\u53D6\u5F15\u5148', crm_contact: '\u53D6\u5F15\u5148\u8CAC\u4EFB\u8005', crm_opportunity: '\u5546\u8AC7',\n  crm_lead: '\u30EA\u30FC\u30C9', crm_case: '\u30B1\u30FC\u30B9',\n};\n\nexport const activity: Record<string, ObjectTranslationData> = {\n  crm_task: {\n    _validations: {\n      completed_date_required: {\n        message: '\u30B9\u30C6\u30FC\u30BF\u30B9\u304C\u300C\u5B8C\u4E86\u300D\u306E\u5834\u5408\u306F\u5B8C\u4E86\u65E5\u304C\u5FC5\u8981\u3067\u3059',\n      },\n      recurrence_fields_required: {\n        message: '\u7E70\u308A\u8FD4\u3057\u30BF\u30B9\u30AF\u306B\u306F\u7E70\u308A\u8FD4\u3057\u7A2E\u5225\u304C\u5FC5\u8981\u3067\u3059',\n      },\n      related_to_required: {\n        message: '\u95A2\u9023\u30EC\u30B3\u30FC\u30C9\u3092\u5C11\u306A\u304F\u3068\u3082 1 \u4EF6\u9078\u629E\u3057\u3066\u304F\u3060\u3055\u3044',\n      },\n    },\n    label: '\u30BF\u30B9\u30AF',\n    pluralLabel: '\u30BF\u30B9\u30AF',\n    description: '\u6D3B\u52D5\u3068 ToDo',\n    fields: {\n      subject: { label: '\u4EF6\u540D' },\n      description: { label: '\u8AAC\u660E' },\n      status: {\n        label: '\u30B9\u30C6\u30FC\u30BF\u30B9',\n        options: {\n          not_started: '\u672A\u7740\u624B', in_progress: '\u9032\u884C\u4E2D', waiting: '\u5F85\u6A5F\u4E2D',\n          completed: '\u5B8C\u4E86', deferred: '\u4FDD\u7559',\n        },\n      },\n      priority: {\n        label: '\u512A\u5148\u5EA6',\n        options: { low: '\u4F4E', normal: '\u901A\u5E38', high: '\u9AD8', urgent: '\u7DCA\u6025' },\n      },\n      priority_rank: { label: '\u512A\u5148\u5EA6\u30E9\u30F3\u30AF' },\n      type: {\n        label: '\u30BF\u30B9\u30AF\u7A2E\u5225',\n        options: {\n          call: '\u96FB\u8A71', email: '\u30E1\u30FC\u30EB', meeting: '\u4F1A\u8B70',\n          follow_up: '\u30D5\u30A9\u30ED\u30FC\u30A2\u30C3\u30D7', demo: '\u30C7\u30E2', other: '\u305D\u306E\u4ED6',\n        },\n      },\n      due_date: { label: '\u671F\u9650' },\n      reminder_date: { label: '\u30EA\u30DE\u30A4\u30F3\u30C0\u30FC\u65E5\u6642' },\n      reminder_sent: { label: '\u30EA\u30DE\u30A4\u30F3\u30C0\u30FC\u9001\u4FE1\u6E08\u307F' },\n      completed_date: { label: '\u5B8C\u4E86\u65E5' },\n      owner_id: { label: '\u62C5\u5F53\u8005' },\n      related_to_type: {\n        label: '\u95A2\u9023\u30AA\u30D6\u30B8\u30A7\u30AF\u30C8\u7A2E\u5225',\n        options: { ...relatedToTypeOptions },\n      },\n      related_to_account: { label: '\u95A2\u9023\u53D6\u5F15\u5148' },\n      related_to_contact: { label: '\u95A2\u9023\u53D6\u5F15\u5148\u8CAC\u4EFB\u8005' },\n      related_to_opportunity: { label: '\u95A2\u9023\u5546\u8AC7' },\n      related_to_lead: { label: '\u95A2\u9023\u30EA\u30FC\u30C9' },\n      related_to_case: { label: '\u95A2\u9023\u30B1\u30FC\u30B9' },\n      is_recurring: { label: '\u7E70\u308A\u8FD4\u3057\u30BF\u30B9\u30AF' },\n      recurrence_type: {\n        label: '\u7E70\u308A\u8FD4\u3057\u7A2E\u5225',\n        options: { daily: '\u6BCE\u65E5', weekly: '\u6BCE\u9031', monthly: '\u6BCE\u6708', yearly: '\u6BCE\u5E74' },\n      },\n      recurrence_interval: { label: '\u7E70\u308A\u8FD4\u3057\u9593\u9694' },\n      recurrence_end_date: { label: '\u7E70\u308A\u8FD4\u3057\u7D42\u4E86\u65E5' },\n      is_completed: { label: '\u5B8C\u4E86\u6E08' },\n      is_overdue: { label: '\u671F\u9650\u8D85\u904E' },\n      progress_percent: { label: '\u9032\u6357\uFF08%\uFF09' },\n    },\n    _views: {\n      all_tasks: { label: '\u5168\u30BF\u30B9\u30AF' },\n      task_board: { label: '\u30BF\u30B9\u30AF\u30DC\u30FC\u30C9' },\n      task_calendar: { label: '\u30BF\u30B9\u30AF\u30AB\u30EC\u30F3\u30C0\u30FC' },\n      task_gantt: { label: '\u5B9F\u884C\u8A08\u753B' },\n      task_timeline: { label: '\u5DE5\u6570\u30BF\u30A4\u30E0\u30E9\u30A4\u30F3' },\n      my_open_tasks: { label: '\u79C1\u306E\u30AA\u30FC\u30D7\u30F3\u30BF\u30B9\u30AF' },\n      todays_tasks: { label: '\uD83D\uDCC5 \u79C1\u306E\u512A\u5148\u30BF\u30B9\u30AF' },\n      overdue_tasks: { label: '\u23F0 \u30AA\u30FC\u30D7\u30F3\u30BF\u30B9\u30AF \u00B7 \u671F\u9650\u8D85\u904E\u304C\u9577\u3044\u9806' },\n    },\n    _sections: {\n      basic: { label: '\u30BF\u30B9\u30AF\u60C5\u5831' },\n      scheduling: { label: '\u30B9\u30B1\u30B8\u30E5\u30FC\u30EB' },\n      related: { label: '\u95A2\u9023\u30EC\u30B3\u30FC\u30C9' },\n      recurrence: { label: '\u7E70\u308A\u8FD4\u3057' },\n      effort: { label: '\u9032\u6357\u30FB\u5DE5\u6570' },\n      system: { label: '\u30B7\u30B9\u30C6\u30E0' },\n      // task.view.ts \u306E\u30D5\u30A9\u30FC\u30E0\u30BB\u30AF\u30B7\u30E7\u30F3\u540D (#1100)\n      task: { label: '\u30BF\u30B9\u30AF' },\n      related_records: { label: '\u95A2\u9023\u30EC\u30B3\u30FC\u30C9' },\n      recurrence_and_effort: { label: '\u7E70\u308A\u8FD4\u3057\u3068\u5DE5\u6570' },\n    },\n  },\n  crm_event: {\n    _validations: {\n      end_after_start: {\n        message: '\u7D42\u4E86\u6642\u523B\u306F\u958B\u59CB\u6642\u523B\u3088\u308A\u5F8C\u3067\u3042\u308B\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059',\n      },\n      related_to_required: {\n        message: '\u95A2\u9023\u30EC\u30B3\u30FC\u30C9\u3092\u5C11\u306A\u304F\u3068\u3082 1 \u4EF6\u9078\u629E\u3057\u3066\u304F\u3060\u3055\u3044',\n      },\n    },\n    label: '\u30A4\u30D9\u30F3\u30C8',\n    pluralLabel: '\u30A4\u30D9\u30F3\u30C8',\n    description: '\u9867\u5BA2\u3068\u306E\u4F1A\u8B70\u30FB\u96FB\u8A71\u306A\u3069\u306E\u4E88\u5B9A\u3055\u308C\u305F\u5BFE\u8A71',\n    fields: {\n      subject: { label: '\u4EF6\u540D' },\n      description: { label: '\u8AAC\u660E' },\n      type: {\n        label: '\u30A4\u30D9\u30F3\u30C8\u7A2E\u5225',\n        options: {\n          meeting: '\u4F1A\u8B70', call: '\u96FB\u8A71', demo: '\u30C7\u30E2',\n          webinar: '\u30A6\u30A7\u30D3\u30CA\u30FC', onsite_visit: '\u8A2A\u554F', other: '\u305D\u306E\u4ED6',\n        },\n      },\n      status: {\n        label: '\u30B9\u30C6\u30FC\u30BF\u30B9',\n        options: {\n          planned: '\u4E88\u5B9A', held: '\u5B9F\u65BD\u6E08\u307F', cancelled: '\u30AD\u30E3\u30F3\u30BB\u30EB', no_show: '\u7121\u65AD\u6B20\u5E2D',\n        },\n      },\n      owner_id: { label: '\u62C5\u5F53\u8005' },\n      start_datetime: { label: '\u958B\u59CB' },\n      end_datetime: { label: '\u7D42\u4E86' },\n      all_day: { label: '\u7D42\u65E5\u30A4\u30D9\u30F3\u30C8' },\n      duration_minutes: { label: '\u6240\u8981\u6642\u9593\uFF08\u5206\uFF09' },\n      location: { label: '\u5834\u6240', help: '\u4F1A\u8B70\u5BA4\u30FB\u4F4F\u6240\u30FB\u4F1A\u8B70\u30EA\u30F3\u30AF' },\n      related_to_type: {\n        label: '\u95A2\u9023\u30EC\u30B3\u30FC\u30C9\u7A2E\u5225',\n        options: { ...relatedToTypeOptions },\n      },\n      related_to_account: { label: '\u95A2\u9023\u53D6\u5F15\u5148' },\n      related_to_contact: { label: '\u95A2\u9023\u53D6\u5F15\u5148\u8CAC\u4EFB\u8005' },\n      related_to_opportunity: { label: '\u95A2\u9023\u5546\u8AC7' },\n      related_to_lead: { label: '\u95A2\u9023\u30EA\u30FC\u30C9' },\n      related_to_case: { label: '\u95A2\u9023\u30B1\u30FC\u30B9' },\n      outcome_notes: { label: '\u7D50\u679C\u30E1\u30E2', help: '\u5408\u610F\u4E8B\u9805\u3068\u6B21\u306E\u30A2\u30AF\u30B7\u30E7\u30F3' },\n    },\n    _views: {\n      all_events: { label: '\u3059\u3079\u3066\u306E\u30A4\u30D9\u30F3\u30C8' },\n      event_calendar: { label: '\u30A4\u30D9\u30F3\u30C8\u30AB\u30EC\u30F3\u30C0\u30FC' },\n      event_timeline: { label: '\u30C1\u30FC\u30E0\u30B9\u30B1\u30B8\u30E5\u30FC\u30EB' },\n      my_events: { label: '\u30DE\u30A4\u30AB\u30EC\u30F3\u30C0\u30FC' },\n      upcoming_events: { label: '\uD83D\uDCC5 \u958B\u50AC\u4E88\u5B9A \u00B7 \u76F4\u8FD1\u9806' },\n      held_events: { label: '\u2705 \u5BFE\u8A71\u5C65\u6B74' },\n    },\n    _sections: {\n      basic: { label: '\u30A4\u30D9\u30F3\u30C8\u60C5\u5831' },\n      schedule: { label: '\u30B9\u30B1\u30B8\u30E5\u30FC\u30EB' },\n      related: { label: '\u95A2\u9023\u30EC\u30B3\u30FC\u30C9' },\n      outcome: { label: '\u5B9F\u65BD\u7D50\u679C' },\n      // event.view.ts \u306E\u30D5\u30A9\u30FC\u30E0\u30BB\u30AF\u30B7\u30E7\u30F3\u540D (#1100)\n      event: { label: '\u30A4\u30D9\u30F3\u30C8' },\n      related_records: { label: '\u95A2\u9023\u30EC\u30B3\u30FC\u30C9' },\n    },\n  },\n  crm_event_attendee: {\n    _validations: {\n      attendee_resolves: {\n        message: '\u53C2\u52A0\u8005\u306F\u53C2\u52A0\u8005\u7A2E\u5225\u304C\u793A\u3059\u76F8\u624B\u3092\u6307\u5B9A\u3059\u308B\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059\u3002\u53D6\u5F15\u5148\u8CAC\u4EFB\u8005\u306E\u5834\u5408\u306F\u53D6\u5F15\u5148\u8CAC\u4EFB\u8005\u3092\u3001\u793E\u5916\u306E\u5834\u5408\u306F\u793E\u5916\u53C2\u52A0\u8005\u540D\u3092\u5165\u529B\u3057\u3066\u304F\u3060\u3055\u3044',\n      },\n      attendee_type_exclusive: {\n        message: '\u53C2\u52A0\u8005\u304C\u6307\u5B9A\u3067\u304D\u308B\u76F8\u624B\u306F 1 \u3064\u3060\u3051\u3067\u3059\u3002\u53C2\u52A0\u8005\u7A2E\u5225\u304C\u793A\u3055\u306A\u3044\u9805\u76EE\u306F\u3059\u3079\u3066\u7A7A\u306B\u3057\u3066\u304F\u3060\u3055\u3044',\n      },\n    },\n    label: '\u30A4\u30D9\u30F3\u30C8\u53C2\u52A0\u8005',\n    pluralLabel: '\u30A4\u30D9\u30F3\u30C8\u53C2\u52A0\u8005',\n    description: '\u30A4\u30D9\u30F3\u30C8\u306B\u62DB\u5F85\u3055\u308C\u305F\u3001\u307E\u305F\u306F\u51FA\u5E2D\u3057\u305F\u4EBA',\n    fields: {\n      attendee_number: { label: '\u53C2\u52A0\u8005\u756A\u53F7' },\n      crm_event: { label: '\u30A4\u30D9\u30F3\u30C8' },\n      attendee_type: {\n        label: '\u53C2\u52A0\u8005\u7A2E\u5225',\n        options: { contact: '\u53D6\u5F15\u5148\u8CAC\u4EFB\u8005', lead: '\u30EA\u30FC\u30C9', user: '\u793E\u5185\u30E6\u30FC\u30B6\u30FC', external: '\u793E\u5916\u30B2\u30B9\u30C8' },\n      },\n      crm_contact: { label: '\u53D6\u5F15\u5148\u8CAC\u4EFB\u8005', help: '\u53C2\u52A0\u8005\u304C\u65E2\u5B58\u306E\u53D6\u5F15\u5148\u8CAC\u4EFB\u8005\u3067\u3042\u308B\u5834\u5408\u306B\u8A2D\u5B9A\u3057\u307E\u3059' },\n      crm_lead: { label: '\u30EA\u30FC\u30C9', help: '\u53C2\u52A0\u8005\u304C\u307E\u3060\u5909\u63DB\u3055\u308C\u3066\u3044\u306A\u3044\u30EA\u30FC\u30C9\u3067\u3042\u308B\u5834\u5408\u306B\u8A2D\u5B9A\u3057\u307E\u3059' },\n      sys_user: { label: '\u793E\u5185\u30E6\u30FC\u30B6\u30FC', help: '\u53C2\u52A0\u8005\u304C\u793E\u5185\u306E\u540C\u50DA\u3067\u3042\u308B\u5834\u5408\u306B\u8A2D\u5B9A\u3057\u307E\u3059' },\n      external_name: { label: '\u793E\u5916\u53C2\u52A0\u8005', help: 'CRM \u306E\u3069\u306E\u30AA\u30D6\u30B8\u30A7\u30AF\u30C8\u306B\u3082\u5B58\u5728\u3057\u306A\u3044\u53C2\u52A0\u8005\u306E\u6C0F\u540D \u2014 \u53C2\u52A0\u8005\u7A2E\u5225\u304C\u300C\u793E\u5916\u30B2\u30B9\u30C8\u300D\u306E\u3068\u304D\u306B\u8A2D\u5B9A\u3057\u307E\u3059' },\n      response: {\n        label: '\u56DE\u7B54',\n        options: {\n          no_response: '\u672A\u56DE\u7B54', accepted: '\u627F\u8AFE',\n          declined: '\u8F9E\u9000', tentative: '\u4EEE\u627F\u8AFE',\n        },\n      },\n      is_organizer: { label: '\u4E3B\u50AC\u8005' },\n      invited_date: { label: '\u62DB\u5F85\u65E5\u6642' },\n    },\n    _views: {\n      all_event_attendees: { label: '\u30A4\u30D9\u30F3\u30C8\u53C2\u52A0\u8005' },\n    },\n    _sections: {\n      basic: { label: '\u53C2\u52A0\u8005' },\n      response: { label: '\u62DB\u5F85' },\n      // event_attendee.view.ts \u306E\u30D5\u30A9\u30FC\u30E0\u30BB\u30AF\u30B7\u30E7\u30F3\u540D (#1100)\n      attendee: { label: '\u53C2\u52A0\u8005' },\n      invitation: { label: '\u62DB\u5F85' },\n    },\n  },\n};\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/sales/translations/ja-JP/objects.marketing.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/sales/translations/ja-JP\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/sales/translations/ja-JP/objects.marketing.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport type { ObjectTranslationData } from '@objectstack/spec/system';\n\n/**\n * \u65E5\u672C\u8A9E (ja-JP) \u2014 `objects` translations for the MARKETING family:\n * demand generation \u2014 campaigns and their membership.\n *\n * Roster: `crm_campaign`, `crm_campaign_member`.\n *\n * SPLIT AXIS (#1311): translation NAMESPACE first, then CRM DOMAIN FAMILY.\n * Everything that is not `objects` lives in `./app.ts`; `objects` \u2014 69-78% of\n * every bundle \u2014 is one file per CRM domain family, and a detail object\n * follows its master. A new row goes in the file for ITS family, never in\n * whichever file is already open: that is how one file re-grows past the 70%\n * advisory band `pnpm hygiene` prints. Full rule and rationale:\n * `src/sales/translations/ja-JP.ts`.\n */\nexport const marketing: Record<string, ObjectTranslationData> = {\n  crm_campaign: {\n    _validations: {\n      end_after_start: {\n        message: '\u7D42\u4E86\u65E5\u306F\u958B\u59CB\u65E5\u3088\u308A\u5F8C\u3067\u3042\u308B\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059',\n      },\n      actual_cost_within_budget: {\n        message: '\u5B9F\u7E3E\u30B3\u30B9\u30C8\u304C\u4E88\u7B97\u30B3\u30B9\u30C8\u3092\u8D85\u3048\u3066\u3044\u307E\u3059',\n      },\n    },\n    label: '\u30AD\u30E3\u30F3\u30DA\u30FC\u30F3',\n    pluralLabel: '\u30AD\u30E3\u30F3\u30DA\u30FC\u30F3',\n    description: '\u30DE\u30FC\u30B1\u30C6\u30A3\u30F3\u30B0\u30AD\u30E3\u30F3\u30DA\u30FC\u30F3\u3068\u65BD\u7B56',\n    fields: {\n      campaign_code: { label: '\u30AD\u30E3\u30F3\u30DA\u30FC\u30F3\u30B3\u30FC\u30C9' },\n      name: { label: '\u30AD\u30E3\u30F3\u30DA\u30FC\u30F3\u540D' },\n      display_title: { label: '\u8868\u793A\u540D' },\n      description: { label: '\u8AAC\u660E' },\n      type: {\n        label: '\u30AD\u30E3\u30F3\u30DA\u30FC\u30F3\u7A2E\u5225',\n        options: {\n          email: '\u30E1\u30FC\u30EB', webinar: '\u30A6\u30A7\u30D3\u30CA\u30FC', trade_show: '\u5C55\u793A\u4F1A',\n          conference: '\u30AB\u30F3\u30D5\u30A1\u30EC\u30F3\u30B9', direct_mail: '\u30C0\u30A4\u30EC\u30AF\u30C8\u30E1\u30FC\u30EB',\n          social_media: '\u30BD\u30FC\u30B7\u30E3\u30EB\u30E1\u30C7\u30A3\u30A2', content: '\u30B3\u30F3\u30C6\u30F3\u30C4\u30DE\u30FC\u30B1\u30C6\u30A3\u30F3\u30B0',\n          partner: '\u30D1\u30FC\u30C8\u30CA\u30FC\u30DE\u30FC\u30B1\u30C6\u30A3\u30F3\u30B0',\n        },\n      },\n      channel: {\n        label: '\u4E3B\u8981\u30C1\u30E3\u30CD\u30EB',\n        options: {\n          digital: '\u30C7\u30B8\u30BF\u30EB', social: '\u30BD\u30FC\u30B7\u30E3\u30EB', email: '\u30E1\u30FC\u30EB',\n          events: '\u30A4\u30D9\u30F3\u30C8', partner: '\u30D1\u30FC\u30C8\u30CA\u30FC',\n        },\n      },\n      status: {\n        label: '\u30B9\u30C6\u30FC\u30BF\u30B9',\n        options: {\n          planning: '\u8A08\u753B\u4E2D', in_progress: '\u5B9F\u65BD\u4E2D',\n          completed: '\u5B8C\u4E86', aborted: '\u4E2D\u6B62',\n        },\n      },\n      start_date: { label: '\u958B\u59CB\u65E5' },\n      end_date: { label: '\u7D42\u4E86\u65E5' },\n      budgeted_cost: { label: '\u4E88\u7B97\u30B3\u30B9\u30C8' },\n      actual_cost: { label: '\u5B9F\u30B3\u30B9\u30C8' },\n      expected_revenue: { label: '\u4E88\u6E2C\u58F2\u4E0A' },\n      actual_revenue: { label: '\u5B9F\u53CE\u76CA' },\n      target_size: { label: '\u30BF\u30FC\u30B2\u30C3\u30C8\u898F\u6A21', help: '\u5BFE\u8C61\u3068\u3059\u308B\u30EA\u30FC\u30C9\u30FB\u53D6\u5F15\u5148\u8CAC\u4EFB\u8005\u306E\u76EE\u6A19\u4EF6\u6570' },\n      num_sent: { label: '\u9001\u4FE1\u6570' },\n      num_responses: { label: '\u5FDC\u7B54\u6570' },\n      num_leads: { label: '\u30EA\u30FC\u30C9\u6570' },\n      num_converted_leads: { label: '\u5909\u63DB\u6E08\u30EA\u30FC\u30C9\u6570' },\n      num_opportunities: { label: '\u4F5C\u6210\u6E08\u5546\u8AC7\u6570' },\n      num_won_opportunities: { label: '\u53D7\u6CE8\u5546\u8AC7' },\n      response_rate: { label: '\u5FDC\u7B54\u7387\uFF08%\uFF09' },\n      roi: { label: 'ROI\uFF08%\uFF09' },\n      owner_id: { label: '\u30AD\u30E3\u30F3\u30DA\u30FC\u30F3\u62C5\u5F53\u8005' },\n      landing_page_url: { label: '\u30E9\u30F3\u30C7\u30A3\u30F3\u30B0\u30DA\u30FC\u30B8' },\n      is_active: { label: '\u6709\u52B9' },\n    },\n    _views: {\n      all_campaigns: { label: '\u5168\u30AD\u30E3\u30F3\u30DA\u30FC\u30F3' },\n      campaign_gantt: { label: '\u30AD\u30E3\u30F3\u30DA\u30FC\u30F3\u65E5\u7A0B' },\n      campaign_calendar: { label: '\u30AD\u30E3\u30F3\u30DA\u30FC\u30F3\u30AB\u30EC\u30F3\u30C0\u30FC' },\n      campaign_timeline: { label: '\u30DE\u30FC\u30B1\u30C6\u30A3\u30F3\u30B0\u30BF\u30A4\u30E0\u30E9\u30A4\u30F3' },\n    },\n    _sections: {\n      basic: { label: '\u30AD\u30E3\u30F3\u30DA\u30FC\u30F3\u60C5\u5831' },\n      schedule: { label: '\u30B9\u30B1\u30B8\u30E5\u30FC\u30EB' },\n      budget: { label: '\u4E88\u7B97\u30FBROI' },\n      metrics: { label: '\u5B9F\u7E3E' },\n      assignment: { label: '\u62C5\u5F53\u8005' },\n      assets: { label: '\u30AD\u30E3\u30F3\u30DA\u30FC\u30F3\u30A2\u30BB\u30C3\u30C8' },\n    },\n    _actions: {\n      enroll_leads: {\n        label: '\u30E1\u30F3\u30D0\u30FC\u3092\u4E00\u62EC\u767B\u9332',\n        successMessage: '\u5BFE\u8C61\u30E1\u30F3\u30D0\u30FC\u3092\u30AD\u30E3\u30F3\u30DA\u30FC\u30F3\u306B\u767B\u9332\u3057\u307E\u3057\u305F\u3002',\n      },\n    },\n  },\n  crm_campaign_member: {\n    _validations: {\n      lead_or_contact_required: {\n        message: '\u30AD\u30E3\u30F3\u30DA\u30FC\u30F3\u30E1\u30F3\u30D0\u30FC\u306F\u30EA\u30FC\u30C9\u307E\u305F\u306F\u53D6\u5F15\u5148\u8CAC\u4EFB\u8005\u306E\u3044\u305A\u308C\u304B\u3092\u53C2\u7167\u3059\u308B\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059',\n      },\n    },\n    label: '\u30AD\u30E3\u30F3\u30DA\u30FC\u30F3\u30E1\u30F3\u30D0\u30FC',\n    pluralLabel: '\u30AD\u30E3\u30F3\u30DA\u30FC\u30F3\u30E1\u30F3\u30D0\u30FC',\n    description: '\u30AD\u30E3\u30F3\u30DA\u30FC\u30F3\u306E\u5BFE\u8C61\u3068\u306A\u3063\u305F\u30EA\u30FC\u30C9\u30FB\u53D6\u5F15\u5148\u8CAC\u4EFB\u8005\u3068\u305D\u306E\u53CD\u5FDC\u72B6\u6CC1',\n    fields: {\n      member_number: { label: '\u30E1\u30F3\u30D0\u30FC\u756A\u53F7' },\n      crm_campaign: { label: '\u30AD\u30E3\u30F3\u30DA\u30FC\u30F3' },\n      crm_lead: { label: '\u30EA\u30FC\u30C9', help: '\u767B\u9332\u6642\u70B9\u3067\u30EA\u30FC\u30C9\u3060\u3063\u305F\u30E1\u30F3\u30D0\u30FC\u306B\u8A2D\u5B9A\u3055\u308C\u307E\u3059' },\n      crm_contact: { label: '\u53D6\u5F15\u5148\u8CAC\u4EFB\u8005', help: '\u65E2\u5B58\u306E\u53D6\u5F15\u5148\u8CAC\u4EFB\u8005\u3067\u3042\u308B\u30E1\u30F3\u30D0\u30FC\u306B\u8A2D\u5B9A\u3055\u308C\u307E\u3059' },\n      status: {\n        label: '\u30B9\u30C6\u30FC\u30BF\u30B9',\n        options: {\n          sent: '\u9001\u4FE1\u6E08', responded: '\u5FDC\u7B54\u6E08',\n          converted: '\u5909\u63DB\u6E08', unsubscribed: '\u914D\u4FE1\u505C\u6B62',\n        },\n      },\n      added_date: { label: '\u8FFD\u52A0\u65E5\u6642' },\n      response_date: { label: '\u5FDC\u7B54\u65E5\u6642' },\n      has_responded: { label: '\u5FDC\u7B54\u6E08' },\n    },\n    _sections: {\n      basic: { label: '\u57FA\u672C\u60C5\u5831' },\n      response: { label: '\u53CD\u5FDC\u30C8\u30E9\u30C3\u30AD\u30F3\u30B0' },\n    },\n    _actions: {\n      mark_responded: {\n        label: '\u5FDC\u7B54\u6E08\u306B\u3059\u308B',\n        successMessage: '\u3053\u306E\u30AD\u30E3\u30F3\u30DA\u30FC\u30F3\u30E1\u30F3\u30D0\u30FC\u306E\u5FDC\u7B54\u3092\u8A18\u9332\u3057\u307E\u3057\u305F\u3002',\n      },\n    },\n  },\n};\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/sales/translations/ja-JP.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/sales/translations\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/sales/translations/ja-JP.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport type { TranslationData } from '@objectstack/spec/system';\n\nimport { appSurface } from './ja-JP/app';\nimport { customer } from './ja-JP/objects.customer';\nimport { pipeline } from './ja-JP/objects.pipeline';\nimport { commerce } from './ja-JP/objects.commerce';\nimport { service } from './ja-JP/objects.service';\nimport { activity } from './ja-JP/objects.activity';\nimport { marketing } from './ja-JP/objects.marketing';\n\n/**\n * \u65E5\u672C\u8A9E (ja-JP) \u2014 CRM App Translations\n *\n * Per-locale file: one file per language, following the `per_locale` convention.\n *\n * SPLIT AXIS (#1311): translation NAMESPACE first, then CRM DOMAIN FAMILY.\n *\n * This bundle was one file and it had reached 88.6% of the 100KB source cap\n * `pnpm hygiene` enforces, growing ~1.2KB a day. It is now assembled from\n * `./<locale>/`, on an axis measured rather than guessed:\n *\n *   - every namespace that is NOT `objects` \u2014 `apps`, `messages`,\n *     `dashboards`, `datasets`, `pages`, and any namespace `TranslationData`\n *     gains later \u2014 lives in `app.ts`. Measured: those namespaces together\n *     are under a quarter of the bundle, and the schema bounds how many can\n *     ever arrive, so one file holds them with room left;\n *   - `objects` is 69-78% of every bundle, so it is partitioned again, one\n *     file per CRM domain family \u2014 `customer`, `pipeline`, `commerce`,\n *     `service`, `activity`, `marketing` \u2014 and a DETAIL object follows its\n *     master: line items follow their quote or opportunity,\n *     `crm_event_attendee` follows `crm_event`, `crm_campaign_member`\n *     follows `crm_campaign`, `crm_article_feedback` follows\n *     `crm_knowledge_article`.\n *\n * A namespace axis ALONE was measured and rejected: it leaves `objects` at\n * 65.7KB, 3.9KB under the advisory band, which `objects` growth crosses in\n * about nine days. The family axis puts the largest part at 24.2% of the cap.\n *\n * \u26A0\uFE0F A new object translation belongs in the file for ITS family. Do not add\n * it to whichever file is already open \u2014 that is how one file re-grows past\n * the band, which is what split this bundle in the first place.\n *\n * \u26A0\uFE0F A value used by more than one family lives in `<locale>/_shared.ts`. A\n * value used by exactly one family lives in that family's file.\n *\n * \u26A0\uFE0F The key order below is LOAD-BEARING, not cosmetic. `objectstack build`\n * serialises this object into `dist/objectstack.json` in insertion order and\n * never sorts it, so listing the rows here \u2014 rather than spreading the family\n * files \u2014 is what keeps the built artifact byte-identical across the split.\n * The order is this bundle's own historical accretion order and differs\n * between locales; reordering it rewrites the artifact.\n */\nexport const jaJP: TranslationData = {\n  objects: {\n    crm_account: customer.crm_account,\n    crm_contact: customer.crm_contact,\n    crm_knowledge_article: service.crm_knowledge_article,\n    crm_forecast: pipeline.crm_forecast,\n    crm_lead: pipeline.crm_lead,\n    crm_opportunity: pipeline.crm_opportunity,\n    crm_case: service.crm_case,\n    crm_contract: commerce.crm_contract,\n    crm_product: commerce.crm_product,\n    crm_quote: commerce.crm_quote,\n    crm_task: activity.crm_task,\n    crm_campaign: marketing.crm_campaign,\n    crm_event: activity.crm_event,\n    crm_event_attendee: activity.crm_event_attendee,\n    crm_article_feedback: service.crm_article_feedback,\n    crm_campaign_member: marketing.crm_campaign_member,\n    crm_opportunity_line_item: pipeline.crm_opportunity_line_item,\n    crm_quote_line_item: commerce.crm_quote_line_item,\n  },\n  ...appSurface,\n};\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/sales/translations/es-ES/app.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/sales/translations/es-ES\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/sales/translations/es-ES/app.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport type { TranslationData } from '@objectstack/spec/system';\n\nimport { QUOTE_DISCOUNT_CEILING } from '../../objects/_thresholds';\n\n/**\n * Espa\u00F1ol (es-ES) \u2014 every translation namespace EXCEPT `objects`:\n * `apps`, `messages`, `dashboards`, `datasets`, `pages`, `flows`.\n *\n * SPLIT AXIS (#1311): translation NAMESPACE first, then CRM DOMAIN FAMILY.\n * Everything that is not `objects` lives in `./app.ts`; `objects` \u2014 69-78% of\n * every bundle \u2014 is one file per CRM domain family, and a detail object\n * follows its master. A new row goes in the file for ITS family, never in\n * whichever file is already open: that is how one file re-grows past the 70%\n * advisory band `pnpm hygiene` prints. Full rule and rationale:\n * `src/sales/translations/es-ES.ts`.\n *\n * A namespace `TranslationData` gains later lands here too, and the room is\n * measured: this file is the smaller half of the bundle, and the schema bounds\n * how many namespaces can ever arrive.\n */\nexport const appSurface: Omit<TranslationData, 'objects'> = {\n  apps: {\n    crm_enterprise: {\n      label: 'HotCRM',\n      description: 'Gesti\u00F3n de relaciones con clientes para ventas, servicio y marketing',\n      // Indexado por el `id` del nodo de navegaci\u00F3n (espacio de nombres plano,\n      // sea cual sea la profundidad del nodo).\n      navigation: {\n        group_activity: { label: 'Actividad' },\n        nav_event: { label: 'Eventos' },\n        nav_activity_dashboard: { label: 'Actividad de Ventas' },\n        nav_my_calendar: { label: 'Mi Calendario' },\n        nav_home: { label: 'Inicio' },\n\n        group_sales: { label: 'Ventas' },\n        nav_lead: { label: 'Prospectos' },\n        nav_account: { label: 'Cuentas' },\n        nav_account_workbench: { label: 'Mesa de Trabajo de Cuentas' },\n        nav_contact: { label: 'Contactos' },\n        nav_opportunity: { label: 'Oportunidades' },\n        nav_quote: { label: 'Cotizaciones' },\n        nav_contract: { label: 'Contratos' },\n        nav_product: { label: 'Productos' },\n        nav_sales_dashboard: { label: 'Rendimiento de Ventas' },\n\n        group_work: { label: 'Mi Trabajo' },\n        nav_my_tasks: { label: 'Mis Tareas' },\n        nav_my_deals: { label: 'Mis Negocios' },\n        nav_my_leads: { label: 'Mis Prospectos' },\n        nav_my_cases: { label: 'Mis Casos' },\n        nav_approval_requests: { label: 'Bandeja de Entrada' },\n\n        group_service: { label: 'Servicio' },\n        nav_case: { label: 'Casos' },\n        nav_knowledge: { label: 'Conocimiento' },\n        nav_service_dashboard: { label: 'Resumen de Servicio' },\n\n        group_marketing: { label: 'Marketing' },\n        nav_campaign: { label: 'Campa\u00F1as' },\n\n        group_insights: { label: 'An\u00E1lisis' },\n        nav_crm_dashboard: { label: 'Resumen CRM' },\n        nav_forecast: { label: 'Previsiones' },\n        nav_report_pipeline_coverage: { label: 'Cobertura del Pipeline' },\n        nav_report_lead_inflow: { label: 'Entrada de Prospectos' },\n        nav_report_sla: { label: 'Cumplimiento de SLA' },\n      },\n    },\n  },\n  messages: {\n    'common.save': 'Guardar',\n    'common.cancel': 'Cancelar',\n    'common.delete': 'Eliminar',\n    'common.edit': 'Editar',\n    'common.create': 'Crear',\n    'common.search': 'Buscar',\n    'common.filter': 'Filtrar',\n    'common.export': 'Exportar',\n    'common.back': 'Volver',\n    'common.confirm': 'Confirmar',\n    'nav.sales': 'Ventas',\n    'nav.service': 'Servicio',\n    'nav.marketing': 'Marketing',\n    'nav.products': 'Productos',\n    'nav.analytics': 'Anal\u00EDtica',\n    'success.saved': 'Registro guardado exitosamente',\n    'success.converted': 'Prospecto convertido exitosamente',\n    'confirm.delete': '\u00BFEst\u00E1 seguro de que desea eliminar este registro?',\n    'confirm.convert_lead': '\u00BFConvertir este prospecto en cuenta, contacto y oportunidad?',\n    'error.required': 'Este campo es obligatorio',\n    'error.load_failed': 'Error al cargar los datos',\n  },\n  dashboards: {\n    sales_activity_dashboard: {\n      label: 'Actividad de ventas',\n      description: 'Qui\u00E9n habla con los clientes, con qu\u00E9 frecuencia y qu\u00E9 cuentas se han quedado en silencio',\n      widgets: {\n        interactions_held: { title: 'Interacciones registradas', description: 'Llamadas y reuniones que realmente ocurrieron' },\n        meetings_booked: { title: 'Reuniones agendadas', description: 'Reuniones en el calendario que a\u00FAn no ocurren' },\n        customer_minutes: { title: 'Minutos con clientes', description: 'Tiempo total frente a clientes' },\n        tasks_completed: { title: 'Tareas completadas', description: 'Seguimientos cerrados \u2014 la otra mitad de la actividad' },\n        activity_by_rep: { title: 'Actividad por representante', description: 'Interacciones registradas por responsable' },\n        activity_by_week: { title: 'Volumen de actividad por semana', description: 'Interacciones por semana' },\n        activity_mix: { title: 'Composici\u00F3n de la actividad', description: 'Llamadas vs reuniones vs demostraciones' },\n        activity_by_record_type: { title: 'D\u00F3nde cae la actividad', description: 'Qu\u00E9 parte del embudo recibe atenci\u00F3n' },\n        deal_activity: { title: 'Interacciones en oportunidades', description: 'Interacciones vinculadas a una oportunidad' },\n        open_deals_for_activity: { title: 'Oportunidades abiertas', description: 'Oportunidades a\u00FAn en juego' },\n        quiet_accounts_30: { title: 'Silencio 30+ d\u00EDas', description: 'Cuentas activas sin interacci\u00F3n en un mes' },\n        quiet_accounts_60: { title: 'Silencio 60+ d\u00EDas', description: 'Dos meses de silencio \u2014 el umbral de riesgo' },\n        quiet_accounts_90: { title: 'Silencio 90+ d\u00EDas', description: 'Un trimestre sin contacto' },\n      },\n    },\n    crm_overview_dashboard: {\n      label: 'Resumen CRM',\n      description: 'M\u00E9tricas de ingresos, anal\u00EDtica de pipeline e informaci\u00F3n de oportunidades',\n      widgets: {\n        total_revenue: { title: 'Ingresos totales', description: 'Ingresos cerrados ganados en este per\u00EDodo' },\n        active_deals: { title: 'Negocios activos', description: 'Oportunidades abiertas en el pipeline' },\n        won_deals: { title: 'Negocios ganados', description: 'Negocios cerrados ganados en este per\u00EDodo' },\n        avg_deal_size: { title: 'Tama\u00F1o medio del negocio', description: 'Valor medio de los negocios cerrados ganados' },\n        revenue_trends: { title: 'Tendencia de ingresos', description: 'Ingresos cerrados ganados de los \u00FAltimos 12 meses' },\n        lead_source: { title: 'Origen del prospecto', description: 'Valor del pipeline por canal de adquisici\u00F3n' },\n        pipeline_by_stage: { title: 'Pipeline por etapa', description: 'Valor de oportunidades abiertas en cada etapa de venta' },\n        top_products: { title: 'Productos principales', description: 'Ingresos a precio de lista por categor\u00EDa de producto' },\n        pipeline_by_owner: { title: 'Pipeline por responsable', description: 'Valor del pipeline abierto y n\u00FAmero de negocios por comercial' },\n      },\n    },\n    executive_dashboard: {\n      label: 'Vista ejecutiva',\n      description: 'KPI de alto nivel sobre ingresos, clientes y pipeline para la direcci\u00F3n',\n      widgets: {\n        total_revenue_ytd: { title: 'Ingresos totales (YTD)', description: 'Ingresos cerrados ganados en lo que va del a\u00F1o' },\n        total_accounts: { title: 'Cuentas activas', description: 'Clientes con al menos una relaci\u00F3n activa' },\n        total_contacts: { title: 'Total de contactos', description: 'Personas en nuestra agenda' },\n        open_leads: { title: 'Prospectos abiertos', description: 'Prospectos sin convertir en el embudo' },\n        revenue_trend: { title: 'Tendencia de ingresos', description: 'Ingresos cerrados ganados de los \u00FAltimos 12 meses' },\n        revenue_by_industry: { title: 'Ingresos por industria', description: 'Ingresos YTD ganados separados por industria del cliente' },\n        pipeline_by_stage: { title: 'Pipeline por etapa', description: 'Valor de oportunidades abiertas en cada etapa de venta' },\n        new_accounts_by_month: { title: 'Cuentas nuevas', description: 'Ritmo de creaci\u00F3n de cuentas en los \u00FAltimos 6 meses' },\n        accounts_by_industry: { title: 'Cuentas por sector', description: 'Ingreso anual total y n\u00FAmero de cuentas por sector' },\n      },\n    },\n    sales_dashboard: {\n      label: 'Rendimiento de ventas',\n      description: 'Anal\u00EDtica de pipeline, tendencias de tasa de \u00E9xito y rendimiento de los representantes',\n      widgets: {\n        total_pipeline_value: { title: 'Pipeline total', description: 'Suma del valor de las oportunidades abiertas' },\n        closed_won_qtd: { title: 'Cerrado ganado (trimestre)', description: 'Ingresos cerrados este trimestre' },\n        open_opportunities: { title: 'Oportunidades abiertas', description: 'Negocios activos en curso' },\n        avg_deal_size: { title: 'Tama\u00F1o medio del negocio', description: 'Valor medio de los negocios cerrados ganados este trimestre' },\n        pipeline_by_stage: { title: 'Pipeline por etapa', description: 'Valor de oportunidades abiertas en cada etapa de venta' },\n        monthly_revenue_trend: { title: 'Tendencia mensual de ingresos', description: 'Ingresos cerrados ganados de los \u00FAltimos 12 meses' },\n        pipeline_by_forecast_category: { title: 'Pipeline por categor\u00EDa de pron\u00F3stico', description: 'Pipeline abierto agrupado por categor\u00EDa de pron\u00F3stico de ventas' },\n        lead_source_breakdown: { title: 'Origen del prospecto', description: 'De d\u00F3nde proviene nuestro pipeline' },\n        open_pipeline_by_owner: { title: 'Pipeline abierto por responsable', description: 'Valor del pipeline en curso, n\u00FAmero de negocios y probabilidad media de cierre por comercial' },\n        quota_attainment_by_rep: { title: 'Cumplimiento de cuota por representante', description: 'Cuota del trimestre actual, ingresos cerrados y cumplimiento por representante, seg\u00FAn instant\u00E1neas de pron\u00F3stico' },\n        pipeline_stage_by_source: { title: 'Pipeline por Etapa \u00D7 Origen', description: 'Tabla cruzada del importe de oportunidades abiertas por etapa y origen' },\n        win_rate_12m: { title: 'Tasa de \u00E9xito (12M)', description: 'Negocios ganados como porcentaje de todos los negocios resueltos en los \u00FAltimos 12 meses' },\n        won_deals_12m: { title: 'Negocios ganados (12M)', description: 'El numerador de la tasa de \u00E9xito' },\n        lost_deals_12m: { title: 'Negocios perdidos (12M)', description: 'La otra mitad del denominador de la tasa de \u00E9xito' },\n        win_rate_by_owner: { title: 'Ganados / perdidos por representante', description: 'Negocios ganados, negocios perdidos y tasa de \u00E9xito por representante \u2014 \u00FAltimos 12 meses' },\n        win_rate_by_lead_source: { title: 'Ganados / perdidos por origen del prospecto', description: 'Qu\u00E9 or\u00EDgenes producen negocios que realmente se cierran \u2014 \u00FAltimos 12 meses' },\n        loss_reason_breakdown: { title: 'Por qu\u00E9 perdemos', description: 'Negocios perdidos por motivo \u2014 \u00FAltimos 12 meses' },\n      },\n    },\n    service_dashboard: {\n      label: 'Servicio al cliente',\n      description: 'Carga de casos, salud del SLA y rendimiento de resoluci\u00F3n',\n      widgets: {\n        open_cases: { title: 'Casos abiertos', description: 'Casos que a\u00FAn no se han cerrado' },\n        critical_cases: { title: 'Casos cr\u00EDticos', description: 'Casos abiertos marcados como prioridad cr\u00EDtica' },\n        avg_resolution_time: { title: 'Tiempo medio de resoluci\u00F3n', description: 'Tiempo medio hasta el cierre, en horas' },\n        sla_violations: { title: 'Incumplimientos de SLA', description: 'Casos que incumplieron su SLA' },\n        cases_by_status: { title: 'Casos por estado', description: 'Distribuci\u00F3n de la carga a lo largo del pipeline' },\n        cases_by_priority: { title: 'Casos por prioridad', description: 'Mezcla de casos abiertos por urgencia' },\n        cases_by_origin: { title: 'Casos por origen', description: 'De d\u00F3nde provienen nuestros casos' },\n        daily_case_volume: { title: 'Volumen diario de casos', description: 'Casos nuevos creados en los \u00FAltimos 30 d\u00EDas' },\n        sla_compliance_gauge: { title: 'Cumplimiento de SLA', description: 'Porcentaje de casos resueltos dentro del SLA en este per\u00EDodo' },\n        kb_deflection_rate: { title: 'Tasa de Desv\u00EDo por KB', description: 'Proporci\u00F3n de casos cerrados resueltos con un art\u00EDculo de la base de conocimiento' },\n        kb_resolved_cases: { title: 'Resueltos por KB', description: 'Casos cerrados que se\u00F1alan el art\u00EDculo que los resolvi\u00F3' },\n        closed_cases_total: { title: 'Casos Cerrados', description: 'El denominador de la tasa de desv\u00EDo' },\n        top_resolving_articles: { title: 'Art\u00EDculos que M\u00E1s Resuelven', description: 'Art\u00EDculos de la base de conocimiento ordenados por los casos cerrados que resolvieron' },\n        my_open_cases_by_priority: { title: 'Mis casos abiertos por prioridad', description: 'Tus casos abiertos y su tasa de incumplimiento de SLA, desglosados por prioridad' },\n      },\n    },\n  },\n  // `title` / `subtitle` son las propiedades del componente `page:header`.\n  // Los marcadores `{\u2026}` se sustituyen sobre la cadena TRADUCIDA, as\u00ED que el\n  // token debe conservarse tal cual: traducido, no resuelve y se ve vac\u00EDo.\n  datasets: {\n    account_metrics: {\n      label: 'M\u00E9tricas de cuentas',\n      description: 'Capa sem\u00E1ntica para el recuento de cuentas por sector y tipo',\n      dimensions: {\n        industry: {\n          label: 'Sector',\n        },\n        type: {\n          label: 'Tipo',\n        },\n        created_at: {\n          label: 'Creado',\n        },\n      },\n      measures: {\n        account_count: {\n          label: 'Cuentas',\n        },\n        annual_revenue_sum: {\n          label: 'Ingresos anuales',\n        },\n      },\n    },\n    case_metrics: {\n      label: 'M\u00E9tricas de casos',\n      description: 'Capa sem\u00E1ntica para el recuento de casos, el tiempo de resoluci\u00F3n y el SLA',\n      dimensions: {\n        created_at: {\n          label: 'Creado',\n        },\n        origin: {\n          label: 'Origen',\n        },\n        priority: {\n          label: 'Prioridad',\n        },\n        resolved_article: {\n          label: 'Art\u00EDculo de resoluci\u00F3n',\n        },\n        status: {\n          label: 'Estado',\n        },\n        type: {\n          label: 'Tipo',\n        },\n      },\n      measures: {\n        avg_resolution: {\n          label: 'Resoluci\u00F3n media (h)',\n        },\n        avg_sla_violated: {\n          label: 'Tasa de incumplimiento del SLA',\n        },\n        case_count: {\n          label: 'Casos',\n        },\n        closed_count: {\n          label: 'Casos cerrados',\n        },\n        kb_deflection_rate: {\n          label: 'Tasa de desv\u00EDo por base de conocimiento',\n        },\n        kb_resolved_count: {\n          label: 'Resueltos por base de conocimiento',\n        },\n        sla_compliance_rate: {\n          label: 'Tasa de cumplimiento del SLA',\n        },\n        sla_met_count: {\n          label: 'Casos dentro del SLA',\n        },\n      },\n    },\n    contact_metrics: {\n      label: 'M\u00E9tricas de contactos',\n      description: 'Capa sem\u00E1ntica para el recuento de contactos',\n      measures: {\n        contact_count: {\n          label: 'Contactos',\n        },\n      },\n    },\n    event_metrics: {\n      label: 'M\u00E9tricas de actividad',\n      description: 'Capa sem\u00E1ntica para reuniones, llamadas y recencia de interacci\u00F3n',\n      dimensions: {\n        owner: {\n          label: 'Propietario',\n        },\n        related_to_type: {\n          label: 'Relacionado con',\n        },\n        start_datetime: {\n          label: 'Semana de actividad',\n        },\n        status: {\n          label: 'Estado',\n        },\n        type: {\n          label: 'Tipo de actividad',\n        },\n      },\n      measures: {\n        avg_minutes: {\n          label: 'Duraci\u00F3n media',\n        },\n        event_count: {\n          label: 'Actividades',\n        },\n        total_minutes: {\n          label: 'Minutos',\n        },\n      },\n    },\n    forecast_metrics: {\n      label: 'M\u00E9tricas de previsi\u00F3n',\n      description: 'Capa sem\u00E1ntica para cuota, cumplimiento y cobertura de pipeline por propietario',\n      dimensions: {\n        owner: {\n          label: 'Propietario',\n        },\n        period: {\n          label: 'Tipo de periodo',\n        },\n        period_label: {\n          label: 'Periodo',\n        },\n        period_start: {\n          label: 'Inicio del periodo',\n        },\n      },\n      measures: {\n        attainment: {\n          label: 'Cumplimiento',\n        },\n        closed_sum: {\n          label: 'Cerrado',\n        },\n        commit_sum: {\n          label: 'Comprometido',\n        },\n        pipeline_sum: {\n          label: 'Pipeline',\n        },\n        quota_sum: {\n          label: 'Cuota',\n        },\n      },\n    },\n    lead_metrics: {\n      label: 'M\u00E9tricas de prospectos',\n      description: 'Capa sem\u00E1ntica para el recuento de prospectos',\n      dimensions: {\n        created_at: {\n          label: 'Creado',\n        },\n        last_contacted_date: {\n          label: '\u00DAltimo contacto',\n        },\n        lead_source: {\n          label: 'Origen',\n        },\n        status: {\n          label: 'Estado',\n        },\n      },\n      measures: {\n        lead_count: {\n          label: 'Prospectos',\n        },\n      },\n    },\n    opportunity_metrics: {\n      label: 'M\u00E9tricas de oportunidades',\n      description: 'Capa sem\u00E1ntica para el recuento y los importes del pipeline de ventas',\n      dimensions: {\n        account_industry: {\n          label: 'Sector de la cuenta',\n        },\n        close_date: {\n          label: 'Fecha de cierre',\n        },\n        close_quarter: {\n          label: 'Trimestre de cierre',\n        },\n        forecast_category: {\n          label: 'Categor\u00EDa de previsi\u00F3n',\n        },\n        lead_source: {\n          label: 'Origen del prospecto',\n        },\n        loss_reason: {\n          label: 'Motivo de p\u00E9rdida',\n        },\n        owner: {\n          label: 'Propietario',\n        },\n        stage: {\n          label: 'Etapa',\n        },\n        type: {\n          label: 'Tipo de negocio',\n        },\n        win_reason: {\n          label: 'Motivo de ganancia',\n        },\n      },\n      measures: {\n        avg_amount: {\n          label: 'Tama\u00F1o medio del negocio',\n        },\n        avg_probability: {\n          label: 'Probabilidad media',\n        },\n        decided_count: {\n          label: 'Negocios resueltos',\n        },\n        lost_amount: {\n          label: 'Ingresos perdidos',\n        },\n        lost_count: {\n          label: 'Negocios perdidos',\n        },\n        opp_count: {\n          label: 'Oportunidades',\n        },\n        total_amount: {\n          label: 'Importe total',\n        },\n        win_rate: {\n          label: 'Tasa de ganancia',\n        },\n        won_amount: {\n          label: 'Ingresos ganados',\n        },\n        won_count: {\n          label: 'Negocios ganados',\n        },\n      },\n    },\n    product_metrics: {\n      label: 'M\u00E9tricas de productos',\n      description: 'Capa sem\u00E1ntica para el recuento del cat\u00E1logo y el precio de lista',\n      dimensions: {\n        category: {\n          label: 'Categor\u00EDa',\n        },\n      },\n      measures: {\n        list_price_sum: {\n          label: 'Precio de lista total',\n        },\n        product_count: {\n          label: 'Productos',\n        },\n      },\n    },\n    task_metrics: {\n      label: 'M\u00E9tricas de tareas',\n      description: 'Capa sem\u00E1ntica para la carga de trabajo y la finalizaci\u00F3n de tareas',\n      dimensions: {\n        due_date: {\n          label: 'Fecha de vencimiento',\n        },\n        is_completed: {\n          label: 'Completada',\n        },\n        is_overdue: {\n          label: 'Vencida',\n        },\n        priority: {\n          label: 'Prioridad',\n        },\n        priority_rank: {\n          label: 'Urgencia',\n        },\n        status: {\n          label: 'Estado',\n        },\n        type: {\n          label: 'Tipo',\n        },\n      },\n      measures: {\n        avg_progress: {\n          label: 'Progreso medio',\n        },\n        task_count: {\n          label: 'Tareas',\n        },\n      },\n    },\n  },\n  pages: {\n    account_detail_page: {\n      label: 'Detalle de Cuenta',\n      description: 'P\u00E1gina de registro de cuenta por slots: cabecera personalizada + feed de discusi\u00F3n permanente.',\n      title: '{name}',\n      subtitle: '{industry} \u00B7 {type}',\n      components: {\n        account_chatter: { label: 'Discusi\u00F3n' },\n      },\n    },\n    account_workbench: {\n      label: 'Mesa de Trabajo de Cuentas',\n      description: 'Lista de cuentas curada para el equipo comercial: solo filtros r\u00E1pidos, sin gesti\u00F3n de vistas.',\n    },\n    app_launcher_page: {\n      label: 'Lanzador de Aplicaciones',\n      description: 'Punto de acceso central a todas las aplicaciones',\n      subtitle: 'Seleccione una aplicaci\u00F3n para empezar',\n      components: {\n        app_search: { label: 'Buscar Aplicaciones' },\n        app_grid: { label: 'Cuadr\u00EDcula de Aplicaciones' },\n      },\n    },\n    case_detail_page: {\n      label: 'Detalle de Caso',\n      description: 'P\u00E1gina de caso para el agente de servicio: datos destacados, progreso del SLA, detalles y cronolog\u00EDa de actividad.',\n      title: '{case_number} \u00B7 {subject}',\n      subtitle: '{crm_account}',\n      components: {\n        case_highlights: { label: 'Informaci\u00F3n Clave' },\n        case_status_path: { label: 'Progreso del Estado del Caso' },\n        case_details: { label: 'Detalles del Caso' },\n      },\n    },\n    lead_detail_page: {\n      label: 'Detalle de Prospecto',\n      description: 'P\u00E1gina completa de detalle del prospecto, con datos destacados, detalles e informaci\u00F3n relacionada',\n      title: '{first_name} {last_name}',\n      subtitle: '{company}',\n      components: {\n        lead_duplicate_alert_confirmed: { label: 'Aviso de duplicado confirmado' },\n        lead_duplicate_alert_suspected: { label: 'Aviso de duplicado sospechoso' },\n        lead_highlights: { label: 'Informaci\u00F3n Clave' },\n        lead_path: { label: 'Progreso del Estado del Prospecto' },\n        main_tabs: { label: 'Pesta\u00F1as de Informaci\u00F3n del Prospecto' },\n        lead_details: { label: 'Detalles del Prospecto' },\n        related_accordion: { label: 'Registros Relacionados' },\n        related_tasks: { title: 'Tareas Abiertas', label: 'Tareas' },\n        lead_activity: { label: 'Cronolog\u00EDa de Actividad' },\n        lead_history: { label: 'Historial de Campos' },\n      },\n    },\n    opportunity_detail_page: {\n      label: 'Detalle de Oportunidad',\n      description: 'P\u00E1gina completa de detalle de la oportunidad, con recorrido de etapas, datos destacados, detalles y listas relacionadas',\n      title: '{name}',\n      subtitle: '{crm_account}',\n      components: {\n        opp_highlights: { label: 'Informaci\u00F3n Clave' },\n        opp_stage_path: { label: 'Progreso de Etapa de la Oportunidad' },\n        opp_details: { label: 'Detalles de la Oportunidad' },\n      },\n    },\n    sales_home_page: {\n      label: 'Inicio de Ventas',\n      description: 'P\u00E1gina de inicio del equipo comercial con m\u00E9tricas clave y acciones r\u00E1pidas',\n      title: 'Panel de Ventas',\n      subtitle: 'Bienvenido de nuevo',\n      components: {\n        kpi_revenue_won: {\n          label: 'Ingresos (ganados)',\n        },\n        kpi_deals_won: {\n          label: 'Negocios ganados',\n        },\n        kpi_pipeline_value: {\n          label: 'Valor del pipeline',\n        },\n        kpi_open_leads: {\n          label: 'Prospectos abiertos',\n        },\n        home_upcoming_events: {\n          label: '\uD83D\uDCC5 Pr\u00F3ximos \u00B7 M\u00E1s cercanos primero',\n        },\n        quick_create: { title: 'Creaci\u00F3n R\u00E1pida', label: 'Creaci\u00F3n R\u00E1pida' },\n        key_metrics: { title: 'Indicadores Clave de Rendimiento', label: 'M\u00E9tricas Clave' },\n        home_tabs: { label: 'Pesta\u00F1as de Inicio' },\n        home_my_leads: { label: 'Mis Prospectos' },\n        home_my_deals: { label: 'Mis Negocios Abiertos' },\n        home_my_tasks: { label: 'Mis Tareas Abiertas' },\n        ai_briefing: {\n          title: 'Preg\u00FAntale al Asistente de IA',\n          label: 'Hoy con el Asistente de IA',\n        },\n        upcoming_events: { title: 'Pr\u00F3ximos Eventos', label: 'Pr\u00F3ximos Eventos' },\n      },\n    },\n    utility_bar_page: {\n      label: 'Barra de Utilidades',\n      description: 'Barra de acceso r\u00E1pido con herramientas flotantes',\n      components: {\n        notifications_panel: { label: 'Notificaciones' },\n        quick_notes: { title: 'Notas R\u00E1pidas', label: 'Notas R\u00E1pidas' },\n        quick_search: { label: 'B\u00FAsqueda R\u00E1pida' },\n      },\n    },\n  },\n  // Screen-flow copy (#1210, #1975). Keyed `flows.<flow>.label`,\n  // `screens.<node>.title` and `screens.<node>.fields.<field>.{label,placeholder}`\n  // \u2014 the keys `os lint`'s `i18n/missing-flow` names, read by the console's\n  // flow runner since @objectstack 17.7.0 (the spec's `flows` liveness row is\n  // `live` there). A screen with no authored `title` shows its flow's label in\n  // every locale, so each `screen_1.title` repeats the flow label. Since\n  // 18.0.0-next.0 three more surfaces are keys the engine reads in the run's\n  // locale, and `i18n/missing-flow` names each missing one: a select field's\n  // `options.<value>` (worded as the object field's own option in this pack),\n  // an authored screen `description`, and a refusing `end` node's\n  // `refusals.<node>.message`. A translated description or message is a text\n  // slot like the one it translates, so a hole in it is `{{ }}`.\n  // The discount ceiling is interpolated from `QUOTE_DISCOUNT_CEILING`, never\n  // retyped: the number lives in `_thresholds.ts` alone (#1711).\n  flows: {\n    campaign_enrollment: {\n      label: 'Inscribir miembros en la campa\u00F1a',\n      screens: {\n        screen_1: {\n          title: 'Inscribir miembros en la campa\u00F1a',\n          fields: {\n            memberSource: { label: 'Tipo de miembro a inscribir', options: { leads: 'Prospectos', contacts: 'Contactos' } },\n            leadStatus: { label: 'Inscribir prospectos con estado', options: { new: 'Nuevo', contacted: 'Contactado', qualified: 'Calificado' } },\n            contactDepartment: {\n              label: 'Inscribir contactos del departamento',\n              options: { executive: 'Ejecutivo', sales: 'Ventas', marketing: 'Marketing', engineering: 'Ingenier\u00EDa', support: 'Soporte', finance: 'Finanzas', hr: 'Recursos Humanos', operations: 'Operaciones' },\n            },\n          },\n        },\n      },\n    },\n    escalate_case: {\n      label: 'Escalar Caso',\n      screens: { screen_1: { title: 'Escalar Caso', fields: { reason: { label: 'Motivo de Escalaci\u00F3n' } } } },\n    },\n    close_case: {\n      label: 'Cerrar Caso',\n      screens: {\n        screen_1: {\n          title: 'Cerrar Caso',\n          fields: {\n            resolution: { label: 'Resoluci\u00F3n' },\n            resolved_by_article: { label: 'Resuelto con art\u00EDculo (opcional)' },\n          },\n        },\n      },\n    },\n    claim_case: {\n      label: 'Tomar Caso',\n      screens: {\n        screen_1: {\n          title: 'Tomar Caso',\n          fields: {\n            claimStatus: {\n              label: 'Estado de trabajo',\n              options: { in_progress: 'En Curso', waiting_customer: 'Esperando al Cliente', waiting_support: 'Esperando a Soporte' },\n            },\n          },\n        },\n      },\n    },\n    lead_conversion: {\n      label: 'Proceso de conversi\u00F3n de prospecto',\n      screens: {\n        screen_1: {\n          title: 'Proceso de conversi\u00F3n de prospecto',\n          // The duplicate warning's text is a variable the flow assigns; this\n          // key can only carry the hole that shows it.\n          description: '{{duplicateWarning}}',\n          fields: {\n            createOpportunity: { label: '\u00BFCrear oportunidad?' },\n            opportunityName: { label: 'Nombre de Oportunidad' },\n            opportunityAmount: { label: 'Monto de la Oportunidad' },\n            closeDate: { label: 'Fecha de Cierre' },\n          },\n        },\n        refuse_confirmed_duplicate: {\n          title: 'Conversi\u00F3n rechazada',\n          description:\n            'El Estado del Duplicado de este prospecto es Confirmado: un revisor lo compar\u00F3 con un registro existente y registr\u00F3 que lo repite. Convertirlo crear\u00EDa una segunda cuenta, contacto y oportunidad para el mismo comprador. La secci\u00F3n Gesti\u00F3n de Duplicados de este prospecto indica el registro que se conserva; descalifique este prospecto como duplicado. Solo un revisor que cambie ese veredicto vuelve a habilitar la conversi\u00F3n.',\n        },\n        refuse_unapproved: {\n          title: 'Conversi\u00F3n rechazada',\n          description:\n            'Este prospecto no ha sido aprobado para la conversi\u00F3n. Un aprobador debe darle el visto bueno antes de que pueda convertirse en una cuenta, un contacto y una oportunidad; el campo Aprobaci\u00F3n de Conversi\u00F3n del prospecto muestra si la decisi\u00F3n sigue pendiente o fue rechazada. Mientras tanto, siga trabajando el prospecto: nada de \u00E9l queda bloqueado.',\n        },\n        refuse_no_match_key: {\n          title: 'Conversi\u00F3n rechazada',\n          description:\n            'La empresa de este prospecto no tiene clave de coincidencia, as\u00ED que la conversi\u00F3n no puede saber a qu\u00E9 cuenta pertenece y no lo va a adivinar: una suposici\u00F3n podr\u00EDa archivar el contacto y la oportunidad bajo otro cliente. Guardar la Empresa del prospecto reconstruye la clave, as\u00ED que gu\u00E1rdela de nuevo y luego convi\u00E9rtalo. No se ha creado nada.',\n        },\n      },\n    },\n    schedule_followup: {\n      label: 'Programar Seguimiento',\n      screens: {\n        screen_1: {\n          title: 'Programar Seguimiento',\n          fields: {\n            subject: { label: '\u00BFCu\u00E1l es el siguiente paso?' },\n            dueDate: { label: 'Fecha L\u00EDmite' },\n            activityType: {\n              label: 'Tipo de Actividad',\n              options: { call: 'Llamada', email: 'Email', meeting: 'Reuni\u00F3n', follow_up: 'Seguimiento', demo: 'Demostraci\u00F3n', other: 'Otro' },\n            },\n            priority: { label: 'Prioridad', options: { low: 'Baja', normal: 'Normal', high: 'Alta', urgent: 'Urgente' } },\n            notes: { label: 'Notas' },\n          },\n        },\n      },\n    },\n    quote_generation: {\n      label: 'Generar cotizaci\u00F3n desde la oportunidad',\n      refusals: { refuse_held: { message: 'Primero va la aprobaci\u00F3n de calificaci\u00F3n: marque Solicitar Aprobaci\u00F3n de Calificaci\u00F3n. No se cre\u00F3 nada.' } },\n      screens: {\n        screen_1: {\n          title: 'Generar cotizaci\u00F3n desde la oportunidad',\n          fields: {\n            quoteName: { label: 'Nombre de Cotizaci\u00F3n' },\n            expirationDays: { label: 'V\u00E1lida por (d\u00EDas)' },\n            discount: { label: `Descuento % (\u2264 ${QUOTE_DISCOUNT_CEILING})`, placeholder: `0-${QUOTE_DISCOUNT_CEILING}` },\n          },\n        },\n      },\n    },\n  },\n};\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/sales/translations/es-ES/_shared.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/sales/translations/es-ES\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/sales/translations/es-ES/_shared.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\n/**\n * Espa\u00F1ol (es-ES) \u2014 values shared by more than one part of this bundle.\n *\n * SPLIT AXIS (#1311): translation NAMESPACE first, then CRM DOMAIN FAMILY.\n * Everything that is not `objects` lives in `./app.ts`; `objects` \u2014 69-78% of\n * every bundle \u2014 is one file per CRM domain family, and a detail object\n * follows its master. A new row goes in the file for ITS family, never in\n * whichever file is already open: that is how one file re-grows past the 70%\n * advisory band `pnpm hygiene` prints. Full rule and rationale:\n * `src/sales/translations/es-ES.ts`.\n *\n * Every constant here is spread into object rows that live in MORE THAN ONE\n * family file, so it cannot sit in any one of them. A value used by exactly\n * one family lives in that family's file instead \u2014 that split is mechanical,\n * not a judgement call.\n */\n\n/**\n * Familia de acciones de actividad (#592): `log_call`, `log_meeting` y\n * `schedule_meeting` se registran una vez POR OBJETO (prospecto, contacto,\n * cuenta, oportunidad, caso), porque una acci\u00F3n de script sin `objectName`\n * queda bajo una clave que el despachador nunca consulta (#509). Los textos son\n * id\u00E9nticos en los cinco, as\u00ED que se declaran una vez aqu\u00ED.\n */\nexport const activityActions = {\n  log_call: {\n    label: 'Registrar llamada',\n    successMessage: '\u00A1Llamada registrada exitosamente!',\n    params: {\n      subject: { label: 'Asunto de la llamada' },\n      duration: { label: 'Duraci\u00F3n (minutos)' },\n      attendee_contacts: { label: 'Contactos participantes' },\n      attendee_users: { label: 'Participantes internos' },\n      notes: { label: 'Notas de la llamada' },\n    },\n  },\n  log_meeting: {\n    label: 'Registrar reuni\u00F3n',\n    successMessage: '\u00A1Reuni\u00F3n registrada exitosamente!',\n    params: {\n      subject: { label: 'Asunto de la reuni\u00F3n' },\n      duration: { label: 'Duraci\u00F3n (minutos)' },\n      attendee_contacts: { label: 'Contactos participantes' },\n      attendee_users: { label: 'Participantes internos' },\n      notes: { label: 'Notas de la reuni\u00F3n' },\n    },\n  },\n  schedule_meeting: {\n    label: 'Programar reuni\u00F3n',\n    successMessage: '\u00A1Reuni\u00F3n programada!',\n    params: {\n      subject: { label: 'Asunto de la reuni\u00F3n' },\n      start_date: { label: 'Fecha de inicio (UTC)' },\n      start_time: { label: 'Hora de inicio (UTC)' },\n      location: { label: 'Ubicaci\u00F3n' },\n      duration: { label: 'Duraci\u00F3n (minutos)' },\n      attendee_contacts: { label: 'Contactos participantes' },\n      attendee_users: { label: 'Participantes internos' },\n      notes: { label: 'Agenda' },\n    },\n  },\n};\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/sales/translations/es-ES/objects.customer.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/sales/translations/es-ES\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/sales/translations/es-ES/objects.customer.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport type { ObjectTranslationData } from '@objectstack/spec/system';\n\nimport { activityActions } from './_shared';\n\n/**\n * Espa\u00F1ol (es-ES) \u2014 `objects` translations for the CUSTOMER family:\n * the customer record itself \u2014 accounts and the people at them.\n *\n * Roster: `crm_account`, `crm_contact`.\n *\n * SPLIT AXIS (#1311): translation NAMESPACE first, then CRM DOMAIN FAMILY.\n * Everything that is not `objects` lives in `./app.ts`; `objects` \u2014 69-78% of\n * every bundle \u2014 is one file per CRM domain family, and a detail object\n * follows its master. A new row goes in the file for ITS family, never in\n * whichever file is already open: that is how one file re-grows past the 70%\n * advisory band `pnpm hygiene` prints. Full rule and rationale:\n * `src/sales/translations/es-ES.ts`.\n */\nexport const customer: Record<string, ObjectTranslationData> = {\n  crm_account: {\n    label: 'Cuenta',\n    pluralLabel: 'Cuentas',\n    description: 'Empresas y organizaciones con las que mantenemos relaci\u00F3n comercial',\n    fields: {\n      account_number: { label: 'N\u00FAmero de Cuenta' },\n      registration_number: {\n        label: 'N\u00FAmero de Registro',\n        help: 'La identidad registrada de la contraparte, emitida por su propio registro gubernamental. No es el N\u00FAmero de Cuenta, que emitimos nosotros.',\n      },\n      commercial_capability: {\n        label: 'Capacidad Comercial',\n        help: 'Si se puede abrir nuevo negocio con esta cuenta. Las cuentas de Solo Liquidaci\u00F3n siguen siendo utilizables para facturaci\u00F3n y pagos, pero no se les puede vincular ninguna oportunidad nueva.',\n        options: { full: 'Completa', settlement_only: 'Solo Liquidaci\u00F3n' },\n      },\n      incumbent_vendor: { label: 'Proveedor Actual', help: 'El proveedor que actualmente atiende el gasto que perseguimos en esta cuenta.' },\n      annual_purchasing_budget: { label: 'Presupuesto Anual de Compras', help: 'Lo que esta cuenta espera gastar con proveedores este a\u00F1o, no sus propios ingresos.' },\n      payment_cycle: {\n        label: 'Ciclo de Pago',\n        options: { prepaid: 'Prepago', net_30: '30 d\u00EDas', net_60: '60 d\u00EDas', net_90: '90 d\u00EDas' },\n      },\n      approval_status: {\n        label: 'Estado de Aprobaci\u00F3n',\n        help: 'En qu\u00E9 punto de su aprobaci\u00F3n est\u00E1 esta cuenta. Una cuenta nueva comienza Pendiente y se decide en la bandeja de aprobaciones.',\n        options: { pending: 'Pendiente', approved: 'Aprobada', rejected: 'Rechazada' },\n      },\n      name: { label: 'Nombre de Cuenta', help: 'Nombre legal de la empresa u organizaci\u00F3n' },\n      name_normalized: {\n        label: 'Nombre de Cuenta (Normalizado)',\n        help: 'Clave de coincidencia para la conversi\u00F3n de prospectos: el Nombre de Cuenta en min\u00FAsculas, sin espacios sobrantes y con los espacios internos reducidos a uno. Lo mantiene el hook account_protection \u2014 nunca lo edite directamente.',\n      },\n      display_title: { label: 'T\u00EDtulo Mostrado' },\n      type: {\n        label: 'Tipo',\n        // `former` is 'Former Customer' in account.object.ts; the `en` bundle\n        // had truncated it to 'Former', and translating that truncation gave\n        // a bare 'Anterior' \u2014 an adjective with no noun, next to three option\n        // labels that are all nouns.\n        options: { prospect: 'Prospecto', customer: 'Cliente', partner: 'Socio', former: 'Cliente Anterior' },\n      },\n      industry: {\n        label: 'Industria',\n        options: {\n          technology: 'Tecnolog\u00EDa', software: 'Software / SaaS', finance: 'Finanzas',\n          healthcare: 'Salud', retail: 'Comercio', manufacturing: 'Manufactura',\n          education: 'Educaci\u00F3n', real_estate: 'Inmobiliaria', media: 'Medios y Entretenimiento',\n          logistics: 'Log\u00EDstica', hospitality: 'Hosteler\u00EDa', energy: 'Energ\u00EDa y Servicios P\u00FAblicos',\n          government: 'Gobierno', nonprofit: 'Sin \u00C1nimo de Lucro', other: 'Otro',\n        },\n      },\n      annual_revenue: { label: 'Ingresos Anuales' },\n      child_account_revenue: { label: 'Ingresos de Cuentas Hijas', help: 'Suma de los ingresos anuales de las cuentas hijas directas.' },\n      number_of_employees: { label: 'N\u00FAmero de Empleados' },\n      phone: { label: 'Tel\u00E9fono' },\n      website: { label: 'Sitio Web' },\n      billing_address: { label: 'Direcci\u00F3n de Facturaci\u00F3n' },\n      billing_country: {\n        label: 'Pa\u00EDs de Facturaci\u00F3n',\n        help: 'Derivado de la Direcci\u00F3n de Facturaci\u00F3n \u2014 el pa\u00EDs tal como se introdujo, sin espacios y en may\u00FAsculas.',\n      },\n      territory: {\n        label: 'Territorio',\n        help: 'Derivado de la Direcci\u00F3n de Facturaci\u00F3n \u2014 el territorio de ventas que usan las reglas de compartici\u00F3n. Las cuentas fuera de los territorios con equipo asignado son Otro.',\n        options: { na: 'Norteam\u00E9rica', emea: 'EMEA', other: 'Otro' },\n      },\n      office_location: { label: 'Ubicaci\u00F3n de Oficina' },\n      owner_id: { label: 'Propietario de Cuenta' },\n      parent_account: { label: 'Cuenta Matriz', help: 'Empresa matriz en la jerarqu\u00EDa' },\n      description: { label: 'Descripci\u00F3n' },\n      is_active: { label: 'Activo' },\n      last_activity_date: { label: 'Fecha de \u00DAltima Actividad' },\n      brand_color: { label: 'Color de Marca' },\n      logo: { label: 'Logo de la Empresa' },\n      tier: {\n        label: 'Nivel de Cliente',\n        options: {\n          strategic: 'Estrat\u00E9gico', enterprise: 'Gran Empresa',\n          mid_market: 'Mediana Empresa', smb: 'PYME',\n        },\n      },\n      segment: {\n        label: 'Segmento',\n        options: {\n          net_new: 'Cliente Nuevo', growth: 'Crecimiento',\n          at_risk: 'En Riesgo', stable: 'Estable',\n        },\n      },\n      health_score: {\n        label: '\u00CDndice de Salud',\n        help: 'Indicador de salud mantenido por el CSM',\n        options: {\n          healthy: 'Saludable', watching: 'En Observaci\u00F3n',\n          at_risk: 'En Riesgo', churning: 'En Fuga',\n        },\n      },\n    },\n    _views: {\n      all_accounts: {\n        label: 'Todas las Cuentas', description: 'Lista maestra de cuentas con ingresos e industria',\n        bulkActions: {\n          delete: {\n            label: 'Eliminar',\n            confirmLabel: 'Eliminar',\n            confirmText: '\u00BFEliminar permanentemente {{count}} cuenta(s)? Esta acci\u00F3n no se puede deshacer.',\n          },\n          transfer_owner: {\n            label: 'Transferir propietario',\n            confirmText: '\u00BFTransferir la propiedad de {{count}} cuenta(s)?',\n            params: {\n              owner_id: {\n                label: 'Nuevo propietario',\n              },\n            },\n          },\n          update_tier: {\n            label: 'Actualizar nivel',\n            confirmText: '\u00BFActualizar el nivel de {{count}} cuenta(s) a {{tier}}?',\n            params: {\n              tier: {\n                label: 'Nivel de cliente',\n              },\n            },\n          },\n        },\n      },\n      account_gallery: { label: 'Galer\u00EDa de Cuentas', description: 'Vista de tarjetas con colores de marca' },\n      account_map: { label: 'Mapa de Cuentas', description: 'Distribuci\u00F3n geogr\u00E1fica de cuentas' },\n      enterprise_accounts: { label: 'Cuentas Empresariales', description: 'Cuentas con mayores ingresos anuales' },\n      my_accounts: { label: 'Mis Cuentas', description: 'Cuentas asignadas al usuario actual' },\n      at_risk_accounts: { label: '\u26A0\uFE0F Cuentas en Riesgo' },\n    },\n    _sections: {\n      basic: { label: 'Informaci\u00F3n B\u00E1sica' },\n      financials: { label: 'Datos Financieros' },\n      business_profile: { label: 'Perfil de Negocio' },\n      contact_info: { label: 'Informaci\u00F3n de Contacto' },\n      ownership: { label: 'Propiedad y Estado' },\n      branding: { label: 'Identidad de Marca' },\n      system: { label: 'Sistema' },\n      // Nombres de secci\u00F3n del formulario en account.view.ts (#1100)\n      profile: { label: 'Perfil' },\n      customer_success: { label: '\u00C9xito del Cliente' },\n      locations: { label: 'Ubicaciones' },\n      description: { label: 'Descripci\u00F3n' },\n    },\n    _actions: { ...activityActions },\n  },\n  crm_contact: {\n    label: 'Contacto',\n    pluralLabel: 'Contactos',\n    description: 'Personas asociadas a las cuentas',\n    fields: {\n      // Mismo juego de valores que `crm_lead.salutation` \u2014 trad\u00FAzcanse igual.\n      salutation: {\n        label: 'T\u00EDtulo',\n        options: { mr: 'Sr.', ms: 'Srta.', mrs: 'Sra.', dr: 'Dr.', prof: 'Prof.' },\n      },\n      first_name: { label: 'Nombre' },\n      last_name: { label: 'Apellido' },\n      full_name: { label: 'Nombre Completo' },\n      crm_account: { label: 'Cuenta' },\n      email: { label: 'Correo Electr\u00F3nico' },\n      phone: { label: 'Tel\u00E9fono' },\n      mobile: { label: 'M\u00F3vil' },\n      title: { label: 'Cargo' },\n      department: {\n        label: 'Departamento',\n        options: {\n          executive: 'Ejecutivo', sales: 'Ventas', marketing: 'Marketing',\n          engineering: 'Ingenier\u00EDa', support: 'Soporte', finance: 'Finanzas',\n          hr: 'Recursos Humanos', operations: 'Operaciones',\n        },\n      },\n      // Centro de compra (REQ-0004) \u2014 el mapa de la decisi\u00F3n. La etiqueta\n      // inglesa es 'Buying Function' y no 'Buying Role': la regla\n      // security-role-word reserva la palabra inglesa `role` en las\n      // declaraciones (ADR-0090 D3). Esa regla s\u00F3lo lee ingl\u00E9s y no alcanza\n      // los paquetes de idioma, as\u00ED que aqu\u00ED va el t\u00E9rmino natural.\n      buying_function: {\n        label: 'Rol de Compra',\n        options: {\n          decision_maker: 'Decisor', economic_buyer: 'Comprador Econ\u00F3mico',\n          technical_evaluator: 'Evaluador T\u00E9cnico', user: 'Usuario',\n          influencer: 'Influenciador', gatekeeper: 'Guardi\u00E1n',\n        },\n      },\n      attitude: {\n        label: 'Actitud hacia Nosotros',\n        options: {\n          champion: 'Defensor', supportive: 'Favorable', neutral: 'Neutral',\n          skeptical: 'Esc\u00E9ptico', blocker: 'Bloqueador',\n        },\n      },\n      relationship_strength: {\n        label: 'Fuerza de la Relaci\u00F3n',\n        options: {\n          distant: 'Distante', acquaintance: 'Conocido', working: 'Relaci\u00F3n de Trabajo',\n          strong: 'Fuerte', trusted_advisor: 'Asesor de Confianza',\n        },\n      },\n      owner_id: { label: 'Propietario de Contacto' },\n      description: { label: 'Descripci\u00F3n' },\n      is_primary: { label: 'Contacto Principal', help: '\u00BFEs este el contacto principal de la cuenta?' },\n      avatar: { label: 'Foto de Perfil' },\n      mailing_address: { label: 'Direcci\u00F3n de Correo' },\n      // Juego compartido con `crm_lead.lead_source` y\n      // `crm_opportunity.lead_source` \u2014 los tres deben coincidir literalmente.\n      lead_source: {\n        label: 'Origen del Prospecto',\n        options: {\n          web: 'Web', referral: 'Referencia', event: 'Evento / Feria',\n          webinar: 'Seminario Web', partner: 'Socio', advertisement: 'Publicidad',\n          paid_search: 'B\u00FAsqueda de Pago', social: 'Redes Sociales', content: 'Contenido / Blog',\n          cold_call: 'Llamada en Fr\u00EDo', email_campaign: 'Campa\u00F1a de Email', other: 'Otro',\n        },\n      },\n      do_not_call: { label: 'No Llamar' },\n      email_opt_out: { label: 'Excluir de Correos' },\n      last_contacted_date: { label: '\u00DAltimo contacto' },\n    },\n    _views: {\n      all_contacts: { label: 'Todos los Contactos' },\n      contact_directory: { label: 'Directorio de Contactos' },\n      primary_contacts: { label: 'Contactos Principales' },\n    },\n    _sections: {\n      identity: { label: 'Identidad' },\n      account_info: { label: 'Cuenta y Cargo' },\n      buying_centre: { label: 'Centro de Compra' },\n      contact_info: { label: 'Informaci\u00F3n de Contacto' },\n      mailing_address: { label: 'Direcci\u00F3n de Correo' },\n      additional: { label: 'Informaci\u00F3n Adicional' },\n      preferences: { label: 'Preferencias de Comunicaci\u00F3n' },\n      // Nombres de secci\u00F3n del formulario en contact.view.ts (#1100)\n      contact_details: { label: 'Informaci\u00F3n de Contacto' },\n      comm_preferences: { label: 'Preferencias' },\n    },\n    _actions: {\n      ...activityActions,\n      mark_primary: {\n        label: 'Marcar como Principal',\n        confirmText: '\u00BFEstablecer este contacto como contacto principal de la cuenta?',\n        successMessage: '\u00A1Establecido como contacto principal!',\n      },\n      send_email: {\n        label: 'Enviar Correo',\n        params: {\n          subject: { label: 'Asunto' },\n          body: { label: 'Cuerpo' },\n        },\n      },\n      add_contact_to_campaign: {\n        label: 'A\u00F1adir a Campa\u00F1a',\n        successMessage: '\u00A1Contactos a\u00F1adidos a la campa\u00F1a!',\n        params: {\n          crm_campaign: { label: 'Campa\u00F1a' },\n        },\n      },\n    },\n  },\n};\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/sales/translations/es-ES/objects.pipeline.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/sales/translations/es-ES\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/sales/translations/es-ES/objects.pipeline.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport type { ObjectTranslationData } from '@objectstack/spec/system';\n\nimport { activityActions } from './_shared';\n\n/**\n * Espa\u00F1ol (es-ES) \u2014 `objects` translations for the PIPELINE family:\n * demand and the deals it becomes, plus the roll-up that forecasts them.\n *\n * Roster: `crm_lead`, `crm_opportunity`, `crm_opportunity_line_item`, `crm_forecast`.\n *\n * SPLIT AXIS (#1311): translation NAMESPACE first, then CRM DOMAIN FAMILY.\n * Everything that is not `objects` lives in `./app.ts`; `objects` \u2014 69-78% of\n * every bundle \u2014 is one file per CRM domain family, and a detail object\n * follows its master. A new row goes in the file for ITS family, never in\n * whichever file is already open: that is how one file re-grows past the 70%\n * advisory band `pnpm hygiene` prints. Full rule and rationale:\n * `src/sales/translations/es-ES.ts`.\n */\nexport const pipeline: Record<string, ObjectTranslationData> = {\n  crm_lead: {\n    _validations: {\n      disqualification_reason_required: {\n        message: 'El motivo de descalificaci\u00F3n es obligatorio cuando un prospecto no est\u00E1 cualificado',\n      },\n      duplicate_disqualification_requires_survivor: {\n        message: 'Descalificar un prospecto como duplicado exige nombrar el registro superviviente y marcar el estado de duplicado como Confirmado',\n      },\n      email_required: {\n        message: 'El correo electr\u00F3nico es obligatorio',\n      },\n      lead_status_progression: {\n        message: 'Transici\u00F3n de estado de prospecto no v\u00E1lida',\n      },\n    },\n    label: 'Prospecto',\n    pluralLabel: 'Prospectos',\n    description: 'Clientes potenciales todav\u00EDa sin calificar',\n    fields: {\n      first_name: { label: 'Nombre' },\n      last_name: { label: 'Apellido' },\n      company: { label: 'Empresa' },\n      company_normalized: {\n        label: 'Empresa (Normalizado)',\n        help: 'Clave de coincidencia para la conversi\u00F3n de prospectos: la Empresa en min\u00FAsculas, sin espacios sobrantes y con los espacios internos reducidos a uno. Lo mantiene el hook lead_duplicate_check \u2014 nunca lo edite directamente.',\n      },\n      display_title: { label: 'T\u00EDtulo Mostrado' },\n      title: { label: 'Cargo' },\n      email: { label: 'Correo Electr\u00F3nico' },\n      phone: { label: 'Tel\u00E9fono' },\n      status: {\n        label: 'Estado',\n        options: {\n          new: 'Nuevo', contacted: 'Contactado', qualified: 'Calificado',\n          unqualified: 'No Calificado', converted: 'Convertido',\n        },\n      },\n      lead_source: {\n        label: 'Origen del Prospecto',\n        options: {\n          web: 'Web', referral: 'Referencia', event: 'Evento / Feria',\n          webinar: 'Seminario Web', partner: 'Socio', advertisement: 'Publicidad',\n          paid_search: 'B\u00FAsqueda de Pago', social: 'Redes Sociales', content: 'Contenido / Blog',\n          cold_call: 'Llamada en Fr\u00EDo', email_campaign: 'Campa\u00F1a de Email', other: 'Otro',\n        },\n      },\n      owner_id: { label: 'Propietario' },\n      is_converted: { label: 'Convertido' },\n      description: { label: 'Descripci\u00F3n' },\n      // Mismo juego de valores que `crm_contact.salutation` \u2014 trad\u00FAzcanse igual.\n      salutation: {\n        label: 'Tratamiento',\n        options: { mr: 'Sr.', ms: 'Srta.', mrs: 'Sra.', dr: 'Dr.', prof: 'Prof.' },\n      },\n      full_name: { label: 'Nombre Completo' },\n      // Los 15 valores son los mismos que en `crm_account.industry` \u2014 deben\n      // coincidir literalmente entre ambas pantallas.\n      industry: {\n        label: 'Industria',\n        options: {\n          technology: 'Tecnolog\u00EDa', software: 'Software / SaaS', finance: 'Finanzas',\n          healthcare: 'Salud', retail: 'Comercio', manufacturing: 'Manufactura',\n          education: 'Educaci\u00F3n', real_estate: 'Inmobiliaria', media: 'Medios y Entretenimiento',\n          logistics: 'Log\u00EDstica', hospitality: 'Hosteler\u00EDa', energy: 'Energ\u00EDa y Servicios P\u00FAblicos',\n          government: 'Gobierno', nonprofit: 'Sin \u00C1nimo de Lucro', other: 'Otro',\n        },\n      },\n      mobile: { label: 'M\u00F3vil' },\n      website: { label: 'Sitio Web' },\n      rating: { label: 'Puntuaci\u00F3n de Prospecto', help: 'Puntuaci\u00F3n de calidad del prospecto (1-5 estrellas)' },\n      next_followup_date: { label: 'Pr\u00F3xima Fecha de Seguimiento' },\n      last_contacted_date: { label: '\u00DAltimo Contacto' },\n      need_type: {\n        label: 'Tipo de Necesidad',\n        help: 'Qu\u00E9 est\u00E1 pidiendo este prospecto. La asignaci\u00F3n, la priorizaci\u00F3n y los informes de demanda leen este campo.',\n        options: {\n          new_implementation: 'Nueva Implantaci\u00F3n', expansion: 'Ampliaci\u00F3n',\n          replacement: 'Sustituci\u00F3n', renewal: 'Renovaci\u00F3n', consulting: 'Consultor\u00EDa',\n          support: 'Soporte y Mantenimiento', other: 'Otro',\n        },\n      },\n      estimated_amount: {\n        label: 'Importe Estimado',\n        help: 'Valor estimado de esta necesidad, antes de la cualificaci\u00F3n. Precarga el importe de la oportunidad al convertir.',\n      },\n      conversion_approval_status: {\n        label: 'Aprobaci\u00F3n de Conversi\u00F3n',\n        help: 'Si este prospecto tiene el visto bueno para convertirse. \u00ABNo Requerida\u00BB significa que no se pide aprobaci\u00F3n: es el valor predeterminado de f\u00E1brica.',\n        options: {\n          not_required: 'No Requerida', pending: 'Pendiente',\n          approved: 'Aprobada', rejected: 'Rechazada',\n        },\n      },\n      converted_account: { label: 'Cuenta Convertida' },\n      converted_contact: { label: 'Contacto Convertido' },\n      converted_opportunity: { label: 'Oportunidad Convertida' },\n      converted_date: { label: 'Fecha de Conversi\u00F3n' },\n      address: { label: 'Direcci\u00F3n' },\n      annual_revenue: { label: 'Ingresos Anuales' },\n      number_of_employees: { label: 'N\u00FAmero de Empleados' },\n      notes: { label: 'Notas', help: 'Notas de trabajo sobre este cliente potencial: admite formato.' },\n      do_not_call: { label: 'No Llamar' },\n      email_opt_out: { label: 'Excluir de Correos' },\n      disqualification_reason: {\n        label: 'Motivo de No Calificaci\u00F3n',\n        help: 'Obligatorio cuando el estado es No Calificado',\n        options: {\n          not_a_fit: 'No Encaja', no_budget: 'Sin Presupuesto', wrong_persona: 'Perfil Incorrecto',\n          unreachable: 'Ilocalizable', duplicate: 'Duplicado', competitor: 'Competidor',\n          other: 'Otro',\n        },\n      },\n      duplicate_of_type: {\n        label: 'Duplicado De',\n        help: 'Qu\u00E9 objeto contiene el registro superviviente que este prospecto repite.',\n        // `erased` es una l\u00E1pida, no una opci\u00F3n: el formulario no la ofrece\n        // (ver `src/sales/views/lead.view.ts`), pero un prospecto cuyo superviviente\n        // fue eliminado la lleva, as\u00ED que necesita etiqueta all\u00ED donde el\n        // registro se LEE; sin traducir se mostrar\u00EDa el valor crudo `erased`.\n        options: { crm_lead: 'Prospecto', crm_contact: 'Contacto', erased: 'Registro Eliminado' },\n      },\n      duplicate_of_lead: { label: 'Prospecto Duplicado' },\n      duplicate_of_contact: { label: 'Contacto Duplicado' },\n      duplicate_status: {\n        label: 'Estado del Duplicado',\n        help: 'Sospechoso = marcado autom\u00E1ticamente en la captura. Confirmado = una persona verific\u00F3 la coincidencia.',\n        options: { suspected: 'Sospechoso', confirmed: 'Confirmado' },\n      },\n    },\n    _views: {\n      all_leads: {\n        label: 'Todos los Prospectos',\n        emptyState: { title: 'Todav\u00EDa no hay prospectos', message: 'Empiece creando su primer prospecto' },\n      },\n      kanban_by_status: { label: 'Pipeline de Prospectos' },\n      calendar_by_created: { label: 'Calendario de Prospectos' },\n      gallery_view: { label: 'Galer\u00EDa de Prospectos' },\n      my_leads: { label: 'Mis Prospectos' },\n      high_priority: { label: 'Alta Prioridad' },\n      hot_leads: { label: '\uD83D\uDD25 Prospectos Calientes' },\n      suspected_duplicates: {\n        label: 'Duplicados Sospechosos',\n        emptyState: {\n          title: 'Sin duplicados sospechosos',\n          message: 'Nada que revisar: se han comprobado todos los correos recapturados.',\n        },\n      },\n    },\n    _sections: {\n      // Claves de secci\u00F3n del objeto (lead.object.ts) que usan los\n      // formularios de registro y la p\u00E1gina de detalle, cuyas secciones\n      // hacen referencia a estos grupos (#806).\n      address: { label: 'Direcci\u00F3n' },\n      identity: { label: 'Identidad' },\n      company_info: { label: 'Informaci\u00F3n de la Empresa' },\n      contact_info: { label: 'Informaci\u00F3n de Contacto' },\n      qualification: { label: 'Calificaci\u00F3n' },\n      assignment: { label: 'Asignaci\u00F3n' },\n      conversion: { label: 'Conversi\u00F3n' },\n      additional: { label: 'Informaci\u00F3n Adicional' },\n      preferences: { label: 'Preferencias de Comunicaci\u00F3n' },\n      duplicates: { label: 'Gesti\u00F3n de Duplicados' },\n      // Nombres de secci\u00F3n del formulario en lead.view.ts (#1100) \u2014 aqu\u00ED\n      // viven las secciones del formulario por defecto y las de cada formView\n      // con nombre: si se a\u00F1ade un formulario all\u00ED, se a\u00F1aden aqu\u00ED sus\n      // nombres de secci\u00F3n.\n      contact_information: { label: 'Informaci\u00F3n de Contacto' },\n      lead_classification: { label: 'Clasificaci\u00F3n del Lead' },\n      company_information: { label: 'Informaci\u00F3n de la Empresa' },\n      additional_information: { label: 'Informaci\u00F3n Adicional' },\n      privacy: { label: 'Privacidad' },\n      general: { label: 'General' },\n      details: { label: 'Detalles' },\n      step_1_contact_details: { label: 'Paso 1: Datos de Contacto' },\n      step_2_company_information: { label: 'Paso 2: Informaci\u00F3n de la Empresa' },\n      step_3_qualification: { label: 'Paso 3: Calificaci\u00F3n' },\n      step_4_review_and_convert: { label: 'Paso 4: Revisar y Convertir' },\n      primary_information: { label: 'Informaci\u00F3n Principal' },\n      extended_details: { label: 'Detalles Ampliados' },\n      quick_edit: { label: 'Edici\u00F3n R\u00E1pida' },\n      update_lead_status: { label: 'Actualizar Estado del Lead' },\n      tell_us_about_yourself: { label: 'Cu\u00E9ntanos sobre ti' },\n      about_your_company: { label: 'Sobre tu empresa' },\n      how_can_we_help: { label: '\u00BFC\u00F3mo podemos ayudarte?' },\n      lead_information: { label: 'Informaci\u00F3n del Lead' },\n      address_information: { label: 'Informaci\u00F3n de Direcci\u00F3n' },\n      privacy_preferences: { label: 'Preferencias de Privacidad' },\n    },\n    _actions: {\n      ...activityActions,\n      convert_lead: {\n        label: 'Convertir Prospecto',\n        successMessage: '\u00A1Prospecto convertido con \u00E9xito!',\n      },\n      create_campaign: {\n        label: 'Agregar a Campa\u00F1a',\n        successMessage: '\u00A1Prospecto agregado a la campa\u00F1a!',\n        params: {\n          crm_campaign: { label: 'Campa\u00F1a' },\n        },\n      },\n      schedule_followup: {\n        label: 'Programar Seguimiento',\n        successMessage: 'Seguimiento programado.',\n      },\n    },\n  },\n  crm_opportunity: {\n    _validations: {\n      amount_positive: {\n        message: 'El importe debe ser mayor que cero',\n      },\n      close_date_future: {\n        message: 'La fecha de cierre no deber\u00EDa estar en el pasado salvo que la oportunidad est\u00E9 cerrada',\n      },\n      opportunity_stage_progression: {\n        message: 'Transici\u00F3n de etapa de oportunidad no v\u00E1lida',\n      },\n    },\n    label: 'Oportunidad',\n    pluralLabel: 'Oportunidades',\n    description: 'Oportunidades de venta y negocios en el pipeline',\n    fields: {\n      name: { label: 'Nombre de Oportunidad' },\n      crm_account: { label: 'Cuenta' },\n      primary_contact: { label: 'Contacto Principal' },\n      owner_id: { label: 'Propietario de Oportunidad' },\n      amount: { label: 'Monto' },\n      expected_revenue: { label: 'Ingreso Esperado' },\n      stage: {\n        label: 'Etapa',\n        options: {\n          prospecting: 'Prospecci\u00F3n', qualification: 'Calificaci\u00F3n',\n          needs_analysis: 'An\u00E1lisis de Necesidades', proposal: 'Propuesta',\n          negotiation: 'Negociaci\u00F3n', closed_won: 'Cerrada Ganada', closed_lost: 'Cerrada Perdida',\n        },\n      },\n      probability: { label: 'Probabilidad (%)' },\n      close_date: { label: 'Fecha de Cierre' },\n      type: {\n        label: 'Tipo',\n        options: {\n          new_business: 'Nuevo Negocio',\n          existing_upgrade: 'Cliente Existente - Mejora',\n          existing_renewal: 'Cliente Existente - Renovaci\u00F3n',\n          existing_expansion: 'Cliente Existente - Expansi\u00F3n',\n        },\n      },\n      forecast_category: {\n        label: 'Categor\u00EDa de Pron\u00F3stico',\n        options: {\n          pipeline: 'Pipeline', best_case: 'Mejor Caso',\n          commit: 'Compromiso', omitted: 'Omitida', closed: 'Cerrada',\n        },\n      },\n      description: { label: 'Descripci\u00F3n' },\n      next_step: { label: 'Pr\u00F3ximo Paso' },\n      lead_source: {\n        label: 'Origen del Prospecto',\n        options: {\n          web: 'Web', referral: 'Referencia', event: 'Evento / Feria',\n          webinar: 'Seminario Web', partner: 'Socio', advertisement: 'Publicidad',\n          paid_search: 'B\u00FAsqueda de Pago', social: 'Redes Sociales', content: 'Contenido / Blog',\n          cold_call: 'Llamada en Fr\u00EDo', email_campaign: 'Campa\u00F1a de Email', other: 'Otro',\n        },\n      },\n      crm_campaign: { label: 'Campa\u00F1a', help: 'Campa\u00F1a de marketing que gener\u00F3 esta oportunidad' },\n      days_in_stage: { label: 'D\u00EDas en Etapa Actual' },\n      stage_entry_date: { label: 'Fecha de Entrada a la Etapa', help: 'Fecha en la que esta oportunidad entr\u00F3 en su etapa actual.' },\n      is_private: { label: 'Privado' },\n      approval_status: {\n        label: 'Estado de Aprobaci\u00F3n',\n        options: {\n          not_required: 'No Requerida', pending: 'Pendiente',\n          approved: 'Aprobada', rejected: 'Rechazada',\n        },\n      },\n      approved_date: { label: 'Fecha de Aprobaci\u00F3n' },\n      // #593 \u2014 obligatorias al cerrar la oportunidad, y el desglose de\n      // motivos de p\u00E9rdida las muestra en el panel de ventas, as\u00ED que el\n      // valor almacenado nunca debe llegar crudo al selector.\n      win_reason: {\n        label: 'Motivo de Ganancia',\n        help: 'Por qu\u00E9 se gan\u00F3 este negocio. Obligatorio para cerrar una oportunidad como Ganada.',\n        options: {\n          better_product: 'Mejor Producto', better_price: 'Mejor Precio',\n          relationship: 'Relaci\u00F3n Existente', better_support: 'Mejor Soporte',\n          best_fit: 'Mejor Ajuste / Funcionalidades',\n          quote_accepted: 'Cotizaci\u00F3n Aceptada', other: 'Otro',\n        },\n      },\n      loss_reason: {\n        label: 'Motivo de P\u00E9rdida',\n        help: 'Por qu\u00E9 se perdi\u00F3 este negocio. Obligatorio para cerrar una oportunidad como Perdida.',\n        options: {\n          price: 'Precio Demasiado Alto', competitor: 'Perdida ante Competidor',\n          no_budget: 'Sin Presupuesto', no_decision: 'Sin Decisi\u00F3n',\n          timing: 'Momento Inadecuado', features: 'Funcionalidades Faltantes', other: 'Otro',\n        },\n      },\n      loss_details: {\n        label: 'Detalles de Ganancia/P\u00E9rdida',\n        help: 'Contexto en texto libre detr\u00E1s del motivo de ganancia o p\u00E9rdida.',\n      },\n      // REQ-0006 \u2014 calificaci\u00F3n, calendario de compra del cliente, narrativa\n      // del negocio, l\u00EDnea de negocio y aprobaci\u00F3n del cambio de estado.\n      will_bid: {\n        label: 'Presentaremos Oferta',\n        help: 'Si tenemos intenci\u00F3n de presentar oferta. Sin valor significa que la decisi\u00F3n sigue abierta.',\n      },\n      controllability: { label: 'Controlabilidad', options: { high: 'Alta', medium: 'Media', low: 'Baja' } },\n      priority: { label: 'Prioridad', options: { high: 'Alta', medium: 'Media', low: 'Baja' } },\n      deal_level: { label: 'Nivel del Negocio', options: { strategic: 'Estrat\u00E9gico', key: 'Clave', standard: 'Est\u00E1ndar' } },\n      is_subcontracted: { label: 'Incluye Subcontrataci\u00F3n' },\n      subcontracting_note: { label: 'Nota de Subcontrataci\u00F3n' },\n      customer_initiation_date: { label: 'Fecha de Inicio del Proyecto (Cliente)' },\n      expected_tender_date: { label: 'Fecha Prevista de Licitaci\u00F3n' },\n      expected_signing_date: { label: 'Fecha Prevista de Firma' },\n      expected_tender_amount: { label: 'Importe Previsto de Licitaci\u00F3n' },\n      expected_signing_amount: { label: 'Importe Previsto de Firma' },\n      business_line: {\n        label: 'L\u00EDnea de Negocio',\n        options: {\n          product: 'Producto', services: 'Servicios Profesionales', consulting: 'Consultor\u00EDa',\n          support: 'Soporte y Mantenimiento', other: 'Otro',\n        },\n      },\n      customer_background: { label: 'Antecedentes del Cliente' },\n      project_background: { label: 'Antecedentes del Proyecto' },\n      risk_analysis: { label: 'An\u00E1lisis de Riesgos' },\n      payment_terms: { label: 'Condiciones de Pago' },\n      requested_status: { label: 'Estado Solicitado', options: { closed_won: 'Ganada', closed_lost: 'Perdida' } },\n      status_change_approval_status: {\n        label: 'Aprobaci\u00F3n del Cambio de Estado',\n        options: {\n          not_required: 'No Requerida', pending: 'Pendiente',\n          approved: 'Aprobada', rejected: 'Rechazada',\n        },\n      },\n      // REQ-0006 paso 11 \u2014 la aprobaci\u00F3n de calificaci\u00F3n (\u7ACB\u9879).\n      qualification_requested: {\n        label: 'Solicitar Aprobaci\u00F3n de Calificaci\u00F3n',\n        help: 'M\u00E1rquelo para enviar este negocio a aprobaci\u00F3n de calificaci\u00F3n. Un rechazo lo desmarca; vuelva a marcarlo para solicitarla de nuevo.',\n      },\n      qualification_approval_status: {\n        label: 'Aprobaci\u00F3n de Calificaci\u00F3n',\n        options: {\n          not_required: 'No Requerida', pending: 'Pendiente',\n          approved: 'Aprobada', rejected: 'Rechazada',\n        },\n      },\n    },\n    _views: {\n      tender_this_quarter: {\n        label: 'Licitaciones de Este Trimestre',\n        emptyState: {\n          title: 'No hay licitaciones previstas este trimestre',\n          message: 'Esta pesta\u00F1a muestra los negocios abiertos cuya fecha de licitaci\u00F3n del cliente cae dentro del trimestre actual. Registra la Fecha Prevista de Licitaci\u00F3n en un negocio para verlo aqu\u00ED.',\n        },\n      },\n      open_opportunities: { label: 'Oportunidades Abiertas' },\n      all_opportunities: { label: 'Todas las Oportunidades' },\n      pipeline_kanban: { label: 'Pipeline de Ventas' },\n      close_date_calendar: { label: 'Calendario de Pron\u00F3stico' },\n      deal_timeline: { label: 'L\u00EDnea de Tiempo' },\n      deal_gallery: { label: 'Galer\u00EDa de Negocios' },\n      my_open_deals: { label: 'Mis Negocios Abiertos' },\n      closing_this_quarter: {\n        label: 'Cierres de Este Trimestre',\n        emptyState: {\n          title: 'No hay negocios que cierren este trimestre',\n          message: 'Esta pesta\u00F1a muestra los negocios abiertos en categor\u00EDa Compromiso o Mejor Caso cuya fecha de cierre cae dentro del trimestre actual. Ahora mismo no hay ninguno; los negocios que cierran m\u00E1s adelante est\u00E1n en la pesta\u00F1a Negocios Abiertos.',\n        },\n      },\n      stale_opportunities: { label: '\u26A0\uFE0F Oportunidades Estancadas \u00B7 M\u00E1s Tiempo en Etapa Primero' },\n    },\n    _sections: {\n      // Claves de secci\u00F3n del objeto (opportunity.object.ts) que usan los\n      // formularios de registro y la p\u00E1gina de detalle, cuyas secciones\n      // hacen referencia a estos grupos (#1452).\n      //\n      // `crm_forecast` es la clave del grupo de campos (\u00ABForecast & Metrics\u00BB\n      // en ingl\u00E9s). Esta traducci\u00F3n es anterior a #1452, cuando una secci\u00F3n\n      // de la p\u00E1gina de detalle con el mismo nombre se titulaba \u00ABStage &\n      // Forecast\u00BB; desde entonces solo la lee el grupo.\n      crm_forecast: { label: 'Etapa y Previsi\u00F3n' },\n      basic: { label: 'Informaci\u00F3n B\u00E1sica' },\n      financials: { label: 'Datos Financieros' },\n      sales_process: { label: 'Proceso de Venta' },\n      classification: { label: 'Clasificaci\u00F3n' },\n      campaign: { label: 'Campa\u00F1as' },\n      notes: { label: 'Notas y Pr\u00F3ximos Pasos' },\n      qualification: { label: 'Calificaci\u00F3n' },\n      narrative: { label: 'Narrativa del Negocio' },\n      // Nombres de secci\u00F3n del formulario en opportunity.view.ts (#1100)\n      overview: { label: 'Resumen' },\n      forecast: { label: 'Previsi\u00F3n' },\n      sales_strategy: { label: 'Estrategia de Ventas' },\n      win_loss: { label: 'Ganada / Perdida' },\n    },\n    _actions: {\n      ...activityActions,\n      clone_opportunity: {\n        label: 'Clonar Oportunidad',\n        successMessage: '\u00A1Oportunidad clonada con \u00E9xito!',\n      },\n      mass_update_stage: {\n        label: 'Actualizar Etapa',\n        successMessage: '\u00A1Etapa de oportunidad actualizada!',\n        params: {\n          // Mismos valores que `fields.stage` \u2014 deben coincidir literalmente.\n          stage: {\n            label: 'Nueva Etapa',\n            options: {\n              prospecting: 'Prospecci\u00F3n', qualification: 'Calificaci\u00F3n',\n              needs_analysis: 'An\u00E1lisis de Necesidades', proposal: 'Propuesta',\n              negotiation: 'Negociaci\u00F3n', closed_won: 'Cerrada Ganada', closed_lost: 'Cerrada Perdida',\n            },\n          },\n        },\n      },\n      generate_quote: {\n        label: 'Generar Cotizaci\u00F3n',\n        successMessage: '\u00A1Cotizaci\u00F3n creada desde la oportunidad!',\n      },\n    },\n  },\n  crm_opportunity_line_item: {\n    _validations: {\n      unit_price_positive: {\n        message: 'El precio de venta no puede ser negativo',\n      },\n    },\n    label: 'L\u00EDnea de Oportunidad',\n    pluralLabel: 'L\u00EDneas de Oportunidad',\n    description: 'L\u00EDneas de precio por producto dentro de una oportunidad',\n    fields: {\n      crm_opportunity: { label: 'Oportunidad' },\n      crm_product: { label: 'Producto' },\n      description: { label: 'Descripci\u00F3n' },\n      quantity: { label: 'Cantidad' },\n      list_price: { label: 'Precio de Lista', help: 'Se rellena autom\u00E1ticamente desde el Precio de Lista del producto.' },\n      unit_price: { label: 'Precio de Venta', help: 'Precio unitario negociado (puede diferir del precio de lista)' },\n      discount: { label: 'Descuento (%)' },\n      total_price: { label: 'Total' },\n      line_number: { label: 'N\u00BA de L\u00EDnea' },\n    },\n    _sections: {\n      basic: { label: 'L\u00EDnea' },\n      pricing: { label: 'Precios' },\n    },\n  },\n  crm_forecast: {\n    _validations: {\n      period_end_after_start: {\n        message: 'El fin del periodo debe ser posterior a su inicio.',\n      },\n      period_end_matches_calendar_period: {\n        message: 'El fin del periodo debe ser el \u00FAltimo d\u00EDa del periodo: p. ej. 2026-09-30 para un trimestre que empieza el 2026-07-01, o 2026-08-31 para agosto de 2026.',\n      },\n      period_start_first_of_period: {\n        message: 'El inicio del periodo debe ser el primer d\u00EDa del periodo: p. ej. 2026-08-01 para agosto de 2026.',\n      },\n      quarter_starts_on_quarter_boundary: {\n        message: 'Una previsi\u00F3n trimestral debe comenzar en un l\u00EDmite de trimestre: 1 de enero, 1 de abril, 1 de julio o 1 de octubre.',\n      },\n      snapshot_amounts_non_negative: {\n        message: 'Los importes de la instant\u00E1nea no pueden ser negativos.',\n      },\n    },\n    label: 'Previsi\u00F3n',\n    pluralLabel: 'Previsiones',\n    description: 'Instant\u00E1nea peri\u00F3dica del pipeline por propietario para previsi\u00F3n de ingresos',\n    fields: {\n      owner_id: { label: 'Propietario' },\n      period: { label: 'Periodo', options: { month: 'Mes', quarter: 'Trimestre' } },\n      period_start: {\n        label: 'Inicio del periodo',\n        help: 'Debe ser el primer d\u00EDa del periodo \u2014 p. ej. 2026-08-01 para agosto de 2026. Adem\u00E1s, una previsi\u00F3n trimestral debe comenzar en un l\u00EDmite de trimestre: 1 de enero, 1 de abril, 1 de julio o 1 de octubre.',\n      },\n      period_end: {\n        label: 'Fin del periodo',\n        help: 'Normalmente se calcula autom\u00E1ticamente a partir de Periodo e Inicio del periodo. Si se introduce a mano, debe ser el \u00FAltimo d\u00EDa de ese periodo \u2014 p. ej. 2026-09-30 para un trimestre que empieza el 2026-07-01, o 2026-08-31 para agosto de 2026.',\n      },\n      period_label: { label: 'Periodo', help: 'Etiqueta legible, p. ej. \u00ABT3 2026\u00BB o \u00ABAgo 2026\u00BB.' },\n      display_title: { label: 'T\u00EDtulo Mostrado' },\n      snapshot_date: { label: 'Fecha de instant\u00E1nea', help: 'El d\u00EDa en que se captur\u00F3 esta instant\u00E1nea.' },\n      source: {\n        label: 'Origen',\n        options: { scheduled: 'Instant\u00E1nea programada', ai: 'Skill de IA', manual: 'Entrada manual' },\n      },\n      quota: { label: 'Cuota' },\n      pipeline_amount: { label: 'Pipeline', help: 'Suma de todas las oportunidades abiertas que cierran en este periodo (en cualquier etapa).' },\n      best_case_amount: { label: 'Mejor caso', help: 'Oportunidades abiertas en la categor\u00EDa de pron\u00F3stico Mejor caso o Compromiso.' },\n      commit_amount: { label: 'Compromiso', help: 'Oportunidades abiertas en la categor\u00EDa de pron\u00F3stico Compromiso (comprometidas por el propietario).' },\n      closed_amount: { label: 'Cerrado', help: 'Importe ya cerrado ganado en este periodo.' },\n      expected_amount: { label: 'Esperado', help: 'Cerrado + Compromiso: lo que el propietario espera razonablemente cerrar.' },\n      attainment_pct: { label: 'Cumplimiento %', help: 'Cerrado \u00F7 Cuota \u00D7 100. Muestra 0 % hasta que se fija una cuota positiva.' },\n      coverage_ratio: { label: 'Cobertura', help: 'Pipeline \u00F7 (Cuota \u2212 Cerrado): si queda pipeline suficiente para cubrir la diferencia. Muestra 0 cuando ya se ha alcanzado la cuota.' },\n      notes: { label: 'Notas' },\n      seed_key: {\n        label: 'Clave de semilla',\n        help: 'Identidad del juego de datos de demostraci\u00F3n. Solo la escribe el cargador de semillas; est\u00E1 vac\u00EDa en cualquier instant\u00E1nea real.',\n      },\n    },\n    _views: {\n      all_forecasts: { label: 'Todas las previsiones' },\n      this_quarter_forecasts: {\n        label: 'Este trimestre',\n        emptyState: {\n          title: 'A\u00FAn no hay instant\u00E1neas de este trimestre',\n          message: 'Las instant\u00E1neas trimestrales las escribe el barrido nocturno de previsiones. Hasta que se ejecute una vez para el trimestre actual, esta vista est\u00E1 vac\u00EDa; los trimestres cerrados est\u00E1n en la pesta\u00F1a Todas.',\n        },\n      },\n      my_forecast: { label: 'Mi previsi\u00F3n' },\n    },\n    _sections: {\n      basic: { label: 'Instant\u00E1nea' },\n      amounts: { label: 'Importes' },\n      meta: { label: 'Origen' },\n      // Nombres de secci\u00F3n del formulario en forecast.view.ts (#1100)\n      snapshot: { label: 'Instant\u00E1nea' },\n      notes: { label: 'Notas' },\n    },\n  },\n};\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/sales/translations/es-ES/objects.commerce.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/sales/translations/es-ES\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/sales/translations/es-ES/objects.commerce.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport type { ObjectTranslationData } from '@objectstack/spec/system';\n\n/**\n * Espa\u00F1ol (es-ES) \u2014 `objects` translations for the COMMERCE family:\n * what gets sold and on what paper \u2014 quotes, contracts, products.\n *\n * Roster: `crm_quote`, `crm_quote_line_item`, `crm_contract`, `crm_product`.\n *\n * SPLIT AXIS (#1311): translation NAMESPACE first, then CRM DOMAIN FAMILY.\n * Everything that is not `objects` lives in `./app.ts`; `objects` \u2014 69-78% of\n * every bundle \u2014 is one file per CRM domain family, and a detail object\n * follows its master. A new row goes in the file for ITS family, never in\n * whichever file is already open: that is how one file re-grows past the 70%\n * advisory band `pnpm hygiene` prints. Full rule and rationale:\n * `src/sales/translations/es-ES.ts`.\n */\nexport const commerce: Record<string, ObjectTranslationData> = {\n  crm_quote: {\n    _validations: {\n      discount_within_ceiling: {\n        message: 'El descuento no puede superar el 60 %',\n      },\n      expiration_after_quote: {\n        message: 'La fecha de vencimiento debe ser posterior a la de la cotizaci\u00F3n',\n      },\n      quote_status_progression: {\n        message: 'Transici\u00F3n de estado de cotizaci\u00F3n no v\u00E1lida',\n      },\n    },\n    label: 'Cotizaci\u00F3n',\n    pluralLabel: 'Cotizaciones',\n    description: 'Cotizaciones de precios para clientes',\n    fields: {\n      quote_number: { label: 'N\u00FAmero de Cotizaci\u00F3n' },\n      display_title: { label: 'T\u00EDtulo Mostrado' },\n      name: { label: 'Nombre de Cotizaci\u00F3n' },\n      crm_account: { label: 'Cuenta' },\n      crm_contact: {\n        label: 'Contacto',\n        help: 'Obligatorio en cuanto la cotizaci\u00F3n pasa a Presentada o Aceptada: el contrato generado toma de aqu\u00ED su Contacto principal.',\n      },\n      crm_opportunity: { label: 'Oportunidad' },\n      owner_id: { label: 'Propietario de Cotizaci\u00F3n' },\n      status: {\n        label: 'Estado',\n        options: {\n          draft: 'Borrador', in_review: 'En Revisi\u00F3n', presented: 'Presentada',\n          accepted: 'Aceptada', rejected: 'Rechazada', expired: 'Expirada',\n        },\n      },\n      quote_date: { label: 'Fecha de Cotizaci\u00F3n' },\n      expiration_date: { label: 'Fecha de Expiraci\u00F3n' },\n      subtotal: { label: 'Subtotal' },\n      discount: { label: 'Descuento %' },\n      discount_amount: { label: 'Monto de Descuento' },\n      tax: { label: 'Impuesto' },\n      shipping_handling: { label: 'Env\u00EDo y Manipulaci\u00F3n' },\n      total_price: { label: 'Precio Total' },\n      // Mismo juego de valores que `crm_contract.payment_terms` \u2014 trad\u00FAzcanse igual.\n      payment_terms: {\n        label: 'T\u00E9rminos de Pago',\n        options: {\n          net_15: 'Neto 15', net_30: 'Neto 30', net_60: 'Neto 60', net_90: 'Neto 90',\n          due_on_receipt: 'Pago a la Recepci\u00F3n',\n        },\n      },\n      shipping_terms: { label: 'T\u00E9rminos de Env\u00EDo' },\n      billing_address: { label: 'Direcci\u00F3n de Facturaci\u00F3n' },\n      shipping_address: { label: 'Direcci\u00F3n de Env\u00EDo' },\n      description: { label: 'Descripci\u00F3n' },\n      internal_notes: { label: 'Notas Internas' },\n    },\n    _views: {\n      all_quotes: { label: 'Todas las Cotizaciones' },\n      quote_pipeline: { label: 'Pipeline de Cotizaciones' },\n      quote_calendar: { label: 'Calendario de Cotizaciones' },\n    },\n    _sections: {\n      basic: { label: 'Informaci\u00F3n de la Cotizaci\u00F3n' },\n      pricing: { label: 'Precios' },\n      terms: { label: 'T\u00E9rminos y Vigencia' },\n      address: { label: 'Direcciones' },\n      system: { label: 'Sistema' },\n      // Nombres de secci\u00F3n del formulario en quote.view.ts (#1100)\n      quote: { label: 'Cotizaci\u00F3n' },\n      totals: { label: 'Totales' },\n      quote_terms: { label: 'T\u00E9rminos' },\n      addresses_and_notes: { label: 'Direcciones y Notas' },\n    },\n  },\n  crm_quote_line_item: {\n    _validations: {\n      discount_within_ceiling: {\n        message: 'El descuento de l\u00EDnea no puede superar el 60 %',\n      },\n      unit_price_positive: {\n        message: 'El precio de venta no puede ser negativo',\n      },\n    },\n    label: 'L\u00EDnea de Cotizaci\u00F3n',\n    pluralLabel: 'L\u00EDneas de Cotizaci\u00F3n',\n    description: 'L\u00EDneas de precio por producto dentro de una cotizaci\u00F3n',\n    fields: {\n      crm_quote: { label: 'Cotizaci\u00F3n' },\n      crm_product: { label: 'Producto' },\n      description: { label: 'Descripci\u00F3n' },\n      quantity: { label: 'Cantidad' },\n      list_price: { label: 'Precio de Lista' },\n      unit_price: { label: 'Precio de Venta' },\n      discount: { label: 'Descuento (%)' },\n      subtotal: { label: 'Subtotal' },\n      total_price: { label: 'Total' },\n      line_number: { label: 'N\u00BA de L\u00EDnea' },\n    },\n    _sections: {\n      basic: { label: 'L\u00EDnea' },\n      pricing: { label: 'Precios' },\n    },\n  },\n  crm_contract: {\n    _validations: {\n      end_after_start: {\n        message: 'La fecha de fin debe ser posterior a la de inicio',\n      },\n      contract_status_progression: {\n        message: 'Transici\u00F3n de estado de contrato no v\u00E1lida',\n      },\n    },\n    label: 'Contrato',\n    pluralLabel: 'Contratos',\n    description: 'Contratos y acuerdos legales',\n    fields: {\n      contract_number: { label: 'N\u00FAmero de Contrato' },\n      crm_account: { label: 'Cuenta' },\n      crm_contact: { label: 'Contacto Principal' },\n      crm_opportunity: { label: 'Oportunidad Relacionada' },\n      owner_id: { label: 'Propietario del Contrato' },\n      status: {\n        label: 'Estado',\n        options: {\n          draft: 'Borrador', in_approval: 'En Aprobaci\u00F3n', activated: 'Activado',\n          expired: 'Expirado', terminated: 'Rescindido',\n        },\n      },\n      contract_term_months: { label: 'Plazo del Contrato (Meses)' },\n      start_date: { label: 'Fecha de Inicio' },\n      end_date: { label: 'Fecha de Fin' },\n      contract_value: { label: 'Valor del Contrato' },\n      billing_frequency: {\n        label: 'Frecuencia de Facturaci\u00F3n',\n        options: { monthly: 'Mensual', quarterly: 'Trimestral', annually: 'Anual', one_time: 'Pago \u00DAnico' },\n      },\n      // Mismo juego de valores que `crm_quote.payment_terms` \u2014 trad\u00FAzcanse igual.\n      payment_terms: {\n        label: 'T\u00E9rminos de Pago',\n        options: {\n          net_15: 'Neto 15', net_30: 'Neto 30', net_60: 'Neto 60', net_90: 'Neto 90',\n          due_on_receipt: 'Pago a la Recepci\u00F3n',\n        },\n      },\n      auto_renewal: { label: 'Renovaci\u00F3n Autom\u00E1tica' },\n      renewal_notice_days: { label: 'Aviso de Renovaci\u00F3n (D\u00EDas)' },\n      contract_type: {\n        label: 'Tipo de Contrato',\n        options: {\n          subscription: 'Suscripci\u00F3n', service: 'Acuerdo de Servicio', license: 'Licencia',\n          partnership: 'Asociaci\u00F3n', nda: 'Acuerdo de Confidencialidad (NDA)',\n          msa: 'Acuerdo Marco de Servicios (MSA)',\n        },\n      },\n      signed_date: { label: 'Fecha de Firma' },\n      signed_by: { label: 'Firmado Por' },\n      document_url: { label: 'Documento de Contrato' },\n      special_terms: { label: 'T\u00E9rminos Especiales' },\n      description: { label: 'Descripci\u00F3n' },\n      billing_address: { label: 'Direcci\u00F3n de Facturaci\u00F3n' },\n    },\n    _views: {\n      all_contracts: { label: 'Todos los Contratos' },\n      renewal_calendar: { label: 'Calendario de Renovaci\u00F3n' },\n      contract_gantt: { label: 'Plazos del Contrato' },\n      contract_timeline: { label: 'L\u00EDnea de Tiempo' },\n    },\n    _sections: {\n      basic: { label: 'Informaci\u00F3n del Contrato' },\n      parties: { label: 'Partes' },\n      terms: { label: 'T\u00E9rminos y Fechas' },\n      value: { label: 'Valor del Contrato' },\n      status: { label: 'Estado y Aprobaci\u00F3n' },\n      renewal: { label: 'Renovaci\u00F3n' },\n      // Nombres de secci\u00F3n del formulario en contract.view.ts (#1100)\n      contract_terms: { label: 'T\u00E9rminos' },\n      signing_and_documents: { label: 'Firma y Documentos' },\n      notes: { label: 'Notas' },\n    },\n  },\n  crm_product: {\n    _validations: {\n      cost_less_than_price: {\n        message: 'El coste deber\u00EDa ser inferior al precio de lista',\n      },\n      price_positive: {\n        message: 'El precio de lista debe ser positivo',\n      },\n    },\n    label: 'Producto',\n    pluralLabel: 'Productos',\n    description: 'Productos y servicios que ofrece la empresa',\n    fields: {\n      product_code: { label: 'C\u00F3digo de Producto' },\n      display_title: { label: 'T\u00EDtulo Mostrado' },\n      name: { label: 'Nombre de Producto' },\n      description: { label: 'Descripci\u00F3n' },\n      category: {\n        label: 'Categor\u00EDa',\n        options: {\n          software: 'Software', hardware: 'Hardware', service: 'Servicio',\n          subscription: 'Suscripci\u00F3n', support: 'Soporte',\n        },\n      },\n      family: {\n        label: 'Familia de Producto',\n        options: {\n          enterprise: 'Soluciones para Gran Empresa', smb: 'Soluciones para PYMEs',\n          services: 'Servicios Profesionales', cloud: 'Servicios en la Nube',\n        },\n      },\n      list_price: { label: 'Precio de Lista' },\n      cost: { label: 'Costo' },\n      sku: { label: 'SKU' },\n      is_active: { label: 'Activo' },\n      product_manager: { label: 'Gerente de Producto' },\n      image: { label: 'Imagen de Producto' },\n      datasheet: { label: 'Ficha T\u00E9cnica' },\n    },\n    _views: {\n      all_products: { label: 'Todos los Productos' },\n      product_catalog: { label: 'Cat\u00E1logo de Productos' },\n    },\n    _sections: {\n      basic: { label: 'Informaci\u00F3n del Producto' },\n      pricing: { label: 'Precios' },\n      metadata: { label: 'Recursos' },\n      // Nombres de secci\u00F3n del formulario en product.view.ts (#1100)\n      product_info: { label: 'Informaci\u00F3n del Producto' },\n      pricing_info: { label: 'Precios' },\n      media: { label: 'Multimedia' },\n    },\n  },\n};\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/sales/translations/es-ES/objects.service.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/sales/translations/es-ES\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/sales/translations/es-ES/objects.service.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport type { ObjectTranslationData } from '@objectstack/spec/system';\n\nimport { activityActions } from './_shared';\n\n/**\n * Espa\u00F1ol (es-ES) \u2014 `objects` translations for the SERVICE family:\n * post-sale support \u2014 cases and the knowledge that deflects them.\n *\n * Roster: `crm_case`, `crm_knowledge_article`, `crm_article_feedback`.\n *\n * SPLIT AXIS (#1311): translation NAMESPACE first, then CRM DOMAIN FAMILY.\n * Everything that is not `objects` lives in `./app.ts`; `objects` \u2014 69-78% of\n * every bundle \u2014 is one file per CRM domain family, and a detail object\n * follows its master. A new row goes in the file for ITS family, never in\n * whichever file is already open: that is how one file re-grows past the 70%\n * advisory band `pnpm hygiene` prints. Full rule and rationale:\n * `src/sales/translations/es-ES.ts`.\n */\nexport const service: Record<string, ObjectTranslationData> = {\n  crm_case: {\n    _validations: {\n      resolution_required_for_closed: {\n        message: 'La resoluci\u00F3n es obligatoria al cerrar un caso',\n      },\n      escalation_reason_required: {\n        message: 'El motivo de escalado es obligatorio al escalar un caso',\n      },\n      case_status_progression: {\n        message: 'Transici\u00F3n de estado no v\u00E1lida',\n      },\n    },\n    label: 'Caso',\n    pluralLabel: 'Casos',\n    description: 'Casos de soporte y solicitudes de servicio de clientes',\n    fields: {\n      case_number: { label: 'N\u00FAmero de Caso' },\n      display_title: { label: 'T\u00EDtulo Mostrado' },\n      subject: { label: 'Asunto' },\n      description: { label: 'Descripci\u00F3n' },\n      crm_account: { label: 'Cuenta' },\n      crm_contact: { label: 'Contacto' },\n      status: {\n        label: 'Estado',\n        options: {\n          new: 'Nuevo', in_progress: 'En Curso',\n          waiting_customer: 'Esperando al Cliente', waiting_support: 'Esperando a Soporte',\n          escalated: 'Escalado', resolved: 'Resuelto', closed: 'Cerrado',\n        },\n      },\n      priority: {\n        label: 'Prioridad',\n        options: { low: 'Baja', medium: 'Media', high: 'Alta', critical: 'Cr\u00EDtica' },\n      },\n      priority_rank: { label: 'Rango de Prioridad' },\n      type: {\n        label: 'Tipo de Caso',\n        options: {\n          question: 'Consulta', problem: 'Problema',\n          feature_request: 'Solicitud de Funcionalidad', bug: 'Error',\n        },\n      },\n      // `email` y `chat` se dejan como pr\u00E9stamos: son el t\u00E9rmino habitual en\n      // espa\u00F1ol de negocios y concuerdan con `crm_campaign.channel`.\n      origin: {\n        label: 'Origen del Caso',\n        options: { email: 'Email', phone: 'Tel\u00E9fono', web: 'Web', chat: 'Chat', social_media: 'Redes Sociales' },\n      },\n      owner_id: { label: 'Propietario del Caso' },\n      closed_date: { label: 'Fecha de Cierre' },\n      first_response_date: { label: 'Fecha de Primera Respuesta' },\n      resolution_time_hours: { label: 'Tiempo de Resoluci\u00F3n (Horas)' },\n      sla_due_date: { label: 'Fecha L\u00EDmite SLA', help: 'Se fija seg\u00FAn la prioridad del caso y el Nivel de Cliente de la cuenta, en horas naturales: las noches, los fines de semana y los festivos cuentan.' },\n      is_sla_violated: { label: 'SLA Incumplido' },\n      is_escalated: { label: 'Escalado' },\n      escalated_date: { label: 'Fecha de Escalaci\u00F3n' },\n      escalation_reason: { label: 'Motivo de Escalaci\u00F3n' },\n      resolution: { label: 'Resoluci\u00F3n' },\n      resolved_by_article: { label: 'Resuelto por Art\u00EDculo', help: 'Art\u00EDculo de la base de conocimiento que resolvi\u00F3 este caso \u2014 la se\u00F1al de desv\u00EDo.' },\n      internal_notes: { label: 'Notas Internas', help: 'Notas internas no visibles para el cliente' },\n      is_closed: { label: 'Est\u00E1 Cerrado' },\n    },\n    _views: {\n      all_cases: { label: 'Todos los Casos' },\n      case_workflow: { label: 'Flujo de Servicio' },\n      sla_calendar: { label: 'Calendario SLA' },\n      case_timeline: { label: 'L\u00EDnea de Tiempo de Casos' },\n      unassigned_triage: {\n        label: 'Sin asignar \u2014 triaje',\n        emptyState: {\n          title: 'Nada pendiente de triaje',\n          message: 'Todos los casos tienen propietario. Los casos aparecen aqu\u00ED cuando llegan sin propietario \u2014 normalmente un env\u00EDo web-a-caso recibido mientras nadie ocupaba el puesto de Agente de Servicio.',\n        },\n      },\n      escalated_cases: { label: 'Casos Escalados' },\n      my_open_cases: { label: 'Mis Casos Abiertos' },\n      sla_at_risk: { label: '\u23F0 SLA en Riesgo' },\n    },\n    _sections: {\n      // Nombres de secci\u00F3n del formulario en case.view.ts (#1100).\n      case: { label: 'Caso' },\n      how_can_we_help: { label: '\u00BFC\u00F3mo podemos ayudarte?' },\n      // Claves de secci\u00F3n del objeto (case.object.ts) que usan los\n      // formularios de registro y la p\u00E1gina de detalle, cuyas secciones\n      // hacen referencia a estos grupos (#970).\n      basic: { label: 'Informaci\u00F3n del Caso' },\n      origin: { label: 'Origen y Asignaci\u00F3n' },\n      sla: { label: 'SLA y Prioridad' },\n      resolution: { label: 'Resoluci\u00F3n' },\n      escalation: { label: 'Escalaci\u00F3n' },\n      system: { label: 'Sistema' },\n    },\n    _actions: {\n      ...activityActions,\n      escalate_case: {\n        label: 'Escalar Caso',\n        confirmText: 'Esto enviar\u00E1 el caso al equipo de escalaci\u00F3n. \u00BFContinuar?',\n        successMessage: '\u00A1Caso escalado con \u00E9xito!',\n      },\n      close_case: {\n        label: 'Cerrar Caso',\n        confirmText: '\u00BFEst\u00E1 seguro de querer cerrar este caso?',\n        successMessage: '\u00A1Caso cerrado con \u00E9xito!',\n      },\n      claim_case: {\n        label: 'Tomar Caso',\n        successMessage: 'Caso tomado: ahora es suyo.',\n      },\n    },\n  },\n  crm_knowledge_article: {\n    _validations: {\n      published_requires_body: {\n        message: 'No se pueden publicar art\u00EDculos sin cuerpo.',\n      },\n      published_requires_summary: {\n        message: 'Los art\u00EDculos publicados deben tener un resumen para los resultados de b\u00FAsqueda y las citas de IA.',\n      },\n    },\n    label: 'Art\u00EDculo de Conocimiento',\n    pluralLabel: 'Base de Conocimiento',\n    description: 'Respuestas y gu\u00EDas reutilizables para clientes y agentes',\n    fields: {\n      article_number: { label: 'N.\u00BA Art\u00EDculo' },\n      display_title: { label: 'T\u00EDtulo Mostrado' },\n      title: { label: 'T\u00EDtulo' },\n      summary: { label: 'Resumen', help: 'Resumen de un p\u00E1rrafo que se muestra en los resultados de b\u00FAsqueda y en las citas de la IA.' },\n      body: { label: 'Contenido', help: 'Contenido completo del art\u00EDculo (Markdown).' },\n      category: {\n        label: 'Categor\u00EDa',\n        options: {\n          getting_started: 'Primeros pasos', how_to: 'C\u00F3mo hacerlo',\n          troubleshooting: 'Resoluci\u00F3n de problemas', billing: 'Facturaci\u00F3n', api: 'API e Integraciones',\n          release_notes: 'Notas de versi\u00F3n', policy: 'Pol\u00EDticas',\n        },\n      },\n      tags: {\n        label: 'Etiquetas',\n        options: {\n          auth: 'Autenticaci\u00F3n', sso: 'SSO', mobile: 'M\u00F3vil', email: 'Correo',\n          reports: 'Informes', performance: 'Rendimiento',\n          data_import: 'Importaci\u00F3n de datos', webhooks: 'Webhooks',\n        },\n      },\n      status: {\n        label: 'Estado',\n        options: { draft: 'Borrador', in_review: 'En revisi\u00F3n', published: 'Publicado', archived: 'Archivado' },\n      },\n      audience: {\n        label: 'Audiencia',\n        help: 'Los art\u00EDculos p\u00FAblicos son visibles en el portal de clientes; los internos solo los ven los agentes.',\n        options: { public: 'P\u00FAblico', internal: 'Interno' },\n      },\n      language: {\n        label: 'Idioma',\n        options: { en: 'Ingl\u00E9s', zh_cn: 'Chino simplificado', es_es: 'Espa\u00F1ol', ja_jp: 'Japon\u00E9s' },\n      },\n      owner_id: { label: 'Propietario' },\n      related_to_case: { label: 'Caso de origen', help: 'Caso a partir del cual se redact\u00F3 este art\u00EDculo (opcional).' },\n      published_at: { label: 'Publicado el' },\n      last_reviewed_at: { label: '\u00DAltima revisi\u00F3n' },\n      helpful_count: { label: '\u00DAtil', help: 'Recontado desde crm_article_feedback \u2014 nunca se escribe a mano.' },\n      not_helpful_count: { label: 'No \u00FAtil', help: 'Recontado desde crm_article_feedback \u2014 nunca se escribe a mano.' },\n    },\n    _views: {\n      all_articles: { label: 'Todos los art\u00EDculos' },\n      published_articles: { label: 'Publicados' },\n      my_drafts: { label: 'Mis borradores' },\n    },\n    _sections: {\n      basic: { label: 'Informaci\u00F3n del Art\u00EDculo' },\n      content: { label: 'Contenido' },\n      taxonomy: { label: 'Categorizaci\u00F3n' },\n      metrics: { label: 'Interacci\u00F3n' },\n      engagement: { label: 'Interacci\u00F3n' },\n      // Nombre de secci\u00F3n del formulario en knowledge_article.view.ts (#1100)\n      article: { label: 'Art\u00EDculo' },\n    },\n    _actions: {\n      mark_article_helpful: {\n        label: '\u00DAtil',\n        successMessage: 'Gracias \u2014 registrado como \u00FAtil.',\n      },\n      mark_article_not_helpful: {\n        label: 'No \u00FAtil',\n        successMessage: 'Gracias \u2014 registrado como no \u00FAtil.',\n      },\n    },\n  },\n  crm_article_feedback: {\n    label: 'Opini\u00F3n sobre el Art\u00EDculo',\n    pluralLabel: 'Opiniones sobre Art\u00EDculos',\n    description: 'El veredicto \u00FAtil / no \u00FAtil de un lector sobre un art\u00EDculo de la base de conocimiento',\n    fields: {\n      feedback_number: { label: 'N.\u00BA de Opini\u00F3n' },\n      owner_id: { label: 'Lector' },\n      crm_knowledge_article: { label: 'Art\u00EDculo', help: 'Art\u00EDculo de la base de conocimiento al que se refiere esta opini\u00F3n.' },\n      verdict: {\n        label: 'Veredicto',\n        options: { helpful: '\u00DAtil', not_helpful: 'No \u00FAtil' },\n      },\n      comment: { label: 'Comentario', help: 'Nota opcional que explica el veredicto \u2014 la lee el autor del art\u00EDculo.' },\n    },\n    _sections: {\n      basic: { label: 'Opini\u00F3n' },\n    },\n  },\n};\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/sales/translations/es-ES/objects.activity.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/sales/translations/es-ES\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/sales/translations/es-ES/objects.activity.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport type { ObjectTranslationData } from '@objectstack/spec/system';\n\n/**\n * Espa\u00F1ol (es-ES) \u2014 `objects` translations for the ACTIVITY family:\n * the interaction log \u2014 tasks, events, and who attended.\n *\n * Roster: `crm_task`, `crm_event`, `crm_event_attendee`.\n *\n * SPLIT AXIS (#1311): translation NAMESPACE first, then CRM DOMAIN FAMILY.\n * Everything that is not `objects` lives in `./app.ts`; `objects` \u2014 69-78% of\n * every bundle \u2014 is one file per CRM domain family, and a detail object\n * follows its master. A new row goes in the file for ITS family, never in\n * whichever file is already open: that is how one file re-grows past the 70%\n * advisory band `pnpm hygiene` prints. Full rule and rationale:\n * `src/sales/translations/es-ES.ts`.\n */\nexport const activity: Record<string, ObjectTranslationData> = {\n  crm_task: {\n    _validations: {\n      completed_date_required: {\n        message: 'La fecha de finalizaci\u00F3n es obligatoria cuando el estado es Completada',\n      },\n      recurrence_fields_required: {\n        message: 'El tipo de recurrencia es obligatorio para las tareas recurrentes',\n      },\n      related_to_required: {\n        message: 'Debe seleccionarse al menos un registro relacionado',\n      },\n    },\n    label: 'Tarea',\n    pluralLabel: 'Tareas',\n    description: 'Actividades y tareas pendientes',\n    fields: {\n      subject: { label: 'Asunto' },\n      description: { label: 'Descripci\u00F3n' },\n      status: {\n        label: 'Estado',\n        options: {\n          not_started: 'No Iniciada', in_progress: 'En Curso', waiting: 'En Espera',\n          completed: 'Completada', deferred: 'Aplazada',\n        },\n      },\n      priority: {\n        label: 'Prioridad',\n        options: { low: 'Baja', normal: 'Normal', high: 'Alta', urgent: 'Urgente' },\n      },\n      priority_rank: { label: 'Rango de Prioridad' },\n      type: {\n        label: 'Tipo de Tarea',\n        options: {\n          call: 'Llamada', email: 'Email', meeting: 'Reuni\u00F3n',\n          follow_up: 'Seguimiento', demo: 'Demostraci\u00F3n', other: 'Otro',\n        },\n      },\n      due_date: { label: 'Fecha L\u00EDmite' },\n      reminder_date: { label: 'Fecha/Hora de Recordatorio' },\n      reminder_sent: { label: 'Recordatorio Enviado' },\n      completed_date: { label: 'Fecha de Finalizaci\u00F3n' },\n      owner_id: { label: 'Asignado A' },\n      // Los valores son nombres de objeto: se reutilizan las etiquetas ya\n      // traducidas de cada objeto en este mismo paquete (igual que\n      // `crm_event.related_to_type`).\n      related_to_type: {\n        label: 'Tipo de Objeto Relacionado',\n        options: {\n          crm_account: 'Cuenta', crm_contact: 'Contacto', crm_opportunity: 'Oportunidad',\n          crm_lead: 'Prospecto', crm_case: 'Caso',\n        },\n      },\n      related_to_account: { label: 'Cuenta Relacionada' },\n      related_to_contact: { label: 'Contacto Relacionado' },\n      related_to_opportunity: { label: 'Oportunidad Relacionada' },\n      related_to_lead: { label: 'Prospecto Relacionado' },\n      related_to_case: { label: 'Caso Relacionado' },\n      is_recurring: { label: 'Tarea Recurrente' },\n      recurrence_type: {\n        label: 'Tipo de Recurrencia',\n        options: { daily: 'Diaria', weekly: 'Semanal', monthly: 'Mensual', yearly: 'Anual' },\n      },\n      recurrence_interval: { label: 'Intervalo de Recurrencia' },\n      recurrence_end_date: { label: 'Fecha Fin de Recurrencia' },\n      is_completed: { label: 'Est\u00E1 Completado' },\n      is_overdue: { label: 'Est\u00E1 Vencido' },\n      progress_percent: { label: 'Progreso (%)' },\n    },\n    _views: {\n      all_tasks: { label: 'Todas las Tareas' },\n      task_board: { label: 'Tablero de Tareas' },\n      task_calendar: { label: 'Calendario de Tareas' },\n      task_gantt: { label: 'Plan de Ejecuci\u00F3n' },\n      task_timeline: { label: 'L\u00EDnea de Tiempo' },\n      my_open_tasks: { label: 'Mis Tareas Abiertas' },\n      todays_tasks: { label: '\uD83D\uDCC5 Mis Tareas Prioritarias' },\n      overdue_tasks: { label: '\u23F0 Tareas Abiertas \u00B7 M\u00E1s Vencidas Primero' },\n    },\n    _sections: {\n      basic: { label: 'Informaci\u00F3n de la Tarea' },\n      scheduling: { label: 'Programaci\u00F3n' },\n      related: { label: 'Registros Relacionados' },\n      recurrence: { label: 'Recurrencia' },\n      effort: { label: 'Progreso y Esfuerzo' },\n      system: { label: 'Sistema' },\n      // Nombres de secci\u00F3n del formulario en task.view.ts (#1100)\n      task: { label: 'Tarea' },\n      related_records: { label: 'Registros Relacionados' },\n      recurrence_and_effort: { label: 'Recurrencia y Esfuerzo' },\n    },\n  },\n  crm_event: {\n    _validations: {\n      end_after_start: {\n        message: 'La hora de fin debe ser posterior a la de inicio',\n      },\n      related_to_required: {\n        message: 'Debe seleccionarse al menos un registro relacionado',\n      },\n    },\n    label: 'Evento',\n    pluralLabel: 'Eventos',\n    description: 'Reuniones, llamadas y otras interacciones programadas con clientes',\n    fields: {\n      subject: { label: 'Asunto' },\n      description: { label: 'Descripci\u00F3n' },\n      type: {\n        label: 'Tipo de evento',\n        options: {\n          meeting: 'Reuni\u00F3n', call: 'Llamada', demo: 'Demostraci\u00F3n',\n          webinar: 'Seminario web', onsite_visit: 'Visita presencial', other: 'Otro',\n        },\n      },\n      status: {\n        label: 'Estado',\n        options: {\n          planned: 'Planificado', held: 'Realizado', cancelled: 'Cancelado', no_show: 'No asisti\u00F3',\n        },\n      },\n      owner_id: { label: 'Asignado a' },\n      start_datetime: { label: 'Inicio' },\n      end_datetime: { label: 'Fin' },\n      all_day: { label: 'Evento de todo el d\u00EDa' },\n      duration_minutes: { label: 'Duraci\u00F3n (minutos)' },\n      location: { label: 'Ubicaci\u00F3n', help: 'Sala, direcci\u00F3n o enlace de la reuni\u00F3n' },\n      related_to_type: {\n        label: 'Tipo de registro relacionado',\n        options: {\n          crm_account: 'Cuenta', crm_contact: 'Contacto', crm_opportunity: 'Oportunidad',\n          crm_lead: 'Prospecto', crm_case: 'Caso',\n        },\n      },\n      related_to_account: { label: 'Cuenta relacionada' },\n      related_to_contact: { label: 'Contacto relacionado' },\n      related_to_opportunity: { label: 'Oportunidad relacionada' },\n      related_to_lead: { label: 'Prospecto relacionado' },\n      related_to_case: { label: 'Caso relacionado' },\n      outcome_notes: { label: 'Notas de resultado', help: 'Qu\u00E9 se acord\u00F3 y qu\u00E9 sigue' },\n    },\n    _views: {\n      all_events: { label: 'Todos los eventos' },\n      event_calendar: { label: 'Calendario de eventos' },\n      event_timeline: { label: 'Agenda del equipo' },\n      my_events: { label: 'Mi calendario' },\n      upcoming_events: { label: '\uD83D\uDCC5 Pr\u00F3ximos \u00B7 M\u00E1s cercanos primero' },\n      held_events: { label: '\u2705 Historial de interacciones' },\n    },\n    _sections: {\n      basic: { label: 'Informaci\u00F3n del Evento' },\n      schedule: { label: 'Programaci\u00F3n' },\n      related: { label: 'Registros Relacionados' },\n      outcome: { label: 'Resultado' },\n      // Nombres de secci\u00F3n del formulario en event.view.ts (#1100)\n      event: { label: 'Evento' },\n      related_records: { label: 'Registros Relacionados' },\n    },\n  },\n  crm_event_attendee: {\n    _validations: {\n      attendee_resolves: {\n        message: 'Un asistente debe indicar la parte que nombra su tipo: el tipo Contacto requiere un contacto y el tipo Externo requiere un nombre de asistente externo',\n      },\n      attendee_type_exclusive: {\n        message: 'Un asistente nombra exactamente una parte: borre las columnas que su tipo de asistente no nombra',\n      },\n    },\n    label: 'Asistente al evento',\n    pluralLabel: 'Asistentes al evento',\n    description: 'Persona invitada o presente en un evento',\n    fields: {\n      attendee_number: { label: 'N\u00FAmero de asistente' },\n      crm_event: { label: 'Evento' },\n      attendee_type: {\n        label: 'Tipo de asistente',\n        options: { contact: 'Contacto', lead: 'Prospecto', user: 'Usuario', external: 'Externo' },\n      },\n      crm_contact: { label: 'Contacto', help: 'Se rellena cuando el asistente es un contacto de cliente ya existente' },\n      crm_lead: { label: 'Prospecto', help: 'Se rellena cuando el asistente sigue siendo un prospecto sin convertir' },\n      sys_user: { label: 'Usuario', help: 'Se rellena cuando el asistente es un compa\u00F1ero de la empresa' },\n      external_name: { label: 'Asistente externo', help: 'Nombre de un asistente que no est\u00E1 en ning\u00FAn objeto del CRM: se rellena cuando el tipo de asistente es Externo' },\n      response: {\n        label: 'Respuesta',\n        options: {\n          no_response: 'Sin respuesta', accepted: 'Aceptado',\n          declined: 'Rechazado', tentative: 'Tentativo',\n        },\n      },\n      is_organizer: { label: 'Organizador' },\n      invited_date: { label: 'Invitado el' },\n    },\n    _views: {\n      all_event_attendees: { label: 'Asistentes al evento' },\n    },\n    _sections: {\n      // El ingl\u00E9s es \u00ABAttendee\u00BB / \u00ABInvitation\u00BB, no el par\n      // \u00ABBasic Information\u00BB / \u00ABResponse Tracking\u00BB de crm_campaign_member.\n      basic: { label: 'Asistente' },\n      response: { label: 'Invitaci\u00F3n' },\n      // Nombres de secci\u00F3n del formulario en event_attendee.view.ts (#1100)\n      attendee: { label: 'Asistente' },\n      invitation: { label: 'Invitaci\u00F3n' },\n    },\n  },\n};\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/sales/translations/es-ES/objects.marketing.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/sales/translations/es-ES\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/sales/translations/es-ES/objects.marketing.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport type { ObjectTranslationData } from '@objectstack/spec/system';\n\n/**\n * Espa\u00F1ol (es-ES) \u2014 `objects` translations for the MARKETING family:\n * demand generation \u2014 campaigns and their membership.\n *\n * Roster: `crm_campaign`, `crm_campaign_member`.\n *\n * SPLIT AXIS (#1311): translation NAMESPACE first, then CRM DOMAIN FAMILY.\n * Everything that is not `objects` lives in `./app.ts`; `objects` \u2014 69-78% of\n * every bundle \u2014 is one file per CRM domain family, and a detail object\n * follows its master. A new row goes in the file for ITS family, never in\n * whichever file is already open: that is how one file re-grows past the 70%\n * advisory band `pnpm hygiene` prints. Full rule and rationale:\n * `src/sales/translations/es-ES.ts`.\n */\nexport const marketing: Record<string, ObjectTranslationData> = {\n  crm_campaign: {\n    _validations: {\n      end_after_start: {\n        message: 'La fecha de fin debe ser posterior a la de inicio',\n      },\n      actual_cost_within_budget: {\n        message: 'El coste real supera el coste presupuestado',\n      },\n    },\n    label: 'Campa\u00F1a',\n    pluralLabel: 'Campa\u00F1as',\n    description: 'Campa\u00F1as e iniciativas de marketing',\n    fields: {\n      campaign_code: { label: 'C\u00F3digo de Campa\u00F1a' },\n      display_title: { label: 'T\u00EDtulo Mostrado' },\n      name: { label: 'Nombre de Campa\u00F1a' },\n      description: { label: 'Descripci\u00F3n' },\n      type: {\n        label: 'Tipo de Campa\u00F1a',\n        options: {\n          email: 'Email', webinar: 'Seminario Web', trade_show: 'Feria Comercial',\n          conference: 'Conferencia', direct_mail: 'Correo Postal', social_media: 'Redes Sociales',\n          content: 'Marketing de Contenidos', partner: 'Marketing con Socios',\n        },\n      },\n      channel: {\n        label: 'Canal Principal',\n        options: {\n          digital: 'Digital', social: 'Redes Sociales', email: 'Email',\n          events: 'Eventos', partner: 'Socios',\n        },\n      },\n      status: {\n        label: 'Estado',\n        options: {\n          planning: 'Planificaci\u00F3n', in_progress: 'En Curso',\n          completed: 'Completada', aborted: 'Cancelada',\n        },\n      },\n      start_date: { label: 'Fecha de Inicio' },\n      end_date: { label: 'Fecha de Fin' },\n      budgeted_cost: { label: 'Costo Presupuestado' },\n      actual_cost: { label: 'Costo Real' },\n      expected_revenue: { label: 'Ingresos Previstos' },\n      actual_revenue: { label: 'Ingresos Reales' },\n      target_size: { label: 'Tama\u00F1o Objetivo', help: 'N\u00FAmero objetivo de prospectos/contactos' },\n      num_sent: { label: 'Cantidad Enviada' },\n      num_responses: { label: 'N\u00FAmero de Respuestas' },\n      num_leads: { label: 'N\u00FAmero de Prospectos' },\n      num_converted_leads: { label: 'Prospectos Convertidos' },\n      num_opportunities: { label: 'Oportunidades Creadas' },\n      num_won_opportunities: { label: 'Oportunidades Ganadas' },\n      response_rate: { label: 'Tasa de Respuesta %' },\n      roi: { label: 'ROI %' },\n      owner_id: { label: 'Propietario de Campa\u00F1a' },\n      landing_page_url: { label: 'P\u00E1gina de Aterrizaje' },\n      is_active: { label: 'Activo' },\n    },\n    _views: {\n      all_campaigns: { label: 'Todas las Campa\u00F1as' },\n      campaign_gantt: { label: 'Programaci\u00F3n de Campa\u00F1as' },\n      campaign_calendar: { label: 'Calendario de Campa\u00F1as' },\n      campaign_timeline: { label: 'L\u00EDnea de Tiempo de Marketing' },\n    },\n    _sections: {\n      basic: { label: 'Informaci\u00F3n de Campa\u00F1a' },\n      schedule: { label: 'Programaci\u00F3n' },\n      budget: { label: 'Presupuesto y ROI' },\n      metrics: { label: 'Rendimiento' },\n      // El ingl\u00E9s de este grupo es \u00ABOwnership\u00BB, no \u00ABAssignment\u00BB: agrupa al\n      // propietario de la campa\u00F1a, igual que `crm_account.ownership`.\n      assignment: { label: 'Propiedad' },\n      assets: { label: 'Recursos de Campa\u00F1a' },\n    },\n    _actions: {\n      enroll_leads: {\n        label: 'Inscribir Miembros',\n        successMessage: 'Miembros elegibles inscritos en la campa\u00F1a.',\n      },\n    },\n  },\n  crm_campaign_member: {\n    _validations: {\n      lead_or_contact_required: {\n        message: 'Un miembro de campa\u00F1a debe referenciar un prospecto o un contacto',\n      },\n    },\n    label: 'Miembro de Campa\u00F1a',\n    pluralLabel: 'Miembros de Campa\u00F1a',\n    description: 'Prospectos y contactos alcanzados por una campa\u00F1a, con su estado de respuesta',\n    fields: {\n      member_number: { label: 'N\u00FAmero de Miembro' },\n      crm_campaign: { label: 'Campa\u00F1a' },\n      crm_lead: { label: 'Prospecto', help: 'Se rellena cuando el miembro era un Prospecto en el momento de la inscripci\u00F3n' },\n      crm_contact: { label: 'Contacto', help: 'Se rellena cuando el miembro es un Contacto existente' },\n      status: {\n        label: 'Estado',\n        options: {\n          sent: 'Enviado', responded: 'Respondido',\n          converted: 'Convertido', unsubscribed: 'Dado de Baja',\n        },\n      },\n      added_date: { label: 'Fecha de Alta' },\n      response_date: { label: 'Fecha de Respuesta' },\n      has_responded: { label: 'Ha Respondido' },\n    },\n    _sections: {\n      basic: { label: 'Informaci\u00F3n B\u00E1sica' },\n      response: { label: 'Seguimiento de Respuesta' },\n    },\n    _actions: {\n      mark_responded: {\n        label: 'Marcar como Respondido',\n        successMessage: 'Respuesta registrada en este miembro de campa\u00F1a.',\n      },\n    },\n  },\n};\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/sales/translations/es-ES.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/sales/translations\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/sales/translations/es-ES.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport type { TranslationData } from '@objectstack/spec/system';\n\nimport { appSurface } from './es-ES/app';\nimport { customer } from './es-ES/objects.customer';\nimport { pipeline } from './es-ES/objects.pipeline';\nimport { commerce } from './es-ES/objects.commerce';\nimport { service } from './es-ES/objects.service';\nimport { activity } from './es-ES/objects.activity';\nimport { marketing } from './es-ES/objects.marketing';\n\n/**\n * Espa\u00F1ol (es-ES) \u2014 CRM App Translations\n *\n * Per-locale file: one file per language, following the `per_locale` convention.\n *\n * SPLIT AXIS (#1311): translation NAMESPACE first, then CRM DOMAIN FAMILY.\n *\n * This bundle was one file and it had reached 88.6% of the 100KB source cap\n * `pnpm hygiene` enforces, growing ~1.2KB a day. It is now assembled from\n * `./<locale>/`, on an axis measured rather than guessed:\n *\n *   - every namespace that is NOT `objects` \u2014 `apps`, `messages`,\n *     `dashboards`, `datasets`, `pages`, and any namespace `TranslationData`\n *     gains later \u2014 lives in `app.ts`. Measured: those namespaces together\n *     are under a quarter of the bundle, and the schema bounds how many can\n *     ever arrive, so one file holds them with room left;\n *   - `objects` is 69-78% of every bundle, so it is partitioned again, one\n *     file per CRM domain family \u2014 `customer`, `pipeline`, `commerce`,\n *     `service`, `activity`, `marketing` \u2014 and a DETAIL object follows its\n *     master: line items follow their quote or opportunity,\n *     `crm_event_attendee` follows `crm_event`, `crm_campaign_member`\n *     follows `crm_campaign`, `crm_article_feedback` follows\n *     `crm_knowledge_article`.\n *\n * A namespace axis ALONE was measured and rejected: it leaves `objects` at\n * 65.7KB, 3.9KB under the advisory band, which `objects` growth crosses in\n * about nine days. The family axis puts the largest part at 24.2% of the cap.\n *\n * \u26A0\uFE0F A new object translation belongs in the file for ITS family. Do not add\n * it to whichever file is already open \u2014 that is how one file re-grows past\n * the band, which is what split this bundle in the first place.\n *\n * \u26A0\uFE0F A value used by more than one family lives in `<locale>/_shared.ts`. A\n * value used by exactly one family lives in that family's file.\n *\n * \u26A0\uFE0F The key order below is LOAD-BEARING, not cosmetic. `objectstack build`\n * serialises this object into `dist/objectstack.json` in insertion order and\n * never sorts it, so listing the rows here \u2014 rather than spreading the family\n * files \u2014 is what keeps the built artifact byte-identical across the split.\n * The order is this bundle's own historical accretion order and differs\n * between locales; reordering it rewrites the artifact.\n */\nexport const esES: TranslationData = {\n  objects: {\n    crm_account: customer.crm_account,\n    crm_contact: customer.crm_contact,\n    crm_knowledge_article: service.crm_knowledge_article,\n    crm_forecast: pipeline.crm_forecast,\n    crm_lead: pipeline.crm_lead,\n    crm_opportunity: pipeline.crm_opportunity,\n    crm_case: service.crm_case,\n    crm_contract: commerce.crm_contract,\n    crm_product: commerce.crm_product,\n    crm_quote: commerce.crm_quote,\n    crm_task: activity.crm_task,\n    crm_campaign: marketing.crm_campaign,\n    crm_event: activity.crm_event,\n    crm_event_attendee: activity.crm_event_attendee,\n    crm_article_feedback: service.crm_article_feedback,\n    crm_campaign_member: marketing.crm_campaign_member,\n    crm_opportunity_line_item: pipeline.crm_opportunity_line_item,\n    crm_quote_line_item: commerce.crm_quote_line_item,\n  },\n  ...appSurface,\n};\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/sales/translations/crm.translation.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/sales/translations\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/sales/translations/crm.translation.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport type { TranslationBundle } from '@objectstack/spec/system';\nimport { en } from './en';\nimport { zhCN } from './zh-CN';\nimport { jaJP } from './ja-JP';\nimport { esES } from './es-ES';\n\n/**\n * CRM App \u2014 Internationalization (i18n)\n *\n * Demonstrates **per-locale file splitting** convention:\n * each language is defined in its own file (`en.ts`, `zh-CN.ts`, `ja-JP.ts`, `es-ES.ts`)\n * and assembled into a single `TranslationBundle` here.\n *\n * Enterprise-grade multi-language translations covering:\n * - Core CRM objects: Account, Contact, Lead, Opportunity\n * - Select-field option labels for each object\n * - App & navigation group labels\n * - Common UI messages, validation messages\n *\n * Supported locales: en, zh-CN, ja-JP, es-ES\n */\nexport const CrmTranslations: TranslationBundle = {\n  en,\n  'zh-CN': zhCN,\n  'ja-JP': jaJP,\n  'es-ES': esES,\n};\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/sales/views/index.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/sales/views\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/sales/views/index.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\n/**\n * Sales (the app package) views barrel.\n *\n * The doctrine for this metadata type is written once, in\n * `src/sales/views/index.ts`; this file is the sales package's half of\n * the same file-by-file registration.\n */\n\nexport { LeadViews } from './lead.view';\nexport { AccountViews } from './account.view';\nexport { ContactViews } from './contact.view';\nexport { OpportunityViews } from './opportunity.view';\nexport { TaskViews } from './task.view';\nexport { EventViews } from './event.view';\nexport { EventAttendeeViews } from './event_attendee.view';\nexport { ForecastViews } from './forecast.view';\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/sales/views/lead.view.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/sales/views\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/sales/views/lead.view.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport { P } from '@objectstack/spec';\nimport { defineView } from '@objectstack/spec/ui';\nimport { DUPLICATE_OF_TYPE_AUTHORABLE_OPTIONS } from '../objects/_picklists';\n\n/**\n * \u2550\u2550\u2550 HOUSE RULE: form predicates are `record.`-bound AND TOTAL \u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\n *\n * Every `visibleOn` / `visibleWhen` below is a CEL predicate the *renderer*\n * evaluates, and it must satisfy two properties. `test/view-predicate-dialect.test.ts`\n * enforces both against the compiled stack, so you do not have to remember them.\n *\n * 1. **`record.`-bound.** The evaluation context binds field values under the\n *    `record` namespace (`buildScope` in `@objectstack/formula` binds exactly\n *    `record` / `previous` / `input` / `user` / `current_user` / `ctx` / `os`).\n *    A bare field name is an unbound identifier, so it never evaluates:\n *\n *        evaluate('status == \"unqualified\"',        { record: { status: 'new' } })\n *          \u2192 ok:false  type  \"Unknown variable: status\"       \u2190 for EVERY record\n *        evaluate('record.status == \"unqualified\"', { record: { status: 'new' } })\n *          \u2192 ok:true   false\n *\n * 2. **TOTAL** \u2014 the same `has(record.x)` rule AGENTS.md states for\n *    `validations[].condition` / `requiredWhen` / `readonlyWhen` / `visibleWhen`\n *    (#630). Prefixing alone is not enough: on a *brand-new* record the key is\n *    absent, and strict CEL aborts on the read:\n *\n *        evaluate('record.duplicate_of_type == \"crm_lead\"',                { record: {} })\n *          \u2192 ok:false  \"No such key: duplicate_of_type\"\n *        evaluate('has(record.duplicate_of_type) && record.duplicate_of_type == \"crm_lead\"',\n *                                                                          { record: {} })\n *          \u2192 ok:true   false\n *\n * Why both matter here and not only in theory (#688): the console's predicate\n * evaluation **fails OPEN** \u2014 an unevaluable `visibleWhen` defaults the field to\n * *visible*, with no diagnostic \u2014 and a visible field carries its `required: true`\n * into client-side submit validation. So a predicate that cannot answer does not\n * degrade to \"shown but optional\"; it makes the form unsatisfiable. On `crm_lead`\n * this rendered all five conditional disqualification fields at once and demanded\n * a new lead be a duplicate of *both* a lead and a contact \u2014 mutually exclusive by\n * design \u2014 so no lead could be created through the UI at all. The fail-open half\n * is tracked upstream at objectstack-ai/objectstack#5149; these predicates are the\n * half this repo owns, and they must be able to answer.\n *\n * Numeric comparisons carry `!= null` on top of `has(...)`, matching the object\n * files: `has(record.rating) && record.rating != null && record.rating >= 4`.\n * Strict CEL aborts on `dyn<null> < int`, which `has()` alone does not prevent.\n */\n\n/**\n * The duplicate-link block (#598), spread into every form that offers\n * `disqualification_reason`.\n *\n * `duplicate_disqualification_requires_survivor` on `crm_lead` rejects a lead\n * closed as \"Duplicate\" that does not name the record it duplicates and confirm\n * the match. So the same rule the `disqualification_reason` field itself follows\n * applies one level down: a form that lets a user PICK \"Duplicate\" must also let\n * them satisfy it, or the save fails with an error the form gives no way to\n * clear. Declared once and reused rather than retyped eight times \u2014 the copies\n * would drift, and a form that quietly lost the block is exactly the failure\n * this shape is meant to make impossible.\n *\n * The two lookups mirror the object's `requiredWhen` predicates: each appears\n * only when `duplicate_of_type` names its object \u2014 and now says so in the same\n * words, character for character as the `requiredWhen` on those two fields in\n * `lead.object.ts`, so the form shows a lookup exactly when the server will\n * demand it. `test/view-predicate-dialect.test.ts` pins the two together.\n */\nconst DUPLICATE_LINK_FIELDS = [\n  {\n    field: 'duplicate_of_type',\n    required: true,\n    // The picker offers the AUTHORABLE half of the vocabulary only (#1164).\n    // `crm_lead.duplicate_of_type` also accepts `erased`, a tombstone\n    // `lead_duplicate_check` stamps when the engine's reference cleanup nulls\n    // the pointer \u2014 \"confirmed duplicate of a record that has since been\n    // erased\". Nobody authors that: it is an observation about a deletion that\n    // already happened, and offering it would let a reviewer close a lead as a\n    // duplicate of nothing while satisfying every rule that exists to stop\n    // exactly that. Narrowing here rather than deleting the value is the point\n    // \u2014 the record can still SAY it, and the field keeps its label in all four\n    // locales, so a tombstoned lead reads as \"Erased Record\" on the detail page\n    // instead of as a raw enum nobody can explain.\n    //\n    // Spread from `_picklists.ts` rather than retyped: the authorable set is\n    // the source both lists derive from, so a future object type added there\n    // reaches this picker automatically and the tombstone never can.\n    options: [...DUPLICATE_OF_TYPE_AUTHORABLE_OPTIONS],\n    visibleOn: P`has(record.disqualification_reason) && record.disqualification_reason == \"duplicate\"`,\n  },\n  {\n    field: 'duplicate_of_lead',\n    required: true,\n    visibleOn: P`has(record.duplicate_of_type) && record.duplicate_of_type == \"crm_lead\"`,\n  },\n  {\n    field: 'duplicate_of_contact',\n    required: true,\n    visibleOn: P`has(record.duplicate_of_type) && record.duplicate_of_type == \"crm_contact\"`,\n  },\n  {\n    field: 'duplicate_status',\n    required: true,\n    visibleOn: P`has(record.disqualification_reason) && record.disqualification_reason == \"duplicate\"`,\n    helpText: 'Confirmed means a human checked the two records and they are the same person.',\n  },\n];\n\n/**\n * Lead Views - Comprehensive UI Showcase\n * \n * This file demonstrates:\n * 1. All 6 FormView layout types (simple, tabbed, wizard, split, drawer, modal)\n * 2. Section features (collapsible, 1-4 column layouts)\n * 3. Field-level controls (readonly, required, hidden, span, visibleOn, dependsOn, custom widget)\n * 4. Multiple named formViews for different scenarios\n * 5. Various list view types\n */\nexport const LeadViews = defineView({\n  /**\n   * Default List View - Grid with Advanced Features\n   */\n  list: {\n    type: 'grid',\n    name: 'all_leads',\n    label: 'All Leads',\n    userActions: { editInline: true },\n    data: {\n      provider: 'object',\n      object: 'crm_lead',\n    },\n    \n    // Column Configuration with Enhanced Features\n    columns: [\n      {\n        // One name column, not two. Splitting first/last spent 300px to say\n        // what \"Alice Martinez\" says in one, and hung the record link off the\n        // given name alone \u2014 so opening a person meant aiming at their first\n        // name specifically.\n        field: 'full_name',\n        label: 'Name',\n        width: 200,\n        sortable: true,\n        link: true, // Primary navigation link\n      },\n      {\n        field: 'company',\n        label: 'Company',\n        width: 200,\n        sortable: true,\n      },\n      {\n        field: 'email',\n        label: 'Email',\n        width: 200,\n      },\n      {\n        field: 'status',\n        label: 'Status',\n        width: 120,\n        sortable: true,\n      },\n      {\n        field: 'rating',\n        label: 'Score',\n        width: 100,\n        align: 'center',\n      },\n      {\n        field: 'lead_source',\n        label: 'Source',\n        width: 120,\n      },\n      // REQ-0005 acceptance 1: what the prospect wants and what it is worth,\n      // on the roster a rep opens every morning. Columns are also what the\n      // list's own filter and grouping controls offer, which is what makes the\n      // two FILTERABLE and GROUPABLE here rather than only readable \u2014 the same\n      // reading `contact.view.ts` records for the buying-centre columns.\n      // `need_type` is single-valued for exactly that reason (see\n      // `_picklists.ts`): a grouped list answers with one aggregate per raw\n      // stored value, so a multi-valued column would group by the combination.\n      {\n        field: 'need_type',\n        label: 'Need Type',\n        width: 160,\n        sortable: true,\n      },\n      {\n        field: 'estimated_amount',\n        label: 'Est. Amount',\n        width: 130,\n        align: 'right',\n        sortable: true,\n      },\n      {\n        field: 'owner_id',\n        label: 'Owner',\n        width: 150,\n      },\n    ],\n    \n    sort: [\n      { field: 'created_at', order: 'desc' }\n    ],\n    \n    // A row click opens the record page. There is deliberately no\n    // `navigation.view` here: measured in the browser on console 17.3.0\n    // (#1716), the key is not resolved as a form-view name. The navigation\n    // hook reads it into the SECOND argument of `onNavigate` \u2014 the slot that\n    // otherwise carries the literal mode string, `r(t, d ?? 'view')` \u2014 so it\n    // named nothing and selected nothing. The record page here is rendered by\n    // `lead_detail_page` (`src/sales/pages/lead_detail.page.ts`), not by a named\n    // form view, and clicking a row behaved identically with the key present,\n    // with it absent, and on a list that never declared it. `detail_form`\n    // below stays: it is this file's one TABBED layout example, and it was\n    // already reachable by no path.\n    navigation: {\n      mode: 'page',\n    },\n    \n    // `convert_lead` / `schedule_followup` declare `locations: ['list_item']`\n    // and are auto-injected into the menu. Do not add strings here: the legacy\n    // rowActions surface only dispatches defined stack actions.\n    // Built-in `exportOptions` covers CSV export; no export action needed.\n    bulkActions: ['create_campaign'],\n    \n    // Features\n    pagination: { pageSize: 25, pageSizeOptions: [10, 25, 50, 100] },\n    rowHeight: 'medium',\n    exportOptions: { formats: ['csv', 'xlsx'] },\n    \n    // Empty State\n    emptyState: {\n      title: 'No Leads Yet',\n      message: 'Get started by creating your first lead',\n      icon: 'user-plus',\n    },\n  },\n  \n  /**\n   * Default Form View - SIMPLE Layout\n   * Basic sectioned form with collapsible sections and column layouts\n   */\n  form: {\n    type: 'simple',\n    \n    sections: [\n      {\n        name: 'contact_information',\n        label: 'Contact Information',\n        collapsible: true,\n        collapsed: false,\n        columns: 2, // 2-column layout\n        fields: [\n          {\n            field: 'salutation',\n          },\n          {\n            field: 'first_name',\n            required: true,\n          },\n          {\n            field: 'last_name',\n            required: true,\n            span: 'full',\n          },\n          'company',\n          'title',\n          'email',\n          'phone',\n          'mobile',\n          'website',\n        ],\n      },\n      {\n        name: 'lead_classification',\n        label: 'Lead Classification',\n        collapsible: true,\n        collapsed: false,\n        columns: 3, // 3-column layout\n        fields: [\n          {\n            field: 'status',\n            required: true,\n          },\n          {\n            field: 'rating',\n            widget: 'star_rating', // Custom widget\n          },\n          'lead_source',\n          'industry',\n          // Offered, \u26D4 not `required` (#2097): an insert that leaves it empty is\n          // stamped to the creator by the platform (see `lead.hook.ts`), so a\n          // rep's new lead is theirs without a pick, and a manager can still\n          // choose another owner. `required` blocked that save client-side.\n          'owner_id',\n          // `disqualification_reason` is enforced by the\n          // `disqualification_reason_required` validation on crm_lead, so every\n          // form that lets a user pick \"Unqualified\" must also offer the reason\n          // \u2014 otherwise the save fails with an error the form gives you no way\n          // to clear. Hidden until it applies.\n          {\n            field: 'disqualification_reason',\n            required: true,\n            visibleOn: P`has(record.status) && record.status == \"unqualified\"`,\n          },\n          // REQ-0005 step 6: \u300C\u586B\u5199\u2026\u9700\u6C42\u7C7B\u578B\u2026\u9884\u8BA1\u91D1\u989D\u300D. A rep types these at\n          // intake, so they need an authoring surface \u2014 and this form IS the\n          // create dialog (`RecordFormPage` and `useActionModal` both resolve\n          // `view.form ?? view.formViews?.default`, see `case.view.ts`).\n          //\n          // \u26A0\uFE0F Named rather than reached through a group reference, and the\n          // AGENTS.md ladder's rung 3 asks for the reason in writing. Both\n          // fields declare `group: 'qualification'` on the object, so every\n          // DERIVED surface \u2014 the page synthesizer, an auto-derived form \u2014\n          // already carries them from `fieldGroups` alone with nothing authored.\n          // This form is not one of those: it authors `sections`, and an\n          // authored `sections` array wins outright over the auto-derived path.\n          // The rung-2 fix, a `{ group: 'qualification' }` section, cannot be\n          // used HERE specifically: this section is a CURATED cross-group set,\n          // not a mirror of that group. It already names four of the group's\n          // members with per-field overrides a group reference cannot carry\n          // (`status` required, `rating`'s star widget, and\n          // `disqualification_reason`'s `required` + `visibleOn` directly\n          // above), and it borrows `industry` and `owner_id` from two other\n          // groups. Adding a group reference beside it would render those four\n          // a second time and pull in `next_followup_date` /\n          // `last_contacted_date`, which are machine-written and deliberately\n          // absent from every form. \u21D2 The customer need is real, the group\n          // reference genuinely cannot express it, and the two lines below are\n          // what that leaves.\n          'need_type',\n          'estimated_amount',\n          ...DUPLICATE_LINK_FIELDS,\n        ],\n      },\n      {\n        name: 'company_information',\n        label: 'Company Information',\n        collapsible: true,\n        collapsed: true, // Collapsed by default\n        columns: 2,\n        fields: [\n          'annual_revenue',\n          'number_of_employees',\n        ],\n      },\n      {\n        name: 'address',\n        label: 'Address',\n        collapsible: true,\n        collapsed: true,\n        columns: 2,\n        // `crm_lead` stores the location in one composite `Field.address`;\n        // the discrete street/city/state/postal_code/country columns this\n        // section used to list do not exist on the object, so the whole\n        // section rendered blank.\n        fields: [\n          {\n            field: 'address',\n            span: 'full',\n          },\n        ],\n      },\n      {\n        name: 'additional_information',\n        label: 'Additional Information',\n        collapsible: true,\n        collapsed: true,\n        columns: 1, // Single column for text areas\n        fields: [\n          'description',\n          'notes',\n        ],\n      },\n      {\n        name: 'privacy',\n        label: 'Privacy',\n        collapsible: true,\n        collapsed: true,\n        columns: 2,\n        fields: [\n          'do_not_call',\n          'email_opt_out',\n        ],\n      },\n    ],\n  },\n  \n  /**\n   * Additional Named List Views\n   */\n  listViews: {\n    // Declaration order IS tab order in the console. These three working\n    // queues used to sit AFTER the kanban / calendar / gallery views, which\n    // pushed all of them into the \"3 more\" overflow menu \u2014 so the one screen\n    // a rep opens this list for was the one they had to go hunting for, while\n    // three presentation modes held the front row.\n\n    /**\n     * My Leads \u2014 a rep's own queue, hottest first.\n     */\n    my_leads: {\n      name: 'my_leads',\n      type: 'grid',\n      label: 'My Leads',\n      userActions: { editInline: true },\n      data: {\n        provider: 'object',\n        object: 'crm_lead',\n      },\n      columns: ['full_name', 'company', 'email', 'status', 'rating'],\n      filter: [\n        { field: 'owner_id', operator: 'equals', value: '{current_user_id}' },\n      ],\n      sort: [\n        { field: 'rating', order: 'desc' },\n        { field: 'created_at', order: 'desc' }\n      ],\n    },\n\n    /**\n     * Hot Leads \u2014 the working queue for the leads routing declared HOT.\n     *\n     * \"Hot\" is defined in exactly ONE place: the `lead_assignment` flow's\n     * `check_hot` decision (edge `e2`, `record.rating >= 4`). Crossing that\n     * line is what stamps the 1-day follow-up SLA and fires the \"Hot lead \u2014\n     * assign within 24h\" alert at the owner, so this queue must hold precisely\n     * the leads that alert is about. (An earlier comment here credited a\n     * flagging workflow that has never existed in this repo \u2014 dead name\n     * removed, the routing flow is the producer.)\n     *\n     * The cut was `rating >= 4.5` (#766). `rating` is a WHOLE-star field \u2014\n     * `lead.hook.ts` rounds its computed score (\"round to WHOLE stars\"), the\n     * `star_rating` widget offers nothing finer, and the one seeded 4.5 was\n     * deleted for the same reason (#591) \u2014 so `>= 4.5` meant `== 5` on every\n     * row that can actually exist. A 4-star lead was routed hot, alerted on,\n     * and then missing from the queue its owner was sent to.\n     *\n     * Sharing the population with \"High Priority\" is the deliberate cost of\n     * having one definition of hot, not an oversight: both views now show\n     * rating >= 4, still New or Contacted. What differs is what they are FOR.\n     * Hot Leads is the work order \u2014 sorted by next-follow-up (the SLA that\n     * routing just stamped), with phone, email and owner on the row so it can\n     * be dialled top to bottom. High Priority is the scan list \u2014 score-tinted\n     * rows and lead source, no SLA column, no time ordering. A 5-star-only\n     * queue, if it is ever a real need, gets its own view under its own name\n     * instead of squatting on \"Hot\".\n     *\n     * `test/hot-lead-threshold-parity.test.ts` derives this threshold and the\n     * flow's from the metadata and fails if they drift apart again.\n     */\n    hot_leads: {\n      name: 'hot_leads',\n      type: 'grid',\n      label: '\uD83D\uDD25 Hot Leads',\n      userActions: { editInline: true },\n      data: { provider: 'object', object: 'crm_lead' },\n      columns: ['full_name', 'company', 'phone', 'email', 'rating', 'next_followup_date', 'owner_id'],\n      // Same rating cut as the `lead_assignment` hot branch, scoped to the\n      // statuses still worth working. (Operator-only filters; the view runtime\n      // does not resolve date template strings.)\n      filter: [\n        { field: 'rating', operator: 'greater_than_or_equal', value: 4 },\n        { field: 'status', operator: 'in', value: ['new', 'contacted'] },\n      ],\n      sort: [{ field: 'next_followup_date', order: 'asc' }],\n    },\n\n    /**\n     * High Priority Leads\n     */\n    high_priority: {\n      name: 'high_priority',\n      type: 'grid',\n      label: 'High Priority',\n      userActions: { editInline: true },\n      data: {\n        provider: 'object',\n        object: 'crm_lead',\n      },\n      columns: ['full_name', 'company', 'email', 'status', 'rating', 'lead_source'],\n      filter: [\n        { field: 'rating', operator: 'greater_than_or_equal', value: 4 },\n        { field: 'status', operator: 'in', value: ['new', 'contacted'] },\n      ],\n      rowColor: {\n        field: 'rating',\n        colors: {\n          '5': 'green',\n          '4': 'orange',\n        },\n      },\n    },\n\n    /**\n     * Suspected Duplicates \u2014 the review queue behind the intake flag (#598).\n     *\n     * `lead_duplicate_check` marks a re-captured email `suspected` and links it\n     * to the record it repeats. Without a place to SEE that set, the flag would\n     * be a column nobody reads: the reviewer opens this queue, compares the two\n     * records, and either clears the flag or disqualifies the lead as a\n     * confirmed duplicate. `confirmed` rows drop out of the queue, so it drains.\n     */\n    suspected_duplicates: {\n      name: 'suspected_duplicates',\n      type: 'grid',\n      label: 'Suspected Duplicates',\n      userActions: { editInline: true },\n      data: { provider: 'object', object: 'crm_lead' },\n      columns: [\n        'full_name', 'company', 'email',\n        'duplicate_of_type', 'duplicate_of_lead', 'duplicate_of_contact',\n        'status', 'owner_id',\n      ],\n      filter: [\n        { field: 'duplicate_status', operator: 'equals', value: 'suspected' },\n      ],\n      // Oldest suspicion first: an unreviewed duplicate is a second rep working\n      // the same person, so the queue is worked front to back.\n      sort: [{ field: 'created_at', order: 'asc' }],\n      emptyState: {\n        title: 'No Suspected Duplicates',\n        message: 'Nothing to review \u2014 every re-captured email has been checked.',\n        icon: 'copy',\n      },\n    },\n\n    /**\n     * Kanban Board View\n     */\n    kanban_by_status: {\n      name: 'kanban_by_status',\n      type: 'kanban',\n      label: 'Lead Pipeline',\n      data: {\n        provider: 'object',\n        object: 'crm_lead',\n      },\n      columns: ['first_name', 'last_name', 'company', 'email'],\n      kanban: {\n        groupByField: 'status',\n        summarizeField: 'annual_revenue',\n        columns: ['first_name', 'last_name', 'company', 'rating'],\n      },\n      navigation: {\n        mode: 'drawer', // Open in drawer instead of new page\n        width: '600px',\n      },\n    },\n    \n    /**\n     * Calendar View\n     */\n    calendar_by_created: {\n      name: 'calendar_by_created',\n      type: 'calendar',\n      label: 'Lead Calendar',\n      data: {\n        provider: 'object',\n        object: 'crm_lead',\n      },\n      columns: ['first_name', 'last_name', 'company'],\n      calendar: {\n        startDateField: 'created_at',\n        titleField: 'company',\n        colorField: 'status',\n      },\n    },\n    \n    /**\n     * Gallery/Card View\n     */\n    gallery_view: {\n      name: 'gallery_view',\n      type: 'gallery',\n      label: 'Lead Cards',\n      data: {\n        provider: 'object',\n        object: 'crm_lead',\n      },\n      columns: ['first_name', 'last_name', 'company', 'email', 'status'],\n      gallery: {\n        cardSize: 'medium',\n        titleField: 'company',\n        visibleFields: ['first_name', 'last_name', 'email', 'phone', 'status', 'rating'],\n      },\n    },\n    \n  },\n\n  /**\n   * Additional Named Form Views - Demonstrating All 6 Layout Types\n   *\n   * One example per layout type. The SIMPLE one is the default `form`\n   * above, so this block carries the other five, plus the public and the\n   * conditional-visibility examples. Every layout is demonstrated exactly\n   * once across the file: each entry below is the only example of its own.\n   */\n  formViews: {\n    /**\n     * 2. TABBED Layout\n     * Organize complex forms with tabs\n     */\n    detail_form: {\n      type: 'tabbed',\n      sections: [\n        {\n          name: 'general',\n          label: 'General',\n          columns: 2,\n          fields: [\n            'salutation',\n            'first_name',\n            'last_name',\n            'company',\n            'title',\n            'email',\n            'phone',\n            'mobile',\n          ],\n        },\n        {\n          name: 'qualification',\n          label: 'Qualification',\n          columns: 2,\n          fields: [\n            { field: 'status', required: true },\n            { field: 'rating', widget: 'star_rating' },\n            'lead_source',\n            'industry',\n            'annual_revenue',\n            'number_of_employees',\n            // See the default form: `unqualified` requires a reason.\n            {\n              field: 'disqualification_reason',\n              required: true,\n              visibleOn: P`has(record.status) && record.status == \"unqualified\"`,\n            },\n            ...DUPLICATE_LINK_FIELDS,\n          ],\n        },\n        {\n          name: 'address',\n          label: 'Address',\n          columns: 2,\n          // Single composite `Field.address` \u2014 see the note on the default\n          // form's Address section.\n          fields: [\n            { field: 'address', span: 'full' },\n          ],\n        },\n        {\n          name: 'details',\n          label: 'Details',\n          columns: 1,\n          fields: [\n            'description',\n            'notes',\n            'do_not_call',\n            'email_opt_out',\n          ],\n        },\n      ],\n    },\n    \n    /**\n     * 3. WIZARD Layout\n     * Step-by-step guided process\n     */\n    lead_conversion_wizard: {\n      type: 'wizard',\n      data: {\n        provider: 'object',\n        object: 'crm_lead',\n      },\n      sections: [\n        {\n          name: 'step_1_contact_details',\n          label: 'Step 1: Contact Details',\n          columns: 2,\n          fields: [\n            { field: 'first_name', required: true, readonly: true },\n            { field: 'last_name', required: true, readonly: true },\n            { field: 'email', readonly: true, span: 'full' },\n            'phone',\n            'mobile',\n          ],\n        },\n        {\n          name: 'step_2_company_information',\n          label: 'Step 2: Company Information',\n          columns: 2,\n          fields: [\n            { field: 'company', required: true, readonly: true },\n            'title',\n            'industry',\n            'annual_revenue',\n            'number_of_employees',\n            'website',\n          ],\n        },\n        {\n          name: 'step_3_qualification',\n          label: 'Step 3: Qualification',\n          columns: 2,\n          fields: [\n            { field: 'status', required: true },\n            // See the default form: `unqualified` requires a reason. The status\n            // is editable in this step, so the wizard can land there too.\n            {\n              field: 'disqualification_reason',\n              required: true,\n              visibleOn: P`has(record.status) && record.status == \"unqualified\"`,\n            },\n            ...DUPLICATE_LINK_FIELDS,\n            { field: 'rating', widget: 'star_rating' },\n            'lead_source',\n            {\n              field: 'owner_id',\n              // Conditional visibility. `!= null` on top of `has(...)`: strict\n              // CEL aborts on `dyn<null> < int`, which `has()` alone allows.\n              visibleOn: P`has(record.rating) && record.rating != null && record.rating >= 4`,\n            },\n          ],\n        },\n        {\n          name: 'step_4_review_and_convert',\n          label: 'Step 4: Review & Convert',\n          columns: 1,\n          fields: [\n            {\n              field: 'description',\n              helpText: 'Review all information before converting to Account and Contact',\n            },\n          ],\n        },\n      ],\n    },\n    \n    /**\n     * 4. SPLIT Layout\n     * Master-detail split view\n     */\n    split_edit: {\n      type: 'split',\n      data: {\n        provider: 'object',\n        object: 'crm_lead',\n      },\n      sections: [\n        {\n          name: 'primary_information',\n          label: 'Primary Information',\n          columns: 1,\n          fields: [\n            'first_name',\n            'last_name',\n            'company',\n            'email',\n            { field: 'status', required: true },\n            'owner_id',\n            // See the default form: `unqualified` requires a reason.\n            {\n              field: 'disqualification_reason',\n              required: true,\n              visibleOn: P`has(record.status) && record.status == \"unqualified\"`,\n            },\n            ...DUPLICATE_LINK_FIELDS,\n          ],\n        },\n        {\n          name: 'extended_details',\n          label: 'Extended Details',\n          columns: 2,\n          fields: [\n            'phone',\n            'mobile',\n            'title',\n            'industry',\n            'lead_source',\n            { field: 'rating', widget: 'star_rating' },\n            'annual_revenue',\n            'number_of_employees',\n          ],\n        },\n      ],\n    },\n    \n    /**\n     * 5. DRAWER Layout\n     * Side panel form (typically opened from list view)\n     */\n    quick_edit_drawer: {\n      type: 'drawer',\n      data: {\n        provider: 'object',\n        object: 'crm_lead',\n      },\n      sections: [\n        {\n          name: 'quick_edit',\n          label: 'Quick Edit',\n          columns: 1, // Drawers typically use single column\n          fields: [\n            { field: 'first_name', required: true },\n            { field: 'last_name', required: true },\n            'company',\n            'email',\n            'phone',\n            { field: 'status', required: true },\n            { field: 'rating', widget: 'star_rating' },\n            'lead_source',\n            {\n              field: 'owner_id',\n              // Only show owner after initial contact. A record with no status\n              // yet has not been contacted, so `!isBlank` keeps the blank case\n              // on the \"hidden\" side rather than letting `null != \"new\"` show it.\n              visibleOn: P`has(record.status) && !isBlank(record.status) && record.status != \"new\"`,\n            },\n            // See the default form: `unqualified` requires a reason.\n            {\n              field: 'disqualification_reason',\n              required: true,\n              visibleOn: P`has(record.status) && record.status == \"unqualified\"`,\n            },\n            ...DUPLICATE_LINK_FIELDS,\n          ],\n        },\n      ],\n    },\n    \n    /**\n     * 6. MODAL Layout\n     * Dialog-based form for quick actions\n     */\n    status_update_modal: {\n      type: 'modal',\n      data: {\n        provider: 'object',\n        object: 'crm_lead',\n      },\n      sections: [\n        {\n          name: 'update_lead_status',\n          label: 'Update Lead Status',\n          columns: 1,\n          fields: [\n            { field: 'first_name', readonly: true },\n            { field: 'last_name', readonly: true },\n            { field: 'company', readonly: true },\n            { \n              field: 'status', \n              required: true,\n              helpText: 'Select the new status for this lead',\n            },\n            {\n              field: 'rating',\n              widget: 'star_rating',\n              // Only show rating for qualified leads\n              visibleOn: P`has(record.status) && record.status == \"qualified\"`,\n            },\n            // The reason picklist, not just free-text notes: it is what the\n            // `disqualification_reason_required` validation checks, and this\n            // modal is the main place a rep flips a lead to Unqualified.\n            {\n              field: 'disqualification_reason',\n              required: true,\n              visibleOn: P`has(record.status) && record.status == \"unqualified\"`,\n            },\n            ...DUPLICATE_LINK_FIELDS,\n            {\n              field: 'notes',\n              placeholder: 'Add notes about this status change',\n              // Free-text context alongside the reason\n              visibleOn: P`has(record.status) && record.status == \"unqualified\"`,\n            },\n          ],\n        },\n      ],\n    },\n    \n    /**\n     * 7. PUBLIC / ANONYMOUS \u2014 \"Web-to-Lead\"\n     *\n     * Airtable-style public form hosted at `/forms/contact-us`. Embeddable\n     * via iframe on a marketing site. Guests can ONLY submit (insert) \u2014 the\n     * `guest_portal` profile denies read/edit/delete on `crm_lead`.\n     *\n     * Fields not on the form (status, lead_source, owner_id, rating) are stamped\n     * by the `lead_automation` hook in `lead.hook.ts` after a guest submission.\n     */\n    web_to_lead: {\n      type: 'simple',\n      data: {\n        provider: 'object',\n        object: 'crm_lead',\n      },\n      sections: [\n        {\n          name: 'tell_us_about_yourself',\n          label: 'Tell us about yourself',\n          columns: 2,\n          fields: [\n            { field: 'first_name', required: true },\n            { field: 'last_name',  required: true },\n            { field: 'email',      required: true, span: 'full' },\n            'phone',\n            'title',\n          ],\n        },\n        {\n          name: 'about_your_company',\n          label: 'About your company',\n          columns: 2,\n          fields: [\n            { field: 'company', required: true, span: 'full' },\n            'website',\n            'industry',\n            'number_of_employees',\n            'annual_revenue',\n          ],\n        },\n        {\n          name: 'how_can_we_help',\n          label: 'How can we help?',\n          columns: 1,\n          fields: [\n            {\n              field: 'description',\n              required: true,\n              placeholder: 'Briefly describe what you are looking for...',\n              helpText: 'A sales representative will get back to you within one business day.',\n            },\n          ],\n        },\n      ],\n      sharing: {\n        enabled: true,\n        allowAnonymous: true,\n        publicLink: '/forms/contact-us',\n      },\n    },\n\n    /**\n     * Advanced Example: Conditional Field Visibility & Dependencies\n     */\n    advanced_conditional: {\n      type: 'simple',\n      data: {\n        provider: 'object',\n        object: 'crm_lead',\n      },\n      sections: [\n        {\n          name: 'lead_information',\n          label: 'Lead Information',\n          columns: 2,\n          fields: [\n            'first_name',\n            'last_name',\n            'company',\n            'email',\n            'status',\n            'lead_source',\n            {\n              field: 'rating',\n              widget: 'star_rating',\n              // Only show after first contact \u2014 see the drawer form's note on\n              // why blank stays on the \"hidden\" side.\n              visibleOn: P`has(record.status) && !isBlank(record.status) && record.status != \"new\"`,\n            },\n            {\n              field: 'industry',\n              dependsOn: 'company', // Industry options depend on company\n            },\n            {\n              field: 'annual_revenue',\n              // Only for qualified leads\n              visibleOn: P`has(record.rating) && record.rating != null && record.rating >= 3`,\n            },\n            {\n              field: 'number_of_employees',\n              visibleOn: P`has(record.rating) && record.rating != null && record.rating >= 3`,\n            },\n            {\n              field: 'owner_id',\n              required: true,\n              visibleOn: P`has(record.status) && (record.status == \"contacted\" || record.status == \"qualified\")`,\n            },\n            // See the default form: `unqualified` requires a reason.\n            {\n              field: 'disqualification_reason',\n              required: true,\n              visibleOn: P`has(record.status) && record.status == \"unqualified\"`,\n            },\n            ...DUPLICATE_LINK_FIELDS,\n            {\n              field: 'notes',\n              span: 'full',\n              required: true,\n              // Require explanation for unqualified\n              visibleOn: P`has(record.status) && record.status == \"unqualified\"`,\n            },\n          ],\n        },\n        {\n          name: 'address_information',\n          label: 'Address Information',\n          collapsible: true,\n          collapsed: true,\n          columns: 2,\n          // Single composite `Field.address` \u2014 the discrete street/city/state/\n          // postal_code/country columns do not exist on crm_lead.\n          fields: [\n            { field: 'address', span: 'full' },\n          ],\n        },\n        {\n          name: 'privacy_preferences',\n          label: 'Privacy Preferences',\n          collapsible: true,\n          collapsed: true,\n          columns: 2,\n          fields: [\n            {\n              field: 'do_not_call',\n              helpText: 'Check if this lead has requested not to be called',\n            },\n            {\n              field: 'email_opt_out',\n              helpText: 'Check if this lead has opted out of email communications',\n            },\n          ],\n        },\n      ],\n    },\n  },\n});\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/sales/views/account.view.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/sales/views\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/sales/views/account.view.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport { defineView } from '@objectstack/spec/ui';\n\n/**\n * Account Views\n *\n *   \u2022 grid    \u2014 primary list with revenue / industry summaries\n *   \u2022 gallery \u2014 branded account cards with brand_color highlights\n *   \u2022 map     \u2014 geospatial distribution (uses office_location)\n */\nexport const AccountViews = defineView({\n  list: {\n    type: 'grid',\n    name: 'all_accounts',\n    label: 'All Accounts',\n    userActions: { editInline: true },\n    data: { provider: 'object', object: 'crm_account' },\n    columns: [\n      { field: 'name', width: 240, sortable: true, link: true, pinned: 'left' },\n      { field: 'industry', width: 140, sortable: true },\n      { field: 'type', width: 130 },\n      { field: 'annual_revenue', width: 160, align: 'right', summary: 'sum' },\n      { field: 'number_of_employees', width: 130, align: 'right', summary: 'avg' },\n      { field: 'health_score', width: 140 },\n    ],\n    sort: [{ field: 'annual_revenue', order: 'desc' }],\n    rowColor: { field: 'is_active', colors: { true: 'green', false: 'slate' } },\n    selection: { type: 'multiple' },\n    pagination: { pageSize: 50, pageSizeOptions: [25, 50, 100] },\n    exportOptions: { formats: ['csv', 'xlsx'] },\n    compactToolbar: true,\n    bulkActionDefs: [\n      {\n        name: 'update_tier',\n        label: 'Update Tier',\n        icon: 'tag',\n        operation: 'update',\n        params: [\n          {\n            name: 'tier',\n            label: 'Customer Tier',\n            type: 'select',\n            required: true,\n            options: [\n              { label: 'Strategic',  value: 'strategic'  },\n              { label: 'Enterprise', value: 'enterprise' },\n              { label: 'Mid-Market', value: 'mid_market' },\n              { label: 'SMB',        value: 'smb'        },\n            ],\n          },\n        ],\n        confirmText: 'Update tier on {{count}} account(s) to {{tier}}?',\n      },\n      {\n        name: 'transfer_owner',\n        label: 'Transfer Owner',\n        icon: 'user-check',\n        operation: 'update',\n        params: [\n          {\n            name: 'owner_id',\n            label: 'New Owner',\n            type: 'lookup',\n            // The platform registers `sys_user` \u2014 `user` matches no object and\n            // rendered an empty picker.\n            object: 'sys_user',\n            required: true,\n          },\n        ],\n        confirmText: 'Transfer ownership of {{count}} account(s)?',\n      },\n      {\n        name: 'delete',\n        label: 'Delete',\n        icon: 'trash-2',\n        variant: 'danger',\n        operation: 'delete',\n        confirmText: 'Permanently delete {{count}} account(s)? This cannot be undone.',\n        confirmLabel: 'Delete',\n      },\n    ],\n    appearance: {\n      showDescription: true,\n      allowedVisualizations: ['grid', 'gallery', 'map'],\n    },\n  },\n\n  listViews: {\n    /** Branded account cards */\n    account_gallery: {\n      name: 'account_gallery',\n      type: 'gallery',\n      label: 'Account Cards',\n      data: { provider: 'object', object: 'crm_account' },\n      // `logo` rides in the projection for the same reason the timeline view\n      // carries its date fields: the list data source projects the configured\n      // columns, and `coverField` reads off that projection.\n      columns: ['name', 'industry', 'annual_revenue', 'phone', 'logo'],\n      gallery: {\n        // The card art this view was named for. \"Branded account cards\" had a\n        // brand COLOUR and no brand IMAGE \u2014 `crm_account.logo` is the object's\n        // only image field and nothing displayed it, so every card drew the\n        // same blank cover. `coverFit` is left unstated: the schema's default\n        // is the crop these cards want, and materialising a default rewrites\n        // \"the author said nothing\" into \"the author asked for this\".\n        coverField: 'logo',\n        cardSize: 'medium',\n        titleField: 'name',\n        visibleFields: ['industry', 'annual_revenue', 'number_of_employees', 'phone', 'website', 'owner_id'],\n      },\n    },\n\n    /**\n     * Geospatial distribution.\n     *\n     * The `map` block is what BINDS the view to a coordinate source. Without it\n     * the renderer falls back to literal default field names, which resolve on\n     * `crm_account` only by luck \u2014 the view draws no marker while authoring\n     * reports success (`view/layout-without-binding`). `office_location` is the\n     * object's `Field.location(...)`, which is the one field on `crm_account`\n     * carrying coordinates; `billing_address` is an `address` field and is a\n     * postal shape, not a coordinate one, so it stays a column rather than the\n     * binding. `titleField` names the marker label \u2014 `name`, not the object's\n     * `nameField` (`display_title`), because the map's own `columns` show\n     * `name` and the two should agree.\n     */\n    account_map: {\n      name: 'account_map',\n      type: 'map',\n      label: 'Accounts by Location',\n      data: { provider: 'object', object: 'crm_account' },\n      columns: ['name', 'industry', 'office_location', 'billing_address'],\n      map: { locationField: 'office_location', titleField: 'name' },\n    },\n\n    /** Tier accounts: Enterprise (>= $10M ARR) */\n    enterprise_accounts: {\n      name: 'enterprise_accounts',\n      type: 'grid',\n      label: 'Enterprise Accounts',\n      userActions: { editInline: true },\n      data: { provider: 'object', object: 'crm_account' },\n      columns: ['name', 'industry', 'annual_revenue', 'number_of_employees', 'owner_id'],\n      filter: [{ field: 'annual_revenue', operator: 'greater_than_or_equal', value: 10000000 }],\n      sort: [{ field: 'annual_revenue', order: 'desc' }],\n\n      // ADR-0047 end-user quick filters (Airtable \"User filters\", Elements:\n      // dropdowns). `element: 'dropdown'`, deliberately \u2014 on an object list\n      // the view SWITCHER owns the tab bar (it builds one entry per `list` /\n      // `listViews` descriptor), so a quick-filter block shaped as tabs is\n      // dropped there: the console logs `defines userFilters (element:\n      // \"tabs\"), which are ignored on an object list view (ADR-0047 \"views\"\n      // mode \u2014 the view switcher owns the tab bar here)` and renders nothing.\n      // Dropdowns sit beside the switcher and are unaffected.\n      // `owner_id` is the platform ownership lookup (#548) \u2014 it renders as a\n      // record-picker dropdown.\n      // NOTE: requires @objectstack/spec > 9.2.0 (ADR-0047 UserFiltersSchema);\n      // on older specs defineStack strips this block \u2014 harmless no-op.\n      ...({\n        userFilters: {\n          element: 'dropdown',\n          fields: [\n            { field: 'industry', showCount: true },\n            { field: 'type' },\n            { field: 'owner_id' },\n          ],\n        },\n        // typed via spread-as-any until @objectstack/spec ships ADR-0047\n        // (UserFiltersSchema is in framework main, > 9.2.0)\n      } as any),\n    },\n\n    my_accounts: {\n      name: 'my_accounts',\n      type: 'grid',\n      label: 'My Accounts',\n      userActions: { editInline: true },\n      data: { provider: 'object', object: 'crm_account' },\n      columns: ['name', 'industry', 'annual_revenue', 'phone', 'last_activity_date'],\n      filter: [{ field: 'owner_id', operator: 'equals', value: '{current_user_id}' }],\n      sort: [{ field: 'last_activity_date', order: 'desc' }],\n    },\n\n    // The `renewals_due` view is gone with the fields it was built on (#1181):\n    // both its `is_not_null` filter and its sort key were\n    // `crm_account.next_renewal_date`, so the view could not outlive the field.\n    // Nothing is lost \u2014 `crm_contract` ships the renewals queue that the daily\n    // sweep actually acts on (`renewal_calendar`, over `end_date`).\n\n    /** At-risk customers \u2014 CSM action queue */\n    at_risk_accounts: {\n      name: 'at_risk_accounts',\n      type: 'grid',\n      label: '\u26A0\uFE0F At-Risk Accounts',\n      userActions: { editInline: true },\n      data: { provider: 'object', object: 'crm_account' },\n      columns: ['name', 'tier', 'health_score', 'segment', 'last_activity_date'],\n      filter: [\n        { field: 'type', operator: 'equals', value: 'customer' },\n        { field: 'health_score', operator: 'in', value: ['at_risk', 'churning'] },\n      ],\n      sort: [{ field: 'health_score', order: 'desc' }],\n    },\n  },\n\n  form: {\n    type: 'tabbed',\n    sections: [\n      {\n        name: 'profile',\n        label: 'Profile',\n        columns: 2,\n        fields: [\n          { field: 'name', required: true, span: 'full' },\n          'account_number',\n          // `type` (prospect / customer / partner \u2026) drives the Renewals and\n          // At-Risk views' `type = customer` filter \u2014 with no form field it\n          // could never be set, so those views matched nothing.\n          'type',\n          'industry',\n          'phone',\n          'website',\n          'owner_id',\n          'parent_account',\n          'is_active',\n          'brand_color',\n          // The other half of the `branding` group. Without a form field there\n          // is no upload control anywhere in the app, so the logo the gallery\n          // cards now cover with could never have been set. Full span: an\n          // image drop target in a half-width cell is a thumbnail-sized one.\n          { field: 'logo', span: 'full' },\n        ],\n      },\n      {\n        // `child_account_revenue` is a roll-up the engine maintains, so it is\n        // read-only on the form by construction \u2014 it is here because a hierarchy\n        // nobody can see the effect of is the decoration this field replaced.\n        name: 'financials',\n        label: 'Financials',\n        columns: 2,\n        fields: ['annual_revenue', 'number_of_employees', 'child_account_revenue'],\n      },\n      {\n        // The customer-success fields the at_risk_accounts view lists and\n        // filters on. They existed on the object but no form offered them, so\n        // the CS working queue stayed permanently empty. (`renewal_owner` and\n        // `next_renewal_date` were removed from this section with the fields\n        // themselves \u2014 #1181.)\n        name: 'customer_success',\n        label: 'Customer Success',\n        columns: 2,\n        fields: ['tier', 'segment', 'health_score'],\n      },\n      {\n        name: 'locations',\n        label: 'Locations',\n        columns: 1,\n        // `billing_country` and `territory` are readonly and derived, but both\n        // are on the form on purpose: an admin asking \"why does the NA team not\n        // see this account?\" reads the answer off the record instead of\n        // guessing at the address blob (#621). `territory` is what the rules\n        // actually match (#639) and `billing_country` is the input it was\n        // classified from, so the two together show the whole derivation \u2014\n        // including the case the picklist alone cannot explain, an account\n        // sitting in `Other` because its country was typed in a spelling the\n        // mapping does not know.\n        fields: ['billing_address', 'billing_country', 'territory', 'office_location'],\n      },\n      {\n        name: 'description',\n        label: 'Description',\n        columns: 1,\n        fields: ['description'],\n      },\n    ],\n  },\n});\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/sales/views/contact.view.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/sales/views\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/sales/views/contact.view.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport { defineView } from '@objectstack/spec/ui';\n\n/**\n * Contact Views\n *\n *   \u2022 grid    \u2014 primary roster with avatar\n *   \u2022 gallery \u2014 people directory cards (avatar as cover)\n */\nexport const ContactViews = defineView({\n  list: {\n    type: 'grid',\n    name: 'all_contacts',\n    label: 'All Contacts',\n    userActions: { editInline: true },\n    data: { provider: 'object', object: 'crm_contact' },\n    columns: [\n      { field: 'avatar', width: 64, align: 'center' },\n      { field: 'first_name', width: 140, sortable: true, link: true },\n      { field: 'last_name', width: 140, sortable: true },\n      { field: 'crm_account', width: 200 },\n      { field: 'title', width: 180 },\n      { field: 'department', width: 140 },\n      // REQ-0004 acceptance 2: the three buying-centre attributes are columns\n      // on the landing roster, which is already grouped by account with the\n      // groups collapsed \u2014 so expanding one account reads as a MAP (who\n      // decides, who is on our side) instead of a directory. Columns are also\n      // what the list's own filter and grouping controls offer.\n      { field: 'buying_function', width: 160 },\n      { field: 'attitude', width: 140 },\n      { field: 'relationship_strength', width: 180 },\n      { field: 'email', width: 220 },\n      { field: 'phone', width: 150 },\n      { field: 'owner_id', width: 150 },\n    ],\n    sort: [{ field: 'last_name', order: 'asc' }],\n    grouping: { fields: [{ field: 'crm_account', order: 'asc', collapsed: true }] },\n    selection: { type: 'multiple' },\n    // The selection-bar entry point for campaigning at existing customers\n    // (#597), mirroring `bulkActions: ['create_campaign']` on the lead grid.\n    // The bare-string form fans the action out once per selected row; do not\n    // add strings for `mark_primary` / `send_email`, which declare\n    // `locations: ['list_item']` and are auto-injected into the row menu.\n    bulkActions: ['add_contact_to_campaign'],\n    pagination: { pageSize: 50, pageSizeOptions: [25, 50, 100] },\n    exportOptions: { formats: ['csv', 'xlsx'] },\n    appearance: {\n      showDescription: true,\n      allowedVisualizations: ['grid', 'gallery'],\n    },\n  },\n\n  listViews: {\n    /** People directory */\n    contact_directory: {\n      name: 'contact_directory',\n      type: 'gallery',\n      label: 'People Directory',\n      data: { provider: 'object', object: 'crm_contact' },\n      columns: ['first_name', 'last_name', 'title', 'email'],\n      gallery: {\n        coverField: 'avatar',\n        coverFit: 'cover',\n        cardSize: 'small',\n        titleField: 'last_name',\n        visibleFields: ['first_name', 'title', 'department', 'email', 'phone', 'crm_account'],\n      },\n    },\n\n    primary_contacts: {\n      name: 'primary_contacts',\n      type: 'grid',\n      label: 'Primary Contacts',\n      userActions: { editInline: true },\n      data: { provider: 'object', object: 'crm_contact' },\n      columns: ['first_name', 'last_name', 'crm_account', 'title', 'email', 'phone'],\n      filter: [{ field: 'is_primary', operator: 'equals', value: true }],\n      sort: [{ field: 'crm_account', order: 'asc' }],\n    },\n  },\n\n  form: {\n    type: 'tabbed',\n    sections: [\n      {\n        name: 'identity',\n        label: 'Identity',\n        columns: 2,\n        fields: [\n          'salutation',\n          { field: 'first_name', required: true },\n          { field: 'last_name', required: true, span: 'full' },\n          { field: 'crm_account', required: true },\n          'title',\n          'department',\n          'owner_id',\n        ],\n      },\n      {\n        // REQ-0004 acceptance 1: the buying-centre group is rendered FROM\n        // `fieldGroups`, with no per-field enumeration authored anywhere.\n        //\n        // This form authors `sections`, and an authored `sections` array wins\n        // outright over the renderer's `fieldGroups` auto-derivation (the\n        // mechanism is written up at length in `case.view.ts`), so a group\n        // declared on the object alone would reach the SYNTHESIZED detail\n        // page and never this form \u2014 which is also the create dialog. The\n        // group-reference form is rung 2 of the AGENTS.md ladder, for exactly\n        // this \"partial arrangement is genuinely needed\" case: `group:`\n        // inherits the object's `buying_centre` members (every field pointing\n        // at it, in declaration order) and its presentation, so adding a\n        // fourth attribute to the group later reaches this form by itself.\n        //\n        // \u26D4 `group:` is mutually exclusive with `fields:` and with every key\n        // the group itself declares (`name`, `label`, `description`,\n        // `visibleWhen`, `collapsible`/`collapsed: true`) \u2014 `columns` is not\n        // one of those, because the group declares nothing about layout.\n        group: 'buying_centre',\n        columns: 2,\n      },\n      {\n        // Named `contact_details`, not `contact_info` \u2014 `contact_info` is\n        // already a distinct fieldGroup key on `crm_contact` (\"Contact\n        // Information\"), and reusing it here would make this section's\n        // translated heading follow that group's wording instead of its own\n        // \"Contact Info\".\n        name: 'contact_details',\n        label: 'Contact Info',\n        columns: 2,\n        fields: ['email', 'phone', 'mobile', 'avatar'],\n      },\n      {\n        // Named `mailing_address` \u2014 deliberately the SAME key as the\n        // `mailing_address` fieldGroup on `crm_contact`, which is the opposite\n        // call from the two sections either side of it and for the same\n        // reason. Reusing a group key makes the section's translated heading\n        // follow that group's wording; `contact_details` and\n        // `comm_preferences` wanted their own shorter wording, so they had to\n        // avoid the collision. This section wants exactly the group's wording\n        // (\"Mailing Address\"), which every locale already carries under\n        // `objects.crm_contact._sections.mailing_address`, so the collision is\n        // the feature: one heading, one translation, four locales, no new row.\n        //\n        // Why the section exists at all: an authored `sections` array wins\n        // outright over the renderer's `fieldGroups` auto-derivation (the\n        // mechanism is written up at length in `case.view.ts`), and this form\n        // is also the CREATE dialog. Without this section the address was\n        // readable on the SYNTHESIZED detail page \u2014 which does derive from\n        // `fieldGroups` \u2014 while no form in the app could enter or edit it,\n        // even though `contact_import.mapping.ts` writes it from the shipped\n        // CSV template. This tab is the authoring half of the import path.\n        name: 'mailing_address',\n        label: 'Mailing Address',\n        columns: 2,\n        fields: [\n          // One structured `address` field; full width, so its parts lay out\n          // as a unit rather than in half a grid column.\n          { field: 'mailing_address', span: 'full' },\n        ],\n      },\n      {\n        // Named `comm_preferences`, not `preferences` \u2014 `preferences` is\n        // already a distinct fieldGroup key on `crm_contact` (\"Communication\n        // Preferences\"), and reusing it here would make this section's\n        // translated heading follow that group's wording instead of its own\n        // \"Preferences\".\n        name: 'comm_preferences',\n        label: 'Preferences',\n        columns: 2,\n        fields: ['lead_source', 'is_primary', 'do_not_call', 'email_opt_out'],\n      },\n    ],\n  },\n});\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/sales/views/opportunity.view.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/sales/views\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/sales/views/opportunity.view.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport { defineView } from '@objectstack/spec/ui';\n\n/**\n * Opportunity Views\n *\n * Sales pipeline benefits from multiple visualisations:\n *   \u2022 grid     \u2014 full pipeline browsing & inline edits\n *   \u2022 kanban   \u2014 drag-and-drop pipeline stage management (group by stage)\n *   \u2022 calendar \u2014 close-date forecasting on a monthly view\n *   \u2022 timeline \u2014 chronological deal flow grouped by owner\n *   \u2022 gallery  \u2014 pinboard / executive review cards\n */\nexport const OpportunityViews = defineView({\n  // The landing view is OPEN deals, not every deal ever recorded.\n  //\n  // Sorted by close_date ascending and unfiltered, \"All Opportunities\" opened\n  // on settled history: the first screen was 7 closed-won and 4 closed-lost\n  // records, and a rep had to scroll past months of finished business to reach\n  // anything they could still act on. The full unfiltered list is still one\n  // click away on the \"All Opportunities\" tab.\n  list: {\n    type: 'grid',\n    name: 'open_opportunities',\n    label: 'Open Deals',\n    userActions: { editInline: true },\n    data: { provider: 'object', object: 'crm_opportunity' },\n    filter: [\n      { field: 'stage', operator: 'not_in', value: ['closed_won', 'closed_lost'] },\n    ],\n    columns: [\n      { field: 'name', width: 220, sortable: true, link: true },\n      { field: 'crm_account', label: 'Account', width: 180 },\n      { field: 'stage', width: 140, sortable: true },\n      { field: 'amount', width: 140, align: 'right', sortable: true, summary: 'sum' },\n      { field: 'probability', width: 110, align: 'right' },\n      { field: 'expected_revenue', width: 160, align: 'right', summary: 'sum' },\n      { field: 'close_date', width: 140, sortable: true },\n    ],\n    sort: [{ field: 'close_date', order: 'asc' }],\n    rowColor: {\n      field: 'stage',\n      colors: {\n        prospecting: 'slate',\n        qualification: 'sky',\n        // Teal sits between the cool qualification blue and the warm proposal\n        // amber, keeping the cool\u2192warm funnel ramp readable. NOT the gold\n        // `#FFD700` this option carries in `_picklists.ts`: gold is one hue\n        // step from proposal's amber, so the two adjacent stages would tint\n        // rows the same.\n        //\n        // Values are colour NAMES, not hex: objectui's `useRowColor` resolves\n        // only a name from its own vocabulary (or a full `bg-*` class) and\n        // turns a hex into no colour at all \u2014 so until 17.6.0's lint said so,\n        // this map tinted nothing.\n        needs_analysis: 'teal',\n        proposal: 'amber',\n        negotiation: 'purple',\n        closed_won: 'green',\n        closed_lost: 'red',\n      },\n    },\n    pagination: { pageSize: 25, pageSizeOptions: [25, 50, 100] },\n    selection: { type: 'multiple' },\n    showRecordCount: true,\n    exportOptions: { formats: ['csv', 'xlsx'] },\n    appearance: {\n      showDescription: true,\n      allowedVisualizations: ['grid', 'kanban', 'calendar', 'timeline', 'gallery'],\n    },\n    // Binds the 'calendar' entry above: the same forecast dates the dedicated\n    // `close_date_calendar` view shows, on the field this list sorts by.\n    // `close_date` is required + notNull on crm_opportunity.\n    calendar: {\n      startDateField: 'close_date',\n      titleField: 'name',\n      colorField: 'stage',\n    },\n    // List-level entry points: generate_quote reaches the row menu via its\n    // own `locations: ['list_item']`. Built-in `exportOptions` covers CSV\n    // export.\n    //\n    // `mass_update_stage` is wired as an AGGREGATE bulk def, not as a bare\n    // `bulkActions: ['mass_update_stage']` string (#508). The two forms are\n    // different dispatch contracts, and only this one moves a whole selection:\n    //\n    //   - bare string  \u2192 per-record fan-out: the action is dispatched ONCE PER\n    //     selected row with `recordId` set. N requests, N stage moves.\n    //   - aggregate def \u2192 ONE dispatch for the whole selection, carrying every\n    //     id in the builtin `params._selectedIds` and no `recordId`. One\n    //     request, N stage moves, one audit entry.\n    //\n    // Aggregate is the right shape here because the body already loops over the\n    // selection itself, and because the run is all-or-nothing: a partial result\n    // rejects instead of leaving the bar reporting per-row success it cannot\n    // honour (see the body in `src/sales/actions/opportunity.actions.ts`).\n    //\n    // `execution: 'aggregate'` is REQUIRED on an `operation: 'custom'` def and\n    // is not boilerplate: a custom def without it has no dispatcher, so the\n    // button ticks green once per row and does nothing at all. The spec refuses\n    // that shape at parse time (#4457) \u2014 which is also what makes this\n    // declaration safe to trust rather than merely present.\n    //\n    // History: this list carried the bare-string form until #588 removed it as\n    // a silent no-op, and the removal was read as \"the platform cannot deliver\n    // a selection\" for two release candidates. It could: the channel is\n    // `params._selectedIds`, the underscore is load-bearing, and nothing was\n    // injecting it precisely BECAUSE this declaration was gone\n    // (objectstack-ai/objectstack#5568, closed works-as-declared).\n    //\n    // The def deliberately carries only the three keys that choose the dispatch\n    // contract. Label, icon, params (the New Stage picker) and `visible` are\n    // promoted from the action itself by the renderer, so the dialog and the\n    // toolbar button cannot drift apart \u2014 and the label stays i18n-resolved,\n    // which an inline `label:` here would not be.\n    bulkActionDefs: [\n      { name: 'mass_update_stage', operation: 'custom', execution: 'aggregate' },\n    ],\n  },\n\n  listViews: {\n    /**\n     * All Opportunities \u2014 the unfiltered book, including closed business.\n     *\n     * Demoted from the landing view (see the note on `list` above) but kept\n     * whole: reporting, audits and win/loss reviews all need the closed rows,\n     * and a manager reaches this in one click.\n     */\n    all_opportunities: {\n      name: 'all_opportunities',\n      type: 'grid',\n      label: 'All Opportunities',\n      userActions: { editInline: true },\n      data: { provider: 'object', object: 'crm_opportunity' },\n      columns: [\n        { field: 'name', width: 220, sortable: true, link: true },\n        { field: 'crm_account', label: 'Account', width: 180 },\n        { field: 'stage', width: 140, sortable: true },\n        { field: 'amount', width: 140, align: 'right', sortable: true, summary: 'sum' },\n        { field: 'probability', width: 110, align: 'right' },\n        { field: 'expected_revenue', width: 160, align: 'right', summary: 'sum' },\n        { field: 'close_date', width: 140, sortable: true },\n        { field: 'owner_id', width: 150 },\n      ],\n      sort: [{ field: 'close_date', order: 'desc' }],\n      showRecordCount: true,\n    },\n\n    /** Drag-and-drop sales pipeline */\n    pipeline_kanban: {\n      name: 'pipeline_kanban',\n      type: 'kanban',\n      label: 'Sales Pipeline',\n      data: { provider: 'object', object: 'crm_opportunity' },\n      columns: ['name', 'crm_account', 'amount', 'close_date', 'owner_id'],\n      kanban: {\n        groupByField: 'stage',\n        summarizeField: 'amount',\n        columns: ['name', 'crm_account', 'amount', 'close_date'],\n      },\n      // The board is the active working pipeline. Closed business remains in\n      // the full book and the dashboard, while excluding it here keeps all\n      // five active stages visible at a presentation-friendly width.\n      filter: [{ field: 'stage', operator: 'not_in', value: ['closed_won', 'closed_lost'] }],\n      sort: [{ field: 'close_date', order: 'asc' }],\n      navigation: { mode: 'drawer', width: '640px' },\n    },\n\n    /** Close-date forecasting calendar */\n    close_date_calendar: {\n      name: 'close_date_calendar',\n      type: 'calendar',\n      label: 'Forecast Calendar',\n      data: { provider: 'object', object: 'crm_opportunity' },\n      columns: ['name', 'amount', 'stage', 'owner_id'],\n      calendar: {\n        startDateField: 'close_date',\n        titleField: 'name',\n        colorField: 'stage',\n      },\n    },\n\n    /** Chronological deal flow */\n    deal_timeline: {\n      name: 'deal_timeline',\n      type: 'timeline',\n      label: 'Deal Timeline',\n      data: { provider: 'object', object: 'crm_opportunity' },\n      columns: ['name', 'crm_account', 'amount'],\n      timeline: {\n        // `created_at`, the platform's own creation stamp \u2014 the object's\n        // duplicate `created_date` was removed in #575 B2 because nothing ever\n        // wrote it, so this timeline started every bar at null. Same spelling\n        // as the lead activity calendar.\n        startDateField: 'created_at',\n        endDateField: 'close_date',\n        titleField: 'name',\n        groupByField: 'owner_id',\n        colorField: 'stage',\n        scale: 'month',\n      },\n    },\n\n    /** Executive review cards */\n    deal_gallery: {\n      name: 'deal_gallery',\n      type: 'gallery',\n      label: 'Deal Cards',\n      data: { provider: 'object', object: 'crm_opportunity' },\n      columns: ['name', 'crm_account', 'amount', 'stage', 'close_date'],\n      gallery: {\n        cardSize: 'medium',\n        titleField: 'name',\n        visibleFields: ['crm_account', 'amount', 'stage', 'probability', 'close_date', 'owner_id'],\n      },\n    },\n\n    /** Personal pipeline */\n    my_open_deals: {\n      name: 'my_open_deals',\n      type: 'grid',\n      label: 'My Open Deals',\n      userActions: { editInline: true },\n      data: { provider: 'object', object: 'crm_opportunity' },\n      columns: ['name', 'crm_account', 'stage', 'amount', 'close_date'],\n      // \"Open\" has to exclude BOTH closed stages. Excluding only closed_won\n      // meant a rep's own queue opened on their lost deals, sorted to the top\n      // by close_date \u2014 the least actionable rows in the system.\n      filter: [\n        { field: 'owner_id', operator: 'equals', value: '{current_user_id}' },\n        { field: 'stage', operator: 'not_in', value: ['closed_won', 'closed_lost'] },\n      ],\n      sort: [{ field: 'close_date', order: 'asc' }],\n    },\n\n    /** Stale Opportunities \u2014 still-open deals, longest-parked first */\n    stale_opportunities: {\n      name: 'stale_opportunities',\n      type: 'grid',\n      // Honest label: this view does not apply the 14-day cut its automation\n      // twin (`opportunity_stagnation`, STALE_THRESHOLD_DAYS = 14) uses, and\n      // does not claim to. Two independent reasons were recorded for that; one\n      // still holds and one has expired, so they are separated here.\n      //\n      // STILL TRUE \u2014 `days_in_stage` is a FORMULA (#489), evaluated in JS after\n      // the query, so the data engine can neither filter nor sort on it. Any\n      // filter phrased in terms of `days_in_stage` remains impossible.\n      //\n      // EXPIRED (#744) \u2014 the second reason said the list data path resolves no\n      // date macros, so `stage_entry_date < {14_days_ago}` would ship the token\n      // as a literal and invert the comparison lexicographically ('2026-\u2026' sorts\n      // below '{', so every row matched). That was measured on @objectstack\n      // 16.1.0 and stopped being true at 17.0.0-rc.0, when `resolveFilterTokens()`\n      // was wired into the ObjectQL read path (objectql #3582). `{14_days_ago}`\n      // is a first-class vocabulary member \u2014 it matches the parameterised\n      // grammar `DATE_MACRO_PARAM_RE`, `{N_(minutes|hours|days|weeks|months|\n      // years)_(ago|from_now)}` \u2014 and it reaches the driver already substituted\n      // for an ISO date. Measured on 17.0.0-rc.2, RE-MEASURED 2026-09-03 on\n      // 17.2.0 (#1467), RE-RUN on 17.3.0 (#1676, after the PR #1577 bump) and\n      // RE-RUN again on 17.4.0 (#1883, after the PR #1814 bump; not yet on\n      // 17.5.0), unchanged at every taking: over four rows parked\n      // 30d / 15d / 13d / 1d, `stage_entry_date < {14_days_ago}` returned the\n      // 30d and 15d rows \u2014 the same two the equivalent day-start literal\n      // returns, and not all four, which is what an unsubstituted token would\n      // have matched. It is the same seam\n      // `closing_this_quarter` \u2014 the very next view in this file \u2014 relies on,\n      // pinned against a real engine in\n      // `test/forecast-current-quarter-view.test.ts`.\n      //\n      // Correcting that half of the comment does not decide anything about the\n      // filter, and is deliberately not a licence to change it: expressing the\n      // cut as `stage_entry_date <= {14_days_ago}` would drop `days_in_stage`\n      // from the question entirely and change which rows this view returns \u2014\n      // hiding today's 13-day-old deals from a manager's queue. That is a\n      // BEHAVIOUR change with its own issue (#770), where the open question is\n      // whether this queue should be a cut or a ranking at all \u2014 this label\n      // promises a ranking and honours it. `stale_articles` in\n      // `src/views/knowledge_article.view.ts` carried the same expired premise\n      // and was corrected in the same pass (#769); that tab was then DELETED\n      // outright (#781, the review queue ruled out of the product), so it is no\n      // longer a comparison available in this tree \u2014 the surviving precedent\n      // for \"ranking, not cut\" is this view. Nothing below was touched.\n      //\n      // As shipped: operator-only filter, ordered by the stored\n      // `stage_entry_date` ascending \u2014 longest-parked on top, which is the\n      // queue a manager works. The `days_in_stage` column puts the\n      // `opportunity_stagnation` threshold in plain sight on every row.\n      label: '\u26A0\uFE0F Stale Opportunities \u00B7 Longest in Stage First',\n      userActions: { editInline: true },\n      data: { provider: 'object', object: 'crm_opportunity' },\n      columns: ['name', 'crm_account', 'stage', 'amount', 'stage_entry_date', 'days_in_stage', 'close_date', 'owner_id'],\n      filter: [\n        { field: 'stage', operator: 'not_in', value: ['closed_won', 'closed_lost'] },\n      ],\n      sort: [{ field: 'stage_entry_date', order: 'asc' }, { field: 'close_date', order: 'asc' }],\n    },\n\n    /**\n     * Tender expected this quarter \u2014 REQ-0006 acceptance 2 in one view.\n     *\n     * The point of the view is the predicate: it windows\n     * `expected_tender_date`, the CUSTOMER's procurement calendar, and touches\n     * `close_date` nowhere \u2014 which is what \"reportable independently of\n     * `close_date`\" means and what a single forecast date could never express.\n     *\n     * Same inclusive `{current_quarter_*}` bounds as `closing_this_quarter`\n     * below, exact for the same measured reason: both bounds are date macros\n     * resolved server-side, and `expected_tender_date` is a `Field.date()`\n     * stored as `YYYY-MM-DD` TEXT, so the inclusive upper bound drops no rows.\n     */\n    tender_this_quarter: {\n      name: 'tender_this_quarter',\n      type: 'grid',\n      label: 'Tender This Quarter',\n      userActions: { editInline: true },\n      data: { provider: 'object', object: 'crm_opportunity' },\n      columns: ['name', 'crm_account', 'expected_tender_date', 'expected_tender_amount', 'expected_signing_date', 'stage', 'owner_id'],\n      filter: [\n        { field: 'stage', operator: 'not_in', value: ['closed_won', 'closed_lost'] },\n        { field: 'expected_tender_date', operator: 'greater_than_or_equal', value: '{current_quarter_start}' },\n        { field: 'expected_tender_date', operator: 'less_than_or_equal', value: '{current_quarter_end}' },\n      ],\n      sort: [{ field: 'expected_tender_date', order: 'asc' }],\n      // Empty is the legitimate state on a fresh install: no seed row carries\n      // a customer-side tender date, so this tab opens on nothing until a rep\n      // records one. Unexplained, that reads as broken.\n      emptyState: {\n        title: 'No Tenders Expected This Quarter',\n        message: 'This tab lists open deals whose customer-side tender date falls inside the current quarter. Record Expected Tender Date on a deal to see it here.',\n        icon: 'calendar-clock',\n      },\n    },\n\n    /** Closing this quarter (commit + best_case) \u2014 sales-manager forecast */\n    closing_this_quarter: {\n      name: 'closing_this_quarter',\n      type: 'grid',\n      label: 'Closing This Quarter',\n      userActions: { editInline: true },\n      data: { provider: 'object', object: 'crm_opportunity' },\n      columns: ['name', 'crm_account', 'amount', 'forecast_category', 'probability', 'close_date', 'owner_id'],\n      // The `close_date` window is what makes the label true (#743). Without\n      // it this view returned EVERY open commit/best-case deal whenever it\n      // closed \u2014 a deal slated for next March sat under a heading that said\n      // \"Closing This Quarter\", and summing the Amount column gave a number\n      // that was not this quarter's commit.\n      //\n      // Both bounds are date macros resolved server-side: `resolveFilterTokens()`\n      // was wired into the ObjectQL read path in 17.0.0-rc.0 (objectql #3582,\n      // covering find/findOne/count/aggregate ahead of the middleware chain),\n      // so a saved-view filter value reaches the driver already substituted.\n      // Measured on 17.0.0-rc.2, RE-MEASURED 2026-09-03 on 17.2.0 (#1467),\n      // RE-RUN on 17.3.0 (#1676, after the PR #1577 bump) and RE-RUN again on\n      // 17.4.0 (#1883, after the PR #1814 bump), unchanged at\n      // every taking \u2014 see the runtime block in\n      // `test/forecast-current-quarter-view.test.ts`, which is that\n      // re-measurement (not yet re-run on 17.5.0).\n      //\n      // The upper bound is INCLUSIVE against `{current_quarter_end}` rather\n      // than half-open against `{next_quarter_start}`, and that choice is\n      // deliberate: a `*_end` token resolves to the period's last calendar DAY\n      // (2026-09-30), which on a `datetime` column would stop at midnight and\n      // silently drop that day's rows \u2014 the spec says to use the half-open\n      // form there. `close_date` is `Field.date()`, stored as `YYYY-MM-DD`\n      // TEXT on both sides of the comparison, so the inclusive bound is exact.\n      // That is the same field-type property `metadata-references.test.ts`\n      // relies on for why the CRM/Sales/Executive dashboards may window\n      // `close_date` at all (#460). Both forms were measured to return the\n      // identical row set here; the inclusive one reads as what it means.\n      filter: [\n        { field: 'forecast_category', operator: 'in', value: ['commit', 'best_case'] },\n        { field: 'stage', operator: 'not_in', value: ['closed_won', 'closed_lost'] },\n        { field: 'close_date', operator: 'greater_than_or_equal', value: '{current_quarter_start}' },\n        { field: 'close_date', operator: 'less_than_or_equal', value: '{current_quarter_end}' },\n      ],\n      sort: [{ field: 'close_date', order: 'asc' }],\n      // Scoping the list makes \"empty\" a state a real user meets, so it needs\n      // copy. Unlike the forecast view's (#745, where the sweep owns the\n      // window and a fresh install is ALWAYS empty until it runs), the seeds\n      // here do produce rows for most of a quarter \u2014 six seeded deals qualify\n      // on forecast_category + stage, at `daysFromNow` offsets 11/14/24/30/38/45.\n      // But every one of those offsets is relative to the INSTALL day, so once\n      // fewer than 11 days remain in the quarter all six land in the next one\n      // and a freshly seeded demo opens this tab on nothing. A real org meets\n      // the same state whenever a quarter's commit slips out. Empty is\n      // legitimate here; unexplained, it reads as broken.\n      emptyState: {\n        title: 'No Deals Closing This Quarter',\n        message: 'This tab lists open commit and best-case deals with a close date inside the current quarter. Nothing matches right now \u2014 deals closing later are on the Open Deals tab.',\n        icon: 'calendar-check',\n      },\n    },\n  },\n\n  form: {\n    type: 'tabbed',\n    sections: [\n      {\n        name: 'overview',\n        label: 'Overview',\n        columns: 2,\n        fields: [\n          { field: 'name', required: true, span: 'full' },\n          { field: 'crm_account', required: true },\n          'primary_contact',\n          { field: 'stage', required: true },\n          { field: 'amount', required: true },\n          'probability',\n          'close_date',\n          'owner_id',\n        ],\n      },\n      {\n        name: 'forecast',\n        label: 'Forecast',\n        columns: 2,\n        fields: [\n          'expected_revenue',\n          'forecast_category',\n          'type',\n          'lead_source',\n          'crm_campaign',\n          'stage_entry_date',\n          'days_in_stage',\n          'is_private',\n          // REQ-0006 step 8 \u2014 the customer's own procurement calendar. Named\n          // here (AGENTS.md ladder rung 3), and the reason in writing:\n          // `tender_this_quarter` filters on `expected_tender_date`, and a\n          // filtered field no form offers is a view that can never match a\n          // deal a rep created through the UI (`test/metadata-references\n          // .test.ts`). The fields declare `group: 'sales_process'`, so every\n          // DERIVED surface \u2014 the record page's Details tab \u2014 already carries\n          // them; this form authors `sections`, which win outright over\n          // derivation. A `{ group: 'sales_process' }` reference cannot stand\n          // in: it would render `stage`, `probability` and `close_date`\n          // (curated in Overview, `stage` `required`) and `stage_entry_date`\n          // (above) a second time, and pull the approval verdict columns and\n          // the inert-by-default `requested_status` into the create dialog.\n          'customer_initiation_date',\n          'expected_tender_date',\n          'expected_tender_amount',\n          'expected_signing_date',\n          'expected_signing_amount',\n        ],\n      },\n      // REQ-0006 acceptance 1, FROM `fieldGroups` (AGENTS.md ladder rung 2),\n      // the way `contact.view.ts` references REQ-0004's buying centre: this\n      // form authors `sections`, which win outright over the renderer's\n      // `fieldGroups` derivation, so a group declared on the object alone\n      // never reaches this form \u2014 the Edit and New dialog. A group reference\n      // enumerates nothing; members, label and icon come from the object.\n      //\n      // \u26A0\uFE0F Measured on the 17.6.0 console: the tabbed dialog renders NO tab\n      // for a `{ group }` section \u2014 this one, and the contact form's buying\n      // centre on `main` alike. That is the platform's to fix, and these two\n      // lines are the contract-correct form waiting for it (AGENTS.md: a\n      // platform defect is waited for, never routed around). Until then every\n      // REQ-0006 field is edited through the Details tab's edit mode \u2014 which\n      // offers no markdown editor, the reason the narrative fields are\n      // textareas (see the note above `customer_background`).\n      { group: 'qualification', columns: 2 },\n      { group: 'narrative', columns: 1 },\n      {\n        name: 'sales_strategy',\n        label: 'Sales Strategy',\n        columns: 1,\n        // `competitors` sat here until #1061 retired it \u2014 this form section was\n        // the field's ONLY surface anywhere in the app (nothing read it back).\n        fields: ['next_step'],\n      },\n      {\n        // Win/loss capture at close time. The fields existed on the object for\n        // reporting but no form offered them, so every closed deal lost its\n        // why-we-won / why-we-lost data.\n        name: 'win_loss',\n        label: 'Win / Loss',\n        collapsible: true,\n        collapsed: true,\n        columns: 2,\n        fields: ['win_reason', 'loss_reason', { field: 'loss_details', span: 'full' }],\n      },\n    ],\n  },\n});\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/sales/views/task.view.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/sales/views\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/sales/views/task.view.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport { defineView } from '@objectstack/spec/ui';\n\n/**\n * Task Views\n *\n *   \u2022 grid     \u2014 to-do list with completion controls\n *   \u2022 kanban   \u2014 work board grouped by status\n *   \u2022 calendar \u2014 schedule by due_date\n *   \u2022 gantt    \u2014 execution plan from reminder_date \u2192 due_date\n *   \u2022 timeline \u2014 chronological worklog grouped by owner\n */\nexport const TaskViews = defineView({\n  list: {\n    type: 'grid',\n    name: 'all_tasks',\n    label: 'All Tasks',\n    userActions: { editInline: true },\n    data: { provider: 'object', object: 'crm_task' },\n    // NO `progress_percent` column here (#1214 item 5). The default grid used\n    // to render completion THREE times on one row \u2014 \u662F\u5426\u5B8C\u6210 (tick), \u72B6\u6001, and\n    // \u8FDB\u5EA6(%) \u2014 and the percent was the one that carried nothing.\n    //\n    // \u26A0\uFE0F The card justified the removal as \"every seeded row is 0%\". That is\n    // FALSE as stated and was re-measured before deleting: two of the seven\n    // seeded tasks carry 100. What is TRUE is the claim underneath it \u2014 nobody\n    // maintains a percent per task \u2014 and the seed shows it more sharply than\n    // the card did:\n    //   \u00B7 every value that exists is 100, and every one of those rows is\n    //     `status: 'completed'` (`service.seed.ts` mirrors what the hook would\n    //     stamp, since hooks do not run over seeds);\n    //   \u00B7 `task_completion` stamps 100 on the completed transition and writes\n    //     the field at no other time;\n    //   \u00B7 both `in_progress` rows sit at 0 \u2014 the one status where a percent\n    //     could say something a status cannot, and it says nothing.\n    // \u21D2 On this grid the column is `status` re-rendered at LOWER resolution: it\n    // cannot tell `not_started` from `in_progress` (both 0), while the `status`\n    // column beside it can. Dropping it loses no fact this row does not already\n    // carry twice.\n    //\n    // \u26D4 The FIELD stays, and so does every other reader \u2014 this is one column\n    // on one view, not a retirement: `task_gantt` fills its bars from\n    // `gantt.progressField`, `task_board` and `my_open_tasks` show it (neither\n    // carries `status` AND `is_completed`, so there it is not a third spelling),\n    // `avg_progress` in `task.dataset.ts` aggregates it, and the Effort section\n    // of this file's form still lets a user author one.\n    //\n    // \u26D4 `is_completed` STAYS, and is not the second half of this cleanup: it is\n    // not an independent shadow that can contradict `status` \u2014 `task_completion`\n    // recomputes it from status on every insert and update\n    // (`input.is_completed = effStatus === 'completed'`), which is precisely the\n    // \"render completion from status\" the card asks for, already done at the\n    // data layer. It is also this list's first sort key and its completion\n    // control.\n    columns: [\n      { field: 'is_completed', width: 60, align: 'center' },\n      { field: 'subject', width: 280, sortable: true, link: true },\n      { field: 'status', width: 130, sortable: true },\n      { field: 'priority', width: 110, sortable: true },\n      { field: 'due_date', width: 140, sortable: true },\n      { field: 'owner_id', width: 150 },\n      { field: 'is_overdue', width: 100, align: 'center' },\n    ],\n    sort: [\n      { field: 'is_completed', order: 'asc' },\n      { field: 'due_date', order: 'asc' },\n    ],\n    rowColor: {\n      // Task priority is low/normal/high/urgent \u2014 the previous critical/medium\n      // keys were Case values, so urgent and normal rows got no color at all.\n      // Colors mirror the option colors on crm_task.priority.\n      field: 'priority',\n      colors: { urgent: 'red', high: 'orange', normal: 'green', low: 'slate' },\n    },\n    selection: { type: 'multiple' },\n    pagination: { pageSize: 50 },\n    appearance: {\n      showDescription: true,\n      allowedVisualizations: ['grid', 'kanban', 'calendar', 'gantt', 'timeline'],\n    },\n    // Binds the 'calendar' entry above: the same schedule the dedicated\n    // `task_calendar` view shows, on the field this list sorts by. `due_date`\n    // is optional \u2014 an undated task stays off the calendar instead of being\n    // dropped on today by a guessed field.\n    calendar: {\n      startDateField: 'due_date',\n      titleField: 'subject',\n      colorField: 'priority',\n    },\n  },\n\n  listViews: {\n    /** Work board */\n    task_board: {\n      name: 'task_board',\n      type: 'kanban',\n      label: 'Task Board',\n      data: { provider: 'object', object: 'crm_task' },\n      columns: ['subject', 'priority', 'due_date', 'owner_id'],\n      kanban: {\n        groupByField: 'status',\n        columns: ['subject', 'priority', 'due_date', 'progress_percent'],\n      },\n      filter: [{ field: 'is_completed', operator: 'equals', value: false }],\n      navigation: { mode: 'drawer', width: '520px' },\n    },\n\n    /** Schedule view */\n    task_calendar: {\n      name: 'task_calendar',\n      type: 'calendar',\n      label: 'Task Schedule',\n      data: { provider: 'object', object: 'crm_task' },\n      columns: ['subject', 'priority', 'owner_id'],\n      calendar: {\n        startDateField: 'due_date',\n        titleField: 'subject',\n        colorField: 'priority',\n      },\n    },\n\n    /** Execution plan */\n    task_gantt: {\n      name: 'task_gantt',\n      type: 'gantt',\n      label: 'Execution Plan',\n      data: { provider: 'object', object: 'crm_task' },\n      columns: ['subject', 'owner_id', 'progress_percent'],\n      gantt: {\n        startDateField: 'reminder_date',\n        endDateField: 'due_date',\n        titleField: 'subject',\n        progressField: 'progress_percent',\n      },\n    },\n\n    /** Worklog timeline */\n    task_timeline: {\n      name: 'task_timeline',\n      type: 'timeline',\n      label: 'Worklog Timeline',\n      data: { provider: 'object', object: 'crm_task' },\n      columns: ['subject', 'status'],\n      timeline: {\n        startDateField: 'reminder_date',\n        endDateField: 'due_date',\n        titleField: 'subject',\n        groupByField: 'owner_id',\n        colorField: 'status',\n        scale: 'week',\n      },\n    },\n\n    my_open_tasks: {\n      name: 'my_open_tasks',\n      type: 'grid',\n      label: 'My Open Tasks',\n      userActions: { editInline: true },\n      data: { provider: 'object', object: 'crm_task' },\n      columns: ['subject', 'priority', 'due_date', 'progress_percent'],\n      filter: [\n        { field: 'owner_id', operator: 'equals', value: '{current_user_id}' },\n        { field: 'is_completed', operator: 'equals', value: false },\n      ],\n      sort: [{ field: 'due_date', order: 'asc' }],\n    },\n\n    /** My open priority tasks \u2014 daily morning queue */\n    todays_tasks: {\n      name: 'todays_tasks',\n      type: 'grid',\n      label: '\uD83D\uDCC5 My Priority Tasks',\n      userActions: { editInline: true },\n      data: { provider: 'object', object: 'crm_task' },\n      columns: ['subject', 'priority', 'status', 'due_date', 'related_to_type', 'owner_id'],\n      // Operator-only filter \u2014 priority and status, no tokens \u2014 and the reason\n      // recorded here for that has expired (#782). Two claims stood here; both\n      // were wrong already on 17.0.0-rc.2 \u2014 the version this repo pinned AT\n      // THE TIME they were measured, not the current pin \u2014 in different\n      // ways. \"Wrong\" is about those two\n      // retired claims, not about the engine: nothing in this block reports\n      // broken platform behaviour.\n      //\n      // \u26A0\uFE0F READ THE VERSION ON EACH READING BELOW. They were taken at\n      // several different pins and are labelled individually; a reading\n      // labelled 17.2.0 was taken there and has NOT been re-taken on any later\n      // pin unless it says so.\n      //\n      // `{current_user_id}` DOES interpolate. `resolveFilterTokens()` was wired\n      // into the ObjectQL READ path at 17.0.0-rc.0 (objectql #3582) ahead of\n      // the middleware chain, covering `find` / `findOne` / `count` /\n      // `aggregate` \u2014 saved-view filters included. `my_open_tasks`, the view\n      // directly above, ships that exact token. Measured in #784 with two probes\n      // that separate the three possible outcomes: `owner_id =\n      // {current_org_id}` returned 0 rows (the filter is not being dropped)\n      // while `owner_id = {current_user_id}` returned every seeded task (not a\n      // literal-string compare either \u2014 the literal matches no owner at all).\n      // RE-MEASURED 2026-09-03 on 17.2.0 (#1467), unchanged: both probes\n      // reported exactly those results there. NOT re-run on 17.3.0 (#1676) \u2014\n      // the two-probe result is a 17.2.0 reading, and the seam it rests on\n      // (`resolveFilterTokens()` on the read path) was re-confirmed on 17.4.0\n      // by `test/flow-filter-today-token.test.ts` (not yet re-run on 17.5.0).\n      //\n      // `{TODAY()}` is not a spelling of anything and never was. The vocabulary\n      // is `{today}` / `{yesterday}` / `{tomorrow}` / `{now}`, the period\n      // tokens, and the parameterised `{N_days_ago}` family.\n      //\n      // \u26A0\uFE0F WHAT CHANGED between rc.2 and 17.4.0 \u2014 the one reading in\n      // this block that did NOT survive re-measurement, and the reason the\n      // version qualifiers here are load-bearing rather than bookkeeping. On\n      // rc.2 `{TODAY()}` was not REJECTED either: the placeholder grammar was\n      // `/^\\$?\\{([a-zA-Z0-9_]+)\\}$/`, parentheses fell outside it,\n      // `classifyFilterToken('{TODAY()}')` returned null, and the string\n      // reached the driver verbatim and compared as text. From 17.2.0 on \u2014\n      // re-confirmed on 17.3.0 (#1676) and again on 17.4.0\n      // (#1883) by the PREMISE case in\n      // `test/flow-filter-today-token.test.ts`, which drives a real engine \u2014\n      // that is FALSE: `FILTER_TOKEN_WRAPPED_RE` in `@objectstack/spec/data`\n      // now reads `/^\\$?\\{([^{}]+)\\}$/`, which DOES match `TODAY()`, so it\n      // classifies as `kind: 'unknown'` and `resolveFilterTokens()` throws\n      // `UnknownFilterTokenError` (`FILTER_TOKEN_UNKNOWN`, HTTP 400) \u2014 the same\n      // envelope `{TODAY}` gets. The change landed at 17.0.0-rc.6 and this repo\n      // already pins it elsewhere: `test/flow-filter-today-token.test.ts`\n      // (#1107). That is also why the `src/*/flows` sweeps that still spell\n      // `{TODAY()}` work \u2014 `interpolateFilter()` resolves it before ObjectQL\n      // sees the filter at all.\n      //\n      // Measured on rc.2 over a four-row `crm_task` fixture (due 30d ago / 1d\n      // ago / today / in 7d), and RE-MEASURED 2026-09-03 on 17.2.0 (#1467)\n      // over the same fixture \u2014 three rows unchanged, the fourth not. \u26D4 The\n      // row COUNTS below are a 17.2.0 reading and were NOT re-taken on 17.3.0\n      // (#1676); what WAS re-confirmed there is the throw/resolve verdict in\n      // the right-hand column, by `test/flow-filter-today-token.test.ts`:\n      //\n      //                                  rc.2               17.2.0\n      //     due_date <  '{today}'    ->  2 rows (past-due)  2 rows\n      //     due_date <= '{today}'    ->  3 rows             3 rows\n      //     due_date <  '{TODAY}'    ->  throws             throws\n      //     due_date <  '{TODAY()}'  ->  ALL 4 rows         throws\n      //\n      // (Both throws are `UnknownFilterTokenError`, `FILTER_TOKEN_UNKNOWN`.)\n      //\n      // So the #744 lexicographic inversion ('2026-\u2026' sorts below '{') is NOT\n      // still live on this path, and \u26D4 nothing here should carry a workaround\n      // for it: on rc.2 it reached every spelling the grammar could not see,\n      // and the 17.2.0 grammar sees them all. The author-time guard in\n      // `test/metadata-references.test.ts` \u2014 it scans the broader\n      // `/\\{([^{}]+)\\}/` and rejects any token neither path resolves \u2014 still\n      // earns its keep, by failing at authoring time rather than as a 400 in a\n      // user's face, and by covering the analytics path the engine gate does\n      // not.\n      //\n      // Correcting the comment is not a licence to change the filter. Whether\n      // this view should carry a date bound at all \u2014 and whether a label\n      // reading \"My Priority Tasks\" over a filter with no owner condition is\n      // the right name \u2014 are BEHAVIOUR decisions on #770's line for the task\n      // views, not this one's.\n      //\n      // The sort below is due_date-MAJOR, not priority-major: `priority_rank\n      // desc` only breaks ties inside a single due date, so a high task due\n      // tomorrow outranks an urgent one due next week. Measured on rc.2 with\n      // the shipped sort over four rows \u2014 soon/urgent, soon/high, later/urgent,\n      // later/high, in that order. What stood here said the sort \"puts urgent\n      // at top\", which is what the OTHER key order would do.\n      filter: [\n        { field: 'status', operator: 'in', value: ['not_started', 'in_progress'] },\n        { field: 'priority', operator: 'in', value: ['high', 'urgent'] },\n      ],\n      sort: [{ field: 'due_date', order: 'asc' }, { field: 'priority_rank', order: 'desc' }],\n    },\n\n    /** Overdue / open tasks across the team \u2014 sorted oldest-due first */\n    overdue_tasks: {\n      name: 'overdue_tasks',\n      type: 'grid',\n      // Honest label. Two independent reasons were recorded for it; one still\n      // holds and one has expired (#782), so they are separated here.\n      //\n      // STILL TRUE \u2014 `is_overdue` is a WRITE-TIME snapshot. `task.hook.ts:68`\n      // stamps it in `beforeSave` off that moment's clock (`effDue < todayStr`\n      // and not completed) and nothing re-stamps it afterwards, so a task that\n      // was on time when it was last saved still reads `is_overdue = false` the\n      // day after its due date passes. A filter on that column would hand back\n      // the wrong rows, and it would go wrong silently.\n      //\n      // EXPIRED \u2014 the other reason said the view layer cannot resolve\n      // `due_date < {TODAY()}`, and that only `{current_user_id}` interpolates.\n      // Both halves were wrong already on 17.0.0-rc.2 \u2014 the version this repo\n      // pinned AT THE TIME they were measured, not the current pin \u2014 and the\n      // file said the opposite of\n      // itself: the note on `todays_tasks` above asserted that\n      // `{current_user_id}` does NOT interpolate. It does.\n      // That comment carries the measurements with their versions, INCLUDING\n      // the one that moved: `{TODAY()}` is REJECTED from 17.2.0 on\n      // (`FILTER_TOKEN_UNKNOWN`, re-confirmed on 17.3.0 and again on\n      // 17.4.0 by\n      // `test/flow-filter-today-token.test.ts`) where on rc.2 it shipped to\n      // the driver as text, so \"cannot resolve `{TODAY()}`\" is wrong on the\n      // current pin for a different reason than it was wrong on rc.2. The\n      // canonical `{today}` resolves on the read path either way, so a\n      // strictly past-due filter IS expressible: `due_date < '{today}'`\n      // selected exactly the past-due rows out of four on rc.2, and did again\n      // on 17.2.0 (RE-MEASURED 2026-09-03; that row count was not re-taken on\n      // 17.3.0, where the token's resolution is re-confirmed by the test file\n      // named above).\n      //\n      // So the honest statement is narrower than the one that stood here: this\n      // view CAN be given a strictly past-due cut through `{today}`, and is not\n      // given one. Adding it is a BEHAVIOUR change, not a comment correction \u2014\n      // it would drop today's due-today work out of the queue and turn an\n      // \"Open Tasks\" backlog into a strict overdue list, which is the\n      // cut-versus-ranking question already open on #770 for the task views.\n      // That also retires the follow-up this comment used to end on: an hourly\n      // flow re-stamping `is_overdue` was proposed as the ONLY route to a\n      // truly-overdue gauge, because the filter route was believed closed.\n      // There are two routes now, and choosing between them belongs to #770.\n      //\n      // As shipped: the open-task backlog ordered most-overdue-first (oldest\n      // due date on top), which is the actionable queue a manager works.\n      label: '\u23F0 Open Tasks \u00B7 Most Overdue First',\n      userActions: { editInline: true },\n      data: { provider: 'object', object: 'crm_task' },\n      columns: ['subject', 'priority', 'status', 'due_date', 'owner_id'],\n      filter: [\n        { field: 'is_completed', operator: 'equals', value: false },\n      ],\n      sort: [{ field: 'due_date', order: 'asc' }],\n    },\n  },\n\n  form: {\n    type: 'simple',\n    sections: [\n      {\n        name: 'task',\n        label: 'Task',\n        columns: 2,\n        // `type` (call / email / meeting / demo) is what makes an activity\n        // history readable and is the first thing a rep reaches for after the\n        // subject \u2014 it was missing entirely. `description` captures what was\n        // actually said on the call. `progress_percent` moved to the Effort\n        // section: a task being filed is 0% by definition, so a percentage\n        // slider on the create form is noise.\n        fields: [\n          { field: 'subject', required: true, span: 'full' },\n          { field: 'type', required: false },\n          { field: 'status', required: true },\n          'priority',\n          'due_date',\n          'owner_id',\n          'reminder_date',\n          { field: 'description', span: 'full' },\n        ],\n      },\n      {\n        name: 'related_records',\n        label: 'Related Records',\n        collapsible: true,\n        columns: 2,\n        fields: [\n          'related_to_account',\n          'related_to_contact',\n          'related_to_opportunity',\n          'related_to_lead',\n          'related_to_case',\n        ],\n      },\n      {\n        name: 'recurrence_and_effort',\n        label: 'Recurrence & Effort',\n        collapsible: true,\n        collapsed: true,\n        columns: 2,\n        fields: [\n          'is_recurring',\n          'recurrence_type',\n          'recurrence_interval',\n          'recurrence_end_date',\n          'progress_percent',\n        ],\n      },\n    ],\n  },\n});\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/sales/views/event.view.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/sales/views\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/sales/views/event.view.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport { defineView } from '@objectstack/spec/ui';\n\n/**\n * Event Views (#592)\n *\n *   \u2022 grid     \u2014 every interaction, most recent first\n *   \u2022 calendar \u2014 the schedule, start \u2192 end (the platform view type the issue asks for)\n *   \u2022 timeline \u2014 the same rows laid out per rep\n *   \u2022 mine     \u2014 my calendar\n *   \u2022 upcoming \u2014 what is booked but has not happened yet\n *   \u2022 held     \u2014 what actually happened, the interaction history\n *\n * # Why no \"past events\" filter on a date\n *\n * The list-view data path resolves ONLY the user tokens (`{current_user_id}`);\n * date macros ship to the server as literal strings, and because\n * `'2026-\u2026' < '{\u2026'` is lexicographically true, a `start_datetime < {today}`\n * filter matches the FUTURE rows instead of the past ones \u2014 inverted, not\n * merely empty (the same trap `overdue_tasks` documents). So the past/future\n * split is expressed with `status`, which is authored and does not decay, and\n * the ordering does the rest.\n */\nexport const EventViews = defineView({\n  list: {\n    type: 'grid',\n    name: 'all_events',\n    label: 'All Events',\n    userActions: { editInline: true },\n    data: { provider: 'object', object: 'crm_event' },\n    columns: [\n      { field: 'subject', width: 280, sortable: true, link: true },\n      { field: 'type', width: 120, sortable: true },\n      { field: 'status', width: 120, sortable: true },\n      { field: 'start_datetime', width: 180, sortable: true },\n      { field: 'duration_minutes', width: 120, align: 'right' },\n      { field: 'location', width: 180 },\n      { field: 'owner_id', width: 150 },\n    ],\n    sort: [{ field: 'start_datetime', order: 'desc' }],\n    rowColor: {\n      // Mirrors the option colors on crm_event.status.\n      field: 'status',\n      colors: { planned: 'blue', held: 'green', cancelled: 'slate', no_show: 'orange' },\n    },\n    selection: { type: 'multiple' },\n    pagination: { pageSize: 50 },\n    appearance: {\n      showDescription: true,\n      allowedVisualizations: ['grid', 'calendar', 'timeline', 'kanban'],\n    },\n    // Binds the 'calendar' entry above: the same span the dedicated\n    // `event_calendar` view shows. `start_datetime` is required + notNull;\n    // `end_datetime` is optional, so an event without one stays a single point\n    // in time rather than borrowing a neighbour's end.\n    calendar: {\n      startDateField: 'start_datetime',\n      endDateField: 'end_datetime',\n      titleField: 'subject',\n      colorField: 'type',\n    },\n  },\n\n  listViews: {\n    /** The calendar the issue asks for \u2014 start \u2192 end, coloured by kind. */\n    event_calendar: {\n      name: 'event_calendar',\n      type: 'calendar',\n      label: 'Event Calendar',\n      data: { provider: 'object', object: 'crm_event' },\n      columns: ['subject', 'type', 'owner_id'],\n      calendar: {\n        startDateField: 'start_datetime',\n        endDateField: 'end_datetime',\n        titleField: 'subject',\n        colorField: 'type',\n      },\n    },\n\n    /** Who is booked when \u2014 one lane per rep. */\n    event_timeline: {\n      name: 'event_timeline',\n      type: 'timeline',\n      label: 'Team Schedule',\n      data: { provider: 'object', object: 'crm_event' },\n      columns: ['subject', 'status'],\n      timeline: {\n        startDateField: 'start_datetime',\n        endDateField: 'end_datetime',\n        titleField: 'subject',\n        groupByField: 'owner_id',\n        colorField: 'type',\n        scale: 'day',\n      },\n    },\n\n    my_events: {\n      name: 'my_events',\n      type: 'calendar',\n      label: 'My Calendar',\n      data: { provider: 'object', object: 'crm_event' },\n      columns: ['subject', 'type', 'location'],\n      // `{current_user_id}` is the one token the list-view data path really\n      // interpolates (see crm.app.ts's \"My Work\" note).\n      filter: [{ field: 'owner_id', operator: 'equals', value: '{current_user_id}' }],\n      calendar: {\n        startDateField: 'start_datetime',\n        endDateField: 'end_datetime',\n        titleField: 'subject',\n        colorField: 'type',\n      },\n    },\n\n    /** Booked, not yet held \u2014 soonest first. */\n    upcoming_events: {\n      name: 'upcoming_events',\n      type: 'grid',\n      label: '\uD83D\uDCC5 Upcoming \u00B7 Soonest First',\n      userActions: { editInline: true },\n      data: { provider: 'object', object: 'crm_event' },\n      columns: ['subject', 'type', 'start_datetime', 'location', 'related_to_type', 'owner_id'],\n      filter: [{ field: 'status', operator: 'equals', value: 'planned' }],\n      sort: [{ field: 'start_datetime', order: 'asc' }],\n    },\n\n    /** What actually happened \u2014 the interaction history the CRM could not show. */\n    held_events: {\n      name: 'held_events',\n      type: 'grid',\n      label: '\u2705 Interaction History',\n      userActions: { editInline: true },\n      data: { provider: 'object', object: 'crm_event' },\n      columns: ['subject', 'type', 'start_datetime', 'duration_minutes', 'related_to_type', 'owner_id'],\n      filter: [{ field: 'status', operator: 'equals', value: 'held' }],\n      sort: [{ field: 'start_datetime', order: 'desc' }],\n    },\n  },\n\n  form: {\n    type: 'simple',\n    sections: [\n      {\n        name: 'event',\n        label: 'Event',\n        columns: 2,\n        fields: [\n          { field: 'subject', required: true, span: 'full' },\n          { field: 'type', required: true },\n          { field: 'status', required: true },\n          'owner_id',\n          'location',\n          { field: 'description', span: 'full' },\n        ],\n      },\n      {\n        name: 'schedule',\n        label: 'Schedule',\n        columns: 2,\n        fields: [\n          { field: 'start_datetime', required: true },\n          'end_datetime',\n          'all_day',\n          'duration_minutes',\n        ],\n      },\n      {\n        name: 'related_records',\n        label: 'Related Records',\n        collapsible: true,\n        columns: 2,\n        fields: [\n          'related_to_account',\n          'related_to_contact',\n          'related_to_opportunity',\n          'related_to_lead',\n          'related_to_case',\n        ],\n      },\n      {\n        name: 'outcome',\n        label: 'Outcome',\n        collapsible: true,\n        collapsed: true,\n        columns: 1,\n        fields: ['outcome_notes'],\n      },\n    ],\n  },\n});\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/sales/views/event_attendee.view.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/sales/views\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/sales/views/event_attendee.view.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport { defineView } from '@objectstack/spec/ui';\n\n/**\n * Event Attendee Views (#592)\n *\n * A junction object is normally edited inside its parent's related list, and\n * `crm_event_attendee` is no exception. It carries no navigation entry: an\n * attendee is never something you go looking for on its own, you reach it\n * through the meeting.\n *\n * # What each half of this bundle actually renders \u2014 measured (#944)\n *\n * This header used to justify both halves in one sentence: the related list\n * renders THIS view's columns, the quick-create modal renders THIS form, and\n * without them the panel falls back to every column in declaration order while\n * the modal offers the raw autonumber \u2014 \"for the same reason\n * `crm_campaign_member` has them\". `crm_campaign_member` has no view metadata\n * at all, which is what sent #944 looking; re-measuring the paragraph against\n * the shipped Console (17.0.0-rc.3) left only the form half standing.\n *\n * **`form` \u2014 live.** The Console merges a view bundle's `form` onto the object\n * definition it holds, and the record drawer a related list opens (\"New\" on\n * the panel, edit on a row) renders that form's `sections`. What the authored\n * form buys is the section split and the field order \u2014 not rescue from a raw\n * autonumber, because the no-form fallback is not raw either: in `create` mode\n * the drawer drops `autonumber`, `formula` and `summary` fields (and anything\n * hidden or readonly) and sections whatever is left by the object's own\n * `fieldGroups`. `attendee_number` was never on offer.\n *\n * **`list` \u2014 not what the related list reads.** A detail-page related list\n * takes its columns from the CHILD's lookup field \u2014 `relatedListColumns` on\n * `crm_event`, which this app authors nowhere \u2014 and falls back to the child\n * object's `highlightFields` minus the parent lookup, capped at six, with\n * columns that are empty on every fetched row dropped. Only an object with no\n * `highlightFields` reaches the last resort, and that is a heuristic over the\n * field map (title-ish names first, audit columns last, `rich_text` / `html` /\n * `json` excluded) \u2014 not declaration order, and never this view. So the\n * attendee panel on a meeting shows `attendee_type`, `response` and\n * `is_organizer`, straight off `crm_event_attendee.highlightFields`, whatever\n * the columns below say.\n *\n * The grid is therefore reachable only at this object's own list URL, which no\n * navigation entry links to. It is kept as the curated answer to \"what do you\n * show about an attendee\", and it is what a future `relatedListColumns` would\n * be copied from \u2014 but nothing in this repo may cite it as what makes a\n * related list readable. The load-bearing metadata is `highlightFields`, and\n * `test/view-references.test.ts` pins it for every object reached only through\n * a parent: strip it and the panel really does fall to the heuristic, which\n * leads with the autonumber these objects use as their `nameField`.\n */\nexport const EventAttendeeViews = defineView({\n  list: {\n    type: 'grid',\n    name: 'all_event_attendees',\n    label: 'Event Attendees',\n    userActions: { editInline: true },\n    data: { provider: 'object', object: 'crm_event_attendee' },\n    columns: [\n      { field: 'attendee_type', width: 120, sortable: true },\n      { field: 'crm_contact', width: 200 },\n      { field: 'crm_lead', width: 200 },\n      { field: 'sys_user', width: 200 },\n      { field: 'external_name', width: 200 },\n      { field: 'response', width: 140, sortable: true },\n      { field: 'is_organizer', width: 100, align: 'center' },\n    ],\n    sort: [{ field: 'is_organizer', order: 'desc' }],\n    rowColor: {\n      // Mirrors the option colors on crm_event_attendee.response.\n      field: 'response',\n      colors: { accepted: 'green', declined: 'red', tentative: 'orange', no_response: 'slate' },\n    },\n    pagination: { pageSize: 25 },\n  },\n\n  form: {\n    type: 'simple',\n    sections: [\n      {\n        name: 'attendee',\n        label: 'Attendee',\n        columns: 2,\n        fields: [\n          { field: 'crm_event', required: true },\n          { field: 'attendee_type', required: true },\n          'crm_contact',\n          'crm_lead',\n          'sys_user',\n          'external_name',\n        ],\n      },\n      {\n        name: 'invitation',\n        label: 'Invitation',\n        columns: 2,\n        fields: ['response', 'is_organizer', 'invited_date'],\n      },\n    ],\n  },\n});\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/sales/views/forecast.view.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/sales/views\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/sales/views/forecast.view.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport { defineView } from '@objectstack/spec/ui';\n\n/**\n * Forecast Views\n *\n *   \u2022 grid            \u2014 every snapshot\n *   \u2022 current_quarter \u2014 owners \u00D7 this-quarter row\n *   \u2022 my_forecast     \u2014 current user's snapshots\n */\nexport const ForecastViews = defineView({\n  list: {\n    type: 'grid',\n    name: 'all_forecasts',\n    label: 'All Forecasts',\n    userActions: { editInline: true },\n    data: { provider: 'object', object: 'crm_forecast' },\n    columns: [\n      { field: 'owner_id',            width: 160, pinned: 'left', link: true },\n      { field: 'period_label',     width: 130, sortable: true },\n      { field: 'period_start',     width: 130, sortable: true },\n      { field: 'snapshot_date',    width: 130, sortable: true },\n      { field: 'quota',            width: 130, align: 'right', summary: 'sum' },\n      { field: 'closed_amount',    width: 140, align: 'right', summary: 'sum' },\n      { field: 'commit_amount',    width: 140, align: 'right', summary: 'sum' },\n      { field: 'best_case_amount', width: 140, align: 'right', summary: 'sum' },\n      { field: 'pipeline_amount',  width: 140, align: 'right', summary: 'sum' },\n      // No total here: a formula has no stored column to aggregate, so the spec refuses `sum` on a `formula` field (#1980).\n      { field: 'expected_amount',  width: 140, align: 'right' },\n      { field: 'attainment_pct',   width: 130, align: 'right' },\n      { field: 'coverage_ratio',   width: 130, align: 'right' },\n      { field: 'source',           width: 130 },\n    ],\n    sort: [\n      { field: 'period_start',  order: 'desc' },\n      { field: 'owner_id',         order: 'asc' },\n    ],\n    grouping: { fields: [{ field: 'period_label', order: 'desc' }] },\n    pagination: { pageSize: 50 },\n    appearance: { allowedVisualizations: ['grid'] },\n  },\n\n  listViews: {\n    this_quarter_forecasts: {\n      name: 'this_quarter_forecasts',\n      type: 'grid',\n      // The label promises the CURRENT quarter, and the filter delivers it.\n      //\n      // The restriction was dropped in #515 on the measurement that \"the list\n      // data path resolves no date macro\". That measurement was taken on\n      // @objectstack 16.1.0 and has since expired: `resolveFilterTokens()` was\n      // wired into the ObjectQL READ path in 17.0.0-rc.0 (objectql\n      // `feat(filters): evaluate {filter-token} placeholders server-side`,\n      // #3582) \u2014 `find`/`findOne`/`count`/`aggregate`, ahead of the middleware\n      // chain, which is the one gate every server-side read passes through,\n      // saved-view filters included. Measured rather than inferred;\n      // `test/forecast-current-quarter-view.test.ts` runs THIS filter through a\n      // real engine and pins the three-way outcome (one quarter selected, not\n      // zero and not all of them). First taken on 17.0.0-rc.2, RE-RUN\n      // 2026-09-03 on 17.2.0 (#1467), RE-RUN on 17.3.0 (#1676, after the PR\n      // #1577 bump) and RE-RUN again on 17.4.0 (#1883, after the PR #1814\n      // bump), green all four times. Not yet re-run on 17.5.0; the test is\n      // what re-takes the reading on each new pin.\n      //\n      // Both halves of the key are load-bearing, same as the quota-attainment\n      // widget in `src/sales/dashboards/sales.dashboard.ts`: `period: 'quarter'`\n      // alone returns every quarter ever snapshotted (the #730 defect), and\n      // `period_start` alone merges the quarter row with the MONTH row that\n      // opens the same quarter \u2014 Q3 and July both start on the 1st.\n      //\n      // The old `{this_quarter_start}` spelling is not merely unresolved now,\n      // it is rejected: the resolver throws `Unresolvable filter placeholder`\n      // and names `{current_quarter_start}` as the fix, so the silent-empty\n      // failure mode that removal was reacting to is no longer reachable.\n      label: 'This Quarter',\n      userActions: { editInline: true },\n      data: { provider: 'object', object: 'crm_forecast' },\n      columns: ['owner_id', 'quota', 'closed_amount', 'commit_amount', 'best_case_amount', 'pipeline_amount', 'attainment_pct', 'coverage_ratio'],\n      filter: [\n        { field: 'period', operator: 'equals', value: 'quarter' },\n        { field: 'period_start', operator: 'equals', value: '{current_quarter_start}' },\n      ],\n      // One sort key, because the filter pins `period_start` to a single value\n      // \u2014 the `period_start desc` key that ranked quarters against each other\n      // existed only to float the current quarter to the top of an unscoped\n      // list, and is provably inert now that the list holds one quarter.\n      //\n      // The tiebreaker is NOT `attainment_pct desc`, which is a FORMULA \u2014 the\n      // engine computes it in JS after the query, so the data engine never saw\n      // that sort key and the ordering within a quarter was arbitrary (same\n      // class of defect as #489's `days_in_stage` filter). `closed_amount` is\n      // the stored numerator behind attainment and ranks the same direction.\n      sort: [\n        { field: 'closed_amount', order: 'desc' },\n      ],\n      // Empty is the honest state, and it needs to say so. The seeds ship no\n      // current-quarter row on purpose (#702 \u2014 the sweep owns that window, and\n      // two producers in one window is what left a phantom ownerless\n      // duplicate), so on a fresh install this view is empty until the 03:00\n      // `forecast_snapshot` sweep has run once. That is the same trade the\n      // quota-attainment widget already takes; without this copy the user\n      // cannot tell it apart from a broken view.\n      emptyState: {\n        title: 'This Quarter Has No Snapshots Yet',\n        message: 'Quarterly snapshots are written by the nightly forecast sweep. Until it has run once for the current quarter this view is empty \u2014 settled quarters are on the All tab.',\n        icon: 'calendar',\n      },\n    },\n    my_forecast: {\n      name: 'my_forecast',\n      type: 'grid',\n      label: 'My Forecast',\n      userActions: { editInline: true },\n      data: { provider: 'object', object: 'crm_forecast' },\n      columns: ['period_label', 'snapshot_date', 'quota', 'closed_amount', 'commit_amount', 'pipeline_amount', 'attainment_pct'],\n      // `{current_user_id}` is the only user token the view runtime resolves\n      // (`{current_user}` silently never matches).\n      filter: [{ field: 'owner_id', operator: 'equals', value: '{current_user_id}' }],\n      sort: [{ field: 'period_start', order: 'desc' }],\n    },\n  },\n\n  form: {\n    type: 'simple',\n    sections: [\n      {\n        name: 'snapshot',\n        label: 'Snapshot',\n        columns: 2,\n        fields: ['owner_id', 'period', 'period_start', 'period_end', 'period_label', 'snapshot_date', 'source'],\n      },\n      {\n        name: 'amounts',\n        label: 'Amounts',\n        columns: 2,\n        fields: ['quota', 'closed_amount', 'commit_amount', 'best_case_amount', 'pipeline_amount', 'expected_amount', 'attainment_pct', 'coverage_ratio'],\n      },\n      {\n        name: 'notes',\n        label: 'Notes',\n        columns: 1,\n        fields: ['notes'],\n      },\n    ],\n  },\n});\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/revenue/views/index.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/revenue/views\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/revenue/views/index.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\n/**\n * Revenue views barrel.\n *\n * The doctrine for this metadata type is written once, in\n * `src/sales/views/index.ts`; this file is the revenue package's half of\n * the same file-by-file registration.\n */\n\nexport { ContractViews } from './contract.view';\nexport { ProductViews } from './product.view';\nexport { QuoteViews } from './quote.view';\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/revenue/views/contract.view.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/revenue/views\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/revenue/views/contract.view.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport { defineView } from '@objectstack/spec/ui';\n\n/**\n * Contract Views\n *\n *   \u2022 grid     \u2014 contract register with renewal info\n *   \u2022 calendar \u2014 start/end dates\n *   \u2022 gantt    \u2014 contract terms timeline\n *   \u2022 timeline \u2014 chronological contract stream\n */\nexport const ContractViews = defineView({\n  list: {\n    type: 'grid',\n    name: 'all_contracts',\n    label: 'All Contracts',\n    userActions: { editInline: true },\n    data: { provider: 'object', object: 'crm_contract' },\n    columns: [\n      { field: 'contract_number', width: 150, link: true, pinned: 'left' },\n      { field: 'crm_account', width: 200 },\n      { field: 'crm_opportunity', width: 200 },\n      { field: 'status', width: 130, sortable: true },\n      { field: 'contract_value', width: 140, align: 'right', summary: 'sum' },\n      { field: 'contract_term_months', width: 130, align: 'right' },\n      { field: 'start_date', width: 130, sortable: true },\n      { field: 'end_date', width: 130, sortable: true },\n      { field: 'auto_renewal', width: 110, align: 'center' },\n      { field: 'owner_id', width: 150 },\n    ],\n    sort: [{ field: 'end_date', order: 'asc' }],\n    pagination: { pageSize: 25 },\n    selection: { type: 'multiple' },\n    appearance: {\n      allowedVisualizations: ['grid', 'calendar', 'gantt', 'timeline'],\n    },\n    // Binds the 'calendar' entry above: renewal dates, same as the dedicated\n    // `renewal_calendar` view and the field this list sorts by. A contract\n    // calendar answers \"what renews when\" \u2014 the start -> end term SPAN is\n    // already carried by `contract_gantt` and `contract_timeline`, which is\n    // why `end_date` is the start of the event here rather than an end.\n    calendar: {\n      startDateField: 'end_date',\n      titleField: 'contract_number',\n      colorField: 'status',\n    },\n  },\n\n  listViews: {\n    /** Renewal calendar (highlights upcoming end dates) */\n    renewal_calendar: {\n      name: 'renewal_calendar',\n      type: 'calendar',\n      label: 'Renewal Calendar',\n      data: { provider: 'object', object: 'crm_contract' },\n      columns: ['contract_number', 'crm_account', 'status'],\n      calendar: {\n        startDateField: 'end_date',\n        titleField: 'contract_number',\n        colorField: 'status',\n      },\n    },\n\n    /** Contract terms gantt */\n    contract_gantt: {\n      name: 'contract_gantt',\n      type: 'gantt',\n      label: 'Contract Terms',\n      data: { provider: 'object', object: 'crm_contract' },\n      columns: ['contract_number', 'crm_account', 'contract_value'],\n      gantt: {\n        startDateField: 'start_date',\n        endDateField: 'end_date',\n        titleField: 'contract_number',\n      },\n    },\n\n    /** Chronological timeline */\n    contract_timeline: {\n      name: 'contract_timeline',\n      type: 'timeline',\n      label: 'Contract Timeline',\n      data: { provider: 'object', object: 'crm_contract' },\n      columns: ['contract_number', 'crm_account'],\n      timeline: {\n        startDateField: 'start_date',\n        endDateField: 'end_date',\n        titleField: 'contract_number',\n        groupByField: 'crm_account',\n        colorField: 'status',\n        scale: 'quarter',\n      },\n    },\n  },\n\n  form: {\n    type: 'tabbed',\n    sections: [\n      {\n        name: 'parties',\n        label: 'Parties',\n        columns: 2,\n        fields: ['contract_number', 'crm_account', 'crm_contact', 'crm_opportunity', 'owner_id', 'status'],\n      },\n      {\n        // Named `contract_terms`, not `terms` \u2014 `terms` is already a distinct\n        // fieldGroup key on `crm_contract` (\"Terms & Dates\"), and reusing it\n        // here would make this section's translated heading follow that\n        // group's wording instead of its own \"Terms\".\n        name: 'contract_terms',\n        label: 'Terms',\n        columns: 2,\n        fields: [\n          'contract_term_months',\n          'start_date',\n          'end_date',\n          'contract_value',\n          'billing_frequency',\n          'payment_terms',\n          'auto_renewal',\n          'renewal_notice_days',\n        ],\n      },\n      {\n        name: 'signing_and_documents',\n        label: 'Signing & Documents',\n        columns: 2,\n        fields: ['signed_date', 'signed_by', 'document_url'],\n      },\n      {\n        // The contract's two markdown bodies, together and in the order a\n        // reader needs them \u2014 the question #1826 asked this form to answer.\n        // They are not redundant, and `content/docs/revenue/contracts.mdx`\n        // already rules which is which: **Description** is the plain summary\n        // of what this contract is (declared on the `basic` group, listed\n        // there under \"Contract Information\"), while **Special Terms** is\n        // where every free-text TERM goes \u2014 the doc sends renewal\n        // instructions, an unlisted billing cadence and an unlisted payment\n        // arrangement to Special Terms by name, three separate times.\n        // Description was the one field in that inventory no form offered, so\n        // the summary a reader was told the record carries could not be\n        // written. One column, because both are long-form.\n        name: 'notes',\n        label: 'Notes',\n        columns: 1,\n        fields: ['description', 'special_terms', 'billing_address'],\n      },\n    ],\n  },\n});\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/revenue/views/product.view.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/revenue/views\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/revenue/views/product.view.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport { defineView } from '@objectstack/spec/ui';\n\n/**\n * Product Views\n *\n *   \u2022 grid    \u2014 catalog listing\n *   \u2022 gallery \u2014 visual product catalog (`image` as cover)\n *\n * The `low_stock` view was removed with the inventory fields it was built on:\n * its columns, its filter and its sort key were all `quantity_on_hand` /\n * `reorder_point`, so it could not outlive them. It was never the stock report\n * it looked like either \u2014 the filter compared against a hardcoded 10 rather\n * than each product's own reorder point.\n */\nexport const ProductViews = defineView({\n  list: {\n    type: 'grid',\n    name: 'all_products',\n    label: 'All Products',\n    userActions: { editInline: true },\n    data: { provider: 'object', object: 'crm_product' },\n    columns: [\n      { field: 'product_code', width: 140, link: true, pinned: 'left' },\n      { field: 'name', width: 240, sortable: true },\n      { field: 'category', width: 140 },\n      { field: 'family', width: 140 },\n      { field: 'sku', width: 140 },\n      { field: 'list_price', width: 130, align: 'right', summary: 'avg' },\n      { field: 'cost', width: 130, align: 'right' },\n      { field: 'is_active', width: 100, align: 'center' },\n    ],\n    sort: [{ field: 'name', order: 'asc' }],\n    grouping: { fields: [{ field: 'category', order: 'asc' }] },\n    pagination: { pageSize: 50 },\n    selection: { type: 'multiple' },\n    appearance: {\n      allowedVisualizations: ['grid', 'gallery'],\n    },\n  },\n\n  listViews: {\n    /** Visual catalog */\n    product_catalog: {\n      name: 'product_catalog',\n      type: 'gallery',\n      label: 'Product Catalog',\n      data: { provider: 'object', object: 'crm_product' },\n      columns: ['name', 'category', 'list_price'],\n      gallery: {\n        coverField: 'image',\n        coverFit: 'cover',\n        cardSize: 'medium',\n        titleField: 'name',\n        visibleFields: ['product_code', 'category', 'family', 'list_price', 'sku'],\n      },\n    },\n  },\n\n  form: {\n    type: 'simple',\n    sections: [\n      {\n        name: 'product_info',\n        label: 'Product Info',\n        columns: 2,\n        fields: [\n          'product_code',\n          { field: 'name', required: true, span: 'full' },\n          'category',\n          'family',\n          'sku',\n          'product_manager',\n          'is_active',\n        ],\n      },\n      {\n        name: 'pricing_info',\n        label: 'Pricing',\n        columns: 2,\n        fields: ['list_price', 'cost'],\n      },\n      {\n        name: 'media',\n        label: 'Media',\n        columns: 1,\n        fields: ['image', 'datasheet', 'description'],\n      },\n    ],\n  },\n});\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/revenue/views/quote.view.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/revenue/views\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/revenue/views/quote.view.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport { defineView } from '@objectstack/spec/ui';\n\n/**\n * Quote Views\n *\n *   \u2022 grid     \u2014 quote register with totals\n *   \u2022 kanban   \u2014 quote workflow grouped by status\n *   \u2022 calendar \u2014 quote-date calendar\n */\nexport const QuoteViews = defineView({\n  list: {\n    type: 'grid',\n    name: 'all_quotes',\n    label: 'All Quotes',\n    userActions: { editInline: true },\n    data: { provider: 'object', object: 'crm_quote' },\n    columns: [\n      { field: 'quote_number', width: 140, link: true, pinned: 'left' },\n      { field: 'crm_account', width: 200 },\n      { field: 'crm_opportunity', width: 200 },\n      { field: 'status', width: 130, sortable: true },\n      { field: 'quote_date', width: 130, sortable: true },\n      { field: 'expiration_date', width: 140, sortable: true },\n      { field: 'subtotal', width: 130, align: 'right', summary: 'sum' },\n      { field: 'discount', width: 110, align: 'right' },\n      { field: 'tax', width: 110, align: 'right', summary: 'sum' },\n      { field: 'total_price', width: 140, align: 'right', summary: 'sum' },\n      { field: 'owner_id', width: 150 },\n    ],\n    sort: [{ field: 'quote_date', order: 'desc' }],\n    pagination: { pageSize: 25 },\n    selection: { type: 'multiple' },\n    appearance: {\n      allowedVisualizations: ['grid', 'kanban', 'calendar'],\n    },\n    // Binds the 'calendar' entry above: the same span the dedicated\n    // `quote_calendar` view shows. `quote_date` and `expiration_date` are both\n    // required + notNull on crm_quote, so every quote lands on a real window.\n    calendar: {\n      startDateField: 'quote_date',\n      endDateField: 'expiration_date',\n      titleField: 'quote_number',\n      colorField: 'status',\n    },\n  },\n\n  listViews: {\n    /** Quote workflow board */\n    quote_pipeline: {\n      name: 'quote_pipeline',\n      type: 'kanban',\n      label: 'Quote Pipeline',\n      data: { provider: 'object', object: 'crm_quote' },\n      columns: ['quote_number', 'crm_account', 'total_price', 'expiration_date'],\n      kanban: {\n        groupByField: 'status',\n        summarizeField: 'total_price',\n        columns: ['quote_number', 'crm_account', 'total_price', 'expiration_date'],\n      },\n    },\n\n    /** Quote-date calendar */\n    quote_calendar: {\n      name: 'quote_calendar',\n      type: 'calendar',\n      label: 'Quote Calendar',\n      data: { provider: 'object', object: 'crm_quote' },\n      columns: ['quote_number', 'crm_account', 'total_price'],\n      calendar: {\n        startDateField: 'quote_date',\n        endDateField: 'expiration_date',\n        titleField: 'quote_number',\n        colorField: 'status',\n      },\n    },\n  },\n\n  form: {\n    type: 'tabbed',\n    sections: [\n      {\n        name: 'quote',\n        label: 'Quote',\n        columns: 2,\n        // `name` is required on crm_quote with no default \u2014 omitting it made\n        // quote creation through this form impossible.\n        fields: [{ field: 'name', required: true, span: 'full' }, 'quote_number', 'crm_account', 'crm_contact', 'crm_opportunity', 'owner_id', 'status', 'quote_date', 'expiration_date'],\n      },\n      {\n        name: 'totals',\n        label: 'Totals',\n        columns: 2,\n        fields: ['subtotal', 'discount', 'discount_amount', 'tax', 'shipping_handling', 'total_price'],\n      },\n      {\n        // Named `quote_terms`, not `terms` \u2014 `terms` is already a distinct\n        // fieldGroup key on `crm_quote` (\"Terms & Validity\"), and reusing it\n        // here would make this section's translated heading follow that\n        // group's wording instead of its own \"Terms\".\n        name: 'quote_terms',\n        label: 'Terms',\n        columns: 2,\n        fields: ['payment_terms', 'shipping_terms'],\n      },\n      {\n        name: 'addresses_and_notes',\n        label: 'Addresses & Notes',\n        columns: 1,\n        fields: ['billing_address', 'shipping_address', 'internal_notes'],\n      },\n    ],\n  },\n});\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/marketing/views/index.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/marketing/views\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/marketing/views/index.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\n/**\n * Marketing views barrel.\n *\n * The doctrine for this metadata type is written once, in\n * `src/sales/views/index.ts`; this file is the marketing package's half of\n * the same file-by-file registration.\n */\n\nexport { CampaignViews } from './campaign.view';\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/marketing/views/campaign.view.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/marketing/views\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/marketing/views/campaign.view.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport { defineView } from '@objectstack/spec/ui';\n\n/**\n * Campaign Views\n *\n *   \u2022 grid     \u2014 performance grid with aggregated KPIs\n *   \u2022 gantt    \u2014 campaign schedule (start_date \u2192 end_date)\n *   \u2022 calendar \u2014 launch calendar\n *   \u2022 timeline \u2014 multi-campaign chronological view\n */\nexport const CampaignViews = defineView({\n  list: {\n    type: 'grid',\n    name: 'all_campaigns',\n    label: 'All Campaigns',\n    userActions: { editInline: true },\n    data: { provider: 'object', object: 'crm_campaign' },\n    columns: [\n      { field: 'name', width: 240, sortable: true, link: true, pinned: 'left' },\n      { field: 'channel', width: 130 },\n      { field: 'status', width: 130, sortable: true },\n      { field: 'start_date', width: 130, sortable: true },\n      { field: 'end_date', width: 130, sortable: true },\n      { field: 'budgeted_cost', width: 140, align: 'right', summary: 'sum' },\n      { field: 'expected_revenue', width: 160, align: 'right', summary: 'sum' },\n    ],\n    sort: [{ field: 'start_date', order: 'asc' }],\n    pagination: { pageSize: 25 },\n    selection: { type: 'multiple' },\n    appearance: {\n      showDescription: true,\n      allowedVisualizations: ['grid', 'gantt', 'calendar', 'timeline'],\n    },\n    // Binds the 'calendar' entry above: the switcher opens the same schedule\n    // the dedicated `campaign_calendar` view shows. Both dates are required +\n    // notNull on crm_campaign, so every campaign spans a truthful range.\n    calendar: {\n      startDateField: 'start_date',\n      endDateField: 'end_date',\n      titleField: 'name',\n      colorField: 'channel',\n    },\n  },\n\n  listViews: {\n    /** Campaign schedule */\n    campaign_gantt: {\n      name: 'campaign_gantt',\n      type: 'gantt',\n      label: 'Campaign Schedule',\n      data: { provider: 'object', object: 'crm_campaign' },\n      columns: ['name', 'channel'],\n      gantt: {\n        startDateField: 'start_date',\n        endDateField: 'end_date',\n        titleField: 'name',\n      },\n    },\n\n    /** Launch calendar */\n    campaign_calendar: {\n      name: 'campaign_calendar',\n      type: 'calendar',\n      label: 'Launch Calendar',\n      data: { provider: 'object', object: 'crm_campaign' },\n      columns: ['name', 'channel', 'status'],\n      calendar: {\n        startDateField: 'start_date',\n        endDateField: 'end_date',\n        titleField: 'name',\n        colorField: 'channel',\n      },\n    },\n\n    /** Marketing timeline */\n    campaign_timeline: {\n      name: 'campaign_timeline',\n      type: 'timeline',\n      label: 'Marketing Timeline',\n      data: { provider: 'object', object: 'crm_campaign' },\n      // The list data source projects configured columns. Keep the date\n      // fields in that projection so the timeline renderer can bucket and\n      // order campaigns from the same schedule data as the calendar/Gantt.\n      columns: ['name', 'channel', 'start_date', 'end_date'],\n      timeline: {\n        startDateField: 'start_date',\n        endDateField: 'end_date',\n        titleField: 'name',\n        groupByField: 'channel',\n        colorField: 'status',\n        scale: 'month',\n      },\n    },\n  },\n\n  form: {\n    type: 'tabbed',\n    sections: [\n      {\n        // Every form section here carries a `name` matching the object's\n        // fieldGroup key, so the heading resolves through\n        // `objects.crm_campaign._sections.<name>.label` in all four packs. A\n        // nameless section has no key a bundle can carry and renders its\n        // English label in every locale \u2014 the platform warns about exactly this\n        // during `objectstack validate`, and this form was carrying four of\n        // those warnings before the #597 restructure gave it a reason to move.\n        name: 'basic',\n        label: 'Campaign Information',\n        columns: 2,\n        fields: [\n          { field: 'name', required: true, span: 'full' },\n          'campaign_code',\n          'type',\n          'channel',\n          { field: 'status', required: true },\n          'owner_id',\n          'is_active',\n          'landing_page_url',\n          // The markdown body of the campaign brief. Declared on the `basic`\n          // group and filled by seven of the seed campaigns, but omitted from\n          // this enumeration \u2014 so the only surface that could show it did not,\n          // and a marketer could neither read nor write the brief they wrote.\n          { field: 'description', span: 'full' },\n        ],\n      },\n      {\n        name: 'schedule',\n        label: 'Schedule',\n        columns: 2,\n        fields: ['start_date', 'end_date'],\n      },\n      {\n        /**\n         * Budget & ROI \u2014 a SECTION OF ITS OWN, deliberately (#597).\n         *\n         * `budgeted_cost` and `actual_cost` are the only two campaign numbers\n         * that are manual-entry by design: nothing on the platform knows what a\n         * trade-show booth cost. They used to sit seventh and eighth in a\n         * seven-field \"Schedule & Budget\" row, below the dates and beside two\n         * revenue figures one of which the metric hooks own \u2014 so the two fields\n         * a marketer must type were the least visible things on the form, and\n         * `actual_cost` in particular went untyped.\n         *\n         * That is not a cosmetic complaint: `roi` divides by `actual_cost`, and\n         * its formula answers a flat `0.0` for any campaign where that field is\n         * blank. An empty cost field renders as 0% ROI on every campaign \u2014 the\n         * one number the whole Performance section exists to produce, reading\n         * as a real measurement rather than as missing input.\n         *\n         * So the costs get their own heading, and `roi` is displayed HERE with\n         * them rather than at the bottom of Performance, where its dependency\n         * on two fields three sections away was invisible. The heading matches\n         * the object's `budget` fieldGroup, so the form and the detail page\n         * agree on what this group is called.\n         */\n        name: 'budget',\n        label: 'Budget & ROI',\n        columns: 2,\n        fields: ['budgeted_cost', 'actual_cost', 'expected_revenue', 'actual_revenue', 'roi'],\n      },\n      {\n        name: 'metrics',\n        label: 'Performance',\n        columns: 2,\n        fields: [\n          'target_size',\n          'num_sent',\n          'num_responses',\n          'num_leads',\n          'num_converted_leads',\n          'num_opportunities',\n          'num_won_opportunities',\n          'response_rate',\n        ],\n      },\n    ],\n  },\n});\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/sales/pages/index.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/sales/pages\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/sales/pages/index.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\n/**\n * Sales (the app package) pages barrel.\n *\n * The doctrine for this metadata type is written once, in\n * `src/sales/pages/index.ts`; this file is the sales package's half of\n * the same file-by-file registration.\n */\n\nexport { LeadDetailPage } from './lead_detail.page';\nexport { OpportunityDetailPage } from './opportunity_detail.page';\nexport { AccountDetailPage } from './account_detail.page';\nexport { AccountWorkbenchPage } from './account_workbench.page';\nexport { SalesHomePage } from './home.page';\nexport { AppLauncherPage } from './app_launcher.page';\nexport { UtilityBarPage } from './utility_bar.page';\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/sales/pages/lead_detail.page.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/sales/pages\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/sales/pages/lead_detail.page.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport { Page } from '@objectstack/spec/ui';\nimport { P } from '@objectstack/spec';\n\n/**\n * Lead Detail Record Page\n *\n * Demonstrates a comprehensive record page layout similar to Salesforce Lightning Record Page.\n *\n * Features:\n * - Template-based layout with named regions\n * - Rich component composition (details, highlights, related lists)\n * - Component visibility rules\n * - Profile-based page assignment\n */\nexport const LeadDetailPage: Page = {\n  name: 'lead_detail_page',\n  label: 'Lead Detail',\n  description: 'Comprehensive lead detail page with highlights, details, and related information',\n\n  type: 'record',\n  object: 'crm_lead',\n\n  // Template defines the overall layout structure. We use `full-width`\n  // (single column) because the previous `header-sidebar-main` layout\n  // sandwiched the highlights strip into a cramped sidebar with no other\n  // meaningful sidebar content \u2014 Salesforce Lightning record pages\n  // similarly default to a stacked column for medium-density objects.\n  template: 'full-width',\n  kind: 'full',\n  // Page-level state variables\n  variables: [\n    {\n      name: 'showHistory',\n      type: 'boolean',\n      defaultValue: false,\n    },\n    {\n      name: 'activeTab',\n      type: 'string',\n      defaultValue: 'details',\n    },\n  ],\n\n  // Regions correspond to slots in the template\n  regions: [\n    {\n      name: 'header',\n      width: 'full',\n      components: [\n        // Title + subtitle + icon, with record-level actions rendered\n        // inline in the header's action slot via the first-class\n        // `actions` property (no sibling node, no visual offset hack).\n        {\n          type: 'page:header',\n          id: 'lead_header',\n          label: 'Lead Information',\n          properties: {\n            title: '{first_name} {last_name}',\n            subtitle: '{company}',\n            // `icon` removed from `page:header` in @objectstack/spec 17.0.0\n            // (#6946, ADR-0087 D2) \u2014 deleted, not renamed. See the full note on\n            // `account_detail.page.ts`; nothing ever drew it.\n            // `breadcrumb` retired from `page:header` in @objectstack/spec 17.6.0\n            // (#20785, `page-header-breadcrumb-removed`) \u2014 deleted: no renderer\n            // ever drew a trail for it; the app shell's own trail is unchanged.\n            // Convert is the outcome; scheduling the next touch is the daily\n            // act. Both belong in the header \u2014 the follow-up used to be four\n            // clicks deep in the Related tab.\n            //\n            // The three activity actions are listed EXPLICITLY (#592): a custom\n            // record page replaces the synthesized header, so an object-scoped\n            // action that is not named here is unreachable from the record \u2014\n            // only the list-row \u22EE menu can fire it. Logging the call you just\n            // made is the single most frequent thing a rep does on a lead, and\n            // it was two navigations away.\n            //\n            // Action IDs, not `ActionDef` objects: `PageHeaderProps.actions` is\n            // `z.array(z.string())` (\"Action IDs to show in header\") in\n            // @objectstack/spec 17.3.0, and this repo authors against the\n            // protocol (#1653). Each id is the `name` of a crm_lead-scoped\n            // action \u2014 `convert_lead` / `schedule_followup` in\n            // `src/sales/actions/lead.actions.ts`, the activity trio in\n            // `src/sales/actions/activity-actions.ts`.\n            actions: [\n              'convert_lead',\n              'schedule_followup',\n              'log_call',\n              'log_meeting',\n              'schedule_meeting',\n            ],\n          },\n        },\n        // Duplicate banners \u2014 ONE PER VERDICT (#1207 \u00B7 widened by #1289 \u00B7\n        // split by #1628).\n        //\n        // `lead_duplicate_check` (lead.hook.ts, job 2) already writes\n        // `duplicate_status: 'suspected'` and links the record the lead repeats\n        // \u2014 the flag existed, and this page never read it. A rep opened a\n        // flagged lead, saw a page identical to a clean one, and converted it\n        // into a second account, contact and opportunity. These banners and the\n        // `duplicates` section on the Details tab are the record-page half of\n        // that fix \u2014 the banner is the alarm, the section is the link to\n        // compare against; the conversion screen carries the other half.\n        //\n        // ## Why there are TWO of them (#1628)\n        //\n        // #1207 shipped one banner gated on `== \"suspected\"`, which left the\n        // STRONGER state silent. #1289 widened the predicate to every verdict\n        // and, being one component, had to pick copy that named NEITHER state:\n        // a `record:alert` carries a single `visible` and a single title/body\n        // pair, and `pickLocalized` picks by LANGUAGE, not by row \u2014 so naming\n        // one verdict would have mislabelled every lead in the other.\n        //\n        // That was correct for one banner, and it is why one banner is not\n        // enough. Since #1288 the two verdicts have OPPOSITE next steps:\n        //\n        //   suspected \u2014 the intake hook's guess. Conversion PROCEEDS; the rep\n        //               should compare against the linked record first.\n        //   confirmed \u2014 a reviewer's verdict. Conversion is REFUSED outright\n        //               (`lead-conversion.flow.ts`, `refuse_confirmed_duplicate`).\n        //\n        // One sentence cannot state either without being false for the other,\n        // so it stated neither, and the rep had to scroll to the Duplicate\n        // Status chip to learn which situation they were in. A banner that\n        // announces something is wrong but not what to do is not doing the one\n        // job a banner has. Two components, two predicates, two next steps.\n        //\n        // \u26A0\uFE0F Two sibling `record:alert` nodes really do BOTH render: a region\n        // renders as `components.map((node, i) => <SchemaRenderer key={node?.id\n        // || fallback} \u2026>)` \u2014 read out of the shipped console bundle at the\n        // `.objectui-sha` pin \u2014 so each is mounted separately and evaluates its\n        // own `visible` against the same row. Their `id`s are their React keys,\n        // which is why the two ids differ rather than sharing one.\n        //\n        // \u26A0\uFE0F `visible` is the ONE record component whose PROPS carry a real row\n        // predicate: `record-alert.tsx` evaluates `properties.visible` through\n        // `toPredicateInput` + `useCondition` against the row\n        // (`usePredicateRecordContext`), the same pipeline as an action button.\n        // A node-level `visibleWhen` is a different gate one tier up,\n        // evaluated by `SchemaRenderer`, and the two compose as AND. Measured\n        // on the 17.6.0 pin (#1887), that tier binds the page's row as\n        // `record` too (objectui#5454): this same predicate, moved there,\n        // gated correctly in both directions. `visible` stays because it is\n        // the gate `record:alert` declares in its own props.\n        //\n        // \u26A0\uFE0F `has()` is load-bearing, and this surface is the WORST of the four\n        // this repo measures (cf. `test/view-predicate-dialect.test.ts`): the\n        // renderer's call site is FAIL-SOFT \u2014 an unevaluable predicate answers\n        // SHOWN. So a bare `record.duplicate_status == \"suspected\"` would abort\n        // with `No such key` on every clean lead whose driver omits the column\n        // (`driver-memory` / `driver-mongodb`; `driver-sql` returns it as null)\n        // and put a duplicate warning on leads that are not duplicates. The\n        // guard is what makes the predicate answer `false` instead of faulting.\n        // Pinned on the real engine in `test/lead-duplicate-visibility.test.ts`.\n        //\n        // \u26D4 And the guard is NOT the whole predicate \u2014 `has()` ALONE is wrong\n        // here, in either shape. It is TRUE for a key that is PRESENT AND NULL,\n        // which is precisely what `driver-sql` hands back for a clean lead\n        // (measured: `has(record.duplicate_status)` against\n        // `{ duplicate_status: null }` answers `{ ok: true, value: true }`), so\n        // the guard needs a comparison beside it or the banner cries wolf on\n        // every clean lead. #1289, covering both verdicts at once, spelled that\n        // comparison `&& \u2026 != null`. A per-verdict banner spells it with the\n        // EQUALITY, which is strictly narrower and subsumes it: measured on\n        // this engine, `null == \"suspected\"` is a clean `false`, not a fault,\n        // and the two spellings agree on every record shape a driver can\n        // produce. Both halves of the shape #1289 ruled for are intact \u2014 the\n        // `has()` guard verbatim, and a comparison that makes \"set\" mean set \u2014\n        // and the comparison got STRICTER, which is the point of the split. The\n        // same spelling already ships one file over, on this same field: the\n        // conversion flow's `e21` / `e25` edges (#1288) read\n        // `has(vars.leadRecord.duplicate_status) && \u2026 == \"suspected\"`.\n        //\n        // \u26D4 Neither half may be simplified away. Both are pinned, shape by\n        // shape, including the reverse pin that the unguarded tail really does\n        // fault.\n        //\n        // `P` \u2014 an explicit `{ dialect: 'cel' }` envelope \u2014 is not decoration\n        // either: `ExpressionEvaluator.evaluateCondition` routes ONLY the\n        // envelope to `@objectstack/formula`'s CEL engine, where `has()` is a\n        // real function; a bare string takes the legacy JS path, whose\n        // `FormulaFunctions` has no CEL `has()`, so the guard would itself be\n        // the fault that fails soft to visible.\n        //\n        // `title` / `body` carry inline locale maps rather than plain strings:\n        // this renderer resolves both through `pickLocalized(\u2026, language)`\n        // (the same capability `opportunity_detail.page.ts` records under\n        // #972), and `body` has no other channel \u2014 the i18n extractor's\n        // per-component copy keys (`PAGE_COMPONENT_COPY_KEYS`, read on 17.6.0)\n        // are title/description/label/placeholder/emptyText, so a plain-string\n        // `body` would ship English to all four locales. Keeping both halves of one banner's copy in one\n        // place beats splitting `title` into the locale packs.\n        //\n        // \u2B50 Each banner's copy NAMES ITS OWN VERDICT, in the vocabulary the\n        // `duplicate_status` chip below publishes, and never the other one \u2014\n        // pinned against the option labels read out of the locale packs in\n        // `test/lead-duplicate-visibility.test.ts`, so renaming an option\n        // re-aims the assertion rather than retiring it.\n        {\n          type: 'record:alert',\n          id: 'lead_duplicate_alert_suspected',\n          label: 'Suspected Duplicate Alert',\n          properties: {\n            // `warning`, not `error`: conversion still PROCEEDS on this\n            // verdict, and the renderer maps `error` to `role=\"alert\"` /\n            // `aria-live=\"assertive\"` \u2014 an interruption this state has not\n            // earned.\n            severity: 'warning',\n            visible: P`has(record.duplicate_status) && record.duplicate_status == \"suspected\"`,\n            title: {\n              en: 'Suspected duplicate \u2014 compare before you convert',\n              'zh-CN': '\u7591\u4F3C\u91CD\u590D\u2014\u2014\u8F6C\u6362\u524D\u8BF7\u5148\u6BD4\u5BF9',\n              'ja-JP': '\u91CD\u8907\u306E\u7591\u3044 \u2014 \u5909\u63DB\u3059\u308B\u524D\u306B\u7167\u5408\u3057\u3066\u304F\u3060\u3055\u3044',\n              'es-ES': 'Duplicado Sospechoso: compare antes de convertir',\n            },\n            body: {\n              en:\n                'Intake matched this lead to a record this app already has. Duplicate '\n                + 'Management below links that record \u2014 open it and compare. You can still '\n                + 'convert this lead: this is the match intake guessed at, not a reviewer\\'s '\n                + 'decision. But if it is the same buyer, disqualify it instead, because '\n                + 'converting creates a second account, contact and opportunity for them.',\n              'zh-CN':\n                '\u5F55\u5165\u65F6\u53D1\u73B0\u8BE5\u7EBF\u7D22\u4E0E\u7CFB\u7EDF\u4E2D\u5DF2\u6709\u8BB0\u5F55\u5339\u914D\u3002\u4E0B\u65B9\u300C\u91CD\u590D\u7EBF\u7D22\u7BA1\u7406\u300D\u4E2D\u662F\u5B83\u91CD\u590D\u7684\u90A3\u6761\u8BB0\u5F55\uFF0C'\n                + '\u8BF7\u5148\u6253\u5F00\u6BD4\u5BF9\u3002\u8BE5\u7EBF\u7D22\u4ECD\u7136\u53EF\u4EE5\u8F6C\u6362\uFF1A\u8FD9\u662F\u5F55\u5165\u65F6\u7684\u81EA\u52A8\u5224\u65AD\uFF0C\u4E0D\u662F\u5BA1\u6838\u4EBA\u7684\u7ED3\u8BBA\u3002'\n                + '\u4F46\u82E5\u786E\u5C5E\u540C\u4E00\u5BA2\u6237\uFF0C\u8BF7\u6539\u4E3A\u53D6\u6D88\u8D44\u683C\u2014\u2014\u8F6C\u6362\u4F1A\u4E3A\u540C\u4E00\u5BA2\u6237\u518D\u521B\u5EFA\u4E00\u5957\u5BA2\u6237\u3001\u8054\u7CFB\u4EBA\u548C\u5546\u673A\u3002',\n              'ja-JP':\n                '\u767B\u9332\u6642\u306B\u3001\u3053\u306E\u30EA\u30FC\u30C9\u304C\u65E2\u5B58\u30EC\u30B3\u30FC\u30C9\u3068\u4E00\u81F4\u3057\u307E\u3057\u305F\u3002\u4E0B\u306E\u300C\u91CD\u8907\u7BA1\u7406\u300D\u306B\u91CD\u8907\u5148\u306E'\n                + '\u30EC\u30B3\u30FC\u30C9\u304C\u3042\u308A\u307E\u3059\u3002\u307E\u305A\u958B\u3044\u3066\u7167\u5408\u3057\u3066\u304F\u3060\u3055\u3044\u3002\u3053\u306E\u30EA\u30FC\u30C9\u306F\u307E\u3060\u5909\u63DB\u3067\u304D\u307E\u3059\u3002'\n                + '\u3053\u308C\u306F\u767B\u9332\u6642\u306E\u81EA\u52D5\u5224\u5B9A\u3067\u3042\u308A\u3001\u62C5\u5F53\u8005\u306E\u7D50\u8AD6\u3067\u306F\u3042\u308A\u307E\u305B\u3093\u3002\u305F\u3060\u3057\u540C\u3058\u76F8\u624B\u3067'\n                + '\u3042\u308C\u3070\u3001\u5909\u63DB\u305B\u305A\u4E0D\u9069\u683C\u306B\u3057\u3066\u304F\u3060\u3055\u3044\u3002\u5909\u63DB\u3059\u308B\u3068\u540C\u3058\u76F8\u624B\u306B\u53D6\u5F15\u5148\u30FB\u53D6\u5F15\u5148'\n                + '\u8CAC\u4EFB\u8005\u30FB\u5546\u8AC7\u304C\u3082\u3046\u4E00\u7D44\u4F5C\u6210\u3055\u308C\u307E\u3059\u3002',\n              'es-ES':\n                'La captura encontr\u00F3 que este prospecto coincide con un registro que ya '\n                + 'existe. Gesti\u00F3n de Duplicados, m\u00E1s abajo, enlaza ese registro: \u00E1bralo y '\n                + 'comp\u00E1relo. Todav\u00EDa puede convertir este prospecto, porque se trata de una '\n                + 'coincidencia autom\u00E1tica de la captura y no del veredicto de una persona. '\n                + 'Pero si es el mismo comprador, descalif\u00EDquelo en su lugar: convertirlo '\n                + 'crea una segunda cuenta, contacto y oportunidad para \u00E9l.',\n            },\n          },\n        },\n        {\n          type: 'record:alert',\n          id: 'lead_duplicate_alert_confirmed',\n          label: 'Confirmed Duplicate Alert',\n          properties: {\n            // `error`, and the level is the message: this is the state on which\n            // the app REFUSES the rep's next click, and the renderer gives\n            // `error` `role=\"alert\"` / `aria-live=\"assertive\"` rather than the\n            // polite `role=\"status\"` every other level gets. \u26D4 The severity is\n            // presentation only \u2014 what the app refuses was ruled by #1288 and\n            // shipped by PR #1555, and nothing here changes it.\n            severity: 'error',\n            visible: P`has(record.duplicate_status) && record.duplicate_status == \"confirmed\"`,\n            title: {\n              en: 'Confirmed duplicate \u2014 conversion will be refused',\n              'zh-CN': '\u5DF2\u786E\u8BA4\u91CD\u590D\u2014\u2014\u8F6C\u6362\u5C06\u88AB\u62D2\u7EDD',\n              'ja-JP': '\u91CD\u8907\u78BA\u5B9A \u2014 \u5909\u63DB\u306F\u62D2\u5426\u3055\u308C\u307E\u3059',\n              'es-ES': 'Duplicado Confirmado: la conversi\u00F3n ser\u00E1 rechazada',\n            },\n            body: {\n              // \u2B50 The only place a rep learns the Convert button will refuse\n              // them BEFORE they press it \u2014 until this banner, the refusal\n              // dialog was the first they heard of it.\n              en:\n                'A reviewer checked this lead and recorded that it repeats a record this app '\n                + 'already has, so Convert Lead refuses it \u2014 this banner is the only warning '\n                + 'you get before you press the button. Disqualify this lead instead, naming '\n                + 'the surviving record from Duplicate Management below. If the verdict is '\n                + 'wrong, a reviewer revises Duplicate Status; there is no override here.',\n              'zh-CN':\n                '\u5BA1\u6838\u4EBA\u5DF2\u6838\u5B9E\u8BE5\u7EBF\u7D22\u4E0E\u7CFB\u7EDF\u4E2D\u5DF2\u6709\u8BB0\u5F55\u91CD\u590D\uFF0C\u56E0\u6B64\u300C\u8F6C\u6362\u7EBF\u7D22\u300D\u4F1A\u62D2\u7EDD\u6267\u884C\u2014\u2014'\n                + '\u672C\u63D0\u793A\u662F\u4F60\u6309\u4E0B\u6309\u94AE\u524D\u552F\u4E00\u7684\u9884\u8B66\u3002\u8BF7\u6539\u4E3A\u53D6\u6D88\u8BE5\u7EBF\u7D22\u7684\u8D44\u683C\uFF0C\u5E76\u5728\u4E0B\u65B9'\n                + '\u300C\u91CD\u590D\u7EBF\u7D22\u7BA1\u7406\u300D\u4E2D\u6CE8\u660E\u4FDD\u7559\u7684\u90A3\u6761\u8BB0\u5F55\u3002\u82E5\u5224\u5B9A\u6709\u8BEF\uFF0C\u5E94\u7531\u5BA1\u6838\u4EBA\u4FEE\u6539'\n                + '\u300C\u91CD\u590D\u72B6\u6001\u300D\uFF0C\u6B64\u5904\u4E0D\u63D0\u4F9B\u5F3A\u5236\u8F6C\u6362\u7684\u5165\u53E3\u3002',\n              'ja-JP':\n                '\u62C5\u5F53\u8005\u304C\u78BA\u8A8D\u3057\u3001\u3053\u306E\u30EA\u30FC\u30C9\u306F\u65E2\u5B58\u30EC\u30B3\u30FC\u30C9\u306E\u91CD\u8907\u3067\u3042\u308B\u3068\u8A18\u9332\u3055\u308C\u307E\u3057\u305F\u3002'\n                + '\u305D\u306E\u305F\u3081\u300C\u30EA\u30FC\u30C9\u5909\u63DB\u300D\u306F\u62D2\u5426\u3055\u308C\u307E\u3059\u3002\u3053\u306E\u901A\u77E5\u304C\u3001\u30DC\u30BF\u30F3\u3092\u62BC\u3059\u524D\u306B\u5F97\u3089\u308C\u308B'\n                + '\u552F\u4E00\u306E\u8B66\u544A\u3067\u3059\u3002\u3053\u306E\u30EA\u30FC\u30C9\u306F\u4E0D\u9069\u683C\u306B\u3057\u305F\u3046\u3048\u3067\u3001\u4E0B\u306E\u300C\u91CD\u8907\u7BA1\u7406\u300D\u3067\u6B8B\u3059'\n                + '\u30EC\u30B3\u30FC\u30C9\u3092\u660E\u8A18\u3057\u3066\u304F\u3060\u3055\u3044\u3002\u5224\u5B9A\u304C\u8AA4\u3063\u3066\u3044\u308B\u5834\u5408\u306F\u62C5\u5F53\u8005\u304C\u300C\u91CD\u8907\u30B9\u30C6\u30FC\u30BF\u30B9\u300D'\n                + '\u3092\u4FEE\u6B63\u3057\u307E\u3059\u3002\u3053\u3053\u306B\u5F37\u5236\u5909\u63DB\u306E\u624B\u6BB5\u306F\u3042\u308A\u307E\u305B\u3093\u3002',\n              'es-ES':\n                'Una persona verific\u00F3 que este prospecto repite un registro que ya existe, '\n                + 'por lo que Convertir Prospecto lo rechazar\u00E1: este aviso es la \u00FAnica '\n                + 'advertencia antes de pulsar el bot\u00F3n. Descalifique el prospecto e indique '\n                + 'el registro que sobrevive desde Gesti\u00F3n de Duplicados, m\u00E1s abajo. Si el '\n                + 'veredicto es incorrecto, una persona debe cambiar el Estado del Duplicado; '\n                + 'aqu\u00ED no hay forma de forzar la conversi\u00F3n.',\n            },\n          },\n        },\n        // Salesforce-style Highlights Panel: a horizontal strip of the\n        // most-important key facts directly under the header. Pulled out\n        // of the sidebar so it can use the full page width.\n        {\n          type: 'record:highlights',\n          id: 'lead_highlights',\n          label: 'Key Information',\n          properties: {\n            fields: ['status', 'rating', 'lead_source', 'owner_id', 'email', 'phone'],\n          },\n        },\n        {\n          type: 'record:path',\n          id: 'lead_path',\n          label: 'Lead Status Path',\n          properties: {\n            statusField: 'status',\n            // `converted` is the terminal WIN state and must be on the path \u2014\n            // without it the strip reads as if \"Unqualified\" were the goal, and\n            // a converted lead had no stage to light up at all.\n            stages: [\n              { value: 'new', label: 'New' },\n              { value: 'contacted', label: 'Contacted' },\n              { value: 'qualified', label: 'Qualified' },\n              { value: 'converted', label: 'Converted' },\n              { value: 'unqualified', label: 'Unqualified' },\n            ],\n          },\n        },\n      ],\n    },\n\n    {\n      name: 'main',\n      width: 'large',\n      components: [\n        {\n          type: 'page:tabs',\n          id: 'main_tabs',\n          label: 'Lead Information Tabs',\n          properties: {\n            // `type` \u2192 `tabStyle` (@objectstack/spec 17.0.0, #6776, ADR-0087\n            // D2). Same three values; see the full note on `home.page.ts`.\n            tabStyle: 'line',\n            position: 'top',\n            items: [\n              {\n                label: 'Details',\n                icon: 'info-circle',\n                children: [\n                  {\n                    type: 'record:details',\n                    id: 'lead_details',\n                    label: 'Lead Details',\n                    properties: {\n                      columns: '2',\n                      // `layout` was REMOVED from `record:details` in\n                      // @objectstack/spec 17.0.0 (#6946, ADR-0087 D2) and is\n                      // deleted with no successor: its `auto` | `custom`\n                      // semantics were never implemented.\n                      //\n                      // Every section is a GROUP REFERENCE (#806, maintainer\n                      // ruling C, decision batch #21, 2026-09-03). `{ group }`\n                      // names one of crm_lead's `fieldGroups`, and the renderer\n                      // derives that section's members, label, icon and collapse\n                      // state from the object (`deriveFieldGroupLayout`,\n                      // ADR-0085 \u00A75). Membership has ONE declaration site \u2014 the\n                      // `group:` on each field in lead.object.ts \u2014 and this page\n                      // curates only the ORDER, so a field added to a group shows\n                      // up here with no edit to this file. \u26D4 Do not enumerate\n                      // `fields:` again, and do not restate a key the group owns\n                      // (`name` / `label` / `icon` / `collapsible` /\n                      // `defaultCollapsed`) beside `group`: the spec refuses both.\n                      //\n                      // \u26D4 `sections` stays load-bearing. Omitting it renders an\n                      // EMPTY Details tab, not a `fieldGroups` fallback (#806 R28\n                      // on 17.2.0, #1521); derivation is per section, through\n                      // `group:`, never page-level.\n                      //\n                      // Measured on @objectstack/console 17.6.0 (#806 R70,\n                      // headless Chromium, with a control leg; on 17.4.0 R61\n                      // measured this form crashing the component). What a\n                      // group section does there is the renderer's, not ours:\n                      //   - it lays out its own column count (the page-level\n                      //     `columns` above does not reach it);\n                      //   - a group whose members are all empty renders nothing\n                      //     (`duplicates` on a clean lead), unless the section\n                      //     says `hideEmpty: false`;\n                      //   - members the highlights strip registered are dropped,\n                      //     so `assignment` (only `owner_id`) renders nothing on\n                      //     this page \u2014 the owner is in the strip;\n                      //   - a group declared `collapse: 'collapsed'` starts\n                      //     collapsed; changing that is a `fieldGroups` decision\n                      //     in lead.object.ts, not a key on this page.\n                      //\n                      // `hideEmpty: false` (#2003, the #1211 reasoning) sits on\n                      // the groups whose every member a rep types and the\n                      // create form asks for: `contact_info` (`mobile` and\n                      // `website` once the strip takes `email` and `phone`),\n                      // `address`, and `additional` (revenue, headcount,\n                      // description, notes). Without it all three vanish on a\n                      // fresh lead, so a rep cannot see what is left to fill.\n                      // Not on `assignment`: its derived list is empty, and the\n                      // renderer draws nothing for an empty list whatever\n                      // `hideEmpty` says. Not on `duplicates`: the\n                      // `lead_duplicate_check` hook writes it.\n                      sections: [\n                        { group: 'identity' },\n                        { group: 'company_info' },\n                        { group: 'contact_info', hideEmpty: false },\n                        // Do Not Call / Email Opt Out, right under the numbers\n                        // a rep is about to dial (#806).\n                        { group: 'preferences' },\n                        { group: 'qualification' },\n                        { group: 'assignment' },\n                        { group: 'address', hideEmpty: false },\n                        { group: 'conversion' },\n                        // The LINK half of the duplicate banners (#1207): the\n                        // group carries both survivor lookups, because\n                        // `lead_duplicate_check` matches contacts before leads.\n                        // On a clean lead every member is empty, so the section\n                        // renders nothing. \u26A0\uFE0F Not the highlights strip:\n                        // `record:highlights` caps `fields` at 7 and holds 6.\n                        { group: 'duplicates' },\n                        // Description and Notes \u2014 kept last, where the page's\n                        // Description section always sat.\n                        { group: 'additional', hideEmpty: false },\n                      ],\n                    },\n                  },\n                ],\n              },\n              {\n                label: 'Related',\n                icon: 'link',\n                children: [\n                  {\n                    type: 'page:accordion',\n                    id: 'related_accordion',\n                    label: 'Related Records',\n                    properties: {\n                      allowMultiple: true,\n                      items: [\n                        {\n                          label: 'Tasks',\n                          icon: 'list-checks',\n                          collapsed: false,\n                          children: [\n                            {\n                              type: 'record:related_list',\n                              id: 'related_tasks',\n                              label: 'Tasks',\n                              properties: {\n                                objectName: 'crm_task',\n                                // crm_task links back through the polymorphic\n                                // `related_to_lead` lookup; there is no `lead_id`\n                                // column, so the old binding matched nothing and\n                                // this list read \"0\" no matter how many follow-ups\n                                // the rep had filed.\n                                relationshipField: 'related_to_lead',\n                                columns: ['subject', 'status', 'priority', 'due_date', 'owner_id'],\n                                sort: [\n                                  { field: 'due_date', order: 'asc' }\n                                ],\n                                limit: 10,\n                                title: 'Open Tasks',\n                                filter: [{ field: 'status', operator: 'not_equals', value: 'completed' }],\n                                showViewAll: true,\n                              },\n                            },\n                          ],\n                        },\n                      ],\n                    },\n                  },\n                ],\n              },\n              {\n                label: 'Activity',\n                icon: 'clock',\n                children: [\n                  {\n                    type: 'record:activity',\n                    id: 'lead_activity',\n                    label: 'Activity Timeline',\n                    properties: {\n                      // `types` is keyed on FEED ITEM KIND, never on object name\n                      // (#1209). The old `['crm_task']` was not one of the kinds\n                      // the prop accepts, and nothing anywhere enforced that: the\n                      // page schema's `properties` is an open bag\n                      // (`z.record(z.string(), z.unknown())`) so the value was\n                      // stored verbatim, and the renderer's own sanitiser drops\n                      // members it does not recognise and then reads the EMPTY\n                      // remainder as \"no filter authored\" \u2014 measured on the\n                      // shipped bundle, `types: ['crm_task']`, `types: []` and\n                      // omitting `types` all render the same unfiltered stream.\n                      // That is why the tab showed `Created Lead` / `Updated\n                      // Lead` audit rows, which the History tab already covers.\n                      //\n                      // What this component can actually show is `sys_activity`\n                      // scoped to the record, through the renderer's own\n                      // type map \u2014 measured, not inferred:\n                      //\n                      //   sys_activity.type      feed kind      written by\n                      //   created/updated/\u2026      field_change   platform audit\n                      //   system                 system         platform\n                      //   completed              task           log_call /\n                      //                                         log_meeting /\n                      //                                         send_email\n                      //   scheduled              (dropped)      schedule_meeting\n                      //\n                      // So `task` is the kind that carries a rep's logged\n                      // interactions, and it is the only reachable one worth\n                      // filtering to. `event` is NOT added: it is a legal kind\n                      // the prop accepts but no `sys_activity.type` maps to it,\n                      // so it would be a declared value enforced by nothing.\n                      // `scheduled` rows fall out of the map upstream \u2014 a\n                      // platform gap, not something to work around here.\n                      types: ['task'],\n                      limit: 20,\n                      // Load-bearing, not cosmetic: the renderer strips every\n                      // `task` item BEFORE the `types` filter runs unless this is\n                      // true, and `task` items are exactly the `completed` rows.\n                      // `types: ['task']` with the old `showCompleted: false`\n                      // renders an empty tab.\n                      showCompleted: true,\n                    },\n                  },\n                ],\n              },\n              {\n                label: 'History',\n                icon: 'history',\n                children: [\n                  {\n                    // `record:history` is the platform's own audit feed over the\n                    // fields marked `trackHistory` (status / rating). Ownership\n                    // moved to the platform's `owner_id` in #548, which carries no\n                    // `trackHistory` flag \u2014 transfers land in the compliance audit\n                    // log, not on this feed.\n                    // The hand-rolled version queried an object named\n                    // `field_history`, which this app does not define, so the\n                    // tab could only ever render empty.\n                    type: 'record:history',\n                    id: 'lead_history',\n                    label: 'Field History',\n                    properties: {\n                      limit: 25,\n                    },\n                  },\n                ],\n              },\n            ],\n          },\n        },\n      ],\n    },\n  ],\n\n  // Make this the default page for leads\n  isDefault: true,\n\n  // ARIA accessibility\n  aria: {\n    ariaLabel: 'Lead Detail Page',\n    ariaDescribedBy: 'Detailed view of lead information with related records and activity',\n  },\n};\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/sales/pages/opportunity_detail.page.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/sales/pages\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/sales/pages/opportunity_detail.page.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport { Page } from '@objectstack/spec/ui';\n\n/**\n * Opportunity Detail Record Page\n *\n * Salesforce Lightning-style record page for the `crm_opportunity` object.\n * Mirrors the lead_detail blueprint: single-column full-width layout with\n * a Lightning-style header chip, primary action, key highlights strip and\n * status path, then a tab strip below. No sidebar \u2014 secondary widgets such\n * as the AI assistant live in the floating console chat instead.\n */\nexport const OpportunityDetailPage: Page = {\n  name: 'opportunity_detail_page',\n  label: 'Opportunity Detail',\n  description: 'Comprehensive opportunity detail page with path, highlights, details, and related lists',\n\n  type: 'record',\n  object: 'crm_opportunity',\n\n  template: 'full-width',\n  kind: 'full',\n  variables: [\n    { name: 'activeTab', type: 'string', defaultValue: 'details' },\n  ],\n\n  regions: [\n    {\n      name: 'header',\n      width: 'full',\n      components: [\n        {\n          type: 'page:header',\n          id: 'opp_header',\n          label: 'Opportunity Information',\n          properties: {\n            title: '{name}',\n            // The lookup field is `crm_account` \u2014 `{account}` matched nothing\n            // and the subtitle rendered blank.\n            subtitle: '{crm_account}',\n            // `icon` removed from `page:header` in @objectstack/spec 17.0.0\n            // (#6946, ADR-0087 D2) \u2014 deleted, not renamed. See the full note on\n            // `account_detail.page.ts`; nothing ever drew it.\n            // `breadcrumb` retired from `page:header` in @objectstack/spec 17.6.0\n            // (#20785, `page-header-breadcrumb-removed`) \u2014 deleted: no renderer\n            // ever drew a trail for it; the app shell's own trail is unchanged.\n            // generate_quote is the CPQ entry point (opportunity \u2192 quote); a\n            // custom record page replaces the default header, so the action\n            // must be listed here explicitly or it is unreachable. The same\n            // sentence is why the three activity actions are named here (#592):\n            // without them a rep can log a call on the deal only from the list\n            // row's \u22EE menu, never from the deal itself.\n            //\n            // Action IDs, not `ActionDef` objects: `PageHeaderProps.actions` is\n            // `z.array(z.string())` (\"Action IDs to show in header\") in\n            // @objectstack/spec 17.3.0, and this repo authors against the\n            // protocol (#1653). Each id is the `name` of a\n            // crm_opportunity-scoped action \u2014 `generate_quote` /\n            // `clone_opportunity` in `src/sales/actions/opportunity.actions.ts`, the\n            // activity trio in `src/sales/actions/activity-actions.ts`.\n            actions: [\n              'generate_quote',\n              'clone_opportunity',\n              'log_call',\n              'log_meeting',\n              'schedule_meeting',\n            ],\n          },\n        },\n        {\n          type: 'record:highlights',\n          id: 'opp_highlights',\n          label: 'Key Information',\n          properties: {\n            fields: ['amount', 'close_date', 'probability', 'expected_revenue', 'owner_id', 'crm_account'],\n          },\n        },\n        {\n          type: 'record:path',\n          id: 'opp_stage_path',\n          label: 'Opportunity Stage Path',\n          properties: {\n            statusField: 'stage',\n            // Every canonical value of `stage` must appear here, in funnel\n            // order \u2014 the path is the only place a rep reads \"where is this\n            // deal\". `needs_analysis` was missing, so a deal sitting in that\n            // stage lit up NO step at all and the strip read as if the deal\n            // had skipped from Qualification to Proposal. The two terminal\n            // stages stay last (won before lost), matching lead_detail's\n            // converted/unqualified tail.\n            stages: [\n              { value: 'prospecting', label: 'Prospecting' },\n              { value: 'qualification', label: 'Qualification' },\n              { value: 'needs_analysis', label: 'Needs Analysis' },\n              { value: 'proposal', label: 'Proposal' },\n              { value: 'negotiation', label: 'Negotiation' },\n              { value: 'closed_won', label: 'Closed Won' },\n              { value: 'closed_lost', label: 'Closed Lost' },\n            ],\n          },\n        },\n      ],\n    },\n    {\n      name: 'main',\n      width: 'large',\n      components: [\n        {\n          type: 'page:tabs',\n          id: 'opp_main_tabs',\n          properties: {\n            // `type` \u2192 `tabStyle` (@objectstack/spec 17.0.0, #6776, ADR-0087\n            // D2). Same three values; see the full note on `home.page.ts`.\n            tabStyle: 'line',\n            position: 'top',\n            items: [\n              {\n                // Tab item `key` \u2192 `value` (#1269): `value` is the stable\n                // `?tab=` URL token the renderer reads, `key` is read by\n                // nothing. See the full note on `case_detail.page.ts`.\n                value: 'details',\n                label: 'Details',\n                children: [\n                  {\n                    type: 'record:details',\n                    id: 'opp_details',\n                    label: 'Opportunity Details',\n                    properties: {\n                      // `columns` is a STRING enum ('1'|'2'|'3'|'4') in\n                      // @objectstack/spec 17. `layout` is gone (removed in spec\n                      // 17.0.0, #6946 / ADR-0087 D2).\n                      columns: '2',\n                      // Every section references one of crm_opportunity's\n                      // `fieldGroups` (#1452, the #806 class ruling C): the\n                      // renderer derives members, label, icon and collapse state\n                      // from the object, so this page curates only the order.\n                      // The full note \u2014 what a group section does on 17.6.0 and\n                      // what may not sit beside `group` \u2014 is on\n                      // `lead_detail.page.ts`.\n                      //\n                      // The highlights strip still wins (#1211): the renderer\n                      // drops every field `record:highlights` registered, and the\n                      // record title, from the derived members. So `basic` shows\n                      // `primary_contact` only, and `financials` (`amount`,\n                      // `expected_revenue`, both in the strip) renders nothing\n                      // here \u2014 it stays referenced so that a field added to the\n                      // group reaches this tab without an edit to this file.\n                      //\n                      // `hideEmpty: false` keeps an ALL-empty section on screen\n                      // (#1211). The platform default (objectui#8603 ruling A)\n                      // renders such a section as nothing at all, so on a deal\n                      // with only its required fields the deal's type and\n                      // source (`classification`), its campaign (`campaign`)\n                      // and its description and next step (`notes`) vanished \u2014\n                      // the very fields a seller fills in later. Kept, they\n                      // show as labelled empty rows to fill. Measured on\n                      // 17.6.0 on such a deal: 2 sections render without it, 5\n                      // with it. Not on `basic` (its only member outside the\n                      // title and the strip is `primary_contact`), nor on\n                      // `financials`: both members sit in the strip, the\n                      // derived list is empty, and the renderer draws nothing\n                      // for an empty list whatever `hideEmpty` says.\n                      //\n                      // `qualification` and `narrative` (REQ-0006) sit right\n                      // after `sales_process`, the order the object declares\n                      // them in, and both keep `hideEmpty: false` on the same\n                      // reasoning: every member is a judgement or a piece of\n                      // prose the seller is expected to write (bid / no-bid,\n                      // controllability, priority, deal level, subcontracting;\n                      // the four narrative fields), none sits in the strip, and\n                      // no deal that predates REQ-0006 carries any of them \u2014 so\n                      // without the key both sections vanish on every existing\n                      // deal, which is exactly where a seller would fill them.\n                      sections: [\n                        { group: 'basic' },\n                        { group: 'financials' },\n                        { group: 'classification', hideEmpty: false },\n                        { group: 'campaign', hideEmpty: false },\n                        { group: 'sales_process' },\n                        { group: 'qualification', hideEmpty: false },\n                        { group: 'narrative', hideEmpty: false },\n                        { group: 'crm_forecast' },\n                        { group: 'notes', hideEmpty: false },\n                      ],\n                    },\n                  },\n                ],\n              },\n              {\n                value: 'related',\n                label: 'Related',\n                children: [\n                  {\n                    type: 'page:accordion',\n                    id: 'opp_related_accordion',\n                    properties: {\n                      items: [\n                        {\n                          // Accordion item `key` is DELETED, not renamed to\n                          // `value` \u2014 the opposite verdict to the tab items\n                          // above, because this renderer overwrites `value` with\n                          // `panel-<index>`. See the full note on\n                          // `case_detail.page.ts`.\n                          label: 'Quotes',\n                          // OPEN on arrival (#1214 item 6). All three panels\n                          // used to start shut, so the Related tab opened on\n                          // three closed bars whose headers already carried the\n                          // counts \u2014 the click bought the user nothing the page\n                          // had not already told them.\n                          //\n                          // `collapsed: false` is the whole mechanism, and it is\n                          // needed even though the schema DEFAULTS it to false:\n                          // the renderer opens the panels it finds by strict\n                          // identity \u2014 `items.filter(i => i.collapsed === false)`\n                          // \u2014 so an item that simply omits the key is\n                          // `undefined`, not `false`, and stays shut. Measured\n                          // on the @objectstack/console 17.3.0 bundle \u2014 the pin\n                          // at that taking, \u26D4 NOT re-taken on 17.4.0\n                          // (#1814, #1807) or 17.5.0 \u2014\n                          // and the component's own designer text says the same\n                          // (\"collapsed: false opens a panel by default\").\n                          //\n                          // \u26A0\uFE0F ONLY the first panel, and that is the renderer's\n                          // choice rather than a preference: with `allowMultiple`\n                          // absent (it defaults false) the accordion mounts as\n                          // `type=\"single\"` and takes `defaultValue={open[0]}` \u2014\n                          // one panel, the first in declaration order. Marking\n                          // Products or Open Tasks too would change nothing on\n                          // screen. Opening more than one means declaring\n                          // `allowMultiple: true`, which changes the interaction\n                          // model (panels stop closing each other) and is not\n                          // this card's ask.\n                          //\n                          // \u26D4 NOT \"default-open the sections that have rows\",\n                          // which the card asked for first: that is not\n                          // expressible here. `collapsed` is a static boolean on\n                          // a strict item shape (`label` / `icon` / `collapsed` /\n                          // `children` \u2014 nothing else parses), the page is\n                          // authored metadata evaluated before any row is read,\n                          // and the related lists below fetch their own rows\n                          // after mount. Reported rather than worked around; \u26D4\n                          // the component is not this repo's to change.\n                          collapsed: false,\n                          children: [\n                            {\n                              type: 'record:related_list',\n                              id: 'opp_quotes',\n                              properties: {\n                                objectName: 'crm_quote',\n                                relationshipField: 'crm_opportunity',\n                                columns: ['quote_number', 'name', 'status', 'total_price', 'expiration_date'],\n                                limit: 10,\n                              },\n                            },\n                          ],\n                        },\n                        {\n                          label: 'Products',\n                          children: [\n                            {\n                              type: 'record:related_list',\n                              id: 'opp_products',\n                              properties: {\n                                objectName: 'crm_opportunity_line_item',\n                                relationshipField: 'crm_opportunity',\n                                columns: ['crm_product', 'quantity', 'unit_price', 'total_price'],\n                                limit: 10,\n                                // The entry point that was missing (#1731). Every\n                                // OTHER surface already treated line items as\n                                // live \u2014 three profiles grant `allowCreate`, the\n                                // docs describe the amount rolling up from them,\n                                // and `billing-handoff.flow.ts`'s\n                                // `load_line_items` reads them on every won deal\n                                // \u2014 while nothing in the app could create one:\n                                // no action, no list view, no navigation entry,\n                                // no seed. A rep who wanted to itemise a deal had\n                                // to type the Amount by hand. Declared surface and\n                                // reachable surface now coincide again.\n                                //\n                                // What `add` writes is the whole reason a picker\n                                // is sufficient here. It creates a row carrying\n                                // exactly two authored keys \u2014\n                                // `{ [relationshipField]: <opportunityId>,\n                                //    [linkField]: <pickedProductId> }` \u2014 and\n                                // nothing else. On this object that would leave\n                                // `quantity` and `unit_price` unset, and both are\n                                // `required` + `storage.notNull`, so the insert\n                                // would be refused. It is not, because the two\n                                // gaps are already filled by machinery that\n                                // predates this list:\n                                //\n                                //   quantity   -> the field's own `defaultValue: 1`\n                                //   unit_price -> `_line-item-price-fill.ts`, which\n                                //                 on `beforeInsert` stamps\n                                //                 `list_price` from the chosen\n                                //                 product and defaults the\n                                //                 negotiated `unit_price` to it\n                                //   discount   -> the field's own `defaultValue: 0`\n                                //   total_price-> the formula over the three above\n                                //\n                                // and `crm_product.list_price` is itself `required`\n                                // + `notNull`, so the hook can never fail to find a\n                                // source. Measured end-to-end, not reasoned:\n                                // `test/opportunity-line-item-add-picker.test.ts`\n                                // inserts the picker's exact two-key shape and\n                                // asserts the complete priced row, with an ablation\n                                // that unbinds the hook and shows the same insert\n                                // rejected as \"Sales Price is required\" \u2014 so the\n                                // assertion cannot pass vacuously.\n                                //\n                                // \u26D4 Do not add a `label`. The button falls back to\n                                // the platform's own localized \"Add\"; the\n                                // translation bundles reach a page component through\n                                // `pages.<page>.components.<id>`, which carries\n                                // `label`/`title`/`description` for the COMPONENT\n                                // and has no route to a nested `add.label`. A\n                                // hand-authored string here would ship English into\n                                // the zh-CN / es-ES / ja-JP bundles with no key to\n                                // translate it under.\n                                //\n                                // `valueField` and `labelField` are both omitted on\n                                // purpose rather than restated: `valueField`\n                                // defaults to `id`, which is what the `crm_product`\n                                // lookup stores, and `labelField` defaults to the\n                                // picked object's own title field \u2014 `crm_product`\n                                // declares `nameField: 'display_title'` (ADR-0079),\n                                // so the picker labels rows \"PRD-0001 - Widget\" and\n                                // keeps ONE source of truth for a product's title.\n                                // That formula title is searchable only because the\n                                // object also declares `searchableFields`, which it\n                                // already does for exactly this reason.\n                                add: {\n                                  picker: {\n                                    object: 'crm_product',\n                                    // A retired product must not be sellable onto a\n                                    // new deal. `product.hook.ts`'s `beforeDelete`\n                                    // defines retirement as precisely this flag\n                                    // (\"Set is_active=false to retire instead\"),\n                                    // so the catalog's own retirement mechanism is\n                                    // what scopes the picker. All 13 seeded\n                                    // products carry `is_active: true`, so this\n                                    // narrows without emptying.\n                                    filter: [{ field: 'is_active', operator: 'equals', value: true }],\n                                  },\n                                  linkField: 'crm_product',\n                                },\n                              },\n                            },\n                          ],\n                        },\n                        {\n                          label: 'Open Tasks',\n                          children: [\n                            {\n                              type: 'record:related_list',\n                              id: 'opp_tasks',\n                              properties: {\n                                objectName: 'crm_task',\n                                relationshipField: 'related_to_opportunity',\n                                columns: ['subject', 'status', 'priority', 'due_date', 'owner_id'],\n                                filter: [{ field: 'status', operator: 'not_equals', value: 'completed' }],\n                                limit: 10,\n                              },\n                            },\n                          ],\n                        },\n                      ],\n                    },\n                  },\n                ],\n              },\n              {\n                value: 'activity',\n                label: 'Activity',\n                children: [\n                  {\n                    type: 'record:activity',\n                    id: 'opp_activity',\n                    /**\n                     * `filters` is deleted with nothing put in its place, and\n                     * that is the whole finding (#1269).\n                     *\n                     * It used to read `['all', 'tasks', 'meetings', 'calls',\n                     * 'emails']` \u2014 a vocabulary that exists nowhere in the\n                     * contract. `RecordActivityProps` has exactly two filter\n                     * channels and neither takes that list:\n                     *\n                     *   `types`      \u2014 an array of FEED ITEM KINDS\n                     *                  (`comment` | `field_change` | `task` |\n                     *                  `event` | `email` | `call` | \u2026). Not\n                     *                  these values: `all` is not a kind and\n                     *                  `meetings` is not one either (the kind\n                     *                  is `event`), and all five are plural\n                     *                  where the enum is singular.\n                     *   `filterMode` \u2014 ONE default for the panel's dropdown,\n                     *                  from `all` | `comments_only` |\n                     *                  `changes_only` | `tasks_only`. The\n                     *                  dropdown's option list is the renderer's,\n                     *                  not authorable.\n                     *\n                     * So the list was reaching for a third thing \u2014 \"offer these\n                     * filter chips\" \u2014 that the component does not expose. What\n                     * it wanted is already delivered: `showFilterToggle`\n                     * defaults on, so the panel renders its filter dropdown, and\n                     * `filterMode` defaults to `all`, so it opens unfiltered.\n                     * Neither is restated here, because materializing a default\n                     * turns \"the author said nothing\" into \"the author asked for\n                     * the default\" \u2014 a different fact, and the one a later\n                     * liveness audit reads.\n                     *\n                     * Mapping it onto `types` instead was considered and\n                     * rejected: #1209 corrected exactly that mistake one page\n                     * over (the lead timeline's `types: ['crm_task']`), and the\n                     * renderer sanitises out-of-enum members then reads the\n                     * EMPTY remainder as \"no filter authored\" \u2014 so a bad `types`\n                     * is indistinguishable from no `types` on screen while\n                     * claiming otherwise in source. A `types` here would also\n                     * be a NEW restriction nobody asked for: it would drop\n                     * comments and field changes from a timeline that shows them\n                     * today.\n                     */\n                    properties: {\n                      limit: 25,\n                      // Load-bearing (#2071): a call or meeting logged on the\n                      // deal is a `sys_activity` row of type `completed` (the\n                      // `task` feed kind), and the renderer drops every such\n                      // row unless this is true \u2014 so a rep's logged call never\n                      // reached this tab. The deal's other `completed` writers\n                      // are its own won / lost milestones\n                      // (`opportunity.object.ts`), which belong here too.\n                      // Completed crm_task rows do NOT arrive: their audit rows\n                      // are keyed to the task, and this feed reads only rows\n                      // keyed to the deal. Nor is this the `types` restriction\n                      // the note above refuses: it adds rows and filters none.\n                      showCompleted: true,\n                    },\n                  },\n                ],\n              },\n            ],\n          },\n        },\n      ],\n    },\n    {\n      name: 'aside',\n      width: 'small',\n      components: [\n        {\n          type: 'record:reference_rail',\n          id: 'opp_reference_rail',\n          properties: {\n            /**\n             * No entry declares a `title` \u2014 deliberately (#972).\n             *\n             * The rail resolves a card's heading as\n             * `entry.title || i18n.objectLabel({ name: objectName, \u2026 })`, so a\n             * literal `title` does not merely provide a default: it WINS, and\n             * the locale bundle is never consulted. The three literals that\n             * used to sit here (`Quotes` / `Products` / `Open Tasks`) therefore\n             * printed English into every one of the four locales this app\n             * ships, on top of `objects.<name>.label` already being translated\n             * in all of them. Dropping them hands the heading back to the\n             * translation bundle \u2014 the single source of truth for what an\n             * object is called \u2014 so a locale added later is covered for free.\n             *\n             * A translated literal is not available as an alternative: unlike\n             * `record:alert`, whose `title` is run through the inline\n             * translation-map resolver, the rail renders `entry.title` as a\n             * raw React child. An `{ en, 'zh-CN' }` map here would not be\n             * resolved \u2014 it would be handed to React as an object.\n             *\n             * The third card losing the word \"Open\" is a correction, not a\n             * casualty. A rail entry has no filter at all \u2014 the rail queries\n             * `{ $filter: { [relationshipField]: parentId }, $top: limit }` and\n             * reads nothing else \u2014 so that card always counted and listed this\n             * deal's tasks whatever their status. The heading claimed a filter\n             * the component cannot apply. The genuinely filtered view is the\n             * `opp_tasks` related list on the *Related* tab above, which does\n             * carry `status neq completed`.\n             *\n             * Pinned by `test/metadata-references.test.ts` (entries resolve,\n             * no literal titles) and `test/i18n-references.test.ts` (every\n             * rail object has a `label` in every locale, so the fallback\n             * lands on a translation rather than on a humanized object name).\n             */\n            entries: [\n              {\n                objectName: 'crm_quote',\n                relationshipField: 'crm_opportunity',\n                limit: 3,\n              },\n              {\n                objectName: 'crm_opportunity_line_item',\n                relationshipField: 'crm_opportunity',\n                limit: 3,\n              },\n              {\n                objectName: 'crm_task',\n                relationshipField: 'related_to_opportunity',\n                limit: 3,\n              },\n            ],\n          },\n        },\n      ],\n    },\n  ],\n\n  isDefault: true,\n\n  aria: {\n    ariaLabel: 'Opportunity Detail Page',\n    ariaDescribedBy: 'Detailed view of opportunity information with related records and activity',\n  },\n};\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/sales/pages/account_detail.page.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/sales/pages\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/sales/pages/account_detail.page.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport type { Page } from '@objectstack/spec/ui';\n\n/**\n * Account Detail \u2014 slotted record page.\n *\n * We use ObjectUI's **slotted page** pattern: the default-page\n * synthesizer owns layout (header, highlights, path, tabs with\n * Details/Related/Activity/History, reference rail). We override\n * two slots:\n *\n *   header   \u00B7 Custom `page:header` with title and subtitle. It used to\n *              claim an ACCOUNT eyebrow, a building icon and a breadcrumb\n *              back to the list; none of them ever drew anything (#1269 and\n *              the props notes below \u2014 `breadcrumb` retired in 17.6.0).\n *\n *   discussion \u00B7 `record:chatter` is already auto-emitted, but we\n *              re-state it so it ALWAYS appears \u2014 even on accounts\n *              with no related lists (the auto-emitter sometimes\n *              skips chatter for lean objects). Discussion is core\n *              to the chat-first vibe, and it is the account's\n *              activity timeline: its one `feed` turns on the\n *              completed rows a logged call or meeting writes\n *              (see the slot's note).\n *\n * Why not embed an inline chat panel? `ai:chat_window` was dropped\n * from objectui (see @object-ui/layout CHANGELOG 5.x). The supported\n * surface is the global floating chatbot mounted by app-shell, which\n * picks up `defaultAgent: 'ask'` from this app and is launched from\n * the FAB at the bottom-right.\n */\nexport const AccountDetailPage = {\n  name: 'account_detail_page',\n  label: 'Account Detail',\n  description:\n    'Slotted account record page \u2014 custom header + persistent discussion feed.',\n\n  type: 'record',\n  object: 'crm_account',\n\n  kind: 'slotted',\n  regions: [],\n\n  slots: {\n    header: {\n      type: 'page:header',\n      id: 'account_header_slotted',\n      label: 'Account Header (slotted)',\n      properties: {\n        title: '{name}',\n        subtitle: '{industry} \u00B7 {type}',\n        // `icon` and `eyebrow` are GONE, and for two different reasons \u2014 both\n        // measured against the contract rather than inferred from the warning\n        // text (#1269).\n        //\n        // `icon` was REMOVED from `page:header` in @objectstack/spec 17.0.0\n        // (#6946, ADR-0087 D2). It is deleted rather than renamed because no\n        // renderer ever read it: objectui resolves `icon` per header ACTION\n        // (`action.icon`) and never off the header's own props bag, and the\n        // component registry never published it as an input \u2014 which is what put\n        // the key in objectui's `UNPUBLISHED_EXEMPTIONS` as a \"spec declares it,\n        // NO renderer read point\" entry. The header's own identity comes from\n        // the record chrome (`recordChrome`, on by default).\n        //\n        // `eyebrow` was never declared by anything. It is not in\n        // `PageHeaderProps`, it has no alias or tombstone there, and the string\n        // \"eyebrow\" does not occur anywhere in objectui \u2014 no schema, no\n        // registry input, no renderer. So the ACCOUNT kicker this page's\n        // docblock used to promise has never reached a screen: the props bag is\n        // `z.record(z.string(), z.unknown())`, so the key was carried into the\n        // artifact and dropped at render. Deleting it changes nothing a user\n        // sees; it only stops the source claiming a kicker exists.\n        // `breadcrumb` retired from `page:header` in @objectstack/spec 17.6.0\n        // (#20785, `page-header-breadcrumb-removed`) \u2014 deleted: no renderer\n        // ever drew a trail for it; the app shell's own trail is unchanged.\n        // Overriding the `header` slot REPLACES the synthesized header, actions\n        // and all \u2014 so this slot has to re-state every action it wants to keep.\n        // Before #592 it named none, which is why an account record showed no\n        // activity buttons at all while the list row's \u22EE menu showed three.\n        //\n        // Action IDs, not `ActionDef` objects: `PageHeaderProps.actions` is\n        // `z.array(z.string())` (\"Action IDs to show in header\") in\n        // @objectstack/spec 17.3.0, and this repo authors against the protocol\n        // (#1653). Each id is the `name` of a crm_account-scoped action in\n        // `src/sales/actions/activity-actions.ts`.\n        actions: ['log_call', 'log_meeting', 'schedule_meeting'],\n      },\n    },\n\n    discussion: {\n      type: 'record:chatter',\n      id: 'account_chatter',\n      label: 'Discussion',\n      /**\n       * One `feed`, for one reason: `showCompleted` (#2071).\n       *\n       * This feed IS the account's activity timeline \u2014 the slotted page\n       * synthesizes no Activity tab, so the panel's \"All Activity\" stream is\n       * where an account's `sys_activity` rows surface. A call or meeting\n       * logged on the account is a row of type `completed` (the `task` feed\n       * kind), and the timeline drops every such row unless\n       * `feed.showCompleted` is true \u2014 so Log a Call / Log a Meeting on an\n       * account wrote a row that appeared nowhere on the account.\n       *\n       * Authoring a `feed` costs two more keys, and they are stated rather\n       * than left out. `RecordChatterRenderer` builds `{ position: 'bottom',\n       * collapsible: false, feed: { enableReactions: true, enableThreading:\n       * true, showCommentInput: true }, ...schema }` \u2014 one shallow spread \u2014 so\n       * a `feed` of our own REPLACES that default object wholesale, and\n       * `RecordActivityTimeline` reads `enableReactions ?? false` and\n       * `enableThreading ?? false` off what is left. Without the two keys\n       * below, reactions and threading would silently switch off.\n       * `showCommentInput` needs no restating: the timeline reads it as\n       * `!== false`.\n       *\n       * `feed.enableMentions` needs none either: the renderer reads it as\n       * `!== false` too. And the older note still holds (#1269):\n       * `enableComments` and a top-level `enableReactions` / `enableMentions`\n       * are not `record:chatter` keys \u2014 `RecordChatterProps` declares\n       * `position`, `width`, `collapsible`, `defaultCollapsed`, `feed` and\n       * `aria`, nothing else.\n       */\n      properties: {\n        feed: {\n          showCompleted: true,\n          enableReactions: true,\n          enableThreading: true,\n        },\n      },\n    },\n  },\n} as unknown as Page;\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/sales/pages/account_workbench.page.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/sales/pages\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/sales/pages/account_workbench.page.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport { Page } from '@objectstack/spec/ui';\n\n/**\n * Account Workbench \u2014 ADR-0047 interface page (Airtable Interfaces parity).\n *\n * The author-curated counterpart to the Accounts object nav entry. Where\n * the object entry (data mode) shows every list view as switcher tabs and\n * offers the full toolbar, this page is deliberately closed:\n *\n *   \u2022 it REFERENCES the account default view (`sourceView`) \u2014 columns,\n *     base filter and sort are inherited, never restated (the iron rule);\n *   \u2022 end users get exactly three quick filters: industry (with record\n *     counts), customer type, and owner_id (the platform ownership lookup \u2014\n *     renders as a\n *     record-picker dropdown);\n *   \u2022 the visualization is locked to grid (single-entry whitelist);\n *   \u2022 advanced filtering / view management are not offered.\n *\n * Filter selections persist as `uf_*` URL params \u2014 reload-safe, shareable.\n *\n * NOTE: `interfaceConfig.userFilters` requires @objectstack/spec > 9.2.0\n * (ADR-0047). On older specs defineStack strips the unknown keys and the\n * page renders without the filter bar \u2014 a harmless no-op until the\n * dependency bump activates it.\n */\nexport const AccountWorkbenchPage: Page = {\n  name: 'account_workbench',\n  label: 'Account Workbench',\n  description: 'Curated account list for the sales team: quick filters only, no view management.',\n  type: 'list',\n  object: 'crm_account',\n  kind: 'full',\n  template: 'default',\n  isDefault: false,\n  // Interface pages carry no regions \u2014 the list surface is generated from\n  // `interfaceConfig` (ADR-0047), not composed from components.\n  regions: [],\n  interfaceConfig: {\n    source: 'crm_account',\n    sourceView: 'all_accounts',\n\n    ...({\n      userFilters: {\n        element: 'dropdown',\n        fields: [\n          { field: 'industry', showCount: true },\n          { field: 'type' },\n          { field: 'owner_id' },\n        ],\n      },\n      // typed via spread-as-any until @objectstack/spec ships ADR-0047\n      // (UserFiltersSchema is in framework main, > 9.2.0)\n    } as any),\n\n    appearance: {\n      showDescription: true,\n      allowedVisualizations: ['grid'],\n    },\n\n    userActions: {\n      sort: true,\n      search: true,\n      filter: false,\n      rowHeight: false,\n      addRecordForm: false,\n    },\n\n    showRecordCount: true,\n  },\n};\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/sales/pages/home.page.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/sales/pages\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/sales/pages/home.page.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport { Page, PageComponent, View } from '@objectstack/spec/ui';\nimport { EventViews } from '../views/event.view';\nimport { LeadViews } from '../views/lead.view';\nimport { OpportunityViews } from '../views/opportunity.view';\nimport { TaskViews } from '../views/task.view';\n\n/**\n * Embed one of an object's OWN saved list views in a page region.\n *\n * The home tabs used to hold a bare `{ type: 'page:section', properties: {} }`\n * each, which renders an empty `<section>` \u2014 three tab names promising content\n * over three blank panels. Same lesson as the `record:highlights` card below:\n * a component with no binding renders nothing, silently.\n *\n * `list-view` is the block that renders an object list inside a page (it is in\n * the platform's public block contract, ADR-0080), and it takes its columns /\n * filter / sort inline \u2014 there is no way for a page component to name a saved\n * view, so those three keys are READ OFF the saved view here rather than\n * retyped. That is the same iron rule `account_workbench.page.ts` states for\n * interface pages: columns, base filter and sort are inherited, never restated.\n * Retyping them would have created a second definition of \"my leads\" that\n * drifts from `src/sales/views/lead.view.ts` the first time either side is edited.\n *\n * `{current_user_id}` in a saved view's filter resolves on this path (the\n * ObjectQL read path runs `resolveFilterTokens()` since 17.0.0-rc.0), so\n * \"mine\" really does mean mine here \u2014 measured tab by tab in the browser, see\n * the PR. The nav's My Work group reaches the SAME views by name\n * (`src/sales/apps/crm.app.ts`); these tabs are the landing-page shortcut to them.\n */\nconst embeddedListView = (id: string, objectName: string, views: View, viewKey: string): PageComponent => {\n  const view = views.listViews?.[viewKey];\n  // Loud, at build time: a renamed or deleted view must not degrade back into\n  // a blank tab \u2014 that is the defect this whole component replaces.\n  if (!view) throw new Error(`home.page.ts: no saved view \"${viewKey}\" on ${objectName}`);\n  return {\n    type: 'list-view',\n    id,\n    label: view.label,\n    properties: {\n      objectName,\n      viewType: 'grid',\n      columns: view.columns,\n      filter: view.filter,\n      sort: view.sort,\n    },\n  };\n};\n\n/**\n * Sales Home Page\n *\n * Demonstrates a home page layout with dashboards and quick access widgets.\n * Similar to Salesforce Lightning Home Page.\n *\n * Features:\n * - Dashboard-style layout\n * - Multiple component regions\n * - Global search and notifications\n * - Quick action cards\n */\nexport const SalesHomePage: Page = {\n  name: 'sales_home_page',\n  label: 'Sales Home',\n  description: 'Sales team home page with key metrics and quick actions',\n  \n  type: 'home',\n  \n  template: 'three-column',\n  kind: 'full',  \n  variables: [\n    {\n      name: 'selectedPeriod',\n      type: 'string',\n      defaultValue: 'this_month',\n    },\n  ],\n  \n  regions: [\n    {\n      name: 'header',\n      width: 'full',\n      components: [\n        {\n          type: 'page:header',\n          id: 'home_header',\n          label: 'Sales Home Header',\n          properties: {\n            title: 'Sales Dashboard',\n            // Was `Welcome back, {current_user.first_name}`, which rendered as\n            // \"Welcome back, \" \u2014 the name was never going to arrive, because\n            // that one string mixes three vocabularies that do not compose:\n            //\n            //  1. `subtitle` is an `I18nLabel` (`ComponentPropsMap`,\n            //     `@objectstack/spec/ui`) \u2014 a display string or an inline\n            //     locale map, resolved by `resolveI18nLabel`. The field has no\n            //     token pass and no expression pass of its own.\n            //  2. Braces DO resolve in a page header, but the vocabulary is the\n            //     BOUND RECORD's own fields \u2014 `case_detail.page.ts` records the\n            //     measurement, where `{account}` matched no field and the\n            //     subtitle rendered blank until it was spelled `{crm_account}`.\n            //     A `type: 'home'` page has no record, so no brace token can\n            //     ever resolve here.\n            //  3. `current_user.first_name` is a CEL path, and CEL is written\n            //     bare, never inside `{\u2026}`. The one resolvable brace token in\n            //     the filter vocabulary is `{current_user_id}` on its own.\n            //\n            // A greeting that names the user is not expressible on a\n            // translatable label, so the label now says the part that is true\n            // in every locale and the four bundles carry the translations\n            // (`pages.sales_home_page.subtitle`). Personalising it would need a\n            // component that takes user data \u2014 no shipped component does\n            // (`user:profile` and its neighbours are `emptyProps` rows), so\n            // this is a static greeting rather than a widened accept surface.\n            subtitle: 'Welcome back',\n            // `icon` removed from `page:header` in @objectstack/spec 17.0.0\n            // (#6946, ADR-0087 D2) \u2014 deleted, not renamed. See the full note on\n            // `account_detail.page.ts`; nothing ever drew it.\n            // `breadcrumb` retired from `page:header` in @objectstack/spec 17.6.0\n            // (#20785, `page-header-breadcrumb-removed`) \u2014 deleted: no renderer\n            // ever drew a trail for it; the app shell's own trail is unchanged.\n          },\n        },\n      ],\n    },\n    \n    {\n      name: 'left_sidebar',\n      width: 'small',\n      components: [\n        {\n          type: 'page:card',\n          id: 'quick_create',\n          label: 'Quick Create',\n          properties: {\n            title: 'Quick Create',\n            bordered: true,\n            children: [\n              {\n                type: 'nav:menu',\n                id: 'create_menu',\n                properties: {},\n              },\n            ],\n          },\n        },\n        // There is no `Recent Items` card here any more, and re-adding one\n        // needs a data source that does not exist yet.\n        //\n        // It shipped as a `page:card` with a title and no body: a bordered box\n        // with the words \"Recent Items\" and nothing under them, on the landing\n        // page of every `sales_rep` / `sales_manager`. \"Recent\" is per-user\n        // access history across objects, and the platform publishes no source\n        // for it on 17.1.0 \u2014 `ComponentPropsMap` has no recent-records\n        // component, and the two that sound like one (`record:activity`,\n        // `record:history`) both read the page's BOUND RECORD, which a home\n        // page does not have. Binding it to one object's list view instead\n        // would have made the title lie, which is the defect #771 exists to\n        // prevent, so the card is removed rather than filled with something\n        // that is not recency. Recorded as #1217; when the platform ships a\n        // recent-records source, this is where the card goes back.\n      ],\n    },\n    \n    {\n      name: 'main',\n      width: 'large',\n      components: [\n        {\n          type: 'page:card',\n          id: 'key_metrics',\n          label: 'Key Metrics',\n          properties: {\n            title: 'Key Performance Indicators',\n            bordered: false,\n            // `record:highlights` needs a bound record and real fields; a home\n            // page has neither, and the four names it listed (total_revenue,\n            // deals_won, \u2026) exist on no object \u2014 the card rendered blank.\n            // `object-metric` widgets aggregate live data instead.\n            children: [\n              {\n                type: 'object-metric',\n                id: 'kpi_revenue_won',\n                properties: {\n                  objectName: 'crm_opportunity',\n                  label: 'Revenue (Won)',\n                  icon: 'dollar-sign',\n                  aggregate: { field: 'amount', function: 'sum' },\n                  filter: [{ field: 'stage', operator: 'equals', value: 'closed_won' }],\n                },\n              },\n              {\n                type: 'object-metric',\n                id: 'kpi_deals_won',\n                properties: {\n                  objectName: 'crm_opportunity',\n                  label: 'Deals Won',\n                  icon: 'trophy',\n                  aggregate: { field: 'id', function: 'count' },\n                  filter: [{ field: 'stage', operator: 'equals', value: 'closed_won' }],\n                },\n              },\n              {\n                type: 'object-metric',\n                id: 'kpi_pipeline_value',\n                properties: {\n                  objectName: 'crm_opportunity',\n                  label: 'Pipeline Value',\n                  icon: 'briefcase',\n                  aggregate: { field: 'amount', function: 'sum' },\n                  filter: [{ field: 'stage', operator: 'not_in', value: ['closed_won', 'closed_lost'] }],\n                },\n              },\n              {\n                type: 'object-metric',\n                id: 'kpi_open_leads',\n                properties: {\n                  objectName: 'crm_lead',\n                  label: 'Open Leads',\n                  icon: 'user-plus',\n                  aggregate: { field: 'id', function: 'count' },\n                  filter: [{ field: 'is_converted', operator: 'equals', value: false }],\n                },\n              },\n            ],\n          },\n        },\n        {\n          type: 'page:tabs',\n          id: 'home_tabs',\n          label: 'Home Tabs',\n          properties: {\n            /**\n             * `type` \u2192 `tabStyle` (@objectstack/spec 17.0.0, #6776, ADR-0087\n             * D2). The concept and the value vocabulary (`line` | `card` |\n             * `pill`) are unchanged; only the spelling moved, because a props\n             * key named `type` collides with the page component's own dispatch\n             * key: objectui's `SchemaRenderer` hoists `properties` onto the node\n             * but deliberately skips `type` and `id` (or the inner value would\n             * shadow which renderer to dispatch to), and `sdui-parser` lists\n             * `type` in `BASE_PROPS`, so a manifest input by that name is never\n             * validated at all.\n             *\n             * Renaming is behaviour-preserving on this page and on the three\n             * record pages: the renderer resolves\n             * `schema?.properties?.type || schema?.tabStyle || 'line'`, so it\n             * has been honouring the retired spelling as a back-compat read all\n             * along and picks up the canonical one through the same hoist.\n             */\n            tabStyle: 'card',\n            position: 'top',\n            items: [\n              {\n                label: 'My Leads',\n                icon: 'user-plus',\n                children: [embeddedListView('home_my_leads', 'crm_lead', LeadViews, 'my_leads')],\n              },\n              {\n                // Was \"My Opportunities\", which promises every deal I own; the\n                // view behind it is the open-pipeline one (the nav's My Work >\n                // My Deals opens the same `my_open_deals`). The tab name now\n                // says what the panel shows.\n                label: 'My Open Deals',\n                icon: 'dollar-sign',\n                children: [embeddedListView('home_my_deals', 'crm_opportunity', OpportunityViews, 'my_open_deals')],\n              },\n              {\n                // Same correction: `my_open_tasks` excludes completed tasks.\n                label: 'My Open Tasks',\n                icon: 'list-checks',\n                children: [embeddedListView('home_my_tasks', 'crm_task', TaskViews, 'my_open_tasks')],\n              },\n            ],\n          },\n        },\n      ],\n    },\n    \n    {\n      name: 'right_sidebar',\n      width: 'medium',\n      components: [\n        {\n          type: 'page:card',\n          id: 'ai_briefing',\n          // The assistant is the PLATFORM's (`ask`), not an app-owned persona:\n          // HotCRM contributes skills, the agent lives in the cloud side\n          // (maintainer ruling on #612, 2026-08-04). The retired `sales_copilot`\n          // agent (#512, ADR-0063 \u00A72) must not be named in live UI copy \u2014 and\n          // the entry point is the assistant panel the platform opens from the\n          // right edge of every page, which is the wording\n          // `content/docs/ai-copilot/index.mdx` landed in #611/PR #1001.\n          label: 'Today with the AI Assistant',\n          properties: {\n            title: 'Ask the AI Assistant',\n            bordered: true,\n            // The paragraph is an `element:text` child (#1581). It used to be\n            // `properties.description`, which `page:card` does not declare, so\n            // the card rendered as a title over nothing. `content` is not on\n            // the locale pack's page-component face, so the four languages\n            // live here as an inline locale map, the spec's route for page\n            // prose. The #1002 persona guard in\n            // `test/metadata-references.test.ts` reads this child.\n            children: [\n              {\n                type: 'element:text',\n                id: 'ai_briefing_text',\n                properties: {\n                  content: {\n                    en: 'Open the assistant panel from the right edge of the page and ask \"what should I focus on today?\" \u2014 it sees your live pipeline, schema, and accounts.',\n                    'zh-CN':\n                      '\u4ECE\u9875\u9762\u53F3\u4FA7\u6253\u5F00\u52A9\u624B\u9762\u677F\uFF0C\u8BE2\u95EE\"\u6211\u4ECA\u5929\u5E94\u8BE5\u5173\u6CE8\u4EC0\u4E48\uFF1F\"\u2014\u2014\u5B83\u53EF\u4EE5\u5B9E\u65F6\u67E5\u770B\u60A8\u7684\u9500\u552E\u7BA1\u9053\u3001\u67B6\u6784\u4E0E\u5BA2\u6237\u4FE1\u606F\u3002',\n                    'es-ES':\n                      'Abra el panel del asistente desde el borde derecho de la p\u00E1gina y pregunte \"\u00BFen qu\u00E9 deber\u00EDa concentrarme hoy?\" \u2014 ve su flujo de ventas, esquema y cuentas en tiempo real.',\n                    'ja-JP':\n                      '\u30DA\u30FC\u30B8\u53F3\u7AEF\u304B\u3089\u30A2\u30B7\u30B9\u30BF\u30F3\u30C8\u30D1\u30CD\u30EB\u3092\u958B\u304D\u3001\u300C\u4ECA\u65E5\u306F\u4F55\u306B\u96C6\u4E2D\u3059\u3079\u304D\u304B\uFF1F\u300D\u3068\u5C0B\u306D\u3066\u304F\u3060\u3055\u3044 \u2014 \u30EA\u30A2\u30EB\u30BF\u30A4\u30E0\u306E\u30D1\u30A4\u30D7\u30E9\u30A4\u30F3\u3001\u30B9\u30AD\u30FC\u30DE\u3001\u53D6\u5F15\u5148\u60C5\u5831\u3092\u628A\u63E1\u3057\u3066\u3044\u307E\u3059\u3002',\n                  },\n                },\n              },\n            ],\n          },\n        },\n        {\n          type: 'page:card',\n          id: 'upcoming_events',\n          // Was `Calendar` / \"Today's Schedule\" over an empty bordered box \u2014\n          // the card declared no body, so the renderer had nothing to draw.\n          //\n          // It is bound to `crm_event`'s saved `upcoming_events` view, read off\n          // the view exactly like the tabs above, and the name now matches what\n          // the panel shows. \"Today's Schedule\" is NOT what any existing view\n          // says: `my_events` is scoped to the current user but carries no date\n          // filter, no sort and no date column (27 seeded rows, mostly `held`\n          // interactions from the past), while `upcoming_events` is\n          // `status: 'planned'` sorted by `start_datetime` ascending with the\n          // date on the row. Narrowing either one to today would mean retyping\n          // a filter in this page \u2014 the second definition the helper above\n          // exists to prevent \u2014 so the title says \"upcoming\" instead of\n          // promising a day this page cannot compute.\n          label: 'Upcoming Events',\n          properties: {\n            title: 'Upcoming Events',\n            bordered: true,\n            children: [embeddedListView('home_upcoming_events', 'crm_event', EventViews, 'upcoming_events')],\n          },\n        },\n      ],\n    },\n  ],\n  \n  isDefault: true,\n  \n  aria: {\n    ariaLabel: 'Sales Home Page',\n    ariaDescribedBy: 'Sales team home page with metrics, leads, and quick actions',\n  },\n};\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/sales/pages/app_launcher.page.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/sales/pages\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/sales/pages/app_launcher.page.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport { Page } from '@objectstack/spec/ui';\n\n/**\n * App Launcher Page\n * \n * Demonstrates an application launcher page similar to Salesforce App Launcher.\n * \n * Features:\n * - Grid-based app icon layout\n * - Global search\n * - Quick access to all apps\n */\nexport const AppLauncherPage: Page = {\n  name: 'app_launcher_page',\n  label: 'App Launcher',\n  description: 'Central hub for accessing all applications',\n  \n  type: 'app',\n  \n  template: 'centered',\n  kind: 'full',  \n  regions: [\n    {\n      name: 'header',\n      width: 'full',\n      components: [\n        {\n          type: 'global:search',\n          id: 'app_search',\n          label: 'Search Apps',\n          properties: {},\n        },\n      ],\n    },\n    \n    {\n      name: 'main',\n      width: 'large',\n      components: [\n        {\n          type: 'page:header',\n          id: 'launcher_header',\n          label: 'App Launcher Header',\n          properties: {\n            title: 'App Launcher',\n            subtitle: 'Select an app to get started',\n            // `icon` removed from `page:header` in @objectstack/spec 17.0.0\n            // (#6946, ADR-0087 D2) \u2014 deleted, not renamed. See the full note on\n            // `account_detail.page.ts`; nothing ever drew it.\n            // `breadcrumb` retired from `page:header` in @objectstack/spec 17.6.0\n            // (#20785, `page-header-breadcrumb-removed`) \u2014 deleted: no renderer\n            // ever drew a trail for it; the app shell's own trail is unchanged.\n          },\n        },\n        {\n          type: 'app:launcher',\n          id: 'app_grid',\n          label: 'Application Grid',\n          properties: {},\n        },\n      ],\n    },\n  ],\n  \n  isDefault: false,\n  \n  aria: {\n    ariaLabel: 'App Launcher Page',\n    ariaDescribedBy: 'Central application launcher for accessing all apps',\n  },\n};\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/sales/pages/utility_bar.page.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/sales/pages\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/sales/pages/utility_bar.page.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport { Page } from '@objectstack/spec/ui';\n\n/**\n * Utility Bar Page\n * \n * Demonstrates a utility bar page for floating panels and quick access tools.\n * Similar to Salesforce Lightning Utility Bar.\n * \n * Features:\n * - Floating utility panels\n * - Quick notes\n * - Chat/messaging\n * - Notifications\n */\nexport const UtilityBarPage: Page = {\n  name: 'utility_bar_page',\n  label: 'Utility Bar',\n  description: 'Quick access utility bar with floating tools',\n  \n  type: 'utility',\n  \n  template: 'utility-bar',\n  kind: 'full',\n  regions: [\n    {\n      name: 'utilities',\n      width: 'full',\n      components: [\n        {\n          type: 'global:notifications',\n          id: 'notifications_panel',\n          label: 'Notifications',\n          properties: {},\n        },\n        {\n          type: 'page:card',\n          id: 'quick_notes',\n          label: 'Quick Notes',\n          properties: {\n            title: 'Quick Notes',\n            bordered: true,\n          },\n        },\n        {\n          type: 'global:search',\n          id: 'quick_search',\n          label: 'Quick Search',\n          properties: {},\n        },\n      ],\n    },\n  ],\n  \n  isDefault: false,\n  \n  aria: {\n    ariaLabel: 'Utility Bar',\n    ariaDescribedBy: 'Quick access utility bar with floating tools and notifications',\n  },\n};\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/sales/email-templates/index.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/sales/email-templates\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/sales/email-templates/index.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\n/**\n * Sales email-template barrel.\n *\n * An email template lives with the object its `notify` node is authored\n * against (AGENTS.md layout rule 3), so the packages that own notifying flows\n * each carry their own directory. `_bundle.ts` is the shared source the other\n * two read along their edge into sales.\n */\nexport { SalesEmailTemplates } from './crm.email-template';\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/sales/email-templates/en.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/sales/email-templates\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/sales/email-templates/en.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport type { EmailTemplatePack } from './_bundle';\n\n/**\n * English (en-US) \u2014 the sales package's notification templates.\n *\n * Per-locale file, one language each, assembled in `crm.email-template.ts` \u2014\n * the same convention `src/sales/translations/` already follows for the UI\n * locale packs.\n *\n * Every string here is the text its `notify` node already sent, with the\n * flow's `{var.path}` interpolations re-expressed as the `{{key}}` holes the\n * renderer fills from that node's `templateData`. A conversion, not a rewrite:\n * no notification says anything new.\n *\n * \u26A0\uFE0F Registered under `en-US`, not `en` \u2014 see the ladder note on `bundle()`.\n */\nexport const en: EmailTemplatePack = {\n  'crm.account_approved': {\n    label: 'Account Approved',\n    subject: 'Account approved: {{name}}',\n    bodyHtml: '<p>This account has been signed off and is now established data.</p>',\n  },\n  'crm.account_rejected': {\n    label: 'Account Not Approved',\n    subject: 'Account not approved: {{name}}',\n    bodyHtml: '<p>This account was not signed off. Correct its details and ask for another review.</p>',\n  },\n  'crm.contact_welcome': {\n    label: 'New Contact',\n    subject: 'New contact: {{first_name}} {{last_name}}',\n    bodyHtml: '<p>{{first_name}} {{last_name}} was added as a contact. Reach out to welcome them.</p>',\n  },\n  'crm.deal_stalled': {\n    label: 'Stalled Deal',\n    subject: 'Stalled deal: {{name}}',\n    bodyHtml: '<p>Opportunity {{name}} has sat in {{stage}} for {{days_in_stage}} days. Time to advance or re-qualify it.</p>',\n  },\n  'crm.large_deal_won': {\n    label: 'Large Deal Won',\n    subject: 'Large deal won: {{name}}',\n    bodyHtml: '<p>{{name}} closed at {{amount}}. Congratulations to the team.</p>',\n  },\n  'crm.lead_conversion_approved': {\n    label: 'Lead Approved for Conversion',\n    subject: 'Lead approved for conversion: {{first_name}} {{last_name}}',\n    bodyHtml: '<p>This lead has been signed off. You can convert it into an account, contact and opportunity.</p>',\n  },\n  'crm.lead_conversion_rejected': {\n    label: 'Lead Not Approved',\n    subject: 'Lead not approved: {{first_name}} {{last_name}}',\n    bodyHtml: '<p>Conversion of this lead was not approved. Keep working it, or disqualify it with a reason.</p>',\n  },\n  'crm.lead_converted': {\n    label: 'Lead Converted',\n    subject: 'Lead converted: {{first_name}} {{last_name}}',\n    bodyHtml: '<p>Lead {{first_name}} {{last_name}} was converted into an account and contact.</p>',\n  },\n  'crm.lead_routing_hot': {\n    label: 'Hot Lead Routing',\n    subject: 'Hot lead \u2014 assign within 24h: {{first_name}} {{last_name}}',\n    bodyHtml: '<p>{{first_name}} {{last_name}} from {{company}} (rating {{rating}}) needs an owner today.</p>',\n  },\n  'crm.lead_routing_new': {\n    label: 'New Lead Routing',\n    subject: 'New lead to assign: {{first_name}} {{last_name}}',\n    bodyHtml: '<p>{{first_name}} {{last_name}} from {{company}} is awaiting assignment.</p>',\n  },\n  'crm.opportunity_approved': {\n    label: 'Deal Approved',\n    subject: 'Deal approved: {{name}}',\n    bodyHtml: '<p>Your opportunity {{name}} has been approved.</p>',\n  },\n  'crm.opportunity_rejected': {\n    label: 'Deal Rejected',\n    subject: 'Deal rejected: {{name}}',\n    bodyHtml: '<p>Your opportunity {{name}} was not approved. Review and revise before resubmitting.</p>',\n  },\n  'crm.task_reminder': {\n    label: 'Task Reminder',\n    subject: 'Task reminder: {{subject}}',\n    bodyHtml: '<p>Your task \"{{subject}}\" is due (reminder set for {{reminder_date}}).</p>',\n  },\n  'crm.urgent_task': {\n    label: 'Urgent Task',\n    subject: 'Urgent task: {{subject}}',\n    bodyHtml: '<p>An urgent task \"{{subject}}\" was assigned to you and needs attention.</p>',\n  },\n};\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/sales/email-templates/zh-CN.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/sales/email-templates\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/sales/email-templates/zh-CN.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport type { EmailTemplatePack } from './_bundle';\n\n/** \u7B80\u4F53\u4E2D\u6587 (zh-CN) \u2014 the sales package's notification templates. See `en.ts`. */\nexport const zhCN: EmailTemplatePack = {\n  'crm.account_approved': {\n    label: '\u5BA2\u6237\u5BA1\u6279\u901A\u8FC7',\n    subject: '\u5BA2\u6237\u5DF2\u5BA1\u6279\u901A\u8FC7\uFF1A{{name}}',\n    bodyHtml: '<p>\u8BE5\u5BA2\u6237\u5DF2\u5BA1\u6279\u901A\u8FC7\uFF0C\u73B0\u4E3A\u6B63\u5F0F\u6570\u636E\u3002</p>',\n  },\n  'crm.account_rejected': {\n    label: '\u5BA2\u6237\u5BA1\u6279\u672A\u901A\u8FC7',\n    subject: '\u5BA2\u6237\u672A\u901A\u8FC7\u5BA1\u6279\uFF1A{{name}}',\n    bodyHtml: '<p>\u8BE5\u5BA2\u6237\u672A\u901A\u8FC7\u5BA1\u6279\u3002\u8BF7\u4FEE\u6B63\u5176\u4FE1\u606F\u540E\u518D\u6B21\u63D0\u4EA4\u5BA1\u6838\u3002</p>',\n  },\n  'crm.contact_welcome': {\n    label: '\u65B0\u8054\u7CFB\u4EBA',\n    subject: '\u65B0\u8054\u7CFB\u4EBA\uFF1A{{first_name}} {{last_name}}',\n    bodyHtml: '<p>{{first_name}} {{last_name}} \u5DF2\u6DFB\u52A0\u4E3A\u8054\u7CFB\u4EBA\u3002\u8BF7\u4E3B\u52A8\u8054\u7CFB\u5E76\u8868\u793A\u6B22\u8FCE\u3002</p>',\n  },\n  'crm.deal_stalled': {\n    label: '\u5546\u673A\u505C\u6EDE',\n    subject: '\u505C\u6EDE\u5546\u673A\uFF1A{{name}}',\n    bodyHtml: '<p>\u5546\u673A {{name}} \u5DF2\u5728\u201C{{stage}}\u201D\u9636\u6BB5\u505C\u7559 {{days_in_stage}} \u5929\u3002\u8BF7\u63A8\u8FDB\u6216\u91CD\u65B0\u8BC4\u4F30\u3002</p>',\n  },\n  'crm.large_deal_won': {\n    label: '\u5927\u989D\u5546\u673A\u8D62\u5355',\n    subject: '\u5927\u989D\u5546\u673A\u8D62\u5355\uFF1A{{name}}',\n    bodyHtml: '<p>{{name}} \u4EE5 {{amount}} \u6210\u4EA4\u3002\u606D\u559C\u56E2\u961F\u3002</p>',\n  },\n  'crm.lead_conversion_approved': {\n    label: '\u7EBF\u7D22\u8F6C\u6362\u5DF2\u6279\u51C6',\n    subject: '\u7EBF\u7D22\u8F6C\u6362\u5DF2\u6279\u51C6\uFF1A{{first_name}} {{last_name}}',\n    bodyHtml: '<p>\u8BE5\u7EBF\u7D22\u5DF2\u5BA1\u6279\u901A\u8FC7\u3002\u60A8\u53EF\u4EE5\u5C06\u5176\u8F6C\u6362\u4E3A\u5BA2\u6237\u3001\u8054\u7CFB\u4EBA\u548C\u5546\u673A\u3002</p>',\n  },\n  'crm.lead_conversion_rejected': {\n    label: '\u7EBF\u7D22\u8F6C\u6362\u672A\u6279\u51C6',\n    subject: '\u7EBF\u7D22\u672A\u901A\u8FC7\u5BA1\u6279\uFF1A{{first_name}} {{last_name}}',\n    bodyHtml: '<p>\u8BE5\u7EBF\u7D22\u7684\u8F6C\u6362\u672A\u83B7\u6279\u51C6\u3002\u8BF7\u7EE7\u7EED\u8DDF\u8FDB\uFF0C\u6216\u6CE8\u660E\u539F\u56E0\u5C06\u5176\u53D6\u6D88\u8D44\u683C\u3002</p>',\n  },\n  'crm.lead_converted': {\n    label: '\u7EBF\u7D22\u5DF2\u8F6C\u6362',\n    subject: '\u7EBF\u7D22\u5DF2\u8F6C\u6362\uFF1A{{first_name}} {{last_name}}',\n    bodyHtml: '<p>\u7EBF\u7D22 {{first_name}} {{last_name}} \u5DF2\u8F6C\u6362\u4E3A\u5BA2\u6237\u548C\u8054\u7CFB\u4EBA\u3002</p>',\n  },\n  'crm.lead_routing_hot': {\n    label: '\u70ED\u95E8\u7EBF\u7D22\u5206\u914D',\n    subject: '\u70ED\u95E8\u7EBF\u7D22 \u2014 24 \u5C0F\u65F6\u5185\u5206\u914D\uFF1A{{first_name}} {{last_name}}',\n    bodyHtml: '<p>\u6765\u81EA {{company}} \u7684 {{first_name}} {{last_name}}\uFF08\u8BC4\u5206 {{rating}}\uFF09\u9700\u8981\u4ECA\u5929\u5C31\u6307\u5B9A\u8D1F\u8D23\u4EBA\u3002</p>',\n  },\n  'crm.lead_routing_new': {\n    label: '\u65B0\u7EBF\u7D22\u5206\u914D',\n    subject: '\u5F85\u5206\u914D\u65B0\u7EBF\u7D22\uFF1A{{first_name}} {{last_name}}',\n    bodyHtml: '<p>\u6765\u81EA {{company}} \u7684 {{first_name}} {{last_name}} \u6B63\u5728\u7B49\u5F85\u5206\u914D\u3002</p>',\n  },\n  'crm.opportunity_approved': {\n    label: '\u5546\u673A\u5BA1\u6279\u901A\u8FC7',\n    subject: '\u5546\u673A\u5DF2\u6279\u51C6\uFF1A{{name}}',\n    bodyHtml: '<p>\u60A8\u7684\u5546\u673A {{name}} \u5DF2\u83B7\u6279\u51C6\u3002</p>',\n  },\n  'crm.opportunity_rejected': {\n    label: '\u5546\u673A\u5BA1\u6279\u672A\u901A\u8FC7',\n    subject: '\u5546\u673A\u672A\u6279\u51C6\uFF1A{{name}}',\n    bodyHtml: '<p>\u60A8\u7684\u5546\u673A {{name}} \u672A\u83B7\u6279\u51C6\u3002\u8BF7\u68C0\u67E5\u5E76\u4FEE\u6539\u540E\u91CD\u65B0\u63D0\u4EA4\u3002</p>',\n  },\n  'crm.task_reminder': {\n    label: '\u4EFB\u52A1\u63D0\u9192',\n    subject: '\u4EFB\u52A1\u63D0\u9192\uFF1A{{subject}}',\n    bodyHtml: '<p>\u60A8\u7684\u4EFB\u52A1\u201C{{subject}}\u201D\u5DF2\u5230\u671F\uFF08\u63D0\u9192\u65F6\u95F4 {{reminder_date}}\uFF09\u3002</p>',\n  },\n  'crm.urgent_task': {\n    label: '\u7D27\u6025\u4EFB\u52A1',\n    subject: '\u7D27\u6025\u4EFB\u52A1\uFF1A{{subject}}',\n    bodyHtml: '<p>\u4E00\u9879\u7D27\u6025\u4EFB\u52A1\u201C{{subject}}\u201D\u5DF2\u5206\u914D\u7ED9\u60A8\uFF0C\u9700\u8981\u5C3D\u5FEB\u5904\u7406\u3002</p>',\n  },\n};\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/sales/email-templates/ja-JP.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/sales/email-templates\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/sales/email-templates/ja-JP.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport type { EmailTemplatePack } from './_bundle';\n\n/** \u65E5\u672C\u8A9E (ja-JP) \u2014 the sales package's notification templates. See `en.ts`. */\nexport const jaJP: EmailTemplatePack = {\n  'crm.account_approved': {\n    label: '\u30A2\u30AB\u30A6\u30F3\u30C8\u627F\u8A8D\u6E08\u307F',\n    subject: '\u30A2\u30AB\u30A6\u30F3\u30C8\u304C\u627F\u8A8D\u3055\u308C\u307E\u3057\u305F: {{name}}',\n    bodyHtml: '<p>\u3053\u306E\u30A2\u30AB\u30A6\u30F3\u30C8\u306F\u627F\u8A8D\u3055\u308C\u3001\u6B63\u5F0F\u306A\u30C7\u30FC\u30BF\u306B\u306A\u308A\u307E\u3057\u305F\u3002</p>',\n  },\n  'crm.account_rejected': {\n    label: '\u30A2\u30AB\u30A6\u30F3\u30C8\u672A\u627F\u8A8D',\n    subject: '\u30A2\u30AB\u30A6\u30F3\u30C8\u304C\u627F\u8A8D\u3055\u308C\u307E\u305B\u3093\u3067\u3057\u305F: {{name}}',\n    bodyHtml: '<p>\u3053\u306E\u30A2\u30AB\u30A6\u30F3\u30C8\u306F\u627F\u8A8D\u3055\u308C\u307E\u305B\u3093\u3067\u3057\u305F\u3002\u5185\u5BB9\u3092\u4FEE\u6B63\u306E\u3046\u3048\u3001\u518D\u5EA6\u627F\u8A8D\u3092\u4F9D\u983C\u3057\u3066\u304F\u3060\u3055\u3044\u3002</p>',\n  },\n  'crm.contact_welcome': {\n    label: '\u65B0\u898F\u53D6\u5F15\u5148\u8CAC\u4EFB\u8005',\n    subject: '\u65B0\u3057\u3044\u53D6\u5F15\u5148\u8CAC\u4EFB\u8005: {{first_name}} {{last_name}}',\n    bodyHtml: '<p>{{first_name}} {{last_name}} \u304C\u53D6\u5F15\u5148\u8CAC\u4EFB\u8005\u3068\u3057\u3066\u8FFD\u52A0\u3055\u308C\u307E\u3057\u305F\u3002\u3054\u6328\u62F6\u306E\u9023\u7D61\u3092\u3057\u3066\u304F\u3060\u3055\u3044\u3002</p>',\n  },\n  'crm.deal_stalled': {\n    label: '\u505C\u6EDE\u4E2D\u306E\u5546\u8AC7',\n    subject: '\u505C\u6EDE\u4E2D\u306E\u5546\u8AC7: {{name}}',\n    bodyHtml: '<p>\u5546\u8AC7 {{name}} \u306F\u300C{{stage}}\u300D\u306B {{days_in_stage}} \u65E5\u9593\u7559\u307E\u3063\u3066\u3044\u307E\u3059\u3002\u6B21\u306E\u6BB5\u968E\u306B\u9032\u3081\u308B\u304B\u3001\u518D\u8A55\u4FA1\u3057\u3066\u304F\u3060\u3055\u3044\u3002</p>',\n  },\n  'crm.large_deal_won': {\n    label: '\u5927\u578B\u5546\u8AC7\u306E\u53D7\u6CE8',\n    subject: '\u5927\u578B\u5546\u8AC7\u3092\u53D7\u6CE8: {{name}}',\n    bodyHtml: '<p>{{name}} \u304C {{amount}} \u3067\u6210\u7D04\u3057\u307E\u3057\u305F\u3002\u30C1\u30FC\u30E0\u306E\u7686\u3055\u3093\u3001\u304A\u3081\u3067\u3068\u3046\u3054\u3056\u3044\u307E\u3059\u3002</p>',\n  },\n  'crm.lead_conversion_approved': {\n    label: '\u30EA\u30FC\u30C9\u5909\u63DB\u306E\u627F\u8A8D',\n    subject: '\u30EA\u30FC\u30C9\u306E\u5909\u63DB\u304C\u627F\u8A8D\u3055\u308C\u307E\u3057\u305F: {{first_name}} {{last_name}}',\n    bodyHtml: '<p>\u3053\u306E\u30EA\u30FC\u30C9\u306F\u627F\u8A8D\u3055\u308C\u307E\u3057\u305F\u3002\u53D6\u5F15\u5148\u3001\u53D6\u5F15\u5148\u8CAC\u4EFB\u8005\u3001\u5546\u8AC7\u306B\u5909\u63DB\u3067\u304D\u307E\u3059\u3002</p>',\n  },\n  'crm.lead_conversion_rejected': {\n    label: '\u30EA\u30FC\u30C9\u672A\u627F\u8A8D',\n    subject: '\u30EA\u30FC\u30C9\u304C\u627F\u8A8D\u3055\u308C\u307E\u305B\u3093\u3067\u3057\u305F: {{first_name}} {{last_name}}',\n    bodyHtml: '<p>\u3053\u306E\u30EA\u30FC\u30C9\u306E\u5909\u63DB\u306F\u627F\u8A8D\u3055\u308C\u307E\u305B\u3093\u3067\u3057\u305F\u3002\u5F15\u304D\u7D9A\u304D\u5BFE\u5FDC\u3059\u308B\u304B\u3001\u7406\u7531\u3092\u4ED8\u3051\u3066\u5BFE\u8C61\u5916\u306B\u3057\u3066\u304F\u3060\u3055\u3044\u3002</p>',\n  },\n  'crm.lead_converted': {\n    label: '\u30EA\u30FC\u30C9\u5909\u63DB\u6E08\u307F',\n    subject: '\u30EA\u30FC\u30C9\u3092\u5909\u63DB\u3057\u307E\u3057\u305F: {{first_name}} {{last_name}}',\n    bodyHtml: '<p>\u30EA\u30FC\u30C9 {{first_name}} {{last_name}} \u3092\u53D6\u5F15\u5148\u3068\u53D6\u5F15\u5148\u8CAC\u4EFB\u8005\u306B\u5909\u63DB\u3057\u307E\u3057\u305F\u3002</p>',\n  },\n  'crm.lead_routing_hot': {\n    label: '\u30DB\u30C3\u30C8\u30EA\u30FC\u30C9\u306E\u5272\u308A\u5F53\u3066',\n    subject: '\u30DB\u30C3\u30C8\u30EA\u30FC\u30C9 \u2014 24 \u6642\u9593\u4EE5\u5185\u306B\u5272\u308A\u5F53\u3066: {{first_name}} {{last_name}}',\n    bodyHtml: '<p>{{company}} \u306E {{first_name}} {{last_name}}\uFF08\u8A55\u4FA1 {{rating}}\uFF09\u306B\u672C\u65E5\u4E2D\u306B\u62C5\u5F53\u8005\u3092\u5272\u308A\u5F53\u3066\u3066\u304F\u3060\u3055\u3044\u3002</p>',\n  },\n  'crm.lead_routing_new': {\n    label: '\u65B0\u898F\u30EA\u30FC\u30C9\u306E\u5272\u308A\u5F53\u3066',\n    subject: '\u5272\u308A\u5F53\u3066\u5F85\u3061\u306E\u65B0\u898F\u30EA\u30FC\u30C9: {{first_name}} {{last_name}}',\n    bodyHtml: '<p>{{company}} \u306E {{first_name}} {{last_name}} \u304C\u5272\u308A\u5F53\u3066\u3092\u5F85\u3063\u3066\u3044\u307E\u3059\u3002</p>',\n  },\n  'crm.opportunity_approved': {\n    label: '\u5546\u8AC7\u627F\u8A8D\u6E08\u307F',\n    subject: '\u5546\u8AC7\u304C\u627F\u8A8D\u3055\u308C\u307E\u3057\u305F: {{name}}',\n    bodyHtml: '<p>\u5546\u8AC7 {{name}} \u304C\u627F\u8A8D\u3055\u308C\u307E\u3057\u305F\u3002</p>',\n  },\n  'crm.opportunity_rejected': {\n    label: '\u5546\u8AC7\u672A\u627F\u8A8D',\n    subject: '\u5546\u8AC7\u304C\u627F\u8A8D\u3055\u308C\u307E\u305B\u3093\u3067\u3057\u305F: {{name}}',\n    bodyHtml: '<p>\u5546\u8AC7 {{name}} \u306F\u627F\u8A8D\u3055\u308C\u307E\u305B\u3093\u3067\u3057\u305F\u3002\u5185\u5BB9\u3092\u78BA\u8A8D\u30FB\u4FEE\u6B63\u306E\u3046\u3048\u3001\u518D\u7533\u8ACB\u3057\u3066\u304F\u3060\u3055\u3044\u3002</p>',\n  },\n  'crm.task_reminder': {\n    label: 'ToDo \u30EA\u30DE\u30A4\u30F3\u30C0\u30FC',\n    subject: 'ToDo \u306E\u30EA\u30DE\u30A4\u30F3\u30C0\u30FC: {{subject}}',\n    bodyHtml: '<p>ToDo\u300C{{subject}}\u300D\u304C\u671F\u9650\u3092\u8FCE\u3048\u307E\u3057\u305F\uFF08\u30EA\u30DE\u30A4\u30F3\u30C0\u30FC\u8A2D\u5B9A: {{reminder_date}}\uFF09\u3002</p>',\n  },\n  'crm.urgent_task': {\n    label: '\u7DCA\u6025 ToDo',\n    subject: '\u7DCA\u6025\u306E ToDo: {{subject}}',\n    bodyHtml: '<p>\u7DCA\u6025\u306E ToDo\u300C{{subject}}\u300D\u304C\u5272\u308A\u5F53\u3066\u3089\u308C\u307E\u3057\u305F\u3002\u5BFE\u5FDC\u3092\u304A\u9858\u3044\u3057\u307E\u3059\u3002</p>',\n  },\n};\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/sales/email-templates/es-ES.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/sales/email-templates\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/sales/email-templates/es-ES.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport type { EmailTemplatePack } from './_bundle';\n\n/** Espa\u00F1ol (es-ES) \u2014 the sales package's notification templates. See `en.ts`. */\nexport const esES: EmailTemplatePack = {\n  'crm.account_approved': {\n    label: 'Cuenta aprobada',\n    subject: 'Cuenta aprobada: {{name}}',\n    bodyHtml: '<p>Esta cuenta ha sido aprobada y ya es un dato consolidado.</p>',\n  },\n  'crm.account_rejected': {\n    label: 'Cuenta no aprobada',\n    subject: 'Cuenta no aprobada: {{name}}',\n    bodyHtml: '<p>Esta cuenta no fue aprobada. Corrige sus datos y solicita otra revisi\u00F3n.</p>',\n  },\n  'crm.contact_welcome': {\n    label: 'Nuevo contacto',\n    subject: 'Nuevo contacto: {{first_name}} {{last_name}}',\n    bodyHtml: '<p>{{first_name}} {{last_name}} se ha a\u00F1adido como contacto. Ponte en contacto para darle la bienvenida.</p>',\n  },\n  'crm.deal_stalled': {\n    label: 'Oportunidad estancada',\n    subject: 'Oportunidad estancada: {{name}}',\n    bodyHtml: '<p>La oportunidad {{name}} lleva {{days_in_stage}} d\u00EDas en {{stage}}. Es hora de avanzarla o volver a cualificarla.</p>',\n  },\n  'crm.large_deal_won': {\n    label: 'Gran operaci\u00F3n ganada',\n    subject: 'Gran operaci\u00F3n ganada: {{name}}',\n    bodyHtml: '<p>{{name}} se cerr\u00F3 por {{amount}}. Enhorabuena al equipo.</p>',\n  },\n  'crm.lead_conversion_approved': {\n    label: 'Cliente potencial aprobado para conversi\u00F3n',\n    subject: 'Cliente potencial aprobado para conversi\u00F3n: {{first_name}} {{last_name}}',\n    bodyHtml: '<p>Este cliente potencial ha sido aprobado. Puedes convertirlo en cuenta, contacto y oportunidad.</p>',\n  },\n  'crm.lead_conversion_rejected': {\n    label: 'Cliente potencial no aprobado',\n    subject: 'Cliente potencial no aprobado: {{first_name}} {{last_name}}',\n    bodyHtml: '<p>La conversi\u00F3n de este cliente potencial no fue aprobada. Sigue trabaj\u00E1ndolo o descalif\u00EDcalo indicando un motivo.</p>',\n  },\n  'crm.lead_converted': {\n    label: 'Cliente potencial convertido',\n    subject: 'Cliente potencial convertido: {{first_name}} {{last_name}}',\n    bodyHtml: '<p>El cliente potencial {{first_name}} {{last_name}} se convirti\u00F3 en cuenta y contacto.</p>',\n  },\n  'crm.lead_routing_hot': {\n    label: 'Asignaci\u00F3n de cliente potencial caliente',\n    subject: 'Cliente potencial caliente \u2014 asignar en 24 h: {{first_name}} {{last_name}}',\n    bodyHtml: '<p>{{first_name}} {{last_name}} de {{company}} (puntuaci\u00F3n {{rating}}) necesita propietario hoy.</p>',\n  },\n  'crm.lead_routing_new': {\n    label: 'Asignaci\u00F3n de cliente potencial',\n    subject: 'Nuevo cliente potencial por asignar: {{first_name}} {{last_name}}',\n    bodyHtml: '<p>{{first_name}} {{last_name}} de {{company}} est\u00E1 pendiente de asignaci\u00F3n.</p>',\n  },\n  'crm.opportunity_approved': {\n    label: 'Oportunidad aprobada',\n    subject: 'Oportunidad aprobada: {{name}}',\n    bodyHtml: '<p>Tu oportunidad {{name}} ha sido aprobada.</p>',\n  },\n  'crm.opportunity_rejected': {\n    label: 'Oportunidad rechazada',\n    subject: 'Oportunidad rechazada: {{name}}',\n    bodyHtml: '<p>Tu oportunidad {{name}} no fue aprobada. Rev\u00EDsala y corr\u00EDgela antes de volver a enviarla.</p>',\n  },\n  'crm.task_reminder': {\n    label: 'Recordatorio de tarea',\n    subject: 'Recordatorio de tarea: {{subject}}',\n    bodyHtml: '<p>Tu tarea \"{{subject}}\" vence (recordatorio fijado para {{reminder_date}}).</p>',\n  },\n  'crm.urgent_task': {\n    label: 'Tarea urgente',\n    subject: 'Tarea urgente: {{subject}}',\n    bodyHtml: '<p>Se te ha asignado una tarea urgente \"{{subject}}\" que requiere atenci\u00F3n.</p>',\n  },\n};\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/sales/email-templates/crm.email-template.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/sales/email-templates\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/sales/email-templates/crm.email-template.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport type { EmailTemplateDefinition } from '@objectstack/spec/system';\nimport { bundle } from './_bundle';\nimport { en } from './en';\nimport { zhCN } from './zh-CN';\nimport { jaJP } from './ja-JP';\nimport { esES } from './es-ES';\n\n/**\n * Sales \u2014 every `sys_email_template` row this package's `notify` nodes name.\n *\n * Four locale packs crossed with fourteen template names: the rows a\n * recipient's own `sys_user.locale` is resolved against, per recipient, after\n * fan-out. Assembled here the way `translations/crm.translation.ts` assembles\n * the UI locale packs \u2014 one file per language, one file that collects them.\n */\nexport const SalesEmailTemplates: EmailTemplateDefinition[] = bundle({\n  'en-US': en,\n  'zh-CN': zhCN,\n  'ja-JP': jaJP,\n  'es-ES': esES,\n});\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/revenue/email-templates/index.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/revenue/email-templates\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/revenue/email-templates/index.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\n/** Revenue email-template barrel. */\nexport { RevenueEmailTemplates } from './crm.email-template';\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/revenue/email-templates/en.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/revenue/email-templates\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/revenue/email-templates/en.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport type { EmailTemplatePack } from '../../sales/email-templates/_bundle';\n\n/**\n * English (en-US) \u2014 the revenue package's notification templates.\n *\n * Every string is the text its `notify` node already sent, with the flow's\n * `{var.path}` interpolations re-expressed as the `{{key}}` holes the renderer\n * fills from that node's `templateData`. \u26A0\uFE0F Tagged `en-US`, not `en` \u2014 see the\n * resolution-ladder note on `bundle()`.\n */\nexport const en: EmailTemplatePack = {\n  'crm.contract_expired': {\n    label: 'Contract Expired',\n    subject: 'Contract expired: {{contract_number}}',\n    bodyHtml: '<p>Contract {{contract_number}} reached its end date and has been marked expired.</p>',\n  },\n  'crm.contract_renewal': {\n    label: 'Contract Renewal Due',\n    subject: 'Contract renewal due: {{contract_number}}',\n    bodyHtml: '<p>Contract {{contract_number}} ends on {{end_date}}. Start the renewal conversation now.</p>',\n  },\n  'crm.quote_created': {\n    label: 'Quote Created',\n    subject: 'Quote created: {{quote_name}}',\n    bodyHtml: '<p>Your quote {{quote_name}} has been created from this opportunity.</p>',\n  },\n};\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/revenue/email-templates/zh-CN.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/revenue/email-templates\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/revenue/email-templates/zh-CN.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport type { EmailTemplatePack } from '../../sales/email-templates/_bundle';\n\n/** \u7B80\u4F53\u4E2D\u6587 (zh-CN) \u2014 the revenue package's notification templates. See `en.ts`. */\nexport const zhCN: EmailTemplatePack = {\n  'crm.contract_expired': {\n    label: '\u5408\u540C\u5DF2\u5230\u671F',\n    subject: '\u5408\u540C\u5DF2\u5230\u671F\uFF1A{{contract_number}}',\n    bodyHtml: '<p>\u5408\u540C {{contract_number}} \u5DF2\u5230\u8FBE\u7ED3\u675F\u65E5\u671F\uFF0C\u5E76\u5DF2\u6807\u8BB0\u4E3A\u5230\u671F\u3002</p>',\n  },\n  'crm.contract_renewal': {\n    label: '\u5408\u540C\u7EED\u7EA6\u63D0\u9192',\n    subject: '\u5408\u540C\u5F85\u7EED\u7EA6\uFF1A{{contract_number}}',\n    bodyHtml: '<p>\u5408\u540C {{contract_number}} \u5C06\u4E8E {{end_date}} \u7ED3\u675F\u3002\u8BF7\u7ACB\u5373\u542F\u52A8\u7EED\u7EA6\u6C9F\u901A\u3002</p>',\n  },\n  'crm.quote_created': {\n    label: '\u62A5\u4EF7\u5355\u5DF2\u521B\u5EFA',\n    subject: '\u62A5\u4EF7\u5355\u5DF2\u521B\u5EFA\uFF1A{{quote_name}}',\n    bodyHtml: '<p>\u60A8\u7684\u62A5\u4EF7\u5355 {{quote_name}} \u5DF2\u4ECE\u8BE5\u5546\u673A\u521B\u5EFA\u3002</p>',\n  },\n};\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/revenue/email-templates/ja-JP.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/revenue/email-templates\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/revenue/email-templates/ja-JP.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport type { EmailTemplatePack } from '../../sales/email-templates/_bundle';\n\n/** \u65E5\u672C\u8A9E (ja-JP) \u2014 the revenue package's notification templates. See `en.ts`. */\nexport const jaJP: EmailTemplatePack = {\n  'crm.contract_expired': {\n    label: '\u5951\u7D04\u306E\u6E80\u4E86',\n    subject: '\u5951\u7D04\u304C\u6E80\u4E86\u3057\u307E\u3057\u305F: {{contract_number}}',\n    bodyHtml: '<p>\u5951\u7D04 {{contract_number}} \u306F\u7D42\u4E86\u65E5\u306B\u9054\u3057\u3001\u6E80\u4E86\u3068\u3057\u3066\u8A18\u9332\u3055\u308C\u307E\u3057\u305F\u3002</p>',\n  },\n  'crm.contract_renewal': {\n    label: '\u5951\u7D04\u66F4\u65B0\u306E\u6642\u671F',\n    subject: '\u5951\u7D04\u306E\u66F4\u65B0\u6642\u671F\u3067\u3059: {{contract_number}}',\n    bodyHtml: '<p>\u5951\u7D04 {{contract_number}} \u306F {{end_date}} \u306B\u7D42\u4E86\u3057\u307E\u3059\u3002\u66F4\u65B0\u306E\u76F8\u8AC7\u3092\u59CB\u3081\u3066\u304F\u3060\u3055\u3044\u3002</p>',\n  },\n  'crm.quote_created': {\n    label: '\u898B\u7A4D\u306E\u4F5C\u6210',\n    subject: '\u898B\u7A4D\u3092\u4F5C\u6210\u3057\u307E\u3057\u305F: {{quote_name}}',\n    bodyHtml: '<p>\u3053\u306E\u5546\u8AC7\u304B\u3089\u898B\u7A4D {{quote_name}} \u304C\u4F5C\u6210\u3055\u308C\u307E\u3057\u305F\u3002</p>',\n  },\n};\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/revenue/email-templates/es-ES.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/revenue/email-templates\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/revenue/email-templates/es-ES.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport type { EmailTemplatePack } from '../../sales/email-templates/_bundle';\n\n/** Espa\u00F1ol (es-ES) \u2014 the revenue package's notification templates. See `en.ts`. */\nexport const esES: EmailTemplatePack = {\n  'crm.contract_expired': {\n    label: 'Contrato vencido',\n    subject: 'Contrato vencido: {{contract_number}}',\n    bodyHtml: '<p>El contrato {{contract_number}} alcanz\u00F3 su fecha de fin y se ha marcado como vencido.</p>',\n  },\n  'crm.contract_renewal': {\n    label: 'Renovaci\u00F3n de contrato pendiente',\n    subject: 'Renovaci\u00F3n de contrato pendiente: {{contract_number}}',\n    bodyHtml: '<p>El contrato {{contract_number}} finaliza el {{end_date}}. Inicia ya la conversaci\u00F3n de renovaci\u00F3n.</p>',\n  },\n  'crm.quote_created': {\n    label: 'Presupuesto creado',\n    subject: 'Presupuesto creado: {{quote_name}}',\n    bodyHtml: '<p>Tu presupuesto {{quote_name}} se ha creado a partir de esta oportunidad.</p>',\n  },\n};\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/revenue/email-templates/crm.email-template.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/revenue/email-templates\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/revenue/email-templates/crm.email-template.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport type { EmailTemplateDefinition } from '@objectstack/spec/system';\nimport { bundle } from '../../sales/email-templates/_bundle';\nimport { en } from './en';\nimport { zhCN } from './zh-CN';\nimport { jaJP } from './ja-JP';\nimport { esES } from './es-ES';\n\n/**\n * Revenue \u2014 every `sys_email_template` row this package's `notify` nodes name.\n *\n * Four locale packs crossed with three template names. `bundle()` is imported\n * along this module's edge into sales, the one deterministic home for a source\n * more than one package needs.\n */\nexport const RevenueEmailTemplates: EmailTemplateDefinition[] = bundle({\n  'en-US': en,\n  'zh-CN': zhCN,\n  'ja-JP': jaJP,\n  'es-ES': esES,\n});\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/sales/profiles/tenant-admin.profile.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/sales/profiles\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/sales/profiles/tenant-admin.profile.ts\";// Copyright (c) 2026 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport { SystemAdminProfile } from './system-admin.profile';\n\n/**\n * Tenant Administrator \u2014 the admin persona of the SaaS / multi-org composition\n * (#1361). Registered ONLY by that composition; the community app ships\n * `system_admin` exactly as it always has and this file is not in its artifact.\n *\n * ### Why a second admin set instead of narrowing the first\n *\n * The two admins are different people. `system_admin` is the operator of a\n * single-org install: the one who owns the deployment. A tenant admin owns an\n * ORGANIZATION inside somebody else's deployment, and under an `isolated`\n * posture every other organization in that database is none of their business.\n * A profile is a description of a persona, so where the persona differs the\n * profile does \u2014 narrowing `system_admin` in place would have changed the\n * community app's meaning to describe a customer it does not have.\n *\n * ### The OBJECT grants are shared, on purpose and by reference\n *\n * A tenant admin administers their own org's records with exactly the authority\n * `system_admin` has over a single-org install's records \u2014 same objects, same\n * CRUD, same all-records depth, same transfer and export bits. So the map is\n * DERIVED from `SystemAdminProfile.objects` rather than transcribed.\n *\n * That is the load-bearing half. Permission sets are explicit-allow only, so an\n * object missing from the map is permission-denied for tenant admins too, and a\n * transcribed copy would drift the first time an object shipped \u2014 the exact\n * defect `test/authorization-coverage.test.ts` exists to catch on the community\n * set (#488: objects that shipped with navigation, views, hooks and seeds but a\n * grant in no set at all). Deriving means a new object lands in both admins the\n * day it lands in one, with nothing to remember.\n *\n * ### What changes: `manage_users` \u2192 `manage_org_users`\n *\n * `manage_users` is `scope: 'platform'` in the platform's own capability\n * registry \u2014 \"Create, edit, and deactivate users across the platform\". Handing\n * that to a tenant is handing them every other tenant's people. Its org-scoped\n * sibling, `manage_org_users` (\"Manage members within the caller's\n * organization\"), is the member-management authority a tenant admin should hold,\n * and it is declared in the released `@objectstack/spec` 17.1.0 this app depends\n * on (verified against the installed `PLATFORM_CAPABILITIES`, not against a\n * newer platform checkout \u2014 an app on a released line cannot grant a capability\n * that line has not shipped).\n *\n * Both are DECLARATIONS here, not enforcement: measured against the installed\n * 17.1.0 packages, `manage_users` appears in a single comment and nothing reads\n * either name \u2014 the member-management door is the enterprise organizations\n * runtime's, and it is the edition that supplies the gate. That is the shape the\n * maintainer's 2026-08-11 ruling asks for and the app package's `requires`\n * (`src/sales/index.ts`) already follows for `hierarchy-security`: \u300C\u672C\u9879\u76EE\u662F\u5143\u6570\u636Eapp\uFF0C\u5728\u4F01\u4E1A\u7248\u8FD0\u884C\u5C31\u5177\u5907\u4F01\u4E1A\u7248\n * \u76F8\u5173\u7684\u80FD\u529B\uFF0C\u4E0D\u91CD\u590D\u5F00\u53D1\u3002\u300D The app states what it MEANS; the edition enforces.\n *\n * ### What `view_all_data` / `modify_all_data` mean under the wall \u2014 the audit\n *\n * They are KEPT, and they are bounded by the organization, not by them.\n *\n * Two measurements, both against the 17.1.0 line \u2014 the version\n * installed AT THE TIME they were taken, not the current pin (neither was\n * re-taken on 17.3.0, 17.4.0 or 17.5.0).\n *\n * \u26A0\uFE0F The zero-occurrence result in 1 \u2014 the load-bearing half \u2014 reproduced on\n * 17.2.0 and has not been re-run since (#1676). The three CONTROL counts in\n * it do NOT reproduce: they are\n * as-measured-then figures and have since moved. They are kept at their\n * measured values on purpose rather than refreshed, because what they are\n * evidence FOR is that the sweep can find a name it looks for \u2014 never a\n * current total. \u26D4 Do not cite them as one, and \u26D4 do not \"fix\" them by\n * pasting today's numbers over a 17.1.0 measurement.\n *\n *  1. **Neither string is read by anything.** `view_all_data` and\n *     `modify_all_data` occur in ZERO installed `@objectstack/*` JavaScript\n *     files (control probes in the same sweep: `manage_sharing` 15 files,\n *     `manage_metadata` 25, `setup.access` 32 \u2014 so the sweep can find a name it\n *     is looking for). They are app-declared vocabulary. The authority that is\n *     really enforced is the PER-OBJECT `viewAllRecords` / `modifyAllRecords`\n *     bits in the map above, which the sharing layer reads on every request.\n *  2. **The organization predicate is not part of that layer.** A tenant-scoped\n *     read is compiled by the DRIVER from the execution context's tenant id,\n *     underneath permissions and sharing entirely. Measured on a real engine: a\n *     caller in `org_a` reading `crm_account` sees 1 of the 2 rows in the table\n *     \u2014 and still sees 1 of 2 with the tenancy posture flipped to `single`,\n *     which is what shows the boundary belongs to the driver and the context\n *     rather than to a deployment knob a profile might hope to out-rank.\n *\n * So \"all data\" answers a question about DEPTH inside one organization \u2014 all\n * rows regardless of owner \u2014 and no permission-set bit can widen it past the\n * wall, because the wall is not applied by the permission set. The one context\n * that does cross it is a system context (`isSystem`), which no profile grants\n * and no session produces. Keeping the two grants therefore says the true\n * thing about a tenant admin: inside their org, they see and edit everything.\n *\n * ### What a tenant admin may AUTHOR: nothing, since 18.0.0-next.0\n *\n * Through 17.7.0 this set held `manage_org_presentation`, the platform's\n * `scope: 'org'` capability (objectstack-ai/objectstack#12702) that admitted\n * `/meta` writes of the `allowOrgOverride: true` types \u2014 view, dashboard,\n * report, translation, email_template \u2014 as overlays in the caller's own\n * organization. 18.0.0-next.0 RETIRES it with the per-organization overlay\n * axis (ADR-0131 D6, the spec's `manage-org-presentation-retired` entry): it is\n * no longer in `PLATFORM_CAPABILITIES`, nothing consults it, and the entry's\n * remedy is to delete it from every set. There is no organization-bounded\n * authoring capability left; the only key that admits those writes is\n * `manage_metadata`, whose writes land environment-wide, so it stays\n * ungranted for the reason below.\n *\n * `customize_application`, `manage_profiles` and `manage_roles` stay\n * ungranted. They describe authoring the app's structure and security model \u2014\n * objects, apps, pages, permission sets, positions \u2014 and the registry declares\n * every one of those types `allowOrgOverride: false`, so the only key that\n * admits those writes is still `manage_metadata`: `scope: 'platform'`, reach\n * across every organization in the deployment. Granting the three would\n * describe an authority the deployment cannot safely give.\n *\n * `manage_sharing` IS granted: the platform declares it `scope: 'org'`\n * (\"Administer record sharing \u2026 beyond one's own records\"), which is precisely\n * a tenant admin's job over their own org's records.\n *\n * `view_setup` is kept for parity with the community admin \u2014 it is this app's\n * own Setup-entry vocabulary and, like the two above, has no platform consumer\n * on this line. (The platform's own `setup.access` is `scope: 'platform'` and\n * is not granted here for the same reason `manage_users` is not.)\n */\nexport const TenantAdminProfile = {\n  name: 'tenant_admin',\n  label: 'Tenant Administrator',\n  // Derived, never transcribed \u2014 see the note above. Spread rather than\n  // aliased so the two sets are independent values in the built artifact.\n  objects: { ...SystemAdminProfile.objects },\n  systemPermissions: [\n    'view_setup',\n    // The one substitution this profile exists for: org-scoped member\n    // management instead of platform-wide user management.\n    'manage_org_users',\n    // Org-bounded by the driver's tenant predicate \u2014 see the audit above.\n    'view_all_data', 'modify_all_data',\n    'manage_sharing',\n  ],\n};\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/sales/objects/account.hook.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/sales/objects\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/sales/objects/account.hook.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport type { Hook, HookContext } from '@objectstack/spec/data';\nimport type { HookApi } from './_hook-api';\n\n/**\n * Account protection hook.\n *\n * - Validates `website` format and `annual_revenue` non-negative.\n * - Projects `billing_address.country` onto the flat `billing_country` column\n *   (#621) and classifies it into the `territory` select the territory sharing\n *   rules filter on (#639).\n * - Folds `name` into the `name_normalized` column lead conversion matches\n *   accounts on (#626).\n * - Refuses to delete a `customer` account that still has opportunities \u2014\n *   open or closed, the account's sales history (#2019) \u2014 or activated\n *   contracts \u2014 contracts cascade with the account since #549.\n */\nconst accountHook: Hook = {\n  name: 'account_protection',\n  object: 'crm_account',\n  events: ['beforeInsert', 'beforeUpdate', 'beforeDelete'],\n  priority: 200,\n  description:\n    'Validate account fields and protect customer accounts with opportunities or activated contracts from deletion.',\n  handler: async (ctx: HookContext) => {\n    // The refusal envelope (#1075). Mirrored from `./_refusal.ts` because a\n    // lowered body has no module scope and `extractHookBody` THROWS on an\n    // import; `test/refusal-envelope.test.ts` pins every copy against it.\n    function refuse(\n      message: string,\n      code: string,\n      status: number,\n      userMessage: string = message,\n    ): Error {\n      const err = new Error(message) as Error & {\n        code: string;\n        status: number;\n        userMessage: string;\n      };\n      err.code = code;\n      err.status = status;\n      err.userMessage = userMessage;\n      return err;\n    }\n    const { event, input } = ctx;\n\n    if (event === 'beforeInsert' || event === 'beforeUpdate') {\n      if (typeof input.website === 'string' && input.website.length > 0) {\n        if (!/^https?:\\/\\//i.test(input.website)) {\n          throw refuse('Website must start with http:// or https://', 'VALIDATION_FAILED', 400);\n        }\n      }\n      if (typeof input.annual_revenue === 'number' && input.annual_revenue < 0) {\n        throw refuse('Annual Revenue must be greater than or equal to 0', 'VALIDATION_FAILED', 400);\n      }\n\n      // \u2500\u2500\u2500 Territory (#621 storage location, #639 classification) \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n      //\n      // Two derived columns, one input. `billing_country` is the flat\n      // projection of `billing_address.country`; `territory` is the CLASSIFIED\n      // value the two territory sharing rules now filter on. This block is the\n      // only writer of both.\n      //\n      // `billing_country` became a flat column because a sharing rule's CEL\n      // condition is compiled into a pushdown-able query filter, and that\n      // compiler rejects any path reaching INSIDE a composite `address` value\n      // \u2014 `record.billing_address.country in [...]` is not translatable, so\n      // plugin-sharing dropped both rules on every boot and `na_sales_team` /\n      // `eu_sales_team` got nothing at all (#621).\n      //\n      // That fixed WHERE the country is read from and left WHAT the rules\n      // match on unfixed: a free-text country. `United States` matched no\n      // territory, silently, and the same country lists were restated in two\n      // CEL strings and six documentation files. #639 replaced the matching\n      // with `territory`, a declared select \u2014 see `./_territory.ts` for the\n      // whole argument and for the authored tables this table is derived from.\n      //\n      // \u2500\u2500 Two different recompute rules, on purpose \u2500\u2500\n      //\n      // `billing_country` MIRRORS the address, so it is rewritten only when\n      // the write carries one: a partial update that never mentions\n      // `billing_address` must leave it alone, or every unrelated edit would\n      // blank the column. A write that CLEARS the address\n      // (`billing_address: null`) does clear it \u2014 the key is present, the\n      // value is empty.\n      //\n      // `territory` is a CLASSIFICATION, and #639 decided it is always a\n      // stated fact rather than a blank (\"belongs to no territory\" and \"nobody\n      // filled it in\" must not look alike). So it is also stated on an insert\n      // that carries no address at all, where it is `other`. On an update that\n      // does not mention the address it is left alone, exactly like the\n      // projection \u2014 an unrelated edit must not re-derive it.\n      //\n      // Only `country` is read. `countryCode` is the ISO 3166-1 alpha-2 slot\n      // and would be the better input, but it is optional and mostly empty in\n      // this app's data; reading it in preference would move which slot decides\n      // an account's territory, which #639 did not ask for. `UK` vs `GB` is\n      // handled in the mapping instead (both are `emea`), which is why nothing\n      // had to migrate.\n      //\n      // \u2500\u2500 Why the map is INLINE rather than imported \u2500\u2500\n      //\n      // A hook handler is lowered to a metadata-only `body.source` and\n      // evaluated inside QuickJS with no module scope, so an import is a\n      // `ReferenceError` at runtime, not a closure; `extractHookBody` rejects\n      // such a handler and `test/action-sandbox.test.ts` runs that same\n      // lowering pass over every registered hook. The table therefore cannot be\n      // read from `./_territory.ts` here. It is not trusted to stay in step\n      // either: `test/territory-single-source.test.ts` parses this literal out\n      // of the LOWERED body and asserts deep equality with the module's derived\n      // map, so a country added to either side alone fails.\n      if ('billing_address' in input || event === 'beforeInsert') {\n        const address = input.billing_address;\n        const country =\n          address !== null && typeof address === 'object' && !Array.isArray(address)\n            ? (address as { country?: unknown }).country\n            : undefined;\n        // The one normalisation rule, mirrored from `normalizeCountry`: trim,\n        // collapse internal whitespace, upper-case. Every key below is written\n        // in that form, so the lookup is a plain property read rather than a\n        // pile of tolerant comparisons.\n        const normalized =\n          typeof country === 'string' ? country.trim().replace(/\\s+/g, ' ').toUpperCase() : '';\n\n        if ('billing_address' in input) {\n          input.billing_country = normalized === '' ? null : normalized;\n        }\n\n        // A COPY of the map derived in `./_territory.ts`, kept here because a\n        // sandboxed body cannot import it (see above). Edit `_territory.ts`\n        // and mirror the result here \u2014 `test/territory-single-source.test.ts`\n        // reads this literal back out of the lowered body and fails if the two\n        // disagree, so the mirroring is enforced rather than remembered.\n        const TERRITORY_BY_COUNTRY: Record<string, string> = {\n          \"US\": \"na\", \"CA\": \"na\", \"MX\": \"na\",\n          \"GB\": \"emea\", \"DE\": \"emea\", \"FR\": \"emea\", \"IT\": \"emea\", \"ES\": \"emea\",\n          \"UNITED STATES\": \"na\", \"UNITED STATES OF AMERICA\": \"na\", \"USA\": \"na\",\n          \"CANADA\": \"na\", \"MEXICO\": \"na\",\n          \"UK\": \"emea\", \"UNITED KINGDOM\": \"emea\", \"GREAT BRITAIN\": \"emea\",\n          \"GERMANY\": \"emea\", \"FRANCE\": \"emea\", \"ITALY\": \"emea\", \"SPAIN\": \"emea\"\n        };\n        input.territory = TERRITORY_BY_COUNTRY[normalized] || 'other';\n      }\n\n      // \u2500\u2500\u2500 Account-name match key (#626) \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n      //\n      // `name_normalized` is the column `lead_conversion` matches accounts on,\n      // and this block is its only writer. It exists because the flow that\n      // reads it cannot compute it: `service-automation`'s template resolver\n      // knows one function form (`NOW()` / `TODAY()`), so `{LOWER(x)}`,\n      // `{TRIM(x)}` and `{x.toLowerCase()}` all resolve to `undefined` \u2014 and a\n      // formula field has no physical column to filter on\n      // (`fieldHasColumn(formula) === false`). The canonical form therefore has\n      // to be established HERE, by the producer, exactly as `crm_lead.email`\n      // and `crm_contact.email` are.\n      //\n      // lower + trim + collapse internal whitespace, so \"Acme Corp\",\n      // \"ACME  Corp\" and \" acme corp \" all land on `acme corp`. That is the\n      // whole transform: normalize-then-EXACT. Fuzzy matching is out of scope\n      // (see the field's doc comment on `crm_account`).\n      //\n      // Recompute ONLY when the write carries the name \u2014 a partial update that\n      // never mentions `name` must leave the key alone, or every unrelated edit\n      // would blank it and make the account invisible to conversion. `name` is\n      // required + notNull, so on insert it is always present; the null branch\n      // is for a whitespace-only value the validator would reject anyway.\n      //\n      // Written inline, not as a module-scope helper, for the same reason as\n      // the block above: hook bodies lower to metadata-only (no free\n      // identifiers), which `test/action-sandbox.test.ts` enforces.\n      if ('name' in input) {\n        const rawName = input.name;\n        const normalizedName =\n          typeof rawName === 'string'\n            ? rawName.trim().toLowerCase().replace(/\\s+/g, ' ')\n            : '';\n        input.name_normalized = normalizedName === '' ? null : normalizedName;\n      }\n    }\n\n    // Stamp last_activity_date when ownership or type changes.\n    // USER writes only (`ctx.user?.id` \u2014 this repo's system-write signal, cf.\n    // opportunity/quote hooks): the platform's seed-ownership claim re-owns\n    // ownerless seeded accounts as a system write (the retired `demo_bootstrap`\n    // sweep did the same every 10 minutes), and stamping those flattened every\n    // seeded activity date to \"today\", emptying the churn report buckets.\n    // D3 stand-down on the predicate path (`forecast.hook.ts`): `ownerChanged`\n    // / `typeChanged` are decided against THIS row's `previous`, so the stamp\n    // would spread to every matched row. The `billing_country` / `territory` /\n    // `name_normalized` normalisation above reads only the payload and stays.\n    if (event === 'beforeUpdate' && ctx.user?.id && ctx.dispatch?.mode !== 'per-row') {\n      const prev = ctx.previous ?? {};\n      const ownerChanged = typeof input.owner_id !== 'undefined' && input.owner_id !== prev.owner_id;\n      const typeChanged = typeof input.type !== 'undefined' && input.type !== prev.type;\n      if (ownerChanged || typeChanged) {\n        input.last_activity_date = new Date().toISOString().slice(0, 10);\n      }\n    }\n\n    if (event === 'beforeDelete') {\n      const previous = ctx.previous;\n      if (!previous || previous.type !== 'customer') return;\n      const api = ctx.api as HookApi | undefined;\n      if (!api) return;\n      // EVERY opportunity, closed ones included (#2019). A closed deal is the\n      // account's sales history \u2014 the won and lost amounts its rollups,\n      // forecasts and win rates are read from \u2014 and the app keeps it: the\n      // `crm_opportunity.crm_account` lookup is required and does not cascade,\n      // so the engine refuses the delete while ANY deal names the account, and\n      // `opportunity_lifecycle` freezes a closed deal against being moved to\n      // another account. This guard used to count open deals only and tell the\n      // user to \"Close or reassign it first\"; closing it was answered by the\n      // engine's own refusal all the same. So the count is the engine's, and\n      // the sentence names what frees the account for every deal it counts \u2014\n      // deleting it (an open deal could also be moved; a closed one cannot) \u2014\n      // and the way to retire a customer that keeps its history: the account\n      // goes inactive, as `product_catalog` retires a product with a history.\n      const opportunities = await api.object('crm_opportunity').count({\n        where: { crm_account: previous.id },\n      });\n      if (opportunities > 0) {\n        // Whole sentence per branch, not a stitched-together noun (#721). The\n        // count switched the NOUN only (`opportunit{y,ies}`) while the verb and\n        // the closing pronoun stayed plural, so the singular case read\n        // \"1 open opportunity still reference it. Close or reassign them\n        // first.\" Agreement runs across three words here \u2014 noun, verb and\n        // pronoun \u2014 and the two readable sentences are cheaper to keep correct\n        // (and to grep for) than three interlocking conditionals.\n        throw refuse(\n          opportunities === 1\n            ? 'Cannot delete customer account: 1 opportunity, open or closed, still references it. Delete the opportunity first, or mark the account inactive to retire it instead.'\n            : `Cannot delete customer account: ${opportunities} opportunities, open or closed, still reference it. Delete the opportunities first, or mark the account inactive to retire it instead.`,\n          'DELETE_RESTRICTED',\n          409,\n        );\n      }\n      // `crm_contract` is master-detail under the account (#549), so a delete\n      // would cascade the signed agreements away. Activated = live (the same\n      // definition `contact_integrity` uses); drafts and ended contracts go.\n      const activeContracts = await api.object('crm_contract').count({\n        where: { crm_account: previous.id, status: 'activated' },\n      });\n      if (activeContracts > 0) {\n        throw refuse(\n          activeContracts === 1\n            ? 'Cannot delete customer account: 1 activated contract still references it. Terminate or reassign it first.'\n            : `Cannot delete customer account: ${activeContracts} activated contracts still reference it. Terminate or reassign them first.`,\n          'DELETE_RESTRICTED',\n          409,\n        );\n      }\n    }\n  },\n};\n\nexport default accountHook;\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/sales/objects/contact.hook.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/sales/objects\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/sales/objects/contact.hook.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport type { Hook, HookContext } from '@objectstack/spec/data';\nimport type { HookApi } from './_hook-api';\n\n/**\n * Contact integrity hook.\n *\n * - On insert/update, dedupes by `email` WITHIN THE ORGANIZATION \u2014 matching\n *   the constraint the schema actually declares. `crm_contact.email` carries\n *   field-level `unique: true`, which materializes as the tenant composite\n *   `(organization_id, email)` (framework#3696), so the address is unique\n *   across every account of one organization and two organizations may each\n *   know the same person. The lookup is deliberately NOT account-scoped (the\n *   old per-account lookup let a cross-account duplicate sail past the\n *   friendly check and explode on the DB index instead, mid-conversion) \u2014 but\n *   it must not reach ACROSS organizations either.\n *\n *   ## What an unscoped lookup cost, as measured\n *\n *   `ctx.api` reads are not organization-scoped for every caller: the seed\n *   loader replays a dataset per organization as a SYSTEM write, and an\n *   unscoped `findOne({ where: { email } })` from inside that replay meets the\n *   FIRST organization's contacts. On the deployment shape where many\n *   organizations share one database, the second organization's replay was\n *   refused row by row \u2014 `Another contact (\u2026) with email\n *   john.smith@acme.example.com already exists.` \u2014 landing 0 of 9 contacts\n *   and, because `crm_contract` requires one, 0 of 4 contracts, plus\n *   half-populated quotes, quote line items, campaign members and event\n *   attendees. Nothing leaked; the tenant wall held. The data never arrived.\n *\n *   The organization is therefore resolved before the lookup, in the blessed\n *   order: the acting user's active organization first (`user.organizationId`\n *   === `session.organizationId` === the `organization_id` column === RLS's\n *   `current_user.organizationId`), then the row's own stamp, which is what a\n *   system write carries when no session does. Resolved: scope the lookup.\n *   Unresolvable on a system write: skip the friendly guard and let the\n *   `(organization_id, email)` index enforce. Unresolvable for a USER write:\n *   an untenanted (community) install, where the old global lookup is right.\n * - On delete, refuses if the contact is referenced by an active opportunity,\n *   open quote or active contract.\n *\n * \u26D4 No email/phone propagation to opportunities: `crm_opportunity` has no\n * `contact_email` / `contact_phone` columns, and a rollup writing nonexistent\n * fields is silently swallowed. Opportunities reach the live values through\n * their `primary_contact` lookup.\n */\n\nconst contactHook: Hook = {\n  name: 'contact_integrity',\n  object: 'crm_contact',\n  events: ['beforeInsert', 'beforeUpdate', 'beforeDelete'],\n  priority: 200,\n  description:\n    'Dedupe contacts by email and protect referenced contacts from deletion.',\n  handler: async (ctx: HookContext) => {\n    // The refusal envelope (#1075). Mirrored from `./_refusal.ts` because a\n    // lowered body has no module scope and `extractHookBody` THROWS on an\n    // import; `test/refusal-envelope.test.ts` pins every copy against it.\n    function refuse(\n      message: string,\n      code: string,\n      status: number,\n      userMessage: string = message,\n    ): Error {\n      const err = new Error(message) as Error & {\n        code: string;\n        status: number;\n        userMessage: string;\n      };\n      err.code = code;\n      err.status = status;\n      err.userMessage = userMessage;\n      return err;\n    }\n    const { event, input } = ctx;\n    const api = ctx.api as HookApi | undefined;\n\n    if ((event === 'beforeInsert' || event === 'beforeUpdate') && api) {\n      const email = typeof input.email === 'string' ? input.email.toLowerCase() : '';\n      if (email) {\n        input.email = email;\n        // Scope the guard to the organization the write belongs to, so it is\n        // exactly as strict as the `(organization_id, email)` index it fires\n        // ahead of \u2014 no stricter. An unresolvable organization on a SYSTEM\n        // write (no `ctx.user`) means the caller is the seed loader or a\n        // backfill: skip the friendly guard rather than run it unscoped, and\n        // let the database constraint be the enforcement. Running it unscoped\n        // there is what starved every organization after the first of its\n        // contacts.\n        const organizationId = [\n          ctx.user?.organizationId,\n          ctx.session?.organizationId,\n          input.organization_id,\n          ctx.previous?.organization_id,\n        ].find((candidate): candidate is string => typeof candidate === 'string' && candidate !== '');\n        if (organizationId || ctx.user?.id) {\n          const dup = await api.object('crm_contact').findOne({\n            where: organizationId ? { organization_id: organizationId, email } : { email },\n          });\n          const dupRow = dup as\n            | { id?: string; first_name?: unknown; last_name?: unknown }\n            | null;\n          const dupId = dupRow?.id;\n          const selfId = ctx.previous?.id ?? input.id;\n          if (dup && dupId !== selfId) {\n            // Name the colliding contact, not its primary key (#1243, the same\n            // class #1208 closed on the escalation task). This refusal is read\n            // by a rep in a dialog at the moment their save is blocked, and the\n            // one actionable thing it can say is WHOSE record already holds the\n            // address. The id was the opposite of that: a 16-character string\n            // that appears on no screen in this app and cannot be pasted into\n            // search. `full_name` is `crm_contact.nameField`, and it is composed\n            // from the same two stored columns here \u2014 a lowered hook body cannot\n            // read a formula field. No second read pays for it: the `findOne`\n            // above carries no projection, so the whole row is already in hand.\n            const dupName = [dupRow?.first_name, dupRow?.last_name]\n              .filter((part) => typeof part === 'string' && part.trim() !== '')\n              .join(' ');\n            throw refuse(\n              dupName\n                ? `Another contact (${dupName}) with email ${email} already exists.`\n                : `Another contact with email ${email} already exists.`,\n              'DUPLICATE_VALUE',\n              409,\n            );\n          }\n        }\n      }\n    }\n\n    if (event === 'beforeDelete' && api) {\n      const id = ctx.previous?.id;\n      if (!id) return;\n      const [openOpps, openQuotes, activeContracts] = await Promise.all([\n        api.object('crm_opportunity').count({\n          where: { primary_contact: id, stage: { $nin: ['closed_won', 'closed_lost'] } },\n        }),\n        api.object('crm_quote').count({\n          where: { crm_contact: id, status: { $nin: ['rejected', 'expired'] } },\n        }),\n        api.object('crm_contract').count({\n          where: { crm_contact: id, status: 'activated' },\n        }),\n      ]);\n      const total = openOpps + openQuotes + activeContracts;\n      if (total > 0) {\n        // Phrase the refusal as the BLOCKING RELATIONSHIP, not as the caller's\n        // operation (#693). This hook fires on a direct\n        // `DELETE /crm_contact/<id>` AND as a cascade child of\n        // `DELETE /crm_account/<id>` (`crm_contact.crm_account` is a\n        // master-detail with `deleteBehavior: 'cascade'`), and the hook context\n        // carries nothing that distinguishes the two \u2014 measured on 17.0.0-rc.2,\n        // a cascaded `beforeDelete` ctx holds exactly\n        // {api,event,input,object,previous,provenance,ql,session,transaction,user}\n        // with no cascade marker. So \"Cannot delete contact\" told an account\n        // deleter that they had asked to delete a contact, and sent them\n        // looking for the wrong record. Naming the contact and both\n        // consequences is true in either context.\n        const name = [ctx.previous?.first_name, ctx.previous?.last_name]\n          .filter((part) => typeof part === 'string' && part.trim() !== '')\n          .join(' ');\n        // Named, never keyed (#1243). `id` still does the work it is good at \u2014\n        // it is what the three counts above were queried by \u2014 but the sentence\n        // the user reads names the contact the way `nameField` does. A contact\n        // with no name at all is referred to, not identified: a bare id told\n        // the reader nothing they could look up either.\n        const subject = name ? `Contact ${name}` : 'This contact';\n        // What frees the contact is not the same for the three (#2019). An\n        // opportunity's `primary_contact` and a quote's `crm_contact` are\n        // optional, so once the deal or quote is settled the engine clears the\n        // link and the delete lands. A contract's `crm_contact` is REQUIRED: a\n        // contract keeps its primary contact for its whole life, ended or not\n        // \u2014 it is the account's signed record and is kept, so the engine\n        // refuses the delete while ANY contract names the contact. The old\n        // closing \"Close or reassign those records first\" sent the user to\n        // terminate the contract, after which the engine refused all the same.\n        // So the sentence says what frees the contact from a contract: another\n        // primary contact on it.\n        //\n        // \u26D4 The COUNT stays `activated`, and that is deliberate. This guard also\n        // runs inside an account delete (the cascade above) and cannot tell the\n        // two apart, and an account delete takes its draft and ended contracts\n        // with it (#549, `account_protection`). Counting those here would make\n        // this guard refuse that account delete itself \u2014 today the engine\n        // already refuses it on the cascade's order (objectstack#22305, pinned\n        // in `test/hooks-runtime-sales.test.ts`), and that is the platform's to\n        // fix. An ended contract on a DIRECT contact delete is refused by the\n        // engine, in its own words naming the contract.\n        throw refuse(\n          `${subject} is still referenced by ${openOpps} open opportunity(ies), ${openQuotes} active quote(s), ${activeContracts} active contract(s), so it cannot be deleted \u2014 and neither can its account, because deleting an account deletes its contacts. Close or reassign the opportunities and quotes first, and give each contract another primary contact: a contract keeps its primary contact even after it ends.`,\n          'DELETE_RESTRICTED',\n          409,\n        );\n      }\n    }\n  },\n};\n\nexport default contactHook;\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/sales/objects/event.hook.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/sales/objects\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/sales/objects/event.hook.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport type { Hook, HookContext } from '@objectstack/spec/data';\nimport type { HookApi } from './_hook-api';\n\n/**\n * Event lifecycle hooks (#592).\n *\n * - `event_schedule_derive` keeps `start_datetime` / `end_datetime` /\n *   `duration_minutes` mutually consistent, so a calendar view and a duration\n *   report cannot disagree about the same row.\n * - `event_activity_bubble` is the app's PRIMARY writer of interaction\n *   recency: a `held` event stamps `crm_account.last_activity_date`,\n *   `crm_lead.last_contacted_date` and `crm_contact.last_contacted_date`,\n *   walking UP from an opportunity / case / contact to the account it hangs\n *   off. Since #595 it is also the SINGLE writer of\n *   `crm_case.first_response_date` (see the block at the end of the handler).\n *\n * # Why the walk-up matters\n *\n * `at_risk_accounts` and `customer_churn_signals` are built on\n * `crm_account.last_activity_date`, but a rep logs a call on the OPPORTUNITY or\n * the CONTACT \u2014 almost never on the account row itself. \u26D4 Bubbling only to the\n * directly-named record leaves the account clock untouched through an entire\n * sales cycle, and the churn report then counts a busy customer as silent. The\n * walk-up is the whole reason the signal becomes real.\n */\n\nconst eventScheduleDerive: Hook = {\n  name: 'event_schedule_derive',\n  object: 'crm_event',\n  events: ['beforeInsert', 'beforeUpdate'],\n  priority: 200,\n  description:\n    'Keep start/end/duration coherent: derive whichever of end_datetime or duration_minutes was not supplied.',\n  handler: async (ctx: HookContext) => {\n    // D3 stand-down: a predicate update has ONE payload for every matched row,\n    // so the `ctx.previous`-conditioned writes below would land on rows that\n    // did not earn them \u2014 refused as a diverging key set, or stored silently\n    // from the last row. Full account and the measurement: `forecast.hook.ts`.\n    if (ctx.event === 'beforeUpdate' && ctx.dispatch?.mode === 'per-row') return;\n\n    const { input } = ctx;\n    const previous = ctx.previous;\n\n    const effective = (key: string): unknown =>\n      input[key] !== undefined && input[key] !== null ? input[key] : previous?.[key];\n\n    const start = effective('start_datetime');\n    const end = effective('end_datetime');\n    const durationRaw = effective('duration_minutes');\n\n    const startMs = typeof start === 'string' || start instanceof Date ? new Date(start as string).getTime() : NaN;\n    const endMs = typeof end === 'string' || end instanceof Date ? new Date(end as string).getTime() : NaN;\n    const duration = typeof durationRaw === 'number' && isFinite(durationRaw) ? durationRaw : NaN;\n\n    // An all-day event has no meaningful minute count; leave duration alone so\n    // a report can tell \"all day\" apart from \"we forgot to fill it in\".\n    const allDay = effective('all_day') === true;\n\n    if (!isNaN(startMs) && !isNaN(endMs)) {\n      // Both ends known \u2014 the duration is a MEASUREMENT, so it is recomputed\n      // even when the caller supplied one. A stored duration that disagrees\n      // with its own timestamps is the kind of metadata a report quietly\n      // averages into nonsense.\n      if (!allDay) input.duration_minutes = Math.max(0, Math.round((endMs - startMs) / 60000));\n    } else if (!isNaN(startMs) && isNaN(endMs) && !isNaN(duration) && duration > 0) {\n      // Duration-only, the shape `log_call` submits (\"a 20-minute call, now\").\n      // Materialising the end timestamp is what puts the row on a calendar.\n      input.end_datetime = new Date(startMs + duration * 60000).toISOString();\n    }\n\n    // A cancelled or no-show meeting occupies no one's time. Zeroing it keeps\n    // \"meeting minutes this week\" honest without deleting the row, which is\n    // still evidence that the interaction was attempted.\n    const status = effective('status');\n    if (status === 'cancelled' || status === 'no_show') input.duration_minutes = 0;\n  },\n};\n\n/**\n * The activity bubble \u2014 the canonical copy (`task_activity_bubble` carries a\n * verbatim twin).\n *\n * ## `runAs: 'system'` (#2014, AGENTS.md rule 9)\n *\n * The clocks it stamps belong to the records the interaction was WITH \u2014 the\n * account, contact and lead \u2014 and to the case it answered, not to the person\n * who logged it. As the caller, every one of those writes (and the walk-up\n * reads) met the caller's grants: a service agent holds no edit right on\n * accounts, and a rep need not own the account or contact their own deal hangs\n * off. Each refusal was swallowed best-effort, so the clocks never moved\n * (measured on 17.7.0: a service agent's held call on their own case left the\n * case account's `last_activity_date` empty while an admin's identical call\n * stamped it; the task twin the same, and a rep's completed task on their own\n * deal reached neither the account nor the contact a manager owns). So the\n * hook elevates. It writes nothing the caller chose beyond the links already on\n * the event, and only the recency dates and the case's first-response stamp;\n * elevation is not anonymity \u2014 `updated_by` still names the person.\n *\n * ## Organization (AGENTS.md rule 10)\n *\n * Every read and every write is pinned to the triggering event's own\n * `organization_id` when it carries one: the walk-up reads carry the predicate,\n * and because a by-id update cannot (the engine refuses an extra `where` key on\n * the by-id path), each write target is first confirmed inside the\n * organization by one pinned read per object. A person's elevated context\n * already keeps their tenant; the pin is what holds the wall for a trigger\n * that carries none (a system write, which runs unscoped). An event with no\n * organization (a single-organization install) has no wall, and is not pinned.\n */\nconst eventActivityBubble: Hook = {\n  name: 'event_activity_bubble',\n  object: 'crm_event',\n  events: ['afterInsert', 'afterUpdate'],\n  priority: 800,\n  async: true,\n  onError: 'log',\n  runAs: 'system',\n  description:\n    'A held event stamps interaction recency on the related account (walking up from contact/opportunity/case), lead and contact, and the first-response time on a related case.',\n  handler: async (ctx: HookContext) => {\n    const { input } = ctx;\n    const previous = ctx.previous;\n    const api = ctx.api as HookApi | undefined;\n    if (!api) return;\n\n    const r: Record<string, any> = { ...(previous ?? {}), ...input };\n\n    // Only an interaction that HAPPENED resets the recency clock. A meeting\n    // booked for next quarter is not contact; letting `planned` bubble would\n    // make an account look freshly-touched the moment someone put a placeholder\n    // on the calendar, which is the exact failure mode the churn report exists\n    // to avoid.\n    if (r.status !== 'held') return;\n    // Fire once, on the transition into `held` (afterInsert has no `previous`).\n    if (previous && previous.status === 'held') return;\n\n    const nowIso = new Date().toISOString();\n    // `crm_account.last_activity_date` is a DATE column; the two contact\n    // timestamps are datetimes. Passing an ISO instant to a date column is what\n    // stores '2026-08-04T\u2026' in a field every filter compares as 'YYYY-MM-DD'.\n    const today = nowIso.slice(0, 10);\n\n    const idOf = (key: string): string | undefined =>\n      typeof r[key] === 'string' && r[key].length > 0 ? (r[key] as string) : undefined;\n    // The rule-10 pin \u2014 see the hook's note.\n    const org = idOf('organization_id');\n    const inOrg: Record<string, string> = org ? { organization_id: org } : {};\n\n    const accountIds = new Set<string>();\n    const contactIds = new Set<string>();\n    const leadIds = new Set<string>();\n\n    const direct = idOf('related_to_account');\n    if (direct) accountIds.add(direct);\n    const contactId = idOf('related_to_contact');\n    if (contactId) contactIds.add(contactId);\n    const leadId = idOf('related_to_lead');\n    if (leadId) leadIds.add(leadId);\n\n    // Walk UP to the account. Every one of these objects names its parent\n    // `crm_account`, so one loop covers all three. `find(... top: 1)` rather\n    // than `findOne`: the two agree here, and `find` is the shape the rest of\n    // the app's hooks read with.\n    const parentLookups: Array<[string, string]> = [\n      ['related_to_contact', 'crm_contact'],\n      ['related_to_opportunity', 'crm_opportunity'],\n      ['related_to_case', 'crm_case'],\n    ];\n    for (const [field, object] of parentLookups) {\n      const id = idOf(field);\n      if (!id) continue;\n      try {\n        const raw: any = await api.object(object).find({\n          where: { id, ...inOrg },\n          fields: ['crm_account'],\n          top: 1,\n        });\n        const rows = Array.isArray(raw) ? raw : (raw?.records ?? []);\n        const parent = rows.length ? rows[0].crm_account : undefined;\n        if (typeof parent === 'string' && parent.length > 0) accountIds.add(parent);\n      } catch {\n        // Best-effort: a parent that cannot be read is not bubbled through.\n        // No `console` in the L2 hook sandbox \u2014 logging here would throw its\n        // own ReferenceError (cf. #471).\n      }\n    }\n\n    const targets: Array<[string, Set<string>, Record<string, any>]> = [\n      ['crm_account', accountIds, { last_activity_date: today }],\n      ['crm_contact', contactIds, { last_contacted_date: nowIso }],\n      ['crm_lead', leadIds, { last_contacted_date: nowIso }],\n    ];\n    for (const [object, ids, doc] of targets) {\n      let inside = [...ids];\n      if (org && inside.length > 0) {\n        try {\n          const raw: any = await api.object(object).find({ where: { id: { $in: inside }, ...inOrg }, fields: ['id'], top: inside.length });\n          inside = (Array.isArray(raw) ? raw : (raw?.records ?? [])).map((row: any) => String(row.id));\n        } catch {\n          inside = [];\n        }\n      }\n      for (const id of inside) {\n        try {\n          // `update(document, options)` \u2014 `ctx.api` is the engine repo facade,\n          // whose update takes a DOCUMENT, not an id (#616; pinned by\n          // test/hook-write-shape.test.ts against a real kernel).\n          await api.object(object).update({ ...doc, id }, { where: { id } });\n        } catch {\n          // Best-effort activity bubble; never break the parent write.\n        }\n      }\n    }\n\n    // \u2500\u2500 First response on a case (#595) \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n    //\n    // \u26D4 The SINGLE writer of `crm_case.first_response_date`, and it belongs\n    // here rather than in the `log_call` / `log_meeting` action bodies: stamping\n    // it per-button covers only interactions recorded through those two\n    // buttons, and an event created any other way (the Activity tab, an import,\n    // an integration, a future action) leaves the most standard SLA metric a\n    // service desk reports permanently null. The rule those actions express is\n    // the one this hook already computes for recency \u2014 an interaction that\n    // HAPPENED \u2014 so it lives once, where every writer of a held event passes\n    // through it. Same argument that makes this hook the single writer of\n    // recency, and `case_status_side_effects` the single owner of escalation\n    // follow-up tasks.\n    //\n    // A status change is deliberately NOT a first response: an agent can move a\n    // case to \"in progress\" and investigate\n    // for an hour while the customer hears nothing, so a status-derived number\n    // would report a response that never happened. Neither is a meeting merely\n    // BOOKED \u2014 that is the `held` gate above, which this block sits under.\n    const responseCaseId = idOf('related_to_case');\n    if (responseCaseId) {\n      try {\n        // Read the STORED value rather than trusting the event's own payload:\n        // \"first response\" is a property of the case, so the second held event\n        // on a case must find the first one's stamp and leave it alone. A\n        // re-stamp would silently turn the metric into \"last response\".\n        // Pinned like the bubble, and written only when the read FOUND the\n        // case: under elevation an empty read means \"not this organization's\"\n        // (or gone), never \"not stamped yet\".\n        const raw: any = await api.object('crm_case').find({\n          where: { id: responseCaseId, ...inOrg },\n          fields: ['first_response_date'],\n          top: 1,\n        });\n        const rows = Array.isArray(raw) ? raw : (raw?.records ?? []);\n        if (rows.length > 0 && !rows[0].first_response_date) {\n          await api.object('crm_case').update(\n            { id: responseCaseId, first_response_date: nowIso },\n            { where: { id: responseCaseId } },\n          );\n        }\n      } catch {\n        // Best-effort, like the bubble above: never break the event write.\n      }\n    }\n  },\n};\n\n/**\n * `do_not_call` \u2014 the calendar half of the same promise.\n *\n * `crm_task` carries the follow-up a rep OWES; `crm_event` carries the slot a\n * rep BOOKS. A `planned` event of type `call` is a booked outbound phone call,\n * so it is refused against a person flagged `do_not_call` for exactly the\n * reasons stated on `task_do_not_call_guard` in `src/sales/objects/task.hook.ts`\n * (read that block first \u2014 it carries the full rationale for enforcing on the\n * write rather than on a button, and for scoping to the phone).\n *\n * The status split is what makes this guard honest, and it is the whole reason\n * `log_call` needs no gate of its own:\n *\n *   - `status: 'held'`   \u2014 the call HAPPENED. Allowed, always. This is what\n *     `log_call` writes, and refusing it would hide evidence of a call rather\n *     than prevent one.\n *   - `status: 'planned'` \u2014 the call is BOOKED. Refused.\n *\n * `schedule_meeting` is deliberately NOT caught here: it hardcodes\n * `type: 'meeting'`, and a person who does not want phone calls may still be\n * met in person or over video. Gating it would widen `do_not_call` into\n * `do_not_contact`.\n */\nconst eventDoNotCallGuard: Hook = {\n  name: 'event_do_not_call_guard',\n  object: 'crm_event',\n  events: ['beforeInsert', 'beforeUpdate'],\n  priority: 150,\n  description: 'Refuse to book a planned Call event against a lead/contact flagged Do Not Call.',\n  handler: async (ctx: HookContext) => {\n    // The refusal envelope (#1075). Mirrored from `./_refusal.ts` because a\n    // lowered body has no module scope and `extractHookBody` THROWS on an\n    // import; `test/refusal-envelope.test.ts` pins every copy against it.\n    function refuse(\n      message: string,\n      code: string,\n      status: number,\n      userMessage: string = message,\n    ): Error {\n      const err = new Error(message) as Error & {\n        code: string;\n        status: number;\n        userMessage: string;\n      };\n      err.code = code;\n      err.status = status;\n      err.userMessage = userMessage;\n      return err;\n    }\n    const { input } = ctx;\n    const previous = ctx.previous;\n    const api = ctx.api as HookApi | undefined;\n    if (!api) return;\n\n    const effective = (key: string): unknown =>\n      input[key] !== undefined && input[key] !== null ? input[key] : previous?.[key];\n\n    if (effective('type') !== 'call') return;\n    // Only a booking. `held` (what `log_call` writes) and every other status\n    // describe a call that is no longer preventable.\n    if (effective('status') !== 'planned') return;\n\n    const leadId = effective('related_to_lead');\n    const contactId = effective('related_to_contact');\n\n    const targets: Array<{ object: string; id: string; label: string }> = [];\n    if (typeof leadId === 'string' && leadId) {\n      targets.push({ object: 'crm_lead', id: leadId, label: 'lead' });\n    }\n    if (typeof contactId === 'string' && contactId) {\n      targets.push({ object: 'crm_contact', id: contactId, label: 'contact' });\n    }\n\n    for (const t of targets) {\n      // `find(... top: 1)`, normalised for both driver shapes \u2014 same reasoning\n      // as `event_activity_bubble` below.\n      const raw: any = await api.object(t.object).find({\n        where: { id: t.id },\n        fields: ['id', 'do_not_call'],\n        top: 1,\n      });\n      const rows = Array.isArray(raw) ? raw : (raw?.records ?? []);\n      const person = rows[0];\n      // `=== true`: absent / null / false are all \"not flagged\".\n      if (person?.do_not_call === true) {\n        throw refuse(\n          `This ${t.label} is flagged Do Not Call, so a call cannot be scheduled against them. ` +\n            'Log the call as held if it already happened, book a meeting instead, ' +\n            'or clear Do Not Call on the record first.',\n          'FORBIDDEN',\n          403,\n        );\n      }\n    }\n  },\n};\n\nexport default [eventScheduleDerive, eventDoNotCallGuard, eventActivityBubble];\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/sales/objects/forecast.hook.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/sales/objects\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/sales/objects/forecast.hook.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport type { Hook, HookContext } from '@objectstack/spec/data';\n\n/**\n * Forecast lifecycle hook.\n *\n * Auto-derives the whole period family \u2014 `period_start`, `period_end` and\n * `period_label` \u2014 from `period` (+ `period_start`, when the caller supplies\n * one) so callers (UI, AI skill, the `forecast_snapshot` scheduled flow) don't\n * have to compute them. Also stamps `snapshot_date` to today on insert if\n * unset.\n *\n * Why `period_start` is derived here and nowhere else: a flow template can\n * express `{TODAY()}` and day offsets, but it has no way to say \"the first day\n * of the calendar quarter containing today\". If each writer computed its own\n * boundary we would get exactly the drift #530 pinned in the seeds \u2014 snapshots\n * labelled 'Q3 2026' whose `period_start` is some mid-quarter date, so every\n * \"this quarter\" equals-filter misses. One derivation, one definition: give\n * the object a `period` and it lands on a calendar-true boundary or not at all.\n *\n * NOTE: all helpers are inlined into `handler` because the build pipeline\n * lowers inline handlers \u2014 module-scope helpers would not survive lowering.\n */\nconst forecastDerive: Hook = {\n  name: 'forecast_derive_period',\n  object: 'crm_forecast',\n  events: ['beforeInsert', 'beforeUpdate'],\n  priority: 200,\n  description: 'Derive period_start, period_end and period_label from period (+ snapshot_date).',\n  handler: async (ctx: HookContext) => {\n    // \u26D4 A PREDICATE UPDATE DERIVES NOTHING HERE \u2014 ADR-0058 Addendum II D3.\n    //\n    // `update(obj, payload, { multi: true, where })` sends ONE `SET` clause for\n    // all N matched rows, and the engine hands every row's `beforeUpdate` THAT\n    // payload rather than a per-row copy. A payload write whose value \u2014 or\n    // whose if-guard \u2014 reads `ctx.previous` therefore does not scope itself to\n    // the row it was decided on. Both outcomes are measured on\n    // 17.4.0, in this app, on a fresh `pnpm dev`:\n    //\n    //  - keys written for SOME rows only \u21D2 the engine refuses the whole batch\n    //    (`MULTI_UPDATE_HOOK_KEY_DIVERGENCE`) and writes nothing. This hook's\n    //    own `if (!input.period_end)` did exactly that under the platform's\n    //    seed-ownership claim: row 0 stamped `period_end` / `period_label`\n    //    into the shared payload, rows 1-6 then saw them already set and\n    //    stamped nothing, so all 7 seeded forecasts stayed ownerless (#1804).\n    //  - the SAME key on EVERY row \u21D2 nothing diverges, the batch resolves, and\n    //    the LAST row's value is stored for all of them, in silence. That is\n    //    what left `probability: 80` on closed-lost opportunities (#1275).\n    //\n    // `ctx.previous` on this path is supplied so a guard can REFUSE a write,\n    // never so a rewrite can be aimed. Deriving is per-record work, so it\n    // stands down here and still happens on the per-record path \u2014 which is\n    // every writer this app has: all 19 `update_record` flow nodes and every\n    // action and hook write through `ctx.api`, all of them by id. The platform's\n    // seed-ownership claim is a predicate write, and it writes only `owner_id`,\n    // which derives nothing.\n    //\n    // \u26A0\uFE0F The `ctx.event` half is load-bearing, not ceremony: a BATCH INSERT\n    // also reports `dispatch.mode === 'per-row'`, and there each row carries\n    // its OWN payload \u2014 dropping that half would stop the seeds deriving their\n    // periods at all.\n    if (ctx.event === 'beforeUpdate' && ctx.dispatch?.mode === 'per-row') return;\n\n    const pad = (n: number) => String(n).padStart(2, '0');\n    const isoDate = (d: Date) =>\n      `${d.getUTCFullYear()}-${pad(d.getUTCMonth() + 1)}-${pad(d.getUTCDate())}`;\n    const MONTHS = ['Jan','Feb','Mar','Apr','May','Jun','Jul','Aug','Sep','Oct','Nov','Dec'];\n    const endOfMonth = (start: Date) =>\n      new Date(Date.UTC(start.getUTCFullYear(), start.getUTCMonth() + 1, 0));\n    // \"start + one period\", a ROLLING window \u2014 calendar-true only because a\n    // hand-filled `period_start` off a calendar boundary is now REFUSED by\n    // `period_start_first_of_period` / `quarter_starts_on_quarter_boundary` in\n    // `forecast.object.ts` (#1008). Before that rule, `2026-08-15` + `quarter`\n    // derived `2026-10-31` under the label `Q3 2026`.\n    const endOfQuarter = (start: Date) =>\n      new Date(Date.UTC(start.getUTCFullYear(), start.getUTCMonth() + 3, 0));\n    // First day of the calendar period CONTAINING `d` \u2014 the inverse of the\n    // two helpers above, and the piece a flow template cannot express.\n    const startOfPeriod = (period: string, d: Date) =>\n      new Date(Date.UTC(\n        d.getUTCFullYear(),\n        period === 'quarter' ? Math.floor(d.getUTCMonth() / 3) * 3 : d.getUTCMonth(),\n        1,\n      ));\n    const labelFor = (period: string, start: Date) => {\n      if (period === 'quarter') {\n        const q = Math.floor(start.getUTCMonth() / 3) + 1;\n        return `Q${q} ${start.getUTCFullYear()}`;\n      }\n      return `${MONTHS[start.getUTCMonth()]} ${start.getUTCFullYear()}`;\n    };\n\n    const { input } = ctx;\n    const previous = ctx.previous;\n    const period =\n      (typeof input.period === 'string' && input.period) ||\n      (typeof previous?.period === 'string' && (previous.period as string)) ||\n      'month';\n    let startStr =\n      (typeof input.period_start === 'string' && input.period_start) ||\n      (typeof previous?.period_start === 'string' && (previous.period_start as string)) ||\n      undefined;\n\n    // No period_start anywhere \u21D2 snapshot the period that contains the\n    // snapshot day (falling back to today). `period_start` is required +\n    // notNull, so before this the write simply failed; deriving it is what\n    // makes `{ period: 'quarter' }` a complete, calendar-true snapshot\n    // request \u2014 the only shape an automated writer can express.\n    if (!startStr) {\n      const anchorStr =\n        (typeof input.snapshot_date === 'string' && input.snapshot_date) ||\n        (typeof previous?.snapshot_date === 'string' && (previous.snapshot_date as string)) ||\n        isoDate(new Date());\n      const anchor = new Date(`${anchorStr.slice(0, 10)}T00:00:00Z`);\n      if (!Number.isNaN(anchor.getTime())) {\n        startStr = isoDate(startOfPeriod(period, anchor));\n        input.period_start = startStr;\n      }\n    }\n\n    if (startStr) {\n      const start = new Date(`${startStr}T00:00:00Z`);\n      if (!Number.isNaN(start.getTime())) {\n        const end = period === 'quarter' ? endOfQuarter(start) : endOfMonth(start);\n        if (!input.period_end) input.period_end = isoDate(end);\n        if (!input.period_label) input.period_label = labelFor(period, start);\n      }\n    }\n\n    if (!input.snapshot_date && !previous?.snapshot_date) {\n      input.snapshot_date = isoDate(new Date());\n    }\n  },\n};\n\nexport default forecastDerive;\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/sales/objects/lead.hook.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/sales/objects\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/sales/objects/lead.hook.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport type { Hook, HookContext } from '@objectstack/spec/data';\nimport type { HookApi } from './_hook-api';\n\n/**\n * Lead automation hook.\n *\n * - Auto-scores incoming leads into `rating` (1-5) using industry/title/email/phone weights.\n * - Refuses edits to a converted lead \u2014 but not the engine's reference cleanup,\n *   so a converted lead never makes its conversion products undeletable.\n * - When status flips to `qualified`, schedules a follow-up `crm_task` for the current user.\n * - Normalizes `email` and flags a re-captured address as a suspected duplicate.\n */\n\n// \u26A0\uFE0F The scoring constants and `computeRating` live INSIDE `lead_automation`'s\n// handler: L2 hook bodies run body-only in the QuickJS sandbox, so module scope\n// is not reachable at runtime. Tune the weights in the handler \u2014 a module-level\n// copy is dead code that silently diverges from the copy that actually runs.\n\n/**\n * Lead auto-assignment (load-balanced round-robin).\n *\n * A lead created without an owner (CSV import, web-to-lead, API capture) is\n * assigned to the sales rep with the FEWEST open leads \u2014 a self-balancing\n * round-robin that needs no rotation counter. It writes `owner_id`, the platform\n * ownership anchor that OWD, sharing and the \"My Leads\" view all read, so the\n * assigned rep really owns the lead rather than merely being named on it.\n *\n * \u26A0\uFE0F Writing a FOREIGN owner is normally an ownership transfer, denied without\n * `allowTransfer` (#3004). It passes here because of WHERE this runs, not what\n * it is granted: a `beforeInsert` hook mutates `opCtx.data` INSIDE the operation\n * the security middleware already wrapped, so the guard read (and stamped) the\n * payload before this line changed it. `test/ownership-model.test.ts` pins that\n * ordering against a real ObjectQL \u2014 an assumption here would be the difference\n * between round-robin working and every web-to-lead submission 403-ing.\n *\n * The rep pool is whoever holds the `sales_rep` position (`sys_user_position`).\n * When that pool is empty (a fresh org before positions are assigned) the hook\n * is a NO-OP and the lead keeps whatever owner it had \u2014 it never blocks lead\n * creation. UI-created leads already carry `owner_id` = creator (the\n * middleware's insert-time stamp), so this only fires on genuinely ownerless\n * intake.\n *\n * Runs beforeInsert so the downstream `lead_assignment` flow (afterInsert) sees\n * the assigned owner and routes its SLA alert to that rep.\n *\n * \u26A0\uFE0F Priority 250 \u2014 hooks run in ASCENDING priority order, so this must run\n * AFTER `lead_automation` (200), whose guest branch strips a client-spoofed\n * `owner_id` from anonymous Web-to-Lead submissions. Assigning first and being\n * stripped afterwards lands every web-to-lead ownerless \u2014 the exact case this\n * hook exists for.\n */\nconst leadAutoAssignHook: Hook = {\n  name: 'lead_auto_assign',\n  object: 'crm_lead',\n  events: ['beforeInsert'],\n  priority: 250,\n  description: 'Assign ownerless new leads to the least-loaded sales rep.',\n  handler: async (ctx: HookContext) => {\n    const { input } = ctx;\n    // Respect an explicit / creator-assigned owner. On a write that carries a\n    // user the security middleware has ALREADY stamped `owner_id` to that user\n    // by the time this runs, so this is also what makes the hook a no-op for\n    // ordinary UI creation \u2014 only genuinely ownerless intake falls through.\n    if (typeof input.owner_id === 'string' && input.owner_id) return;\n    const api = ctx.api as HookApi | undefined;\n    if (!api) return;\n\n    // Auto-assignment is a best-effort ENHANCEMENT \u2014 it must NEVER block lead\n    // creation. In particular an anonymous Web-to-Lead submission runs under the\n    // public-form grant, which permits only create/read-back on crm_lead and\n    // DENIES `find` on sys_user_position; letting that denial propagate would\n    // reject the whole insert and break the public form. So the pool lookup +\n    // load balancing are wrapped: on ANY error (permission, etc.) we log and\n    // leave the lead ownerless (a manager / the lead_assignment flow routes it).\n    try {\n      // Rep pool = holders of the sales_rep position.\n      const holders = await api.object('sys_user_position').find({\n        where: { position: 'sales_rep' }, fields: ['user_id'], top: 1000,\n      });\n      const repIds = Array.from(\n        new Set(\n          (holders ?? [])\n            .map((r) => (typeof r.user_id === 'string' ? r.user_id : ''))\n            .filter(Boolean),\n        ),\n      );\n      if (repIds.length === 0) return; // no pool \u2192 leave ownerless (no-op)\n\n      // Pick the rep with the fewest OPEN (non-converted) leads.\n      let best: string | undefined;\n      let bestCount = Infinity;\n      for (const repId of repIds) {\n        const openCount = await api.object('crm_lead').count({\n          where: { owner_id: repId, is_converted: false },\n        });\n        if (openCount < bestCount) {\n          bestCount = openCount;\n          best = repId;\n        }\n      }\n      if (best) input.owner_id = best;\n    } catch {\n      // Swallow: auto-assignment must never block the insert. Common case is the\n      // anonymous public-form context, which can't read sys_user_position \u2014 the\n      // lead is still captured, ownerless, for downstream routing. (No `console`\n      // here \u2014 the L2 hook sandbox doesn't define it.)\n    }\n  },\n};\n\nconst leadHook: Hook = {\n  name: 'lead_automation',\n  object: 'crm_lead',\n  events: ['beforeInsert', 'beforeUpdate', 'afterUpdate'],\n  priority: 200,\n  description:\n    'Score new leads, lock converted leads, and create follow-up task on qualification.',\n  handler: async (ctx: HookContext) => {\n    // The refusal envelope (#1075). Mirrored from `./_refusal.ts` because a\n    // lowered body has no module scope and `extractHookBody` THROWS on an\n    // import; `test/refusal-envelope.test.ts` pins every copy against it.\n    function refuse(\n      message: string,\n      code: string,\n      status: number,\n      userMessage: string = message,\n    ): Error {\n      const err = new Error(message) as Error & {\n        code: string;\n        status: number;\n        userMessage: string;\n      };\n      err.code = code;\n      err.status = status;\n      err.userMessage = userMessage;\n      return err;\n    }\n    const { event, input } = ctx;\n\n    const HIGH_VALUE_INDUSTRIES = new Set(['technology', 'finance', 'healthcare']);\n    const SENIOR_TITLE_PATTERN = /\\b(ceo|cto|cfo|cio|coo|founder|vp|vice president|director|head of)\\b/i;\n    function computeRating(input: Record<string, unknown>): number {\n      let score = 0;\n      const email = typeof input.email === 'string' ? input.email : '';\n      const phone = typeof input.phone === 'string' ? input.phone : '';\n      const title = typeof input.title === 'string' ? input.title : '';\n      const industry = typeof input.industry === 'string' ? input.industry : '';\n      const employees = typeof input.number_of_employees === 'number' ? input.number_of_employees : 0;\n      const revenue = typeof input.annual_revenue === 'number' ? input.annual_revenue : 0;\n      if (email && !/(gmail|yahoo|hotmail|outlook|qq|163)\\.com$/i.test(email)) score += 1;\n      if (phone.length > 0) score += 0.5;\n      if (SENIOR_TITLE_PATTERN.test(title)) score += 1.5;\n      if (HIGH_VALUE_INDUSTRIES.has(industry)) score += 1;\n      if (employees >= 200) score += 0.5;\n      if (revenue >= 10_000_000) score += 0.5;\n      // Cap at 5, floor at 1, round to WHOLE stars \u2014 `rating` is a 1-5 star\n      // field; half values rendered inconsistently in the star widget.\n      const clamped = Math.max(1, Math.min(5, score));\n      return Math.round(clamped);\n    }\n\n    if (event === 'beforeInsert') {\n      // Web-to-Lead: anonymous submissions from the public form get sensible\n      // defaults stamped server-side so they cannot be spoofed by the client.\n      // Guests are unauthenticated, so we identify them by the absence of\n      // `ctx.user?.id`. (The `guest_portal` profile already restricts them to\n      // INSERT-only on `crm_lead`.)\n      //\n      // \u26A0\uFE0F `!ctx.session?.isSystem` is required, not decoration: a SYSTEM write\n      // (seed load, backfill, seed-ownership claim) also arrives with no user id, and\n      // the strip below would otherwise blank the owner and conversion state of\n      // every system-written lead. The converted-lead lock further down reads\n      // that same absence as the system-write signal, so the two readings have\n      // to agree. `case.hook.ts`'s guest branch carries the same correction.\n      const isGuestSubmission = !ctx.user?.id && !ctx.session?.isSystem;\n      if (isGuestSubmission) {\n        if (!input.lead_source) input.lead_source = 'web';\n        if (!input.status)      input.status      = 'new';\n        // Never trust client-supplied conversion / ownership fields on a public\n        // form \u2014 OVERWRITE them with a safe value.\n        //\n        // \u2705 HISTORY, RESOLVED \u2014 and the conclusion is unchanged. Through\n        // 17.2.0, `delete input.x` in a hook was a SILENT NO-OP: ObjectQL's\n        // flat-record input Proxy had no `deleteProperty` trap, so the key\n        // survived the delete and reached storage, while an ASSIGNMENT to the\n        // same key on the same `input` landed normally. This block was ten\n        // `delete` statements and every one of them did nothing; the symptom was\n        // a guest insert storing `is_converted: true` and an `owner_id` it\n        // supplied itself. Assignment is what this block uses.\n        //\n        // Upstream objectstack#12277 shipped in **17.3.0**, so every later\n        // pin carries the fix and `delete` is effective on both execution paths.\n        // \u26D4 That is still not a licence to spell this block with `delete`: the\n        // assignments are load-bearing as WRITES \u2014 `lead_duplicate_check` stands\n        // down only on a NON-BLANK verdict, so these columns must arrive `null`\n        // rather than ABSENT. `case.hook.ts`'s copy carries the full note and\n        // the measurement; `test/hook-input-shape.test.ts` pins the new contract.\n        //\n        // `null` is the no-value spelling throughout, and it is load-bearing\n        // twice over: `lead_auto_assign` stands down only on a non-empty STRING\n        // `owner_id`, and `lead_duplicate_check` stands down only on a NON-BLANK\n        // `duplicate_status` / `duplicate_of_type` \u2014 where its own `isBlank`\n        // counts `null` as blank. Both therefore still run on a sanitised guest\n        // submission, which is exactly what the removed deletes were for.\n        input.is_converted           = false;\n        input.converted_account      = null;\n        input.converted_contact      = null;\n        input.converted_opportunity  = null;\n        input.converted_date         = null;\n        input.owner_id               = null;\n        // Same reasoning for the duplicate link: a submitter who can post\n        // `duplicate_status: 'confirmed'` can switch OFF the intake dedupe for\n        // their own submission (`lead_duplicate_check` stands down on a record\n        // that already carries a verdict) and park a link to any record id they\n        // care to guess. Guests state facts about themselves, never about the\n        // pipeline.\n        input.duplicate_of_type      = null;\n        input.duplicate_of_lead      = null;\n        input.duplicate_of_contact   = null;\n        input.duplicate_status       = null;\n      }\n\n      if (typeof input.rating !== 'number') {\n        input.rating = computeRating(input);\n      }\n    }\n\n    // \u2500\u2500 The conversion approval gate (REQ-0005 step 7) \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n    //\n    // \u300C\u7EBF\u7D22\u5BF9\u5E94\u5BA1\u6279\u6D41\u7A0B\uFF0C\u5BA1\u6279\u901A\u8FC7\u540E\u65B9\u53EF\u8F6C\u5316\u4E3A\u6B63\u5F0F\u5546\u673A\u300D. This is the WRITE-PATH\n    // half of the gate; `convert_lead`'s `visible` predicate is the other, and\n    // it only hides a button. Hiding a button is not a control: the conversion\n    // screen flow is reachable over REST (`POST /automation/lead_conversion/\n    // trigger`), and so is a bare `PATCH` that sets `is_converted` itself. Both\n    // land HERE, because both are an update to `crm_lead`.\n    //\n    // \u26A0\uFE0F A TRANSITION GATE, not an invariant (AGENTS.md metadata semantics rule\n    // 7), and the difference is the `!wasConverted` term rather than a comment\n    // claiming it. The refusal is conditioned on the record CROSSING into\n    // converted on THIS write; a lead that was already converted before the\n    // gate existed is untouched by it forever, whatever its approval column\n    // says (REQ-0005 acceptance 4). \u26D4 Never restate this as a `validations[]`\n    // script: a validation is evaluated against `{...previous, ...data}`, where\n    // \"already converted\" and \"converting now\" are the same state, so it would\n    // brick every later write to every historical converted lead.\n    //\n    // \u26A0\uFE0F The verdict is read off `previous`, never off `input`. The approval\n    // column is `readonly: true`, so a caller-supplied value is stripped before\n    // storage on the non-system path \u2014 but `stripReadonlyFields` is not a thing\n    // this guard may lean on (it does not run on inserts, nor for a system\n    // write), and reading the STORED verdict is the correct semantics anyway:\n    // what may convert a lead is what an approver decided, not what the writer\n    // attached to the request.\n    //\n    // \u26A0\uFE0F Fail OPEN on an absent or unrecognised verdict, and that is the gate's\n    // off switch, not an oversight. With the gate off \u2014 the shipped default \u2014\n    // every lead carries `not_required`, and a lead that predates the column\n    // carries nothing at all; both must convert exactly as they did before this\n    // field existed. So only the two verdicts a live approval actually writes\n    // refuse. (`convert_lead`'s predicate carries the same polarity and the\n    // same reason, against its own fail-CLOSED neighbours.)\n    if (event === 'beforeUpdate') {\n      const previous = ctx.previous;\n      const wasConverted = previous?.is_converted === true || previous?.status === 'converted';\n      const isConverting =\n        !wasConverted && (input.is_converted === true || input.status === 'converted');\n      const verdict = previous?.conversion_approval_status;\n      if (isConverting && (verdict === 'pending' || verdict === 'rejected')) {\n        // Name the lead the way `display_title` does \u2014 see the converted-lead\n        // lock below for why an id never appears in a sentence a user reads.\n        const person = [previous?.first_name, previous?.last_name]\n          .filter((part) => typeof part === 'string' && part.trim() !== '')\n          .join(' ');\n        const company =\n          typeof previous?.company === 'string' ? previous.company.trim() : '';\n        const label = [person, company].filter(Boolean).join(' - ');\n        const state = verdict === 'rejected' ? 'was rejected' : 'is still awaiting approval';\n        throw refuse(\n          `Cannot convert ${label ? `lead ${label}` : 'this lead'}: its conversion ${state}. Conversion opens once an approver signs it off \u2014 the Conversion Approval field on the lead shows where it stands.`,\n          'RECORD_LOCKED',\n          409,\n        );\n      }\n    }\n\n    // Converted-lead lock \u2014 USER edits only (`ctx.user?.id` is this repo's\n    // system-write signal, cf. opportunity/quote/account hooks): a blanket\n    // throw also rejected system writes (seed-ownership claims, flow\n    // backfills). Narrative notes and framework-managed columns stay editable;\n    // identity and conversion fields stay locked.\n    //\n    // This is the ONLY converted-lead guard \u2014 there is deliberately no second,\n    // friendlier script validation over the same four identity fields, because\n    // this throw always won the race and a second layer could only drift. The\n    // message below therefore has to carry the whole story, hence the\n    // attempted-field list.\n    if (event === 'beforeUpdate' && ctx.user?.id) {\n      const previous = ctx.previous;\n      const wasConverted = previous?.is_converted === true || previous?.status === 'converted';\n      if (wasConverted) {\n        const ALLOWED = new Set([\n          'description', 'notes',\n          // Framework-managed / system columns (cf. opportunity.hook.ts).\n          'id', 'owner_id', 'created_at', 'updated_at',\n          'created_by', 'updated_by', 'space_id', 'organization_id', 'org_id', 'version',\n        ]);\n        const violating = Object.keys(input).filter(\n          (k) => !ALLOWED.has(k) && input[k] !== previous?.[k],\n        );\n        if (violating.length > 0) {\n          // Every lookup on `crm_lead` a referential clear can attack.\n          const REFERENCE_FIELDS = new Set([\n            'converted_account', 'converted_contact', 'converted_opportunity',\n            'duplicate_of_lead', 'duplicate_of_contact',\n          ]);\n          // \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500 the reference-cleanup yield \u2500\u2500\n          // #720. The engine implements `deleteBehavior: 'set_null'` by UPDATING\n          // the row that HOLDS the lookup, so deleting the account / contact /\n          // opportunity a converted lead points at (or the lead / contact it was\n          // flagged as a duplicate of) arrives here as an ordinary user\n          // `beforeUpdate` \u2014 and this lock refused it, which made a converted\n          // lead able to keep all three of its conversion products undeletable\n          // forever (a GDPR erasure that cannot be carried out).\n          //\n          // Measured on 17.1.0 \u2014 the version this repo pinned AT THE TIME of\n          // the measurement, not the current pin (the cascade shape below has\n          // NOT been re-measured on any later pin \u2014 not 17.3.0, #1676, not\n          // 17.4.0, PR #1814, and not 17.5.0) \u2014 with a probe hook at priority 199 immediately\n          // ahead of each guard, not assumed.\n          // The engine builds its cleanup write on the CALLER's own context\n          // plus two engine keys, so on the path a REST `DELETE` takes, the\n          // cascade and a user's hand-clear of the same lookup are identical\n          // everywhere a guard can look: payload\n          // `{ id, <link>: null, updated_at, updated_by }`, `ctx.user` the\n          // CALLER, `ctx.session` the caller's own `{ userId, isSystem }`.\n          // (Both `updated_by` and the identity drop out together when the\n          // DELETE itself carried no `userId` \u2014 a rig artefact, not this app's\n          // path.) So the WRITE SHAPE is not a discriminator, and the yield\n          // below is not one either: it lets ANY caller clear a declared link\n          // on a settled record. That is the trade #720 accepted, not a side\n          // effect of it.\n          //\n          // \u26A0\uFE0F A marker DOES reach a hook \u2014 and is deliberately not read. An\n          // earlier version of this note concluded \"no marker reaches a hook,\n          // and the WRITE SHAPE is the only evidence there is\"; it reasoned\n          // only about `ctx.session`, whose allow-list really does omit\n          // `__`-prefixed operation-private keys, and missed the other route\n          // into the context. `ObjectQL.cascadeDeleteRelations` builds\n          // `{ ...context, __referentialFieldClear: true }`, readable at\n          // `ctx.api.executionContext.__referentialFieldClear`: measured `true`\n          // on every cascade into `crm_opportunity`, `crm_quote` and\n          // `crm_lead`, `undefined` on every hand-clear (#1165, #1412).\n          //\n          // \u26D4 The #1165 ruling (2026-08-25) reviewed that and upheld NOT\n          // reading it, on two grounds. It is an operation-private key \u2014 an\n          // undeclared dependency that can vanish in a patch release. And\n          // reachability through the SHIPPED path is unproven: a hook body runs\n          // body-only in QuickJS, where `buildSandboxApi` passes `engineCtx.api`\n          // only when that exposes `object()`, and otherwise a shim with no\n          // `executionContext` at all. Green in a kernel rig and silently false\n          // in production is the worst outcome a guard can have. The declared\n          // replacement `ctx.referentialFieldClear` is asked for upstream as\n          // objectstack-ai/objectstack#13644.\n          //\n          // \u26D4 Keep this narrow (maintainer's ruling on #720, Option A): a write\n          // yields ONLY when every one of its non-system changes is a DECLARED\n          // link going from a value to `null`. One business field alongside it,\n          // or a link repointed to a NEW value, and the refusal below still\n          // fires. The three freeze guards share this block verbatim \u2014 sharing\n          // it as an imported helper is not possible (hook bodies run body-only\n          // in the sandbox and cannot reach module scope), so\n          // `test/freeze-guard-reference-cleanup.test.ts` pins the three copies\n          // as identical text and pins both directions of the narrowness.\n          const isReferenceCleanup = violating.every(\n            (k) => REFERENCE_FIELDS.has(k) && input[k] === null && previous?.[k] != null,\n          );\n          if (isReferenceCleanup) return;\n\n          // Name the lead the way `crm_lead.display_title` does \u2014 the person\n          // and the company, joined \u2014 rather than appending the record id,\n          // which is unmatchable against every lead surface in this app (record\n          // page, list view, breadcrumb, lookup picker), all of which title a\n          // lead `Ada Lovelace - Acme`. Composed from the two stored columns\n          // because a lowered hook body cannot read the `display_title` formula.\n          const person = [previous?.first_name, previous?.last_name]\n            .filter((part) => typeof part === 'string' && part.trim() !== '')\n            .join(' ');\n          const company =\n            typeof previous?.company === 'string' ? previous.company.trim() : '';\n          const label = [person, company].filter(Boolean).join(' - ');\n\n          throw refuse(\n            `Cannot edit ${label ? `converted lead ${label}` : 'a converted lead'} (attempted: ${violating.join(', ')}). Make changes on the converted records instead.`,\n            'RECORD_LOCKED',\n            409,\n          );\n        }\n      }\n    }\n\n    if (event === 'afterUpdate') {\n      const previous = ctx.previous;\n      const becameQualified =\n        input.status === 'qualified' && previous?.status !== 'qualified';\n      if (!becameQualified) return;\n\n      const api = ctx.api as HookApi | undefined;\n      if (!api) return;\n\n      const leadId =\n        (typeof input.id === 'string' && input.id) ||\n        (typeof previous?.id === 'string' && previous.id) ||\n        undefined;\n      const ownerId =\n        (typeof input.owner_id === 'string' && input.owner_id) ||\n        (typeof previous?.owner_id === 'string' && previous.owner_id) ||\n        ctx.user?.id;\n\n      // ONE calendar, and it is UTC \u2014 the day step is taken with `setUTCDate`\n      // because the result is rendered with `toISOString()` below. `setDate`\n      // reads and writes the LOCAL calendar and preserves wall-clock time, so\n      // in a DST-observing deployment a two-day step across a spring-forward\n      // advances 47 h, not 48, and the rendered UTC day is one short. It is\n      // invisible at `TZ=UTC`, where the two calendars coincide.\n      const dueDate = new Date();\n      dueDate.setUTCDate(dueDate.getUTCDate() + 2);\n\n      // Title the task with the lead's name, not its record id. **All Tasks**\n      // is where a rep starts the day; a queue of rows reading `Follow up with\n      // qualified lead (EMtmaScoa3I-uYFG)` is a queue nobody can triage, and\n      // the key matches nothing on any lead page or in search. Both halves\n      // prefer the value THIS write is setting, since a qualifying write may be\n      // renaming the lead in the same payload.\n      //\n      // \u26A0\uFE0F The 255 cap is load-bearing, exactly as in `case.hook.ts`:\n      // `crm_task.subject` declares `maxLength: 255` and the engine enforces\n      // it, while `crm_lead.company` alone allows 255 \u2014 so an uncapped title is\n      // rejected, and the `catch` below swallows that rejection, leaving no\n      // follow-up task and no trace. Truncating the TAIL keeps the\n      // discriminating head intact.\n      const person = [\n        (typeof input.first_name === 'string' && input.first_name) || previous?.first_name,\n        (typeof input.last_name === 'string' && input.last_name) || previous?.last_name,\n      ]\n        .filter((part) => typeof part === 'string' && part.trim() !== '')\n        .join(' ');\n      const company =\n        (typeof input.company === 'string' && input.company.trim()) ||\n        (typeof previous?.company === 'string' && previous.company.trim()) ||\n        '';\n      const label = [person, company].filter(Boolean).join(' - ');\n      const titled = label\n        ? `Follow up with qualified lead: ${label}`\n        : 'Follow up with qualified lead';\n\n      try {\n        await api.object('crm_task').insert({\n          subject: titled.length > 255 ? `${titled.slice(0, 254)}\u2026` : titled,\n          status: 'not_started',\n          priority: 'high',\n          type: 'follow_up',\n          due_date: dueDate.toISOString().slice(0, 10),\n          // Unlike `lead_auto_assign` above, this is a SEPARATE insert on\n          // `ctx.api` \u2014 a new operation carrying the caller's context, so the\n          // #3004 transfer guard does apply to it. When the qualifier is the\n          // lead's own rep (`owner_id` == caller) it is not a transfer at all;\n          // a manager qualifying a rep's lead holds `allowTransfer`. Any other\n          // caller is denied and the catch below drops the task rather than\n          // landing it on the wrong desk.\n          owner_id: ownerId,\n          related_to_type: 'crm_lead',\n          related_to_lead: leadId,\n        });\n      } catch {\n        // Side-effect failure must not break the parent transaction. No\n        // `console` in the L2 hook sandbox \u2014 logging would throw its own\n        // ReferenceError and mask the real failure (cf. #471).\n      }\n    }\n  },\n};\n\n/**\n * Soft lead dedupe.\n *\n * A prospect who enquires twice must not be REJECTED \u2014 a re-captured address is\n * recorded as a fact instead of refused, so the public Web-to-Lead form never\n * answers a returning visitor with a save error.\n *\n * Four jobs, all `before`-phase so the values land in the same write:\n *\n * 1. **Normalize `email`** (trim + lowercase), exactly as `contact_integrity`\n *    does on `crm_contact`. \u26A0\uFE0F This is what makes the dedupe lookup below a\n *    plain equality match: there is no case-insensitive predicate to lean on \u2014\n *    ObjectQL's `$regex` compiles to a LIKE *substring* on SQL, which would\n *    match `a@b.com` inside `xa@b.com` \u2014 so the canonical form has to be\n *    established by the PRODUCER at write time rather than worked around by\n *    every reader. Also on update: an edit reintroducing mixed case would\n *    silently make the record invisible to every later dedupe.\n *\n * 1b. **Fold `company` into `company_normalized`** \u2014 a SEPARATE column, not an\n *    in-place rewrite, because `company` is the display value the conversion\n *    flow copies onto the account it creates. It is the lead half of the pair\n *    `crm_account.name_normalized` completes, and it exists for the same reason\n *    as the email fold: the reader (a flow template) can compare two stored\n *    columns but cannot compute either one.\n *\n * 2. **Link a repeated address to the record it repeats** \u2014 on insert only.\n *    An existing `crm_contact` wins over an open lead: the prospect who already\n *    became a contact is the further-along record, and the one the conversion\n *    flow would reuse anyway. Within a kind the OLDEST record wins, so a cluster\n *    of five re-submissions all point at the same origin instead of chaining.\n *\n * 3. **Retire the whole claim when the record it named is gone** \u2014 on update\n *    only, and the exact mirror of job 2: the hook that stamps a duplicate link\n *    is the one that takes it back down. See the note at the block itself.\n *\n * The write is `duplicate_status: 'suspected'` \u2014 a machine's guess, explicitly\n * distinguished from the `confirmed` verdict a human records when disqualifying\n * as a duplicate. The hook stands down on any record that already carries a\n * verdict, so `confirmed` can never be reverted to `suspected` by a later\n * write, and on any record that already names a survivor.\n *\n * Detection is INSERT-only by design: a later edit re-scanning would re-open a\n * question a human may have already closed, and the review queue\n * (`suspected_duplicates`) is the affordance for anything intake missed.\n *\n * \u26A0\uFE0F Priority 300 \u2014 after `lead_automation` (200), whose guest branch strips\n * client-supplied `duplicate_*` from anonymous submissions. Running earlier\n * would let a spoofed `duplicate_status` switch this hook off.\n */\nconst leadDuplicateCheckHook: Hook = {\n  name: 'lead_duplicate_check',\n  object: 'crm_lead',\n  events: ['beforeInsert', 'beforeUpdate'],\n  priority: 300,\n  description:\n    'Normalize lead email and company match key; flag a re-captured address as a suspected duplicate of the record it repeats.',\n  handler: async (ctx: HookContext) => {\n    const { event, input } = ctx;\n\n    // A duplicate cluster larger than this is pathological; every member points\n    // at the same origin either way, so the scan is bounded rather than paged.\n    const SCAN_LIMIT = 50;\n\n    /** Absent, null or whitespace \u2014 the shape `isBlank` tests in CEL. */\n    const isBlank = (value: unknown): boolean =>\n      value === undefined || value === null || (typeof value === 'string' && value.trim() === '');\n\n    // 1. Canonical email. `input.email` is absent on a partial update; leave it\n    //    alone then rather than writing an empty string over a real address.\n    if (typeof input.email === 'string') {\n      input.email = input.email.trim().toLowerCase();\n    }\n    const email = typeof input.email === 'string' ? input.email : '';\n\n    // 1b. Canonical COMPANY, into its own column (#626). Same doctrine as the\n    //     email above \u2014 the canonical form is established by the producer at\n    //     write time \u2014 but it cannot be done in place: `company` is the display\n    //     value and is copied verbatim onto the account `lead_conversion`\n    //     creates, so folding it would ship \"acme corp\" as the account name.\n    //     `crm_account.name_normalized` is the other half of the pair; the flow\n    //     compares the two columns because it can compute neither\n    //     (`resolveToken` knows only `NOW()` / `TODAY()`).\n    //\n    //     Runs before the insert-only early return below, so an edit that\n    //     rewrites `company` re-folds the key instead of leaving a stale one.\n    //     Absent key \u21D2 untouched: a partial update that never mentions\n    //     `company` must not blank the match key.\n    if ('company' in input) {\n      const rawCompany = input.company;\n      const normalizedCompany =\n        typeof rawCompany === 'string'\n          ? rawCompany.trim().toLowerCase().replace(/\\s+/g, ' ')\n          : '';\n      input.company_normalized = normalizedCompany === '' ? null : normalizedCompany;\n    }\n\n    // 1c. Retire a duplicate claim once the record it named is gone.\n    //\n    //     \u26A0\uFE0F Platform constraint. `duplicate_of_type` is a DISCRIMINATOR, and\n    //     `lead.object.ts` pairs it with the lookup it names through\n    //     `requiredWhen` \u2014 so \"the type is set\" and \"that lookup is populated\"\n    //     are ONE fact stated in two columns. Neither lookup declares a\n    //     `deleteBehavior`, so both take the spec default `set_null`, and the\n    //     engine implements `set_null` by UPDATING the row that HOLDS the\n    //     lookup. Deleting the contact (or lead) a lead was flagged against\n    //     therefore arrives here as `{ id, duplicate_of_<x>: null, \u2026 }`, nulls\n    //     one half of the pair, and the row instantly breaks its own rule \u2014 so\n    //     the whole delete rolls back with `Duplicate Of Contact is required`,\n    //     an error naming a field on an object the caller never addressed.\n    //\n    //     The blast radius is why this matters: the flag is stamped\n    //     automatically at intake on any OPEN lead that merely re-uses a\n    //     contact's email, so an ordinary duplicate makes that CONTACT\n    //     undeletable \u2014 and because `crm_contact.crm_account` is a\n    //     master-detail with `deleteBehavior: 'cascade'`, the ACCOUNT above it\n    //     too. A GDPR \"delete this person\" request with no way to carry it out.\n    //\n    //     The rule restored here is one line: **the discriminator may not\n    //     outlive the lookup it names.** When a write leaves that lookup blank,\n    //     the claim is retired WHOLE \u2014 type and status go with the link \u2014 and\n    //     the lead simply stops saying it duplicates something.\n    //\n    //     \u26A0\uFE0F This is deliberately NOT a second spelling of #720's \"is this write\n    //     the engine's reference cleanup?\" predicate in `lead_automation` above.\n    //     Re-measured on 17.1.0 with a probe hook at priority 199: the engine's\n    //     cleanup write and a user's hand-clear of the same lookup are identical\n    //     in everything this block could read \u2014 identical `input`\n    //     (`{ id, <link>: null, updated_at, updated_by }`), identical\n    //     `ctx.user`, identical `ctx.session` \u2014 because the engine builds the\n    //     cleanup on the CALLER's own context. They are not indistinguishable\n    //     outright, though: a marker is reachable at\n    //     `ctx.api.executionContext.__referentialFieldClear`, `true` on the\n    //     cascade and `undefined` on the hand-clear. The #1165 ruling of\n    //     2026-08-25 upheld NOT reading it \u2014 an operation-private key is an\n    //     undeclared dependency, and a hook body in QuickJS can be handed an\n    //     api shim with no `executionContext` at all (#1412; the declared\n    //     replacement is asked for as objectstack-ai/objectstack#13644).\n    //     None of which changes this block, and that is the point: asking \"is\n    //     the pair still whole?\" needs no provenance at all, and answers both\n    //     callers the same correct way \u2014 a lead whose link you removed no\n    //     longer duplicates anything, however the removal was spelled.\n    //\n    //     It does NOT loosen the pairing, which is the thing to check when\n    //     reading this: a write that STATES a type without naming a record is\n    //     still refused by `requiredWhen`, on insert and on update. That is what\n    //     the `restated` guard below protects \u2014 a payload carrying its own\n    //     non-blank `duplicate_of_type` is an author's claim, so it is left for\n    //     the rule to judge instead of being quietly deleted.\n    //\n    //     \u26A0\uFE0F Priority 300 is load-bearing here, not just for job 2:\n    //     `lead_automation` (200) must see the CALLER's payload before these two\n    //     nulls are added to it. Its reference-cleanup yield passes a write only\n    //     when every non-system change is a declared LOOKUP going value\u2192null,\n    //     and `duplicate_of_type` / `duplicate_status` are neither \u2014 so at a\n    //     lower priority this block would make the converted-lead lock refuse\n    //     the very cleanup that yield exists to allow.\n    // D3 stand-down on the predicate path \u2014 the `email` / `company_normalized`\n    // normalisation above reads only the payload, so it is batch-scoped by\n    // construction and keeps running. This block is not: see `forecast.hook.ts`.\n    if (event === 'beforeUpdate' && ctx.dispatch?.mode !== 'per-row') {\n      const previous = ctx.previous;\n      const LINK_OF_TYPE: Record<string, string> = {\n        crm_lead: 'duplicate_of_lead',\n        crm_contact: 'duplicate_of_contact',\n      };\n      const restated = 'duplicate_of_type' in input && !isBlank(input.duplicate_of_type);\n      const declared = previous?.duplicate_of_type;\n      const link = typeof declared === 'string' ? LINK_OF_TYPE[declared] : undefined;\n      if (!restated && link && link in input && isBlank(input[link])) {\n        // Two outcomes, and which applies turns on ONE question: did a human\n        // ever look at these two records and agree? `duplicate_status` already\n        // records exactly that, so the question is answered from the record's\n        // own vocabulary rather than from a second rule restated here.\n        //\n        //   `confirmed` \u2014 a person compared the two records and said yes. The\n        //     record it named is gone, but the VERDICT is about what the\n        //     reviewer found, not about the pointer. So the claim is\n        //     TOMBSTONED: the discriminator moves to `erased` and the status\n        //     stands, and the lead goes on saying \"confirmed duplicate of a\n        //     record that has since been erased\".\n        //\n        //   anything else \u2014 the machine's `suspected` guess, or no opinion at\n        //     all. Retired WHOLE; there is no human verdict to preserve.\n        //\n        // \u26A0\uFE0F `'erased'` is spelled INLINE on purpose. L2 hook bodies run\n        // body-only in the QuickJS sandbox, so `DUPLICATE_OF_TYPE_ERASED` from\n        // `_picklists.ts` would resolve at authoring time and arrive as\n        // `undefined`. The canonical constant is the one in `_picklists.ts`;\n        // `test/lead-duplicate-management.test.ts` pins this literal to it and\n        // pins this block as its only writer, so the two cannot drift.\n        //\n        // The verdict is read from `previous`, and the write must be SILENT\n        // about it \u2014 `'duplicate_status' in input` disqualifies the tombstone.\n        // That keeps the tombstone on the erasure path and off every other one:\n        // the engine's `set_null` cleanup never mentions the status, while a\n        // caller that DOES mention it is managing the claim by hand, and a\n        // hand-blanked pointer is not an erasure. It also means no payload can\n        // manufacture a tombstone by supplying its own `confirmed`.\n        if (!('duplicate_status' in input) && previous?.duplicate_status === 'confirmed') {\n          input.duplicate_of_type = 'erased';\n          // `duplicate_status` deliberately UNTOUCHED \u2014 it stays `confirmed`,\n          // which is what keeps the surviving state readable as a verdict.\n        } else {\n          input.duplicate_of_type = null;\n          // `duplicate_status` goes with it. Its readers in this app are the\n          // `suspected_duplicates` review queue (`src/sales/views/lead.view.ts`),\n          // whose whole workflow is \"open the two records and compare them\";\n          // the `duplicate_disqualification_requires_survivor` validation,\n          // which demands a NAMED survivor; the duplicate form block; and this\n          // hook's own insert-time stand-down, which reads the payload and\n          // never the stored row. With no link left, none of them can act on\n          // `suspected`, and leaving it would park a permanently unworkable row\n          // in that queue. The verdict is not lost: `duplicate_status` declares\n          // `trackHistory: true`, so who decided what, and when, stays on the\n          // record's field history.\n          input.duplicate_status = null;\n        }\n      }\n    }\n\n    if (event !== 'beforeInsert' || !email) return;\n\n    // 2. Never overwrite an opinion the record already carries. The\n    //    `duplicate_status` half is the load-bearing one: it is what keeps a\n    //    human's `confirmed` verdict safe from any later automatic write.\n    if (!isBlank(input.duplicate_status) || !isBlank(input.duplicate_of_type)) return;\n\n    const api = ctx.api as HookApi | undefined;\n    if (!api) return;\n\n    /** Oldest row wins; an undated row only wins if nothing dated is present. */\n    const original = (rows: Array<Record<string, unknown>>): string | undefined => {\n      let best: string | undefined;\n      let bestKey = Infinity;\n      for (const row of rows) {\n        const id = typeof row.id === 'string' ? row.id : '';\n        if (!id) continue;\n        const raw = row.created_at;\n        const parsed =\n          typeof raw === 'string' || typeof raw === 'number' || raw instanceof Date\n            ? new Date(raw as string).getTime()\n            : Number.NaN;\n        const key = Number.isFinite(parsed) ? parsed : Infinity;\n        if (best === undefined || key < bestKey) {\n          best = id;\n          bestKey = key;\n        }\n      }\n      return best;\n    };\n\n    // Best-effort ENHANCEMENT, never a gate on the write \u2014 identical to\n    // `lead_auto_assign` above. An anonymous Web-to-Lead submission runs under\n    // the `guest_portal` grant, which is INSERT-only on `crm_lead` and denies\n    // reads outright; letting that denial propagate would reject the very\n    // submission this feature exists to accept. A guest's duplicate therefore\n    // lands unflagged rather than not landing at all.\n    try {\n      const contacts = await api.object('crm_contact').find({\n        where: { email },\n        fields: ['id', 'created_at'],\n        top: SCAN_LIMIT,\n      });\n      const contactId = original(contacts ?? []);\n      if (contactId) {\n        input.duplicate_of_type = 'crm_contact';\n        input.duplicate_of_contact = contactId;\n        input.duplicate_status = 'suspected';\n        return;\n      }\n\n      // Open leads only. A predecessor that already converted is represented by\n      // the contact it created, which the branch above matches on the same\n      // address \u2014 pointing at the locked lead instead would name a record\n      // nobody can work.\n      const leads = await api.object('crm_lead').find({\n        where: { email, is_converted: false },\n        fields: ['id', 'created_at'],\n        top: SCAN_LIMIT,\n      });\n      const leadId = original(leads ?? []);\n      if (leadId) {\n        input.duplicate_of_type = 'crm_lead';\n        input.duplicate_of_lead = leadId;\n        input.duplicate_status = 'suspected';\n      }\n    } catch {\n      // Swallow: see above. (No `console` in the L2 hook sandbox.)\n    }\n  },\n};\n\nexport default [leadAutoAssignHook, leadHook, leadDuplicateCheckHook];\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/sales/objects/lead.campaign-metrics.hook.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/sales/objects\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/sales/objects/lead.campaign-metrics.hook.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport type { Hook, HookContext } from '@objectstack/spec/data';\nimport type { HookApi } from './_hook-api';\n\n/**\n * Campaign metric refresh, triggered by a LEAD conversion.\n *\n * Attached to `crm_lead`, which the sales package owns, so it lives here\n * beside that object rather than with the campaign metadata it maintains\n * (plan item 6: a hook sits beside its object, which is what enforces R4).\n * Its three siblings: `campaign_validation` and `campaign_metrics_refresh` on\n * `crm_campaign` in `src/marketing/objects/campaign.hook.ts`, and\n * `campaign_attribution_refresh` on `crm_opportunity` next door in\n * `opportunity.campaign-metrics.hook.ts`.\n *\n * \u26A0\uFE0F WHY THE RECOMPUTE IS WRITTEN OUT FOUR TIMES.\n *\n * L2 hook bodies are lowered to metadata and evaluated BODY-ONLY in the QuickJS\n * sandbox: a handler cannot reach module scope at runtime, so a shared\n * `refreshCampaignMetrics()` import would be a free identifier \u2014 the CLI build\n * silently declines to lower the handler, keeps it in a bundled runtime file,\n * and the hook stops being deployable as pure metadata (the build says so in\n * one line nobody reads). `test/action-sandbox.test.ts` is what catches it.\n *\n * So the arithmetic is inlined per handler. The duplication is NOT trusted:\n * `test/campaign-member-lifecycle.test.ts` lowers all four bodies and asserts\n * the recompute block is character-identical across them, so a fix landing on\n * one copy and skipping three fails a test instead of shipping four definitions\n * of `num_sent`. Splitting the four across three files by owning object changed\n * none of that \u2014 the suite reads them by hook name, not by file.\n */\n\n/**\n * Promote the member rows of a converting lead, then recompute.\n *\n * This hook is `converted`'s ONLY writer, and without it that status option\n * would be exactly the kind of inert vocabulary #597 removed the tracker states\n * for \u2014 a value the picklist offers, the ROI surfaces segment by, and nothing\n * produces. Conversion is the one campaign outcome the app can observe by\n * itself: `crm_lead.is_converted` flips (the `lead_conversion` flow, or the\n * convert action), and every campaign that lead was enrolled in has just\n * recorded a conversion.\n *\n * Only members still `sent` or `responded` are promoted. An `unsubscribed`\n * member is NOT: that person asked to be left alone, and overwriting their\n * opt-out state with a marketing outcome is precisely the kind of quiet rewrite\n * `campaign_member_optout_sync` exists to prevent.\n *\n * `num_converted_leads` also counts `crm_lead.is_converted` across the\n * membership, so this same event is the metric's trigger \u2014 a lead can sit in\n * several campaigns and every one of them is refreshed.\n *\n * `runAs: 'system'` (#2014, AGENTS.md rule 9). Conversions are a rep's act,\n * and a rep may edit neither campaign members nor campaigns, so the promotion\n * was refused, logged and swallowed: the lead converted and its memberships\n * stayed where they were. The promotion and the recompute are marketing's\n * record of the outcome, not the rep's write, so the hook elevates; the lead\n * write stays the caller's. Organization (rule 10): every read is keyed to the\n * triggering lead's own memberships and their campaigns, and the elevated\n * `ctx.api` keeps the trigger's tenant.\n */\nconst campaignLeadConversionRefresh: Hook = {\n  name: 'campaign_lead_conversion_refresh',\n  object: 'crm_lead',\n  events: ['afterUpdate'],\n  priority: 810,\n  async: true,\n  onError: 'log',\n  runAs: 'system',\n  description: 'Promote campaign members of a converting lead and recompute campaign metrics.',\n  handler: async (ctx: HookContext) => {\n    const api = ctx.api as HookApi | undefined;\n    if (!api) return;\n    const { input } = ctx;\n    const previous = ctx.previous;\n    if (input?.is_converted !== true) return;\n    if (previous?.is_converted === true) return;\n    const leadId =\n      (typeof input?.id === 'string' && input.id) ||\n      (typeof previous?.id === 'string' ? (previous.id as string) : '');\n    if (!leadId) return;\n    // `id` is projected because the promotion below updates each row by it:\n    // the SQL datasource returns exactly the columns a read names (#2018).\n    const memberships = await api.object('crm_campaign_member').find({\n      where: { crm_lead: leadId }, fields: ['id', 'crm_campaign', 'status'], top: 500,\n    });\n    for (const m of memberships) {\n      const memberId = typeof m.id === 'string' ? m.id : '';\n      if (!memberId) continue;\n      if (m.status !== 'sent' && m.status !== 'responded') continue;\n      await api.object('crm_campaign_member').update(\n        { id: memberId, status: 'converted' },\n        { where: { id: memberId } },\n      );\n    }\n    const campaignIds = Array.from(new Set(\n      memberships.map((m) => (typeof m.crm_campaign === 'string' ? m.crm_campaign : '')).filter(Boolean),\n    ));\n    for (const id of campaignIds) {\n      // \u2500\u2500 recompute \u2500\u2500 identical in all four refresh hooks; see the header.\n      const memberRows = await api.object('crm_campaign_member').find({\n        where: { crm_campaign: id }, fields: ['crm_lead', 'status'], top: 5000,\n      });\n      const leadIds = Array.from(new Set(\n        memberRows.map((r) => (typeof r.crm_lead === 'string' ? r.crm_lead : '')).filter(Boolean),\n      ));\n      const convertedLeads = leadIds.length > 0\n        ? await api.object('crm_lead').count({ where: { id: { $in: leadIds }, is_converted: true } })\n        : 0;\n      const numOpportunities = await api.object('crm_opportunity').count({ where: { crm_campaign: id } });\n      const numWon = await api.object('crm_opportunity').count({ where: { crm_campaign: id, stage: 'closed_won' } });\n      const wonRows = await api.object('crm_opportunity').find({\n        where: { crm_campaign: id, stage: 'closed_won' }, fields: ['amount'], top: 5000,\n      });\n      const actualRevenue = wonRows.reduce(\n        (sum, row) => sum + (typeof row.amount === 'number' ? row.amount : Number(row.amount) || 0), 0,\n      );\n      await api.object('crm_campaign').update({\n        id,\n        num_sent: memberRows.length,\n        num_responses: memberRows.filter((r) => r.status === 'responded' || r.status === 'converted').length,\n        num_leads: leadIds.length,\n        num_converted_leads: convertedLeads,\n        num_opportunities: numOpportunities,\n        num_won_opportunities: numWon,\n        actual_revenue: actualRevenue,\n      }, { where: { id } });\n      // \u2500\u2500 /recompute \u2500\u2500\n    }\n  },\n};\n\nexport default [campaignLeadConversionRefresh];\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/sales/objects/opportunity.hook.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/sales/objects\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/sales/objects/opportunity.hook.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport type { Hook, HookContext } from '@objectstack/spec/data';\nimport type { HookApi } from './_hook-api';\n\n/**\n * Opportunity lifecycle hook.\n *\n * - Re-derives `expected_revenue` from `amount * stageProbability` when either changes.\n * - Stamps `stage_entry_date` on insert and on every stage change \u2014 the stored\n *   clock behind the `days_in_stage` formula and the stagnation sweep (#489).\n * - Freezes most fields after stage is closed (won/lost) \u2014 only narrative fields\n *   editable. The freeze yields to the engine's reference cleanup, so a closed\n *   deal never makes the records it points at undeletable (#720).\n * - On `closed_won`: stamps `close_date=today`, promotes the parent account to `customer`,\n *   and asynchronously schedules an \"Activate customer\" task.\n */\n\nconst opportunityValidationHook: Hook = {\n  name: 'opportunity_lifecycle',\n  object: 'crm_opportunity',\n  events: ['beforeInsert', 'beforeUpdate'],\n  priority: 200,\n  description:\n    'Recompute expected_revenue, freeze closed opportunities except narrative fields.',\n  handler: async (ctx: HookContext) => {\n    // The refusal envelope (#1075). Mirrored from `./_refusal.ts` because a\n    // lowered body has no module scope and `extractHookBody` THROWS on an\n    // import; `test/refusal-envelope.test.ts` pins every copy against it.\n    function refuse(\n      message: string,\n      code: string,\n      status: number,\n      userMessage: string = message,\n    ): Error {\n      const err = new Error(message) as Error & {\n        code: string;\n        status: number;\n        userMessage: string;\n      };\n      err.code = code;\n      err.status = status;\n      err.userMessage = userMessage;\n      return err;\n    }\n    // NOTE: L2 hook bodies run *body-only* in a sandbox (QuickJS) \u2014 module-level\n    // constants are NOT in scope at runtime. These MUST be declared inside the\n    // handler or the body throws `ReferenceError` on every write. (See ADR on\n    // sandboxed hooks; same pattern as lead.hook.ts.)\n    const STAGE_PROBABILITY: Record<string, number> = {\n      prospecting: 10,\n      qualification: 25,\n      needs_analysis: 40,\n      proposal: 60,\n      negotiation: 80,\n      closed_won: 100,\n      closed_lost: 0,\n    };\n    const NARRATIVE_FIELDS = new Set(['description', 'next_step', 'notes']);\n    // Framework-managed columns are re-stamped by the runtime itself (ownership\n    // reassignment, audit timestamps) \u2014 including during post-seed ownership\n    // assignment introduced in ObjectStack 9.x. The \"freeze closed record\" guard\n    // must never reject these system writes, only user edits to business fields.\n    // (Declared in-handler: sandboxed bodies have no module scope.)\n    const SYSTEM_FIELDS = new Set([\n      'id', 'owner_id', 'created_at', 'updated_at',\n      'created_by', 'updated_by', 'space_id', 'organization_id', 'org_id', 'version',\n    ]);\n    // Approval verdicts must be allowed to land even if the deal closes while\n    // the request is in flight \u2014 rejecting them left the record locked with a\n    // permanently pending approval.\n    //\n    // \u26A0\uFE0F Why this exemption is still needed even though `opportunity_approval`\n    // declares `runAs: 'system'`, and why that is not a contradiction:\n    // ELEVATION IS NOT ANONYMITY (objectstack#5494). `resolveRunDataContext`\n    // returns `{ isSystem: true, actor, ...userId }` for a `runAs: 'system'`\n    // run \u2014 it carries the triggering user through rather than erasing them.\n    // So ONE approval write is seen by TWO guards keyed on DIFFERENT halves of\n    // that context, and both fire as designed:\n    //   \u2022 this freeze guard keys on `ctx.user?.id`, which is PRESENT \u21D2 the\n    //     write is judged as a user edit and would be rejected on a closed\n    //     deal \u2014 hence this allow-list.\n    //   \u2022 the engine's readonly strip keys on `isSystem`, which is TRUE \u21D2 the\n    //     strip branch (`if (!opCtx.context?.isSystem)`) is skipped, so the\n    //     stamps land even though both columns are declared `readonly: true`\n    //     (#1666).\n    // \u26D4 Neither mechanism needs changing, and neither is a substitute for the\n    // other: dropping this allow-list re-locks in-flight approvals, and the\n    // readonly declaration is what keeps a hand-edit out. Measured in\n    // `test/readonly-write-semantics.test.ts` and pinned for these two columns\n    // in `test/audit-stamp-readonly.test.ts`.\n    // `status_change_approval_status` and `requested_status` join the\n    // allow-list for the same reason and by the same mechanism: the REQ-0006\n    // gate's flow stamps its verdict and clears the request AFTER the deal has\n    // reached a closed stage, and elevation is not anonymity \u2014 the freeze\n    // guard below would judge those writes as user edits on a closed record\n    // and re-lock an in-flight approval.\n    // `qualification_approval_status` and `qualification_requested` (the\n    // REQ-0006 step-11 \u7ACB\u9879 gate) join for the same reason and by the same\n    // mechanism. Their flow stamps the verdict, and on a rejection clears the\n    // request, under the triggering user; a deal a write this hook does not\n    // judge (a system write, no user) closed while the \u7ACB\u9879 request was open\n    // would otherwise refuse that stamp and leave the approval decided but\n    // never recorded.\n    const APPROVAL_FIELDS = new Set([\n      'approval_status', 'approved_date',\n      'status_change_approval_status', 'requested_status',\n      'qualification_approval_status', 'qualification_requested',\n    ]);\n    // Stage \u2192 forecast category.\n    const STAGE_FORECAST: Record<string, string> = {\n      prospecting: 'pipeline',\n      qualification: 'pipeline',\n      needs_analysis: 'best_case',\n      proposal: 'commit',\n      negotiation: 'commit',\n      closed_won: 'closed',\n      closed_lost: 'omitted',\n    };\n\n    const { event, input } = ctx;\n    const previous = ctx.previous;\n\n    // \u2500\u2500\u2500 \u7ACB\u9879 (qualification) gate (REQ-0006 step 11) \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n    //\n    // \u300C\u65B0\u589E\u5546\u673A\u53EF\u8DDF\u8FDB\uFF0C\u7ACB\u9879\u901A\u8FC7\u540E\u65B9\u53EF\u66F4\u65B0\u9636\u6BB5\u3001\u6295\u6807\u3001\u8D62\u4E22\u5355\u64CD\u4F5C\u3002\u300D Until \u7ACB\u9879 is\n    // approved, two acts are refused and every other edit stays open:\n    //   \u2022 any change of `stage` \u2014 \u66F4\u65B0\u9636\u6BB5, which includes a direct close\n    //     (\u8D62\u4E22\u5355);\n    //   \u2022 a NEW `requested_status` \u2014 the won/lost request (\u8D62\u4E22\u5355) the step-14\n    //     gate opens. So with both gates armed \u7ACB\u9879 comes FIRST: an unqualified\n    //     deal cannot even ask for a status change.\n    // `will_bid` (\u662F\u5426\u6295\u6807) is deliberately NOT held (#2004, ruled): step 8 has\n    // the rep fill it as INPUT to \u7ACB\u9879, for the approver to read, so holding it\n    // until approval would have the approver decide without it. Step 11's \u6295\u6807\n    // is the act of bidding, which HotCRM does not model.\n    // Built on the step-14 gate below and deliberately the same in every\n    // load-bearing term:\n    //   \u2022 a TRANSITION GATE, not an invariant (AGENTS.md metadata semantics\n    //     rule 7) \u2014 inert unless the install arms it, since\n    //     `qualification_approval_status` ships `not_required`;\n    //   \u2022 the verdict is read INPUT-FIRST, so a write that carries the\n    //     approved verdict is judged as approved. This gate's own flow writes\n    //     only the verdict (and on a rejection the request), so it never needs\n    //     that; it keeps the sibling's reading, and a hand-supplied verdict is\n    //     stripped before this hook runs (see the field);\n    //   \u2022 `rejected` refuses as `pending` does \u2014 an approver's \"no\" is not a\n    //     release; the way on is a new request;\n    //   \u2022 USER writes only (`ctx.user?.id`), the boundary both other guards in\n    //     this hook draw;\n    //   \u2022 RECORD_LOCKED / 409 (`REFUSAL_CODES.locked`).\n    // It sits ABOVE the step-14 block so an unqualified deal's direct close\n    // names the gate that comes first.\n    //\n    // \u26A0\uFE0F BOUNDARY, recorded rather than hidden: `beforeInsert` is not judged.\n    // Creating a deal is \u65B0\u589E\u5546\u673A, which step 11 leaves open (step 8 has the rep\n    // fill \u662F\u5426\u6295\u6807 on the new-deal form) \u2014 the line the step-14 gate draws too.\n    if (event === 'beforeUpdate' && previous && ctx.user?.id) {\n      const qualification = (input.qualification_approval_status ?? previous.qualification_approval_status) as string | undefined;\n      if (qualification === 'pending' || qualification === 'rejected') {\n        const held: string[] = [];\n        if (typeof input.stage === 'string' && input.stage !== previous.stage) held.push('Stage');\n        if (typeof input.requested_status === 'string' && input.requested_status !== '' && input.requested_status !== previous.requested_status) {\n          held.push('Requested Status');\n        }\n        if (held.length > 0) {\n          throw refuse(\n            `This deal needs qualification approval first: tick Request Qualification Approval. ${held.join(' and ')} can change once it is approved.`,\n            'RECORD_LOCKED',\n            409,\n          );\n        }\n      }\n    }\n\n    // \u2500\u2500\u2500 Status-change gate (REQ-0006 steps 13-14) \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n    //\n    // A TRANSITION GATE, not an invariant (AGENTS.md metadata semantics rule\n    // 7): it refuses the next move, and every deal already sitting in a closed\n    // stage keeps it. Inert unless the install arms the gate \u2014 shipped,\n    // `status_change_approval_status` defaults to `not_required` and this\n    // condition is false for every record that has ever existed, which is what\n    // keeps REQ-0006 acceptance 3's \"bit-for-bit what it is today\" true.\n    //\n    // \u26A0\uFE0F The gate value is read INPUT-FIRST, and that is load-bearing. The\n    // approving flow writes `stage` and `status_change_approval_status:\n    // 'approved'` in ONE payload; reading `previous` first would see `pending`\n    // and refuse the flow's own write. `runAs: 'system'` does not help \u2014\n    // elevation is not anonymity, so `ctx.user?.id` is present in that run\n    // exactly as the APPROVAL_FIELDS note above records.\n    //\n    // \u26A0\uFE0F `rejected` refuses too, exactly as `lead_automation` refuses a\n    // conversion in both `pending` and `rejected`. An approver's \"no\" is not a\n    // release: if only `pending` refused, a single rejection would disarm the\n    // gate on that deal for good, and the rep could then close it directly with\n    // no approval at all. From `rejected` the way forward is a NEW request \u2014 the\n    // flow's start condition re-opens on it \u2014 never a direct stage write.\n    //\n    // RECORD_LOCKED / 409 (`REFUSAL_CODES.locked`): while the gate holds, the\n    // deal's own state freezes `stage` against a move into a closed stage \u2014 the\n    // same class the lead sibling answers with.\n    if (event === 'beforeUpdate' && previous && ctx.user?.id) {\n      const gate = (input.status_change_approval_status ?? previous.status_change_approval_status) as string | undefined;\n      const next = input.stage as string | undefined;\n      const closing = (next === 'closed_won' || next === 'closed_lost') && next !== previous.stage;\n      if (closing && (gate === 'pending' || gate === 'rejected')) {\n        throw refuse(\n          'This deal\\'s status change needs approval: set Requested Status (and the win/loss reason) instead. The stage takes effect when the request is approved.',\n          'RECORD_LOCKED',\n          409,\n        );\n      }\n    }\n\n    // Freeze closed opportunities \u2014 but guard ONLY genuine USER edits. A write\n    // with no authenticated user (`ctx.user?.id` absent) is a system / seed /\n    // backfill write and must pass: the seed's `close_date: daysAgo(15)`\n    // re-evaluates to a new date on every reboot, so a re-seed legitimately\n    // changes close_date on already-closed opps. Guarding those threw 23\n    // boot-time BodyRunner errors AND blocked the seed from correcting\n    // closed-won `probability` to 100 (#459). `ctx.user?.id` is this repo's\n    // system-write signal (cf. case/lead/quote hooks) and matches the\n    // SYSTEM_FIELDS intent above (\"only user edits to business fields\").\n    // Still runs before the derived-field recompute below so a genuine user\n    // edit is judged on the caller's own fields, not injected ones.\n    if (event === 'beforeUpdate' && previous && ctx.user?.id) {\n      const prevStage = previous.stage as string | undefined;\n      const isClosed = prevStage === 'closed_won' || prevStage === 'closed_lost';\n      if (isClosed) {\n        const violating = Object.keys(input).filter(\n          (k) => !NARRATIVE_FIELDS.has(k) && !SYSTEM_FIELDS.has(k) && !APPROVAL_FIELDS.has(k) && input[k] !== previous[k],\n        );\n        if (violating.length > 0) {\n          // Every lookup on `crm_opportunity` a referential clear can attack.\n          const REFERENCE_FIELDS = new Set(['crm_account', 'primary_contact', 'crm_campaign']);\n          // \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500 the reference-cleanup yield \u2500\u2500\n          // #720. The engine implements `deleteBehavior: 'set_null'` by UPDATING\n          // the row that HOLDS the lookup, so deleting a contact or a campaign a\n          // CLOSED opportunity references arrives here as an ordinary user\n          // `beforeUpdate` \u2014 and this freeze refused it, which made the frozen\n          // opportunity able to keep a person undeletable forever (and, through\n          // the master-detail cascade, that person's account too \u2014 a GDPR\n          // erasure that cannot be carried out).\n          //\n          // Measured on 17.1.0 \u2014 the version this repo pinned AT THE TIME of\n          // the measurement, not the current pin (the cascade shape below has\n          // NOT been re-measured on any later pin \u2014 not 17.3.0, #1676, not\n          // 17.4.0, PR #1814, and not 17.5.0) \u2014 with a probe hook at priority 199 immediately\n          // ahead of each guard, not assumed.\n          // The engine builds its cleanup write on the CALLER's own context\n          // plus two engine keys, so on the path a REST `DELETE` takes, the\n          // cascade and a user's hand-clear of the same lookup are identical\n          // everywhere a guard can look: payload\n          // `{ id, <link>: null, updated_at, updated_by }`, `ctx.user` the\n          // CALLER, `ctx.session` the caller's own `{ userId, isSystem }`.\n          // (Both `updated_by` and the identity drop out together when the\n          // DELETE itself carried no `userId` \u2014 a rig artefact, not this app's\n          // path.) So the WRITE SHAPE is not a discriminator, and the yield\n          // below is not one either: it lets ANY caller clear a declared link\n          // on a settled record. That is the trade #720 accepted, not a side\n          // effect of it.\n          //\n          // \u26A0\uFE0F A marker DOES reach a hook \u2014 and is deliberately not read. An\n          // earlier version of this note concluded \"no marker reaches a hook,\n          // and the WRITE SHAPE is the only evidence there is\"; it reasoned\n          // only about `ctx.session`, whose allow-list really does omit\n          // `__`-prefixed operation-private keys, and missed the other route\n          // into the context. `ObjectQL.cascadeDeleteRelations` builds\n          // `{ ...context, __referentialFieldClear: true }`, readable at\n          // `ctx.api.executionContext.__referentialFieldClear`: measured `true`\n          // on every cascade into `crm_opportunity`, `crm_quote` and\n          // `crm_lead`, `undefined` on every hand-clear (#1165, #1412).\n          //\n          // \u26D4 The #1165 ruling (2026-08-25) reviewed that and upheld NOT\n          // reading it, on two grounds. It is an operation-private key \u2014 an\n          // undeclared dependency that can vanish in a patch release. And\n          // reachability through the SHIPPED path is unproven: a hook body runs\n          // body-only in QuickJS, where `buildSandboxApi` passes `engineCtx.api`\n          // only when that exposes `object()`, and otherwise a shim with no\n          // `executionContext` at all. Green in a kernel rig and silently false\n          // in production is the worst outcome a guard can have. The declared\n          // replacement `ctx.referentialFieldClear` is asked for upstream as\n          // objectstack-ai/objectstack#13644.\n          //\n          // \u26D4 Keep this narrow (maintainer's ruling on #720, Option A): a write\n          // yields ONLY when every one of its non-system changes is a DECLARED\n          // link going from a value to `null`. One business field alongside it,\n          // or a link repointed to a NEW value, and the refusal below still\n          // fires. The three freeze guards share this block verbatim \u2014 sharing\n          // it as an imported helper is not possible (hook bodies run body-only\n          // in the sandbox and cannot reach module scope), so\n          // `test/freeze-guard-reference-cleanup.test.ts` pins the three copies\n          // as identical text and pins both directions of the narrowness.\n          const isReferenceCleanup = violating.every(\n            (k) => REFERENCE_FIELDS.has(k) && input[k] === null && previous?.[k] != null,\n          );\n          if (isReferenceCleanup) return;\n\n          // `crm_opportunity.nameField` IS `name`, so the name on its own is\n          // exactly how every other surface titles this record. \u26D4 Never append\n          // the record id \u2014 it matches none of them.\n          const name = typeof previous.name === 'string' ? previous.name.trim() : '';\n          const subject = name ? `Opportunity ${name}` : 'Opportunity';\n          throw refuse(\n            `${subject} is closed (${prevStage}); only ${[...NARRATIVE_FIELDS].join(', ')} may be edited. Attempted: ${violating.join(', ')}.`,\n            'RECORD_LOCKED',\n            409,\n          );\n        }\n      }\n    }\n\n    // D3 stand-down: a predicate update has ONE payload for every matched row,\n    // so the `ctx.previous`-conditioned recomputes below would land on rows that\n    // did not earn them \u2014 refused as a diverging key set, or stored silently\n    // from the last row. Full account and the measurement: `forecast.hook.ts`.\n    // The closed-record REFUSAL above deliberately sits before this line:\n    // reading `previous` to throw is what D3 supplies it for, and a batch that\n    // touches a closed deal must still be refused.\n    if (ctx.event === 'beforeUpdate' && ctx.dispatch?.mode === 'per-row') return;\n\n    // Recompute expected_revenue\n    const amount =\n      typeof input.amount === 'number'\n        ? input.amount\n        : typeof previous?.amount === 'number'\n          ? (previous.amount as number)\n          : undefined;\n    const stage =\n      typeof input.stage === 'string'\n        ? input.stage\n        : typeof previous?.stage === 'string'\n          ? (previous.stage as string)\n          : undefined;\n    if (typeof amount === 'number' && stage && STAGE_PROBABILITY[stage] !== undefined) {\n      input.expected_revenue = Math.round(amount * STAGE_PROBABILITY[stage]) / 100;\n    }\n    if (stage && STAGE_PROBABILITY[stage] !== undefined) {\n      // Always sync probability with stage (single source of truth = stage).\n      input.probability = STAGE_PROBABILITY[stage];\n    }\n    // Sync forecast_category with stage on insert and whenever stage changes.\n    if (stage && STAGE_FORECAST[stage] !== undefined) {\n      const stageChanged = event === 'beforeInsert' || (typeof input.stage === 'string' && input.stage !== previous?.stage);\n      if (stageChanged) input.forecast_category = STAGE_FORECAST[stage];\n    }\n\n    // Start the stage-age clock at creation. Without this the row lands with a\n    // null `stage_entry_date`, `days_in_stage` reads null instead of 0, and the\n    // deal is invisible to the stagnation sweep until its first stage change \u2014\n    // exactly backwards, since a deal that never moves is the stalled one.\n    if (event === 'beforeInsert' && !input.stage_entry_date) {\n      input.stage_entry_date = new Date().toISOString().slice(0, 10);\n    }\n\n    if (event === 'beforeUpdate' && previous) {\n      // Stamp close_date when transitioning into closed_won\n      if (input.stage === 'closed_won' && previous.stage !== 'closed_won' && !input.close_date) {\n        input.close_date = new Date().toISOString().slice(0, 10);\n      }\n      // Restart the stage-age clock on any stage change so a deal that\n      // advances stops matching the stagnation sweep. `days_in_stage` is a\n      // formula over this column, so this one write IS the reset \u2014 it used to\n      // set `days_in_stage = 0` against a counter nothing ever incremented.\n      // (Readonly fields are writable from before-hooks via input mutation:\n      // readonly stripping only drops keys the CALLER supplied.)\n      if (typeof input.stage === 'string' && input.stage !== previous.stage) {\n        input.stage_entry_date = new Date().toISOString().slice(0, 10);\n      }\n    }\n  },\n};\n\n/**\n * On close-won: promote the account to `customer` and schedule the activation\n * task for the deal's owner.\n *\n * `runAs: 'system'` (#2014, AGENTS.md rule 9). The trigger is a rep winning\n * their own deal, and the account need not be theirs: as the caller, a read of\n * an account the rep cannot see came back empty and the promotion was skipped\n * without a word (measured: a rep's win on an account another user owns left\n * it a `prospect`). That an account has a won deal is the account's fact, not\n * the rep's edit, so the hook elevates; the deal write stays the caller's.\n * Elevation is not anonymity: `ctx.user` and the audit stamps still name the\n * rep. Organization (rule 10): it reads and writes only the account the\n * triggering deal names, and the elevated `ctx.api` keeps the trigger's tenant.\n */\nconst opportunityWonHook: Hook = {\n  name: 'opportunity_promote_account',\n  object: 'crm_opportunity',\n  events: ['afterUpdate'],\n  priority: 800,\n  async: true,\n  onError: 'log',\n  runAs: 'system',\n  description:\n    'On closed_won: promote linked account to customer and create activation task.',\n  handler: async (ctx: HookContext) => {\n    const { input } = ctx;\n    const previous = ctx.previous;\n    const becameWon = input.stage === 'closed_won' && previous?.stage !== 'closed_won';\n    if (!becameWon) return;\n    const api = ctx.api as HookApi | undefined;\n    if (!api) return;\n\n    const accountId =\n      (typeof input.crm_account === 'string' && input.crm_account) ||\n      (typeof previous?.crm_account === 'string' && previous.crm_account) ||\n      undefined;\n    if (!accountId) return;\n\n    const account = await api.object('crm_account').findOne({ where: { id: accountId } });\n    if (account && account.type !== 'customer') {\n      await api.object('crm_account').update(\n        { id: accountId, type: 'customer' },\n        { where: { id: accountId } },\n      );\n    }\n\n    const oppId = (typeof input.id === 'string' && input.id) || previous?.id;\n    const ownerId =\n      (typeof input.owner_id === 'string' && input.owner_id) ||\n      (typeof previous?.owner_id === 'string' && previous.owner_id) ||\n      ctx.user?.id;\n    // UTC calendar for the step, matching the `toISOString()` render below \u2014\n    // see the note on the same shape in `lead.hook.ts`. A local `setDate` step\n    // preserves wall-clock time, so across a spring-forward the activation task\n    // is filed a day early in every non-UTC deployment.\n    const due = new Date();\n    due.setUTCDate(due.getUTCDate() + 3);\n\n    // Title the task with the opportunity's NAME (#1243). This is one of the\n    // two rows a walkthrough of current main still writes with a raw key in it,\n    // and it lands in **All Tasks** next to the escalation rows #1208 already\n    // fixed. `crm_opportunity.name` is required + notNull, so the bare fallback\n    // is a shape the schema does not permit rather than an expected case \u2014 it\n    // exists so a pre-image that arrived without the column still produces a\n    // sentence instead of a dangling one. The 255 cap is the same one\n    // `case.hook.ts` documents: `crm_task.subject` enforces it, and this hook is\n    // `async: true` + `onError: 'log'`, so a rejected insert would surface\n    // nowhere at all.\n    const oppName =\n      (typeof input.name === 'string' && input.name.trim()) ||\n      (typeof previous?.name === 'string' && previous.name.trim()) ||\n      '';\n    const titled = oppName\n      ? `Activate new customer for opportunity ${oppName}`\n      : 'Activate new customer';\n    await api.object('crm_task').insert({\n      subject: titled.length > 255 ? `${titled.slice(0, 254)}\u2026` : titled,\n      status: 'not_started',\n      priority: 'high',\n      type: 'follow_up',\n      due_date: due.toISOString().slice(0, 10),\n      owner_id: ownerId,\n      related_to_type: 'crm_opportunity',\n      related_to_opportunity: oppId,\n      related_to_account: accountId,\n    });\n  },\n};\n\n\n/**\n * The capability gate \u2014 an account whose `commercial_capability` is\n * `settlement_only` may not have a NEW opportunity opened against it.\n *\n * REQ-0003's most valuable primitive: *some counterparties are payable but not\n * sellable* \u2014 \u300C\u62DB\u6807\u4EE3\u7406\u53CA\u5176\u4ED6\u7C7B\u5BA2\u6237\u4EC5\u53EF\u7528\u4E8E\u4ED8\u6B3E\u56DE\u6B3E\uFF0C\u65E0\u6CD5\u53D1\u8D77\u5546\u673A\u300D. The category lives on\n * `crm_account`; this is the rule that reads it, and without a reader the\n * category would be prose (REQ-0003 *Disposition & rationale*).\n *\n * ## \u26A0\uFE0F `beforeInsert` ONLY \u2014 a transition gate, not an invariant\n *\n * Maintainer ruling, 2026-09-16 (verbatim, kept untranslated):\n *\n *   \u300C\u95F8\u95E8\u8D70 `opportunity.hook.ts` \u7684 `beforeInsert`\uFF0C\u7528 hook \u7684 `ctx.api` \u8BFB\u5BA2\u6237\u7C7B\u522B\u3002\n *    REQ-0003 \u7B2C 128 \u884C\u7684 `validations[]` \u4E0E\u8BE5\u8BB0\u5F55\u81EA\u5DF1\u7684\u9A8C\u6536\u7B2C 2 \u6761\u51B2\u7A81\uFF0C\u4EE5\u9A8C\u6536\u4E3A\u51C6\u3002\u300D\n *\n * The event list IS the transition gate (AGENTS.md metadata semantics rule 7),\n * and it is the construct rather than a comment claiming the property. An\n * opportunity that already points at an account restricted later is never\n * re-evaluated: it keeps working and keeps being editable, which REQ-0003\n * acceptance 2 demands in as many words. \u26D4 Never restate this as a\n * `validations[]` script \u2014 a validation is evaluated against\n * `{...previous, ...data}` on every write, where \"already linked\" and \"linking\n * now\" are the same state, so it would refuse every later edit to every\n * historical opportunity. The whole measurement, including why a predicate\n * cannot read the account at all, is on `crm_account.commercial_capability`.\n *\n * \u26A0\uFE0F BOUNDARY, recorded rather than hidden: an UPDATE that re-points an\n * EXISTING opportunity onto a restricted account is not refused. That is the\n * ruling's construct and it is also what acceptance 2 asks for \u2014 the refusal is\n * scoped to \"linked to a NEW opportunity\". Widening to `beforeUpdate` is not a\n * free win either: the update payload would have to be judged against\n * `previous` to tell a re-point from an ordinary edit, which is the state\n * confusion this event list exists to avoid. A gate on re-pointing is a\n * separate decision, not a tidy-up.\n *\n * ## Fails OPEN, on purpose\n *\n * Only the one verdict a person wrote down refuses (AGENTS.md metadata\n * semantics rule 8). An account that predates the column, an account that\n * cannot be found, an absent `ctx.api` and an unrecognised value all let the\n * write through: the shipped default is `full`, and an account created before\n * this field existed carries nothing at all \u2014 both must open deals exactly as\n * they did before the gate existed.\n *\n * \u26A0\uFE0F A read that THROWS is not in that list and is deliberately not caught. A\n * broken read is not evidence that the account is sellable; swallowing it\n * would make the gate silently absent exactly when the platform cannot answer.\n *\n * ## `runAs: 'system'`, and a refusal that names no account (#2014)\n *\n * As the caller, the verdict was read under the caller's record access \u2014 and a\n * rep who cannot read the account is not refused that read: record-level\n * access FILTERS it, `findOne` answers `null`, the gate took that for \"cannot\n * be found\" and stood down, and the engine's reference check accepted the link\n * (measured on 17.7.0: an outsider opened a deal on a Settlement Only account\n * they cannot read). Whether an account is sellable is the account's\n * commercial fact, not a privilege of whoever names it, so the gate reads it\n * elevated (AGENTS.md rule 9 \u2014 the read is the one thing elevated; the deal\n * write stays the caller's).\n *\n * What elevation reads must not leak back through the refusal. Maintainer\n * ruling on #2014 (option B): the refusal says \"this account\" and names none \u2014\n * no number, no name, no id \u2014 and states nothing it read beyond the one fact\n * that blocks the deal, the Settlement Only verdict. It supersedes #1243's\n * \"name the account the way the UI does\" on this one path: the caller chose\n * the account on the very form the refusal answers, so the dialog stays clear\n * without echoing an account the caller may not be allowed to read. So the read\n * asks for `commercial_capability` and nothing else.\n *\n * Organization (AGENTS.md rule 10): the read is pinned to the new deal's own\n * `organization_id` when it carries one, so an elevated verdict is never read\n * from another organization's account; a deal with no organization (a\n * single-organization install) has no wall to stay inside, and is not pinned.\n * An account outside the deal's organization then reads as \"cannot be found\"\n * and the gate stands down \u2014 the same answer a person's tenant-scoped read\n * already gives.\n *\n * \u26D4 No system-write exemption, deliberately, and it is the same reading the\n * two approval flows record: a control that engages only for writers carrying a\n * session is not a control, since a `runAs: 'system'` importer would simply\n * bypass it.\n *\n * Priority 150 runs it AHEAD of `opportunity_lifecycle` (200): a refused write\n * should not first pay for the derived-field recompute.\n */\nconst opportunityAccountCapabilityHook: Hook = {\n  name: 'opportunity_account_capability',\n  object: 'crm_opportunity',\n  events: ['beforeInsert'],\n  priority: 150,\n  runAs: 'system',\n  description:\n    'Refuse a NEW opportunity linked to an account whose commercial capability is settlement only.',\n  handler: async (ctx: HookContext) => {\n    // The refusal envelope (#1075). Mirrored from `./_refusal.ts` because a\n    // lowered body has no module scope and `extractHookBody` THROWS on an\n    // import; `test/refusal-envelope.test.ts` pins every copy against it.\n    function refuse(\n      message: string,\n      code: string,\n      status: number,\n      userMessage: string = message,\n    ): Error {\n      const err = new Error(message) as Error & {\n        code: string;\n        status: number;\n        userMessage: string;\n      };\n      err.code = code;\n      err.status = status;\n      err.userMessage = userMessage;\n      return err;\n    }\n    const api = ctx.api as HookApi | undefined;\n    if (!api) return;\n    const accountId = ctx.input.crm_account;\n    if (typeof accountId !== 'string' || accountId === '') return;\n\n    const org = ctx.input.organization_id;\n    const account = await api.object('crm_account').findOne({\n      where: { id: accountId, ...(typeof org === 'string' && org ? { organization_id: org } : {}) },\n      fields: ['commercial_capability'],\n    });\n    if (!account || account.commercial_capability !== 'settlement_only') return;\n\n    // \u26D4 \"this account\", never a number, a name or an id \u2014 see the note above.\n    throw refuse(\n      'Cannot open an opportunity against this account: its Commercial Capability is Settlement Only, so it is available for billing and payment but no new business may be booked against it. Pick a different account, or have the account reclassified to Full first.',\n      'VALIDATION_FAILED',\n      400,\n    );\n  },\n};\n\nexport default [\n  opportunityAccountCapabilityHook,\n  opportunityValidationHook,\n  opportunityWonHook,\n];\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/sales/objects/opportunity.campaign-metrics.hook.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/sales/objects\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/sales/objects/opportunity.campaign-metrics.hook.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport type { Hook, HookContext } from '@objectstack/spec/data';\nimport type { HookApi } from './_hook-api';\n\n/**\n * Campaign metric refresh, triggered by an OPPORTUNITY write.\n *\n * The hook is campaign arithmetic, but it is attached to `crm_opportunity`,\n * which the sales package owns \u2014 and since the ADR-0130 layout a hook lives\n * beside the object it names (plan item 6: R4 is enforced by co-location\n * rather than by reading). Its three siblings: `campaign_validation` and\n * `campaign_metrics_refresh` on `crm_campaign` in\n * `src/marketing/objects/campaign.hook.ts`, and\n * `campaign_lead_conversion_refresh` on `crm_lead` next door in\n * `lead.campaign-metrics.hook.ts`. The membership side of the same recompute\n * is `src/marketing/objects/campaign_member.hook.ts`.\n *\n * \u26A0\uFE0F WHY THE RECOMPUTE IS WRITTEN OUT FOUR TIMES.\n *\n * L2 hook bodies are lowered to metadata and evaluated BODY-ONLY in the QuickJS\n * sandbox: a handler cannot reach module scope at runtime, so a shared\n * `refreshCampaignMetrics()` import would be a free identifier \u2014 the CLI build\n * silently declines to lower the handler, keeps it in a bundled runtime file,\n * and the hook stops being deployable as pure metadata (the build says so in\n * one line nobody reads). `test/action-sandbox.test.ts` is what catches it.\n *\n * So the arithmetic is inlined per handler. The duplication is NOT trusted:\n * `test/campaign-member-lifecycle.test.ts` lowers all four bodies and asserts\n * the recompute block is character-identical across them, so a fix landing on\n * one copy and skipping three fails a test instead of shipping four definitions\n * of `num_sent`. Splitting the four across three files by owning object changed\n * none of that \u2014 the suite reads them by hook name, not by file.\n */\n\n/**\n * Recompute when an opportunity's campaign attribution changes.\n *\n * `num_opportunities`, `num_won_opportunities` and `actual_revenue` derive from\n * opportunities, not from members \u2014 so the membership trigger alone would leave\n * exactly the three metrics `roi` is built on stale. Insert / update / delete,\n * and both sides of a re-attribution (old and new campaign), the same way the\n * line-item rollup handles re-parenting.\n *\n * Declared here rather than in `opportunity.hook.ts` on purpose: it is campaign\n * arithmetic that happens to be triggered by an opportunity write, and the\n * hooks barrel flattens each `*.hook.ts` default export regardless of which\n * object each entry names.\n *\n * `runAs: 'system'` (#2014, AGENTS.md rule 9). The trigger is a sales write \u2014\n * a rep winning their own deal, a manager winning one on a marketing-owned\n * campaign \u2014 and neither may edit the campaign, so the metric write was\n * refused, logged and swallowed: the deal was won and the campaign's revenue\n * stayed 0. The recompute is the campaign's writer, not the rep's, so the\n * hook elevates; the opportunity write stays the caller's. Organization\n * (rule 10): every read is keyed to the triggering deal's campaign (and the\n * leads its members name), and the elevated `ctx.api` keeps the trigger's\n * tenant.\n */\nconst campaignAttributionRefresh: Hook = {\n  name: 'campaign_attribution_refresh',\n  object: 'crm_opportunity',\n  events: ['afterInsert', 'afterUpdate', 'afterDelete'],\n  priority: 810,\n  async: true,\n  onError: 'log',\n  runAs: 'system',\n  description: 'Recompute campaign metrics when an opportunity\u2019s campaign attribution changes.',\n  handler: async (ctx: HookContext) => {\n    const api = ctx.api as HookApi | undefined;\n    if (!api) return;\n    const { input } = ctx;\n    const previous = ctx.previous;\n    const campaignIds = Array.from(new Set([\n      typeof input?.crm_campaign === 'string' ? input.crm_campaign : '',\n      typeof previous?.crm_campaign === 'string' ? (previous.crm_campaign as string) : '',\n    ].filter(Boolean)));\n    for (const id of campaignIds) {\n      // \u2500\u2500 recompute \u2500\u2500 identical in all four refresh hooks; see the header.\n      const memberRows = await api.object('crm_campaign_member').find({\n        where: { crm_campaign: id }, fields: ['crm_lead', 'status'], top: 5000,\n      });\n      const leadIds = Array.from(new Set(\n        memberRows.map((r) => (typeof r.crm_lead === 'string' ? r.crm_lead : '')).filter(Boolean),\n      ));\n      const convertedLeads = leadIds.length > 0\n        ? await api.object('crm_lead').count({ where: { id: { $in: leadIds }, is_converted: true } })\n        : 0;\n      const numOpportunities = await api.object('crm_opportunity').count({ where: { crm_campaign: id } });\n      const numWon = await api.object('crm_opportunity').count({ where: { crm_campaign: id, stage: 'closed_won' } });\n      const wonRows = await api.object('crm_opportunity').find({\n        where: { crm_campaign: id, stage: 'closed_won' }, fields: ['amount'], top: 5000,\n      });\n      const actualRevenue = wonRows.reduce(\n        (sum, row) => sum + (typeof row.amount === 'number' ? row.amount : Number(row.amount) || 0), 0,\n      );\n      await api.object('crm_campaign').update({\n        id,\n        num_sent: memberRows.length,\n        num_responses: memberRows.filter((r) => r.status === 'responded' || r.status === 'converted').length,\n        num_leads: leadIds.length,\n        num_converted_leads: convertedLeads,\n        num_opportunities: numOpportunities,\n        num_won_opportunities: numWon,\n        actual_revenue: actualRevenue,\n      }, { where: { id } });\n      // \u2500\u2500 /recompute \u2500\u2500\n    }\n  },\n};\n\nexport default [campaignAttributionRefresh];\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/sales/objects/task.hook.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/sales/objects\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/sales/objects/task.hook.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport type { Hook, HookContext } from '@objectstack/spec/data';\nimport type { HookApi } from './_hook-api';\n\n/**\n * Task lifecycle hook.\n *\n * - On `completed` transition, stamps `completed_date` and `progress_percent=100`.\n * - Warns when `reminder_date` is after `due_date`.\n * - Bubbles activity to the polymorphic parent (account `last_activity_date`,\n *   lead `last_contacted_date`).\n * - Refuses to SCHEDULE a phone touch against a person flagged `do_not_call`\n *   (see {@link taskDoNotCallGuard}).\n */\n\nconst taskValidation: Hook = {\n  name: 'task_completion',\n  object: 'crm_task',\n  events: ['beforeInsert', 'beforeUpdate'],\n  priority: 200,\n  description: 'Stamp completed/overdue flags + dates on completion and validate reminder timing.',\n  handler: async (ctx: HookContext) => {\n    // D3 stand-down: a predicate update has ONE payload for every matched row,\n    // so the `ctx.previous`-conditioned writes below would land on rows that\n    // did not earn them \u2014 refused as a diverging key set, or stored silently\n    // from the last row. Full account and the measurement: `forecast.hook.ts`.\n    if (ctx.event === 'beforeUpdate' && ctx.dispatch?.mode === 'per-row') return;\n\n    // The refusal envelope (#1075). Mirrored from `./_refusal.ts` because a\n    // lowered body has no module scope and `extractHookBody` THROWS on an\n    // import; `test/refusal-envelope.test.ts` pins every copy against it.\n    function refuse(\n      message: string,\n      code: string,\n      status: number,\n      userMessage: string = message,\n    ): Error {\n      const err = new Error(message) as Error & {\n        code: string;\n        status: number;\n        userMessage: string;\n      };\n      err.code = code;\n      err.status = status;\n      err.userMessage = userMessage;\n      return err;\n    }\n    const { input } = ctx;\n    const previous = ctx.previous;\n\n    // Land `reminder_sent` as a real boolean on insert, never NULL. The\n    // task_due_reminder sweep de-dups on `reminder_date` (cleared after each\n    // send), not on this flag \u2014 but keep it a real boolean so the audit trail\n    // and any future `!= true` filter behave under SQL three-valued logic.\n    if (!previous && input.reminder_sent == null) {\n      input.reminder_sent = false;\n    }\n\n    // Materialise the urgency ordinal so the to-do queue can sort by it \u2014\n    // sorting on `priority` itself compares raw strings and inverts urgency.\n    const effPriority =\n      (typeof input.priority === 'string' && input.priority) ||\n      (typeof previous?.priority === 'string' && (previous.priority as string)) ||\n      undefined;\n    //\n    // Inline and duplicated in case.hook.ts on purpose \u2014 L2 hook bodies run\n    // body-only in the QuickJS sandbox, so a shared module constant resolves at\n    // authoring time and arrives as `undefined` (see _line-item-price-fill.ts).\n    // The vocabularies differ (normal vs medium), but the UNKNOWN fallback must\n    // match crm_case: `0`, the unranked sentinel that sorts below every real\n    // rank. `test/priority-rank-parity.test.ts` pins that agreement.\n    if (effPriority) {\n      const rank: Record<string, number> = { low: 1, normal: 2, high: 3, urgent: 4 };\n      input.priority_rank = rank[effPriority] ?? 0;\n    }\n\n    if (input.status === 'completed' && previous?.status !== 'completed') {\n      // \u26A0\uFE0F `!input.completed_date` ALONE was the defect, and `|| !ctx.session?.isSystem`\n      // is the fix \u2014 \u26D4 do not tidy the second half away. `completed_date` is\n      // `readonly: true`, and since `@objectstack/objectql@17.4.0` the engine strips a\n      // static readonly field from a NON-SYSTEM caller's INSERT too, not just their\n      // UPDATE (the retired-pin note in `test/readonly-write-semantics.test.ts` carries\n      // that migration). Measured against a running server on the 17.4.0 pin: this\n      // handler still SEES the caller's value \u2014 the strip runs after `beforeInsert`\n      // returns \u2014 and the value THIS line writes survives it, because a hook-written\n      // key is not caller-supplied.\n      //\n      // So deferring to a supplied value inverted the rule below it: a caller who sent\n      // `completed_date` suppressed the only stamp there was, the engine then deleted\n      // what they sent, and `completed_date_required` rejected the one call that had\n      // actually supplied the field \u2014 while omitting it succeeded. The error named the\n      // field whose PRESENCE caused it, so an agent retried by sending it again.\n      //\n      // The `isSystem` half is not decoration: nothing strips a system write, and\n      // `src/sales/data/activity.seed.ts` back-dates completions with `daysAgo(3)` /\n      // `daysAgo(2)`. Stamping over those would replay the demo book with every\n      // completion dated today.\n      if (!input.completed_date || !ctx.session?.isSystem) {\n        input.completed_date = new Date().toISOString();\n      }\n      if (typeof input.progress_percent !== 'number') input.progress_percent = 100;\n    }\n\n    // Derived flags.\n    const effStatus =\n      (typeof input.status === 'string' && input.status) ||\n      (typeof previous?.status === 'string' && (previous.status as string)) ||\n      undefined;\n    if (typeof effStatus === 'string') input.is_completed = effStatus === 'completed';\n    const effDue =\n      (typeof input.due_date === 'string' && input.due_date) ||\n      (typeof previous?.due_date === 'string' && (previous.due_date as string)) ||\n      undefined;\n    const todayStr = new Date().toISOString().slice(0, 10);\n    input.is_overdue = !!effDue && effDue.slice(0, 10) < todayStr && input.is_completed !== true;\n\n    const reminder =\n      (typeof input.reminder_date === 'string' && input.reminder_date) ||\n      (typeof previous?.reminder_date === 'string' && (previous.reminder_date as string)) ||\n      undefined;\n    const due =\n      (typeof input.due_date === 'string' && input.due_date) ||\n      (typeof previous?.due_date === 'string' && (previous.due_date as string)) ||\n      undefined;\n    if (reminder && due && reminder.slice(0, 10) > due.slice(0, 10)) {\n      throw refuse(\n        `Reminder (${reminder}) is after the due date (${due}); reminders should fire before the deadline.`,\n        'VALIDATION_FAILED',\n        400,\n      );\n    }\n  },\n};\n\n/**\n * Recurring-task generator.\n *\n * The schema carries `is_recurring` / `recurrence_type` / `recurrence_interval`\n * / `recurrence_end_date`, but nothing ever spawned the next occurrence \u2014 so a\n * \"recurring\" task was recurring in name only. On the completing transition of a\n * recurring task, this clones it with `due_date` (and `reminder_date`) advanced\n * by `recurrence_type \u00D7 interval`, until `recurrence_end_date` is passed.\n *\n * Done in a hook (not a flow) because the next due date needs real calendar math\n * (month/year rollover); the flow runtime's `{NOW()+n}` only does day offsets and\n * has no `DATEADD`. The spawned task is `not_started`, so it never re-triggers\n * this completion hook (no recursion).\n */\nconst taskRecurrence: Hook = {\n  name: 'task_recurrence',\n  object: 'crm_task',\n  events: ['afterUpdate'],\n  priority: 700,\n  async: true,\n  onError: 'log',\n  description: 'On completion of a recurring task, spawn the next occurrence (dates advanced by recurrence_type \u00D7 interval).',\n  handler: async (ctx: HookContext) => {\n    /**\n     * Advance a date by `interval` units of the given recurrence type.\n     *\n     * Declared INSIDE the handler, matching every other hook in this directory:\n     * L2 hook bodies run body-only in the QuickJS sandbox, where module scope\n     * is not available (cf. opportunity.hook.ts / lead.hook.ts). This was the\n     * one module-level helper left in the tree.\n     *\n     * Month and year steps CLAMP to the last valid day of the target month\n     * instead of overflowing. `Date.setMonth` rolls a day that does not exist\n     * forward into the next month \u2014 Jan 31 + 1 month landed on Mar 3, so a\n     * month-end recurring task walked further into the following month on every\n     * occurrence and, for the 31st, skipped February entirely.\n     *\n     * \u26A0\uFE0F Every read and write below is on the UTC calendar, and that is the\n     * whole point of the spelling rather than a style choice. The base is the\n     * stored `due_date` \u2014 a bare `YYYY-MM-DD`, which the spec's date-only form\n     * anchors at UTC midnight \u2014 and the result is rendered with\n     * `toISOString()`. A local `getDate`/`setDate`/`setMonth` step in between\n     * reads that UTC anchor on a different calendar (west of Greenwich it is\n     * the previous evening, so `getDate()` on `2026-01-15` answers 14) and\n     * preserves wall-clock time across a DST transition, which is a 23 h or\n     * 25 h day. Both errors render as a day the series never recovers from:\n     * each occurrence is computed from the previous one.\n     *\n     * The clamp probe is built with `Date.UTC` for the same reason \u2014 a\n     * `new Date(y, m, d)` constructor reads its arguments as LOCAL fields, so\n     * it would answer the length of the wrong month at either end of the year.\n     */\n    function advanceDate(d: Date, type: string, interval: number): Date {\n      const next = new Date(d);\n      if (type === 'daily') {\n        next.setUTCDate(next.getUTCDate() + interval);\n        return next;\n      }\n      if (type === 'weekly') {\n        next.setUTCDate(next.getUTCDate() + 7 * interval);\n        return next;\n      }\n      const months = type === 'monthly' ? interval : type === 'yearly' ? 12 * interval : 0;\n      if (months === 0) return next;\n\n      const day = next.getUTCDate();\n      // Move to the 1st first so the month arithmetic can never overflow, then\n      // clamp the day to the target month's length.\n      next.setUTCDate(1);\n      next.setUTCMonth(next.getUTCMonth() + months);\n      const lastDayOfTargetMonth = new Date(Date.UTC(\n        next.getUTCFullYear(), next.getUTCMonth() + 1, 0,\n      )).getUTCDate();\n      next.setUTCDate(Math.min(day, lastDayOfTargetMonth));\n      return next;\n    }\n\n    const { input } = ctx;\n    const previous = ctx.previous;\n    const api = ctx.api as HookApi | undefined;\n    if (!api) return;\n\n    // Fire only on the transition INTO completed (not on later edits of an\n    // already-completed task).\n    const nowDone = input.status === 'completed' || input.is_completed === true;\n    const wasDone = previous?.status === 'completed' || previous?.is_completed === true;\n    if (!nowDone || wasDone) return;\n\n    const r: Record<string, any> = { ...(previous ?? {}), ...input };\n    if (r.is_recurring !== true) return;\n\n    const type = typeof r.recurrence_type === 'string' ? r.recurrence_type : undefined;\n    if (!type || !['daily', 'weekly', 'monthly', 'yearly'].includes(type)) return;\n    const interval = Number(r.recurrence_interval) > 0 ? Number(r.recurrence_interval) : 1;\n\n    const baseDue = r.due_date ? new Date(r.due_date) : new Date();\n    if (isNaN(baseDue.getTime())) return;\n    const nextDue = advanceDate(baseDue, type, interval);\n\n    // Stop the series once the next occurrence would fall past the end date.\n    if (r.recurrence_end_date) {\n      const end = new Date(r.recurrence_end_date);\n      if (!isNaN(end.getTime()) && nextDue > end) return;\n    }\n\n    const doc: Record<string, any> = {\n      subject: r.subject,\n      description: r.description ?? null,\n      priority: r.priority,\n      type: r.type ?? null,\n      owner_id: r.owner_id ?? null,\n      status: 'not_started',\n      is_completed: false,\n      reminder_sent: false,\n      due_date: nextDue.toISOString().slice(0, 10),\n      is_recurring: true,\n      recurrence_type: type,\n      recurrence_interval: interval,\n      recurrence_end_date: r.recurrence_end_date ?? null,\n      related_to_type: r.related_to_type ?? null,\n      related_to_account: r.related_to_account ?? null,\n      related_to_contact: r.related_to_contact ?? null,\n      related_to_opportunity: r.related_to_opportunity ?? null,\n      related_to_lead: r.related_to_lead ?? null,\n      related_to_case: r.related_to_case ?? null,\n    };\n    if (r.reminder_date) {\n      const baseRem = new Date(r.reminder_date);\n      if (!isNaN(baseRem.getTime())) doc.reminder_date = advanceDate(baseRem, type, interval).toISOString();\n    }\n\n    try {\n      await api.object('crm_task').insert(doc);\n    } catch {\n      // Best-effort; never break the parent write. No `console` in the L2 hook\n      // sandbox \u2014 logging here would throw its own ReferenceError (cf. #471).\n    }\n  },\n};\n\n/**\n * The activity bubble's task twin.\n *\n * `runAs: 'system'` (#2014, AGENTS.md rule 9) and the organization pin (rule\n * 10) for the reasons `event_activity_bubble` records \u2014 read that note. The\n * measurement that put this copy on the card: a service agent completing a\n * task on their own case left the case account's `last_activity_date` empty,\n * while an admin's identical completion stamped it (17.7.0); a rep's\n * completed task on their own deal reached neither the account nor the\n * contact a manager owns.\n */\nconst taskBubble: Hook = {\n  name: 'task_activity_bubble',\n  object: 'crm_task',\n  events: ['afterUpdate'],\n  priority: 800,\n  async: true,\n  onError: 'log',\n  runAs: 'system',\n  description:\n    'A completed task stamps interaction recency on the related account (walking up from contact/opportunity/case), lead and contact.',\n  handler: async (ctx: HookContext) => {\n    /*\n     * The activity bubble, second copy. `src/sales/objects/event.hook.ts` carries the\n     * canonical one and the rationale; this is a deliberate verbatim duplicate,\n     * not drift \u2014 an L2 hook body ships body-only into the QuickJS sandbox, so a\n     * shared module helper resolves at authoring time and arrives `undefined` at\n     * runtime (same constraint as `_line-item-price-fill.ts` and the\n     * `priority_rank` table above). `test/activity-recency.test.ts` runs BOTH\n     * copies through the same cases so they cannot diverge silently.\n     *\n     * \u26D4 Two properties this must keep:\n     *\n     *   1. It does NOT key off `related_to_type`. That discriminator is a\n     *      display hint a rep can leave blank, and a task with a perfectly good\n     *      `related_to_account` then bubbles to nothing at all.\n     *   2. It WALKS UP to the account. A rep completes a task on the\n     *      opportunity, not on the account row, so bubbling only to the named\n     *      record leaves `crm_account.last_activity_date` untouched through an\n     *      entire deal \u2014 and `at_risk_accounts` then lists active customers.\n     */\n    const { input } = ctx;\n    const previous = ctx.previous;\n    const api = ctx.api as HookApi | undefined;\n    if (!api) return;\n\n    // Recency means the interaction HAPPENED. An open task is a promise, not\n    // contact; only the completing transition bubbles.\n    const nowDone = input.status === 'completed' || input.is_completed === true;\n    const wasDone = previous?.status === 'completed' || previous?.is_completed === true;\n    if (!nowDone || wasDone) return;\n\n    const r: Record<string, any> = { ...(previous ?? {}), ...input };\n\n    const nowIso = new Date().toISOString();\n    // `crm_account.last_activity_date` is a DATE column; the two contact\n    // timestamps are datetimes.\n    const today = nowIso.slice(0, 10);\n\n    const idOf = (key: string): string | undefined =>\n      typeof r[key] === 'string' && r[key].length > 0 ? (r[key] as string) : undefined;\n    // The rule-10 pin \u2014 see `event_activity_bubble`'s note.\n    const org = idOf('organization_id');\n    const inOrg: Record<string, string> = org ? { organization_id: org } : {};\n\n    const accountIds = new Set<string>();\n    const contactIds = new Set<string>();\n    const leadIds = new Set<string>();\n\n    const direct = idOf('related_to_account');\n    if (direct) accountIds.add(direct);\n    const contactId = idOf('related_to_contact');\n    if (contactId) contactIds.add(contactId);\n    const leadId = idOf('related_to_lead');\n    if (leadId) leadIds.add(leadId);\n\n    const parentLookups: Array<[string, string]> = [\n      ['related_to_contact', 'crm_contact'],\n      ['related_to_opportunity', 'crm_opportunity'],\n      ['related_to_case', 'crm_case'],\n    ];\n    for (const [field, object] of parentLookups) {\n      const id = idOf(field);\n      if (!id) continue;\n      try {\n        const raw: any = await api.object(object).find({\n          where: { id, ...inOrg },\n          fields: ['crm_account'],\n          top: 1,\n        });\n        const rows = Array.isArray(raw) ? raw : (raw?.records ?? []);\n        const parent = rows.length ? rows[0].crm_account : undefined;\n        if (typeof parent === 'string' && parent.length > 0) accountIds.add(parent);\n      } catch {\n        // Best-effort: a parent that cannot be read is not bubbled through.\n        // No `console` in the L2 hook sandbox (cf. #471).\n      }\n    }\n\n    const targets: Array<[string, Set<string>, Record<string, any>]> = [\n      ['crm_account', accountIds, { last_activity_date: today }],\n      ['crm_contact', contactIds, { last_contacted_date: nowIso }],\n      ['crm_lead', leadIds, { last_contacted_date: nowIso }],\n    ];\n    for (const [object, ids, doc] of targets) {\n      let inside = [...ids];\n      if (org && inside.length > 0) {\n        try {\n          const raw: any = await api.object(object).find({ where: { id: { $in: inside }, ...inOrg }, fields: ['id'], top: inside.length });\n          inside = (Array.isArray(raw) ? raw : (raw?.records ?? [])).map((row: any) => String(row.id));\n        } catch {\n          inside = [];\n        }\n      }\n      for (const id of inside) {\n        try {\n          await api.object(object).update({ ...doc, id }, { where: { id } });\n        } catch {\n          // Best-effort activity bubble; never break the parent write.\n        }\n      }\n    }\n  },\n};\n\n/**\n * `do_not_call` \u2014 refuse to SCHEDULE a phone touch, never to record one.\n *\n * # Why this is a hook and not an action predicate\n *\n * The obvious mirror of the `email_opt_out` treatment is\n * `visible: P\\`record.do_not_call == false\\`` on a button, the way\n * `send_email` and `add_contact_to_campaign` are gated in\n * `src/sales/actions/contact.actions.ts`. That is a RENDERING hint, and it is the\n * whole of what those two do: it hides a button in the Console and leaves the\n * action reachable over REST, from an AI tool call, from a flow, and from an\n * import. For email that is only half a promise too \u2014 but the email half is\n * backed by real enforcement elsewhere (`campaign-enrollment.flow.ts` filters\n * on the flag, `campaign_member.hook.ts` writes it). `do_not_call` had no such\n * backing, so a predicate alone would have moved the field from \"declared and\n * unenforced\" to \"declared and unenforced unless you use the mouse\".\n *\n * Enforcing on the WRITE instead covers every entry point at once \u2014 the\n * `schedule_followup` screen flow, a hand-created task, an import, an AI agent\n * calling the data API \u2014 which is the same \"one writer, not one per entry\n * point\" reasoning `src/sales/actions/activity-actions.ts` gives for keeping the\n * recency bubble on `crm_event`'s hook rather than in each button's body.\n *\n * # Why `type: 'call'` and not \"any forward-looking outreach\"\n *\n * `do_not_call` is a promise about the PHONE. It is not `do_not_contact`:\n * this person may still be emailed (that is `email_opt_out`'s separate flag),\n * met, or demoed to. Refusing a `meeting` task here would silently widen a\n * declared field into a promise the app never made \u2014 the mirror image of the\n * defect this guard closes.\n *\n * # Why a completed task is allowed through\n *\n * A `completed` Call task is a RECORD of a call that already happened, not a\n * plan to place one. Refusing it would delete the evidence rather than prevent\n * the call \u2014 and would make the flag actively harmful, because the honest rep\n * who logs the call they should not have made is the one who gets blocked. The\n * same reasoning keeps the `log_call` action reachable and ungated.\n */\nconst taskDoNotCallGuard: Hook = {\n  name: 'task_do_not_call_guard',\n  object: 'crm_task',\n  events: ['beforeInsert', 'beforeUpdate'],\n  priority: 150,\n  description: 'Refuse to schedule an open Call task against a lead/contact flagged Do Not Call.',\n  handler: async (ctx: HookContext) => {\n    // The refusal envelope (#1075). Mirrored from `./_refusal.ts` because a\n    // lowered body has no module scope and `extractHookBody` THROWS on an\n    // import; `test/refusal-envelope.test.ts` pins every copy against it.\n    function refuse(\n      message: string,\n      code: string,\n      status: number,\n      userMessage: string = message,\n    ): Error {\n      const err = new Error(message) as Error & {\n        code: string;\n        status: number;\n        userMessage: string;\n      };\n      err.code = code;\n      err.status = status;\n      err.userMessage = userMessage;\n      return err;\n    }\n    const { input } = ctx;\n    const previous = ctx.previous;\n    const api = ctx.api as HookApi | undefined;\n    if (!api) return;\n\n    // The value the row will HAVE after this write, not the value the write\n    // happens to mention: flipping `type` to `call` on an existing task and\n    // re-parenting an existing Call task are both ways in, and each only\n    // supplies one of the two keys.\n    const effective = (key: string): unknown =>\n      input[key] !== undefined && input[key] !== null ? input[key] : previous?.[key];\n\n    if (effective('type') !== 'call') return;\n    if (effective('status') === 'completed') return;\n\n    const leadId = effective('related_to_lead');\n    const contactId = effective('related_to_contact');\n\n    // Both branches run rather than an if/else: `related_to_required` on the\n    // object guarantees at least one parent, and a row that somehow carries\n    // both must be checked against both people, not against whichever the\n    // author listed first.\n    const targets: Array<{ object: string; id: string; label: string }> = [];\n    if (typeof leadId === 'string' && leadId) {\n      targets.push({ object: 'crm_lead', id: leadId, label: 'lead' });\n    }\n    if (typeof contactId === 'string' && contactId) {\n      targets.push({ object: 'crm_contact', id: contactId, label: 'contact' });\n    }\n\n    for (const t of targets) {\n      // `find(... top: 1)` rather than `findOne`, matching\n      // `event_activity_bubble` in `src/sales/objects/event.hook.ts` and the shape\n      // the rest of the app's hooks read with. The result is normalised for\n      // both driver shapes (bare array / `{ records }`).\n      const raw: any = await api.object(t.object).find({\n        where: { id: t.id },\n        fields: ['id', 'do_not_call'],\n        top: 1,\n      });\n      const rows = Array.isArray(raw) ? raw : (raw?.records ?? []);\n      const person = rows[0];\n      // `=== true` on purpose: an absent key, `null`, and `false` are all \"not\n      // flagged\". A driver that stores only written columns hands back the key\n      // ABSENT (see AGENTS.md on predicate totality), and treating that as\n      // truthy would block every ordinary call task in the app.\n      if (person?.do_not_call === true) {\n        throw refuse(\n          `This ${t.label} is flagged Do Not Call, so a Call task cannot be scheduled against them. ` +\n            'Log a completed call if one already happened, choose a non-phone activity type, ' +\n            'or clear Do Not Call on the record first.',\n          'FORBIDDEN',\n          403,\n        );\n      }\n    }\n  },\n};\n\nexport default [taskValidation, taskDoNotCallGuard, taskRecurrence, taskBubble];\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/revenue/objects/contract.hook.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/revenue/objects\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/revenue/objects/contract.hook.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport type { Hook, HookContext } from '@objectstack/spec/data';\nimport type { HookApi } from '../../sales/objects/_hook-api';\n\n/**\n * Contract lifecycle hook.\n *\n * - Validates `end_date` \u2248 `start_date + contract_term_months`.\n * - Rejects shrinking `end_date` after activation.\n * - On `activated`: stamps `signed_date` (if missing) and promotes the account\n *   to `customer`. Renewal reminders are owned by the `contract_renewal` flow.\n */\n\n// NB: helpers used by handlers are declared INSIDE each handler \u2014 L2 hook\n// bodies run body-only in the QuickJS sandbox, so module scope is not\n// available at runtime (cf. opportunity.hook.ts). Module-level copies were\n// dead code that invited silent divergence.\n\nconst contractValidation: Hook = {\n  name: 'contract_validation',\n  object: 'crm_contract',\n  events: ['beforeInsert', 'beforeUpdate'],\n  priority: 200,\n  description: 'Enforce contract term math and prevent shrinking end_date once activated.',\n  handler: async (ctx: HookContext) => {\n    // The refusal envelope (#1075). Mirrored from `src/sales/objects/_refusal.ts` because a\n    // lowered body has no module scope and `extractHookBody` THROWS on an\n    // import; `test/refusal-envelope.test.ts` pins every copy against it.\n    function refuse(\n      message: string,\n      code: string,\n      status: number,\n      userMessage: string = message,\n    ): Error {\n      const err = new Error(message) as Error & {\n        code: string;\n        status: number;\n        userMessage: string;\n      };\n      err.code = code;\n      err.status = status;\n      err.userMessage = userMessage;\n      return err;\n    }\n    const { event, input, previous } = ctx;\n\n    // Both operands are stored `YYYY-MM-DD` values, which the date-only parse\n    // anchors at UTC MIDNIGHT \u2014 so they are read here on the calendar they were\n    // written on. The local accessors are one day earlier west of Greenwich\n    // (`new Date('2026-01-01').getDate()` answers 31 in `America/New_York`, 1 in\n    // `Europe/Berlin`), and this count feeds a hard refusal that the +/-1 month\n    // tolerance does not absorb at the boundary: a legal contract spanning\n    // `term + 1` months measured `term + 2` and the save was rejected, quoting a\n    // month count its own dates do not have.\n    function monthsBetween(startISO: string, endISO: string): number {\n      const s = new Date(startISO);\n      const e = new Date(endISO);\n      return (\n        (e.getUTCFullYear() - s.getUTCFullYear()) * 12 +\n        (e.getUTCMonth() - s.getUTCMonth()) +\n        // Unchanged intent: has the end day-of-month reached the start's yet?\n        // If not, the last month is not complete and does not count.\n        (e.getUTCDate() >= s.getUTCDate() ? 0 : -1)\n      );\n    }\n\n    // The patch's value, else the stored one; an empty string or a 0 / NaN\n    // term counts as absent, so the check below stands down.\n    const startDate = [input.start_date, previous?.start_date].find((v): v is string => typeof v === 'string' && v !== '');\n    const endDate = [input.end_date, previous?.end_date].find((v): v is string => typeof v === 'string' && v !== '');\n    const term = [input.contract_term_months, previous?.contract_term_months].find((v): v is number => typeof v === 'number' && !!v);\n\n    if (startDate && endDate && term) {\n      const calc = monthsBetween(startDate, endDate);\n      if (Math.abs(calc - term) > 1) {\n        throw refuse(\n          `Contract term (${term} months) does not match date range (${calc} months from ${startDate} to ${endDate}).`,\n          'VALIDATION_FAILED',\n          400,\n        );\n      }\n    }\n\n    if (event === 'beforeUpdate' && previous?.status === 'activated') {\n      if (\n        typeof input.end_date === 'string' &&\n        typeof previous.end_date === 'string' &&\n        input.end_date < previous.end_date\n      ) {\n        throw refuse(\n          `Cannot shrink end_date (${previous.end_date as string} \u2192 ${input.end_date}) after activation. Use a termination/amendment workflow instead.`,\n          'RECORD_LOCKED',\n          409,\n        );\n      }\n    }\n  },\n};\n\nconst contractActivation: Hook = {\n  name: 'contract_on_activation',\n  object: 'crm_contract',\n  events: ['afterUpdate'],\n  priority: 800,\n  async: true,\n  onError: 'log',\n  description: 'On activation: stamp signed_date, promote account.',\n  handler: async (ctx: HookContext) => {\n    const { input, previous } = ctx;\n    if (input.status !== 'activated' || previous?.status === 'activated') return;\n    const api = ctx.api as HookApi | undefined;\n    if (!api) return;\n\n    const id = [input.id, previous?.id].find((v): v is string => typeof v === 'string' && v !== '');\n    const accountId = [input.crm_account, previous?.crm_account].find((v): v is string => typeof v === 'string' && v !== '');\n\n    if (id && !input.signed_date && !previous?.signed_date) {\n      await api.object('crm_contract').update(\n        { id, signed_date: new Date().toISOString().slice(0, 10) },\n        { where: { id } },\n      );\n    }\n\n    if (accountId) {\n      const account = await api.object('crm_account').findOne({ where: { id: accountId } });\n      if (account && account.type !== 'customer') {\n        await api.object('crm_account').update(\n          { id: accountId, type: 'customer' },\n          { where: { id: accountId } },\n        );\n      }\n    }\n\n    // No renewal task here: renewal reminders are owned by the\n    // `contract_renewal` scheduled flow, which honours the per-contract\n    // `renewal_notice_days`. The activation-time task this hook used to\n    // create hardcoded a 60-day notice and duplicated the flow's task.\n  },\n};\n\nexport default [contractValidation, contractActivation];\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/revenue/objects/_line-item-price-fill.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/revenue/objects\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/revenue/objects/_line-item-price-fill.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport type { Hook, HookContext } from '@objectstack/spec/data';\nimport type { HookApi } from '../../sales/objects/_hook-api';\n\n/**\n * Shared line-item price fill.\n *\n * `list_price` on both line-item objects is documented as \"auto-populated from\n * product.list_price\", and nothing implemented it until this hook. On write,\n * when a product is part of THIS change, it stamps the catalog `list_price`;\n * on INSERT it also defaults the negotiated `unit_price` to the list price when\n * the rep left it blank (they can still override). On update the negotiated\n * `unit_price` is left alone, so a re-synced catalog price never clobbers a\n * price someone actually negotiated.\n *\n * Why it lives here rather than twice: `crm_opportunity_line_item` and\n * `crm_quote_line_item` carried near-verbatim copies of this handler that\n * differed only in comments \u2014 the shape that lets a fix land on one object and\n * silently skip the other. Only the price fill is shared; the two ROLLUP hooks\n * next door look alike but compute genuinely different totals, so they stay\n * separate.\n *\n * Sandbox note: L2 hook bodies run BODY-ONLY in the QuickJS sandbox, so a\n * handler cannot reach module scope at runtime. This factory is still safe\n * because the sharing happens at authoring time \u2014 `objectName`/`hookName` are\n * plain metadata on the returned Hook, and the handler body below closes over\n * NOTHING but its own `ctx`. Never move a value the body reads into this\n * factory's parameters; it would resolve here and be undefined in the sandbox.\n *\n * That rule is enforced, not just documented: `test/action-sandbox.test.ts`\n * lowers this handler with the CLI build's own extraction pass (which rejects a\n * body referencing anything out of scope) and runs the result under the real\n * QuickJS runner, with a negative control that shows the guard still bites.\n * Worth knowing why a test has to: when extraction fails the build does not,\n * it silently keeps the handler in its bundled form and the hook stops being\n * deployable as pure metadata.\n */\nexport function createLineItemPriceFill(objectName: string, hookName: string): Hook {\n  return {\n    name: hookName,\n    object: objectName,\n    events: ['beforeInsert', 'beforeUpdate'],\n    priority: 100,\n    description: 'Default list_price / unit_price from the chosen product.',\n    handler: async (ctx: HookContext) => {\n      const { event, input } = ctx;\n      const api = ctx.api as HookApi | undefined;\n      if (!api) return;\n      // Only act when a product reference is part of THIS write.\n      const productId = typeof input.crm_product === 'string' ? input.crm_product : undefined;\n      if (!productId) return;\n      const product = await api.object('crm_product').findOne({\n        where: { id: productId }, fields: ['id', 'list_price'],\n      });\n      const listPrice = product && typeof product.list_price === 'number' ? product.list_price : undefined;\n      if (listPrice === undefined) return;\n      // Catalog reference always tracks the product.\n      input.list_price = listPrice;\n      // Negotiated price defaults to list on create when left blank; never\n      // overwritten on update (respect a rep's negotiated figure).\n      if (event === 'beforeInsert' && input.unit_price == null) {\n        input.unit_price = listPrice;\n      }\n    },\n  };\n}\n\n/**\n * Shared line-number assigner (#1828) \u2014 `line_number` is `readonly`, so this is\n * its one writer. Insert: `max under the parent + 1`. Update of a row that still\n * has none (created before this hook \u2014 `scripts/backfill-line-number.ts` touches\n * each once): same stamp. An existing ordinal is never renumbered. The engine\n * keeps a payload key a hook wrote through its readonly strip, so a user write\n * lands the stamp and a user-supplied value is overwritten; only a no-user\n * system write that supplies one (the seed, and its replay) keeps its own. `runAs: 'system'`\n * elevates the sibling read and nothing else. Body-only rule as above: the\n * parent key comes from `ctx.object`, never a factory parameter.\n */\nexport function createLineItemNumbering(objectName: string, hookName: string): Hook {\n  return {\n    name: hookName,\n    object: objectName,\n    events: ['beforeInsert', 'beforeUpdate'],\n    priority: 110,\n    runAs: 'system',\n    description: 'Assign line_number = (max under the parent) + 1.',\n    handler: async (ctx: HookContext) => {\n      const { event, input } = ctx;\n      const prev = ctx.previous;\n      const api = ctx.api as HookApi | undefined;\n      if (!api) return;\n      if (!ctx.user?.id && typeof input.line_number === 'number') return;\n      // D3: a predicate update has ONE payload for every row (forecast.hook.ts).\n      if (event === 'beforeUpdate' && (ctx.dispatch?.mode === 'per-row' || typeof prev?.line_number === 'number')) return;\n      const parentKey = ctx.object === 'crm_quote_line_item' ? 'crm_quote' : 'crm_opportunity';\n      const parentId = input[parentKey] ?? prev?.[parentKey];\n      if (typeof parentId !== 'string' || !parentId) return;\n      const siblings = await api.object(ctx.object).find({\n        where: { [parentKey]: parentId }, fields: ['line_number'], top: 5000,\n      });\n      let max = 0;\n      for (const s of siblings) {\n        if (typeof s.line_number === 'number' && s.line_number > max) max = s.line_number;\n      }\n      // A batch insert runs every row's beforeInsert before storing any row.\n      const offset = event === 'beforeInsert' && ctx.dispatch?.mode === 'per-row' ? ctx.dispatch.index : 0;\n      input.line_number = max + 1 + offset;\n    },\n  };\n}\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/revenue/objects/opportunity_line_item.hook.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/revenue/objects\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/revenue/objects/opportunity_line_item.hook.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport type { Hook, HookContext } from '@objectstack/spec/data';\nimport type { HookApi } from '../../sales/objects/_hook-api';\nimport { createLineItemNumbering, createLineItemPriceFill } from './_line-item-price-fill';\n\n/**\n * Opportunity amount rollup.\n *\n * Keeps `crm_opportunity.amount` in sync with the sum of its line items'\n * extended price. Fires after a line item is inserted / updated / deleted (the\n * console surfaces these as the opportunity's \"Products\" related list) and\n * recomputes the parent opportunity's amount from the current line set.\n *\n * Why this exists: `amount` was a free-typed currency field with no link to\n * `crm_opportunity_line_item`, so itemising a deal and its headline number\n * could drift apart. Once a deal is itemised, the line sum is authoritative.\n *\n * Design decisions:\n * - Recomputes from raw `quantity * unit_price * (1 - discount/100)` rather than\n *   reading the `total_price` FORMULA field, so it doesn't depend on formula\n *   hydration inside the sandboxed hook body.\n * - If the opportunity has NO line items (e.g. the last one was just deleted),\n *   `amount` is left untouched \u2014 zeroing it would trip the `amount > 0`\n *   validation and wipe the manually-entered figure on opportunities that never\n *   used line items at all.\n * - `async: true` + `onError: 'log'` \u2014 the rollup is a derived convenience; a\n *   failure must never block the line-item write. Updating the parent does not\n *   re-trigger this hook (different object), so there's no loop.\n * - On re-parenting (update that moves a line to another opportunity), BOTH the\n *   old and new parents are recomputed.\n */\n/**\n * Line-item price fill \u2014 one implementation shared with the quote line item;\n * see `_line-item-price-fill.ts` for the behaviour and the sandbox caveat.\n */\nconst opportunityLineItemPriceFill: Hook = createLineItemPriceFill(\n  'crm_opportunity_line_item',\n  'opportunity_line_item_price_fill',\n);\n\n/** `line_number` assigner \u2014 see `_line-item-price-fill.ts` (#1828). */\nconst opportunityLineItemNumbering: Hook = createLineItemNumbering(\n  'crm_opportunity_line_item',\n  'opportunity_line_item_line_number',\n);\n\nconst opportunityAmountRollup: Hook = {\n  name: 'opportunity_amount_rollup',\n  object: 'crm_opportunity_line_item',\n  events: ['afterInsert', 'afterUpdate', 'afterDelete'],\n  priority: 300,\n  async: true,\n  onError: 'log',\n  description: 'Recompute parent opportunity.amount from the sum of its line items.',\n  handler: async (ctx: HookContext) => {\n    const api = ctx.api as HookApi | undefined;\n    if (!api) return;\n    const { input, previous } = ctx;\n    const num = (v: unknown): number => (typeof v === 'number' ? v : 0);\n\n    // Every parent opportunity touched by this change (old + new handles the\n    // re-parenting case on update).\n    const oppIds = new Set<string>();\n    for (const v of [input?.crm_opportunity, previous?.crm_opportunity]) {\n      if (typeof v === 'string' && v) oppIds.add(v);\n    }\n    if (oppIds.size === 0) return;\n\n    for (const oppId of oppIds) {\n      // Skip closed deals. The rollup runs in a system context (no ctx.user),\n      // which BYPASSES the opportunity freeze guard \u2014 so without this check,\n      // editing a line item would silently rewrite a closed-won deal's recorded\n      // amount. A closed deal's value is settled; leave it.\n      const opp = await api.object('crm_opportunity').findOne({\n        where: { id: oppId }, fields: ['id', 'stage'],\n      });\n      const stage = opp && typeof opp.stage === 'string' ? opp.stage : undefined;\n      if (stage === 'closed_won' || stage === 'closed_lost') continue;\n\n      const lines = await api.object('crm_opportunity_line_item').find({\n        where: { crm_opportunity: oppId },\n        fields: ['quantity', 'unit_price', 'discount'],\n        top: 5000,\n      });\n      // No lines left \u2192 leave the existing amount as-is (see design note).\n      if (!lines || lines.length === 0) continue;\n\n      let sum = 0;\n      for (const l of lines) sum += num(l.quantity) * num(l.unit_price) * (1 - num(l.discount) / 100);\n      sum = Math.round(sum * 100) / 100;\n      if (sum > 0) {\n        await api.object('crm_opportunity').update(\n          { id: oppId, amount: sum },\n          { where: { id: oppId } },\n        );\n      }\n    }\n  },\n};\n\nexport default [opportunityLineItemPriceFill, opportunityLineItemNumbering, opportunityAmountRollup];\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/revenue/objects/product.hook.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/revenue/objects\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/revenue/objects/product.hook.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport type { Hook, HookContext } from '@objectstack/spec/data';\nimport type { HookApi } from '../../sales/objects/_hook-api';\n\n/**\n * Product catalog hook.\n *\n * - Enforces `list_price >= cost`.\n * - Normalizes `sku` to uppercase.\n * - Refuses delete when the product is referenced by ANY opportunity or quote\n *   line item (historical included \u2014 deals keep their line history); suggests\n *   deactivating (`is_active=false`) instead.\n */\n\nconst productHook: Hook = {\n  name: 'product_catalog',\n  object: 'crm_product',\n  events: ['beforeInsert', 'beforeUpdate', 'beforeDelete'],\n  priority: 200,\n  description: 'Pricing sanity, SKU normalization, and protect referenced products from deletion.',\n  handler: async (ctx: HookContext) => {\n    // The refusal envelope (#1075). Mirrored from `src/sales/objects/_refusal.ts` because a\n    // lowered body has no module scope and `extractHookBody` THROWS on an\n    // import; `test/refusal-envelope.test.ts` pins every copy against it.\n    function refuse(\n      message: string,\n      code: string,\n      status: number,\n      userMessage: string = message,\n    ): Error {\n      const err = new Error(message) as Error & {\n        code: string;\n        status: number;\n        userMessage: string;\n      };\n      err.code = code;\n      err.status = status;\n      err.userMessage = userMessage;\n      return err;\n    }\n    const { event, input, previous } = ctx;\n\n    if (event === 'beforeInsert' || event === 'beforeUpdate') {\n      // The patch's value, else the stored one \u2014 the first that is a number.\n      const listPrice = [input.list_price, previous?.list_price].find((v): v is number => typeof v === 'number');\n      const cost = [input.cost, previous?.cost].find((v): v is number => typeof v === 'number');\n      if (typeof listPrice === 'number' && typeof cost === 'number' && listPrice < cost) {\n        throw refuse(\n          `List Price (${listPrice}) must be greater than or equal to Cost (${cost}).`,\n          'VALIDATION_FAILED',\n          400,\n        );\n      }\n      if (typeof input.sku === 'string') {\n        input.sku = input.sku.toUpperCase();\n      }\n    }\n\n    if (event === 'beforeDelete') {\n      const api = ctx.api as HookApi | undefined;\n      const id = previous?.id;\n      if (!api || !id) return;\n      const [oppRefs, quoteRefs] = await Promise.all([\n        api.object('crm_opportunity_line_item').count({ where: { crm_product: id } }).catch(() => 0),\n        api.object('crm_quote_line_item').count({ where: { crm_product: id } }).catch(() => 0),\n      ]);\n      if (oppRefs + quoteRefs > 0) {\n        throw refuse(\n          `Cannot delete product: referenced by ${oppRefs} opportunity(ies) and ${quoteRefs} quote(s). Set is_active=false to retire instead.`,\n          'DELETE_RESTRICTED',\n          409,\n        );\n      }\n    }\n  },\n};\n\nexport default productHook;\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/revenue/objects/quote.hook.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/revenue/objects\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/revenue/objects/quote.hook.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport type { Hook, HookContext } from '@objectstack/spec/data';\nimport type { HookApi } from '../../sales/objects/_hook-api';\n\n/**\n * Quote workflow hook.\n *\n * - Defaults `expiration_date` to `quote_date + 30 days` when missing.\n * - Freezes quotes once `accepted` or `expired` \u2014 against USER edits only: a\n *   write that is purely the engine clearing a link is let through. The\n *   freeze covers the quote's LINE ITEMS too (#2060): a user may neither add\n *   a line to a settled quote nor change one of its lines.\n * - Refuses a user's acceptance while the linked opportunity is held by an\n *   approval, because acceptance closes that deal as won (#2014).\n * - On `accepted`, drafts a contract \u2014 carrying the quote's negotiated\n *   `payment_terms` onto it, and filling what the quote cannot express from\n *   `DRAFT_CONTRACT_DEFAULTS`, declared placeholders rather than decisions\n *   (#1129) \u2014 and pushes the linked opportunity to `closed_won`. Two hooks,\n *   `quote_accepted_contract_draft` and `quote_on_accepted`, because only the\n *   draft is elevated (#2014; see its note).\n */\n\n// \u26A0\uFE0F Helpers used by handlers are declared INSIDE each handler \u2014 L2 hook bodies\n// run body-only in the QuickJS sandbox, so module scope is not available at\n// runtime (cf. opportunity.hook.ts).\n\nconst quoteValidation: Hook = {\n  name: 'quote_workflow',\n  // \u26A0\uFE0F Two objects, deliberately (#2060): the freeze below is ONE freeze \u2014 the\n  // quote's and its lines' \u2014 so it lives in one place, judged by one user/system\n  // boundary and carried by one envelope, rather than a second copy of both on\n  // the line. `test/package-ownership.test.ts` reads every name in the list.\n  object: ['crm_quote', 'crm_quote_line_item'],\n  events: ['beforeInsert', 'beforeUpdate'],\n  priority: 200,\n  description: 'Default expiration date; freeze accepted/expired quotes and their lines.',\n  handler: async (ctx: HookContext) => {\n    // The refusal envelope. \u26A0\uFE0F Mirrored from `src/sales/objects/_refusal.ts` because a lowered\n    // body has no module scope and `extractHookBody` THROWS on an import;\n    // `test/refusal-envelope.test.ts` pins every copy against it.\n    function refuse(\n      message: string,\n      code: string,\n      status: number,\n      userMessage: string = message,\n    ): Error {\n      const err = new Error(message) as Error & {\n        code: string;\n        status: number;\n        userMessage: string;\n      };\n      err.code = code;\n      err.status = status;\n      err.userMessage = userMessage;\n      return err;\n    }\n    const { event, input, previous } = ctx;\n\n    // \u2500\u2500\u2500 A settled quote's LINES are frozen with it (#2060 item 1, B-09) \u2500\u2500\n    //\n    // Measured on 17.7.0 before this branch: a rep added a line to an accepted\n    // quote (200), `quote_total_rollup` rightly left the settled totals alone,\n    // and the quote's lines stopped summing to them. The doc promises the\n    // opposite (`content/docs/sales/quotes.mdx`, \"the quote is frozen\").\n    //\n    // The freeze's own boundary, not a second one: USER writes only (a seed or\n    // import carries no user and is let through, as below), and an update is\n    // judged by what it CHANGES, like `violating` below \u2014 `id` addresses the\n    // row, `updated_at` / `updated_by` are the engine's stamps (measured on every\n    // user update), and `line_number` is the read-only platform ordinal, which\n    // the 4.0.0 one-time back-fill touches with `{ line_number: null }` on every\n    // unnumbered line, settled quotes included. Both parents are judged, so a\n    // line moves neither onto a settled quote nor off one.\n    //\n    // \u26A0\uFE0F DELETE is not guarded, pending a decision on #2060: deleting a quote,\n    // or the account it cascades from, deletes its lines AS THE DELETING USER\n    // (measured: each line's `beforeDelete` sees that user), and no declared\n    // hook-context key tells that cascade from a hand delete of one line \u2014 so a\n    // delete guard would make every settled quote with lines undeletable.\n    if (ctx.object === 'crm_quote_line_item') {\n      const changed = Object.keys(input).some((k) => !['id', 'updated_at', 'updated_by', 'line_number'].includes(k) && input[k] !== previous?.[k]);\n      for (const id of new Set([input.crm_quote, previous?.crm_quote])) {\n        const q = changed && ctx.user?.id && typeof id === 'string' && id\n          ? await (ctx.api as HookApi | undefined)?.object('crm_quote').findOne({ where: { id }, fields: ['quote_number', 'name', 'status'] })\n          : null;\n        if (q?.status === 'accepted' || q?.status === 'expired') {\n          throw refuse(`Quote ${String(q.quote_number)} - ${String(q.name)} is ${q.status}, so its line items can no longer be added or changed.`, 'RECORD_LOCKED', 409);\n        }\n      }\n      return;\n    }\n\n    // The quote as every quote surface titles it. `crm_quote.display_title` is\n    // `quote_number - name`; compose the same pair from the two stored columns\n    // rather than appending the record id. A lowered hook body cannot read the\n    // formula field itself, and both of its sources are already on the\n    // pre-image \u2014 the number is an engine-issued autonumber, so it is read from\n    // `previous` only. Both refusals below name the quote with it.\n    function subject(): string {\n      const label = [previous?.quote_number, previous?.name].map((v) => (typeof v === 'string' ? v.trim() : '')).filter(Boolean).join(' - ');\n      return label ? `Quote ${label}` : 'Quote';\n    }\n\n    /**\n     * `iso` + `days`, on ONE calendar \u2014 UTC, end to end.\n     *\n     * The base is not an instant here, it is a stored DATE: a bare\n     * `YYYY-MM-DD` is parsed by the date-only form of the spec, which anchors\n     * it at UTC midnight (measured: `new Date('2026-01-01')` is\n     * `2026-01-01T00:00:00.000Z` in every zone). So the anchor was already\n     * UTC and only the arithmetic was not \u2014 and reading a UTC-midnight anchor\n     * on the LOCAL calendar is off by a whole day west of Greenwich, where\n     * that instant is the previous evening (`getDate()` on the value above\n     * answers 31, not 1).\n     *\n     * That is why this site's exposure is not the one-hour window the\n     * \"advance now by N days\" hooks have: the anchor does not move with the\n     * clock, so every quote whose [quote_date, quote_date + days] span crosses\n     * a DST transition took a 23 h day and rendered a day short \u2014 measured at\n     * 60 of 730 consecutive base dates in `America/New_York`, `Europe/Berlin`,\n     * `America/Santiago`, `Australia/Sydney` and `Pacific/Auckland` alike.\n     */\n    function addDays(iso: string, days: number): string {\n      const d = new Date(iso);\n      d.setUTCDate(d.getUTCDate() + days);\n      return d.toISOString().slice(0, 10);\n    }\n\n    if (event === 'beforeInsert' && !input.expiration_date) {\n      const base = typeof input.quote_date === 'string' ? input.quote_date : new Date().toISOString().slice(0, 10);\n      input.expiration_date = addDays(base, 30);\n    }\n\n    // \u26A0\uFE0F Guard ONLY genuine USER edits (`ctx.user?.id` present). System / seed /\n    // backfill writes carry no user and legitimately re-apply business fields\n    // (the seed's quote_date/expiration_date re-evaluate on every reboot), so\n    // guarding them throws boot-time BodyRunner errors. Matches the system-write\n    // convention used across the case/lead/opportunity hooks.\n    if (event === 'beforeUpdate' && previous && ctx.user?.id) {\n      const frozen = previous.status === 'accepted' || previous.status === 'expired';\n      if (frozen) {\n        const allowed = new Set(['internal_notes']);\n        // Framework-managed columns (ownership, audit timestamps) are re-stamped\n        // by the 9.x runtime \u2014 never treat those system writes as edits to a\n        // frozen quote, only user changes to business fields.\n        const SYSTEM_FIELDS = new Set([\n          'id', 'owner_id', 'created_at', 'updated_at', 'created_by', 'updated_by', 'space_id', 'organization_id', 'org_id', 'version',\n        ]);\n        // \u26A0\uFE0F `violating` rather than `changed`: the three freeze guards share\n        // one reference-cleanup predicate verbatim, and a shared block can only\n        // be shared if it reads the same variable in all three.\n        const violating = Object.keys(input).filter(\n          (k) => !allowed.has(k) && !SYSTEM_FIELDS.has(k) && input[k] !== previous[k],\n        );\n        if (violating.length > 0) {\n          // Every lookup on `crm_quote` a referential clear can attack.\n          const REFERENCE_FIELDS = new Set(['crm_account', 'crm_contact', 'crm_opportunity']);\n          // \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500 the reference-cleanup yield \u2500\u2500\n          // #720. The engine implements `deleteBehavior: 'set_null'` by UPDATING\n          // the row that HOLDS the lookup, so deleting the opportunity (or the\n          // contact) an ACCEPTED quote references arrives here as an ordinary\n          // user `beforeUpdate` \u2014 and this freeze refused it, which made a\n          // settled quote able to keep a deal, a person and (through the\n          // master-detail cascade) that person's account undeletable forever.\n          //\n          // Measured on 17.1.0 \u2014 the version this repo pinned AT THE TIME of\n          // the measurement, not the current pin (the cascade shape below has\n          // NOT been re-measured on any later pin \u2014 not 17.3.0, #1676, not\n          // 17.4.0, PR #1814, and not 17.5.0) \u2014 with a probe hook at priority 199 immediately\n          // ahead of each guard, not assumed.\n          // The engine builds its cleanup write on the CALLER's own context\n          // plus two engine keys, so on the path a REST `DELETE` takes, the\n          // cascade and a user's hand-clear of the same lookup are identical\n          // everywhere a guard can look: payload\n          // `{ id, <link>: null, updated_at, updated_by }`, `ctx.user` the\n          // CALLER, `ctx.session` the caller's own `{ userId, isSystem }`.\n          // (Both `updated_by` and the identity drop out together when the\n          // DELETE itself carried no `userId` \u2014 a rig artefact, not this app's\n          // path.) So the WRITE SHAPE is not a discriminator, and the yield\n          // below is not one either: it lets ANY caller clear a declared link\n          // on a settled record. That is the trade #720 accepted, not a side\n          // effect of it.\n          //\n          // \u26A0\uFE0F A marker DOES reach a hook \u2014 and is deliberately not read. An\n          // earlier version of this note concluded \"no marker reaches a hook,\n          // and the WRITE SHAPE is the only evidence there is\"; it reasoned\n          // only about `ctx.session`, whose allow-list really does omit\n          // `__`-prefixed operation-private keys, and missed the other route\n          // into the context. `ObjectQL.cascadeDeleteRelations` builds\n          // `{ ...context, __referentialFieldClear: true }`, readable at\n          // `ctx.api.executionContext.__referentialFieldClear`: measured `true`\n          // on every cascade into `crm_opportunity`, `crm_quote` and\n          // `crm_lead`, `undefined` on every hand-clear (#1165, #1412).\n          //\n          // \u26D4 The #1165 ruling (2026-08-25) reviewed that and upheld NOT\n          // reading it, on two grounds. It is an operation-private key \u2014 an\n          // undeclared dependency that can vanish in a patch release. And\n          // reachability through the SHIPPED path is unproven: a hook body runs\n          // body-only in QuickJS, where `buildSandboxApi` passes `engineCtx.api`\n          // only when that exposes `object()`, and otherwise a shim with no\n          // `executionContext` at all. Green in a kernel rig and silently false\n          // in production is the worst outcome a guard can have. The declared\n          // replacement `ctx.referentialFieldClear` is asked for upstream as\n          // objectstack-ai/objectstack#13644.\n          //\n          // \u26D4 Keep this narrow (maintainer's ruling on #720, Option A): a write\n          // yields ONLY when every one of its non-system changes is a DECLARED\n          // link going from a value to `null`. One business field alongside it,\n          // or a link repointed to a NEW value, and the refusal below still\n          // fires. The three freeze guards share this block verbatim \u2014 sharing\n          // it as an imported helper is not possible (hook bodies run body-only\n          // in the sandbox and cannot reach module scope), so\n          // `test/freeze-guard-reference-cleanup.test.ts` pins the three copies\n          // as identical text and pins both directions of the narrowness.\n          const isReferenceCleanup = violating.every(\n            (k) => REFERENCE_FIELDS.has(k) && input[k] === null && previous?.[k] != null,\n          );\n          if (isReferenceCleanup) return;\n\n          const what = `${subject()} is ${previous.status as string}`;\n          throw refuse(`${what}; only internal_notes may be edited. Attempted: ${violating.join(', ')}.`, 'RECORD_LOCKED', 409);\n        }\n      }\n\n      // \u2500\u2500\u2500 An acceptance the linked deal's approval holds (#2014) \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n      //\n      // Accepting a quote closes its opportunity as won (`quote_on_accepted`,\n      // as the CALLER). While an approval holds that deal, that close is\n      // refused \u2014 and it used to be refused one write too late: the acceptance\n      // was admitted, the close-won met the refusal inside an `async` hook,\n      // `onError: 'log'` swallowed it, and an accepted (therefore frozen) quote\n      // sat on an open deal it could never close again (measured on 17.7.0: a\n      // sales rep, a deal pending its Large Deal Approval). Maintainer ruling\n      // on #2014 (option C): refuse the ACCEPTANCE, at the moment it is made,\n      // so an approval stays an approval and the rep learns why.\n      //\n      // \"Held\" is exactly what makes that close-won fail, measured per state\n      // on 17.7.0 with a rep's direct close \u2014 no wider:\n      //   \u2022 `approval_status` `pending`: the Large Deal Approval's request is\n      //     open, and its approval node locks the record (`lockRecord: true`)\n      //     \u2192 the platform's RECORD_LOCKED. The column is the node's own\n      //     mirror of the live request (`approvalStatusField`); a recalled or\n      //     decided request leaves it `rejected` / `approved`, and neither\n      //     holds the deal (the close goes through on both);\n      //   \u2022 `status_change_approval_status` `pending` or `rejected` (REQ-0006,\n      //     once an install arms it) \u2192 `opportunity_lifecycle`'s refusal of a\n      //     direct close; with a request open the platform lock holds too;\n      //   \u2022 `qualification_approval_status` `pending` or `rejected` (the \u7ACB\u9879\n      //     gate, once armed) \u2192 `opportunity_lifecycle`'s refusal of any stage\n      //     move. Its approval node does NOT lock the record (`lockRecord:\n      //     false`); the refusal is the app's gate, and it is mirrored for that.\n      // A closed deal is never close-won again, so it holds nothing here.\n      //\n      // \u26A0\uFE0F BOUNDARIES, recorded rather than hidden. Read as the CALLER: a deal\n      // the caller cannot read cannot be closed by them either, for a reason\n      // that is not an approval, and that is not this gate's to name \u2014 so an\n      // unreadable deal, or a read that fails, stands down. USER writes only,\n      // the boundary the freeze above draws: a system write's close-won is not\n      // held by the lock or by either app gate (both judge users), so refusing\n      // its acceptance would be wider than the condition it mirrors.\n      if (input.status === 'accepted' && previous.status !== 'accepted') {\n        const dealId = [input.crm_opportunity, previous.crm_opportunity].find((v) => typeof v === 'string' && v);\n        const deal = dealId\n          ? await (ctx.api as HookApi | undefined)?.object('crm_opportunity').findOne({\n            where: { id: dealId },\n            fields: ['stage', 'approval_status', 'status_change_approval_status', 'qualification_approval_status'],\n          }).catch(() => null)\n          : null;\n        // Each hold is named by the field label and value the rep sees on the\n        // deal itself, so the sentence points at where to look. A `rejected`\n        // Large Deal Approval holds nothing (measured: the close goes through).\n        const held = deal && !String(deal.stage).startsWith('closed_')\n          ? [['approval_status', 'Approval Status'], ['status_change_approval_status', 'Status Change Approval'], ['qualification_approval_status', 'Qualification Approval']]\n            .filter(([f]) => deal[f] === 'pending' || (deal[f] === 'rejected' && f !== 'approval_status'))\n            .map(([f, label]) => `${label} is ${deal[f] === 'pending' ? 'Pending' : 'Rejected'}`)\n          : [];\n        // The quote has exactly one opportunity, so \"its opportunity\" names the\n        // deal unambiguously \u2014 and \u26D4 never by its record id.\n        if (held.length > 0) {\n          const what = `${subject()} cannot be accepted while its opportunity is held by an approval`;\n          throw refuse(`${what} (${held.join('; ')}): accepting it would close that deal as won. Accept it once the approval is granted.`, 'RECORD_LOCKED', 409);\n        }\n      }\n    }\n  },\n};\n\n/**\n * On acceptance: draft the contract.\n *\n * ## `runAs: 'system'`, and why the close-won is a separate hook (#2014)\n *\n * A sales rep holds `crm_contract.allowCreate: false`, and a rep accepting the\n * quote on their own deal is the ordinary CPQ path \u2014 so as the caller the\n * draft was refused (\"You do not have permission\"), `onError: 'log'` swallowed\n * it, and the deal went `closed_won` with no contract (measured on 17.7.0).\n * The draft is the business's paperwork for a sale the rep is entitled to\n * record, not the rep authoring a contract, so this hook elevates (AGENTS.md\n * rule 9); the rep still cannot create a contract by hand. Elevation is not\n * anonymity: the contract's `created_by` names the person who accepted.\n *\n * Elevating as little as possible is why the close-won is NOT here. `runAs` is\n * per hook, and a system write is not held by an approval's record lock:\n * elevated, an accepted quote would close a deal its manager has not approved.\n * `quote_on_accepted` keeps that write the caller's. The two were already\n * independent legs (#714) \u2014 a contract that will not draft must not decide\n * whether the deal is won \u2014 and two hooks make that structural.\n *\n * Organization (AGENTS.md rule 10): it issues no read, so there is no scan to\n * pin; its one write is an insert built from the triggering quote's own links,\n * and the engine stamps its `organization_id` from the trigger's context, which\n * elevation carries through unchanged (`withRunAs('system')` is the triggering\n * context plus `isSystem`) \u2014 pinned on a walled deployment by\n * `test/hook-org-inheritance.test.ts`.\n */\nconst quoteAcceptedContractDraft: Hook = {\n  name: 'quote_accepted_contract_draft',\n  object: 'crm_quote',\n  events: ['afterUpdate'],\n  priority: 800,\n  async: true,\n  onError: 'log',\n  runAs: 'system',\n  description: 'Draft the accepted quote\u2019s contract.',\n  handler: async (ctx: HookContext) => {\n    const { input, previous } = ctx;\n    if (input.status !== 'accepted' || previous?.status === 'accepted') return;\n    const api = ctx.api as HookApi | undefined;\n    if (!api) return;\n\n    // Real calendar months \u2014 `days * 30` shorted a 12-month term by ~5 days\n    // and only slipped past contract_validation's \u00B11-month tolerance by luck.\n    //\n    // On the UTC calendar throughout, for the reason `addDays` documents in\n    // the sibling hook above: the base is a UTC-midnight-anchored date string,\n    // so a local `getMonth`/`setMonth` step reads that anchor as the previous\n    // evening and renders a day short whenever the offset at the end of the\n    // term differs from the offset at its start. A 12-month term makes that\n    // rare but not absent \u2014 measured on 9 of 730 consecutive start dates in\n    // `America/New_York` (e.g. `2026-11-02` + 12 months answered\n    // `2027-11-01`), and it is `crm_contract.end_date`, a date the customer is\n    // invoiced against.\n    function addMonths(iso: string, months: number): string {\n      const d = new Date(iso);\n      d.setUTCMonth(d.getUTCMonth() + months);\n      return d.toISOString().slice(0, 10);\n    }\n\n    /**\n     * First candidate that is a non-empty record id, or `undefined` (#714).\n     *\n     * The id chains here used to be written `(typeof a === 'string' && a) || (typeof\n     * b === 'string' && b)`, whose value when NEITHER operand holds is boolean\n     * `false` \u2014 not `undefined`. `false` is a VALUE: it went into the contract\n     * document as the content of a lookup, and a lookup column takes a record id\n     * or nothing at all. What the engine did with it depends on the deployment's\n     * ADR-0104 value-shape posture, and both outcomes are wrong:\n     *\n     *   - warn-first (a deployment that has not run `os migrate value-shapes\n     *     --apply`): the write is ADMITTED with a `[value-shape] \u2026 accepted for\n     *     now` warning, and `crm_contact = false` is persisted into a reference\n     *     column \u2014 a row the value-shape scan will later refuse to convert;\n     *   - strict (after that gate, or `OS_DATA_VALUE_SHAPE_STRICT_ENABLED=1`):\n     *     `ValidationError: Primary Contact has an invalid lookup value: Invalid\n     *     input: expected string, received boolean`, which aborted this whole\n     *     handler \u2014 so no contract, and the close-won leg below never ran.\n     *\n     * `undefined` is the only correct \"there is no id here\": it does not survive\n     * the JSON hop into the engine, and the writes below drop the key outright,\n     * so an absent optional link is an ABSENT COLUMN rather than a junk value.\n     */\n    const pickId = (...candidates: unknown[]): string | undefined =>\n      candidates.find((c): c is string => typeof c === 'string' && c !== '');\n\n    const accountId = pickId(input.crm_account, previous?.crm_account);\n    const contactId = pickId(input.crm_contact, previous?.crm_contact);\n    const opportunityId = pickId(input.crm_opportunity, previous?.crm_opportunity);\n    const ownerId = pickId(input.owner_id, previous?.owner_id, ctx.user?.id);\n    const totalPrice = [input.total_price, previous?.total_price].find((v) => typeof v === 'number') ?? 0;\n\n    /**\n     * The payment terms the customer actually negotiated.\n     *\n     * Quote and Contract share one `payment_terms` vocabulary because an\n     * accepted quote's terms carry over to the contract \u2014 but only if something\n     * carries them. Without this the drafted contract takes\n     * `crm_contract.payment_terms`'s own option default `net_30` on every\n     * accepted quote, including one negotiated at `due_on_receipt`; and the\n     * contract's `payment_terms` is one of the fields\n     * `src/revenue/flows/billing-handoff-contract-activated.flow.ts` POSTs to\n     * billing when the contract activates, so a defaulted term becomes an\n     * invoicing term.\n     *\n     * Read like `totalPrice` above: the patch's value when the accepting write\n     * carried one, else the value already on the quote \u2014 `pickId`'s rule\n     * exactly (the first non-empty string), so it is read with `pickId`. A\n     * quote that never chose a term yields `undefined`, which drops the key and\n     * lets the contract's own default apply.\n     */\n    const paymentTerms = pickId(input.payment_terms, previous?.payment_terms);\n\n    const today = new Date().toISOString().slice(0, 10);\n\n    /**\n     * PLACEHOLDER DEFAULTS \u2014 declared as defaults, NOT decided as business\n     * facts (#1129 ruling, 2026-08-31). An auto-drafted contract is a STARTING\n     * DRAFT an admin completes, not a faithful transcription of what was sold.\n     * `crm_contract` requires all three, a quote can express none of them, so\n     * the hook has to supply something; none of it is evidence about the deal:\n     *\n     *   - `contract_term_months` \u2014 `required + notNull + min: 1` on the\n     *     contract, and the quote has nowhere to record a term. 12 is a guess\n     *     with nothing behind it;\n     *   - `contract_type` \u2014 the contract declares six values (subscription /\n     *     service / license / partnership / nda / msa) and NO option default,\n     *     so this line is the only thing that ever picks one: every\n     *     auto-drafted contract in the app is a subscription and the other\n     *     five types are unreachable on this path. It does not stay here\n     *     either \u2014\n     *     `src/revenue/flows/billing-handoff-contract-activated.flow.ts`\n     *     POSTs `contract_type` to billing when the contract activates;\n     *   - `start_date` \u2014 the one member that is not a literal: the date the\n     *     quote happened to be ACCEPTED, which is not necessarily the date the\n     *     customer's term begins. A placeholder RULE rather than a placeholder\n     *     value. It sits in the block because the block is itself per-draft:\n     *     an L2 body has no module scope at runtime (see the file header), so\n     *     these are handler-local by construction, not module constants.\n     *\n     * `end_date` is not a fourth default \u2014 it is DERIVED from the two above\n     * (`addMonths`, real calendar months), so it inherits their guesses rather\n     * than adding one of its own.\n     *\n     * \u26D4 Do not read these as decisions and do not quietly re-tune them. The\n     * alternative \u2014 the quote carrying a real term and type so the draft\n     * transcribes what was sold \u2014 is option A of #1129: recorded, not\n     * undertaken, unfrozen only by measured evidence that real sales processes\n     * fix the term and type at acceptance time. This block is then the list of\n     * values that move onto `crm_quote`. Leaving them unmarked was excluded by\n     * the same ruling: an unmarked hardcode is exactly how the `payment_terms`\n     * drift of #873 happened.\n     */\n    const DRAFT_CONTRACT_DEFAULTS = {\n      contract_term_months: 12,\n      contract_type: 'subscription',\n      start_date: today,\n    } as const;\n\n    // The contract's ONE field explaining where it came from. \u26D4 Never a record\n    // id: `Auto-drafted from accepted quote MvNopWgEDZwm2T5L` names a string no\n    // surface in this app ever shows, on a quote every screen calls `QTE-0006`.\n    // Name it the way `crm_quote.display_title` does. Unlike the task sites in\n    // this class there is no relationship field to hold the id afterwards \u2014\n    // `crm_contract` links account, contact and opportunity but not the quote \u2014\n    // so this sentence is the whole provenance record and had better be\n    // readable. `quote_number` is an engine-issued autonumber and never appears\n    // on an update payload, so it is read from the pre-image alone; `name` can\n    // be changing in this very write.\n    const trimmed = (v: unknown): string => (typeof v === 'string' ? v.trim() : '');\n    const quoteLabel = [trimmed(previous?.quote_number), [input.name, previous?.name].map(trimmed).find(Boolean)].filter(Boolean).join(' - ');\n\n    // Only lookups we actually HAVE are written. A missing optional link is an\n    // absent key \u2014 never `false` (see `pickId`), and never `null` either: `null`\n    // is a legal shape for the optional `crm_opportunity` but not for the\n    // required `crm_contact`, and one idiom for both is what keeps this honest.\n    const contract: Record<string, unknown> = {\n      ...DRAFT_CONTRACT_DEFAULTS,\n      status: 'draft',\n      end_date: addMonths(DRAFT_CONTRACT_DEFAULTS.start_date, DRAFT_CONTRACT_DEFAULTS.contract_term_months),\n      contract_value: totalPrice,\n      description: quoteLabel ? `Auto-drafted from accepted quote ${quoteLabel}` : 'Auto-drafted from an accepted quote',\n    };\n    if (accountId) contract.crm_account = accountId;\n    if (contactId) contract.crm_contact = contactId;\n    if (opportunityId) contract.crm_opportunity = opportunityId;\n    if (ownerId) contract.owner_id = ownerId;\n    // Same idiom for the same reason: written only when the quote HAS a term,\n    // so \"the quote chose nothing\" stays an absent key rather than becoming a\n    // value the contract's default would otherwise have supplied.\n    if (paymentTerms) contract.payment_terms = paymentTerms;\n\n    // What the draft deliberately does NOT carry (#1129 ruling, 2026-08-31) \u2014\n    // DECIDED, not overlooked. `crm_quote.shipping_terms` and\n    // `crm_quote.shipping_address` have no counterpart column on\n    // `crm_contract` at all; `crm_quote.billing_address` has one and is left\n    // for the admin completing the draft; and the quote's `description` would\n    // displace the provenance sentence written above, which is this contract's\n    // only record of where it came from. Copying any of them is part of option\n    // A (faithful transcription) and unfreezes with it, not before.\n\n    try {\n      await api.object('crm_contract').insert(contract);\n    } catch (err) {\n      // `crm_quote.crm_contact` is deliberately optional while\n      // `crm_contract.crm_contact` is `required + notNull`, so a quote accepted\n      // without a recipient legitimately lands here with \"Primary Contact is\n      // required\". That refusal is the documented behaviour, not a defect \u2014\n      // `content/docs/sales/quotes.mdx` already tells reps to put the contact on\n      // the quote first, because \"what the quote does not carry, acceptance\n      // cannot pass on\". The refusal is truthful (a named missing field, not\n      // \"received boolean\"), and since the close-won lives in its own hook it\n      // can no longer take that leg with it.\n      //\n      // DELIBERATELY BARE, like the close-won one in `quote_on_accepted`: a\n      // cascade fault the accepting user neither caused nor can act on, so a\n      // 500, never a 4xx refusal envelope (#1075). It names the quote the way\n      // every screen does \u2014 the label composed above \u2014 never by its id (#1243).\n      throw new Error(`could not draft the contract for quote ${quoteLabel}: ${(err as Error).message}`);\n    }\n  },\n};\n\n/**\n * On acceptance: push the linked opportunity to `closed_won`.\n *\n * Deliberately NOT elevated \u2014 the reason is on `quote_accepted_contract_draft`\n * above: this write stays the accepting caller's, so the opportunity's own\n * guards and an approval's record lock judge it as they always have. A deal an\n * approval holds is refused at the acceptance itself (`quote_workflow`), so this\n * write no longer meets that lock on a user's acceptance.\n */\nconst quoteAccepted: Hook = {\n  name: 'quote_on_accepted',\n  object: 'crm_quote',\n  events: ['afterUpdate'],\n  priority: 800,\n  async: true,\n  onError: 'log',\n  description: 'Close-win the accepted quote\u2019s opportunity.',\n  handler: async (ctx: HookContext) => {\n    const { input, previous } = ctx;\n    if (input.status !== 'accepted' || previous?.status === 'accepted') return;\n    const api = ctx.api as HookApi | undefined;\n    // A record id or nothing \u2014 never boolean `false` (#714; the full note is on\n    // `pickId` in `quote_accepted_contract_draft`).\n    const id = [input.crm_opportunity, previous?.crm_opportunity].find((v): v is string => typeof v === 'string' && v !== '');\n    if (!api || !id) return;\n\n    try {\n      const opp = await api.object('crm_opportunity').findOne({ where: { id } });\n      // A deal already closed, won or lost, is left where it is.\n      if (opp && !String(opp.stage).startsWith('closed_')) {\n        // `crm_opportunity.win_reason` is `requiredWhen` stage is closed_won\n        // (#593), and this write is the ONE close path with no human in it to\n        // attribute the win \u2014 so without a value here the CPQ leg would be\n        // rejected by the engine on every accepted quote. `quote_accepted`\n        // names the automated path rather than guessing a rep's answer; keep\n        // the reason the rep already recorded if there is one.\n        const won = { id, stage: 'closed_won', close_date: new Date().toISOString().slice(0, 10) };\n        await api.object('crm_opportunity').update({ ...won, ...(opp.win_reason ? {} : { win_reason: 'quote_accepted' }) }, { where: { id } });\n      }\n    } catch (err) {\n      // DELIBERATELY BARE \u2014 one of the two throws in this file the #1075 sweep\n      // left alone (the other is the contract draft's, above). Every other\n      // throw here is a business refusal: the user asked for something the\n      // rules forbid, and an envelope tells their client which rule. This one\n      // is the opposite. It fires from an `afterUpdate` cascade when close-won\n      // bookkeeping FAILED for reasons the user did not cause and cannot act\n      // on, so it is a server fault and belongs in the 5xx band. A bare Error is\n      // already mapped to `500 / INTERNAL_ERROR` by `resolveThrownHttpError`,\n      // which is the correct answer \u2014 dressing it in a 4xx refusal code would\n      // file a broken cascade as user error. It names the quote by its number,\n      // the engine's autonumber every screen shows \u2014 never a record id (#1243).\n      throw new Error(`could not close-won the opportunity of quote ${String(previous?.quote_number)}: ${(err as Error).message}`);\n    }\n  },\n};\n\nexport default [quoteValidation, quoteAcceptedContractDraft, quoteAccepted];\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/revenue/objects/quote_line_item.hook.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/revenue/objects\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/revenue/objects/quote_line_item.hook.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport type { Hook, HookContext } from '@objectstack/spec/data';\nimport type { HookApi } from '../../sales/objects/_hook-api';\nimport { createLineItemNumbering, createLineItemPriceFill } from './_line-item-price-fill';\n\n/**\n * Quote total rollup.\n *\n * Keeps a quote's pricing (`subtotal` / `discount_amount` / `total_price`) in\n * sync with the sum of its line items. Fires after a quote line item is\n * inserted / updated / deleted (the console surfaces these as the quote's\n * \"Line Items\" related list).\n *\n * Why this exists: `quote_generation` seeds the quote totals from the source\n * opportunity's amount at create time, but nothing kept them in step once a\n * rep edited the line items \u2014 the quote total and its itemization could drift.\n *\n * Total model (mirrors the quote_generation flow):\n *   subtotal        = \u03A3 line (quantity \u00D7 unit_price \u00D7 (1 \u2212 line_discount/100))\n *   discount_amount = subtotal \u00D7 quote.discount%              (quote-level)\n *   total_price     = subtotal \u2212 discount_amount + tax + shipping_handling\n * Quote-level `tax` and `shipping_handling` stay manual; only the line-derived\n * figures are rolled up.\n *\n * Design decisions mirror opportunity_line_item.hook:\n * - recompute from raw `quantity/unit_price/discount` (not the `subtotal`\n *   FORMULA field) so it doesn't depend on formula hydration in the sandbox;\n * - leave totals untouched when there are NO lines (never zero a quote whose\n *   totals came from the opportunity);\n * - skip accepted / expired quotes \u2014 the rollup runs system-context and would\n *   otherwise bypass the quote freeze guard and rewrite a settled quote;\n * - async + onError:'log' \u2014 a derived convenience, never blocks the line write;\n * - handles re-parenting (old + new quote).\n */\n/**\n * Line-item price fill \u2014 one implementation shared with the opportunity line\n * item; see `_line-item-price-fill.ts` for the behaviour and the sandbox caveat.\n */\nconst quoteLineItemPriceFill: Hook = createLineItemPriceFill(\n  'crm_quote_line_item',\n  'quote_line_item_price_fill',\n);\n\n/** `line_number` assigner \u2014 see `_line-item-price-fill.ts` (#1828). */\nconst quoteLineItemNumbering: Hook = createLineItemNumbering(\n  'crm_quote_line_item',\n  'quote_line_item_line_number',\n);\n\nconst quoteTotalRollup: Hook = {\n  name: 'quote_total_rollup',\n  object: 'crm_quote_line_item',\n  events: ['afterInsert', 'afterUpdate', 'afterDelete'],\n  priority: 300,\n  async: true,\n  onError: 'log',\n  description: 'Recompute parent quote subtotal/discount/total from its line items.',\n  handler: async (ctx: HookContext) => {\n    const api = ctx.api as HookApi | undefined;\n    if (!api) return;\n    const { input, previous } = ctx;\n    const num = (v: unknown): number => (typeof v === 'number' ? v : 0);\n\n    const quoteIds = new Set<string>();\n    for (const v of [input?.crm_quote, previous?.crm_quote]) {\n      if (typeof v === 'string' && v) quoteIds.add(v);\n    }\n    if (quoteIds.size === 0) return;\n\n    for (const quoteId of quoteIds) {\n      const quote = await api.object('crm_quote').findOne({\n        where: { id: quoteId },\n        fields: ['id', 'status', 'discount', 'tax', 'shipping_handling'],\n      });\n      if (!quote) continue;\n      const status = typeof quote.status === 'string' ? quote.status : undefined;\n      if (status === 'accepted' || status === 'expired') continue;\n\n      const lines = await api.object('crm_quote_line_item').find({\n        where: { crm_quote: quoteId },\n        fields: ['quantity', 'unit_price', 'discount'],\n        top: 5000,\n      });\n      // No lines left \u2192 leave the flow-seeded totals as-is (see design note).\n      if (!lines || lines.length === 0) continue;\n\n      let subtotal = 0;\n      for (const l of lines) subtotal += num(l.quantity) * num(l.unit_price) * (1 - num(l.discount) / 100);\n      subtotal = Math.round(subtotal * 100) / 100;\n\n      const discountAmount = Math.round(subtotal * (num(quote.discount) / 100) * 100) / 100;\n      const total = Math.round((subtotal - discountAmount + num(quote.tax) + num(quote.shipping_handling)) * 100) / 100;\n\n      await api.object('crm_quote').update(\n        { id: quoteId, subtotal, discount_amount: discountAmount, total_price: total },\n        { where: { id: quoteId } },\n      );\n    }\n  },\n};\n\nexport default [quoteLineItemPriceFill, quoteLineItemNumbering, quoteTotalRollup];\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/marketing/objects/campaign.hook.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/marketing/objects\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/marketing/objects/campaign.hook.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport type { Hook, HookContext } from '@objectstack/spec/data';\nimport type { HookApi } from '../../sales/objects/_hook-api';\n\n/**\n * Campaign lifecycle hooks.\n *\n * - `campaign_validation` \u2014 start/end date ordering, and no `in_progress`\n *   without both dates.\n * - `campaign_metrics_refresh` \u2014 recompute the metric block when the campaign's\n *   own status moves.\n * The other two hooks of this family are attached to objects the SALES package\n * owns, so since the ADR-0130 layout they sit beside those objects instead\n * (plan item 6 \u2014 co-location is what enforces R4):\n *\n * - `campaign_attribution_refresh` (`crm_opportunity`) \u2014\n *   `src/sales/objects/opportunity.campaign-metrics.hook.ts`\n * - `campaign_lead_conversion_refresh` (`crm_lead`) \u2014\n *   `src/sales/objects/lead.campaign-metrics.hook.ts`\n *\n * The membership side of the same recompute lives in `campaign_member.hook.ts`.\n * Together these are what replaced the single completion-time snapshot (#597):\n * every input a campaign metric derives from now has a trigger that refreshes\n * the metric when it changes, so a LIVE campaign reports live numbers instead\n * of zeros until the day it ends.\n *\n * \u26A0\uFE0F WHY THE RECOMPUTE IS WRITTEN OUT FOUR TIMES.\n *\n * L2 hook bodies are lowered to metadata and evaluated BODY-ONLY in the QuickJS\n * sandbox: a handler cannot reach module scope at runtime, so a shared\n * `refreshCampaignMetrics()` import would be a free identifier \u2014 the CLI build\n * silently declines to lower the handler, keeps it in a bundled runtime file,\n * and the hook stops being deployable as pure metadata (the build says so in\n * one line nobody reads). `test/action-sandbox.test.ts` is what catches it.\n *\n * So the arithmetic is inlined per handler, the same way `account_protection`\n * inlines the territory table rather than importing `_territory.ts`. The\n * duplication is NOT trusted: `test/campaign-member-lifecycle.test.ts` lowers\n * all four bodies and asserts the recompute block is character-identical across\n * them, so a fix landing on one copy and skipping three fails a test instead of\n * shipping four definitions of `num_sent`. Splitting the four across three\n * files by owning object changed none of that \u2014 the suite reads them by hook\n * name, not by file.\n */\n\nconst campaignValidation: Hook = {\n  name: 'campaign_validation',\n  object: 'crm_campaign',\n  events: ['beforeInsert', 'beforeUpdate'],\n  priority: 200,\n  description: 'Validate campaign date range and required fields per status.',\n  handler: async (ctx: HookContext) => {\n    // The refusal envelope (#1075). Mirrored from `src/sales/objects/_refusal.ts` because a\n    // lowered body has no module scope and `extractHookBody` THROWS on an\n    // import; `test/refusal-envelope.test.ts` pins every copy against it.\n    function refuse(\n      message: string,\n      code: string,\n      status: number,\n      userMessage: string = message,\n    ): Error {\n      const err = new Error(message) as Error & {\n        code: string;\n        status: number;\n        userMessage: string;\n      };\n      err.code = code;\n      err.status = status;\n      err.userMessage = userMessage;\n      return err;\n    }\n    const { input } = ctx;\n    const previous = ctx.previous;\n    const start =\n      (typeof input.start_date === 'string' && input.start_date) ||\n      (typeof previous?.start_date === 'string' && (previous.start_date as string)) ||\n      undefined;\n    const end =\n      (typeof input.end_date === 'string' && input.end_date) ||\n      (typeof previous?.end_date === 'string' && (previous.end_date as string)) ||\n      undefined;\n    if (start && end && start > end) {\n      throw refuse(`Campaign start_date (${start}) must not be after end_date (${end}).`, 'VALIDATION_FAILED', 400);\n    }\n    const status =\n      (typeof input.status === 'string' && input.status) ||\n      (typeof previous?.status === 'string' && (previous.status as string)) ||\n      undefined;\n    if (status === 'in_progress' && (!start || !end)) {\n      throw refuse('Campaign cannot move to in_progress without both start_date and end_date.', 'VALIDATION_FAILED', 400);\n    }\n  },\n};\n\n/**\n * Recompute this campaign's metrics when its own status moves.\n *\n * \u26A0\uFE0F RECURSION. This hook writes to the object it listens on, so its trigger\n * has to be a condition its own write cannot satisfy. It is: the write carries\n * the metric block and nothing else, and this fires only on a `status`\n * TRANSITION \u2014 `input.status` present AND different from `previous.status`. A\n * metric-only write has no `status` key at all, so the re-entry ends at the\n * first guard. `CAMPAIGN_METRIC_WRITE_KEYS` at the bottom of this file states\n * the other half of that contract as data the runtime test checks the recorded\n * write against, so a future writer that adds a non-metric key to the refresh\n * write fails a test instead of looping in production.\n *\n * The old `campaign_snapshot_metrics` fired on `\u2192 completed` and nothing else,\n * which meant a campaign reported zeros for its entire useful life and became\n * accurate on the day everybody stopped looking at it. Completion is now simply\n * one of the transitions this catches.\n */\nconst campaignMetricsRefresh: Hook = {\n  name: 'campaign_metrics_refresh',\n  object: 'crm_campaign',\n  events: ['afterUpdate'],\n  priority: 800,\n  async: true,\n  onError: 'log',\n  description: 'Recompute the campaign metric block whenever the campaign status moves.',\n  handler: async (ctx: HookContext) => {\n    const { input } = ctx;\n    const previous = ctx.previous;\n    // The recursion guard, stated positively: only a status TRANSITION runs.\n    if (typeof input.status !== 'string') return;\n    if (previous && input.status === previous.status) return;\n    const api = ctx.api as HookApi | undefined;\n    if (!api) return;\n    const campaignId =\n      (typeof input.id === 'string' && input.id) ||\n      (typeof previous?.id === 'string' ? (previous.id as string) : '');\n    if (!campaignId) return;\n    for (const id of [campaignId]) {\n      // \u2500\u2500 recompute \u2500\u2500 identical in all four refresh hooks; see the header.\n      const memberRows = await api.object('crm_campaign_member').find({\n        where: { crm_campaign: id }, fields: ['crm_lead', 'status'], top: 5000,\n      });\n      const leadIds = Array.from(new Set(\n        memberRows.map((r) => (typeof r.crm_lead === 'string' ? r.crm_lead : '')).filter(Boolean),\n      ));\n      const convertedLeads = leadIds.length > 0\n        ? await api.object('crm_lead').count({ where: { id: { $in: leadIds }, is_converted: true } })\n        : 0;\n      const numOpportunities = await api.object('crm_opportunity').count({ where: { crm_campaign: id } });\n      const numWon = await api.object('crm_opportunity').count({ where: { crm_campaign: id, stage: 'closed_won' } });\n      const wonRows = await api.object('crm_opportunity').find({\n        where: { crm_campaign: id, stage: 'closed_won' }, fields: ['amount'], top: 5000,\n      });\n      const actualRevenue = wonRows.reduce(\n        (sum, row) => sum + (typeof row.amount === 'number' ? row.amount : Number(row.amount) || 0), 0,\n      );\n      await api.object('crm_campaign').update({\n        id,\n        num_sent: memberRows.length,\n        num_responses: memberRows.filter((r) => r.status === 'responded' || r.status === 'converted').length,\n        num_leads: leadIds.length,\n        num_converted_leads: convertedLeads,\n        num_opportunities: numOpportunities,\n        num_won_opportunities: numWon,\n        actual_revenue: actualRevenue,\n      }, { where: { id } });\n      // \u2500\u2500 /recompute \u2500\u2500\n    }\n  },\n};\n\n/**\n * The metric block these hooks own. Nothing else may write these columns.\n *\n * Module scope, deliberately OUTSIDE every handler: this is read by the tests,\n * never by a sandboxed body \u2014 a body that referenced it would stop lowering\n * (see the header).\n */\nexport const CAMPAIGN_METRIC_FIELDS: readonly string[] = [\n  'num_sent',\n  'num_responses',\n  'num_leads',\n  'num_converted_leads',\n  'num_opportunities',\n  'num_won_opportunities',\n  'actual_revenue',\n];\n\n/**\n * The recursion contract of `campaign_metrics_refresh`, asserted rather than\n * described: the refresh write may carry the metric block and `id`, nothing\n * else. A comment cannot fail; this is checked against the recorded write.\n */\nexport const CAMPAIGN_METRIC_WRITE_KEYS: readonly string[] = ['id', ...CAMPAIGN_METRIC_FIELDS];\n\nexport default [campaignValidation, campaignMetricsRefresh];\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/marketing/objects/campaign_member.hook.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/marketing/objects\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/marketing/objects/campaign_member.hook.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport type { Hook, HookContext } from '@objectstack/spec/data';\nimport type { HookApi } from '../../sales/objects/_hook-api';\n\n/**\n * Campaign member hooks \u2014 the writers that make the trimmed lifecycle honest\n * (#597).\n *\n * `crm_campaign_member` was the app's clearest case of declared-but-inert\n * metadata: a seven-value engagement lifecycle and two tracker stamps, with the\n * enrollment flow writing `sent` and nothing writing anything else, ever. The\n * object trim removed the values no writer could reach; these three hooks are\n * the other half of that trade \u2014 they give every value that SURVIVED a writer\n * that actually runs.\n *\n * - `campaign_member_lifecycle` (before) \u2014 keeps `has_responded` /\n *   `response_date` in lockstep with `status`, whichever end a caller writes.\n * - `campaign_member_optout_sync` (after) \u2014 round-trips `unsubscribed` to the\n *   member's lead/contact `email_opt_out`.\n * - `campaign_member_metrics_refresh` (after) \u2014 recomputes the campaign's\n *   metric block on every membership change, which is what makes a live\n *   campaign show live numbers.\n *\n * \u26A0\uFE0F The recompute block below is written out here and three more times in\n * `campaign.hook.ts`, deliberately: a sandboxed hook body cannot reach module\n * scope, so a shared import would stop the handler lowering to metadata (see\n * that file's header for the full reasoning). All four copies are asserted\n * character-identical by `test/campaign-member-lifecycle.test.ts`.\n */\n\n/**\n * Keep the response summary fields honest, on every write path.\n *\n * There are two ways a member becomes \"responded\" and they must not disagree:\n * the `mark_responded` action (which stamps all three fields itself) and a rep\n * flipping `status` on the record detail page (which stamps only `status`). The\n * second path is why this hook exists \u2014 without it, a hand-flipped member reads\n * `Responded` on the status badge and `Has Responded: false` two rows below it,\n * and `test/seed-consistency.test.ts`'s \"track the responded status exactly\"\n * contract holds for seeded rows while runtime rows drift out of it.\n *\n * `converted` counts as responded too: a member cannot convert without having\n * responded first, and `has_responded` is the \"did this person ever engage\"\n * flag the response surfaces filter on.\n */\nconst campaignMemberLifecycle: Hook = {\n  name: 'campaign_member_lifecycle',\n  object: 'crm_campaign_member',\n  events: ['beforeInsert', 'beforeUpdate'],\n  priority: 200,\n  description: 'Keep has_responded / response_date in lockstep with the member status.',\n  handler: async (ctx: HookContext) => {\n    // D3 stand-down: a predicate update has ONE payload for every matched row,\n    // so the `ctx.previous`-conditioned writes below would land on rows that\n    // did not earn them \u2014 refused as a diverging key set, or stored silently\n    // from the last row. Full account and the measurement: `forecast.hook.ts`.\n    if (ctx.event === 'beforeUpdate' && ctx.dispatch?.mode === 'per-row') return;\n\n    const { input } = ctx;\n    const previous = ctx.previous;\n    const status =\n      (typeof input.status === 'string' && input.status) ||\n      (typeof previous?.status === 'string' ? (previous.status as string) : undefined);\n    if (!status) return;\n\n    // The responded set is spelled INLINE, not lifted to a module constant: a\n    // sandboxed body cannot reach module scope, and a handler that reads one\n    // stops lowering to metadata (see `campaign.hook.ts`'s header).\n    const responded = status === 'responded' || status === 'converted';\n    const priorStatus = typeof previous?.status === 'string' ? (previous.status as string) : '';\n    const wasResponded = priorStatus === 'responded' || priorStatus === 'converted';\n\n    if (responded) {\n      input.has_responded = true;\n      // Stamp a response date only when the member is CROSSING into a responded\n      // state and does not already carry one. Re-stamping on every later edit\n      // would quietly move the response date forward each time somebody touched\n      // the row, and response-time reporting reads this column.\n      const existing = input.response_date ?? previous?.response_date;\n      if (!wasResponded && (existing === undefined || existing === null || existing === '')) {\n        input.response_date = new Date().toISOString();\n      }\n      return;\n    }\n\n    // Moving BACK out of a responded state (a mis-click corrected, or a member\n    // reset to `sent` for a re-send) clears the summary with it. Leaving\n    // `has_responded: true` behind on a `sent` member is the same disagreement\n    // in the other direction, and it inflates nothing visible \u2014 which is\n    // exactly why it would survive review.\n    if (wasResponded && typeof input.status === 'string') {\n      input.has_responded = false;\n      input.response_date = null;\n      return;\n    }\n    if (ctx.event === 'beforeInsert' && input.has_responded === undefined) {\n      input.has_responded = false;\n    }\n  },\n};\n\n/**\n * Round-trip `unsubscribed` to the person's `email_opt_out`.\n *\n * This closes a loop the app already had one half of: `campaign_enrollment`\n * filters on `email_opt_out: false`, and the `send_email` action hides itself\n * on an opted-out contact \u2014 but NOTHING ever set the flag, so honouring it was\n * a promise about a column no user action could reach. Unsubscribing a member\n * marked the junction row and left the person enrollable by the very next\n * campaign, which is the failure mode an opt-out exists to prevent.\n *\n * Deliberately one-directional: member `unsubscribed` \u21D2 person opted out.\n * The reverse (person opts out \u21D2 close their open memberships) is NOT done\n * here \u2014 a past campaign's membership is a historical record, and rewriting it\n * would falsify what happened at the time.\n *\n * `async` + `onError: 'log'`: the member write is the user's action and must\n * not fail because the lead row is locked or gone. A missed sync is recovered\n * by the next unsubscribe; a rejected write loses the unsubscribe itself.\n *\n * `runAs: 'system'` (#2014, AGENTS.md rule 9). Members are worked by\n * marketing, and a contact is a master-detail child of its account, which a\n * marketing user may not edit \u2014 so the contact write was refused (\"requires\n * edit access to its master record\"), logged and swallowed, and the person\n * stayed enrollable by the next campaign. An unsubscribe has to reach the\n * person whoever recorded it, so the hook elevates; the member write stays the\n * caller's, and `updated_by` on the person still names them. Organization\n * (rule 10): it writes only the lead / contact the triggering member row\n * names, and the elevated `ctx.api` keeps the trigger's tenant.\n */\nconst campaignMemberOptOutSync: Hook = {\n  name: 'campaign_member_optout_sync',\n  object: 'crm_campaign_member',\n  events: ['afterInsert', 'afterUpdate'],\n  priority: 300,\n  async: true,\n  onError: 'log',\n  runAs: 'system',\n  description: 'Sync an unsubscribed member back to the lead/contact email_opt_out flag.',\n  handler: async (ctx: HookContext) => {\n    const api = ctx.api as HookApi | undefined;\n    if (!api) return;\n    const { input } = ctx;\n    const previous = ctx.previous;\n    if (input?.status !== 'unsubscribed') return;\n    // Already unsubscribed \u21D2 already synced. Re-running would be harmless\n    // (the write is idempotent) but it would also re-open a row on every\n    // unrelated edit of an unsubscribed member.\n    if (previous?.status === 'unsubscribed') return;\n\n    const leadId =\n      (typeof input?.crm_lead === 'string' && input.crm_lead) ||\n      (typeof previous?.crm_lead === 'string' ? (previous.crm_lead as string) : undefined);\n    const contactId =\n      (typeof input?.crm_contact === 'string' && input.crm_contact) ||\n      (typeof previous?.crm_contact === 'string' ? (previous.crm_contact as string) : undefined);\n\n    // Exactly one of the two is set \u2014 `lead_or_contact_required` on the object\n    // guarantees at least one, and the enrollment writers never set both. Both\n    // branches run anyway rather than an if/else, so a row that somehow carries\n    // both still opts out both people instead of half of them.\n    if (leadId) {\n      await api.object('crm_lead').update(\n        { id: leadId, email_opt_out: true },\n        { where: { id: leadId } },\n      );\n    }\n    if (contactId) {\n      await api.object('crm_contact').update(\n        { id: contactId, email_opt_out: true },\n        { where: { id: contactId } },\n      );\n    }\n  },\n};\n\n/**\n * Recompute the campaign's metric block on every membership change.\n *\n * THIS is the hook the \"metrics are live\" acceptance criterion rests on:\n * enrolling a member, marking one responded, or removing one moves\n * `num_sent` / `num_responses` / `num_leads` / `num_converted_leads`\n * immediately \u2014 no waiting for the campaign to reach `completed`, which is\n * what the removed `campaign_snapshot_metrics` made everyone wait for.\n *\n * Both sides on update: moving a member between campaigns has to decrement the\n * old campaign as well as increment the new one.\n *\n * No loop: this writes `crm_campaign`, and the campaign-side refresh only fires\n * on a `status` transition, which a metric-only write does not carry.\n *\n * `runAs: 'system'` (#2014, AGENTS.md rule 9). A rollup must not depend on who\n * fired it. Run as a marketing user, the recompute counted only the deals that\n * user may see \u2014 a Private won deal is its owner's alone \u2014 and wrote the\n * smaller numbers over the right ones: measured, `num_won_opportunities` 2 \u2192 1\n * and `actual_revenue` 1,100 \u2192 100 the moment a marketer enrolled a member.\n * Elevated, every member write recomputes the same campaign the same way; the\n * member write itself stays the caller's. Organization (rule 10): every read\n * is keyed to the triggering member's campaign (and the leads that campaign's\n * members name), and the elevated `ctx.api` keeps the trigger's tenant.\n */\nconst campaignMemberMetricsRefresh: Hook = {\n  name: 'campaign_member_metrics_refresh',\n  object: 'crm_campaign_member',\n  events: ['afterInsert', 'afterUpdate', 'afterDelete'],\n  priority: 800,\n  async: true,\n  onError: 'log',\n  runAs: 'system',\n  description: 'Recompute the campaign metric block live whenever its membership changes.',\n  handler: async (ctx: HookContext) => {\n    const api = ctx.api as HookApi | undefined;\n    if (!api) return;\n    const { input } = ctx;\n    const previous = ctx.previous;\n    const campaignIds = Array.from(new Set([\n      typeof input?.crm_campaign === 'string' ? input.crm_campaign : '',\n      typeof previous?.crm_campaign === 'string' ? (previous.crm_campaign as string) : '',\n    ].filter(Boolean)));\n    for (const id of campaignIds) {\n      // \u2500\u2500 recompute \u2500\u2500 identical in all four refresh hooks; see the header.\n      const memberRows = await api.object('crm_campaign_member').find({\n        where: { crm_campaign: id }, fields: ['crm_lead', 'status'], top: 5000,\n      });\n      const leadIds = Array.from(new Set(\n        memberRows.map((r) => (typeof r.crm_lead === 'string' ? r.crm_lead : '')).filter(Boolean),\n      ));\n      const convertedLeads = leadIds.length > 0\n        ? await api.object('crm_lead').count({ where: { id: { $in: leadIds }, is_converted: true } })\n        : 0;\n      const numOpportunities = await api.object('crm_opportunity').count({ where: { crm_campaign: id } });\n      const numWon = await api.object('crm_opportunity').count({ where: { crm_campaign: id, stage: 'closed_won' } });\n      const wonRows = await api.object('crm_opportunity').find({\n        where: { crm_campaign: id, stage: 'closed_won' }, fields: ['amount'], top: 5000,\n      });\n      const actualRevenue = wonRows.reduce(\n        (sum, row) => sum + (typeof row.amount === 'number' ? row.amount : Number(row.amount) || 0), 0,\n      );\n      await api.object('crm_campaign').update({\n        id,\n        num_sent: memberRows.length,\n        num_responses: memberRows.filter((r) => r.status === 'responded' || r.status === 'converted').length,\n        num_leads: leadIds.length,\n        num_converted_leads: convertedLeads,\n        num_opportunities: numOpportunities,\n        num_won_opportunities: numWon,\n        actual_revenue: actualRevenue,\n      }, { where: { id } });\n      // \u2500\u2500 /recompute \u2500\u2500\n    }\n  },\n};\n\nexport default [\n  campaignMemberLifecycle,\n  campaignMemberOptOutSync,\n  campaignMemberMetricsRefresh,\n];\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/sales/flows/lead-conversion.flow.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/sales/flows\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/sales/flows/lead-conversion.flow.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport { P, cel } from '@objectstack/spec';\nimport type * as Automation from '@objectstack/spec/automation';\ntype Flow = Automation.Flow;\n\n/** Lead Conversion \u2014 multi-step screen flow to convert qualified leads */\nexport const LeadConversionFlow: Flow = {\n  name: 'lead_conversion',\n  label: 'Lead Conversion Process',\n  description: 'Automated flow to convert qualified leads to accounts, contacts, and opportunities',\n  type: 'screen',\n  status: 'active',\n\n  variables: [\n    // Named `recordId` to match the console's flow-action invocation contract:\n    // POST /automation/:name/trigger sends { recordId, objectName } and the\n    // dispatcher exposes them as params.recordId / params.crmLeadId. A custom\n    // name like `leadId` never gets seeded (16.x runtime).\n    { name: 'recordId', type: 'text', isInput: true, isOutput: false },\n    // THE authority for the conversion default. `defaultValue` is what makes\n    // declared mean BOUND: the engine seeds every declared variable that\n    // carries one before the run starts, so `createOpportunity` is bound on\n    // every path \u2014 including the one where the screen runner posts back only\n    // the fields the user touched. The screen field below derives its prefill\n    // from this line rather than restating `false`.\n    //\n    // Measured on 17.0.0 GA, by running flows (not by reading the engine):\n    //   \u00B7 declared + nothing supplied  \u2192 bound to `false`; ablating this key\n    //     from the declaration re-fails the read with `No such key:\n    //     createOpportunity`, so the default is what binds it;\n    //   \u00B7 seeded BEFORE the start condition is evaluated, so a start condition\n    //     could read it too;\n    //   \u00B7 a caller-supplied `context.params.createOpportunity` WINS \u2014 the\n    //     boundary is `!== undefined`, so an explicit `false`/`null` is a\n    //     supplied answer, and only absence falls through to this default.\n    // \u26D4 Never seed this with an assignment node instead: an assignment is\n    // unconditional and clobbers a caller-supplied value. All of the above is\n    // pinned in `test/flow-variable-conditions.test.ts`.\n    { name: 'createOpportunity', type: 'boolean', isInput: true, isOutput: false, defaultValue: false },\n    { name: 'opportunityName', type: 'text', isInput: true, isOutput: false },\n    { name: 'opportunityAmount', type: 'text', isInput: true, isOutput: false },\n    // The conversion's close date, collected on the screen below\n    // instead of stamped inside `create_opportunity`. Declared with NO\n    // `defaultValue`, and that is measured rather than chosen: the engine\n    // binds a DECLARATION's default raw \u2014 `seedDeclaredVariables` does a plain\n    // `variables.set(name, defaultValue)` with no `interpolate` call \u2014 so\n    // `{TODAY() + 90}` written here would bind that string verbatim and\n    // `create_opportunity` would post the braces into a date column. Measured\n    // on 17.3.0 by running a probe flow, not by reading the engine. The screen\n    // field is therefore the only layer that can carry the expression, which\n    // is where the +90 lives and why this line is deliberately bare.\n    { name: 'closeDate', type: 'date', isInput: true, isOutput: false },\n  ],\n\n  nodes: [\n    { id: 'start', type: 'start', label: 'Start', config: { objectName: 'crm_lead' } },\n    {\n      id: 'screen_1', type: 'screen', label: 'Conversion Details',\n      config: {\n        // The suspected-duplicate warning. `lead_duplicate_check` flags a\n        // re-captured email at intake and links the record the lead repeats;\n        // the rep about to CONVERT is the last moment that flag is worth\n        // anything, and without it the duplicate becomes a second account,\n        // contact and opportunity.\n        //\n        // \u26D4 Not on `convert_lead`'s `confirmText`: that string is static and\n        // unconditional, so it would warn identically on every clean lead \u2014 the\n        // cry-wolf that makes a confirm dialog furniture. This screen is where\n        // the conversion decision is actually taken, and the one surface that\n        // can say something TRUE about THIS lead.\n        //\n        // Mechanism: the executor renders `config.description` \u2014 a text slot,\n        // written as a `{{ }}` hole since 18.0.0-next.0 \u2014 into the `ScreenSpec`\n        // it puts on the wire, and `FlowRunner.tsx` renders it \u2014\n        // `{screen.description && <DialogDescription>\u2026}`. A hole over `null`\n        // renders the empty string, which the executor's `renderTextSlot`\n        // turns into no description at all (read in the installed\n        // 18.0.0-next.0 `service-automation`; on the 17.1.0 bundles it was\n        // measured as `interp` mapping null to `undefined`), so the clean-lead\n        // branch below (which assigns `null`) renders NO description rather\n        // than an empty paragraph. That is why the conditionality lives in an\n        // assignment and not in the copy: a screen `description` has no\n        // `visibleWhen`.\n        description: '{{duplicateWarning}}',\n        // `visibleWhen` on a screen field is BARE CEL over the screen's own\n        // field names \u2014 not the CEL value envelopes the rest of this flow uses\n        // for filters and `update_record` fields, evaluated on the server. The\n        // client re-evaluates the predicate against the values collected so far,\n        // which is why it cannot be a server-evaluated envelope.\n        fields: [\n          // \u26D4 NEVER `required` on a boolean screen field. A checkbox has no\n          // unanswered state \u2014 clear IS an answer, and \"convert this lead\n          // WITHOUT an opportunity\" is the commonest path. `required: true`\n          // blocks on both sides of the wire: the client counts the untouched\n          // box as an unanswered field and disables Submit, and from\n          // 17.0.0-rc.2 the SERVER enforces the screen's declared contract too,\n          // refusing the resume with `INVALID_SCREEN_INPUT: Screen field\n          // \"createOpportunity\" is required` \u2014 so a runner that posts only what\n          // the user touched cannot convert a lead at all. The variable's\n          // declared `defaultValue` is what supplies the answer.\n          //\n          // DERIVED, not restated. The envelope reads the flow variable\n          // `createOpportunity`, so the literal `false` is written exactly once in this\n          // file \u2014 on the declaration \u2014 and the widget prefill cannot drift from\n          // the value the engine binds.\n          //\n          // A screen field's `defaultValue` is a CEL value envelope evaluated\n          // before the descriptor goes on the wire, so the client receives the\n          // value, never the envelope: boolean `false`, which is what the\n          // 17.0.0 GA template was measured to send. (`visibleWhen` below is the\n          // opposite case: forwarded raw, never evaluated on the server. Same\n          // node, two different dialects.)\n          { name: 'createOpportunity', label: 'Create Opportunity?', type: 'boolean', defaultValue: cel`createOpportunity` },\n          // PREFILLED FROM THE LEAD (REQ-0005 acceptance 2). Both defaults are\n          // CEL envelopes over `leadRecord`, which `get_lead` bound before this\n          // screen was reached \u2014 the fetch sits AHEAD of the screen for the\n          // duplicate warning, and these two ride the same ordering.\n          //\n          // \u26A0\uFE0F Each envelope is evaluated before the descriptor goes on the\n          // wire, so `estimated_amount` arrives as a NUMBER. `company` is\n          // required on a lead; `estimated_amount` is not, so its read is\n          // guarded: a lead with no estimate is served `null` where 17.x served\n          // nothing (the migration entry: a field's `defaultValue` seeds the\n          // field with null), and an ABSENT column on a sparse datasource no\n          // longer fails the run at this screen.\n          //\n          // \u26D4 The amount is prefilled, never copied silently. `estimated_amount`\n          // is a pre-qualification guess and `crm_opportunity.amount` is a\n          // number a rep defends in a forecast; conversion is the moment a human\n          // turns one into the other, so the figure is shown in an editable box\n          // and the rep confirms it. Writing it straight into\n          // `create_opportunity` would put an unreviewed estimate into the\n          // forecast and leave the two fields looking like copies of each other.\n          //\n          // `required` on the amount mirrors the column, for the reason given\n          // at `closeDate` below: `crm_opportunity.amount` is `required` +\n          // `notNull`, and without this a ticked box with no amount reached\n          // `create_opportunity` after the account and contact were written,\n          // leaving the lead half-converted (#2060 item 2). Visible-only, so\n          // an unticked box still converts with no amount.\n          { name: 'opportunityName', label: 'Opportunity Name', type: 'text', required: true, defaultValue: cel`leadRecord.company`, visibleWhen: 'createOpportunity == true' },\n          { name: 'opportunityAmount', label: 'Opportunity Amount', type: 'currency', required: true, defaultValue: cel`has(leadRecord.estimated_amount) ? leadRecord.estimated_amount : null`, visibleWhen: 'createOpportunity == true' },\n          // The close date, DEFAULTED AND VISIBLE. `close_date` is what files\n          // an opportunity into a forecast PERIOD, so \u26D4 never stamp it silently\n          // inside `create_opportunity`: a hidden +90 days files every converted\n          // deal a quarter out and moves the forecast where nobody can see it.\n          //\n          // The +90 is written HERE and nowhere else, and here the layer is\n          // FORCED rather than preferred. A screen field's `defaultValue` is\n          // evaluated before the descriptor goes on the wire and a flow\n          // variable's default is bound raw (see the declaration above), so this\n          // is the only place the expression can be written at all.\n          // `isoDate(daysFromNow(90))` writes the `YYYY-MM-DD` string 90 days out\n          // on the UTC calendar \u2014 what 17.3.0's `{TODAY() + 90}` was measured to\n          // send \u2014 and the value the rep sees is the value\n          // `create_opportunity` writes.\n          //\n          // `required` mirrors the column \u2014 `crm_opportunity.close_date` is\n          // `required` + `notNull` \u2014 and it is what keeps the refusal at the\n          // SCREEN boundary. Measured both ways against a real ObjectQL engine:\n          // WITHOUT it, a submission carrying no date reaches\n          // `create_opportunity` and fails there with `Close Date is required`,\n          // by which point the account and the contact have already been\n          // written and the lead is left half-converted; WITH it the resume is\n          // refused before any node runs, nothing is written, and the message\n          // names the field. That path is not hypothetical \u2014 a rep who CLEARS\n          // the prefilled date posts the key empty, and `isPresent('')` is\n          // false. A hidden `required` never fires: the server contract skips it\n          // when `visibleWhen` evaluates false, and so does the console, which\n          // is the untouched-checkbox path this screen has always had to keep\n          // working.\n          { name: 'closeDate', label: 'Close Date', type: 'date', required: true, defaultValue: cel`isoDate(daysFromNow(90))`, visibleWhen: 'createOpportunity == true' },\n        ],\n      },\n    },\n    {\n      // \u26D4 This fetch must stay AHEAD of the screen: the duplicate warning\n      // reads `leadRecord`, and a screen that suspends before the fetch has\n      // nothing to read. The fetch itself never depended on the screen \u2014\n      // `recordId` is an input variable, seeded before the run starts.\n      id: 'get_lead', type: 'get_record', label: 'Get Lead Record',\n      config: { objectName: 'crm_lead', filter: { id: cel`recordId` }, outputVariable: 'leadRecord' },\n    },\n    {\n      // Branching is on edges `e21` / `e22` / `e25` \u2014 see `decision_account`.\n      // Three ways out, because `duplicate_status` carries two different KINDS\n      // of fact and they get different answers: the machine's `suspected` guess\n      // warns and lets the rep decide (`e21`), a person's `confirmed` verdict\n      // refuses outright (`e25`), and everything else converts silently (`e22`).\n      id: 'decision_duplicate', type: 'decision', label: 'Duplicate Verdict?',\n    },\n    {\n      // The warning names the record the way the UI names a person \u2014 by the\n      // email address the two records share \u2014 and NOT by\n      // `duplicate_of_lead` / `duplicate_of_contact`, which hold ids. That is\n      // the house rule `test/record-id-not-in-prose.test.ts` states for every\n      // sentence a user reads: \"the id goes in the relationship field that\n      // exists to carry it, or nowhere\". The link itself is on the lead's\n      // record page (`lead_detail.page.ts`), where it can be clicked.\n      //\n      // \"flagged at intake\" is the app's own published definition of this\n      // value, not a guess about provenance: `duplicate_status`'s help text\n      // reads \"Suspected = flagged automatically at intake\" in all four\n      // locales, and `lead_duplicate_check` is insert-only by design.\n      //\n      // This warning's TEXT is English-only: it is the value of a variable,\n      // and no locale pack reaches a variable \u2014 the screen's translated\n      // `description` can only carry the `{{duplicateWarning}}` hole that\n      // shows it. The screens' own headings and bodies are keyed in the packs\n      // (`flows.lead_conversion` in `src/sales/translations/<locale>/app.ts`),\n      // and the banner on the record page carries the warning in all four.\n      id: 'warn_duplicate', type: 'assignment', label: 'Compose Duplicate Warning',\n      config: {\n        assignments: {\n          duplicateWarning:\n            cel`'Suspected duplicate \u2014 intake flagged this lead as repeating an existing record with this email address (' + leadRecord.email + '). Converting creates a second account, contact and opportunity for the same buyer; compare the linked record on the lead page before you continue.'`,\n        },\n      },\n    },\n    {\n      // The other branch assigns `null`, which is what makes the warning\n      // CONDITIONAL: the description hole renders it as no description at\n      // all (see `screen_1`). Same shape as `no_opportunity` below \u2014 both branches\n      // write the variable so no downstream read ever meets an unset one.\n      id: 'no_duplicate_warning', type: 'assignment', label: 'No Duplicate Warning',\n      config: { assignments: { duplicateWarning: null } },\n    },\n    {\n      // The REFUSAL. A `confirmed` duplicate is a person's verdict, and the app\n      // stops converting on it \u2014 the rule AGENTS.md states as \"interception\n      // stands on a person's judgement\". `suspected` keeps the warn-and-allow\n      // above: a machine's guess stays advisory, because `lead_duplicate_check`\n      // matches on email EQUALITY and a shared inbox (`info@`, a switchboard\n      // address) false-positives by construction. \u26D4 Do not block on the guess \u2014\n      // it would need an override flag to stay usable, and an override flag is\n      // the one shape this exhibit must not demonstrate.\n      //\n      // ## Why the refusal is HERE and not on `convert_lead`'s predicate\n      //\n      // A refusal must NAME the verdict and the surviving record, and measured\n      // against `@objectstack/spec` 17.2.0 the action predicates cannot:\n      // `visible` and `disabled` are each a bare boolean/CEL envelope with\n      // nowhere to put a sentence, so `visible` hides a button that cannot then\n      // explain itself and `disabled` greys one out with no reason attached.\n      // `errorMessage` on the Action is a single static string \u2014 what the\n      // console toasts on a FAILED run \u2014 and cannot say anything about THIS\n      // lead. A screen node's `description` is a text slot rendered per run\n      // and shown by `FlowRunner` as the dialog body.\n      //\n      // The flow is also the only choke point covering every door: the\n      // record-header button, the list-row button and the `action_convert_lead`\n      // AI tool all dispatch `POST /automation/lead_conversion/trigger`, while\n      // `visible` / `disabled` are console-side and say nothing to the other\n      // two.\n      //\n      // ## What the rep sees, measured on the shipped console bundle\n      //\n      // A run that PAUSES returns `{ success: true, silent: true }` to the\n      // action framework (`RecordDetailView`'s flow handler), and `silent`\n      // suppresses the success toast \u2014 so `convert_lead`'s\n      // `successMessage: 'Lead converted successfully!'` does NOT fire behind\n      // this dialog. Submitting it resumes into `end`; nothing is created and\n      // the lead is untouched on either path, because every write in this flow\n      // is downstream of `screen_1`.\n      //\n      // ## What the copy may claim\n      //\n      // \u26D4 NOT the shared email address, which is what `warn_duplicate` above\n      // uses. That claim is safe for `suspected` because only\n      // `lead_duplicate_check` writes it and it matches on email; `confirmed`\n      // is written by a PERSON, and the lead form lets a reviewer point\n      // `duplicate_of_type` + its lookup at any record they like. So the\n      // refusal names the survivor through the relationship fields that exist\n      // to carry it (`test/record-id-not-in-prose.test.ts`: \"the id goes in the\n      // relationship field that exists to carry it, or nowhere\"), naming the\n      // `duplicates` field group by its shipped label, \"Duplicate Management\".\n      // That sentence also stays true on the `erased` tombstone, where the\n      // verdict survives its pointer (`lead.hook.ts`, job 1c).\n      //\n      // \u26D4 Never transcribe the vocabulary of `duplicate_of_type` into this\n      // sentence (\"an existing Lead\" / \"an existing Contact\"). Those labels are\n      // locale-pack facts with one source of truth, the rep can see them on the\n      // section this line points at, and a hand-copied machine list in prose is\n      // the drift AGENTS.md documentation rule 5 forbids.\n      //\n      // The title and the body are translated in the packs\n      // (`flows.lead_conversion.screens.refuse_confirmed_duplicate`).\n      id: 'refuse_confirmed_duplicate', type: 'screen', label: 'Conversion Refused',\n      config: {\n        title: 'Conversion refused',\n        description:\n          \"This lead's Duplicate Status is Confirmed: a reviewer compared it against an existing record and recorded that it repeats one. Converting would create a second account, contact and opportunity for the same buyer. The Duplicate Management section on this lead names the surviving record; disqualify this lead as a duplicate instead. Only a reviewer revising that verdict reopens conversion.\",\n        // A message-only screen: no fields, so the pause has to be asked for.\n        // `waitForInput` is what turns a field-less screen from a server-side\n        // pass-through into the dialog the rep reads (the executor's\n        // `shouldPause`), and without it this node would fall through to `end`\n        // in silence \u2014 a refusal nobody is told about.\n        waitForInput: true,\n      },\n    },\n    {\n      // Branching is on edges `e28` / `e29` \u2014 see `decision_account`.\n      id: 'decision_approval', type: 'decision', label: 'Approved for Conversion?',\n    },\n    {\n      // The approval gate, on the surface a REST caller reaches (REQ-0005\n      // acceptance 3). `convert_lead`'s `visible` predicate hides the button and\n      // `lead.hook.ts` refuses the write, but this flow has its own door \u2014\n      // `POST /automation/lead_conversion/trigger` \u2014 and without this branch a\n      // caller through that door would run the whole conversion and only be\n      // refused at `mark_converted`, by which point the account, the contact and\n      // the opportunity have already been written and the lead is left\n      // half-converted. Refusing HERE, ahead of `screen_1`, is what makes the\n      // gate whole: every create and update in this flow sits behind that\n      // screen, and this path never reaches it.\n      id: 'refuse_unapproved', type: 'screen', label: 'Conversion Refused',\n      config: {\n        title: 'Conversion refused',\n        description:\n          \"This lead has not been approved for conversion. An approver has to sign it off before it can become an account, contact and opportunity; the Conversion Approval field on the lead shows whether the decision is still pending or was refused. Keep working the lead in the meantime \u2014 nothing about it is frozen.\",\n        // Field-less screen: `waitForInput` is what turns it from a server-side\n        // pass-through into the dialog the rep reads. See\n        // `refuse_confirmed_duplicate` for the mechanism.\n        waitForInput: true,\n      },\n    },\n    {\n      // Branching is on edges `e31` / `e32` \u2014 see `decision_account`. The\n      // match-key guard sits between the duplicate verdict and `screen_1`, so\n      // it dominates `find_account` and a key-less lead is refused before the\n      // rep fills in the form and before any write. It is the LAST of the\n      // three refusals on purpose: an unapproved lead or a confirmed duplicate\n      // is told that verdict first, and a missing key is a repairable data\n      // gap rather than a verdict.\n      id: 'decision_match_key', type: 'decision', label: 'Company Match Key?',\n    },\n    {\n      // The KEY-LESS refusal (#2017). Why `find_account` must not run without\n      // a key is recorded on that node; this is what the rep reads instead.\n      //\n      // A refusal, not a new account, and that is the flow's own stated intent\n      // rather than a fresh choice: a conversion that stops is far cheaper to\n      // diagnose than one that quietly attaches to the wrong account or\n      // creates a duplicate one, and `screen_1` offers the rep no account\n      // choice that could confirm a match by hand.\n      //\n      // The copy claims only what holds on every path into it: the key is\n      // derived from `company` on every write that carries it\n      // (`lead_duplicate_check`), and nothing has been written, because every\n      // create and update in this flow sits behind `screen_1`. Its title and\n      // body are translated in the packs, like the other two refusals.\n      //\n      // Field-less screen: `waitForInput` is what turns it from a server-side\n      // pass-through into the dialog the rep reads. See\n      // `refuse_confirmed_duplicate` for the mechanism.\n      id: 'refuse_no_match_key', type: 'screen', label: 'Conversion Refused',\n      config: {\n        title: 'Conversion refused',\n        description:\n          \"This lead's company has no match key, so conversion cannot tell which account it belongs to, and it will not guess: a guess could file the contact and opportunity under another customer. Saving the lead's Company rebuilds the key, so save it again, then convert. Nothing has been created.\",\n        waitForInput: true,\n      },\n    },\n    {\n      // Account dedupe: match on the NORMALIZED company name, never on the raw\n      // one \u2014 \"Acme Corp\" and \"ACME  Corp\" are the same account.\n      //\n      // Both sides of this comparison are stored, hook-maintained columns, and\n      // on 17.x that was forced rather than chosen: a flow template could not\n      // normalize ANYTHING. `service-automation`'s `resolveToken` recognises exactly one\n      // function form \u2014 `NOW()` / `TODAY()` \u2014 and every bare identifier in the\n      // expression fallback is substituted before evaluation, so no string\n      // method is reachable either: `{LOWER(x)}`, `{TRIM(x)}` and\n      // `{x.toLowerCase()}` all resolve to `undefined`, and an unwrapped\n      // `LOWER({x})` interpolates literally to \"LOWER(Acme Corp)\". A formula\n      // field is no help either \u2014 it has no physical column to filter on. So\n      // the producer canonicalizes (`account_protection`,\n      // `lead_duplicate_check`) and this node does a plain, indexed equality\n      // match. `test/account-name-normalized-match.test.ts` re-measures all of\n      // that rather than trusting this paragraph.\n      //\n      // Normalize-then-EXACT only: lower + trim + collapse internal\n      // whitespace. Fuzzy matching stays out of scope.\n      //\n      // A lead with NO `company_normalized` never reaches this node:\n      // `decision_match_key`, ahead of `screen_1`, refuses it first. The node\n      // cannot be left to refuse on its own, because \"no key\" arrives in two\n      // shapes that behave differently (both measured on 17.7.0):\n      //\n      //   \u00B7 ABSENT \u2014 a sparse datasource (`driver-memory` / `driver-mongodb`)\n      //     on a row never written with the column. The token resolves to\n      //     nothing and `get_record` refuses to run, so the run FAILS\n      //     (`FLOW_FAILED`, \"refusing to run \u2014 1 filter condition(s) resolved\n      //     to nothing and were dropped from the query \u2026\").\n      //   \u00B7 NULL \u2014 SQL, or any datasource once the column is written empty,\n      //     which `lead_duplicate_check` does on purpose for a company that\n      //     folds to nothing. The token resolves to `null`, and a bare `null`\n      //     in a filter is the platform's documented HAS-NO-VALUE predicate\n      //     (`$eq: null`, `@objectstack/spec` `data/filter.zod.ts`). This\n      //     lookup then MATCHES every account whose own key is null, and the\n      //     lead converts onto an unrelated customer's account (#2017).\n      //\n      // A key-less lead is not only a row written before the producer existed\n      // (the backfill in docs/MAINTENANCE.md \u00A73.3): a non-string company\n      // written through the record API folds to `null` too. A conversion that\n      // stops is far cheaper to diagnose than one that quietly attaches to the\n      // wrong account or creates a duplicate one, so the answer is the\n      // refusal the rep reads in `refuse_no_match_key`.\n      //\n      // Since 18.0.0-next.0 the operand is a CEL envelope: an absent key fails\n      // the run before the query, and a null one refuses the node instead of\n      // matching (the platform's `flow-value-slot-template-dialect-refused`\n      // entry; not re-measured here). Neither shape converts onto another\n      // account any more, and `decision_match_key` still refuses first, with\n      // copy the rep can read.\n      //\n      // \u26D4 Never paper this over with a second, case-sensitive lookup on the\n      // raw `name`: a missing key means the producer could not derive one, and\n      // a tolerant consumer path would hide that while restoring the exact bug\n      // this node exists to fix.\n      id: 'find_account', type: 'get_record', label: 'Find Existing Account',\n      config: { objectName: 'crm_account', filter: { name_normalized: cel`leadRecord.company_normalized` }, outputVariable: 'matchedAccount' },\n    },\n    {\n      // Branching is on edges `e5` / `e6`. No `config.condition` here: a\n      // `decision` node's singular one is never evaluated.\n      id: 'decision_account', type: 'decision', label: 'Account Already Exists?',\n    },\n    {\n      // NEW-account branch. outputVariable is `createdAccount`; the assignment\n      // below normalizes both branches onto a single `accountId` id string so\n      // downstream nodes don't need to know which path ran.\n      //\n      // `name` carries the lead's company VERBATIM \u2014 the display value. The\n      // match key `name_normalized` is deliberately absent: it is readonly and\n      // hook-owned, and `account_protection` derives it from the `name` written\n      // here, so an account created by this node is immediately findable by the\n      // next conversion.\n      id: 'create_account', type: 'create_record', label: 'Create Account',\n      config: {\n        objectName: 'crm_account',\n        fields: {\n          // `company` is required on a lead; every other copied fact is\n          // optional, so its read is guarded to null (an insert treats null as\n          // it treated the key the template left out).\n          name: cel`leadRecord.company`, phone: cel`has(leadRecord.phone) ? leadRecord.phone : null`,\n          website: cel`has(leadRecord.website) ? leadRecord.website : null`,\n          industry: cel`has(leadRecord.industry) ? leadRecord.industry : null`,\n          annual_revenue: cel`has(leadRecord.annual_revenue) ? leadRecord.annual_revenue : null`,\n          number_of_employees: cel`has(leadRecord.number_of_employees) ? leadRecord.number_of_employees : null`,\n          billing_address: cel`has(leadRecord.address) ? leadRecord.address : null`,\n          owner_id: cel`current_user.id`, is_active: true,\n        },\n        outputVariable: 'createdAccount',\n      },\n    },\n    {\n      id: 'use_new_account', type: 'assignment', label: 'Use New Account',\n      config: { assignments: { accountId: cel`createdAccount.id` } },\n    },\n    {\n      id: 'use_existing_account', type: 'assignment', label: 'Reuse Existing Account',\n      config: { assignments: { accountId: cel`matchedAccount.id` } },\n    },\n    {\n      // Contact dedupe by email \u2014 GLOBAL, not per-account. \u26D4 Never scope this\n      // lookup to the account: `crm_contact` carries a global unique index on\n      // `email`, so an account-scoped lookup misses a same-email contact under\n      // another account and `create_contact` then explodes on the DB index\n      // AFTER the account has been created, orphaning it. Leads require an\n      // email, so the match key is reliable.\n      id: 'find_contact', type: 'get_record', label: 'Find Existing Contact',\n      config: {\n        objectName: 'crm_contact',\n        filter: { email: cel`leadRecord.email` },\n        outputVariable: 'matchedContact',\n      },\n    },\n    {\n      // Branching is on edges `e11` / `e12` \u2014 see `decision_account`.\n      id: 'decision_contact', type: 'decision', label: 'Contact Already Exists?',\n    },\n    {\n      // `accountId` is a bare id string from whichever account branch ran.\n      id: 'create_contact', type: 'create_record', label: 'Create Contact',\n      config: {\n        objectName: 'crm_contact',\n        fields: {\n          // The person's own facts travel with them (#2068). `crm_contact`\n          // declares each of these on the lead's vocabulary (`_picklists.ts`\n          // for the two selects, pinned by `test/actions-flows-integrity`), so\n          // a straight copy is always legal. The two opt-outs are copied,\n          // never defaulted: a lead that opted out must not become a contact\n          // that has not \u2014 `email_opt_out` hides Send Email and silences\n          // `contact_welcome`, `do_not_call` refuses a scheduled call. A\n          // REUSED contact does not come through here: see\n          // `decision_contact_do_not_call`.\n          //\n          // Names and email are required on a lead and read bare; the rest\n          // are optional and guarded to null, which an insert reads as the\n          // omitted key the template wrote (each opt-out then takes its\n          // `false` default, as before).\n          salutation: cel`has(leadRecord.salutation) ? leadRecord.salutation : null`,\n          mobile: cel`has(leadRecord.mobile) ? leadRecord.mobile : null`,\n          lead_source: cel`has(leadRecord.lead_source) ? leadRecord.lead_source : null`,\n          do_not_call: cel`has(leadRecord.do_not_call) ? leadRecord.do_not_call : null`,\n          email_opt_out: cel`has(leadRecord.email_opt_out) ? leadRecord.email_opt_out : null`,\n          first_name: cel`leadRecord.first_name`, last_name: cel`leadRecord.last_name`,\n          email: cel`leadRecord.email`, phone: cel`has(leadRecord.phone) ? leadRecord.phone : null`,\n          title: cel`has(leadRecord.title) ? leadRecord.title : null`, crm_account: cel`accountId`,\n          is_primary: true, owner_id: cel`current_user.id`,\n        },\n        outputVariable: 'createdContact',\n      },\n    },\n    {\n      id: 'use_new_contact', type: 'assignment', label: 'Use New Contact',\n      config: { assignments: { contactId: cel`createdContact.id` } },\n    },\n    {\n      id: 'use_existing_contact', type: 'assignment', label: 'Reuse Existing Contact',\n      config: { assignments: { contactId: cel`matchedContact.id` } },\n    },\n    {\n      // \u2500\u2500 A REUSED contact keeps the stricter consent (#2068) \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n      //\n      // `create_contact` copies the lead's opt-outs onto a NEW contact. A\n      // reused contact already holds its own answer, and an opt-out is a\n      // promise to a person that a conversion never takes back \u2014 so this path\n      // only ever RAISES a flag, one node per flag, and only when the lead\n      // carries it. The `raise_*` nodes write the literal `true`, \u26D4 never a\n      // copy of `leadRecord.x`: a copy would write the lead's `false` over a contact\n      // who had opted out. `crm_account` carries neither flag, so the account\n      // half of \"the stricter value wins\" has nothing to write.\n      //\n      // The edges read the LEAD's flag only, not whether the contact already\n      // holds it. Reading `vars.matchedContact.x` needs a\n      // `has(vars.matchedContact)` guard, which\n      // `test/flow-variable-conditions.test.ts` forbids on this flow (a\n      // `get_record` binds it on every path) \u2014 and writing `true` over `true`\n      // changes nothing.\n      //\n      // Branching on `e35` / `e36`, then `e38` / `e39`: each pair is TOTAL and\n      // partitions by De Morgan, so exactly one edge holds on every shape\n      // `get_lead` can bind \u2014 pinned in `test/flow-conversion.test.ts`.\n      id: 'decision_contact_do_not_call', type: 'decision', label: 'Lead Is Do-Not-Call?',\n    },\n    {\n      id: 'raise_contact_do_not_call', type: 'update_record', label: 'Carry Do-Not-Call to Contact',\n      config: { objectName: 'crm_contact', filter: { id: cel`contactId` }, fields: { do_not_call: true } },\n    },\n    {\n      id: 'decision_contact_email_opt_out', type: 'decision', label: 'Lead Opted Out of Email?',\n    },\n    {\n      id: 'raise_contact_email_opt_out', type: 'update_record', label: 'Carry Email Opt-Out to Contact',\n      config: { objectName: 'crm_contact', filter: { id: cel`contactId` }, fields: { email_opt_out: true } },\n    },\n    {\n      // Branching is on edges `e16` / `e17` \u2014 see `decision_account`.\n      id: 'decision_opportunity', type: 'decision', label: 'Create Opportunity?',\n    },\n    {\n      // `close_date` comes from the screen field, which is the only layer that\n      // can carry the `isoDate(daysFromNow(90))` expression \u2014 see the\n      // `closeDate` declaration. An unbound `closeDate` fails the run at this\n      // node rather than inventing a quarter, which is the failure this node\n      // is allowed to have.\n      id: 'create_opportunity', type: 'create_record', label: 'Create Opportunity',\n      config: {\n        objectName: 'crm_opportunity',\n        fields: {\n          name: cel`opportunityName`, crm_account: cel`accountId`, primary_contact: cel`contactId`,\n          amount: cel`opportunityAmount`, stage: 'prospecting', probability: 10,\n          lead_source: cel`has(leadRecord.lead_source) ? leadRecord.lead_source : null`,\n          close_date: cel`closeDate`, owner_id: cel`current_user.id`,\n        },\n        outputVariable: 'createdOpportunity',\n      },\n    },\n    {\n      // Normalize both opportunity branches onto a single `opportunityId`, the\n      // same pattern as accountId/contactId. \u26D4 Never reference\n      // `createdOpportunity.id` downstream instead: on the \"No\" branch the\n      // create node never ran, and the unbound read fails the run (on 17.x the\n      // unresolved token interpolated into the `converted_opportunity` lookup\n      // as a placeholder).\n      id: 'use_new_opportunity', type: 'assignment', label: 'Use New Opportunity',\n      config: { assignments: { opportunityId: cel`createdOpportunity.id` } },\n    },\n    {\n      id: 'no_opportunity', type: 'assignment', label: 'No Opportunity',\n      config: { assignments: { opportunityId: null } },\n    },\n    {\n      id: 'mark_converted', type: 'update_record', label: 'Mark Lead as Converted',\n      config: {\n        objectName: 'crm_lead', filter: { id: cel`recordId` },\n        fields: {\n          // `status: 'converted'` rides along so list views agree with the\n          // conversion flags (the qualified \u2192 converted transition is legal\n          // per the lead_status_progression state machine).\n          is_converted: true, status: 'converted', converted_date: cel`isoDatetime(now())`,\n          converted_account: cel`accountId`, converted_contact: cel`contactId`,\n          converted_opportunity: cel`opportunityId`,\n        },\n      },\n    },\n    {\n      // ADR-0012: deliver via the `notify` node (inbox + email). The legacy\n      // `script` + `actionType:'email'` shape is a no-op stub in 7.4.\n      id: 'send_notification', type: 'notify', label: 'Send Confirmation',\n      config: {\n        recipients: [cel`current_user.id`],\n        channels: ['inbox', 'email'],\n        topic: 'lead_converted',\n        template: 'crm.lead_converted',\n        templateData: { first_name: cel`leadRecord.first_name`, last_name: cel`leadRecord.last_name` },\n        actionUrl: '/crm_account/{{accountId}}',\n      },\n    },\n    { id: 'end', type: 'end', label: 'End' },\n  ],\n\n  edges: [\n    // \u26D4 A retired edge's id stays VACANT and every surviving edge keeps the id\n    // it has always had \u2014 `e1`, `e3` and `e15` are gaps on purpose.\n    // Renumbering to close a gap rewrites ids that other notes, tests and run\n    // logs refer to.\n    { id: 'e0', source: 'start', target: 'get_lead', type: 'default' },\n    // \u26D4 When you add an edge, take the next id AFTER THE HIGHEST IN USE \u2014 do\n    // not reuse a vacant one, and do not assume an unused-looking id is free.\n    // A duplicate id is INERT (traversal filters out-edges by `source`, never\n    // by `id`), so nothing fails and the collision survives to trap the next\n    // editor picking out of the sequence. `e1`, `e3` and `e15` are vacant\n    // retired ids and stay that way; `e27` is above the highest live id, not\n    // a gap-fill.\n    { id: 'e27', source: 'get_lead', target: 'decision_approval', type: 'default' },\n    // \u2500\u2500 The approval gate (REQ-0005 step 7) \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n    //\n    // The same TOTAL, PARTITIONING pair the duplicate verdict below is written\n    // as, and for the same measured reason: a decision node declaring no\n    // `config.conditions` takes EVERY out-edge whose condition holds, in\n    // parallel, so two overlapping guards would refuse the conversion and\n    // continue it in one run. `e29` is `e28` negated by De Morgan.\n    //\n    // \u26A0\uFE0F The polarity is fail-OPEN, unlike the duplicate branch, and that is the\n    // gate's off switch rather than a slip. Only the two verdicts a live\n    // approval writes refuse; `not_required` \u2014 the shipped default \u2014 and an\n    // absent column (a lead from before the field existed) both continue, so\n    // with the gate off this pair is invisible and conversion behaves exactly as\n    // it did before. `lead.hook.ts` and `convert_lead.visible` carry the same\n    // polarity, because the three have to agree about what \"off\" means.\n    { id: 'e28', source: 'decision_approval', target: 'refuse_unapproved', type: 'default', condition: P`has(vars.leadRecord) && has(vars.leadRecord.conversion_approval_status)\n      && (vars.leadRecord.conversion_approval_status == \"pending\" || vars.leadRecord.conversion_approval_status == \"rejected\")`, label: 'Not approved' },\n    { id: 'e29', source: 'decision_approval', target: 'decision_duplicate', type: 'default', condition: P`!has(vars.leadRecord) || !has(vars.leadRecord.conversion_approval_status)\n      || (vars.leadRecord.conversion_approval_status != \"pending\" && vars.leadRecord.conversion_approval_status != \"rejected\")`, label: 'Clear' },\n    // Rejoins nothing, exactly like `e26`: the refusal IS not reaching a writer.\n    { id: 'e30', source: 'refuse_unapproved', target: 'end', type: 'default' },\n    // \u26A0\uFE0F Both conditions are TOTAL, and on this surface that is not a style\n    // preference: a flow condition is interpreted strict CEL on every run, and\n    // an unguarded field read against a driver that omits absent columns\n    // (`driver-memory` / `driver-mongodb`) aborts \u2014 which FAILS THE RUN, so an\n    // unguarded read here would make ordinary leads unconvertible. Measured, in\n    // exactly that shape: `condition failed to evaluate as CEL: No such key:\n    // duplicate_status`. The full table is in\n    // `test/flow-condition-totality.test.ts`.\n    //\n    // TWO guards, in the spelling `test/flow-variable-conditions.test.ts`\n    // requires, and the outer one is not decoration: `vars.leadRecord` is a\n    // KEY, so a plain `vars.leadRecord != null` would itself abort with\n    // `Unknown variable` on the run where `get_lead` bound nothing \u2014 the guard\n    // would be the fault it was written to prevent. `has(vars.leadRecord)`\n    // answers instead of reading.\n    //\n    // The THREE edges PARTITION by De Morgan (`!(a && b && c)` written out as\n    // `!a || !b || !c`, with the two verdict tests conjoined under the last\n    // term), so exactly one is true for every record shape, including the\n    // shapes where the column, the row or both are missing.\n    //\n    // \u26D4 `e22`'s third term must carry BOTH inequalities. A decision node that\n    // declares no `config.conditions` reports no branch, so traversal takes\n    // EVERY out-edge whose condition holds, IN PARALLEL \u2014 with `e22` left at\n    // `!= \"suspected\"` a confirmed lead satisfies `e22` AND `e25`, showing the\n    // refusal and converting the lead in the same run. Measured on\n    // `AutomationEngine.evaluateCondition` across all seven record shapes; the\n    // pin is in `test/lead-duplicate-visibility.test.ts`.\n    { id: 'e21', source: 'decision_duplicate', target: 'warn_duplicate', type: 'default', condition: P`has(vars.leadRecord) && has(vars.leadRecord.duplicate_status) && vars.leadRecord.duplicate_status == \"suspected\"`, label: 'Suspected' },\n    { id: 'e25', source: 'decision_duplicate', target: 'refuse_confirmed_duplicate', type: 'default', condition: P`has(vars.leadRecord) && has(vars.leadRecord.duplicate_status) && vars.leadRecord.duplicate_status == \"confirmed\"`, label: 'Confirmed' },\n    { id: 'e22', source: 'decision_duplicate', target: 'no_duplicate_warning', type: 'default', condition: P`!has(vars.leadRecord) || !has(vars.leadRecord.duplicate_status) || (vars.leadRecord.duplicate_status != \"suspected\" && vars.leadRecord.duplicate_status != \"confirmed\")`, label: 'Clean' },\n    // Both clear duplicate branches pass the match-key guard before the form.\n    { id: 'e23', source: 'warn_duplicate', target: 'decision_match_key', type: 'default' },\n    { id: 'e24', source: 'no_duplicate_warning', target: 'decision_match_key', type: 'default' },\n    // \u2500\u2500 The match-key guard (#2017) \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n    //\n    // TOTAL and PARTITIONING, for the reason recorded at `e28` / `e29`: `e32`\n    // is `e31` negated by De Morgan, so exactly one holds for every shape\n    // `get_lead` can bind \u2014 unbound, a null row, the column absent, null,\n    // empty, or keyed. `has()` alone is not the test: on a row that carries\n    // the column as null it answers true, so the value needs `isBlank` too.\n    // Fail-CLOSED, unlike the approval gate: without a key there is nothing to\n    // match on, and a guess is the defect.\n    { id: 'e31', source: 'decision_match_key', target: 'screen_1', type: 'default', condition: P`has(vars.leadRecord) && has(vars.leadRecord.company_normalized) && !isBlank(vars.leadRecord.company_normalized)`, label: 'Has match key' },\n    { id: 'e32', source: 'decision_match_key', target: 'refuse_no_match_key', type: 'default', condition: P`!has(vars.leadRecord) || !has(vars.leadRecord.company_normalized) || isBlank(vars.leadRecord.company_normalized)`, label: 'No match key' },\n    // Rejoins nothing, exactly like `e26` / `e30`.\n    { id: 'e33', source: 'refuse_no_match_key', target: 'end', type: 'default' },\n    // The refusal branch rejoins nothing: it goes straight to `end`, so no\n    // node that writes is downstream of it. That is the refusal \u2014 the flow's\n    // every create/update sits behind `screen_1`, which this path never\n    // reaches.\n    { id: 'e26', source: 'refuse_confirmed_duplicate', target: 'end', type: 'default' },\n    { id: 'e2', source: 'screen_1', target: 'find_account', type: 'default' },\n    { id: 'e4', source: 'find_account', target: 'decision_account', type: 'default' },\n    // Existing account \u2192 reuse; no account \u2192 create. Both converge on create_contact.\n    // `find_account` is reached only with a match key (`e31`), so a match\n    // here is an equality on a real key, never the has-no-value predicate.\n    // \u26D4 No second copy of the key test on these two edges: it could never\n    // be false here, and an inert restatement of a live predicate is the\n    // shape #650 retired from this repo's decision nodes.\n    { id: 'e5', source: 'decision_account', target: 'use_existing_account', type: 'default', condition: P`vars.matchedAccount != null`, label: 'Existing' },\n    { id: 'e6', source: 'decision_account', target: 'create_account', type: 'default', condition: P`vars.matchedAccount == null`, label: 'New' },\n    { id: 'e7', source: 'create_account', target: 'use_new_account', type: 'default' },\n    // Both account branches converge on the contact-dedupe lookup.\n    { id: 'e8', source: 'use_new_account', target: 'find_contact', type: 'default' },\n    { id: 'e9', source: 'use_existing_account', target: 'find_contact', type: 'default' },\n    { id: 'e10', source: 'find_contact', target: 'decision_contact', type: 'default' },\n    // Existing contact \u2192 reuse; none \u2192 create. Both converge on\n    // decision_opportunity, the reuse path through the consent raise below.\n    { id: 'e11', source: 'decision_contact', target: 'use_existing_contact', type: 'default', condition: P`vars.matchedContact != null`, label: 'Existing' },\n    { id: 'e12', source: 'decision_contact', target: 'create_contact', type: 'default', condition: P`vars.matchedContact == null`, label: 'New' },\n    { id: 'e13', source: 'create_contact', target: 'use_new_contact', type: 'default' },\n    { id: 'e14', source: 'use_new_contact', target: 'decision_opportunity', type: 'default' },\n    // \u2500\u2500 The reused contact's consent raise (#2068) \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n    //\n    // `e15` (use_existing_contact \u2192 decision_opportunity) is RETIRED and stays\n    // vacant; `e34` replaces it. Each pair below is TOTAL and PARTITIONING, and\n    // only a flag the lead carries as `true` takes the raise.\n    { id: 'e34', source: 'use_existing_contact', target: 'decision_contact_do_not_call', type: 'default' },\n    { id: 'e35', source: 'decision_contact_do_not_call', target: 'raise_contact_do_not_call', type: 'default', condition: P`has(vars.leadRecord) && has(vars.leadRecord.do_not_call) && vars.leadRecord.do_not_call == true`, label: 'Do not call' },\n    { id: 'e36', source: 'decision_contact_do_not_call', target: 'decision_contact_email_opt_out', type: 'default', condition: P`!has(vars.leadRecord) || !has(vars.leadRecord.do_not_call) || vars.leadRecord.do_not_call != true`, label: 'Callable' },\n    { id: 'e37', source: 'raise_contact_do_not_call', target: 'decision_contact_email_opt_out', type: 'default' },\n    { id: 'e38', source: 'decision_contact_email_opt_out', target: 'raise_contact_email_opt_out', type: 'default', condition: P`has(vars.leadRecord) && has(vars.leadRecord.email_opt_out) && vars.leadRecord.email_opt_out == true`, label: 'Opted out' },\n    { id: 'e39', source: 'decision_contact_email_opt_out', target: 'decision_opportunity', type: 'default', condition: P`!has(vars.leadRecord) || !has(vars.leadRecord.email_opt_out) || vars.leadRecord.email_opt_out != true`, label: 'Emailable' },\n    { id: 'e40', source: 'raise_contact_email_opt_out', target: 'decision_opportunity', type: 'default' },\n    { id: 'e16', source: 'decision_opportunity', target: 'create_opportunity', type: 'default', condition: P`vars.createOpportunity == true`, label: 'Yes' },\n    { id: 'e17', source: 'decision_opportunity', target: 'no_opportunity', type: 'default', condition: P`vars.createOpportunity != true`, label: 'No' },\n    { id: 'e18', source: 'create_opportunity', target: 'use_new_opportunity', type: 'default' },\n    { id: 'e18a', source: 'use_new_opportunity', target: 'mark_converted', type: 'default' },\n    { id: 'e18b', source: 'no_opportunity', target: 'mark_converted', type: 'default' },\n    { id: 'e19', source: 'mark_converted', target: 'send_notification', type: 'default' },\n    { id: 'e20', source: 'send_notification', target: 'end', type: 'default' },\n  ],\n};\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/sales/flows/lead-conversion-approval.flow.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/sales/flows\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/sales/flows/lead-conversion-approval.flow.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport { P, cel } from '@objectstack/spec';\nimport type * as Automation from '@objectstack/spec/automation';\ntype Flow = Automation.Flow;\n\n/**\n * Lead Conversion Approval \u2014 sign-off before a lead may become a deal.\n *\n * REQ-0005 step 7: \u300C\u7EBF\u7D22\u5BF9\u5E94\u5BA1\u6279\u6D41\u7A0B\uFF0C\u5BA1\u6279\u901A\u8FC7\u540E\u65B9\u53EF\u8F6C\u5316\u4E3A\u6B63\u5F0F\u5546\u673A\u300D. Expressed as an\n * **approval node** (`type: 'approval'`, ADR-0019), the construct\n * `opportunity-approval.flow.ts` already uses \u2014 \u26D4 there is no `workflow`\n * metadata type and no standalone `ApprovalProcess` to author.\n *\n * ## \u26A0\uFE0F This flow is INERT until an install arms the gate, and that is by design\n *\n * REQ-0005: \"The gate must be configurable \u2014 off by default. A single-seller\n * install must not be forced through an approval to convert a lead.\"\n *\n * The switch is `crm_lead.conversion_approval_status`'s `defaultValue`, not this\n * flow's `status`. Shipped, that default is `not_required`, so NO lead is ever\n * born `pending` and the start condition below is false for every record that\n * has ever existed \u2014 the flow registers, binds its trigger, opens nothing, and\n * costs a predicate evaluation per insert. An install arms the gate by changing\n * that one value to `'pending'`; from then on every NEW lead enters here, and\n * `lead.hook.ts` refuses its conversion until this flow writes a verdict.\n *\n * \u26D4 Do NOT reach for `status: 'draft'` as the off switch instead. Measured on\n * `@objectstack/service-automation` 17.4.0, whose own registration\n * diagnostic says it in as many words \u2014 \"draft flows still fire their triggers;\n * set status: 'active' to make intent explicit, or 'obsolete' to disable\". And\n * \u26D4 not `'obsolete'` either: `isFlowEnabled` composes the authoring status with\n * the installation's activation ledger so that \"either one disarms; neither can\n * override the other\", which makes `obsolete` a gate no install can ever turn\n * ON \u2014 the opposite of configurable. A condition no record satisfies is off AND\n * switchable; a disabled flow is only off.\n *\n * ## Why the trigger is insert-only\n *\n * `pending` appears at exactly one moment \u2014 the field default, stamped as the\n * row is written \u2014 so the request is opened where it appears. \u26D4 An afterUpdate\n * twin (the shape `opportunity_approval` needs, because a deal can GROW across\n * its threshold) would re-enter on every edit made while the lead sat pending\n * and open a second request for the same decision.\n *\n * \u21D2 A lead that predates the arming keeps `not_required` and never enters, which\n * is REQ-0005 acceptance 4 holding by construction: arming the gate invalidates\n * no existing record.\n */\nexport const LeadConversionApprovalFlow: Flow = {\n  name: 'lead_conversion_approval',\n  label: 'Lead Conversion Approval',\n  description:\n    'Sign-off a lead needs before it may be converted. Inert unless the install arms the gate on crm_lead.conversion_approval_status.',\n  type: 'record_change',\n  status: 'active',\n  // Same reading `opportunity_approval` records, and for the same two reasons.\n  // A gate exists to CONSTRAIN the submitter, so the submitter's own scope is\n  // the wrong identity to evaluate it under \u2014 and an approval control that\n  // engages only for writers carrying a session is not a control, since a\n  // `runAs: 'system'` importer creating leads would simply bypass it. The\n  // verdict writes below also land on `conversion_approval_status`, which is\n  // `readonly: true` on the object, so only a platform write reaches it.\n  runAs: 'system',\n\n  variables: [\n    { name: 'leadId', type: 'text', isInput: true, isOutput: false },\n  ],\n\n  nodes: [\n    {\n      id: 'start',\n      type: 'start',\n      label: 'Start',\n      config: {\n        objectName: 'crm_lead',\n        triggerType: 'record-after-create',\n        // TOTALITY (AGENTS.md \u2014 validation predicates must be TOTAL): `has()`\n        // on every read. A flow condition is strict CEL on every run, and an\n        // unguarded read against a driver that omits absent columns aborts \u2014\n        // which from 17.0.0-rc.2 FAILS THE RUN rather than skipping it. The\n        // absent case must read as \"not gated\": a lead with no approval column\n        // at all is a lead from before the field existed, and it converts the\n        // way it always did.\n        condition: P`has(record.conversion_approval_status) && record.conversion_approval_status == \"pending\"`,\n      },\n    },\n    {\n      id: 'get_lead',\n      type: 'get_record',\n      label: 'Get Lead',\n      config: { objectName: 'crm_lead', filter: { id: cel`record.id` }, outputVariable: 'leadRecord' },\n    },\n    {\n      id: 'conversion_review',\n      type: 'approval',\n      label: 'Lead Conversion Review',\n      config: {\n        // The customer's chain is \u9500\u552E\u8D1F\u8D23\u4EBA \u2192 \u9500\u552E\u603B\u76D1; the generic shape core\n        // ships is the manager bench this app already declares approvers\n        // against. A second tier, or a different position, is overlay\n        // configuration \u2014 the same status as the need-type vocabulary.\n        approvers: [{ type: 'position', value: 'sales_manager' }],\n        // Explicit though it is the schema default, exactly as\n        // `opportunity_approval` authors it: approvers snapshot at request\n        // creation, so an empty bench would otherwise leave the request\n        // undecidable \u2014 and here that means a lead nobody can ever convert.\n        onEmptyApprovers: 'admin_rescue',\n        behavior: 'first_response',\n        // \u26A0\uFE0F `false`, and NOT the schema default `true` \u2014 the one place this\n        // node deliberately differs from its opportunity sibling. A deal under\n        // review is a document being negotiated; a LEAD under review is a person\n        // a rep is still calling. Locking the record would freeze\n        // `last_contacted_date`, `next_followup_date`, the notes and every\n        // activity bubble for as long as the approver takes, so the gate would\n        // stop the work it exists to authorise. Nothing is at risk in leaving it\n        // open: the verdict column is `readonly: true`, so the only field this\n        // node's decision touches is one no user may write anyway.\n        lockRecord: false,\n        approvalStatusField: 'conversion_approval_status',\n      },\n    },\n    {\n      id: 'mark_approved',\n      type: 'update_record',\n      label: 'Mark Approved',\n      config: {\n        objectName: 'crm_lead',\n        filter: { id: cel`record.id` },\n        fields: { conversion_approval_status: 'approved' },\n      },\n    },\n    {\n      id: 'notify_approved',\n      type: 'notify',\n      label: 'Notify Owner \u2014 Approved',\n      config: {\n        recipients: [cel`has(leadRecord.owner_id) ? leadRecord.owner_id : null`],\n        channels: ['inbox'],\n        topic: 'lead_conversion_approved',\n        template: 'crm.lead_conversion_approved',\n        templateData: { first_name: cel`leadRecord.first_name`, last_name: cel`leadRecord.last_name` },\n        actionUrl: '/crm_lead/{{record.id}}',\n      },\n    },\n    {\n      id: 'mark_rejected',\n      type: 'update_record',\n      label: 'Mark Rejected',\n      config: {\n        objectName: 'crm_lead',\n        filter: { id: cel`record.id` },\n        fields: { conversion_approval_status: 'rejected' },\n      },\n    },\n    {\n      id: 'notify_rejected',\n      type: 'notify',\n      label: 'Notify Owner \u2014 Rejected',\n      config: {\n        recipients: [cel`has(leadRecord.owner_id) ? leadRecord.owner_id : null`],\n        channels: ['inbox'],\n        severity: 'warning',\n        topic: 'lead_conversion_rejected',\n        template: 'crm.lead_conversion_rejected',\n        templateData: { first_name: cel`leadRecord.first_name`, last_name: cel`leadRecord.last_name` },\n        actionUrl: '/crm_lead/{{record.id}}',\n      },\n    },\n    { id: 'end', type: 'end', label: 'End' },\n  ],\n\n  edges: [\n    { id: 'e1', source: 'start', target: 'get_lead', type: 'default' },\n    { id: 'e2', source: 'get_lead', target: 'conversion_review', type: 'default' },\n    // Approval-node branch labels \u2014 the engine resumes down the out-edge whose\n    // `label` matches the recorded decision.\n    { id: 'e3', source: 'conversion_review', target: 'mark_approved', type: 'default', label: 'approve' },\n    { id: 'e4', source: 'conversion_review', target: 'mark_rejected', type: 'default', label: 'reject' },\n    { id: 'e5', source: 'mark_approved', target: 'notify_approved', type: 'default' },\n    { id: 'e6', source: 'notify_approved', target: 'end', type: 'default' },\n    { id: 'e7', source: 'mark_rejected', target: 'notify_rejected', type: 'default' },\n    { id: 'e8', source: 'notify_rejected', target: 'end', type: 'default' },\n  ],\n};\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/sales/flows/account-approval.flow.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/sales/flows\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/sales/flows/account-approval.flow.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport { P, cel } from '@objectstack/spec';\nimport type * as Automation from '@objectstack/spec/automation';\ntype Flow = Automation.Flow;\n\n/**\n * Account Approval \u2014 the sign-off a new account record needs before it counts\n * as established data.\n *\n * REQ-0003 step 5: \u300C\u5BA2\u6237\u4FE1\u606F\u63D0\u4EA4\u540E\u8FDB\u5165\u5BA1\u6279\u6D41\uFF0C\u5BA1\u6279\u901A\u8FC7\u540E\u5BA2\u6237\u6B63\u5F0F\u751F\u6548\u300D. Expressed as an\n * **approval node** (`type: 'approval'`, ADR-0019), the construct\n * `opportunity-approval.flow.ts` and `lead-conversion-approval.flow.ts` already\n * use \u2014 \u26D4 there is no `workflow` metadata type and no standalone\n * `ApprovalProcess` to author.\n *\n * ## \u26A0\uFE0F This flow ships ARMED, and that is the one place it differs from its\n * ## lead sibling\n *\n * `lead-conversion-approval` is inert until an install opts in, because\n * REQ-0005 asked for a gate that is off by default. REQ-0003 asks for the\n * opposite in as many words \u2014 acceptance 4: \"A newly created account sits in a\n * pending state, appears in the platform approval inbox HotCRM already mounts,\n * and only reaches the approved state through a decision on that request.\" So\n * every new account enters here: `crm_account.approval_status` ships with NO\n * default, a new account is born blank, and the start condition below fires on\n * the blank.\n *\n * ## `pending` is written by the request, not by the field default (#2067)\n *\n * The approval node's `approvalStatusField` mirror writes `pending` onto the\n * account the moment it opens the request (plugin-approvals `openNodeRequest`,\n * measured on 17.7.0), inside the create, so with approvals in the\n * composition acceptance 4 holds exactly as before and `pending` always has a\n * request behind it. Without approvals no executor exists for the node, the\n * run fails at it (`No executor registered for node type 'approval'`), and\n * nothing writes `pending`: the account stays blank and editable. A shipped\n * `pending` default had stamped every such account `pending` with no request\n * behind it, and the console derives its lock from that value, so each one\n * read \"locked for approval\" forever with nothing able to decide it.\n *\n * The off switch is still the field default, not this flow's `status`: an\n * install that wants no account sign-off gives the column a default of\n * `approved`, the start condition below is then false for every record that\n * will ever exist, and the gate is off AND still switchable. \u26D4 Do NOT reach\n * for `status: 'draft'` or `'obsolete'` instead \u2014 both were measured on\n * `@objectstack/service-automation` 17.4.0 and neither is an off switch: draft\n * flows still fire their triggers, and `isFlowEnabled` composes authoring\n * status with the installation's activation ledger so that `obsolete` is a gate\n * no install can ever turn back ON. That measurement is recorded in\n * `lead-conversion-approval.flow.ts`; it is quoted here, \u26D4 not re-derived.\n *\n * ## Why the trigger is insert-only\n *\n * Submission happens at exactly one moment, the account's creation, so that is\n * where the request is opened. \u26D4 An afterUpdate twin would re-enter on every\n * edit made while the account sat blank or pending and open a second request\n * for the same decision. The trigger, not the condition, is also what keeps an\n * account that predates this field out: it carries no `approval_status`, which\n * the condition below would read as blank, but it is never inserted again, so\n * it is never dragged into an approval it was not created under.\n */\nexport const AccountApprovalFlow: Flow = {\n  name: 'account_approval',\n  label: 'Account Approval',\n  description:\n    'Sign-off a newly created account needs before it counts as established data. Switchable from crm_account.approval_status.',\n  type: 'record_change',\n  status: 'active',\n  // Same reading the two sibling approval flows record. A gate exists to\n  // CONSTRAIN the submitter, so the submitter's own scope is the wrong identity\n  // to evaluate it under; and the verdict writes below land on\n  // `approval_status`, which is `readonly: true` on the object, so only a\n  // platform write reaches it at all.\n  runAs: 'system',\n\n  variables: [{ name: 'accountId', type: 'text', isInput: true, isOutput: false }],\n\n  nodes: [\n    {\n      id: 'start',\n      type: 'start',\n      label: 'Start',\n      config: {\n        objectName: 'crm_account',\n        triggerType: 'record-after-create',\n        // Fires on the BLANK a new account is born with (see the header):\n        // absent on a sparse driver, null on SQL. A user cannot pre-fill the\n        // column (it is `readonly`), so only a system writer or an install's\n        // `approved` default can make it non-blank at insert, and both mean\n        // \"nothing to submit\".\n        // TOTALITY (AGENTS.md \u2014 validation predicates must be TOTAL): the\n        // `(!has(x) || isBlank(x))` form is the \"x holds no value\" row of that\n        // table. A flow condition is strict CEL on every run, and an unguarded\n        // read against a driver that omits absent columns aborts \u2014 which from\n        // 17.0.0-rc.2 FAILS THE RUN rather than skipping it.\n        condition: P`!has(record.approval_status) || isBlank(record.approval_status)`,\n      },\n    },\n    {\n      id: 'get_account',\n      type: 'get_record',\n      label: 'Get Account',\n      config: {\n        objectName: 'crm_account',\n        filter: { id: cel`record.id` },\n        outputVariable: 'accountRecord',\n      },\n    },\n    {\n      id: 'account_review',\n      type: 'approval',\n      label: 'Account Review',\n      config: {\n        // The customer's chain is \u9500\u552E\u8D1F\u8D23\u4EBA \u2192 \u9500\u552E\u603B\u76D1; REQ-0003 rules that named\n        // chain **C** (overlay \u2014 one company's org chart), so core ships the\n        // one generic tier against the manager bench this app already declares.\n        approvers: [{ type: 'position', value: 'sales_manager' }],\n        // Explicit though it is the schema default, exactly as both sibling\n        // flows author it: approvers snapshot at request creation, so an empty\n        // bench would otherwise leave the request undecidable \u2014 and here that\n        // means an account nobody can ever approve.\n        onEmptyApprovers: 'admin_rescue',\n        behavior: 'first_response',\n        // \u26A0\uFE0F `false`, matching the lead sibling rather than the opportunity one.\n        // An account under review is a record a rep is still working \u2014 contacts\n        // are being attached, the address is being corrected, activity is\n        // landing on it. Locking it would freeze exactly the data-entry the\n        // approval exists to review. Nothing is at risk: the verdict column is\n        // `readonly: true`, so the only field this decision touches is one no\n        // user may write anyway.\n        lockRecord: false,\n        approvalStatusField: 'approval_status',\n      },\n    },\n    {\n      id: 'mark_approved',\n      type: 'update_record',\n      label: 'Mark Approved',\n      config: {\n        objectName: 'crm_account',\n        filter: { id: cel`record.id` },\n        fields: { approval_status: 'approved' },\n      },\n    },\n    {\n      id: 'notify_approved',\n      type: 'notify',\n      label: 'Notify Owner \u2014 Approved',\n      config: {\n        recipients: [cel`has(accountRecord.owner_id) ? accountRecord.owner_id : null`],\n        channels: ['inbox'],\n        topic: 'account_approved',\n        template: 'crm.account_approved',\n        templateData: { name: cel`accountRecord.name` },\n        actionUrl: '/crm_account/{{record.id}}',\n      },\n    },\n    {\n      id: 'mark_rejected',\n      type: 'update_record',\n      label: 'Mark Rejected',\n      config: {\n        objectName: 'crm_account',\n        filter: { id: cel`record.id` },\n        fields: { approval_status: 'rejected' },\n      },\n    },\n    {\n      id: 'notify_rejected',\n      type: 'notify',\n      label: 'Notify Owner \u2014 Rejected',\n      config: {\n        recipients: [cel`has(accountRecord.owner_id) ? accountRecord.owner_id : null`],\n        channels: ['inbox'],\n        severity: 'warning',\n        topic: 'account_rejected',\n        template: 'crm.account_rejected',\n        templateData: { name: cel`accountRecord.name` },\n        actionUrl: '/crm_account/{{record.id}}',\n      },\n    },\n    { id: 'end', type: 'end', label: 'End' },\n  ],\n\n  edges: [\n    { id: 'e1', source: 'start', target: 'get_account', type: 'default' },\n    { id: 'e2', source: 'get_account', target: 'account_review', type: 'default' },\n    // Approval-node branch labels \u2014 the engine resumes down the out-edge whose\n    // `label` matches the recorded decision.\n    { id: 'e3', source: 'account_review', target: 'mark_approved', type: 'default', label: 'approve' },\n    { id: 'e4', source: 'account_review', target: 'mark_rejected', type: 'default', label: 'reject' },\n    { id: 'e5', source: 'mark_approved', target: 'notify_approved', type: 'default' },\n    { id: 'e6', source: 'notify_approved', target: 'end', type: 'default' },\n    { id: 'e7', source: 'mark_rejected', target: 'notify_rejected', type: 'default' },\n    { id: 'e8', source: 'notify_rejected', target: 'end', type: 'default' },\n  ],\n};\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/sales/flows/schedule-followup.flow.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/sales/flows\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/sales/flows/schedule-followup.flow.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport { cel } from '@objectstack/spec';\nimport type * as Automation from '@objectstack/spec/automation';\nimport { TASK_TYPE_OPTIONS, plainOptions } from '../objects/_picklists';\ntype Flow = Automation.Flow;\n\n/**\n * Schedule Follow-up \u2014 one screen, one task, straight off the lead header.\n *\n * `log_call` / `log_meeting` record what already happened; this flow puts the\n * NEXT touch on the rep's list without leaving the lead \u2014 the single most\n * common thing a rep does after a call.\n *\n * \u26D4 Implemented as a SCREEN FLOW, never a `type: 'modal'` action: modal actions\n * are non-functional in 16.1.0 \u2014 the console resolves the action's `target` as\n * an object name and the submit dies on `GET /api/v1/meta/object/<target>` \u2192\n * 400, even though the spec defines `target` for modals as \"the modal/page name\n * to open\". Flow-typed actions are the mechanism that demonstrably works today;\n * `convert_lead` uses it.\n */\nexport const ScheduleFollowUpFlow: Flow = {\n  name: 'schedule_followup',\n  label: 'Schedule Follow-up',\n  description: 'Create the next follow-up task on a lead, already linked and owned.',\n  type: 'screen',\n  status: 'active',\n\n  variables: [\n    // MUST be `recordId` \u2014 the console's flow-action contract seeds only that\n    // name (and its camelCase object alias); a custom name arrives undefined.\n    { name: 'recordId', type: 'text', isInput: true, isOutput: false },\n    { name: 'subject', type: 'text', isInput: true, isOutput: false },\n    { name: 'dueDate', type: 'date', isInput: true, isOutput: false },\n    { name: 'activityType', type: 'text', isInput: true, isOutput: false },\n    { name: 'priority', type: 'text', isInput: true, isOutput: false },\n    { name: 'notes', type: 'text', isInput: true, isOutput: false },\n  ],\n\n  nodes: [\n    { id: 'start', type: 'start', label: 'Start', config: { objectName: 'crm_lead' } },\n    {\n      id: 'screen_1', type: 'screen', label: 'Schedule Follow-up',\n      config: {\n        fields: [\n          { name: 'subject', label: 'What is the next step?', type: 'text', required: true },\n          { name: 'dueDate', label: 'Due Date', type: 'date', required: true },\n          {\n            name: 'activityType', label: 'Activity Type', type: 'select',\n            // Mirrors crm_task.type exactly. \u26D4 Never hand-copy the subset \u2014 it\n            // silently drops an option (`other`) from the picker.\n            options: plainOptions(TASK_TYPE_OPTIONS),\n          },\n          {\n            name: 'priority', label: 'Priority', type: 'select',\n            options: [\n              { label: 'Low', value: 'low' },\n              { label: 'Normal', value: 'normal' },\n              { label: 'High', value: 'high' },\n              { label: 'Urgent', value: 'urgent' },\n            ],\n          },\n          { name: 'notes', label: 'Notes', type: 'textarea' },\n        ],\n      },\n    },\n    {\n      id: 'get_lead', type: 'get_record', label: 'Get Lead Record',\n      config: { objectName: 'crm_lead', filter: { id: cel`recordId` }, outputVariable: 'leadRecord' },\n    },\n    {\n      id: 'create_task', type: 'create_record', label: 'Create Follow-up Task',\n      config: {\n        objectName: 'crm_task',\n        fields: {\n          subject: cel`subject`,\n          due_date: cel`dueDate`,\n          // The three optional answers: a resume may leave one unbound, which\n          // the template wrote as nothing and the guard writes as null. On an\n          // insert the two are the same \u2014 the engine applies a field's default\n          // to an explicit null exactly as to an omitted key, so an unanswered\n          // priority still lands as `normal`.\n          type: cel`has(vars.activityType) ? activityType : null`,\n          priority: cel`has(vars.priority) ? priority : null`,\n          description: cel`has(vars.notes) ? notes : null`,\n          status: 'not_started',\n          owner_id: cel`current_user.id`,\n          // Polymorphic parent: both halves are required for the lead's\n          // Related tab to pick the task up.\n          related_to_type: 'crm_lead',\n          related_to_lead: cel`recordId`,\n        },\n        outputVariable: 'createdTask',\n      },\n    },\n    {\n      // Keep the lead's own follow-up date in step with the task that was just\n      // filed, so the Hot Leads view (sorted by next_followup_date) reflects\n      // the commitment the rep actually made.\n      id: 'stamp_lead', type: 'update_record', label: 'Stamp Next Follow-up Date',\n      config: {\n        objectName: 'crm_lead',\n        filter: { id: cel`recordId` },\n        fields: { next_followup_date: cel`dueDate` },\n      },\n    },\n    { id: 'end', type: 'end', label: 'End' },\n  ],\n\n  edges: [\n    { id: 'e1', source: 'start', target: 'screen_1', type: 'default' },\n    { id: 'e2', source: 'screen_1', target: 'get_lead', type: 'default' },\n    { id: 'e3', source: 'get_lead', target: 'create_task', type: 'default' },\n    { id: 'e4', source: 'create_task', target: 'stamp_lead', type: 'default' },\n    { id: 'e5', source: 'stamp_lead', target: 'end', type: 'default' },\n  ],\n};\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/sales/flows/opportunity-approval.flow.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/sales/flows\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/sales/flows/opportunity-approval.flow.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport { P, cel } from '@objectstack/spec';\nimport type * as Automation from '@objectstack/spec/automation';\nimport { HIGH_VALUE_DEAL_AMOUNT, LARGE_DEAL_AMOUNT } from '../objects/_thresholds';\ntype Flow = Automation.Flow;\n\n/**\n * Opportunity Approval \u2014 tiered sign-off for large deals.\n *\n * Expressed as **Approval nodes** (`type: 'approval'`, ADR-0019): the engine\n * opens an approval request on entry, suspends the run, and resumes down the\n * out-edge whose `label` matches the decision (`approve` / `reject`).\n * Notifications use the **`notify` node** (ADR-0012). \u26D4 Neither a\n * `connector_action` nor a standalone `ApprovalProcess` is available \u2014 both\n * authoring surfaces were removed in ObjectStack 7.4.\n *\n * Tiered policy (single source of truth \u2014 no double-firing):\n *   - amount >= $100K         \u2192 Sales Manager review\n *   - amount > $500K          \u2192 additionally Sales Director sign-off\n *\n * The entry gate is INCLUSIVE at the line (`>=`) and the director tier is\n * exclusive (`>`): those are not the same kind of number. `LARGE_DEAL_AMOUNT` is\n * the one line this app draws around \"large deal\", and every consumer of it \u2014\n * this gate, its insert twin, the won-deal alert and both sharing rules \u2014 must\n * cut the same way, so a deal at exactly $100,000 is large everywhere or\n * nowhere. `HIGH_VALUE_DEAL_AMOUNT` below is a matched PAIR (`> 500000` /\n * `<= 500000`) whose two halves must partition, which is a different property\n * and is left alone.\n *\n * On full approval the deal is stamped `approval_status = approved` (+ date);\n * any rejection stamps `approval_status = rejected`. The record is locked while\n * a step is pending and `approval_status` mirrors the live request status.\n */\nexport const OpportunityApprovalFlow: Flow = {\n  name: 'opportunity_approval',\n  label: 'Large Deal Approval',\n  description: 'Tiered approval for opportunities: manager review at $100K or more, director sign-off > $500K.',\n  type: 'record_change',\n  status: 'active',\n  // Same user-less exposure as every record-change flow (ADR-0049) \u2014 and the\n  // one with teeth. Measured on 17.0.0-rc.2: a $150K renewal\n  // created by the `runAs: 'system'` contract_renewal sweep fired this flow\n  // with no trigger user, and the run died at `get_opportunity`. The deal sat\n  // at `approval_status: 'not_required'`, unlocked, with no approval request\n  // ever opened \u2014 the gate was bypassed by the writer simply not carrying a\n  // session. An approval control that only engages for logged-in writers is\n  // not a control.\n  //\n  // Elevating the USER-driven runs too is not merely acceptable here, it is\n  // required. This gate exists to CONSTRAIN the submitter, so the submitter's\n  // own scope is the wrong identity to evaluate it under; and\n  // `mark_approved` / `mark_rejected` stamp `approval_status` on a record the\n  // approval node holds locked (`lockRecord: true`), which only a platform\n  // write may land. The approval node itself already opens its request under\n  // the platform identity while re-attaching the deciding user for\n  // attribution, so this declaration aligns the flow with the node it drives.\n  runAs: 'system',\n\n  variables: [\n    { name: 'opportunityId', type: 'text', isInput: true, isOutput: false },\n  ],\n\n  nodes: [\n    {\n      id: 'start',\n      type: 'start',\n      label: 'Start',\n      // Trigger wiring (7.4): bind to afterUpdate; gate on crossing the entry\n      // threshold while not already in an approval state. The `not_required`\n      // guard stops the flow's own approval_status writes from re-triggering it.\n      config: {\n        objectName: 'crm_opportunity',\n        triggerType: 'record-after-update',\n        // Null-tolerant: rows inserted before approval_status had a field-level\n        // defaultValue (e.g. flow-created opportunities) carry null, which must\n        // still enter approval.\n        // Stage guard: a settled deal must never (re-)enter approval \u2014 the\n        // freeze hook rejects approval-status writes on closed records, so\n        // without this guard the flow opened a locked approval request it\n        // could never resolve (lockRecord held the closed record hostage).\n        // TOTALITY: `has(...)` on every read, plus `!= null` on the\n        // ordering comparison \u2014 `has()` passes an explicit null and\n        // `record.amount >= 100000` then aborts with\n        // `no such overload: dyn<null> >= int`. Measured total as authored\n        // today (amount/stage are required, approval_status is defaulted), but\n        // that is `crm_opportunity`'s schema doing the work, not the\n        // predicate. An absent `approval_status` reads the same as the null\n        // this condition already tolerates; an absent `stage` is not a settled\n        // stage, so it must not block approval.\n        condition: P`has(record.amount) && record.amount != null && record.amount >= ${LARGE_DEAL_AMOUNT}\n          && (!has(record.approval_status) || record.approval_status == \"not_required\" || record.approval_status == null)\n          && (!has(record.stage) || (record.stage != \"closed_won\" && record.stage != \"closed_lost\"))`,\n      },\n    },\n    {\n      id: 'get_opportunity',\n      type: 'get_record',\n      label: 'Get Opportunity',\n      config: { objectName: 'crm_opportunity', filter: { id: cel`record.id` }, outputVariable: 'oppRecord' },\n    },\n\n    // \u2500\u2500 Tier 1: Sales Manager review (all deals at $100K or more) \u2500\u2500\u2500\n    {\n      id: 'manager_review',\n      type: 'approval',\n      label: 'Sales Manager Review',\n      config: {\n        // \u26D4 Never add an org-owner approver as an empty-bench workaround.\n        // `onEmptyApprovers: 'admin_rescue'` is the node policy for an empty\n        // position on @objectstack 17 (approvers snapshot at request creation,\n        // so a position with no holders would otherwise leave the request\n        // undecidable while `lockRecord` held the record hostage). An\n        // `{ type: 'org_membership_level', value: 'owner' }` entry overshoots:\n        // with `behavior: 'first_response'` it makes an org owner a routine\n        // approver for every deal, not a rescue when the bench is empty.\n        approvers: [{ type: 'position', value: 'sales_manager' }],\n        // Explicit even though `admin_rescue` is the schema default \u2014 this is\n        // the mechanism the node depends on, so it is authored, not inherited.\n        onEmptyApprovers: 'admin_rescue',\n        behavior: 'first_response',\n        lockRecord: true,\n        approvalStatusField: 'approval_status',\n      },\n    },\n\n    // \u2500\u2500 Tier gate: does this deal also need director sign-off? \u2500\u2500\u2500\u2500\u2500\u2500\n    {\n      // No `config.condition` here: the branch is on edges `e5` / `e6`, which\n      // is where the engine actually reads it. A copy on the node would be\n      // inert and indistinguishable from the live one (17.0.0-rc.2's\n      // `flow-inert-node-condition`).\n      id: 'check_high_value',\n      type: 'decision',\n      label: 'High Value (> $500K)?',\n    },\n\n    // \u2500\u2500 Tier 2: Sales Director sign-off (deals > $500K only) \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n    {\n      id: 'director_signoff',\n      type: 'approval',\n      label: 'Sales Director Sign-off',\n      config: {\n        // Same node policy as manager_review \u2014 see the note there.\n        approvers: [{ type: 'position', value: 'sales_director' }],\n        onEmptyApprovers: 'admin_rescue',\n        behavior: 'first_response',\n        lockRecord: true,\n        approvalStatusField: 'approval_status',\n      },\n    },\n\n    // \u2500\u2500 Final approve: stamp status + notify owner \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n    {\n      id: 'mark_approved',\n      type: 'update_record',\n      label: 'Mark Approved',\n      config: {\n        objectName: 'crm_opportunity',\n        filter: { id: cel`record.id` },\n        fields: { approval_status: 'approved', approved_date: cel`isoDatetime(now())` },\n      },\n    },\n    {\n      id: 'notify_approved',\n      type: 'notify',\n      label: 'Notify Owner \u2014 Approved',\n      config: {\n        recipients: [cel`has(oppRecord.owner_id) ? oppRecord.owner_id : null`],\n        channels: ['inbox', 'email'],\n        topic: 'opportunity_approved',\n        template: 'crm.opportunity_approved',\n        templateData: { name: cel`oppRecord.name` },\n        actionUrl: '/crm_opportunity/{{record.id}}',\n      },\n    },\n\n    // \u2500\u2500 Rejection: stamp status + notify owner \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n    {\n      id: 'mark_rejected',\n      type: 'update_record',\n      label: 'Mark Rejected',\n      config: {\n        objectName: 'crm_opportunity',\n        filter: { id: cel`record.id` },\n        fields: { approval_status: 'rejected' },\n      },\n    },\n    {\n      id: 'notify_rejected',\n      type: 'notify',\n      label: 'Notify Owner \u2014 Rejected',\n      config: {\n        recipients: [cel`has(oppRecord.owner_id) ? oppRecord.owner_id : null`],\n        channels: ['inbox', 'email'],\n        severity: 'warning',\n        topic: 'opportunity_rejected',\n        template: 'crm.opportunity_rejected',\n        templateData: { name: cel`oppRecord.name` },\n        actionUrl: '/crm_opportunity/{{record.id}}',\n      },\n    },\n\n    { id: 'end', type: 'end', label: 'End' },\n  ],\n\n  edges: [\n    { id: 'e1', source: 'start', target: 'get_opportunity', type: 'default' },\n    { id: 'e2', source: 'get_opportunity', target: 'manager_review', type: 'default' },\n\n    // Manager decision (approval-node branch labels)\n    { id: 'e3', source: 'manager_review', target: 'check_high_value', type: 'default', label: 'approve' },\n    { id: 'e4', source: 'manager_review', target: 'mark_rejected', type: 'default', label: 'reject' },\n\n    // Tier gate (decision-node conditional branches). These EDGES are the live\n    // sites \u2014 the engine never evaluates a `decision` node's singular\n    // `config.condition` \u2014 and they must PARTITION, so the guards are written\n    // in opposite polarity. A deal whose amount cannot be read lands on\n    // `mark_approved`: the manager has already approved it, and an unreadable\n    // amount must not strand an approved deal in a locked, undecidable\n    // director step.\n    //\n    // TOTALITY: `oppRecord` is a `get_record` OUTPUT, so the read needs\n    // `has(vars.oppRecord)` (the variable), `has(vars.oppRecord.amount)` (the\n    // column \u2014 `findOne` answers a miss with `null`, and a sparse driver row\n    // omits an unwritten column outright) and `!= null` (an explicit null\n    // passes `has()` and the ordering comparison then aborts with `no such\n    // overload: dyn<null> > int`). Measured total as authored today \u2014 `amount`\n    // is `required` on `crm_opportunity` and the `get_record` is keyed on the\n    // row that just fired the trigger \u2014 but that is the neighbouring schema\n    // doing the work, exactly as in the start condition above. `vars.`-scoped\n    // rather than bare: `has(oppRecord.amount)` still aborts with `Unknown\n    // variable: oppRecord` on an unbound variable, `has(vars.oppRecord)`\n    // answers `false` (measured). From 17.0.0-rc.2 an unevaluable condition\n    // ABORTS the step rather than skipping it, so a guard that was\n    // belt-and-braces is now what keeps the run alive.\n    { id: 'e5', source: 'check_high_value', target: 'director_signoff', type: 'conditional', condition: P`has(vars.oppRecord) && has(vars.oppRecord.amount)\n      && vars.oppRecord.amount != null && vars.oppRecord.amount > ${HIGH_VALUE_DEAL_AMOUNT}`, label: 'High value (> $500K)' },\n    { id: 'e6', source: 'check_high_value', target: 'mark_approved', type: 'conditional', condition: P`!has(vars.oppRecord) || !has(vars.oppRecord.amount)\n      || vars.oppRecord.amount == null || vars.oppRecord.amount <= ${HIGH_VALUE_DEAL_AMOUNT}`, label: 'Standard (\u2264 $500K)' },\n\n    // Director decision (approval-node branch labels)\n    { id: 'e7', source: 'director_signoff', target: 'mark_approved', type: 'default', label: 'approve' },\n    { id: 'e8', source: 'director_signoff', target: 'mark_rejected', type: 'default', label: 'reject' },\n\n    // Terminal branches\n    { id: 'e9', source: 'mark_approved', target: 'notify_approved', type: 'default' },\n    { id: 'e10', source: 'notify_approved', target: 'end', type: 'default' },\n    { id: 'e11', source: 'mark_rejected', target: 'notify_rejected', type: 'default' },\n    { id: 'e12', source: 'notify_rejected', target: 'end', type: 'default' },\n  ],\n};\n\n/**\n * Insert-time twin of `opportunity_approval`. A record-change flow binds\n * exactly one hook event, so the afterUpdate flow above never sees\n * opportunities BORN over the threshold \u2014 flow-created deals (contract\n * renewals, lead conversion) and API inserts. \u26D4 Do not delete this twin\n * expecting the afterUpdate flow to cover them; that population is exactly what\n * the start condition's null-tolerance is written for. Same nodes/edges, only\n * the start node is rebound to afterInsert (mirrors `CaseEscalationOnCreateFlow`).\n * The stage guard carries over, keeping seeded/imported closed deals out.\n */\nexport const OpportunityApprovalOnCreateFlow: Flow = {\n  ...OpportunityApprovalFlow,\n  name: 'opportunity_approval_on_create',\n  label: 'Large Deal Approval (on create)',\n  description: 'Approval intake for opportunities created above the threshold (insert-time twin of opportunity_approval).',\n  nodes: OpportunityApprovalFlow.nodes.map((n) =>\n    n.id === 'start'\n      ? { ...n, config: { ...n.config, triggerType: 'record-after-create' } }\n      : n,\n  ),\n};\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/sales/flows/opportunity-status-change-approval.flow.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/sales/flows\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/sales/flows/opportunity-status-change-approval.flow.ts\";// Copyright (c) 2026 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport { P, cel } from '@objectstack/spec';\nimport type * as Automation from '@objectstack/spec/automation';\ntype Flow = Automation.Flow;\n\n/**\n * Opportunity Status Change Approval \u2014 sign-off before a deal is declared won\n * or abandoned.\n *\n * REQ-0006 steps 13 + 14: \u300C\u53D1\u8D77\u8D62\u5355\u3001\u5F03\u5355\u2026\u72B6\u6001\u53D8\u66F4\u64CD\u4F5C\uFF0C\u586B\u5199\u53D8\u66F4\u539F\u56E0\u4E0E\u8BF4\u660E\u300D then\n * \u300C\u91CD\u8981\u72B6\u6001\u53D8\u66F4\u9700\u5BA1\u6279\uFF0C**\u901A\u8FC7\u540E\u5546\u673A\u72B6\u6001\u6B63\u5F0F\u751F\u6548**\u300D. Expressed as an **approval node**\n * (`type: 'approval'`, ADR-0019), the construct `opportunity-approval.flow.ts`\n * already uses \u2014 \u26D4 there is no `workflow` metadata type and no standalone\n * `ApprovalProcess` to author.\n *\n * ## Why the STAGE is not what the rep writes\n *\n * REQ-0006 acceptance 3: the request opens \"and the stage does not change\n * until it is decided\". A `record_change` flow binds an AFTER hook, so by the\n * time it runs the stage has already moved \u2014 an after-flow can lock the record\n * but it cannot un-move it. So the rep writes the REQUEST\n * (`requested_status`) and the approved decision writes the STAGE, which is\n * also literally what the customer's own step 14 says (\"\u901A\u8FC7\u540E\u2026\u6B63\u5F0F\u751F\u6548\").\n * `opportunity.hook.ts` refuses a direct user move into a closed stage while\n * the gate is armed, and names this field in the refusal.\n *\n * ## \u26A0\uFE0F This flow is INERT until an install arms the gate, and that is by design\n *\n * REQ-0006 acceptance 3 again: \"with it off (the default), the existing\n * amount-tiered behaviour of `opportunity-approval.flow.ts` is bit-for-bit\n * what it is today.\"\n *\n * The switch is `crm_opportunity.status_change_approval_status`'s\n * `defaultValue`, \u26D4 not this flow's `status`. Shipped, that default is\n * `not_required`, so no deal is ever born `pending`, the start condition below\n * is false for every record that has ever existed, and this flow opens nothing\n * \u2014 it costs one predicate evaluation per update. An install arms the gate by\n * changing that one value to `'pending'`.\n *\n * \u26D4 Do NOT reach for `status: 'draft'` as the off switch instead, and \u26D4 not\n * `'obsolete'` either. Both readings are measured and recorded in\n * `lead-conversion-approval.flow.ts`'s docstring on\n * `@objectstack/service-automation` 17.4.0, the pin at that taking: draft flows still fire their\n * triggers, and `isFlowEnabled` composes `obsolete` with the installation's\n * activation ledger into a gate no install can ever turn ON. \u26D4 Do not\n * re-derive it here.\n *\n * \u21D2 A deal that predates the arming keeps `not_required` and never enters,\n * so arming the gate invalidates no existing record.\n *\n * ## \u26A0\uFE0F Its own verdict column, NOT `approval_status`\n *\n * `approval_status` belongs to the amount-tiered flow. Sharing it would make\n * either gate's verdict erase the other's \u2014 and worse, re-arm the amount flow,\n * whose entry condition fires on `approval_status == \"not_required\"`.\n */\nexport const OpportunityStatusChangeApprovalFlow: Flow = {\n  name: 'opportunity_status_change_approval',\n  label: 'Opportunity Status Change Approval',\n  description:\n    'Sign-off a deal needs before it is declared won or lost. Inert unless the install arms the gate on crm_opportunity.status_change_approval_status.',\n  type: 'record_change',\n  status: 'active',\n  // REQ-0006 acceptance 4, and the same reading `opportunity_approval` records\n  // from its own measured failure: a gate that engages only for writers\n  // carrying a session is not a control \u2014 a `runAs: 'system'` sweep or import\n  // would simply bypass it. The verdict and the stage write below also land on\n  // columns the readonly strip protects, which only a platform write reaches.\n  runAs: 'system',\n\n  variables: [\n    { name: 'opportunityId', type: 'text', isInput: true, isOutput: false },\n  ],\n\n  nodes: [\n    {\n      id: 'start',\n      type: 'start',\n      label: 'Start',\n      config: {\n        objectName: 'crm_opportunity',\n        triggerType: 'record-after-update',\n        // TOTALITY (AGENTS.md \u2014 validation predicates must be TOTAL): `has()`\n        // on every read. A flow condition is strict CEL on every run and an\n        // unguarded read against a driver that omits absent columns aborts,\n        // which from 17.0.0-rc.2 FAILS THE RUN rather than skipping it. The\n        // absent case must read as \"not gated\": a deal with no gate column at\n        // all predates the field and closes the way it always did.\n        //\n        // Three halves:\n        //\n        // - the gate is ARMED: `pending` (born armed, no request decided yet)\n        //   or `rejected` (the last request was refused). `rejected` re-opens\n        //   on a new request because `opportunity.hook.ts` refuses a direct\n        //   close in both states \u2014 if only `pending` entered here, a rejected\n        //   deal could be neither requested nor closed, ever.\n        // - a request is present;\n        // - the request is NEW on this write. TRANSITION, not current value \u2014\n        //   the idiom `billing_handoff_closed_won` records for this object.\n        //   Without it the flow re-fires on its own write-back while the\n        //   request is still open (the approval node's `pending` stamp through\n        //   `approvalStatusField` is an update of this record). Measured on\n        //   17.6.0 with this term deleted: one re-entry per request, each\n        //   caught only by the engine's self-trigger guard (\"the guard as\n        //   authored does not exclude the flow's own write-back\"); with it,\n        //   none. `previous.*` is guarded FAIL-CLOSED: no visible prior\n        //   value, no visible new request.\n        //\n        // `apply_status` leaves the gate `approved` (out of reach) and\n        // `clear_request` empties the request, so neither re-enters.\n        condition: P`has(record.status_change_approval_status)\n          && (record.status_change_approval_status == \"pending\" || record.status_change_approval_status == \"rejected\")\n          && has(record.requested_status) && record.requested_status != null && record.requested_status != \"\"\n          && has(previous.requested_status) && previous.requested_status != record.requested_status`,\n      },\n    },\n    {\n      id: 'get_opportunity',\n      type: 'get_record',\n      label: 'Get Opportunity',\n      config: { objectName: 'crm_opportunity', filter: { id: cel`record.id` }, outputVariable: 'oppRecord' },\n    },\n    {\n      id: 'status_review',\n      type: 'approval',\n      label: 'Status Change Review',\n      config: {\n        // The customer's chain is \u9500\u552E\u8D1F\u8D23\u4EBA \u2192 \u4E8B\u4E1A\u90E8\u8D1F\u8D23\u4EBA; the generic shape core\n        // ships is the manager bench this app already declares approvers\n        // against. A second tier, or a different position, is overlay\n        // configuration (REQ-0006 acceptance 5).\n        approvers: [{ type: 'position', value: 'sales_manager' }],\n        // Explicit though it is the schema default, exactly as both sibling\n        // approvals author it: approvers snapshot at request creation, so an\n        // empty bench would leave the request undecidable \u2014 and here that\n        // means a deal nobody can ever close.\n        onEmptyApprovers: 'admin_rescue',\n        behavior: 'first_response',\n        // `true`, matching `opportunity_approval` and NOT the lead gate: a deal\n        // awaiting a won/lost verdict must not keep moving underneath the\n        // approver. Its narrative fields are what the freeze hook leaves open\n        // anyway.\n        lockRecord: true,\n        approvalStatusField: 'status_change_approval_status',\n      },\n    },\n    {\n      // The approved decision is what moves the stage \u2014 \"\u901A\u8FC7\u540E\u6B63\u5F0F\u751F\u6548\".\n      //\n      // \u26A0\uFE0F Both fields in ONE write, and that is load-bearing: the\n      // status-change guard in `opportunity.hook.ts` reads the gate column\n      // INPUT-FIRST, so this write presents itself as already-approved and the\n      // guard lets the stage through. Splitting it into two writes would have\n      // the guard refuse the flow's own write (ELEVATION IS NOT ANONYMITY \u2014\n      // `runAs: 'system'` carries the triggering user, so `ctx.user?.id` is\n      // present in this run).\n      //\n      // `win_reason` / `loss_reason` are `requiredWhen` the stage is closed and\n      // are evaluated against the merged record, so the values the rep captured\n      // when requesting satisfy them here.\n      id: 'apply_status',\n      type: 'update_record',\n      label: 'Apply Requested Status',\n      config: {\n        objectName: 'crm_opportunity',\n        filter: { id: cel`record.id` },\n        fields: {\n          stage: cel`oppRecord.requested_status`,\n          status_change_approval_status: 'approved',\n          approved_date: cel`isoDatetime(now())`,\n        },\n      },\n    },\n    {\n      // A rejected request is cleared, not left standing, and the verdict stays\n      // `rejected` so the hook keeps refusing a direct close: the way on is a\n      // new request, which the start condition opens as a fresh approval.\n      id: 'clear_request',\n      type: 'update_record',\n      label: 'Clear Rejected Request',\n      config: {\n        objectName: 'crm_opportunity',\n        filter: { id: cel`record.id` },\n        fields: { status_change_approval_status: 'rejected', requested_status: null },\n      },\n    },\n    { id: 'end', type: 'end', label: 'End' },\n  ],\n\n  edges: [\n    { id: 'e1', source: 'start', target: 'get_opportunity', type: 'default' },\n    { id: 'e2', source: 'get_opportunity', target: 'status_review', type: 'default' },\n    // Approval-node branch labels.\n    { id: 'e3', source: 'status_review', target: 'apply_status', type: 'default', label: 'approve' },\n    { id: 'e4', source: 'status_review', target: 'clear_request', type: 'default', label: 'reject' },\n    { id: 'e5', source: 'apply_status', target: 'end', type: 'default' },\n    { id: 'e6', source: 'clear_request', target: 'end', type: 'default' },\n  ],\n};\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/sales/flows/opportunity-qualification-approval.flow.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/sales/flows\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/sales/flows/opportunity-qualification-approval.flow.ts\";// Copyright (c) 2026 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport { P, cel } from '@objectstack/spec';\nimport type * as Automation from '@objectstack/spec/automation';\ntype Flow = Automation.Flow;\n\n/**\n * Opportunity Qualification Approval \u2014 the \u7ACB\u9879 sign-off a new deal needs\n * before its stage or its won/lost call may change. Will Bid (\u662F\u5426\u6295\u6807) is\n * not held: step 8 makes it input to \u7ACB\u9879, for the approver to read (#2004).\n *\n * REQ-0006 step 11: \u300C\u9500\u552E\u7ACB\u9879\u9700\u8D70\u5BA1\u6279\u6D41\u7A0B\uFF1B\u65B0\u589E\u5546\u673A\u53EF\u8DDF\u8FDB\uFF0C\u7ACB\u9879\u901A\u8FC7\u540E\u65B9\u53EF\u66F4\u65B0\u9636\u6BB5\u3001\u6295\u6807\u3001\n * \u8D62\u4E22\u5355\u64CD\u4F5C\u3002\u300D Expressed as an **approval node** (`type: 'approval'`, ADR-0019),\n * the construct `opportunity-approval.flow.ts` already uses \u2014 \u26D4 there is no\n * `workflow` metadata type and no standalone `ApprovalProcess` to author.\n *\n * Built on `opportunity-status-change-approval.flow.ts` (REQ-0006 step 14) and\n * deliberately the same in every load-bearing term: the switch is a verdict\n * field's `defaultValue`, the rep writes a REQUEST and the flow opens one\n * approval when the request is NEW, `rejected` re-opens on a new request,\n * `runAs: 'system'`, `onEmptyApprovers: 'admin_rescue'`. The refusal of the\n * two gated acts lives beside the step-14 refusal in `opportunity.hook.ts`'s\n * `opportunity_lifecycle`. Where it differs, the reason is written beside it\n * (`lockRecord`).\n *\n * ## \u26A0\uFE0F This flow is INERT until an install arms the gate, and that is by design\n *\n * REQ-0006 *Disposition*: \"**Both gates must be configurable \u2014 off by\n * default**, so existing installs keep today's amount-only behaviour.\"\n *\n * The switch is `crm_opportunity.qualification_approval_status`'s\n * `defaultValue`, \u26D4 not this flow's `status` (`draft` still fires triggers and\n * `obsolete` is a gate no install can turn ON \u2014 measured and recorded in\n * `lead-conversion-approval.flow.ts`; \u26D4 do not re-derive it here). Shipped,\n * that default is `not_required`, so no deal is ever born `pending`, the start\n * condition below is false for every record that has ever existed, and this\n * flow opens nothing \u2014 it costs one predicate evaluation per update. An\n * install arms the gate by changing that one value to `'pending'`.\n *\n * ## With the status-change gate armed too\n *\n * \u7ACB\u9879 comes first: while this verdict is `pending` or `rejected`,\n * `opportunity_lifecycle` refuses a new `requested_status`, so no status-change\n * approval can be asked for. Once \u7ACB\u9879 is `approved` this flow is out of reach\n * for good, and the status-change gate behaves exactly as it does alone. This\n * flow's own writes carry neither `stage` nor `requested_status`, so they can\n * trip neither gate; both columns sit in the hook's APPROVAL_FIELDS so the\n * closed-deal freeze cannot refuse them either.\n *\n * \u26A0\uFE0F The platform holds ONE pending approval per record (`openNodeRequest`\n * throws `DUPLICATE_REQUEST` otherwise, `@objectstack/plugin-approvals`\n * 17.6.0), so the opportunity gates never stack on one deal: a request a\n * second gate would open while another is pending is refused, not queued.\n * Measured on a 17.6.0 boot with this gate armed: a deal raised past\n * `LARGE_DEAL_AMOUNT` while its \u7ACB\u9879 request waited failed\n * `opportunity_approval`'s run with that error (logged, nothing opened); the\n * amount approval opened on the next write, which was this flow's own verdict\n * stamp, because the amount flow's entry tests the current value.\n */\nexport const OpportunityQualificationApprovalFlow: Flow = {\n  name: 'opportunity_qualification_approval',\n  label: 'Opportunity Qualification Approval',\n  description:\n    'The \u7ACB\u9879 sign-off a deal needs before its stage or won/lost call may change. Inert unless the install arms the gate on crm_opportunity.qualification_approval_status.',\n  type: 'record_change',\n  status: 'active',\n  // The reading both sibling gates record from `opportunity_approval`'s\n  // measured failure: a gate that engages only for writers carrying a session\n  // is not a control. The verdict writes below also land on a column the\n  // readonly strip protects, which only a platform write reaches.\n  runAs: 'system',\n\n  variables: [\n    { name: 'opportunityId', type: 'text', isInput: true, isOutput: false },\n  ],\n\n  nodes: [\n    {\n      id: 'start',\n      type: 'start',\n      label: 'Start',\n      config: {\n        objectName: 'crm_opportunity',\n        triggerType: 'record-after-update',\n        // TOTALITY (AGENTS.md \u2014 validation predicates must be TOTAL): `has()`\n        // on every read; the absent case reads as \"not gated\".\n        //\n        // Three halves, the status-change gate's own:\n        //\n        // - the gate is ARMED: `pending` or `rejected`. `rejected` re-opens on a\n        //   new request because the hook refuses the gated acts in both states \u2014\n        //   if only `pending` entered here, a rejected deal could never qualify.\n        // - the request is ticked;\n        // - the request is NEW on this write. TRANSITION, not current value:\n        //   the approval node's `pending` stamp through `approvalStatusField` is\n        //   an update of this record while the request is still ticked, and a\n        //   current-value test re-fires on it. Measured on a 17.6.0 boot with\n        //   this term deleted: one re-entry per request, caught only by the\n        //   engine's self-trigger guard (\"the guard as authored does not\n        //   exclude the flow's own write-back\"); with it, none. `previous.*` is\n        //   guarded FAIL-CLOSED: no visible prior value, no visible new request.\n        //\n        // `mark_qualified` leaves the gate `approved` (out of reach) and\n        // `clear_request` unticks the request, so neither re-enters.\n        condition: P`has(record.qualification_approval_status)\n          && (record.qualification_approval_status == \"pending\" || record.qualification_approval_status == \"rejected\")\n          && has(record.qualification_requested) && record.qualification_requested == true\n          && has(previous.qualification_requested) && previous.qualification_requested != true`,\n      },\n    },\n    {\n      id: 'get_opportunity',\n      type: 'get_record',\n      label: 'Get Opportunity',\n      config: { objectName: 'crm_opportunity', filter: { id: cel`record.id` }, outputVariable: 'oppRecord' },\n    },\n    {\n      id: 'qualification_review',\n      type: 'approval',\n      label: 'Qualification Review',\n      config: {\n        // The customer's chain is \u9500\u552E\u8D1F\u8D23\u4EBA / \u4E8B\u4E1A\u90E8\u5BA1\u6279\u5C97 \u2192 \u4E8B\u4E1A\u90E8\u8D1F\u8D23\u4EBA; the generic\n        // shape core ships is the manager bench both sibling gates route to. A\n        // second tier, or a different position, is overlay configuration\n        // (REQ-0006: the named approval chains are C).\n        approvers: [{ type: 'position', value: 'sales_manager' }],\n        // Explicit though it is the schema default, as every sibling authors\n        // it: an empty bench would leave the request undecidable \u2014 here, a\n        // deal that can never move its stage.\n        onEmptyApprovers: 'admin_rescue',\n        behavior: 'first_response',\n        // \u26A0\uFE0F `false`, NOT the status-change gate's `true` \u2014 the one term this\n        // node deliberately takes from the LEAD gate instead. Step 11 says it\n        // in as many words: \u300C\u65B0\u589E\u5546\u673A\u53EF\u8DDF\u8FDB\u300D. A deal awaiting \u7ACB\u9879 is still being\n        // worked \u2014 the narrative, the customer calendar, the amount and Will\n        // Bid are what the approver reads \u2014 and locking it would stop that work\n        // for as long as the approver takes. The two acts the gate exists to hold\n        // are refused by `opportunity_lifecycle` whether or not a request is\n        // open, so the lock would add nothing but the freeze.\n        lockRecord: false,\n        approvalStatusField: 'qualification_approval_status',\n      },\n    },\n    {\n      id: 'mark_qualified',\n      type: 'update_record',\n      label: 'Mark Qualified',\n      config: {\n        objectName: 'crm_opportunity',\n        filter: { id: cel`record.id` },\n        fields: { qualification_approval_status: 'approved' },\n      },\n    },\n    {\n      // A rejected request is cleared, not left standing, and the verdict stays\n      // `rejected` so the hook keeps refusing the gated acts: the way on is a\n      // new request, which the start condition opens as a fresh approval.\n      id: 'clear_request',\n      type: 'update_record',\n      label: 'Clear Rejected Request',\n      config: {\n        objectName: 'crm_opportunity',\n        filter: { id: cel`record.id` },\n        fields: { qualification_approval_status: 'rejected', qualification_requested: false },\n      },\n    },\n    { id: 'end', type: 'end', label: 'End' },\n  ],\n\n  edges: [\n    { id: 'e1', source: 'start', target: 'get_opportunity', type: 'default' },\n    { id: 'e2', source: 'get_opportunity', target: 'qualification_review', type: 'default' },\n    // Approval-node branch labels.\n    { id: 'e3', source: 'qualification_review', target: 'mark_qualified', type: 'default', label: 'approve' },\n    { id: 'e4', source: 'qualification_review', target: 'clear_request', type: 'default', label: 'reject' },\n    { id: 'e5', source: 'mark_qualified', target: 'end', type: 'default' },\n    { id: 'e6', source: 'clear_request', target: 'end', type: 'default' },\n  ],\n};\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/sales/flows/opportunity-stagnation.flow.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/sales/flows\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/sales/flows/opportunity-stagnation.flow.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport { P, cel } from '@objectstack/spec';\nimport type * as Automation from '@objectstack/spec/automation';\nimport { guarded } from './_guarded-iteration';\ntype Flow = Automation.Flow;\n\n/**\n * Opportunity Stagnation \u2014 scheduled \"deal-rot\" detector.\n *\n * This daily sweep is what acts on `stage_entry_date` (stamped by the lifecycle\n * hook on insert and on every stage change): it finds open opportunities\n * stalled longer than the threshold, nudges the owner and books a follow-up\n * task so the deal re-enters the working set. A deal with an\n * open stall task is skipped (idempotency), so each stall episode produces\n * exactly one nudge; completing the task re-arms it.\n *\n * Capabilities exercised: scheduled trigger + `loop` + `notify` + task\n * creation. Pipeline-hygiene automation is one of the highest-ROI uses of\n * Flows in a sales org.\n */\nconst STALE_THRESHOLD_DAYS = 14;\n\nexport const OpportunityStagnationFlow: Flow = {\n  name: 'opportunity_stagnation',\n  label: 'Stalled Deal Alert',\n  description: 'Daily sweep: nudge owners about open opportunities stuck in-stage beyond the threshold.',\n  type: 'schedule',\n  status: 'active',\n  // Scheduled runs have no trigger user, so under the default runAs:'user' the\n  // data nodes execute UNSCOPED anyway. Declare runAs:'system' to make that\n  // RLS-bypassing elevation explicit and intended (ADR-0049).\n  runAs: 'system',\n\n  variables: [],\n\n  nodes: [\n    { id: 'start', type: 'start', label: 'Start (daily 07:30)', config: { schedule: '30 7 * * *' } },\n    {\n      id: 'query_stalled', type: 'get_record', label: 'Find Stalled Deals',\n      config: {\n        objectName: 'crm_opportunity',\n        // \u26D4 Predicate on the STORED `stage_entry_date`, never on\n        // `days_in_stage`: the latter is a formula, computed after the query, so\n        // as a filter key it addresses a column that does not exist.\n        // `entry < today \u2212 N`\n        // is the same test as `days_in_stage > N`, computed by a CEL value\n        // envelope (the `isoDate(daysAgo(n))` spelling; contract-renewal uses\n        // its `daysFromNow` twin).\n        // A row with a null `stage_entry_date` does not satisfy `$lt` and is\n        // skipped, preserving \"nothing has stagnated yet\" for unstamped rows.\n        filter: {\n          stage: { $nin: ['closed_won', 'closed_lost'] },\n          stage_entry_date: { $lt: cel`isoDate(daysAgo(${STALE_THRESHOLD_DAYS}))` },\n        },\n        limit: 500,\n        outputVariable: 'oppList',\n      },\n    },\n    {\n      id: 'loop_opps', type: 'loop', label: 'For Each Stalled Deal',\n      config: {\n        collection: cel`oppList`,\n        iteratorVariable: 'currentOpp',\n        body: guarded('opp', {\n          nodes: [\n            {\n              // Idempotency gate: a still-open stall task means this deal was\n              // already nudged. \u26D4 Without it the daily sweep re-notifies and\n              // re-creates an identical task every morning for as long as the\n              // deal stays stalled \u2014 an unbounded duplicate pile-up.\n              id: 'find_existing_task', type: 'get_record', label: 'Already Nudged?',\n              config: {\n                objectName: 'crm_task',\n                filter: {\n                  related_to_opportunity: cel`currentOpp.id`,\n                  subject: cel`'Advance stalled deal: ' + currentOpp.name`,\n                  status: { $nin: ['completed'] },\n                },\n                outputVariable: 'existingStallTask',\n              },\n            },\n            {\n              // Gateway only \u2014 the predicate lives on the out-edge.\n              id: 'check_not_nudged', type: 'decision', label: 'First Nudge?',\n            },\n            {\n              // Owner only: `{currentOpp.owner_id.manager}` cannot traverse a\n              // lookup in flow templates \u2014 it interpolates to the literal\n              // \"undefined\" (cf. opportunity_won_alert).\n              id: 'notify_owner', type: 'notify', label: 'Nudge Owner',\n              config: {\n                recipients: [cel`has(currentOpp.owner_id) ? currentOpp.owner_id : null`],\n                channels: ['inbox', 'email'],\n                topic: 'deal_stalled',\n                template: 'crm.deal_stalled',\n                templateData: {\n                  name: cel`currentOpp.name`, stage: cel`currentOpp.stage`,\n                  days_in_stage: cel`currentOpp.days_in_stage`,\n                },\n                actionUrl: '/crm_opportunity/{{currentOpp.id}}',\n              },\n            },\n            {\n              id: 'create_followup_task', type: 'create_record', label: 'Create Follow-up Task',\n              config: {\n                objectName: 'crm_task',\n                fields: {\n                  subject: cel`'Advance stalled deal: ' + currentOpp.name`,\n                  type: 'follow_up', priority: 'high', status: 'not_started',\n                  due_date: cel`isoDate(daysFromNow(2))`,\n                  owner_id: cel`has(currentOpp.owner_id) ? currentOpp.owner_id : null`,\n                  // ORG PARTITION. A schedule trigger carries no\n                  // organization, so without this the nudge task is born\n                  // `organization_id` NULL \u2014 outside every org partition.\n                  // Upstream ruling objectstack#6155 Q2=A assigns the answer to\n                  // the flow author; the task belongs to the org of the deal it\n                  // nudges. `crm_opportunity` carries the column, so the read\n                  // resolves. It is deliberately UNGUARDED: on 17.x a source\n                  // lacking it interpolated to `undefined` and landed as NULL\n                  // while looking declared; CEL fails the iteration instead, and\n                  // a `has()` guard would write that NULL back.\n                  organization_id: cel`currentOpp.organization_id`,\n                  related_to_type: 'crm_opportunity',\n                  related_to_opportunity: cel`currentOpp.id`,\n                },\n              },\n            },\n          ],\n          edges: [\n            { id: 'b1', source: 'find_existing_task', target: 'check_not_nudged', type: 'default' },\n            // \"Already nudged\" has no edge, so the loop moves to the next item.\n            // This edge is the ONLY site for the predicate: a `decision`\n            // node's singular `config.condition` is never read, so a node copy\n            // would be inert metadata free to drift away from what runs.\n            { id: 'b2', source: 'check_not_nudged', target: 'notify_owner', type: 'conditional', condition: P`existingStallTask == null`, label: 'First nudge' },\n            { id: 'b3', source: 'notify_owner', target: 'create_followup_task', type: 'default' },\n          ],\n        }),\n      },\n    },\n    { id: 'end', type: 'end', label: 'End' },\n  ],\n\n  edges: [\n    { id: 'e1', source: 'start', target: 'query_stalled', type: 'default' },\n    { id: 'e2', source: 'query_stalled', target: 'loop_opps', type: 'default' },\n    { id: 'e3', source: 'loop_opps', target: 'end', type: 'default' },\n  ],\n};\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/sales/flows/forecast-snapshot.flow.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/sales/flows\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/sales/flows/forecast-snapshot.flow.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport { P, expression, cel } from '@objectstack/spec';\nimport type * as Automation from '@objectstack/spec/automation';\nimport { guarded } from './_guarded-iteration';\ntype Flow = Automation.Flow;\n\n/**\n * Forecast Snapshot \u2014 nightly per-owner pipeline snapshot into `crm_forecast`.\n *\n * `forecast.hook.ts` only DERIVES fields on a row someone else creates, so this\n * sweep is what creates them. Without it the forecast object, its\n * `attainment_pct` / `coverage_ratio` formulas, the `forecast_metrics` dataset\n * and the dashboard's quota-attainment table all run on hand-seeded demo rows.\n *\n * ## Buckets\n *\n * Amounts are aggregated from `crm_opportunity` by `forecast_category` \u2014 the\n * stored, indexed column the opportunity lifecycle hook derives from `stage`,\n * and the same column the \"Commit & Best Case\" list view and the\n * `pipeline_by_forecast_category` dashboard widget already group on. \u26D4 Never\n * read the snapshot off `probability` instead: that creates a SECOND definition\n * of \"commit\" that silently disagrees with those surfaces.\n *\n * The buckets are CUMULATIVE, the standard forecast ladder \u2014 and the shape the\n * object's own fields already assume (`pipeline` is \"all open opportunities\",\n * so it necessarily contains the other two), the seeded magnitudes show\n * (pipeline > best case > commit), and the opportunity `closing_this_quarter`\n * view spells out by treating `['commit', 'best_case']` as one bucket:\n *\n *   pipeline_amount  \u2192 every OPEN opportunity closing in the period\n *   best_case_amount \u2192 open, forecast_category \u2208 { best_case, commit }\n *   commit_amount    \u2192 open, forecast_category = commit\n *   closed_amount    \u2192 stage = closed_won, closing in the period\n *\n * `quota` is deliberately never written: it is maintained by hand until a\n * quota model exists, and a sweep that reset it every night would erase the\n * denominator of `attainment_pct`.\n *\n * ## Shape\n *\n * Per owner: ensure the current-period row exists, re-read it, then sum four\n * scoped queries into it. Two things force that ordering.\n *\n * 1. The period window is DATA, not arithmetic. The 17.x flow template\n *    resolved `{TODAY()}` and day offsets only \u2014 it could not say \"the first\n *    day of this calendar quarter\". So the flow selects the row whose window\n *    CONTAINS today (`period_start <= today <= period_end`), lets `forecast.hook.ts`\n *    derive a calendar-true window on create, and then reads the boundaries\n *    back off the row to scope the opportunity queries. One definition of \"the\n *    current period\", owned by the object.\n * 2. Sums come from four separate `get_record` + `loop` pairs rather than one\n *    query with in-loop branching. A filter is plain metadata, so the bucket\n *    definitions stay declarative and greppable; the accumulators stay pure\n *    CEL arithmetic (see `sumBucket`).\n *\n * Idempotency: the row is keyed by (owner, period, containing window), so a\n * re-run finds it and OVERWRITES the amounts instead of inserting a second\n * row \u2014 the same upsert discipline as `contract_renewal` /\n * `opportunity_stagnation`. Re-running is how a snapshot stays current, and it\n * is the only way an amount ever decreases.\n *\n * ## Two questions, two scopes \u2014 a manual forecast SUPPRESSES the sweep\n *\n * \u26D4 Never answer both questions with one filter. The window answers \"has this\n * period been handled?\" and does NOT answer \"which row do I own?\". Used for\n * both, it destroys a manager's typed numbers: `source: 'manual'` is one of\n * three documented origins, and a hand-entered current-quarter row satisfies the\n * window filter exactly as the sweep's own row does, since both ends of the\n * window are pinned to the calendar quarter. The sweep then adopts it,\n * overwrites the four amounts, restamps `snapshot_date` and flips `source` to\n * `scheduled`. `quota` survives (it is never written), so attainment silently\n * re-bases onto swept numbers and the row still looks plausible.\n *\n * So the two jobs read through two filters:\n *\n *   gate  (`find_forecast`)   \u2192 CURRENT_PERIOD_FILTER \u2014 ANY row in the window,\n *                               manual included. \"Handled\" is about the period,\n *                               not about who handled it.\n *   write (`reload_forecast`) \u2192 OWNED_PERIOD_FILTER  \u2014 only rows the sweep\n *                               wrote (`source: 'scheduled'`).\n *\n * and `check_owned` turns \"the window is handled, but not by a row I own\" into\n * a stand-down: no write, and \u2014 equally load-bearing \u2014 no second row.\n *\n * \u26D4 Never reach that by excluding non-`scheduled` rows from ONE shared filter.\n * The sweep would stop finding the manual row, decide the period was unhandled\n * and OPEN a duplicate in the same window \u2014 and `this_quarter_forecasts` and the\n * quota-attainment widget pin `period_start` by equality, so both would match\n * two rows.\n *\n * The way out stays open: delete the manual row and the next sweep opens its\n * own again. Automation an override cannot silence is not an override.\n *\n * Note the scope is `source == 'scheduled'`, not `source != 'manual'`: an `ai`\n * row is equally not the sweep's to overwrite, and gets the same deference.\n *\n * Scope: an \"active opportunity owner\" is a user owning at least one\n * opportunity that is not `closed_lost`. Users with none are skipped entirely,\n * so a fresh install does not litter a zero row per employee.\n */\n\n/**\n * The period this sweep snapshots. `quarter` because that is what every\n * consumer reads: the `this_quarter_forecasts` view filters `period: 'quarter'`\n * and the quota-attainment table is a quarterly scoreboard. A monthly cadence\n * would be a second flow, not a flag \u2014 the upsert key is (owner, period).\n */\nconst SNAPSHOT_PERIOD = 'quarter';\n\n/** Open = not yet resolved either way. Both closed stages leave the pipeline. */\nconst OPEN_STAGES = { $nin: ['closed_won', 'closed_lost'] };\n\n/**\n * Window the current-period row: `period_start <= today <= period_end`.\n *\n * The IDEMPOTENCY scope \u2014 deliberately source-blind. \"Has this period been\n * handled?\" is a question about the window, so a manual row answers it just as\n * a scheduled one does, and the sweep opens nothing beside it.\n */\nconst CURRENT_PERIOD_FILTER = {\n  owner_id: cel`currentOwner.id`,\n  period: SNAPSHOT_PERIOD,\n  period_start: { $lte: cel`isoDate(today())` },\n  period_end: { $gte: cel`isoDate(today())` },\n};\n\n/**\n * The same window narrowed to the rows this sweep OWNS \u2014 its WRITE scope.\n *\n * `source` is what separates the two jobs. Anything else in the window\n * belongs to a human (`manual`) or an agent (`ai`) and is theirs to keep; a\n * miss here is the stand-down signal `check_owned` reads, not a reason to\n * create a second row. Narrowing the write scope also makes the target\n * DETERMINISTIC when a manager adds a manual row beside an existing scheduled\n * one: `findOne` over the shared window would hand back whichever row the\n * driver happened to order first.\n */\nconst OWNED_PERIOD_FILTER = { ...CURRENT_PERIOD_FILTER, source: 'scheduled' };\n\n/**\n * Opportunities of the owner in flight during the snapshot window.\n *\n * ## The organization pin\n *\n * `owner_id` and the period window are both organization-NEUTRAL predicates,\n * and this sweep runs `runAs: 'system'` \u2014 the one context the driver's\n * organization predicate does not constrain. Without the pin below, an owner\n * holding opportunities in more than one organization has every one of them\n * summed into the single row `CURRENT_PERIOD_FILTER` selects: one tenant's\n * forecast row reporting another tenant's pipeline. Nothing is NULL-partitioned\n * and no index is violated \u2014 the numbers are simply wrong, and wrong in the\n * direction that looks plausible. `sys_user` is what makes it reachable:\n * identity is GLOBAL and declares no `organization_id`, so the per-owner loop\n * item cannot narrow anything.\n *\n * The pin is the target row's own organization, read back off\n * `currentForecast`. That is the SAME \"prove the source carries the right\n * organization\" mechanism `ownerAnyDeal.organization_id` establishes on\n * `create_forecast`, inverted \u2014 not a second one. It is in scope by\n * construction: `currentForecast` already supplies the window boundaries in\n * this very filter, and `reload_forecast` binds it before any bucket runs.\n *\n * What this does NOT do: give a cross-organization owner one row per\n * organization. `crm_forecast` is still keyed by (owner, period), so such an\n * owner's snapshot now reports THIS organization's numbers only \u2014 true but\n * incomplete, and strictly better than the cross-tenant total it replaces.\n * Whether that key should widen is a product decision, recorded on #1372 and\n * deliberately not undertaken here.\n */\nconst inPeriod = (extra: Record<string, unknown>) => ({\n  owner_id: cel`currentOwner.id`,\n  organization_id: cel`currentForecast.organization_id`,\n  close_date: {\n    $gte: cel`currentForecast.period_start`,\n    $lte: cel`currentForecast.period_end`,\n  },\n  ...extra,\n});\n\n/**\n * One `get_record` + `loop` pair that sums `amount` into `total`.\n *\n * The accumulator is a CEL value envelope, so its operands are TYPED:\n * `double()` turns a currency some drivers return as a string (`\"90000\"`) into\n * a number, and a decimal amount keeps its cents. \u26D4 Never a bare\n * `double(amount)`: it ERRORS on null \u2014 `found no matching overload for\n * 'double(null)'` \u2014 and one opportunity without an amount would fail the\n * owner's whole sweep. The `has()` / `isBlank()` guard sums a null or absent\n * amount as 0. `expression()` rather than `P`: the source splices the node's\n * variable names, which the tag would JSON-quote.\n */\nconst sumBucket = (key: string, label: string, filter: Record<string, unknown>, total: string, item = `current_${key}`) => ({\n  find: {\n    id: `find_${key}`,\n    type: 'get_record' as const,\n    label: `Find ${label}`,\n    config: {\n      objectName: 'crm_opportunity',\n      filter,\n      limit: 500,\n      outputVariable: `${key}Opps`,\n    },\n  },\n  sum: {\n    id: `sum_${key}`,\n    type: 'loop' as const,\n    label: `Sum ${label}`,\n    config: {\n      collection: expression(`${key}Opps`, 'cel'),\n      iteratorVariable: item,\n      body: {\n        nodes: [\n          {\n            id: `add_${key}`,\n            type: 'assignment' as const,\n            label: `Add to ${label}`,\n            config: {\n              assignments: {\n                [total]: expression(`${total} + (!has(${item}.amount) || isBlank(${item}.amount) ? 0.0 : double(${item}.amount))`, 'cel'),\n              },\n            },\n          },\n        ],\n        edges: [],\n      },\n    },\n  },\n});\n\nconst BUCKETS = [\n  sumBucket('pipeline', 'Open Pipeline', inPeriod({ stage: OPEN_STAGES }), 'pipelineTotal'),\n  sumBucket(\n    'best_case',\n    'Best Case',\n    inPeriod({ stage: OPEN_STAGES, forecast_category: { $in: ['best_case', 'commit'] } }),\n    'bestCaseTotal',\n  ),\n  sumBucket(\n    'commit',\n    'Commit',\n    inPeriod({ stage: OPEN_STAGES, forecast_category: 'commit' }),\n    'commitTotal',\n  ),\n  sumBucket('won', 'Closed Won', inPeriod({ stage: 'closed_won' }), 'closedTotal'),\n];\n\n/**\n * The per-owner body runs as one straight line once the THREE gates pass:\n * reset \u2192 (find/sum) \u00D7 4 \u2192 write.\n *\n * \u26D4 The chain must start AFTER the `check_owned` gateway: every edge derived\n * from this list is unconditional, and `check_owned`'s out-edge is not.\n */\nconst OWNER_CHAIN = [\n  'reset_totals',\n  ...BUCKETS.flatMap((b) => [b.find.id, b.sum.id]),\n  'write_snapshot',\n];\n\nexport const ForecastSnapshotFlow: Flow = {\n  name: 'forecast_snapshot',\n  label: 'Forecast Snapshot',\n  description:\n    'Nightly sweep: upsert a current-quarter crm_forecast row per active opportunity owner with pipeline, best-case, commit and closed-won totals.',\n  type: 'schedule',\n  status: 'active',\n  // Scheduled runs have no trigger user, so under the default runAs:'user' the\n  // data nodes execute UNSCOPED anyway. Declare runAs:'system' to make that\n  // RLS-bypassing elevation explicit and intended (ADR-0049) \u2014 and it\n  // is load-bearing here: `crm_forecast` is `sharingModel: 'private'`, so a\n  // user-scoped sweep could only ever see its own rows.\n  runAs: 'system',\n\n  variables: [],\n\n  nodes: [\n    { id: 'start', type: 'start', label: 'Start (daily 03:00)', config: { schedule: '0 3 * * *' } },\n    {\n      // Every user is a candidate; the `has_deals` gate below decides who is\n      // actually an opportunity owner. Filtering `sys_user` here instead would\n      // hard-code an activity flag this app does not own.\n      // No `filter` key: an EMPTY filter node (`{}`) reduces to TRUE and\n      // matches every row, so it is indistinguishable from an absent key \u2014\n      // ObjectStack 17.0.0-rc.6 promotes the pair to an author-time error\n      // (`filter-empty-node`) precisely because only the absent key SAYS\n      // \"every user is a candidate\" to the next reader. The `has_deals` gate\n      // below is what actually narrows the set.\n      id: 'query_owners', type: 'get_record', label: 'Find Users',\n      config: { objectName: 'sys_user', limit: 500, outputVariable: 'ownerList' },\n    },\n    {\n      id: 'loop_owners', type: 'loop', label: 'For Each Owner',\n      config: {\n        collection: cel`ownerList`,\n        iteratorVariable: 'currentOwner',\n        body: guarded('owner', {\n          nodes: [\n            {\n              // Cheap findOne gate: a user with no live opportunity is not a\n              // forecast owner, and must not get a row (a fresh install would\n              // otherwise gain one empty snapshot per employee).\n              id: 'find_any_deal', type: 'get_record', label: 'Owns Any Live Deal?',\n              config: {\n                objectName: 'crm_opportunity',\n                filter: { owner_id: cel`currentOwner.id`, stage: { $nin: ['closed_lost'] } },\n                outputVariable: 'ownerAnyDeal',\n              },\n            },\n            {\n              // Gateway only \u2014 the predicate lives on the out-edge.\n              id: 'has_deals', type: 'decision', label: 'Active Owner?',\n            },\n            {\n              // Idempotency gate AND period lookup in one read: the row whose\n              // window contains today IS this owner's current-period snapshot.\n              id: 'find_forecast', type: 'get_record', label: 'Current-Period Snapshot?',\n              config: {\n                objectName: 'crm_forecast',\n                filter: CURRENT_PERIOD_FILTER,\n                outputVariable: 'existingForecast',\n              },\n            },\n            {\n              // Gateway only \u2014 the predicate lives on the out-edges.\n              id: 'check_missing', type: 'decision', label: 'First Snapshot This Period?',\n            },\n            {\n              // Only `period` is supplied: `forecast.hook.ts` derives\n              // period_start/period_end/period_label so the boundaries are\n              // calendar-true without the flow doing date arithmetic it\n              // cannot do. `quota` is omitted on purpose \u2014 see the header.\n              // A leaf node: the two mutually-exclusive edges out of\n              // `check_missing` both converge on `reload_forecast`, so the\n              // chain below runs exactly once on either path.\n              id: 'create_forecast', type: 'create_record', label: 'Open Snapshot Row',\n              config: {\n                objectName: 'crm_forecast',\n                fields: {\n                  owner_id: cel`currentOwner.id`,\n                  // ORG PARTITION. A schedule trigger carries no\n                  // organization, so without this the snapshot row is born\n                  // `organization_id` NULL \u2014 outside every org partition, where\n                  // an `(organization_id, \u2026)` unique index does not constrain\n                  // and org-scoped reads never see it. Upstream ruling\n                  // objectstack#6155 Q2=A assigns the answer to the flow author.\n                  //\n                  // The source is `ownerAnyDeal`, NOT `currentOwner`. The loop\n                  // item here is a `sys_user` row, and `sys_user` declares NO\n                  // `organization_id` \u2014 identity is global, org-partitioned it\n                  // is not (it carries `primary_business_unit_id` instead).\n                  // On 17.x `{currentOwner.organization_id}` interpolated to\n                  // `undefined` and landed as NULL: the publish guard, which only\n                  // checks that the key is declared, went green over a row still\n                  // born outside every partition (measured, not assumed). Under\n                  // CEL that read fails the iteration instead.\n                  //\n                  // `ownerAnyDeal` is the `crm_opportunity` from `find_any_deal`\n                  // \u2014 it carries the column, and edge `b2` (`ownerAnyDeal !=\n                  // null`) is the only route to this node, so it is never null\n                  // here. Semantically right too: an owner's forecast belongs to\n                  // the org their pipeline is in.\n                  organization_id: cel`ownerAnyDeal.organization_id`,\n                  period: SNAPSHOT_PERIOD,\n                  snapshot_date: cel`isoDate(today())`,\n                  source: 'scheduled',\n                  pipeline_amount: 0,\n                  best_case_amount: 0,\n                  commit_amount: 0,\n                  closed_amount: 0,\n                },\n              },\n            },\n            {\n              // Re-read rather than reuse the create output, so both paths\n              // (row already existed / row just created) hand the rest of the\n              // body ONE variable carrying the hook-derived period window.\n              //\n              // \u26D4 Scope this to OWNED_PERIOD_FILTER, never to the gate's\n              // window: this read chooses the row that gets WRITTEN, and the\n              // sweep only ever owns its own. A miss binds `currentForecast` to\n              // null \u2014 `get_record` always binds \u2014 which is exactly what\n              // `check_owned` below is there to read.\n              id: 'reload_forecast', type: 'get_record', label: 'Load Snapshot Row',\n              config: {\n                objectName: 'crm_forecast',\n                filter: OWNED_PERIOD_FILTER,\n                outputVariable: 'currentForecast',\n              },\n            },\n            {\n              // Gateway only \u2014 the predicate lives on the out-edge.\n              //\n              // The stand-down gate. The window is handled either way by the\n              // time we get here; this asks whether the row handling it is the\n              // sweep's. Same single-out-edge skip shape as `has_deals`: when\n              // the only conditional edge does not match, the iteration ends and\n              // the engine records the unreached nodes as `skipped` with this\n              // node as `skippedBy` \u2014 so a stand-down is visible in the run log\n              // rather than silent.\n              id: 'check_owned', type: 'decision', label: 'Sweep Owns This Row?',\n            },\n            {\n              // Accumulators live in the flow-wide variable map (a loop body\n              // shares the enclosing scope), so they MUST be zeroed per owner\n              // or every rep inherits the previous rep's totals.\n              id: 'reset_totals', type: 'assignment', label: 'Reset Totals',\n              config: {\n                assignments: {\n                  pipelineTotal: 0,\n                  bestCaseTotal: 0,\n                  commitTotal: 0,\n                  closedTotal: 0,\n                },\n              },\n            },\n            ...BUCKETS.flatMap((b) => [b.find, b.sum]),\n            {\n              // Filter by id: `update_record` calls `data.update` without\n              // `options.multi`, so a filter matching more than one row fails\n              // (same constraint as demo_bootstrap / case_sla_monitor).\n              id: 'write_snapshot', type: 'update_record', label: 'Write Snapshot',\n              config: {\n                objectName: 'crm_forecast',\n                filter: { id: cel`currentForecast.id` },\n                fields: {\n                  pipeline_amount: cel`pipelineTotal`,\n                  best_case_amount: cel`bestCaseTotal`,\n                  commit_amount: cel`commitTotal`,\n                  closed_amount: cel`closedTotal`,\n                  snapshot_date: cel`isoDate(today())`,\n                  source: 'scheduled',\n                },\n              },\n            },\n          ],\n          edges: [\n            // Loop-nested conditions are explicit CEL envelopes (`P`): the\n            // conversion pass that wraps bare strings only walks a flow's\n            // TOP-LEVEL edges, so a bare string in here would fall through to\n            // the legacy template path and compare as text \u2014 a gate that never\n            // opens, silently.\n            //\n            // These edges are the ONLY site for their predicates: a\n            // `decision` node's singular `config.condition` is never read, so a\n            // node-level copy would be inert metadata free to drift.\n            { id: 'b1', source: 'find_any_deal', target: 'has_deals', type: 'default' },\n            // No matching edge simply ends this iteration, so a user with no\n            // live deal is skipped without a snapshot row.\n            { id: 'b2', source: 'has_deals', target: 'find_forecast', type: 'conditional', condition: P`ownerAnyDeal != null`, label: 'Active owner' },\n            { id: 'b3', source: 'find_forecast', target: 'check_missing', type: 'default' },\n            // Mutually exclusive, and both reach `reload_forecast` \u2014 never a\n            // default edge alongside a conditional one, which would traverse\n            // BOTH and double-count the whole chain.\n            { id: 'b4', source: 'check_missing', target: 'create_forecast', type: 'conditional', condition: P`existingForecast == null`, label: 'Open new row' },\n            { id: 'b5', source: 'check_missing', target: 'reload_forecast', type: 'conditional', condition: P`existingForecast != null`, label: 'Refresh existing row' },\n            { id: 'b6', source: 'create_forecast', target: 'reload_forecast', type: 'default' },\n            { id: 'b7', source: 'reload_forecast', target: 'check_owned', type: 'default' },\n            // The stand-down. No complementary edge, on purpose: the\n            // false branch is \"this window belongs to a manual/ai row\", and the\n            // whole point is that the sweep then does NOTHING \u2014 no write, and\n            // no second row. A variable-root null test, so no `has()` guard is\n            // needed: `reload_forecast` is a `get_record` and binds\n            // `currentForecast` unconditionally, to `null` on a miss.\n            { id: 'b8', source: 'check_owned', target: 'reset_totals', type: 'conditional', condition: P`currentForecast != null`, label: 'Sweep owns the row' },\n            ...OWNER_CHAIN.slice(0, -1).map((source, i) => ({\n              id: `c${i}`,\n              source,\n              target: OWNER_CHAIN[i + 1],\n              type: 'default' as const,\n            })),\n          ],\n        }),\n      },\n    },\n    { id: 'end', type: 'end', label: 'End' },\n  ],\n\n  edges: [\n    { id: 'e1', source: 'start', target: 'query_owners', type: 'default' },\n    { id: 'e2', source: 'query_owners', target: 'loop_owners', type: 'default' },\n    { id: 'e3', source: 'loop_owners', target: 'end', type: 'default' },\n  ],\n};\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/sales/flows/lead-assignment.flow.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/sales/flows\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/sales/flows/lead-assignment.flow.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport { P, cel } from '@objectstack/spec';\nimport type * as Automation from '@objectstack/spec/automation';\ntype Flow = Automation.Flow;\n\n/**\n * Lead Assignment & Routing \u2014 react the instant a new lead lands.\n *\n * Fires on lead *insert*, sets a rating-based `next_followup_date` SLA, and\n * alerts the lead's OWNER \u2014 the accountable party \u2014 to follow up.\n *\n * \u26D4 Never address a CRM position (`sales_manager` and friends) as a recipient.\n * Positions are not a messaging audience: the messaging service resolves\n * `user:` / `role:` (sys_member) / `team:` / `owner_of:`, and a bare position\n * name is stored verbatim as `sys_inbox_message.user_id`, matching no real user,\n * so the alert reaches nobody. With no territory / round-robin table modelled,\n * the owner is the correct recipient. (Swap to a `team:`/`role:` audience once a\n * manager group is seeded.)\n *\n * Trigger wiring: the `start` node declares `triggerType: 'record-after-create'`\n * so the record-change trigger provider binds it to the ObjectQL `afterInsert`\n * lifecycle hook. Firing on insert only means the SLA write does not re-trigger\n * the flow. The full record is seeded into the run, so fields are read via\n * `record.*` (no get_record round-trip needed).\n */\nexport const LeadAssignmentFlow: Flow = {\n  name: 'lead_assignment',\n  label: 'New Lead Routing & SLA',\n  description: 'On new lead: set a rating-based follow-up SLA and alert the lead owner.',\n  type: 'record_change',\n  status: 'active',\n  // A record-change flow fired by a SYSTEM write carries no trigger user\n  // either (ADR-0049). This is the population the flow is FOR:\n  // leads arrive from web-to-lead, a CSV import, a partner integration or a\n  // seed load, none of which carry a user session. Measured on 17.0.0-rc.2, a\n  // user-less run refuses `sla_hot` / `sla_std` outright, so the lead lands\n  // with no follow-up SLA and no alert at all \u2014 silently, since the refusal\n  // surfaces only in the server log.\n  //\n  // Elevating the USER-driven runs too is correct: the SLA stamp is the\n  // platform's routing decision about the row that just fired the trigger\n  // (keyed to `{record.id}`), not the submitting rep's own edit, and a rep who\n  // may create a lead is not thereby guaranteed edit rights on it.\n  runAs: 'system',\n\n  variables: [],\n\n  nodes: [\n    {\n      id: 'start', type: 'start', label: 'Start (lead created)',\n      config: { objectName: 'crm_lead', triggerType: 'record-after-create' },\n    },\n    {\n      // Branching lives on edges `e2` / `e3` \u2014 see the totality note there.\n      // This node carries no `config.condition`: the engine never evaluates a\n      // `decision` node's singular one, so a copy here would restate the gate\n      // without being the gate (17.0.0-rc.2's `flow-inert-node-condition`).\n      id: 'check_hot', type: 'decision', label: 'Hot Lead (rating \u2265 4)?',\n    },\n\n    // \u2500\u2500 Hot path: 1-day SLA, high-severity alert \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n    {\n      id: 'sla_hot', type: 'update_record', label: 'Set 1-Day SLA',\n      config: { objectName: 'crm_lead', filter: { id: cel`record.id` }, fields: { next_followup_date: cel`isoDate(daysFromNow(1))` } },\n    },\n    {\n      id: 'notify_hot', type: 'notify', label: 'Alert \u2014 Hot Lead',\n      config: {\n        // Route to the lead's OWNER (a real user id). A CRM position like\n        // 'sales_manager' is NOT a messaging audience \u2014 the messaging service\n        // resolves user:/role:(sys_member)/team:/owner_of:, and a bare\n        // 'sales_manager' was stored verbatim as sys_inbox_message.user_id,\n        // matching no real user, so these alerts reached nobody. owner is set\n        // on insert (defaultValue os.user.id) and is the accountable party.\n        recipients: [cel`record.owner_id`],\n        channels: ['inbox', 'email'],\n        severity: 'warning',\n        topic: 'lead_routing',\n        template: 'crm.lead_routing_hot',\n        templateData: {\n          first_name: cel`record.first_name`, last_name: cel`record.last_name`,\n          company: cel`record.company`, rating: cel`record.rating`,\n        },\n        actionUrl: '/crm_lead/{{record.id}}',\n      },\n    },\n\n    // \u2500\u2500 Standard path: 3-day SLA, normal alert \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n    {\n      id: 'sla_std', type: 'update_record', label: 'Set 3-Day SLA',\n      config: { objectName: 'crm_lead', filter: { id: cel`record.id` }, fields: { next_followup_date: cel`isoDate(daysFromNow(3))` } },\n    },\n    {\n      id: 'notify_std', type: 'notify', label: 'Alert \u2014 New Lead',\n      config: {\n        // Route to the lead's owner \u2014 see notify_hot for why a bare\n        // 'sales_manager' position never reached anyone.\n        recipients: [cel`record.owner_id`],\n        channels: ['inbox'],\n        topic: 'lead_routing',\n        template: 'crm.lead_routing_new',\n        templateData: {\n          first_name: cel`record.first_name`, last_name: cel`record.last_name`, company: cel`record.company`,\n        },\n        actionUrl: '/crm_lead/{{record.id}}',\n      },\n    },\n\n    { id: 'end', type: 'end', label: 'End' },\n  ],\n\n  edges: [\n    { id: 'e1', source: 'start', target: 'check_hot', type: 'default' },\n    // TOTALITY: these two edges must PARTITION every lead \u2014 a rating\n    // the predicate cannot read has to fall down one branch, never neither.\n    // Guarding both with `has(...) &&` would have traded a loud abort for a\n    // silent no-op (unrated lead \u2192 no SLA, no alert, no error), which is the\n    // \"declared \u2260 enforced\" shape this repo keeps deleting rules over. So the\n    // hot branch demands a readable rating and the standard branch absorbs\n    // everything else: an unrated lead is, correctly, not a hot lead.\n    //\n    // `rating` is neither required nor defaulted, so a lead written without one\n    // is stored with NO `rating` column on driver-memory / driver-mongodb.\n    // Measured end-to-end: the unguarded `record.rating >= 4` aborted with `No\n    // such key: rating` and an unrated lead got no SLA stamp and no alert at\n    // all. `has()` alone is not enough on an ORDERING comparison \u2014 an explicit\n    // `rating: null` passes `has()` and then aborts with `no such overload:\n    // dyn<null> >= int` \u2014 so both guards are required, in this order.\n    { id: 'e2', source: 'check_hot', target: 'sla_hot', type: 'conditional', condition: P`has(record.rating) && record.rating != null && record.rating >= 4`, label: 'Hot' },\n    { id: 'e3', source: 'check_hot', target: 'sla_std', type: 'conditional', condition: P`!has(record.rating) || record.rating == null || record.rating < 4`, label: 'Standard' },\n    { id: 'e4', source: 'sla_hot', target: 'notify_hot', type: 'default' },\n    { id: 'e5', source: 'notify_hot', target: 'end', type: 'default' },\n    { id: 'e6', source: 'sla_std', target: 'notify_std', type: 'default' },\n    { id: 'e7', source: 'notify_std', target: 'end', type: 'default' },\n  ],\n};\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/sales/flows/contact-welcome.flow.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/sales/flows\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/sales/flows/contact-welcome.flow.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport { P, cel } from '@objectstack/spec';\nimport type * as Automation from '@objectstack/spec/automation';\ntype Flow = Automation.Flow;\n\n/**\n * New-contact alert \u2014 record-change flow on contact insert.\n *\n * \u26D4 Notifies the OWNER, never the contact. `notify` addresses platform users \u2014\n * a raw email address is stored verbatim as an inbox `user_id` and reaches\n * nobody. A true outbound welcome email to the contact needs an email connector\n * action, not an inbox notification.\n *\n * Gated on `email_opt_out != true` so an opted-out contact triggers no outreach\n * prompt, and skipped entirely when there is no owner to notify.\n */\nexport const ContactWelcomeFlow: Flow = {\n  name: 'contact_welcome',\n  label: 'Contact Welcome',\n  description: 'On new contact: prompt the owner to welcome them.',\n  type: 'record_change',\n  status: 'active',\n  // A record-change flow fired by a SYSTEM write carries no trigger user\n  // either (ADR-0049) \u2014 and this flow exists FOR that\n  // population: the start condition below already documents the seeded /\n  // integration-written contacts whose `owner_id` the security middleware\n  // never stamped because the write carried no session.\n  //\n  // Measured honestly on 17.0.0-rc.2: this flow has NO data node today (start\n  // \u2192 notify \u2192 end), the runAs refusal covers get/create/update/delete only,\n  // and `notify` dispatches through the messaging service without a run data\n  // context \u2014 so a user-less run completes and delivers today, and this\n  // declaration changes nothing observable right now. It is declared anyway\n  // because the decision being recorded is \"record-change automation runs as\n  // the platform\", not \"this flow currently happens to have no data node\".\n  // The day a data node is added \u2014 or a start-node `config.expand`, which is\n  // the remedy the notify node's own error message recommends and which reads\n  // through the same guarded path \u2014 the elevation has already been reasoned\n  // about here rather than discovered as a refusal in production. Elevation is\n  // harmless for the user-driven runs: there is no data operation to scope.\n  runAs: 'system',\n  variables: [],\n  nodes: [\n    {\n      id: 'start', type: 'start', label: 'Start (contact created)',\n      config: {\n        objectName: 'crm_contact',\n        triggerType: 'record-after-create',\n        // TOTALITY: every `record.x` read carries a `has(record.x)`\n        // guard \u2014 see the house-rule block in\n        // `test/flow-condition-totality.test.ts`. The absent-key case is real\n        // here, not hypothetical: `owner_id` is auto-stamped by the security\n        // middleware only on writes that CARRY a user, and a system write \u2014\n        // seed data, an integration, a `runAs: 'system'` flow \u2014 short-circuits\n        // that middleware entirely. Such a row reaches driver-memory\n        // with NO `owner_id` column at all, so `record.owner_id != null` alone\n        // aborts with `No such key` and no seeded contact ever gets a welcome\n        // prompt. `!= null` is not a substitute for `has()`: on an absent key\n        // it aborts exactly like `== \"v\"` does. An absent `email_opt_out`\n        // means the contact has not opted out.\n        condition: P`has(record.owner_id) && record.owner_id != null\n          && (!has(record.email_opt_out) || record.email_opt_out != true)`,\n      },\n    },\n    {\n      id: 'send_welcome', type: 'notify', label: 'Prompt Owner to Welcome',\n      config: {\n        recipients: [cel`record.owner_id`],\n        channels: ['inbox', 'email'],\n        topic: 'contact_welcome',\n        template: 'crm.contact_welcome',\n        templateData: { first_name: cel`record.first_name`, last_name: cel`record.last_name` },\n        actionUrl: '/crm_contact/{{record.id}}',\n      },\n    },\n    { id: 'end', type: 'end', label: 'End' },\n  ],\n  edges: [\n    { id: 'e1', source: 'start', target: 'send_welcome', type: 'default' },\n    { id: 'e2', source: 'send_welcome', target: 'end', type: 'default' },\n  ],\n};\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/sales/flows/opportunity-won-alert.flow.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/sales/flows\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/sales/flows/opportunity-won-alert.flow.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport { P, cel } from '@objectstack/spec';\nimport type * as Automation from '@objectstack/spec/automation';\nimport { LARGE_DEAL_AMOUNT } from '../objects/_thresholds';\ntype Flow = Automation.Flow;\n\n/**\n * Large-deal-won alert \u2014 record-change flow on opportunity update.\n *\n * When a deal of $100K or more is marked closed_won, notify the owner \u2014 the\n * owner alone, not their manager (see the notify node for why the manager\n * cannot be reached).\n *\n * The cut is INCLUSIVE (`>=`): `LARGE_DEAL_AMOUNT` must mean one thing across\n * this alert, the approval entry gate and both sharing rules, so a deal at\n * exactly $100,000 is announced on win for the same reason it is shared with\n * leadership. \u26D4 Never let this site and the sharing rules cut differently \u2014 a\n * deal on the line then becomes visible to leadership and invisible to\n * governance.\n *\n * NB: `record.amount >= 100000` is authored as bare CEL against the\n * (string-serialized) currency field, which relies on the 7.7 numeric-hydration\n * fix; pre-7.7 it would have needed `double(record.amount)`.\n */\nexport const OpportunityWonAlertFlow: Flow = {\n  name: 'opportunity_won_alert',\n  label: 'Large Deal Won Alert',\n  description: 'On closed_won opportunities of $100K or more: notify the owner \u2014 the owner alone, not their manager.',\n  type: 'record_change',\n  status: 'active',\n  // A record-change flow fired by a SYSTEM write carries no trigger user\n  // either (ADR-0049). Deals reach `closed_won` through\n  // machinery as well as through a rep's own save \u2014 `lead_conversion` and the\n  // `contract_renewal` sweep both write opportunities, and the latter is\n  // itself `runAs: 'system'`.\n  //\n  // Measured honestly on 17.0.0-rc.2: this flow has NO data node (start \u2192\n  // notify \u2192 end), so the refusal does not reach it today and declaring\n  // `system` changes nothing observable. Declared for the same reason as\n  // `contact_welcome` \u2014 see the fuller note there. Nothing to scope, so\n  // elevating the user-driven runs costs nothing.\n  runAs: 'system',\n  variables: [],\n  nodes: [\n    {\n      id: 'start', type: 'start', label: 'Start (opp updated)',\n      config: {\n        objectName: 'crm_opportunity',\n        triggerType: 'record-after-update',\n        // `previous.stage` guard: fire on the TRANSITION into closed_won only.\n        // Without it every later edit of a won deal (seed-ownership\n        // claims, approval-status stamps, description tweaks) re-sent the\n        // congratulations blast. The trigger forwards `previous` into the\n        // condition scope (cf. the engine's record-change context).\n        // TOTALITY: `has(...)` on every read, plus `!= null` on the\n        // ordering comparison (`has()` passes an explicit null and\n        // `record.amount >= 100000` then aborts with\n        // `no such overload: dyn<null> >= int`).\n        //\n        // `previous.stage` is guarded FAIL-CLOSED \u2014 `has(previous.stage) &&`,\n        // not `!has(previous.stage) ||` \u2014 which is the opposite of how\n        // `record.stage` is guarded, deliberately. This term exists solely to\n        // suppress a re-fire, and the failure it was written for (a\n        // congratulations blast to management re-sent on every later edit of a\n        // won deal) is worse than a missed one. When the engine cannot see\n        // what the prior stage was it cannot see a TRANSITION either, so it\n        // must not claim one. In practice `previous` is a full prior row on\n        // every record-after-update; the shape this covers is a bulk\n        // `updateMany`, where ObjectQL never reads a prior row and `previous`\n        // arrives null \u2014 and firing one blast per row of a bulk update is\n        // exactly what nobody wants.\n        condition: P`has(record.stage) && record.stage == \"closed_won\"\n          && has(previous.stage) && previous.stage != \"closed_won\"\n          && has(record.amount) && record.amount != null && record.amount >= ${LARGE_DEAL_AMOUNT}`,\n      },\n    },\n    {\n      // The `label` names what this node actually does: it notifies the owner\n      // and nobody else. The `id` keeps its original `notify_management`\n      // spelling on purpose \u2014 `edges[]` reference nodes by id, so renaming one\n      // is a behaviour change, not a wording fix.\n      id: 'notify_management', type: 'notify', label: 'Notify Owner',\n      config: {\n        // Owner only: `{record.owner_id.manager}` cannot traverse a lookup on the\n        // raw trigger snapshot \u2014 it interpolates to the literal \"undefined\"\n        // and the message is delivered to a phantom user.\n        recipients: [cel`record.owner_id`],\n        channels: ['inbox', 'email'],\n        severity: 'info',\n        topic: 'large_deal_won',\n        template: 'crm.large_deal_won',\n        templateData: { name: cel`record.name`, amount: cel`record.amount` },\n        actionUrl: '/crm_opportunity/{{record.id}}',\n      },\n    },\n    { id: 'end', type: 'end', label: 'End' },\n  ],\n  edges: [\n    { id: 'e1', source: 'start', target: 'notify_management', type: 'default' },\n    { id: 'e2', source: 'notify_management', target: 'end', type: 'default' },\n  ],\n};\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/sales/flows/task-urgent-alert.flow.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/sales/flows\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/sales/flows/task-urgent-alert.flow.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport { P, cel } from '@objectstack/spec';\nimport type * as Automation from '@objectstack/spec/automation';\ntype Flow = Automation.Flow;\n\n/**\n * Urgent task alert \u2014 record-change flow on task insert.\n *\n * When an urgent, not-yet-completed task is created, notify its owner.\n */\nexport const TaskUrgentAlertFlow: Flow = {\n  name: 'task_urgent_alert',\n  label: 'Urgent Task Alert',\n  description: 'On new urgent task: notify the owner.',\n  type: 'record_change',\n  status: 'active',\n  // A record-change flow fired by a SYSTEM write carries no trigger user\n  // either (ADR-0049), and most urgent tasks in this app are\n  // machine-written: `case_status_side_effects` opens the escalation follow-up\n  // task, and the scheduled sweeps create their own \u2014 none of those writes\n  // carries a session.\n  //\n  // Measured honestly on 17.0.0-rc.2: this flow has NO data node (start \u2192\n  // notify \u2192 end), so the refusal does not reach it today and declaring\n  // `system` changes nothing observable. Declared for the same reason as\n  // `contact_welcome` \u2014 see the fuller note there: the recorded decision is\n  // that record-change automation runs as the platform, so a data node added\n  // later inherits an elevation that was reasoned about rather than one\n  // discovered as a production refusal. No data operation exists to scope, so\n  // elevating the user-driven runs costs nothing.\n  runAs: 'system',\n  variables: [],\n  nodes: [\n    {\n      id: 'start', type: 'start', label: 'Start (task created)',\n      config: {\n        objectName: 'crm_task',\n        triggerType: 'record-after-create',\n        // Gate on the `status` enum, not the `is_completed` boolean: on\n        // SQLite/libsql booleans persist as integer 1, so `is_completed != true`\n        // is `1 != true` = always true and the guard never trips (cf. the same\n        // hazard documented in case_escalation).\n        // TOTALITY: `has(...)` on every read. Both fields are `required`\n        // AND defaulted today, so this predicate measured total as authored \u2014\n        // but that is a property of `crm_task`'s schema, not of the predicate.\n        // Drop either default and the flow goes silently inert on\n        // driver-memory / driver-mongodb, with nothing to catch it. An absent\n        // `status` is not `completed`, so it must not suppress the alert.\n        condition: P`has(record.priority) && record.priority == \"urgent\"\n          && (!has(record.status) || record.status != \"completed\")`,\n      },\n    },\n    {\n      id: 'notify_owner', type: 'notify', label: 'Notify Owner',\n      config: {\n        recipients: [cel`record.owner_id`],\n        channels: ['inbox', 'email'],\n        severity: 'warning',\n        topic: 'urgent_task',\n        template: 'crm.urgent_task',\n        templateData: { subject: cel`record.subject` },\n        actionUrl: '/crm_task/{{record.id}}',\n      },\n    },\n    { id: 'end', type: 'end', label: 'End' },\n  ],\n  edges: [\n    { id: 'e1', source: 'start', target: 'notify_owner', type: 'default' },\n    { id: 'e2', source: 'notify_owner', target: 'end', type: 'default' },\n  ],\n};\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/sales/flows/task-due-reminder.flow.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/sales/flows\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/sales/flows/task-due-reminder.flow.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport { cel } from '@objectstack/spec';\nimport type * as Automation from '@objectstack/spec/automation';\nimport { guarded } from './_guarded-iteration';\ntype Flow = Automation.Flow;\n\n/**\n * Task Due Reminder \u2014 scheduled time-based reminders.\n *\n * The task schema carries `reminder_date` (and `due_date`), and the calendar /\n * gantt views *display* them; this flow is what watches the clock. It sweeps\n * tasks whose `reminder_date` has arrived (and that are still open and not yet\n * reminded), notifies the owner on the inbox + email channels, and stamps\n * `reminder_sent` so the same task is never alerted twice.\n *\n * Mirrors `case_sla_monitor` (scheduled trigger + get_record + loop + notify +\n * update_record), which is the established pattern for time-based sweeps here.\n *\n */\nexport const TaskDueReminderFlow: Flow = {\n  name: 'task_due_reminder',\n  label: 'Task Due Reminder',\n  description: 'Hourly sweep: notify owners of tasks whose reminder time has arrived.',\n  type: 'schedule',\n  status: 'active',\n  // Scheduled runs have no trigger user, so under the default runAs:'user' the\n  // data nodes execute UNSCOPED anyway. Declare runAs:'system' to make that\n  // RLS-bypassing elevation explicit and intended (ADR-0049).\n  runAs: 'system',\n\n  variables: [],\n\n  nodes: [\n    {\n      id: 'start', type: 'start', label: 'Start (hourly)',\n      config: { schedule: '0 * * * *' },\n    },\n    {\n      id: 'query_due', type: 'get_record', label: 'Find Tasks Due for Reminder',\n      config: {\n        objectName: 'crm_task',\n        // De-dup via `reminder_date` itself: the sweep notifies tasks whose\n        // reminder time has arrived, then CLEARS reminder_date (see mark_sent),\n        // so the row no longer matches `$lte` next tick. We do NOT filter on the\n        // `reminder_sent` boolean here \u2014 empirically, a where-clause on that\n        // (newly added) boolean column returns zero rows at runtime in this\n        // engine build, while the long-standing `is_completed` boolean works.\n        // Reusing the verified `$lte` + `is_completed` predicates keeps the\n        // sweep reliable; `reminder_sent` is still stamped for the audit trail.\n        filter: {\n          is_completed: false,\n          reminder_date: { $lte: cel`isoDatetime(now())` },\n        },\n        limit: 500,\n        outputVariable: 'reminderList',\n      },\n    },\n    {\n      // The loop body MUST be nested in `config.body` \u2014 a flat-graph loop\n      // (body omitted, iterator wired via outer edges) does NOT iterate or bind\n      // the iterator variable in the runtime (legacy no-op path), so\n      // `{currentTask.*}` resolves empty. Verified empirically.\n      id: 'loop_tasks', type: 'loop', label: 'For Each Due Task',\n      config: {\n        collection: cel`reminderList`,\n        iteratorVariable: 'currentTask',\n        body: guarded('task', {\n          nodes: [\n            {\n              id: 'notify_owner', type: 'notify', label: 'Notify Owner',\n              config: {\n                recipients: [cel`has(currentTask.owner_id) ? currentTask.owner_id : null`],\n                channels: ['inbox', 'email'],\n                severity: 'warning',\n                topic: 'task_reminder',\n                template: 'crm.task_reminder',\n                templateData: {\n                  subject: cel`currentTask.subject`, reminder_date: cel`currentTask.reminder_date`,\n                },\n                actionUrl: '/crm_task/{{currentTask.id}}',\n              },\n            },\n            {\n              id: 'mark_sent', type: 'update_record', label: 'Mark Reminder Sent',\n              config: {\n                objectName: 'crm_task',\n                filter: { id: cel`currentTask.id` },\n                // Clearing reminder_date is what de-dups (the row stops matching\n                // the sweep's `$lte` next tick); reminder_sent is the audit flag.\n                fields: { reminder_sent: true, reminder_date: null },\n              },\n            },\n          ],\n          edges: [\n            { id: 'b1', source: 'notify_owner', target: 'mark_sent', type: 'default' },\n          ],\n        }),\n      },\n    },\n    { id: 'end', type: 'end', label: 'End' },\n  ],\n\n  edges: [\n    { id: 'e1', source: 'start', target: 'query_due', type: 'default' },\n    { id: 'e2', source: 'query_due', target: 'loop_tasks', type: 'default' },\n    { id: 'e3', source: 'loop_tasks', target: 'end', type: 'default' },\n  ],\n};\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/sales/flows/billing-handoff-closed-won.flow.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/sales/flows\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/sales/flows/billing-handoff-closed-won.flow.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport { P, cel } from '@objectstack/spec';\nimport type * as Automation from '@objectstack/spec/automation';\ntype Flow = Automation.Flow;\n\nimport {\n  BILLING_HANDOFF_ENDPOINT,\n  BILLING_HANDOFF_EVENT,\n  BILLING_HANDOFF_LINE_ITEM_LIMIT,\n  BILLING_HANDOFF_SIGNING_SECRET,\n  BILLING_HANDOFF_TIMEOUT_MS,\n  LINE_ITEM_FIELDS,\n  billingBody,\n  loadAccountNode,\n} from './_billing-endpoint';\n\n/**\n * \u2550\u2550\u2550 Billing hand-off \u2014 where HotCRM's revenue scope ends \u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\n *\n * HotCRM owns lead \u2192 contract. It does **not** model Orders, Invoices or\n * Payments (maintainer decision, 2026-08-02): billing is an external system's\n * job. What the CRM owes that system is a reliable hand-off, and these two\n * flows are it:\n *\n *   - `billing_handoff_closed_won`          \u2014 an opportunity ENTERS `closed_won`\n *     (this file; `crm_opportunity` is the sales package's object)\n *   - `billing_handoff_contract_activated`  \u2014 a contract ENTERS `activated`\n *     (`src/revenue/flows/billing-handoff-contract-activated.flow.ts`)\n *\n * Each POSTs one JSON document \u2014 the record, its account, and its line items \u2014\n * to {@link BILLING_HANDOFF_ENDPOINT}, through the platform's **durable HTTP\n * outbox**: the `http` node with `durable: true` calls\n * `messaging.enqueueHttp({ source: 'flow', \u2026 })`, which persists a\n * `sys_http_delivery` row that the HTTP dispatcher drains with retry, backoff\n * and dead-lettering, signing the body with HMAC-SHA256 when a secret is set.\n * Nothing here is custom plumbing; it is the platform's own outbound-callout\n * verb, on the same outbox the declarative `webhooks` surface uses.\n *\n * ## \u26D4 Do not re-express these as declared `webhooks`\n *\n * Measured on 17.0.0-rc.6, that surface cannot express either event:\n * `WebhookSchema` is `.strict` and rejects `condition` / `filter` / `body` /\n * `payloadFields` / `retryPolicy`; its `triggers` vocabulary is\n * `create / update / delete / bulk_*` with no transition form; and the\n * auto-enqueuer matches on object + trigger alone and delivers a fixed\n * `DataEvent` envelope carrying neither the account nor the line items. A\n * `sys_webhook` row named for closed-won would fire on *every* opportunity edit\n * \u2014 a declaration that lies about itself, in the app other people copy.\n * Dispatch there is additionally gated on the `realtime` capability, which this\n * app does not require, so such a row would be visible in Setup and never fire\n * at all.\n *\n * The cost of this route is stated in `_billing-endpoint.ts` and in\n * `content/docs/revenue/billing-handoff.mdx`: the endpoint and secret live in\n * flow metadata, so repointing them is a rebuild, not a Setup edit.\n *\n * ## Exactly once per transition, not once per edit\n *\n * \u26D4 Both start conditions must test the TRANSITION\n * (`record.x == v && previous.x != v`), never the current value. This is the\n * idiom `opportunity_won_alert` uses on this very object: without the\n * `previous.*` term, every later edit of a won deal \u2014 a seed-ownership\n * claim, an approval stamp, a description tweak \u2014 re-fires the flow. For a\n * congratulations notification that is noise; for a billing hand-off it is a\n * duplicate order. `previous.*` is guarded FAIL-CLOSED (`has(previous.x) &&`)\n * for the same reason it is there: when the engine cannot see the prior value\n * it cannot see a transition either, and must not claim one. The shape that\n * covers is a bulk `updateMany`, where ObjectQL reads no prior row and\n * `previous` arrives null \u2014 one hand-off per row of a bulk update is exactly\n * what nobody wants.\n *\n * Delivery itself is **at-least-once**: the outbox retries a failed attempt,\n * and every attempt of one enqueued row carries the same `X-Objectstack-Delivery`\n * id. Receivers dedupe on that header.\n *\n * ## Totality\n *\n * Every `record.*` / `previous.*` read below carries a `has(...)` guard \u2014 the\n * house rule `test/flow-condition-totality.test.ts` enforces, because a flow\n * condition that aborts fails the whole run rather than yielding `false`.\n */\n\n/**\n * \u2500\u2500 Event 1: opportunity enters `closed_won` \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n */\nexport const BillingHandoffClosedWonFlow: Flow = {\n  name: 'billing_handoff_closed_won',\n  label: 'Billing Hand-off: Closed Won',\n  description:\n    'On the transition into closed_won: POST the deal, its account and its line items to the billing endpoint via the durable HTTP outbox.',\n  type: 'record_change',\n  status: 'active',\n  // A record-change flow fired by a SYSTEM write carries no trigger user\n  // (ADR-0049), and opportunities reach `closed_won` through\n  // machinery as well as a rep's own save \u2014 `lead_conversion` writes them, and\n  // the `contract_renewal` sweep is itself `runAs: 'system'`. This flow has two\n  // data nodes, so under the default `runAs: 'user'` those reads would be\n  // REFUSED on exactly those runs and the hand-off would vanish silently. The\n  // hand-off must also see the WHOLE deal, not the slice the closing rep may\n  // read: an RLS-scoped line-item query that returns three of five rows would\n  // under-bill the customer without failing anything.\n  runAs: 'system',\n  variables: [\n    // Bound with a default so the payload key always exists. Not strictly\n    // needed here (this flow always runs the read) \u2014 declared for symmetry with\n    // the contract flow, where the read is conditional, so the two payloads\n    // cannot drift into different shapes for an empty item list.\n    { name: 'billingLineItems', type: 'collection', isInput: false, isOutput: false, defaultValue: [] },\n  ],\n  nodes: [\n    {\n      id: 'start',\n      type: 'start',\n      label: 'Start (opportunity updated)',\n      config: {\n        objectName: 'crm_opportunity',\n        triggerType: 'record-after-update',\n        // TRANSITION, not current value \u2014 see the file header. `previous.stage`\n        // is guarded fail-closed: no visible prior stage means no visible\n        // transition, so no hand-off.\n        condition: P`has(record.stage) && record.stage == \"closed_won\"\n          && has(previous.stage) && previous.stage != \"closed_won\"`,\n      },\n    },\n    loadAccountNode(),\n    {\n      id: 'load_line_items',\n      type: 'get_record',\n      label: 'Load Line Items',\n      config: {\n        objectName: 'crm_opportunity_line_item',\n        filter: { crm_opportunity: cel`record.id` },\n        fields: LINE_ITEM_FIELDS,\n        // > 1 is what makes `get_record` issue a `find` and bind an ARRAY;\n        // omit it and the node calls `findOne` and binds a single row.\n        limit: BILLING_HANDOFF_LINE_ITEM_LIMIT,\n        outputVariable: 'billingLineItems',\n      },\n    },\n    {\n      // The node id becomes the delivery's `X-Objectstack-Event` header\n      // (`flow:<nodeId>`), so it is named for the event and not for the verb.\n      id: 'send_closed_won_handoff',\n      type: 'http',\n      label: 'Enqueue Billing Hand-off',\n      config: {\n        url: BILLING_HANDOFF_ENDPOINT,\n        method: 'POST',\n        // The whole point of this route: enqueue on `sys_http_delivery` rather\n        // than call inline, so a receiver that is down gets the delivery when\n        // it comes back instead of losing it.\n        durable: true,\n        timeoutMs: BILLING_HANDOFF_TIMEOUT_MS,\n        signingSecret: BILLING_HANDOFF_SIGNING_SECRET,\n        // One envelope building the whole payload (see `billingBody`). Each\n        // read is the value itself, never its stringification, so the amount\n        // stays a number and the line items an array.\n        body: billingBody(BILLING_HANDOFF_EVENT.opportunityClosedWon, 'opportunity', [\n          'id', 'name', 'amount', 'close_date', 'stage', 'type', ['account_id', 'crm_account'], 'owner_id',\n        ]),\n      },\n    },\n    { id: 'end', type: 'end', label: 'End' },\n  ],\n  edges: [\n    { id: 'e1', source: 'start', target: 'load_account', type: 'default' },\n    { id: 'e2', source: 'load_account', target: 'load_line_items', type: 'default' },\n    { id: 'e3', source: 'load_line_items', target: 'send_closed_won_handoff', type: 'default' },\n    { id: 'e4', source: 'send_closed_won_handoff', target: 'end', type: 'default' },\n  ],\n};\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/sales/flows/_billing-endpoint.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/sales/flows\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/sales/flows/_billing-endpoint.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport { cel, expression } from '@objectstack/spec';\nimport type * as Automation from '@objectstack/spec/automation';\n\n/**\n * Billing hand-off contract \u2014 the ONE place the outbound target and the shape\n * of what is sent to it live.\n *\n * HotCRM's revenue scope ends at the signed contract (maintainer decision,\n * 2026-08-02): no Order / Invoice / Payment objects are modelled here. What the\n * CRM owes the billing system is a **reliable hand-off** \u2014 two outbound events,\n * delivered on the platform's durable HTTP outbox.\n *\n * ## Where the endpoint lives, and why that is a code change\n *\n * These constants are read at **build time** by the two `http` nodes in\n * `billing-handoff.flow.ts`, and `objectstack build` bakes their values into the\n * compiled artifact's flow metadata. There is no Setup screen for them.\n *\n * That is a real cost of the mechanism, stated rather than buried: the\n * admin-editable `webhooks` surface cannot express either of these events, so\n * the trade is exact events with a shaped payload at the price of repointing\n * being a rebuild. The measurements behind that are in\n * `billing-handoff.flow.ts`; `content/docs/revenue/billing-handoff.mdx`\n * documents the cost plainly instead of teaching a Setup screen that does not\n * apply.\n *\n * ## Overriding without editing this file\n *\n * Both values are read from the environment first, so a deployment can set them\n * in the build environment rather than patching source:\n *\n *   HOTCRM_BILLING_ENDPOINT=https://billing.acme.internal/hotcrm/events \\\n *   HOTCRM_BILLING_SIGNING_SECRET=\u2026 \\\n *   pnpm build\n *\n * The secret is deliberately NOT defaulted to a literal: a committed HMAC key\n * in a public reference app is worse than an unsigned delivery, and an unsigned\n * delivery is at least visible (no `X-Objectstack-Signature` header on the\n * request) rather than silently trusted.\n */\n\n/**\n * Where both hand-off events are POSTed.\n *\n * The default is the RFC 2606 example host, i.e. deliberately not a real\n * receiver: an untouched install enqueues the delivery, retries it on the\n * platform's backoff schedule, and lands it in `sys_http_delivery` as `dead`.\n * That is the honest default \u2014 the hand-off is wired and visibly waiting for an\n * endpoint, rather than quietly doing nothing.\n */\nexport const BILLING_HANDOFF_ENDPOINT =\n  process.env.HOTCRM_BILLING_ENDPOINT?.trim() || 'https://billing.example.com/hotcrm/events';\n\n/**\n * HMAC-SHA256 secret for the `X-Objectstack-Signature` header.\n *\n * `undefined` when unset \u2014 the messaging sender only signs when a secret is\n * present, and an empty string would read as \"signed\" to an author while\n * producing no header at all.\n */\nexport const BILLING_HANDOFF_SIGNING_SECRET: string | undefined =\n  process.env.HOTCRM_BILLING_SIGNING_SECRET?.trim() || undefined;\n\n/** Per-request timeout handed to the outbox sender (ms). */\nexport const BILLING_HANDOFF_TIMEOUT_MS = 30_000;\n\n/**\n * Event names carried in the payload's `event` field.\n *\n * The receiver routes on this, so the strings are part of the contract with the\n * billing system \u2014 changing one is a breaking change for the consumer, not a\n * rename.\n */\nexport const BILLING_HANDOFF_EVENT = {\n  opportunityClosedWon: 'crm.opportunity.closed_won',\n  contractActivated: 'crm.contract.activated',\n} as const;\n\n/** Payload contract version \u2014 bumped when the body shape changes shape. */\nexport const BILLING_HANDOFF_PAYLOAD_VERSION = 1;\n\n/** Line items read per hand-off. Deals in this app top out well below it. */\nexport const BILLING_HANDOFF_LINE_ITEM_LIMIT = 200;\n\n/*\n * \u2500\u2500\u2500 The payload halves both hand-off events share \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n *\n * These sat in `billing-handoff.flow.ts` while both flows lived in one file.\n * The ADR-0130 layout puts a flow with its trigger object, and the two events\n * trigger on objects in different packages \u2014 `crm_opportunity` is sales',\n * `crm_contract` is revenue's \u2014 so the flows are now\n * `src/sales/flows/billing-handoff-closed-won.flow.ts` and\n * `src/revenue/flows/billing-handoff-contract-activated.flow.ts`. The shared\n * half moved HERE rather than being copied into each: it is the same contract\n * with the same receiver, and two copies of a contract is how a receiver ends\n * up with two shapes. Revenue reads it along the revenue -> sales edge, the\n * one direction ADR-0130 allows.\n */\n\n/** Account fields the billing system needs to open a customer. */\nexport const ACCOUNT_FIELDS = [\n  'id',\n  'name',\n  'account_number',\n  'billing_address',\n  'billing_country',\n  'phone',\n  'website',\n];\n\n/** Line-item fields that price a hand-off. `total_price` is the formula total. */\nexport const LINE_ITEM_FIELDS = [\n  'id',\n  'line_number',\n  'crm_product',\n  'description',\n  'quantity',\n  'list_price',\n  'unit_price',\n  'discount',\n  'total_price',\n];\n\n/** An optional column of the account row, read as `null` where the row lacks it. */\nconst accountField = (field: string) => `has(billingAccount.${field}) ? billingAccount.${field} : null`;\n\n/**\n * The account block, shared by both payloads: a CEL map literal over the\n * `billingAccount` row {@link loadAccountNode} binds, spliced into each body by\n * {@link billingBody}.\n *\n * Authored field-by-field rather than passing the row whole: this object IS the\n * contract with the billing system, so it must not silently grow a column the\n * day someone adds a field to `crm_account`.\n *\n * `name` is required and `account_number` an autonumber, so both are read\n * bare. The other four are optional, and a sparse driver (memory, mongodb)\n * hands back a column the row was never written with ABSENT, which CEL refuses,\n * so each is guarded to `null`. The 17.x template dropped such a key from the\n * JSON instead; on the SQL drivers the column is always present and the two\n * agree.\n */\nexport const ACCOUNT_BLOCK =\n  `{'id': billingAccount.id, 'name': billingAccount.name, 'account_number': billingAccount.account_number, ` +\n  `'billing_address': ${accountField('billing_address')}, 'billing_country': ${accountField('billing_country')}, ` +\n  `'phone': ${accountField('phone')}, 'website': ${accountField('website')}}`;\n\n/**\n * The http `body` of both hand-offs: ONE CEL value envelope building the whole\n * payload. `key` names the record's own block, and `fields` lists what it\n * carries, read straight off the triggering `record`: a field under its own\n * name, or `[key, field]` where the payload names it differently. `record` is\n * the record-change trigger's, which hands the run every declared field (null\n * where unset), so these reads take no guard.\n *\n * Since 18.0.0-next.0 an http body is one value, evaluated once before the\n * call, so the durable outbox enqueues exactly what an inline call would send.\n * A `{\u2026}` token in a nested string is refused there, and an envelope nested in\n * a literal object would be sent as the object it spells \u2014 so the payload is\n * built by one envelope, not by a literal with envelopes inside it. CEL holds a\n * map's values to one type, so each literal and each nested map is wrapped in\n * `dyn()`. `billingLineItems` is a variable read and already dynamic.\n */\nexport const billingBody = (event: string, key: string, fields: (string | [string, string])[]) =>\n  expression(\n    `{'event': dyn('${event}'), 'version': dyn(${BILLING_HANDOFF_PAYLOAD_VERSION}), ` +\n      `'occurred_at': dyn(isoDatetime(now())), ` +\n      `'${key}': dyn({${fields.map((f) => (typeof f === 'string' ? [f, f] : f)).map(([k, f]) => `'${k}': record.${f}`).join(', ')}}), ` +\n      `'account': dyn(${ACCOUNT_BLOCK}), 'line_items': billingLineItems}`,\n  );\n\n/**\n * Read the account named by the triggering record.\n *\n * `crm_account` is `required` + `storage.notNull` on both `crm_opportunity` and\n * `crm_contract`, so the value is always there on a real row. Left UNGUARDED on\n * purpose: if it were ever absent, the envelope fails the run loudly in Studio's\n * Flow Runs page. For a required field that is the right failure \u2014 a silent skip\n * would drop a hand-off with no trace.\n */\nexport const loadAccountNode = (): Automation.FlowNode => ({\n  id: 'load_account',\n  type: 'get_record',\n  label: 'Load Account',\n  config: {\n    objectName: 'crm_account',\n    filter: { id: cel`record.crm_account` },\n    fields: ACCOUNT_FIELDS,\n    // No `limit`: `get_record` calls `findOne` below 2 and binds the single row\n    // itself, which is what the account block's `billingAccount.FIELD` reads need.\n    outputVariable: 'billingAccount',\n  },\n});\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/revenue/flows/quote-generation.flow.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/revenue/flows\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/revenue/flows/quote-generation.flow.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport { P, expression, cel } from '@objectstack/spec';\nimport type * as Automation from '@objectstack/spec/automation';\nimport { QUOTE_DISCOUNT_CEILING } from '../../sales/objects/_thresholds';\ntype Flow = Automation.Flow;\n\n/**\n * The screen's discount as a CEL double, 0 when the rep cleared the box. A\n * source FRAGMENT, spliced into both pricing envelopes with `expression()`:\n * the `P` tag JSON-quotes an interpolated string, so it cannot splice one.\n */\nconst DISCOUNT = '(!has(vars.discount) || isBlank(vars.discount) ? 0.0 : double(vars.discount))';\n\n/**\n * Edge `e4a`'s predicate \u2014 advance the deal to `proposal`. A source FRAGMENT\n * for the same reason as `DISCOUNT`: edge `e4b` is its exact negation,\n * spliced as `!(\u2026)`, so the two branches partition by construction rather\n * than by a hand-kept De Morgan copy (the rationale is on the edges).\n */\nconst ADVANCE = `has(vars.oppRecord) && has(vars.oppRecord.stage)\n  && (vars.oppRecord.stage == \"prospecting\" || vars.oppRecord.stage == \"qualification\" || vars.oppRecord.stage == \"needs_analysis\")\n  && (!has(vars.oppRecord.approval_status) || vars.oppRecord.approval_status != \"pending\")`;\n\n/** Quote Generation \u2014 screen flow to create a quote from an opportunity */\nexport const QuoteGenerationFlow: Flow = {\n  name: 'quote_generation',\n  label: 'Generate Quote from Opportunity',\n  description: 'Create a quote based on opportunity details',\n  type: 'screen',\n  status: 'active',\n\n  variables: [\n    // MUST be `recordId` \u2014 the console's flow-action trigger contract seeds\n    // only that name ({ recordId, objectName }); a custom name like\n    // `opportunityId` arrives undefined.\n    { name: 'recordId', type: 'text', isInput: true, isOutput: false },\n    { name: 'quoteName', type: 'text', isInput: true, isOutput: false },\n    { name: 'expirationDays', type: 'number', isInput: true, isOutput: false },\n    { name: 'discount', type: 'number', isInput: true, isOutput: false },\n  ],\n\n  nodes: [\n    { id: 'start', type: 'start', label: 'Start', config: { objectName: 'crm_opportunity' } },\n    // \u2500\u2500\u2500 The \u7ACB\u9879 (qualification) gate, REQ-0006 step 11 (#2032) \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n    //\n    // \u300C\u65B0\u589E\u5546\u673A\u53EF\u8DDF\u8FDB\uFF0C\u7ACB\u9879\u901A\u8FC7\u540E\u65B9\u53EF\u66F4\u65B0\u9636\u6BB5\u3001\u6295\u6807\u3001\u8D62\u4E22\u5355\u64CD\u4F5C\u3002\u300D Ruled (hotcrm-R74b\n    // item 2, B): before \u7ACB\u9879 is approved, Generate Quote REFUSES and creates\n    // nothing. Steps 15 and 18 put quoting after the deal's approval too.\n    //\n    // Why the refusal is HERE, ahead of the form and of every writer: this\n    // flow writes the quote BEFORE the stage, and a flow carries no\n    // transaction (ADR-0077). With the gate armed, `opportunity_lifecycle`\n    // refuses the `update_opportunity` stage write \u2014 so the run used to fail\n    // AFTER `create_quote` had landed: measured on 17.7.0 as a sales_rep,\n    // `FLOW_FAILED` 400 at `update_opportunity` (\"This deal needs\n    // qualification approval first \u2026\"), one draft quote left behind, the\n    // stage unchanged. \u26D4 Not #2015's keep-stage-and-quote: that lock does\n    // not hold quoting, this gate does.\n    //\n    // The flow is the one choke point every door reaches \u2014 the record-header\n    // and list-row buttons and `POST /automation/quote_generation/trigger` \u2014\n    // so the refusal lives here and `generate_quote` stays visible: hiding\n    // it would leave the rep a missing button with no reason, because an\n    // action's `visible` / `disabled` are bare predicates with nowhere to\n    // put a sentence.\n    //\n    // The FILTER is the gate's reading, the one `opportunity_lifecycle`\n    // applies: `pending` or `rejected` holds the deal (an approver's \"no\" is\n    // not a release), every other value \u2014 the shipped `not_required`,\n    // `approved`, none at all \u2014 does not. So `held` binds the deal only while\n    // it is held, and `null` otherwise; `test/flow-quote.test.ts` pins that\n    // the two answer alike, verdict by verdict.\n    //\n    // A read of its own, at click time. \u26D4 Do not fold it into\n    // `get_opportunity`: that read stays AFTER the screen so the pricing and\n    // the #2015 approval branch (`e4a` / `e4b`) see the deal as it is at\n    // submit. The verdict cannot drift toward held while the form is open:\n    // `not_required` and `approved` are never written back to `pending`.\n    { id: 'get_held', type: 'get_record', label: 'Get Held Deal', config: { objectName: 'crm_opportunity', filter: { id: cel`recordId`, qualification_approval_status: { $in: ['pending', 'rejected'] } }, outputVariable: 'held' } },\n    // A first-class refusal (`EndConfigSchema` `outcome: 'refused'`): the run\n    // ends `refused`, never `failed` and never parked, nothing is written,\n    // and the console shows the message with Close only \u2014 no Submit and no\n    // \"completed\" toast, which is what a message-only screen would give. It\n    // names the next step the `opportunity_lifecycle` refusal of this gate\n    // names.\n    //\n    // Translated: since 18.0.0-next.0 the `flows` translation group keys an\n    // `end` node's refusal as `refusals.refuse_held.message`, which the\n    // engine renders in the run's locale (at 17.7.0 it had no such key, the\n    // gap raised from #2032). The console titles the dialog with the action's\n    // translated label. \u26D4 Do not re-route the refusal through a screen to\n    // borrow a translatable title.\n    { id: 'refuse_held', type: 'end', label: 'Quote Refused', config: { outcome: 'refused', message: 'Qualification approval comes first: tick Request Qualification Approval. Nothing was created.' } },\n    {\n      id: 'screen_1', type: 'screen', label: 'Quote Details',\n      config: {\n        fields: [\n          { name: 'quoteName', label: 'Quote Name', type: 'text', required: true },\n          { name: 'expirationDays', label: 'Valid For (Days)', type: 'number', required: true, defaultValue: 30 },\n          // The ceiling is a HARD block with no override\n          // (`crm_quote.discount_within_ceiling`), so until it is written here\n          // a rep meets the number only by having the quote refused. Both\n          // strings below interpolate `QUOTE_DISCOUNT_CEILING` \u2014 imported,\n          // never retyped, the same rule the two object rules follow \u2014 so the\n          // hint cannot drift from the rule it describes.\n          //\n          // \u26D4 There is deliberately NO `max`, and adding one does not work:\n          // `ScreenFieldConfigSchema` is STRICT at 17.3.0 and its entire key\n          // set is `name` / `label` / `type` / `required` / `options` /\n          // `defaultValue` / `placeholder` / `visibleWhen`. `max` is rejected\n          // BY NAME (`Unrecognized key(s) on this screen field: max`), so\n          // it fails `pnpm validate` rather than quietly doing nothing, and\n          // the executor forwards no such key into the `ScreenSpec` the client\n          // renders. `helpText` is rejected the same way \u2014 the console's\n          // dialog would render one, but no flow screen can carry it there.\n          //\n          // That leaves two carriers, and the label is the load-bearing one:\n          // `placeholder` renders only while the input is empty and\n          // `defaultValue: 0` seeds it, so it surfaces for the moment the rep\n          // clears the box to type \u2014 real, but not enough on its own.\n          {\n            name: 'discount',\n            label: `Discount % (\u2264 ${QUOTE_DISCOUNT_CEILING})`,\n            type: 'percent',\n            defaultValue: 0,\n            placeholder: `0-${QUOTE_DISCOUNT_CEILING}`,\n          },\n        ],\n      },\n    },\n    {\n      id: 'get_opportunity', type: 'get_record', label: 'Get Opportunity',\n      config: { objectName: 'crm_opportunity', filter: { id: cel`recordId` }, outputVariable: 'oppRecord' },\n    },\n    {\n      id: 'create_quote', type: 'create_record', label: 'Create Quote',\n      config: {\n        objectName: 'crm_quote',\n        fields: {\n          name: cel`quoteName`, crm_opportunity: cel`recordId`,\n          crm_account: cel`oppRecord.crm_account`, crm_contact: cel`has(oppRecord.primary_contact) ? oppRecord.primary_contact : null`,\n          owner_id: cel`current_user.id`, status: 'draft',\n          quote_date: cel`isoDate(today())`, expiration_date: cel`isoDate(addDays(today(), expirationDays))`,\n          // `subtotal` is a bare path pass-through and needs no rounding: it\n          // copies `crm_opportunity.amount` as stored and does no arithmetic,\n          // so it adds no floating-point tail of its own.\n          // `discount` is an optional screen answer: a resume may leave it\n          // unbound, which the template wrote as nothing and the guard writes\n          // as null (the quote field has no default, so the two agree).\n          subtotal: cel`oppRecord.amount`, discount: cel`has(vars.discount) ? discount : null`,\n          // \u26D4 A currency \u00D7 percentage MUST be rounded to whole cents inside the\n          // expression \u2014 the flow hands the engine a money amount, never an\n          // unrounded double. `discount / 100` is inexact for every percentage\n          // whose hundredth is not a dyadic rational, so a BARE product carries\n          // a tail: 180,000 at 30% is 125999.99999999999. While these fields\n          // declared `scale: 2` the insert was rejected for it (`Total Price\n          // must have at most 2 decimal places (got 11)`, #1206). Currency\n          // fields no longer declare `scale` \u2014 the platform refuses it, a\n          // currency's decimals are its ISO 4217 minor unit (#1965) \u2014 so the\n          // write is now ACCEPTED and the tail would be stored silently. The\n          // rounding keeps `discount_amount` / `total_price` whole-cent amounts.\n          //\n          // Both are CEL value envelopes. CEL's `round()` is INTEGER-ONLY and\n          // single-argument, and it returns an INT \u2014 so the divisor MUST be\n          // the decimal `100.0`. \u26D4 Never `/ 100`: in CEL int / int is integer\n          // division, which silently drops the cents (1,234.56 at 10% would\n          // store 123, not 123.46; `test/flow-quote.test.ts` pins it). \u26D4 Not\n          // `round(x, 2)` either: there is no precision form, and it fails\n          // loudly. `double()` types the amount, which some drivers return as\n          // a string. A cleared discount (null / absent / \"\") prices as 0%, as\n          // it did before; the `has()` guard is what keeps that TOTAL.\n          //\n          // \u2B50 This shape applies ANYWHERE a flow multiplies a currency by a\n          // percentage. Write the rounding, not the bare product.\n          discount_amount: expression(`round(double(oppRecord.amount) * (${DISCOUNT} / 100.0) * 100.0) / 100.0`, 'cel'),\n          total_price: expression(`round(double(oppRecord.amount) * (1.0 - ${DISCOUNT} / 100.0) * 100.0) / 100.0`, 'cel'),\n          payment_terms: 'net_30',\n        },\n        outputVariable: 'quoteId',\n      },\n    },\n    {\n      // Advance to `proposal` only from a PRE-proposal stage (the state machine\n      // allows `\u2192 proposal` from all three). \u26D4 Never re-write `proposal` on a\n      // deal already at proposal/negotiation: that is an illegal self/backward\n      // transition. Those deals keep their stage; the quote is still created.\n      //\n      // \u26D4 Nor on a deal AWAITING APPROVAL (`approval_status == \"pending\"`). A\n      // deal of `LARGE_DEAL_AMOUNT` or more is held by `opportunity_approval`'s\n      // approval node (`lockRecord: true`) until a manager decides, and the\n      // lock refuses this run's stage write \u2014 the run is the rep's\n      // (`runAs: 'user'`), and the lock is the approval working as intended.\n      // `create_quote` has already landed by then and a flow carries no\n      // transaction (ADR-0077), so the refusal used to fail the run AFTER the\n      // quote existed: measured on 17.7.0, `FLOW_FAILED` 400 `RECORD_LOCKED`\n      // at `update_opportunity`, the rep told the quote failed, and the draft\n      // quote left standing (#2015). A deal under review keeps its stage\n      // exactly like a deal already at proposal; the quote is still created \u2014\n      // the button is offered at every open stage, and a draft quote commits\n      // nothing the approval is there to hold. `approval_status` is the lock's\n      // own mirror (`approvalStatusField`): the approvals plugin stamps\n      // `pending` when it opens the locking request and a terminal verdict\n      // when it releases it.\n      //\n      // The predicate itself lives on edges `e4a` / `e4b` \u2014 a `decision` node's\n      // singular `config.condition` is never evaluated, so a copy here would be\n      // inert (17.0.0-rc.2's `flow-inert-node-condition`). The totality\n      // rationale is on those edges, where the guards are.\n      id: 'check_stage', type: 'decision', label: 'Can Advance to Proposal?',\n    },\n    {\n      id: 'update_opportunity', type: 'update_record', label: 'Update Opportunity',\n      config: {\n        // \u26D4 No `last_activity_date` write: `crm_opportunity` has no such field\n        // (it lives on `crm_account`), and an unknown column fails this node.\n        objectName: 'crm_opportunity', filter: { id: cel`recordId` },\n        fields: { stage: 'proposal' },\n      },\n    },\n    {\n      // ADR-0012: deliver via the `notify` node (inbox + email). The legacy\n      // `script` + `actionType:'email'` shape is a no-op stub in 7.4.\n      id: 'notify_owner', type: 'notify', label: 'Send Notification',\n      config: {\n        recipients: [cel`current_user.id`],\n        channels: ['inbox', 'email'],\n        topic: 'quote_created',\n        template: 'crm.quote_created',\n        templateData: { quote_name: cel`quoteName` },\n        actionUrl: '/crm_quote/{{quoteId.id}}',\n      },\n    },\n    { id: 'end', type: 'end', label: 'End' },\n  ],\n\n  edges: [\n    // \u26D4 A retired edge's id stays VACANT: `e1` (start \u2192 screen_1) is one.\n    // Every surviving edge keeps its id, and a new one takes the next id after\n    // the highest in use \u2014 a duplicate id is inert, so nothing would flag it.\n    { id: 'e7', source: 'start', target: 'get_held', type: 'default' },\n    // \u2500\u2500 The \u7ACB\u9879 gate (#2032) \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n    //\n    // COMPLEMENTARY CONDITIONALS off a plain data node, not a `decision` \u2014 the\n    // shape `billing-handoff-contract-activated.flow.ts` records: they are\n    // evaluated one by one, and `!= null` / `== null` partition exactly.\n    // `get_held` dominates both and binds `held` on every path \u2014 the row, or\n    // `null` on a miss \u2014 so neither read takes a `has()` guard: the\n    // get_record-dominated case `test/flow-variable-conditions.test.ts`\n    // records as needing none, written like `lead_conversion`'s `e5` / `e6`.\n    // Fail-OPEN like the hook: a deal the read cannot see goes on to the form\n    // and fails at `create_quote` exactly as it always did.\n    { id: 'e9', source: 'get_held', target: 'refuse_held', type: 'default', condition: P`vars.held != null`, label: 'Held' },\n    { id: 'e10', source: 'get_held', target: 'screen_1', type: 'default', condition: P`vars.held == null`, label: 'Not held' },\n    { id: 'e2', source: 'screen_1', target: 'get_opportunity', type: 'default' },\n    { id: 'e3', source: 'get_opportunity', target: 'create_quote', type: 'default' },\n    { id: 'e4', source: 'create_quote', target: 'check_stage', type: 'default' },\n    // The two branches must PARTITION, so the keep side is the advance side\n    // negated whole (`ADVANCE` above): `has(\u2026) && \u2026` advances and everything\n    // else keeps. An unknown stage therefore lands on \"keep stage\" \u2014 the quote\n    // is still created and nothing illegal is written to the state machine.\n    // These EDGES are the live sites; `check_stage` carries no\n    // `config.condition` at all, because the engine never evaluates one.\n    //\n    // TOTALITY: `oppRecord` is a `get_record` OUTPUT \u2014 `findOne` answers\n    // a miss with `null`, and reading a field off it then aborts with `No such\n    // key: stage`. Measured unreachable TODAY only because two neighbouring\n    // schemas happen to close it: `crm_opportunity.stage` is `required` (never\n    // a sparse column) and `crm_quote.crm_account` is `required`, so a null\n    // `oppRecord` makes `create_quote` fail one node earlier. Both are one\n    // `required: false` away from re-opening it, so the predicate carries its\n    // own guard \u2014 and from 17.0.0-rc.2 an unevaluable condition aborts the step\n    // instead of skipping it, so the guard is load-bearing, not\n    // decorative. Note the scope is `vars.oppRecord`, not bare `oppRecord`:\n    // measured, `has(oppRecord.stage)` still aborts with `Unknown variable:\n    // oppRecord` when the variable is unbound, while `has(vars.oppRecord)`\n    // answers `false` \u2014 only the `vars.`-scoped form is total against both\n    // hazards.\n    //\n    // The approval term (see `check_stage`) is guarded the same way: an absent\n    // or null `approval_status` is \"not under approval\" and advances, as it\n    // did before the term existed.\n    { id: 'e4a', source: 'check_stage', target: 'update_opportunity', type: 'conditional', condition: expression(ADVANCE, 'cel'), label: 'Advance' },\n    { id: 'e4b', source: 'check_stage', target: 'notify_owner', type: 'conditional', condition: expression(`!(${ADVANCE})`, 'cel'), label: 'Keep stage' },\n    { id: 'e5', source: 'update_opportunity', target: 'notify_owner', type: 'default' },\n    { id: 'e6', source: 'notify_owner', target: 'end', type: 'default' },\n  ],\n};\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/revenue/flows/contract-renewal.flow.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/revenue/flows\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/revenue/flows/contract-renewal.flow.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport { P, cel } from '@objectstack/spec';\nimport type * as Automation from '@objectstack/spec/automation';\nimport { guarded } from '../../sales/flows/_guarded-iteration';\ntype Flow = Automation.Flow;\n\n/**\n * Contract Renewal \u2014 scheduled daily sweep for contracts entering their\n * renewal-notice window.\n *\n * This flow is what consumes `end_date`, `auto_renewal` and\n * `renewal_notice_days`: each morning it finds `activated` contracts whose\n * `end_date` falls inside their per-contract notice window, books a renewal task\n * for the owner, notifies them, and \u2014 when `auto_renewal` is on \u2014 opens an\n * `existing_renewal` opportunity pre-filled from the contract value so the deal\n * is already in the pipeline.\n *\n * Capabilities exercised: scheduled trigger + `loop` over a query result +\n * per-record `decision` gates + `notify` (ADR-0012).\n */\nexport const ContractRenewalFlow: Flow = {\n  name: 'contract_renewal',\n  label: 'Contract Renewal Reminder',\n  description: 'Daily sweep: open renewal tasks/opportunities for contracts nearing end_date.',\n  type: 'schedule',\n  status: 'active',\n  // Scheduled runs have no trigger user, so under the default runAs:'user' the\n  // data nodes execute UNSCOPED anyway. Declare runAs:'system' to make that\n  // RLS-bypassing elevation explicit and intended (ADR-0049).\n  runAs: 'system',\n\n  variables: [],\n\n  nodes: [\n    { id: 'start', type: 'start', label: 'Start (daily 08:00)', config: { schedule: '0 8 * * *' } },\n    {\n      // Broad pre-filter (next 120 days \u2014 \u26D4 must cover the LARGEST\n      // renewal_notice_days in use; seeds go up to 90). The per-record notice\n      // window is applied in the decision node below so each contract honours\n      // its own renewal_notice_days. A pre-filter narrower than the largest\n      // notice period silently truncates it: a 90-day contract stays invisible\n      // until 60 days out.\n      id: 'query_contracts', type: 'get_record', label: 'Find Expiring Contracts',\n      config: {\n        objectName: 'crm_contract',\n        filter: { status: 'activated', end_date: { $gte: cel`isoDate(today())`, $lte: cel`isoDate(daysFromNow(120))` } },\n        limit: 500,\n        outputVariable: 'contractList',\n      },\n    },\n    {\n      id: 'loop_contracts', type: 'loop', label: 'For Each Contract',\n      config: {\n        collection: cel`contractList`,\n        iteratorVariable: 'currentContract',\n        body: guarded('contract', {\n          nodes: [\n            {\n              // Gateway only \u2014 the predicate lives on the out-edge.\n              id: 'check_notice_window', type: 'decision', label: 'Within Notice Window?',\n            },\n            {\n              // Idempotency gate: the sweep matches the same contract every day\n              // of its notice window, so \u26D4 without it every day produces a\n              // duplicate task + notification (and, below, a duplicate\n              // pipeline-inflating renewal opportunity). An open renewal task\n              // for this contract means this window was already handled.\n              id: 'find_existing_task', type: 'get_record', label: 'Already Reminded?',\n              config: {\n                objectName: 'crm_task',\n                filter: {\n                  related_to_account: cel`currentContract.crm_account`,\n                  subject: cel`'Renewal due: contract ' + currentContract.contract_number`,\n                  status: { $nin: ['completed'] },\n                },\n                outputVariable: 'existingRenewalTask',\n              },\n            },\n            {\n              // Gateway only \u2014 the predicate lives on the out-edge.\n              id: 'check_not_reminded', type: 'decision', label: 'First Reminder?',\n            },\n            {\n              id: 'create_renewal_task', type: 'create_record', label: 'Create Renewal Task',\n              config: {\n                objectName: 'crm_task',\n                fields: {\n                  subject: cel`'Renewal due: contract ' + currentContract.contract_number`,\n                  type: 'follow_up', priority: 'high', status: 'not_started',\n                  due_date: cel`currentContract.end_date`,\n                  owner_id: cel`has(currentContract.owner_id) ? currentContract.owner_id : null`,\n                  // ORG PARTITION. A schedule trigger carries no\n                  // organization, so the engine has nothing to fill this from\n                  // and the row would be born `organization_id` NULL \u2014 outside\n                  // every org partition, where an `(organization_id, \u2026)` unique\n                  // index does not constrain and org-scoped reads never see it.\n                  // Upstream ruling objectstack#6155 Q2=A puts the answer here,\n                  // with the flow author: a renewal task belongs to the org of\n                  // the contract that spawned it. Fill-only precedence means an\n                  // author-set value wins over the engine (objectstack#6153).\n                  // The source MUST be a row that actually carries the column.\n                  // On 17.x an absent key interpolated to `undefined` and landed\n                  // as NULL, which satisfied the publish guard while reproducing\n                  // the bug; the CEL read below fails the iteration instead, and\n                  // it is deliberately left UNGUARDED \u2014 a `has()` guard would\n                  // write that NULL back. `crm_contract` carries it; `sys_user`\n                  // does not.\n                  organization_id: cel`currentContract.organization_id`,\n                  related_to_type: 'crm_account',\n                  related_to_account: cel`currentContract.crm_account`,\n                },\n              },\n            },\n            {\n              id: 'notify_owner', type: 'notify', label: 'Notify Owner',\n              config: {\n                recipients: [cel`has(currentContract.owner_id) ? currentContract.owner_id : null`],\n                channels: ['inbox', 'email'],\n                topic: 'contract_renewal',\n                template: 'crm.contract_renewal',\n                templateData: {\n                  contract_number: cel`currentContract.contract_number`, end_date: cel`currentContract.end_date`,\n                },\n                actionUrl: '/crm_contract/{{currentContract.id}}',\n              },\n            },\n            {\n              // Gateway only \u2014 the predicate lives on the out-edge.\n              id: 'check_auto_renewal', type: 'decision', label: 'Auto-Renewal On?',\n            },\n            {\n              // Second gate: never open a second renewal opportunity while one\n              // is still in flight for this account (belt-and-braces for the\n              // case where the task was completed but the deal is still open).\n              id: 'find_existing_renewal_opp', type: 'get_record', label: 'Open Renewal Deal Exists?',\n              config: {\n                objectName: 'crm_opportunity',\n                filter: {\n                  crm_account: cel`currentContract.crm_account`,\n                  type: 'existing_renewal',\n                  stage: { $nin: ['closed_won', 'closed_lost'] },\n                },\n                outputVariable: 'existingRenewalOpp',\n              },\n            },\n            {\n              // Gateway only \u2014 the predicate lives on the out-edge.\n              id: 'check_no_open_renewal', type: 'decision', label: 'No Open Renewal Deal?',\n            },\n            {\n              id: 'create_renewal_opp', type: 'create_record', label: 'Open Renewal Opportunity',\n              config: {\n                objectName: 'crm_opportunity',\n                fields: {\n                  name: cel`'Renewal \u2014 ' + currentContract.contract_number`,\n                  crm_account: cel`currentContract.crm_account`,\n                  amount: cel`currentContract.contract_value`,\n                  stage: 'proposal',\n                  type: 'existing_renewal',\n                  close_date: cel`currentContract.end_date`,\n                  owner_id: cel`has(currentContract.owner_id) ? currentContract.owner_id : null`,\n                  // ORG PARTITION \u2014 see `create_renewal_task` above.\n                  // The renewal deal belongs to the same org as the contract.\n                  organization_id: cel`currentContract.organization_id`,\n                  next_step: 'Confirm renewal terms with customer',\n                },\n              },\n            },\n          ],\n          edges: [\n            // Only act when inside the per-contract notice window; gates with\n            // no matching edge simply end the iteration, so the loop moves on.\n            //\n            // The EDGE is the ONLY site: a `decision` node's singular\n            // `config.condition` is never read \u2014 the executor reads the plural\n            // `config.conditions[]` and nothing else \u2014 so a copy on the node\n            // would be inert metadata that drifts silently. `check_notice_window`\n            // is therefore a bare gateway and this predicate is authored once.\n            //\n            // `end_date` is a DATE field and arrives as `YYYY-MM-DD`, but CEL's\n            // `timestamp()` only accepts a full ISO 8601 datetime and throws\n            // otherwise (\"timestamp() requires a string in ISO 8601 format\").\n            // Appending the time part is what makes this evaluate instead of\n            // blowing up mid-sweep.\n            //\n            // TOTALITY: `currentContract` is a LOOP ITEM over\n            // `contractList`, which `get_record` filled from `data.find` \u2014\n            // every element is a raw driver row, sparse in exactly the way\n            // a raw driver row is. `end_date` is `required` on `crm_contract` so\n            // that column is always written, but `renewal_notice_days`\n            // (`defaultValue: 30`) and `auto_renewal` (`defaultValue: false`)\n            // are only DEFAULTED, and a row written before the default existed\n            // carries neither the column nor a value. Both operands\n            // additionally need `!= null`, because the abort here is not the\n            // usual overload error: `null + \"T00:00:00Z\"` and `int(null)` each\n            // blow up inside the function call, one contract into a 500-row\n            // sweep, taking the whole scheduled run with them.\n            { id: 'b1', source: 'check_notice_window', target: 'find_existing_task', type: 'conditional', condition: P`has(vars.currentContract) && has(vars.currentContract.end_date) && has(vars.currentContract.renewal_notice_days)\n              && vars.currentContract.end_date != null && vars.currentContract.renewal_notice_days != null\n              && timestamp(vars.currentContract.end_date + \"T00:00:00Z\") <= daysFromNow(int(vars.currentContract.renewal_notice_days))`, label: 'In window' },\n            { id: 'b2', source: 'find_existing_task', target: 'check_not_reminded', type: 'default' },\n            { id: 'b3', source: 'check_not_reminded', target: 'create_renewal_task', type: 'conditional', condition: P`existingRenewalTask == null`, label: 'First reminder' },\n            { id: 'b4', source: 'create_renewal_task', target: 'notify_owner', type: 'default' },\n            { id: 'b5', source: 'notify_owner', target: 'check_auto_renewal', type: 'default' },\n            // TOTALITY: same loop item, same sparse driver row. Only an\n            // explicit `true` opens a renewal deal, so an absent column reads\n            // as \"auto-renewal off\" \u2014 the conservative branch.\n            { id: 'b6', source: 'check_auto_renewal', target: 'find_existing_renewal_opp', type: 'conditional', condition: P`has(vars.currentContract) && has(vars.currentContract.auto_renewal)\n              && vars.currentContract.auto_renewal == true`, label: 'Auto-renew' },\n            { id: 'b7', source: 'find_existing_renewal_opp', target: 'check_no_open_renewal', type: 'default' },\n            { id: 'b8', source: 'check_no_open_renewal', target: 'create_renewal_opp', type: 'conditional', condition: P`existingRenewalOpp == null`, label: 'Open renewal deal' },\n          ],\n        }),\n      },\n    },\n    { id: 'end', type: 'end', label: 'End' },\n  ],\n\n  edges: [\n    { id: 'e1', source: 'start', target: 'query_contracts', type: 'default' },\n    { id: 'e2', source: 'query_contracts', target: 'loop_contracts', type: 'default' },\n    { id: 'e3', source: 'loop_contracts', target: 'end', type: 'default' },\n  ],\n};\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/revenue/flows/quote-expiration.flow.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/revenue/flows\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/revenue/flows/quote-expiration.flow.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport { cel } from '@objectstack/spec';\nimport type * as Automation from '@objectstack/spec/automation';\nimport { guarded } from '../../sales/flows/_guarded-iteration';\ntype Flow = Automation.Flow;\n\n/**\n * Quote auto-expiration \u2014 scheduled daily sweep.\n *\n * Flips quotes past their `expiration_date` to `expired` unless already\n * accepted/rejected/expired.\n */\nexport const QuoteExpirationFlow: Flow = {\n  name: 'quote_expiration',\n  label: 'Quote Auto-Expiration',\n  description: 'Daily: expire quotes past their expiration_date that are still open.',\n  type: 'schedule',\n  status: 'active',\n  // Scheduled runs have no trigger user, so under the default runAs:'user' the\n  // data nodes execute UNSCOPED anyway. Declare runAs:'system' to make that\n  // RLS-bypassing elevation explicit and intended (ADR-0049).\n  runAs: 'system',\n  variables: [],\n  nodes: [\n    { id: 'start', type: 'start', label: 'Start (daily 01:00)', config: { schedule: '0 1 * * *' } },\n    {\n      id: 'query_quotes', type: 'get_record', label: 'Find Expired Quotes',\n      config: {\n        objectName: 'crm_quote',\n        filter: { status: { $nin: ['accepted', 'rejected', 'expired'] }, expiration_date: { $lt: cel`isoDate(today())` } },\n        limit: 500,\n        outputVariable: 'quoteList',\n      },\n    },\n    {\n      id: 'loop_quotes', type: 'loop', label: 'For Each Quote',\n      config: {\n        collection: cel`quoteList`,\n        iteratorVariable: 'currentQuote',\n        body: guarded('quote', {\n          nodes: [\n            {\n              id: 'mark_expired', type: 'update_record', label: 'Mark Expired',\n              config: { objectName: 'crm_quote', filter: { id: cel`currentQuote.id` }, fields: { status: 'expired' } },\n            },\n          ],\n          edges: [],\n        }),\n      },\n    },\n    { id: 'end', type: 'end', label: 'End' },\n  ],\n  edges: [\n    { id: 'e1', source: 'start', target: 'query_quotes', type: 'default' },\n    { id: 'e2', source: 'query_quotes', target: 'loop_quotes', type: 'default' },\n    { id: 'e3', source: 'loop_quotes', target: 'end', type: 'default' },\n  ],\n};\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/revenue/flows/contract-expiration.flow.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/revenue/flows\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/revenue/flows/contract-expiration.flow.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport { cel } from '@objectstack/spec';\nimport type * as Automation from '@objectstack/spec/automation';\nimport { guarded } from '../../sales/flows/_guarded-iteration';\ntype Flow = Automation.Flow;\n\n/**\n * Contract auto-expiration \u2014 scheduled daily sweep.\n *\n * Flips `activated` contracts past their `end_date` to `expired` and notifies\n * the owner. (Renewal *reminders* are a separate concern, handled by the\n * `contract_renewal` flow.)\n */\nexport const ContractExpirationFlow: Flow = {\n  name: 'contract_expiration',\n  label: 'Contract Auto-Expiration',\n  description: 'Daily: expire activated contracts past their end_date and notify the owner.',\n  type: 'schedule',\n  status: 'active',\n  // Scheduled runs have no trigger user, so under the default runAs:'user' the\n  // data nodes execute UNSCOPED anyway. Declare runAs:'system' to make that\n  // RLS-bypassing elevation explicit and intended (ADR-0049).\n  runAs: 'system',\n  variables: [],\n  nodes: [\n    { id: 'start', type: 'start', label: 'Start (daily 00:00)', config: { schedule: '0 0 * * *' } },\n    {\n      id: 'query_contracts', type: 'get_record', label: 'Find Expired Contracts',\n      config: {\n        objectName: 'crm_contract',\n        filter: { status: 'activated', end_date: { $lt: cel`isoDate(today())` } },\n        limit: 500,\n        outputVariable: 'contractList',\n      },\n    },\n    {\n      id: 'loop_contracts', type: 'loop', label: 'For Each Contract',\n      config: {\n        collection: cel`contractList`,\n        iteratorVariable: 'currentContract',\n        body: guarded('contract', {\n          nodes: [\n            {\n              id: 'mark_expired', type: 'update_record', label: 'Mark Expired',\n              config: { objectName: 'crm_contract', filter: { id: cel`currentContract.id` }, fields: { status: 'expired' } },\n            },\n            {\n              id: 'notify_owner', type: 'notify', label: 'Notify Owner',\n              config: {\n                recipients: [cel`has(currentContract.owner_id) ? currentContract.owner_id : null`],\n                channels: ['inbox', 'email'],\n                topic: 'contract_expired',\n                template: 'crm.contract_expired',\n                templateData: { contract_number: cel`currentContract.contract_number` },\n                actionUrl: '/crm_contract/{{currentContract.id}}',\n              },\n            },\n          ],\n          edges: [\n            { id: 'b1', source: 'mark_expired', target: 'notify_owner', type: 'default' },\n          ],\n        }),\n      },\n    },\n    { id: 'end', type: 'end', label: 'End' },\n  ],\n  edges: [\n    { id: 'e1', source: 'start', target: 'query_contracts', type: 'default' },\n    { id: 'e2', source: 'query_contracts', target: 'loop_contracts', type: 'default' },\n    { id: 'e3', source: 'loop_contracts', target: 'end', type: 'default' },\n  ],\n};\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/revenue/flows/billing-handoff-contract-activated.flow.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/revenue/flows\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/revenue/flows/billing-handoff-contract-activated.flow.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport { P, cel } from '@objectstack/spec';\nimport type * as Automation from '@objectstack/spec/automation';\ntype Flow = Automation.Flow;\n\nimport {\n  BILLING_HANDOFF_ENDPOINT,\n  BILLING_HANDOFF_EVENT,\n  BILLING_HANDOFF_LINE_ITEM_LIMIT,\n  BILLING_HANDOFF_SIGNING_SECRET,\n  BILLING_HANDOFF_TIMEOUT_MS,\n  LINE_ITEM_FIELDS,\n  billingBody,\n  loadAccountNode,\n} from '../../sales/flows/_billing-endpoint';\n\n/**\n * \u2550\u2550\u2550 Billing hand-off \u2014 where HotCRM's revenue scope ends \u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\n *\n * HotCRM owns lead \u2192 contract. It does **not** model Orders, Invoices or\n * Payments (maintainer decision, 2026-08-02): billing is an external system's\n * job. What the CRM owes that system is a reliable hand-off, and these two\n * flows are it:\n *\n *   - `billing_handoff_closed_won`          \u2014 an opportunity ENTERS `closed_won`\n *     (`src/sales/flows/billing-handoff-closed-won.flow.ts`)\n *   - `billing_handoff_contract_activated`  \u2014 a contract ENTERS `activated`\n *     (this file; `crm_contract` is the revenue package's object)\n *\n * Each POSTs one JSON document \u2014 the record, its account, and its line items \u2014\n * to {@link BILLING_HANDOFF_ENDPOINT}, through the platform's **durable HTTP\n * outbox**: the `http` node with `durable: true` calls\n * `messaging.enqueueHttp({ source: 'flow', \u2026 })`, which persists a\n * `sys_http_delivery` row that the HTTP dispatcher drains with retry, backoff\n * and dead-lettering, signing the body with HMAC-SHA256 when a secret is set.\n * Nothing here is custom plumbing; it is the platform's own outbound-callout\n * verb, on the same outbox the declarative `webhooks` surface uses.\n *\n * ## \u26D4 Do not re-express these as declared `webhooks`\n *\n * Measured on 17.0.0-rc.6, that surface cannot express either event:\n * `WebhookSchema` is `.strict` and rejects `condition` / `filter` / `body` /\n * `payloadFields` / `retryPolicy`; its `triggers` vocabulary is\n * `create / update / delete / bulk_*` with no transition form; and the\n * auto-enqueuer matches on object + trigger alone and delivers a fixed\n * `DataEvent` envelope carrying neither the account nor the line items. A\n * `sys_webhook` row named for closed-won would fire on *every* opportunity edit\n * \u2014 a declaration that lies about itself, in the app other people copy.\n * Dispatch there is additionally gated on the `realtime` capability, which this\n * app does not require, so such a row would be visible in Setup and never fire\n * at all.\n *\n * The cost of this route is stated in `_billing-endpoint.ts` and in\n * `content/docs/revenue/billing-handoff.mdx`: the endpoint and secret live in\n * flow metadata, so repointing them is a rebuild, not a Setup edit.\n *\n * ## Exactly once per transition, not once per edit\n *\n * \u26D4 Both start conditions must test the TRANSITION\n * (`record.x == v && previous.x != v`), never the current value. This is the\n * idiom `opportunity_won_alert` uses on this very object: without the\n * `previous.*` term, every later edit of a won deal \u2014 a seed-ownership\n * claim, an approval stamp, a description tweak \u2014 re-fires the flow. For a\n * congratulations notification that is noise; for a billing hand-off it is a\n * duplicate order. `previous.*` is guarded FAIL-CLOSED (`has(previous.x) &&`)\n * for the same reason it is there: when the engine cannot see the prior value\n * it cannot see a transition either, and must not claim one. The shape that\n * covers is a bulk `updateMany`, where ObjectQL reads no prior row and\n * `previous` arrives null \u2014 one hand-off per row of a bulk update is exactly\n * what nobody wants.\n *\n * Delivery itself is **at-least-once**: the outbox retries a failed attempt,\n * and every attempt of one enqueued row carries the same `X-Objectstack-Delivery`\n * id. Receivers dedupe on that header.\n *\n * ## Totality\n *\n * Every `record.*` / `previous.*` read below carries a `has(...)` guard \u2014 the\n * house rule `test/flow-condition-totality.test.ts` enforces, because a flow\n * condition that aborts fails the whole run rather than yielding `false`.\n */\n\n/**\n * \u2500\u2500 Event 2: contract enters `activated` \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n *\n * NB the value is `activated`. `crm_contract.status` has no `active` member \u2014\n * the options are `draft / in_approval / activated / expired / terminated`,\n * governed by the `contract_status_progression` state machine.\n */\nexport const BillingHandoffContractActivatedFlow: Flow = {\n  name: 'billing_handoff_contract_activated',\n  label: 'Billing Hand-off: Contract Activated',\n  description:\n    'On the transition into activated: POST the contract, its account and the originating deal\u2019s line items to the billing endpoint via the durable HTTP outbox.',\n  type: 'record_change',\n  status: 'active',\n  // Contracts are activated by machinery as well as by hand \u2014 `contract.hook.ts`\n  // stamps the account promotion and signed date on that same transition, and\n  // the renewal sweep runs `runAs: 'system'`. A system write carries no trigger\n  // user, so under the default `runAs: 'user'` this flow's two reads would be\n  // refused on exactly those runs and the hand-off would disappear without a\n  // failed step. Elevation also guarantees the payload is the whole contract,\n  // not an RLS-narrowed view of it.\n  runAs: 'system',\n  variables: [\n    // Bound with a default because the line-item read below is CONDITIONAL: a\n    // contract need not have an originating opportunity. Without the default,\n    // the skipped path leaves `billingLineItems` unbound and the payload key\n    // vanishes \u2014 so a receiver could not tell \"no items\" from \"not sent\".\n    { name: 'billingLineItems', type: 'collection', isInput: false, isOutput: false, defaultValue: [] },\n  ],\n  nodes: [\n    {\n      id: 'start',\n      type: 'start',\n      label: 'Start (contract updated)',\n      config: {\n        objectName: 'crm_contract',\n        triggerType: 'record-after-update',\n        condition: P`has(record.status) && record.status == \"activated\"\n          && has(previous.status) && previous.status != \"activated\"`,\n      },\n    },\n    loadAccountNode(),\n    {\n      id: 'load_line_items',\n      type: 'get_record',\n      label: 'Load Originating Deal\u2019s Line Items',\n      config: {\n        objectName: 'crm_opportunity_line_item',\n        // Contracts carry no line items of their own; what was sold sits on the\n        // opportunity the contract came from. Reached only via the guarded edge\n        // below, because `crm_opportunity` is OPTIONAL on a contract and a\n        // filter operand that evaluates to null makes `get_record` refuse the\n        // step (an absent condition widens a query rather than narrowing it).\n        filter: { crm_opportunity: cel`record.crm_opportunity` },\n        fields: LINE_ITEM_FIELDS,\n        limit: BILLING_HANDOFF_LINE_ITEM_LIMIT,\n        outputVariable: 'billingLineItems',\n      },\n    },\n    {\n      id: 'send_contract_activated_handoff',\n      type: 'http',\n      label: 'Enqueue Billing Hand-off',\n      config: {\n        url: BILLING_HANDOFF_ENDPOINT,\n        method: 'POST',\n        durable: true,\n        timeoutMs: BILLING_HANDOFF_TIMEOUT_MS,\n        signingSecret: BILLING_HANDOFF_SIGNING_SECRET,\n        // One envelope building the whole payload (see `billingBody`). This\n        // flow is the consumer of `billing_frequency` and `payment_terms`: they\n        // are what the billing system needs to raise the schedule HotCRM\n        // deliberately does not model.\n        body: billingBody(BILLING_HANDOFF_EVENT.contractActivated, 'contract', [\n          'id', 'contract_number', 'status', 'contract_type', 'start_date', 'end_date', 'contract_term_months',\n          'contract_value', 'billing_frequency', 'payment_terms', 'auto_renewal', 'signed_date',\n          ['account_id', 'crm_account'], ['opportunity_id', 'crm_opportunity'], 'owner_id',\n        ]),\n      },\n    },\n    { id: 'end', type: 'end', label: 'End' },\n  ],\n  edges: [\n    { id: 'e1', source: 'start', target: 'load_account', type: 'default' },\n    // The two edges below are COMPLEMENTARY CONDITIONALS on a plain data node,\n    // deliberately not a `decision` gateway. A decision with no declared\n    // `config.conditions` reports the engine's `default` branch label, and\n    // traversal then narrows the edge set to out-edges claiming that label \u2014\n    // an `isDefault: true` sibling would swallow the whole branch and the\n    // conditional edge would never be evaluated. Complementary conditions off a\n    // non-branching node are evaluated one by one, which is the behaviour this\n    // needs.\n    {\n      id: 'e2',\n      source: 'load_account',\n      target: 'load_line_items',\n      type: 'conditional',\n      label: 'Has originating deal',\n      condition: P`has(record.crm_opportunity) && record.crm_opportunity != null`,\n    },\n    {\n      id: 'e3',\n      source: 'load_account',\n      target: 'send_contract_activated_handoff',\n      type: 'conditional',\n      label: 'No originating deal',\n      condition: P`!has(record.crm_opportunity) || record.crm_opportunity == null`,\n    },\n    { id: 'e4', source: 'load_line_items', target: 'send_contract_activated_handoff', type: 'default' },\n    { id: 'e5', source: 'send_contract_activated_handoff', target: 'end', type: 'default' },\n  ],\n};\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/marketing/flows/campaign-enrollment.flow.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/marketing/flows\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/marketing/flows/campaign-enrollment.flow.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport { P, cel } from '@objectstack/spec';\nimport type * as Automation from '@objectstack/spec/automation';\nimport { guarded } from '../../sales/flows/_guarded-iteration';\ntype Flow = Automation.Flow;\n\n/**\n * Campaign Enrollment \u2014 screen flow to bulk-enroll leads OR contacts into a\n * campaign.\n *\n * Launched from the \"Enroll Members\" action on a campaign record. \u26D4 Never turn\n * this into a `schedule` flow: a cron firing seeds NO input variables \u2014 only the\n * console's flow-action trigger does (cf. lead_conversion) \u2014 so `recordId` and\n * the segment fields arrive undefined, and the run either matches no campaign or\n * mass-enrolls every open lead into a null campaign.\n *\n * The contact branch mirrors the lead branch rather than being a second dialect:\n * same open-campaign gate, same eligibility shape, same per-member dedupe, same\n * `sent` + `added_date` stamp. Segmentation mirrors too \u2014 leads are segmented by\n * `status` (where they are in qualification); contacts have no such column, so\n * they are segmented by `department`, the field that answers \"who is this person\n * at the account\", which is what a campaign targeting an existing customer base\n * selects on.\n *\n * Eligibility, both sides: has an email, and is not opted out of email; leads\n * additionally must not already be converted (a converted lead is now a contact,\n * and would otherwise be enrollable through both branches as two people).\n * Already-enrolled people are skipped, so re-running the action tops up rather\n * than duplicating.\n *\n * \u26D4 This flow does NOT write the campaign metric rollups (`num_sent` etc.) \u2014\n * the campaign metric hooks own them and refresh on every membership change. A\n * per-run `num_sent = {leadList.length}` overwrite here clobbers prior batches.\n */\nexport const CampaignEnrollmentFlow: Flow = {\n  name: 'campaign_enrollment',\n  label: 'Enroll Members in Campaign',\n  description: 'Bulk enroll eligible leads or contacts into this campaign (skips already-enrolled and opted-out people).',\n  type: 'screen',\n  status: 'active',\n\n  variables: [\n    // `recordId` matches the console's flow-action trigger contract\n    // ({ recordId, objectName }) \u2014 cf. lead_conversion / quote_generation.\n    { name: 'recordId', type: 'text', isInput: true, isOutput: false },\n    /**\n     * `memberSource` is BOUND BY THIS DECLARATION \u2014 not by a seeding node.\n     *\n     * Both branch edges (`e4` / `e7`) read `vars.memberSource`, so it must be\n     * bound on every path reaching them. `FlowVariableSchema` carries\n     * `defaultValue` and the engine seeds it before the start node runs, so this\n     * key alone binds the name \u2014 while a caller-supplied\n     * `context.params.memberSource` still WINS over it.\n     *\n     * \u26A0\uFE0F Measured on the 17.1.0 spec, with the schema key re-checked on 17.2.0.\n     * Neither that key nor the seeding behaviour was re-checked on 17.3.0 or\n     * 17.4.0 (PR #1814, #1807), nor on 17.5.0, 17.6.0, 17.7.0 or 18.0.0-next.0 (the pin since #2031).\n     *\n     * \u26D4 Never seed this with an assignment node instead. An assignment is\n     * unconditional, so it CLOBBERS a supplied param \u2014 measured: launching with\n     * `params.memberSource = 'contacts'` ran the LEAD branch. It also restates a\n     * default the screen field carries, with nothing keeping the two in step.\n     *\n     * A second, independent reason no seeding node is needed here: the\n     * `memberSource` screen field below is `required: true`, and since\n     * 17.0.0-rc.2 the SERVER holds a screen resume to the declared field\n     * contract. A resume signal omitting `memberSource` is refused with\n     * `INVALID_SCREEN_INPUT` and the run stays paused, so the ordinary resume\n     * path cannot reach an unbound read at all \u2014 unlike `lead_conversion`'s\n     * checkbox, which is deliberately not `required` and therefore has an\n     * unanswered state. The one path that skips that check is a resume carrying\n     * NO signal object; measured on 17.x, it fails one node later at\n     * `query_leads` regardless of this binding, because `leadStatus` is unbound\n     * and the query never runs widened. Since 18.0.0-next.0 the filter operand\n     * is a CEL envelope, and an unbound variable fails the run before the query\n     * (the platform's `flow-value-slot-template-dialect-refused` contract; not\n     * re-measured here).\n     *\n     * The literal lives HERE and nowhere else: the screen field derives its\n     * prefill from this variable (its `defaultValue` envelope reads `memberSource`).\n     */\n    { name: 'memberSource', type: 'text', isInput: true, isOutput: false, defaultValue: 'leads' },\n    /**\n     * `leadStatus` / `contactDepartment` deliberately carry NO `defaultValue`,\n     * and the asymmetry with `memberSource` is the point. No condition in this\n     * flow reads either one \u2014 each is a `get_record` `filter` operand \u2014 so the\n     * binding analysis in `test/flow-variable-conditions.test.ts` does not\n     * cover them. An unbound one fails the run before the query is made (the\n     * 18.0.0-next.0 filter-operand contract), because an absent condition\n     * widens a query instead of narrowing it. Seeding these two would turn that\n     * loud failure into a silent enrolment of a segment nobody chose; their\n     * `required: true` screen fields are what supply them.\n     */\n    { name: 'leadStatus', type: 'text', isInput: true, isOutput: false },\n    { name: 'contactDepartment', type: 'text', isInput: true, isOutput: false },\n  ],\n\n  nodes: [\n    { id: 'start', type: 'start', label: 'Start', config: { objectName: 'crm_campaign' } },\n    {\n      id: 'screen_1', type: 'screen', label: 'Enrollment Criteria',\n      config: {\n        fields: [\n          {\n            // Prefill DERIVED from the variable, so the default is written\n            // once (on the declaration) rather than restated here \u2014 the\n            // single-authority form. The envelope is evaluated before the\n            // screen goes on the wire, so the client receives the raw value,\n            // the string `leads`, which is what a literal\n            // `defaultValue: 'leads'` used to send.\n            name: 'memberSource', label: 'Enroll', type: 'select', required: true,\n            defaultValue: cel`memberSource`,\n            options: [\n              { label: 'Leads', value: 'leads' },\n              { label: 'Contacts', value: 'contacts' },\n            ],\n          },\n          {\n            name: 'leadStatus', label: 'Enroll leads in status', type: 'select', required: true,\n            defaultValue: 'new',\n            options: [\n              { label: 'New', value: 'new' },\n              { label: 'Contacted', value: 'contacted' },\n              { label: 'Qualified', value: 'qualified' },\n            ],\n          },\n          {\n            // Required, like `leadStatus`, and for the same reason: a blank\n            // segment would reach the filter as an empty string and\n            // silently match the contacts with NO department rather than all of\n            // them. Both branches make the caller name a segment.\n            name: 'contactDepartment', label: 'Enroll contacts in department',\n            type: 'select', required: true, defaultValue: 'executive',\n            options: [\n              { label: 'Executive', value: 'executive' },\n              { label: 'Sales', value: 'sales' },\n              { label: 'Marketing', value: 'marketing' },\n              { label: 'Engineering', value: 'engineering' },\n              { label: 'Support', value: 'support' },\n              { label: 'Finance', value: 'finance' },\n              { label: 'Human Resources', value: 'hr' },\n              { label: 'Operations', value: 'operations' },\n            ],\n          },\n        ],\n      },\n    },\n    {\n      id: 'get_campaign', type: 'get_record', label: 'Get Campaign',\n      config: { objectName: 'crm_campaign', filter: { id: cel`recordId` }, outputVariable: 'campaignRecord' },\n    },\n    {\n      // The gate itself is on edges `e4` / `e7` \u2014 see the notes there. This node\n      // carries NO `config.condition`: the key is the trigger gate on a `start`\n      // node and is read nowhere else, so a copy here would be a second, inert\n      // statement of the predicate that no reader can tell apart from the live\n      // one (flagged by `flow-inert-node-condition` from 17.0.0-rc.2).\n      id: 'check_campaign_open', type: 'decision', label: 'Campaign Open?',\n    },\n    {\n      id: 'query_leads', type: 'get_record', label: 'Find Eligible Leads',\n      config: {\n        objectName: 'crm_lead',\n        filter: {\n          status: cel`leadStatus`,\n          is_converted: false,\n          email: { $ne: null },\n          // This is email-campaign enrollment \u2014 honour the opt-out flag.\n          // `campaign_member_optout_sync` populates it: an unsubscribed member\n          // round-trips to the person's `email_opt_out`.\n          email_opt_out: false,\n        },\n        limit: 1000,\n        outputVariable: 'leadList',\n      },\n    },\n    {\n      id: 'loop_leads', type: 'loop', label: 'Process Each Lead',\n      config: {\n        collection: cel`leadList`,\n        iteratorVariable: 'currentLead',\n        body: guarded('lead', {\n          nodes: [\n            {\n              // Dedupe: skip leads already enrolled in THIS campaign, so a\n              // re-run tops up instead of double-enrolling (double rows\n              // inflated num_sent / response_rate).\n              id: 'find_existing_member', type: 'get_record', label: 'Already Enrolled?',\n              config: {\n                objectName: 'crm_campaign_member',\n                filter: { crm_campaign: cel`recordId`, crm_lead: cel`currentLead.id` },\n                outputVariable: 'existingMember',\n              },\n            },\n            {\n              // Gateway only \u2014 the predicate lives on the out-edge.\n              id: 'check_not_enrolled', type: 'decision', label: 'New Member?',\n            },\n            {\n              // \u2B50 The INSERT is elevated, this flow is NOT. `added_date` is\n              // `readonly: true`, and from @objectstack/objectql 17.4.0 the\n              // readonly strip runs inside `engine.insert` for a non-system\n              // caller as well as on update \u2014 so a write from this screen\n              // flow's user context now loses the stamp. The remedy the\n              // platform names is a system context; the remedy AGENTS.md house\n              // rule 9 names is a dedicated `system` sub-flow rather than\n              // elevating the screen flow. Both are satisfied here. \u26D4 Do not\n              // fold this back by giving THIS flow `runAs: 'system'`: it would\n              // also lift RLS off `query_leads` / `query_contacts`, and\n              // `crm_lead` is `sharingModel: 'private'`.\n              // See `src/marketing/flows/campaign-member-enroll.flow.ts`.\n              id: 'create_campaign_member', type: 'subflow', label: 'Add to Campaign',\n              config: {\n                flowName: 'campaign_lead_member_enroll',\n                input: { campaignId: cel`recordId`, leadId: cel`currentLead.id` },\n              },\n            },\n          ],\n          edges: [\n            { id: 'b1', source: 'find_existing_member', target: 'check_not_enrolled', type: 'default' },\n            // Already enrolled \u2192 no edge \u2192 next lead. This edge is the ONLY\n            // site for the predicate: a `decision` node's singular\n            // `config.condition` is never read, so a node copy would be inert.\n            { id: 'b2', source: 'check_not_enrolled', target: 'create_campaign_member', type: 'conditional', condition: P`existingMember == null`, label: 'Enroll' },\n          ],\n        }),\n      },\n    },\n    {\n      id: 'query_contacts', type: 'get_record', label: 'Find Eligible Contacts',\n      config: {\n        objectName: 'crm_contact',\n        filter: {\n          department: cel`contactDepartment`,\n          email: { $ne: null },\n          // Same opt-out honour as the lead branch. There is no `is_converted`\n          // twin here: a contact IS the converted end state.\n          email_opt_out: false,\n        },\n        limit: 1000,\n        outputVariable: 'contactList',\n      },\n    },\n    {\n      id: 'loop_contacts', type: 'loop', label: 'Process Each Contact',\n      config: {\n        collection: cel`contactList`,\n        iteratorVariable: 'currentContact',\n        body: guarded('contact', {\n          nodes: [\n            {\n              // Dedupe scoped on `crm_contact`, so a person enrolled as a LEAD\n              // and again as a CONTACT is not treated as a duplicate: those are\n              // two records of two different relationships, and the seed\n              // datasets key them separately for the same reason.\n              id: 'find_existing_contact_member', type: 'get_record', label: 'Already Enrolled?',\n              config: {\n                objectName: 'crm_campaign_member',\n                filter: { crm_campaign: cel`recordId`, crm_contact: cel`currentContact.id` },\n                outputVariable: 'existingContactMember',\n              },\n            },\n            {\n              // Gateway only \u2014 the predicate lives on the out-edge.\n              id: 'check_contact_not_enrolled', type: 'decision', label: 'New Member?',\n            },\n            {\n              // The contact mirror of `create_campaign_member` above \u2014 same\n              // elevation, same reason. See that node's note.\n              id: 'create_contact_member', type: 'subflow', label: 'Add Contact to Campaign',\n              config: {\n                flowName: 'campaign_contact_member_enroll',\n                input: { campaignId: cel`recordId`, contactId: cel`currentContact.id` },\n              },\n            },\n          ],\n          edges: [\n            { id: 'c1', source: 'find_existing_contact_member', target: 'check_contact_not_enrolled', type: 'default' },\n            { id: 'c2', source: 'check_contact_not_enrolled', target: 'create_contact_member', type: 'conditional', condition: P`existingContactMember == null`, label: 'Enroll' },\n          ],\n        }),\n      },\n    },\n    { id: 'end', type: 'end', label: 'End' },\n  ],\n\n  edges: [\n    { id: 'e1', source: 'start', target: 'screen_1', type: 'default' },\n    { id: 'e2', source: 'screen_1', target: 'get_campaign', type: 'default' },\n    { id: 'e3', source: 'get_campaign', target: 'check_campaign_open', type: 'default' },\n    // Closed campaign \u2192 no edge \u2192 flow ends without enrolling.\n    //\n    // THE live gate, on the EDGES and only here. A `decision` node's singular\n    // `config.condition` is never read by the engine.\n    //\n    // Only enroll into campaigns that are actually running (or planned):\n    // topping up a completed/aborted campaign would corrupt its recorded\n    // metrics. (Status values: planning / in_progress / completed / aborted.)\n    //\n    // TOTALITY: `has(vars.campaignRecord)` first, then\n    // `has(vars.campaignRecord.status)`. `campaignRecord` is a `get_record`\n    // OUTPUT, and `findOne` answers a miss with `null` \u2014 so a campaign that was\n    // deleted (or hidden by sharing) between the action click and this node\n    // leaves the variable bound to null, and an unguarded read aborts with\n    // `No such key: status`, recording the run `failed` with not one lead\n    // enrolled. `status` is `required` on `crm_campaign` today so the column is\n    // never sparse \u2014 but that is the neighbouring schema doing the work, not\n    // this predicate, so it is guarded too.\n    //\n    // TWO conditional out-edges, one per member side. The open-campaign clause\n    // is repeated on both rather than hoisted to a second decision node: the\n    // gate IS the edge predicate here, so a separate \"which side\" node would\n    // need its own out-edges carrying the same clause anyway, and a node\n    // stating it once in `config.condition` is inert.\n    { id: 'e4', source: 'check_campaign_open', target: 'query_leads', type: 'conditional', condition: P`has(vars.campaignRecord) && has(vars.campaignRecord.status)\n      && (vars.campaignRecord.status == \"planning\" || vars.campaignRecord.status == \"in_progress\")\n      && vars.memberSource != \"contacts\"`, label: 'Open \u00B7 Leads' },\n    { id: 'e5', source: 'query_leads', target: 'loop_leads', type: 'default' },\n    { id: 'e6', source: 'loop_leads', target: 'end', type: 'default' },\n    // The contact branch. `memberSource` carries no `has()` guard on either\n    // edge, deliberately: its `flow.variables` declaration carries\n    // `defaultValue: 'leads'`, which the engine seeds before the start node, so\n    // it is bound on every path that reaches here \u2014 and on the ordinary resume\n    // path the server has already refused any signal that omitted the\n    // `required` screen field. A guard would have buried the policy (\"no answer\n    // means leads\") inside a predicate and left the graph defect in place \u2014 see\n    // test/flow-variable-conditions.test.ts.\n    { id: 'e7', source: 'check_campaign_open', target: 'query_contacts', type: 'conditional', condition: P`has(vars.campaignRecord) && has(vars.campaignRecord.status)\n      && (vars.campaignRecord.status == \"planning\" || vars.campaignRecord.status == \"in_progress\")\n      && vars.memberSource == \"contacts\"`, label: 'Open \u00B7 Contacts' },\n    { id: 'e8', source: 'query_contacts', target: 'loop_contacts', type: 'default' },\n    { id: 'e9', source: 'loop_contacts', target: 'end', type: 'default' },\n  ],\n};\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/marketing/flows/campaign-member-enroll.flow.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/marketing/flows\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/marketing/flows/campaign-member-enroll.flow.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport { cel } from '@objectstack/spec';\nimport type * as Automation from '@objectstack/spec/automation';\ntype Flow = Automation.Flow;\n\n/**\n * The campaign-membership INSERT \u2014 the one elevated step behind Enroll Members.\n *\n * ## Why these two flows exist\n *\n * `crm_campaign_member.added_date` is `readonly: true`: nobody is meant to\n * hand-edit when a membership was created.\n *\n * \u2B50 From `@objectstack/objectql` 17.4.0 the readonly strip covers INSERT as\n * well as UPDATE, which is the reason this file exists. Its changelog states\n * the BREAKING behaviour change: *\"a static `readonly` field is now stripped\n * from a **non-system caller's INSERT payload inside `engine.insert`**, exactly\n * as it already was on `engine.update`\"*, and it names the remedy in the same\n * sentence \u2014\n * *\"Seeding a read-only column at create time is a **system** act \u2014 use\n * `context.isSystem`, a flow's `runAs: 'system'`, a system hook or a seed.\"*\n * `objectstack validate` says the same thing at author time through\n * `flow-update-readonly-field`.\n *\n * \u26D4 The remedy is NOT to elevate `campaign_enrollment`. That flow is a screen\n * flow a marketer launches from a campaign record, and `AGENTS.md` house rule 9\n * (\"Elevate as little as possible\") is explicit: *\"A screen\n * flow stays `runAs: 'user'`. A write that genuinely needs elevation is split\n * into a dedicated `system` sub-flow and called through a `subflow` node. \u26D4 Do\n * not elevate a whole flow to make `readonly` take effect.\"* Elevating the\n * parent would also lift row-level security off its two bulk reads \u2014 and\n * `crm_lead` is `sharingModel: 'private'`, so a rep clicking Enroll Members\n * would silently enroll the whole organisation's lead pool instead of the leads\n * they can see. That is a product change, not a migration.\n *\n * So the shape is the one `case_escalation_stamp` already uses for\n * `escalate_case`: the parent keeps the marketer's identity for the campaign\n * read, the eligibility queries and the per-member dedupe, and hands ONLY the\n * insert to a dedicated `runAs: 'system'` callee.\n *\n * ELEVATION IS NOT ANONYMITY: `resolveRunDataContext`\n * returns `{ isSystem: true, actor, ...userId }` for a `runAs: 'system'` run, so\n * the membership row is still attributed to the marketer who enrolled it \u2014 only\n * the readonly strip's `if (!opCtx.context?.isSystem)` branch is skipped.\n *\n * ## Two flows, not one branching flow\n *\n * `create_record`'s `fields` map is static, and the lead branch and the contact\n * branch write DIFFERENT lookup columns (`crm_lead` vs `crm_contact`) \u2014 the\n * dedupe in the parent is scoped that way on purpose, because a person enrolled\n * as a lead and again as a contact is two memberships, not a duplicate. A\n * single callee would need a decision node routing on which id happened to be\n * supplied, which is a second place to get that distinction wrong. Two callees\n * with no branching at all say it once each.\n *\n * ## \u26D4 What these flows deliberately do NOT do\n *\n * They insert one membership row and nothing else. The open-campaign gate, the\n * eligibility filters, the opt-out honour and the already-enrolled dedupe all\n * stay in `campaign_enrollment` under the marketer's context \u2014 moving any of\n * them here would elevate a read that has no business being elevated.\n */\n\n/** Fields both callees write, minus the branch's own person lookup. */\nconst MEMBERSHIP_FIELDS = {\n  status: 'sent',\n  // The readonly stamp this elevation exists for.\n  added_date: cel`isoDatetime(now())`,\n} as const;\n\nexport const CampaignLeadMemberEnrollFlow: Flow = {\n  name: 'campaign_lead_member_enroll',\n  label: 'Enroll Lead in Campaign',\n  description:\n    'Insert one lead campaign-membership row with its readonly added_date stamp, using the system context. Called by campaign_enrollment through a subflow node.',\n  type: 'autolaunched',\n  status: 'active',\n\n  // \u2B50 THE ENTIRE POINT OF THIS FILE \u2014 see the header. One `create_record`.\n  runAs: 'system',\n\n  variables: [\n    // Supplied by the caller's `subflow` node.\n    { name: 'campaignId', type: 'text', isInput: true, isOutput: false },\n    { name: 'leadId', type: 'text', isInput: true, isOutput: false },\n  ],\n\n  nodes: [\n    // `config: {}` \u2014 an autolaunched callee is handed its params by the\n    // `subflow` executor and resolves no trigger record of its own, so there is\n    // no `objectName` for the start node to load. Same shape as\n    // `case_escalation_stamp`, measured in `test/readonly-write-semantics.test.ts`.\n    { id: 'start', type: 'start', label: 'Start', config: {} },\n    {\n      id: 'create_campaign_member', type: 'create_record', label: 'Add to Campaign',\n      config: {\n        objectName: 'crm_campaign_member',\n        // \u26D4 Do not add fields here. Every column in this node is written with\n        // the elevated context; anything a marketer may legitimately type\n        // belongs in `campaign_enrollment` instead.\n        fields: { crm_campaign: cel`campaignId`, crm_lead: cel`leadId`, ...MEMBERSHIP_FIELDS },\n      },\n    },\n    { id: 'end', type: 'end', label: 'End' },\n  ],\n\n  edges: [\n    { id: 'e1', source: 'start', target: 'create_campaign_member', type: 'default' },\n    { id: 'e2', source: 'create_campaign_member', target: 'end', type: 'default' },\n  ],\n};\n\nexport const CampaignContactMemberEnrollFlow: Flow = {\n  name: 'campaign_contact_member_enroll',\n  label: 'Enroll Contact in Campaign',\n  description:\n    'Insert one contact campaign-membership row with its readonly added_date stamp, using the system context. Called by campaign_enrollment through a subflow node.',\n  type: 'autolaunched',\n  status: 'active',\n\n  runAs: 'system',\n\n  variables: [\n    { name: 'campaignId', type: 'text', isInput: true, isOutput: false },\n    { name: 'contactId', type: 'text', isInput: true, isOutput: false },\n  ],\n\n  nodes: [\n    { id: 'start', type: 'start', label: 'Start', config: {} },\n    {\n      id: 'create_contact_member', type: 'create_record', label: 'Add Contact to Campaign',\n      config: {\n        objectName: 'crm_campaign_member',\n        fields: { crm_campaign: cel`campaignId`, crm_contact: cel`contactId`, ...MEMBERSHIP_FIELDS },\n      },\n    },\n    { id: 'end', type: 'end', label: 'End' },\n  ],\n\n  edges: [\n    { id: 'e1', source: 'start', target: 'create_contact_member', type: 'default' },\n    { id: 'e2', source: 'create_contact_member', target: 'end', type: 'default' },\n  ],\n};\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/marketing/flows/campaign-completion.flow.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/marketing/flows\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/marketing/flows/campaign-completion.flow.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport { cel } from '@objectstack/spec';\nimport type * as Automation from '@objectstack/spec/automation';\nimport { guarded } from '../../sales/flows/_guarded-iteration';\ntype Flow = Automation.Flow;\n\n/**\n * Campaign auto-completion \u2014 scheduled daily sweep.\n *\n * Each night it flips `in_progress` campaigns whose `end_date` has passed to\n * `completed` \u2014 a `status` transition, which is one of the triggers\n * `campaign_metrics_refresh` (`campaign.hook.ts`) recomputes the metric block\n * on.\n *\n * \u26A0\uFE0F That is a REFRESH, not a snapshot. The block is kept live by four refresh\n * hooks \u2014 `campaign_metrics_refresh`, `campaign_attribution_refresh`,\n * `campaign_lead_conversion_refresh` and `campaign_member_metrics_refresh` \u2014 so\n * this sweep is not the moment the numbers arrive, just one more transition\n * over numbers that were already current.\n */\nexport const CampaignCompletionFlow: Flow = {\n  name: 'campaign_completion',\n  label: 'Campaign Auto-Completion',\n  description: 'Daily: mark in_progress campaigns whose end_date has passed as completed.',\n  type: 'schedule',\n  status: 'active',\n  // Scheduled runs have no trigger user, so under the default runAs:'user' the\n  // data nodes execute UNSCOPED anyway. Declare runAs:'system' to make that\n  // RLS-bypassing elevation explicit and intended (ADR-0049).\n  runAs: 'system',\n  variables: [],\n  nodes: [\n    { id: 'start', type: 'start', label: 'Start (daily 02:00)', config: { schedule: '0 2 * * *' } },\n    {\n      id: 'query_campaigns', type: 'get_record', label: 'Find Ended Campaigns',\n      config: {\n        objectName: 'crm_campaign',\n        filter: { status: 'in_progress', end_date: { $lt: cel`isoDate(today())` } },\n        limit: 500,\n        outputVariable: 'campaignList',\n      },\n    },\n    {\n      id: 'loop_campaigns', type: 'loop', label: 'For Each Campaign',\n      config: {\n        collection: cel`campaignList`,\n        iteratorVariable: 'currentCampaign',\n        body: guarded('campaign', {\n          nodes: [\n            {\n              id: 'mark_completed', type: 'update_record', label: 'Mark Completed',\n              config: { objectName: 'crm_campaign', filter: { id: cel`currentCampaign.id` }, fields: { status: 'completed' } },\n            },\n          ],\n          edges: [],\n        }),\n      },\n    },\n    { id: 'end', type: 'end', label: 'End' },\n  ],\n  edges: [\n    { id: 'e1', source: 'start', target: 'query_campaigns', type: 'default' },\n    { id: 'e2', source: 'query_campaigns', target: 'loop_campaigns', type: 'default' },\n    { id: 'e3', source: 'loop_campaigns', target: 'end', type: 'default' },\n  ],\n};\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/sales/skills/lead-qualification.skill.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/sales/skills\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/sales/skills/lead-qualification.skill.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport { defineSkill } from '@objectstack/spec';\n\n/**\n * Lead Qualification \u2014 score an inbound lead with BANT, then act on it.\n *\n * ADR-0109: scoring is judgement, not a tool call. The lead is read\n * with the platform's data tools; the two outcomes that change state\n * (`convert_lead`, `schedule_followup`) are HotCRM's own Actions,\n * reached through their materialised `action_<name>` tools.\n *\n * Auto-activates when the user is viewing a lead record so the LLM\n * surfaces the capability without the user having to ask for it.\n */\nexport const LeadQualificationSkill = defineSkill({\n  name: 'lead_qualification',\n  label: 'Lead Qualification',\n  description: 'Qualifies inbound leads using BANT criteria and assigns a 0\u2013100 score.',\n\n  instructions: `When the user asks to qualify, score, or analyse a lead:\n\n1. Read the lead \u2014 \\`describe_object\\` for \\`crm_lead\\` first (fields\n   change), then \\`get_record\\`. Use \\`query_records\\` to pull the\n   related activity history when the lead has any.\n2. Score it yourself, 0\u2013100, with BANT. There is no scoring tool:\n   Budget (is spend confirmed or inferable from company size?),\n   Authority (is the contact a decision maker?), Need (is there a\n   stated problem you solve?), Timeline (is there a date?). Weight\n   them evenly unless the user says otherwise.\n3. Report the score, one line of justification per BANT dimension\n   naming the field or activity you read, and the single recommended\n   next step. Cite the lead ID.\n4. Score >= 70 and the user agrees \u2192 call \\`action_convert_lead\\`.\n5. Otherwise, or when the user wants to nurture, call\n   \\`action_schedule_followup\\` with the date you recommend. Say why\n   that date.\n6. Never convert without explicit confirmation \u2014 conversion is not\n   reversible from this surface.`,\n\n  tools: [\n    'describe_object',\n    'get_record',\n    'query_records',\n    'action_convert_lead',\n    'action_schedule_followup',\n  ],\n\n  triggerConditions: [\n    { field: 'objectName', operator: 'eq', value: 'crm_lead' },\n  ],\n});\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/sales/skills/email-drafting.skill.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/sales/skills\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/sales/skills/email-drafting.skill.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport { defineSkill } from '@objectstack/spec';\n\n/**\n * Email Drafting \u2014 write the copy, then send it through the real Action.\n *\n * ADR-0109: writing a subject line and personalising a body is what the\n * model does; it is not a tool call. Sending is HotCRM's `send_email`\n * Action, which carries no `ai` block \u2014 ADR-0011 exposure is opt-in and\n * default off, so no `action_send_email` tool is materialised and the\n * skill has nothing to call. The agent therefore drafts and hands over; a\n * human reviews the copy and presses Send. For outbound email that review\n * step is a feature, not a limitation.\n */\nexport const EmailDraftingSkill = defineSkill({\n  name: 'email_drafting',\n  label: 'Email Drafting',\n  description: 'Drafts personalised outbound emails grounded in live contact data, ready for a human to review and send.',\n\n  instructions: `When the user asks to draft, write, or optimise an email:\n\n1. Ground it in real data before writing a word: \\`get_record\\` the\n   contact (and the related account or opportunity when the request\n   references one) so names, titles and recent activity are accurate.\n   Use \\`query_records\\` when you need the recent history.\n2. Write the copy yourself \u2014 subject and body. You do not have, and do\n   not need, a copy-generation tool. Aim for: a subject under 60\n   characters naming the concrete value, a first line referencing\n   something specific to THIS recipient rather than a generic\n   pleasantry, one clear ask, and no more than 150 words.\n3. Offer two subject-line variants, say which you recommend and why,\n   so the user can A/B them.\n4. Show the draft and stop. You cannot send \u2014 say so plainly rather\n   than implying a send is queued.\n5. Point the user at **Send Email** on the contact record, where the\n   subject and body you drafted can be pasted, reviewed and sent.`,\n\n  tools: ['get_record', 'query_records'],\n\n});\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/sales/skills/revenue-forecasting.skill.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/sales/skills\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/sales/skills/revenue-forecasting.skill.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport { defineSkill } from '@objectstack/spec';\n\n/**\n * Revenue Forecasting \u2014 analysis over live pipeline data.\n *\n * ADR-0109: forecasting is the whole point of giving a model\n * aggregation over the user's own records; it is not a bespoke tool.\n * This skill declares no tool records at all \u2014 it composes the\n * platform's `aggregate_data` / `query_records` / `visualize_data`\n * with instructions that carry the actual method.\n */\nexport const RevenueForecastingSkill = defineSkill({\n  name: 'revenue_forecasting',\n  label: 'Revenue Forecasting',\n  description: 'Analyses pipeline health, surfaces at-risk deals, and forecasts revenue from live opportunity data.',\n\n  instructions: `When the user asks about pipeline health, forecast,\nrisk, or deal slippage:\n\n1. Establish the shape first: \\`describe_object\\` for\n   \\`crm_opportunity\\` so you use the CURRENT stage, amount,\n   probability and close-date fields rather than assumed ones.\n2. Summarise the pipeline with \\`aggregate_data\\` \u2014 count and summed\n   amount grouped by stage, scoped to the period the user names\n   (default: the current quarter). Weighted value is amount \u00D7\n   probability; compute it yourself from what you read.\n3. Surface at-risk deals with \\`query_records\\`: close date already\n   past, or no activity in 30+ days, or the stage unchanged for longer\n   than its typical duration. Name each deal and the specific signal.\n4. Forecast by summing weighted value for open deals plus closed-won\n   in the period. State the assumption behind the number in one line,\n   and give a range rather than false precision \u2014 the spread between\n   commit-only (high-probability stages) and full weighted pipeline.\n5. Offer \\`visualize_data\\` when a chart would carry the answer better\n   than prose, e.g. stage distribution or month-over-month trend.\n6. Be quantitative: every claim cites a number or a deal name. If the\n   data cannot support a claim, say so instead of estimating.`,\n\n  tools: ['describe_object', 'aggregate_data', 'query_records', 'visualize_data'],\n\n  triggerConditions: [\n    { field: 'objectName', operator: 'in', value: ['crm_opportunity', 'dashboard'] },\n  ],\n});\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/sales/skills/customer-360.skill.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/sales/skills\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/sales/skills/customer-360.skill.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport { defineSkill } from '@objectstack/spec';\n\n/**\n * Customer 360 \u2014 one profile assembled from the records that already exist.\n *\n * ADR-0109: this skill declares no bespoke tools. Its whole tool list used\n * to be `search_knowledge`, while the instructions promised an account +\n * cases + opportunities + knowledge roll-up it had no tool to read \u2014 it\n * could not fetch a single record.\n *\n * `search_knowledge` is NOT fictional; #557 dropped it on that premise and\n * the premise was wrong. It is a real platform tool \u2014 re-measured\n * 2026-09-10 on the 17.4.0 pin, `PLATFORM_PROVIDED_TOOL_NAMES` lists it\n * (from `@objectstack/spec/system`; the `/ai` subpath does not carry that\n * export) and `spec/src/ai/knowledge-source.zod.ts:143` documents it.\n * Added to `tools` it resolves and lints clean.\n *\n * It is left out because there is nothing else to retrieve from. A\n * knowledge source is not app metadata on 17.4.0 \u2014 sources belong to the\n * knowledge service, and no app of any shape declares one. The knowledge\n * base here is `crm_knowledge_article`, a normal CRM object, so\n * `query_records` reaches it like every other object this skill reads;\n * `content/docs/ai-copilot/knowledge-bases.mdx` is that promise. Revisit\n * if a source becomes declarable \u2014 objectstack#17464 is the trigger.\n */\nexport const Customer360Skill = defineSkill({\n  name: 'customer_360',\n  label: 'Customer 360',\n  description: 'Aggregates account, recent cases, open opportunities, and knowledge hits into a single customer profile.',\n\n  instructions: `When the user asks for \"the full picture\" of a\ncustomer / account / contact:\n\n1. Read the shape first \u2014 \\`describe_object\\` for \\`crm_account\\`, and for\n   each related object before you query it. Admins add fields; never\n   summarise from memory of a previous turn.\n2. \\`get_record\\` the account, then pull the related work with\n   \\`query_records\\`, each filtered to this account:\n   - \\`crm_contact\\` \u2014 who the people are, primary contact first.\n   - \\`crm_case\\` \u2014 cases where \\`is_closed\\` is false, newest first.\n   - \\`crm_opportunity\\` \u2014 open deals with stage, amount and close date.\n   Quote totals from \\`aggregate_data\\` (open pipeline amount, case count\n   by status) rather than adding up rows yourself.\n3. For the policy or playbook context, \\`query_records\\` on\n   \\`crm_knowledge_article\\` \u2014 \\`status\\` published, matched on the\n   \\`category\\` or \\`tags\\` of the cases you just read. You have no\n   knowledge-search tool in this skill and do not need one: the knowledge\n   base is an object like any other.\n4. Summarise into three sections: **Account Snapshot** \u00B7 **Active Work** \u00B7\n   **Risks & Notes**. Every risk names the record and the signal that\n   raised it \u2014 an escalated case, a close date already past, a deal with\n   no activity in 30+ days. Do not infer risk you cannot cite.\n5. Cite record IDs inline (e.g. \"case CASE-01234\", \"article KA-0007\") so\n   the UI can deep link. If a section has no records, say so plainly\n   instead of filling it.`,\n\n  tools: ['describe_object', 'get_record', 'query_records', 'aggregate_data'],\n\n});\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/sales/skills/live-data.skill.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/sales/skills\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/sales/skills/live-data.skill.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport { defineSkill } from '@objectstack/spec';\n\n/**\n * Live Data \u2014 the foundation of HotCRM's \"Wow #1\" demo.\n *\n * Wires the platform's built-in metadata + data tools into the\n * assistant so it always sees the current schema before querying.\n * This is what makes \"add a field, AI uses it 30s later\" actually\n * work \u2014 `describe_object` re-reads metadata on every call.\n */\nexport const LiveDataSkill = defineSkill({\n  name: 'live_data',\n  label: 'Live Data Access',\n  description:\n    'Queries any CRM object using the current live schema. Always inspects the object structure first so newly added fields are picked up immediately.',\n\n  instructions: `When the user asks a question that touches a CRM\nrecord (account, contact, lead, opportunity, case, quote, etc.):\n\n1. **Always** call \\`describe_object\\` for the relevant object FIRST,\n   even if you think you remember the fields. The schema can change\n   between turns \u2014 trust the tool, not your memory.\n2. Use \\`list_objects\\` if you are not sure which object holds the\n   data the user is asking about.\n3. Use \\`query_records\\` (filters, sort, limit) for lists,\n   \\`get_record\\` for a single ID, \\`aggregate_data\\` for sums /\n   counts / averages.\n4. When you reference data, cite the record ID inline so the UI\n   can deep-link (e.g. \"opportunity OPP-1234\").\n5. If \\`describe_object\\` shows a field you've never seen before,\n   USE IT \u2014 that's the user's whole point in adding it. Surface it\n   in your answer when relevant.`,\n\n  tools: [\n    'describe_object',\n    'list_objects',\n    'query_records',\n    'get_record',\n    'aggregate_data',\n  ],\n\n});\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/sales/sharing/account.sharing.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/sales/sharing\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/sales/sharing/account.sharing.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport { P } from '@objectstack/spec';\nimport { TERRITORY } from '../objects/_territory';\n\n/** Share accounts with sales managers/directors based on customer status */\nexport const AccountTeamSharingRule = {\n  name: 'account_team_sharing',\n  label: 'Account Team Sharing',\n  object: 'crm_account',\n  type: 'criteria' as const,\n  condition: P`record.type == \"customer\" && record.is_active == true`,\n  accessLevel: 'edit' as const,\n  sharedWith: { type: 'position' as const, value: 'sales_manager' },\n};\n\n/**\n * Territory-Based Sharing (criteria-based, by declared territory).\n *\n * These filter on `crm_account.territory` \u2014 a declared `select` whose value\n * `account.hook.ts` derives from `billing_address.country` against the one\n * authored mapping in `src/sales/objects/_territory.ts`.\n *\n * ### Two defects, in the order they were fixed\n *\n * 1. The condition used to read `record.billing_address.country`. A sharing\n *    rule's condition is compiled to a pushdown-able filter by\n *    `compileCelToFilter`, which rejects any path reaching inside an `address`\n *    value; `plugin-sharing` then refuses to seed the rule at all rather than\n *    degrade it to match-all, which is how both of these shipped inert for\n *    months while the docs promised they worked (#621). The fix was a FLAT\n *    column, `billing_country`. The `in [...]` operator was never the blocker\n *    \u2014 `test/sharing-seeding.test.ts` measures the whole supported operator\n *    set and fails if any declared rule stops translating.\n *\n * 2. That column is free text, so the rules still matched a TYPED STRING: an\n *    account whose billing country read `United States` matched neither\n *    territory, silently, and the country lists were duplicated across two CEL\n *    strings and six localised documentation tables (#639). The fix is to\n *    match a declared value instead. The country never reaches a rule now, and\n *    the `UK`-vs-`GB` question that could not be fixed in isolation dissolved\n *    with it: both spellings are `emea` in the mapping, so nothing migrated.\n *\n * The literal values below are INTERPOLATED from the declared domain \u2014 `P`\n * quotes an interpolated string, so `record.territory == \"na\"` is what is\n * authored, and renaming a territory value cannot be half-applied.\n * `test/territory-single-source.test.ts` pins the rest of the derivation:\n * every value one of these rules names must be a declared option, and must be\n * reachable from at least one country.\n */\nexport const TerritorySharingRules = [\n  {\n    name: 'north_america_territory',\n    label: 'North America Territory',\n    object: 'crm_account',\n    type: 'criteria' as const,\n    condition: P`record.territory == ${TERRITORY.NA}`,\n    accessLevel: 'edit' as const,\n    sharedWith: { type: 'position' as const, value: 'na_sales_team' },\n  },\n  {\n    name: 'europe_territory',\n    label: 'Europe Territory',\n    object: 'crm_account',\n    type: 'criteria' as const,\n    condition: P`record.territory == ${TERRITORY.EMEA}`,\n    accessLevel: 'edit' as const,\n    sharedWith: { type: 'position' as const, value: 'eu_sales_team' },\n  },\n];\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/sales/sharing/opportunity.sharing.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/sales/sharing\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/sales/sharing/opportunity.sharing.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport { P } from '@objectstack/spec';\nimport { LARGE_DEAL_AMOUNT } from '../objects/_thresholds';\n\n/**\n * Share high-value open opportunities with the sales director.\n * ADR-0090 D3: `role_and_subordinates` is gone (positions are flat); the\n * grant now targets the director position itself.\n */\nexport const OpportunitySalesSharingRule = {\n  name: 'opportunity_sales_sharing',\n  label: 'Opportunity Sales Team Sharing',\n  object: 'crm_opportunity',\n  type: 'criteria' as const,\n  condition: P`!(record.stage in [\"closed_won\", \"closed_lost\"]) && record.amount >= ${LARGE_DEAL_AMOUNT}`,\n  accessLevel: 'read' as const,\n  sharedWith: { type: 'position' as const, value: 'sales_director' },\n};\n\n/**\n * The same large-deal visibility one rung up.\n *\n * Positions are FLAT (ADR-0090 D3): nothing rolls the director's grant up to the\n * executive rung, so the rule that gives leadership its pipeline view has to be\n * authored per position. Same criteria, same read-only level \u2014 an executive\n * reads the deal, the deal team still owns it.\n */\nexport const OpportunityExecutiveSharingRule = {\n  name: 'opportunity_executive_sharing',\n  label: 'Large Open Deals \u2014 Executive',\n  object: 'crm_opportunity',\n  type: 'criteria' as const,\n  condition: P`!(record.stage in [\"closed_won\", \"closed_lost\"]) && record.amount >= ${LARGE_DEAL_AMOUNT}`,\n  accessLevel: 'read' as const,\n  sharedWith: { type: 'position' as const, value: 'executive' },\n};\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/sales/sharing/positions.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/sales/sharing\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/sales/sharing/positions.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\n/**\n * CRM Positions (ADR-0090 D3 \u2014 formerly the role hierarchy).\n *\n * Positions are deliberately FLAT: no parent, no hierarchy. The v1 role\n * tree's reporting lines belong on the business-unit tree / manager chain,\n * which this app does not model \u2014 so the old `parentRole` links were\n * dropped rather than translated.\n *\n * Flat also means visibility does NOT roll up: every rung that needs access to\n * a record carries its own sharing rule. That is why each leadership rung has\n * an explicit companion rule (`opportunity_executive_sharing`,\n * `case_director_sharing`, `campaign_leadership_*`) rather than inheriting the\n * manager's \u2014 a position that no sharing rule and no permission-set binding\n * names grants nothing at all (#488).\n */\nexport const CrmPositions = [\n  { name: 'executive',          label: 'Executive' },\n  { name: 'sales_director',     label: 'Sales Director' },\n  { name: 'sales_manager',      label: 'Sales Manager' },\n  { name: 'sales_rep',          label: 'Sales Representative' },\n  { name: 'service_director',   label: 'Service Director' },\n  { name: 'service_manager',    label: 'Service Manager' },\n  { name: 'service_agent',      label: 'Service Agent' },\n  { name: 'marketing_director', label: 'Marketing Director' },\n  { name: 'marketing_manager',  label: 'Marketing Manager' },\n  { name: 'marketing_user',     label: 'Marketing User' },\n  // Territory groupings referenced by the account sharing rules.\n  { name: 'na_sales_team',      label: 'NA Sales Team' },\n  { name: 'eu_sales_team',      label: 'EU Sales Team' },\n];\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/marketing/sharing/campaign.sharing.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/marketing/sharing\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/marketing/sharing/campaign.sharing.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport { P } from '@objectstack/spec';\n\n/**\n * Campaign leadership sharing.\n *\n * `crm_campaign` is `public_read` (`src/marketing/objects/campaign.object.ts`), so the OWD\n * baseline already hands READ to everyone holding object-level read on it: a\n * marketing manager or director opens any campaign with or without this file.\n * What `public_read` does NOT hand out is WRITE. `@objectstack/plugin-sharing`\n * 17.0.0-rc.2 states the boundary in `buildWriteFilter`'s own comment \u2014 the\n * editable set \"applies to BOTH `private` and `read` (public_read) models \u2014\n * public_read is read-open but write-owned; only a fully `public` object is\n * write-open\" \u2014 i.e. owner-match OR records shared at a write access level.\n *\n * These two rules are that second branch, and `accessLevel: 'edit'` is the part\n * doing the work: they let a marketing manager / director EDIT a live campaign a\n * specialist owns, rather than having to take ownership of it. Nor does the\n * `marketing_user` permission set make them redundant \u2014 its\n * `marketing_campaign_updates` RLS policy (`id != null`) widens the RLS layer\n * only, and the sharing layer's write-owned baseline still refuses the update.\n *\n * MEASURED on 17.0.0-rc.2 against this app's own metadata (#724), for a user\n * holding the `marketing_user` set plus position `marketing_manager` and owning\n * no campaign: reads return EVERY campaign at all times; before these rules\n * materialise, `buildWriteFilter` is `{ owner_id: specialist }` and updating a\n * specialist-owned campaign is FORBIDDEN; after, the filter gains\n * `{ id: { $in: [live campaign] } }` and the same update succeeds, while the\n * completed campaign stays FORBIDDEN. So deleting these rules costs the two\n * rungs their only edit path and changes nothing about what they can READ \u2014\n * which is exactly what makes the loss easy to miss.\n *\n * ADR-0090 D3 positions are FLAT (no hierarchy to roll visibility up), so each\n * rung that needs the access carries its own grant. Scoped to live campaigns:\n * finished ones stay with their owner and the analytics surfaces that report on\n * them.\n */\nexport const CampaignLeadershipSharingRules = [\n  {\n    name: 'campaign_leadership_manager',\n    label: 'Live Campaigns \u2014 Marketing Manager',\n    object: 'crm_campaign',\n    type: 'criteria' as const,\n    condition: P`record.status in [\"planning\", \"in_progress\"] && record.is_active == true`,\n    accessLevel: 'edit' as const,\n    sharedWith: { type: 'position' as const, value: 'marketing_manager' },\n  },\n  {\n    name: 'campaign_leadership_director',\n    label: 'Live Campaigns \u2014 Marketing Director',\n    object: 'crm_campaign',\n    type: 'criteria' as const,\n    condition: P`record.status in [\"planning\", \"in_progress\"] && record.is_active == true`,\n    accessLevel: 'edit' as const,\n    sharedWith: { type: 'position' as const, value: 'marketing_director' },\n  },\n];\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/sales/data/sales.seed.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/sales/data\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/sales/data/sales.seed.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\n/**\n * Sales seeds \u2014 accounts, contacts, leads and opportunities.\n *\n * Split out of the former monolithic `src/data/index.ts` (#635). Seed doctrine\n * lives in `./_shared.ts`.\n *\n * `OPPORTUNITY_LINES` stays here, with the deals it prices: `dealValue()`\n * derives every opportunity's `amount` from it. The line-item ROWS it also\n * feeds are `crm_opportunity_line_item`, a revenue object, so they are seeded\n * from `src/revenue/data/opportunity-line-item.seed.ts`, which reads this\n * table along the revenue -> sales edge.\n */\nimport { defineSeed } from '@objectstack/spec/data';\nimport { cel } from '@objectstack/spec';\nimport { Account } from '../objects/account.object';\nimport { Contact } from '../objects/contact.object';\nimport { Lead } from '../objects/lead.object';\nimport { Opportunity } from '../objects/opportunity.object';\nimport { celDaysAgo, linesTotal, type LineSpec } from './_shared';\n\n// \u2500\u2500\u2500 Accounts \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n//\n// `billing_address` is load-bearing demo data, not decoration (#638). The two\n// territory sharing rules filter on `crm_account.billing_country` \u2014 the flat\n// projection `account_protection` derives from `billing_address.country` \u2014 so\n// an account with no address belongs to no territory. Until now not one seeded\n// account carried an address, which meant #621 shipped two territory rules\n// that installed correctly and then matched zero records: Setup listed two\n// territories with nothing behind them.\n//\n// The nine accounts partition deliberately across all THREE outcomes the rules\n// can produce, so a demo shows the split instead of asserting it:\n//\n//   north_america_territory  territory == \"na\"     \u2192 6  (5 \u00D7 US, 1 \u00D7 CA)\n//   europe_territory         territory == \"emea\"   \u2192 2  (DE, UK)\n//   neither territory        territory == \"other\"  \u2192 1  (SG)\n//\n// The rules match `territory`, a declared select the hook classifies the\n// address country into (#639) \u2014 no rule compares a country string any more.\n// `country` still carries the 2-LETTER CODE here: seed addresses keep to ISO\n// 3166-1 alpha-2 as a data-quality convention, and the spelling table in\n// `src/sales/objects/_territory.ts` exists for what USERS type, not for what this\n// file authors.\n//\n// `UK` on the London account is the one deliberate exception, and it is now\n// load-bearing rather than merely historical: `UK` is an ACCEPTED SPELLING of\n// `GB` in that table, so this row is the stock-data proof that the alias path\n// works end to end. Correcting it to `GB` would delete that coverage \u2014 and the\n// eviction #639 was worried about cannot happen, because both spellings are\n// `emea`.\n//\n// `billing_country` and `territory` are both deliberately NOT authored here.\n// Hooks DO run over seed writes (#617, corrected in `./_shared.ts`), so both\n// are computed at seed time; the field is `readonly` and hook-owned, and a\n// hand-copied value would be a second source of truth for something\n// `account_protection` already maintains \u2014 the exact drift the doctrine block\n// exists to prevent. `test/territory-seed-coverage.test.ts` pins the dependency\n// from the other side: every seeded address must carry a country the\n// projection can turn into the territory bucket claimed above.\n//\n// Phone numbers moved with the addresses: a Munich account answering a Denver\n// number is the kind of incoherence an evaluator notices before the feature.\n//\n// \u2500\u2500\u2500 `last_activity_date`: the churn clock, and who is allowed to set it \u2500\u2500\u2500\n//\n// The three \"Quiet 30 / 60 / 90+ Days\" tiles on the Sales Activity dashboard,\n// `at_risk_accounts` and `customer_churn_signals` all window this one column,\n// so the demo needs a real DISTRIBUTION across the three bands \u2014 not the\n// cluster inside a fortnight it used to be, which left every churn surface\n// empty while the data looked populated (#671).\n//\n// Authoring it here is legitimate, and the boundary is worth stating because it\n// is NOT the `billing_country` case three paragraphs up (doctrine rule 3 in\n// `./_shared.ts`). `billing_country` is `readonly` and DERIVED \u2014 the hook\n// recomputes it from `billing_address` on every write that carries one, so a\n// seeded copy would be a second source of truth for a value nothing else owns.\n// `last_activity_date` is neither: #592 removed the `readonly` flag precisely\n// so hooks could write it, and no hook derives it from anything on the account.\n// It is a HISTORICAL fact \u2014 \"when did anyone last speak to this customer\" \u2014 and\n// authoring history into a field whose writers only ever stamp the current date\n// is doctrine rule 1, the same licence `stage_entry_date` and the case seeds'\n// `created_at` already use.\n//\n// What the writers DO impose is a constraint on the events seeded beside these\n// rows, and it decides the whole layout below. Lifecycle hooks run over seed\n// writes (#617), and two of them stamp TODAY on an account:\n//\n//   \u00B7 `event_activity_bubble` \u2014 on any `held` event, walking up from its\n//     contact / opportunity / case (`src/sales/objects/event.hook.ts`);\n//   \u00B7 `task_activity_bubble`  \u2014 on any task seeded already completed.\n//\n// Neither reads the activity's own timestamp: a `held` meeting seeded 45 days\n// ago still stamps the day the demo was seeded. So an account may carry an\n// authored age ONLY if nothing in the seed book bubbles to it; otherwise the\n// authored value is overwritten at seed time and the demo shows something\n// nobody wrote (doctrine rule 2). Hence the three-way split:\n//\n//   today()   Acme, Wayne, Vertex, Stark \u2014 every account something in the seed\n//             book bubbles to. Acme / Wayne / Vertex carry `held` events;\n//             Stark carries the completed welcome-package task, which has\n//             bubbled since long before this issue (its authored `daysAgo(5)`\n//             was being silently overwritten). Authored as today because that\n//             is exactly what the bubble writes, so the value is right whether\n//             or not hooks fire.\n//   6\u20138 days  Lattice, Globex \u2014 recency from channels this seed book does not\n//             model (an email thread, a signature). They carry only `planned`\n//             and `cancelled` events, neither of which bubbles.\n//   41/72/104 Northwind, Initech, Apex \u2014 one per churn band. Nothing held\n//             reaches them; each carries a BOOKED re-engagement meeting\n//             instead, which is #592's whole point: a meeting on the calendar\n//             is not an interaction that happened, and only `held` moves the\n//             clock. Internal pipeline motion (a `stage_entry_date`) is not\n//             customer contact either, which is why a stagnating deal can sit\n//             on a silent account \u2014 that pairing is what the stagnation sweep\n//             and the churn tiles are each looking at from one side.\n//\n// `test/activity-seed-coverage.test.ts` recomputes the bubble's reachability\n// from the seeds themselves and fails if a held event ever reaches one of the\n// three quiet accounts, so the split above cannot rot into a comment.\n//\n// \u2500\u2500\u2500 `health_score`: the churn signal a HUMAN asserts \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n//\n// Four options ship (`healthy` / `watching` / `at_risk` / `churning`) and the\n// churn report's first panel, `csm_flagged_accounts`, selects the worst two.\n// That panel is the ONLY one on the report with no time window, so the\n// population it exists for is an account being worked right now and still\n// flagged. The seed book has to contain one, or the demo renders a panel that\n// merely restates the 60-day window stacked below it (#1414). Hence a\n// deliberate three-way split, the same shape as the territory and activity\n// partitions above:\n//\n//   Initech  `at_risk`  + 72 days quiet \u2014 flagged AND derived. It lands in\n//            this panel and in `at_risk_accounts`; the report's own header\n//            says the two blocks are allowed to overlap.\n//   Wayne    `churning` + clock at today() \u2014 flagged and NOT derived. Its\n//            `strategic` tier is inside `silent_high_value`'s scope as well,\n//            so the clock alone keeps it out of BOTH windowed panels: the\n//            account no derived signal can see. It is what makes the set\n//            difference FLAGGED \\ QUIET60 non-empty.\n//   Stark    `at_risk`  + clock at today(), and NOT a customer \u2014 the row the\n//            panel's `rows: ['type']` grouping exists for (#1647). While every\n//            flagged account was a `customer` the grouping rendered a single\n//            row and could demonstrate nothing; the grid view\n//            `crm_account.at_risk_accounts` filters `type == 'customer'`\n//            before anything else, so a flagged PARTNER is a row the report\n//            block can show and that grid cannot.\n//\n// The other customers stay `healthy` on purpose. A severity every record\n// carries demonstrates nothing, and `churning` is the most severe option in\n// the model \u2014 one record is what makes it real rather than declared.\n//\n// The three PROSPECTS carry no `health_score` at all, and that blank is a\n// stated choice rather than an oversight: the column is what a CSM asserts\n// about a RELATIONSHIP, and nobody has been in the room with an account that\n// was never won. The criterion `$in [at_risk, churning]` does not match an\n// absent value, so a blank row is outside the panel either way \u2014 it says\n// \"nobody has assessed this\", which is exactly true of a prospect.\n//\n// \u2500\u2500\u2500 `approval_status`: every seeded account is already signed off \u2500\u2500\u2500\u2500\u2500\n//\n// Each row below states `approval_status: 'approved'`, and it has to. On a real\n// insert the column is born blank and `account_approval` submits it (REQ-0003;\n// the request's mirror writes `pending`, #2067). A seed row never reaches that\n// flow: the platform writes every seed row with `skipTriggers`\n// (`SEED_WRITE_EXECUTION_CONTEXT`, `@objectstack/spec`), because a seed is\n// established END-STATE data, not a user event. Left unstated, a row would\n// claim no sign-off at all; under the former `pending` default it read\n// `pending` with no request behind it, the console showed \"Locked for\n// approval\" and disabled Edit, and no admin could edit a seeded account\n// (#2042). These accounts carry deals, contracts and cases; they are past\n// their sign-off, so the row says so.\n// \u26D4 Do not \"fix\" it with an `approved` field default instead: that switches\n// the gate off for every account a user creates.\nexport const accounts = defineSeed(Account, {\n  mode: 'upsert',\n  externalId: 'name',\n  records: [\n    {\n      name: 'Acme Corporation',\n      approval_status: 'approved',\n      type: 'customer',\n      industry: 'technology',\n      annual_revenue: 5000000,\n      number_of_employees: 250,\n      phone: '+1-415-555-0100',\n      billing_address: { street: '500 Howard Street, Suite 400', city: 'San Francisco', state: 'CA', postalCode: '94105', country: 'US' },\n      website: 'https://acme.example.com',\n      tier: 'enterprise',\n      segment: 'growth',\n      health_score: 'healthy',\n      // Held: workshop, demo, calls and an onsite visit \u2014 see `service.seed.ts`.\n      last_activity_date: cel`today()`,\n      // The ARR line below used to read \"signed Q1 2025 renewal\" while the\n      // deal it describes closes `daysAgo(15)` \u2014 a fixed calendar quarter on a\n      // relative-date record, wrong in both the quarter and the year (#1692).\n      // The label is not re-derived here either: that date belongs to\n      // `Acme Annual Renewal 2025` (`close_date`) and to its contract\n      // (`signed_date`, `revenue.seed.ts`), and computing a copy in this module\n      // means re-stating that record's own offset \u2014 a second source of truth\n      // for a value two records already own. Same ruling as the `next_step`\n      // block below (#1660): no date goes back into this prose, absolute OR\n      // relative. What stays true however the renewal is dated is that it IS\n      // signed: the deal is `closed_won` and its contract `activated`.\n      description: `**Strategic Customer \u00B7 Enterprise Tier**\n\nAcme Corporation is a Series-C robotics & industrial automation\ncompany that switched from a competitor 18 months ago. They run\nHotCRM as their system of record for sales + service across\nthree regional teams (NA, EMEA, APAC).\n\n**Relationship**\n- Primary economic buyer: Jordan Park (CTO) \u2014 values our open\n  architecture and AI roadmap.\n- Day-to-day champion: John Smith (VP Engineering) \u2014 owns the\n  technical evaluation and integration questions.\n- Procurement: handled by Lisa Kim \u2014 prefers annual contracts,\n  net-30 terms.\n\n**Current state**\n- ARR: $220K (signed renewal). Up 22% YoY.\n- 1 open enterprise opportunity ($150K platform upgrade) in proposal\n  stage, 1 service ticket open (login issues), 1 billing dispute\n  awaiting customer response.\n- AI agent governance became a hard requirement for that upgrade\n  after their internal compliance review, so the workshop now on\n  the calendar is the gate on signature.\n\n**Red flags**\n- Lost the $75K Marketing Cloud add-on on timing \u2014 their marketing\n  org is locked into a 2-year HubSpot contract, and the buying\n  window opens when that contract renews.\n- Login issues ticket is already past its SLA clock \u2014 needs eyes\n  today.`,\n    },\n    {\n      name: 'Globex Industries',\n      approval_status: 'approved',\n      type: 'prospect',\n      industry: 'manufacturing',\n      annual_revenue: 12000000,\n      number_of_employees: 800,\n      phone: '+1-312-555-0200',\n      billing_address: { street: '233 South Wacker Drive', city: 'Chicago', state: 'IL', postalCode: '60606', country: 'US' },\n      website: 'https://globex.example.com',\n      tier: 'enterprise',\n      segment: 'net_new',\n      // Only a booked demo and a cancelled review \u2014 neither bubbles, so this\n      // 8-day age survives the seed load and stays inside every churn window.\n      last_activity_date: cel`daysAgo(8)`,\n    },\n    {\n      name: 'Initech Solutions',\n      approval_status: 'approved',\n      type: 'customer',\n      industry: 'finance',\n      annual_revenue: 3500000,\n      number_of_employees: 150,\n      phone: '+1-212-555-0300',\n      billing_address: { street: '1 Liberty Plaza, 23rd Floor', city: 'New York', state: 'NY', postalCode: '10006', country: 'US' },\n      website: 'https://initech.example.com',\n      tier: 'mid_market',\n      segment: 'at_risk',\n      health_score: 'at_risk',\n      // QUIET 60+ \u2014 the `at_risk` segment and health score, with a clock that\n      // finally agrees with them: ten weeks of silence. A no-show call 55 days\n      // ago was the last attempt; the re-engagement call on the calendar is\n      // `planned`, so it moves nothing.\n      last_activity_date: cel`daysAgo(72)`,\n    },\n    {\n      name: 'Stark Medical',\n      approval_status: 'approved',\n      type: 'partner',\n      industry: 'healthcare',\n      annual_revenue: 8000000,\n      number_of_employees: 400,\n      // The one Canadian account: still inside north_america_territory, and the\n      // reason that rule's `$in` list is not a single-country list in disguise.\n      phone: '+1-416-555-0400',\n      billing_address: { street: '181 Bay Street, Suite 2200', city: 'Toronto', state: 'ON', postalCode: 'M5J 2T3', country: 'CA' },\n      website: 'https://starkmed.example.com',\n      tier: 'mid_market',\n      segment: 'stable',\n      // `at_risk` rather than `churning`, and the distinction is the reason\n      // this row can exist at all: a partner whose pilot was WON and whose\n      // expansion then died on a capital freeze can be at risk, but it was\n      // never a subscription that could churn. The records say it \u2014 `Stark\n      // Expansion (Lost)` closed `no_budget` 60 days ago and the partnership\n      // contract is still in legal review \u2014 and the panel's criterion admits\n      // both values, so the honest severity is also the one that flags.\n      //\n      // Diverging from `segment: 'stable'` is deliberate, the same split\n      // Wayne demonstrates below: `segment` is how the book classifies the\n      // account, `health_score` is what a person asserts about it. The clock\n      // stays at today(), so like Wayne this row is outside every windowed\n      // panel on that report: it reaches `csm_flagged_accounts` and no other\n      // block.\n      health_score: 'at_risk',\n      // The completed 'Send welcome package' task bubbles here on every seed\n      // load, so this has ALWAYS resolved to today \u2014 the previous `daysAgo(5)`\n      // was authored and then overwritten before anyone could read it.\n      last_activity_date: cel`today()`,\n    },\n    {\n      name: 'Wayne Enterprises',\n      approval_status: 'approved',\n      type: 'customer',\n      industry: 'technology',\n      annual_revenue: 25000000,\n      number_of_employees: 2000,\n      phone: '+1-650-555-0500',\n      billing_address: { street: '3000 Hanover Street', city: 'Palo Alto', state: 'CA', postalCode: '94304', country: 'US' },\n      website: 'https://wayne.example.com',\n      tier: 'strategic',\n      segment: 'growth',\n      // CHURNING, with the clock still running \u2014 the population\n      // `csm_flagged_accounts` exists for (#1414). Every DERIVED signal on\n      // this row reads healthy: an operations rollout closed four days ago, a\n      // licence sits at 80% two weeks from signature, three meetings were held\n      // this month. The CSM who has been in the room says the account is going\n      // anyway, and `health_score` is the only churn signal in the model a\n      // person ASSERTS \u2014 which is why the panel that reads it is first on the\n      // report and carries no time window.\n      //\n      // \u26D4 Do not \"correct\" this to `at_risk` to agree with the pipeline, and\n      // \u26D4 do not stop the clock to agree with the health score: either edit\n      // folds the row back into `at_risk_accounts` (60-day window) and the\n      // flagged panel goes back to restating its neighbour.\n      health_score: 'churning',\n      // Held: negotiation meeting, security-addendum call, governance webinar.\n      last_activity_date: cel`today()`,\n    },\n    {\n      name: 'Northwind Energy',\n      approval_status: 'approved',\n      type: 'prospect',\n      industry: 'energy',\n      annual_revenue: 18000000,\n      number_of_employees: 1100,\n      // europe_territory, half 1: DE.\n      phone: '+49-89-5550-0600',\n      billing_address: { street: 'Leopoldstrasse 21', city: 'Munich', state: 'BY', postalCode: '80802', country: 'DE' },\n      website: 'https://northwind.example.com',\n      tier: 'enterprise',\n      segment: 'net_new',\n      // QUIET 30+ \u2014 the field-service pilot was lost 80 days ago and the grid\n      // program has not been worked since. The discovery workshop is booked,\n      // not held.\n      last_activity_date: cel`daysAgo(41)`,\n      description: 'A regional energy provider evaluating a unified operations and customer-data platform.',\n    },\n    {\n      name: 'Vertex Analytics',\n      approval_status: 'approved',\n      type: 'customer',\n      industry: 'software',\n      annual_revenue: 9500000,\n      number_of_employees: 420,\n      phone: '+1-512-555-0700',\n      billing_address: { street: '600 Congress Avenue, Floor 14', city: 'Austin', state: 'TX', postalCode: '78701', country: 'US' },\n      website: 'https://vertex.example.com',\n      tier: 'enterprise',\n      segment: 'growth',\n      health_score: 'healthy',\n      // Held: rollout meeting, analytics demo, committee call, retrospective.\n      last_activity_date: cel`today()`,\n      description: 'An analytics SaaS customer expanding usage from the data team to its revenue organization.',\n    },\n    {\n      name: 'Lattice Education',\n      approval_status: 'approved',\n      type: 'customer',\n      industry: 'education',\n      annual_revenue: 6800000,\n      number_of_employees: 320,\n      // europe_territory, half 2 \u2014 and the alias fixture. `UK` is not ISO\n      // 3166-1 alpha-2 (`GB` is); it is an ACCEPTED SPELLING in\n      // `src/sales/objects/_territory.ts`, so this row proves on stock data that a\n      // legacy spelling still lands in `emea` (#639). No `state`: an address\n      // without a subdivision is a normal shape, and only `country` is read.\n      phone: '+44-20-7946-0800',\n      billing_address: { street: '20 Fenchurch Street', city: 'London', postalCode: 'EC3M 3BY', country: 'UK' },\n      website: 'https://lattice.example.com',\n      tier: 'mid_market',\n      segment: 'stable',\n      health_score: 'healthy',\n      // Signed the analytics expansion six days ago; the renewal review is\n      // booked, not held, so nothing bubbles and this age stands.\n      last_activity_date: cel`daysAgo(6)`,\n      description: 'A higher-education technology company consolidating admissions, student-success and alumni workflows.',\n    },\n    {\n      name: 'Apex Logistics',\n      approval_status: 'approved',\n      type: 'prospect',\n      industry: 'logistics',\n      annual_revenue: 22000000,\n      number_of_employees: 1400,\n      // `territory == \"other\"` on purpose: without a record that matches\n      // neither rule, \"the rules partition the accounts\" is unfalsifiable \u2014\n      // a match-all regression would look identical to a working one. `SG` is\n      // a real country the staffed territories do not cover, which is exactly\n      // what `other` is for (#639) \u2014 it is a stated classification here, not a\n      // blank.\n      phone: '+65-6555-0900',\n      billing_address: { street: '10 Marina Boulevard, #30-01', city: 'Singapore', postalCode: '018983', country: 'SG' },\n      website: 'https://apexlogistics.example.com',\n      tier: 'enterprise',\n      segment: 'net_new',\n      // QUIET 90+ \u2014 a lost compliance deal 110 days ago and a data-hub\n      // evaluation that has been silent for a quarter. Only a booked\n      // re-engagement call.\n      last_activity_date: cel`daysAgo(104)`,\n      description: 'A fast-growing logistics provider assessing a modern data hub for its operations and commercial teams.',\n    },\n  ]\n});\n\n// \u2500\u2500\u2500 Contacts \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\nexport const contacts = defineSeed(Contact, {\n  mode: 'upsert',\n  externalId: 'email',\n  records: [\n    {\n      salutation: 'mr',\n      first_name: 'John',\n      last_name: 'Smith',\n      email: 'john.smith@acme.example.com',\n      phone: '+1-415-555-0101',\n      title: 'VP of Engineering',\n      department: 'engineering',\n      crm_account: 'Acme Corporation',\n      is_primary: true,\n    },\n    {\n      salutation: 'ms',\n      first_name: 'Sarah',\n      last_name: 'Johnson',\n      email: 'sarah.j@globex.example.com',\n      phone: '+1-312-555-0201',\n      title: 'Chief Procurement Officer',\n      department: 'executive',\n      crm_account: 'Globex Industries',\n      is_primary: true,\n    },\n    {\n      salutation: 'dr',\n      first_name: 'Michael',\n      last_name: 'Chen',\n      email: 'mchen@initech.example.com',\n      phone: '+1-212-555-0301',\n      title: 'Director of Operations',\n      department: 'operations',\n      crm_account: 'Initech Solutions',\n      is_primary: true,\n    },\n    {\n      salutation: 'ms',\n      first_name: 'Emily',\n      last_name: 'Davis',\n      email: 'emily.d@starkmed.example.com',\n      phone: '+1-617-555-0401',\n      title: 'Head of Partnerships',\n      department: 'sales',\n      crm_account: 'Stark Medical',\n      is_primary: true,\n    },\n    {\n      salutation: 'mr',\n      first_name: 'Robert',\n      last_name: 'Wilson',\n      email: 'rwilson@wayne.example.com',\n      phone: '+1-650-555-0501',\n      title: 'CTO',\n      department: 'engineering',\n      crm_account: 'Wayne Enterprises',\n      is_primary: true,\n    },\n    {\n      salutation: 'ms',\n      first_name: 'Olivia',\n      last_name: 'Chen',\n      email: 'olivia.chen@northwind.example.com',\n      phone: '+1-303-555-0601',\n      title: 'VP of Digital Operations',\n      department: 'operations',\n      crm_account: 'Northwind Energy',\n      is_primary: true,\n    },\n    {\n      salutation: 'mr',\n      first_name: 'Ethan',\n      last_name: 'Brooks',\n      email: 'ethan.brooks@vertex.example.com',\n      phone: '+1-512-555-0701',\n      title: 'Chief Revenue Officer',\n      department: 'executive',\n      crm_account: 'Vertex Analytics',\n      is_primary: true,\n    },\n    {\n      salutation: 'ms',\n      first_name: 'Priya',\n      last_name: 'Shah',\n      email: 'priya.shah@lattice.example.com',\n      phone: '+1-617-555-0801',\n      title: 'VP of Student Success',\n      department: 'operations',\n      crm_account: 'Lattice Education',\n      is_primary: true,\n    },\n    {\n      salutation: 'mr',\n      first_name: 'Marcus',\n      last_name: 'Reed',\n      email: 'marcus.reed@apexlogistics.example.com',\n      phone: '+1-404-555-0901',\n      title: 'Director of Commercial Systems',\n      department: 'operations',\n      crm_account: 'Apex Logistics',\n      is_primary: true,\n    },\n  ]\n});\n\n// \u2500\u2500\u2500 Leads \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n/**\n * Disqualification reasons for the generated `unqualified` demo leads, paired\n * with the note that explains them.\n *\n * `crm_lead.disqualification_reason_required` rejects an unqualified lead that\n * carries no reason, so every seeded unqualified row must supply one \u2014 the rows\n * used to carry a budget-flavoured note and no reason at all. Rotated over four\n * values so the demo's disqualification breakdown has more than one bar, and\n * the note always matches the reason it sits next to.\n */\nconst DISQUALIFICATION_REASONS = [\n  { reason: 'no_budget',     note: 'No budget approved for this fiscal year \u2014 revisit next planning cycle.' },\n  { reason: 'not_a_fit',     note: 'Requirements sit outside what the product covers today.' },\n  { reason: 'wrong_persona', note: 'Contact has no say in the buying decision and no path to an owner.' },\n  { reason: 'unreachable',   note: 'Six touches across email and phone over four weeks, no response.' },\n] as const;\n\nexport const leads = defineSeed(Lead, {\n  mode: 'upsert',\n  externalId: 'email',\n  records: [\n    {\n      first_name: 'Alice',\n      last_name: 'Martinez',\n      company: 'NextGen Retail',\n      email: 'alice@nextgenretail.example.com',\n      phone: '+1-503-555-0600',\n      status: 'new',\n      lead_source: 'web',\n      industry: 'retail',\n      rating: 3,\n      next_followup_date: cel`daysFromNow(2)`,\n    },\n    {\n      first_name: 'David',\n      last_name: 'Kim',\n      company: 'EduTech Labs',\n      email: 'dkim@edutechlabs.example.com',\n      phone: '+1-408-555-0700',\n      status: 'contacted',\n      lead_source: 'referral',\n      industry: 'education',\n      rating: 4,\n      next_followup_date: cel`daysFromNow(1)`,\n      // A seeded `held` event names this lead, and `event_activity_bubble`\n      // stamps `last_contacted_date` with the SEED MOMENT rather than the\n      // event's own timestamp \u2014 so an authored age here would be overwritten\n      // the instant it was written (doctrine rule 2 in `./_shared.ts`). Day\n      // granularity is the honest match: the seed writes today's UTC midnight,\n      // the bubble writes today's instant, and both render as \"today\".\n      last_contacted_date: cel`today()`,\n    },\n    {\n      first_name: 'Lisa',\n      last_name: 'Thompson',\n      company: 'CloudFirst Inc',\n      email: 'lisa.t@cloudfirst.example.com',\n      phone: '+1-206-555-0800',\n      status: 'qualified',\n      lead_source: 'event',\n      industry: 'technology',\n      // WHOLE stars only. `lead.hook.ts` rounds its computed score to an\n      // integer because \"half values rendered inconsistently in the star\n      // widget\", and the hook leaves an explicitly seeded number alone \u2014 so a\n      // seeded 4.5 was the one rating in the system the contract could never\n      // produce, and it rendered as the broken half-star it was meant to\n      // prevent (#591).\n      rating: 5,\n      next_followup_date: cel`daysFromNow(0)`,\n      // Same as David Kim above: a `held` qualification call names this lead.\n      last_contacted_date: cel`today()`,\n    },\n    // \u2500\u2500\u2500 Generated demo leads \u2014 spread across 6 months for monthly-bucket reports\n    // (`LeadInflowByMonthSourceReport`). Each `last_contacted_date` lives in a\n    // distinct month / source pair so the matrix has multiple cells populated.\n    ...[\n      { fn: 'Noah',    ln: 'Patel',    co: 'Vertex Analytics',     src: 'web',         ind: 'technology',   age: 7   },\n      { fn: 'Maya',    ln: 'Singh',    co: 'BluePeak Logistics',   src: 'referral',    ind: 'logistics',    age: 14  },\n      { fn: 'Owen',    ln: 'Becker',   co: 'Northwind Energy',     src: 'event',       ind: 'energy',       age: 21  },\n      { fn: 'Sara',    ln: 'Lopez',    co: 'Helios Solar',         src: 'partner',     ind: 'energy',       age: 28  },\n      { fn: 'Leo',     ln: 'Vance',    co: 'CleanCart',            src: 'web',         ind: 'retail',       age: 38  },\n      { fn: 'Iris',    ln: 'Okafor',   co: 'PulseHealth',          src: 'cold_call',   ind: 'healthcare',   age: 45  },\n      { fn: 'Ravi',    ln: 'Mehta',    co: 'Foundry Robotics',     src: 'event',       ind: 'manufacturing',age: 52  },\n      { fn: 'Tess',    ln: 'Brown',    co: 'Lattice Education',    src: 'referral',    ind: 'education',    age: 67  },\n      { fn: 'Marco',   ln: 'Ricci',    co: 'Aurora Travel',        src: 'advertisement', ind: 'hospitality',       age: 74  },\n      { fn: 'Pia',     ln: 'Anand',    co: 'Citrine Finance',      src: 'partner',     ind: 'finance', age: 81 },\n      { fn: 'Jonas',   ln: 'Holt',     co: 'Polar Cargo',          src: 'web',         ind: 'logistics',    age: 95  },\n      { fn: 'Anya',    ln: 'Volkov',   co: 'RedOak Realty',        src: 'cold_call',   ind: 'real_estate',  age: 102 },\n      { fn: 'Theo',    ln: 'Park',     co: 'Skyline Media',        src: 'advertisement', ind: 'media',        age: 116 },\n      { fn: 'Wren',    ln: 'Garcia',   co: 'Maple Bakery Group',   src: 'event',       ind: 'retail', age: 123 },\n      { fn: 'Hugo',    ln: 'Dubois',   co: 'Nimbus Aerospace',     src: 'referral',    ind: 'manufacturing',age: 138 },\n      { fn: 'Lena',    ln: 'Fischer',  co: 'Granite Insurance',    src: 'partner',     ind: 'finance', age: 145 },\n      { fn: 'Kai',     ln: 'Watanabe', co: 'Coral Reef Hotels',    src: 'web',         ind: 'hospitality',       age: 162 },\n      { fn: 'Mira',    ln: 'Costa',    co: 'Atlas Construction',   src: 'cold_call',   ind: 'other', age: 175 },\n    ].map((l, i) => {\n      const domain = `${l.co.toLowerCase().replace(/\\s+/g, '')}.example.com`;\n      const status = (['new', 'contacted', 'qualified', 'unqualified'] as const)[i % 4];\n      return {\n        first_name: l.fn,\n        last_name: l.ln,\n        company: l.co,\n        email: `${l.fn.toLowerCase()}.${l.ln.toLowerCase()}@${domain}`,\n        phone: `+1-555-01${String(i).padStart(2, '0')}-${String(1000 + i * 7)}`,\n        status,\n        lead_source: l.src,\n        industry: l.ind,\n        rating: 1 + ((i * 7) % 5),\n        last_contacted_date: celDaysAgo(l.age),\n        // The qualification fields were left blank on every generated lead, so\n        // the detail page's Contact / Lead Detail / Description sections had\n        // nothing to render (they also drop whatever the highlights strip\n        // already shows, so all four collapsed to nothing) and the demo read\n        // like a half-finished import.\n        title: (['VP Operations', 'Head of IT', 'Director of Sales', 'COO', 'Procurement Lead'] as const)[i % 5],\n        mobile: `+1-555-02${String(i).padStart(2, '0')}-${String(2000 + i * 3)}`,\n        website: `https://${domain}`,\n        annual_revenue: 2_000_000 + ((i * 3_700_000) % 90_000_000),\n        number_of_employees: 25 + ((i * 137) % 4_800),\n        description:\n          `Inbound via ${l.src.replace(/_/g, ' ')}. Evaluating a CRM to replace spreadsheets ` +\n          `across their ${l.ind.replace(/_/g, ' ')} operation.`,\n        ...(status === 'unqualified'\n          ? {\n              disqualification_reason: DISQUALIFICATION_REASONS[(i >> 2) % DISQUALIFICATION_REASONS.length].reason,\n              notes: DISQUALIFICATION_REASONS[(i >> 2) % DISQUALIFICATION_REASONS.length].note,\n            }\n          : {}),\n      };\n    }),\n  ]\n});\n\n// \u2500\u2500\u2500 Line items: the one source of truth for deal value \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n/**\n * Opportunity line items, keyed by the opportunity's name (its seed\n * externalId). Every seeded deal is itemised \u2014 before #591 not one was, so the\n * Products related list was empty on every opportunity in the demo and the CPQ\n * story had nothing to show.\n *\n * These sums are AUTHORITATIVE: each opportunity's `amount` below is computed\n * from its lines by `dealValue()` rather than typed in, which is the same\n * answer `opportunity_amount_rollup` computes when a rep touches a line. There\n * is therefore no seeded parent total that a first line-item edit can silently\n * rewrite \u2014 the acceptance condition of #591 holds by construction rather than\n * by anyone re-checking the arithmetic.\n *\n * Deriving rather than delegating is deliberate. Letting the rollup own the\n * number would make every seeded `amount` depend on whether hooks fire over\n * seed writes \u2014 which the doctrine block above says they do not and a boot log\n * says they do (#617) \u2014 and on that hook surviving its own write call (#616).\n * A derived literal is correct under every one of those combinations: if the\n * rollup runs it recomputes the same figure, and if it never runs the figure\n * was already right.\n */\nexport const OPPORTUNITY_LINES: Record<string, readonly LineSpec[]> = {\n  'Acme Platform Upgrade': [\n    { product: 'ObjectStack Platform', quantity: 2, unit_price: 50000, discount: 10, description: 'Enterprise edition \u2014 NA + EMEA production tenants (multi-year discount).' },\n    { product: 'Premium Support', quantity: 1, unit_price: 25000, description: '24\u00D77 premium support with a named TAM.' },\n    { product: 'AI Agent Seat (Annual)', quantity: 35, unit_price: 1000, description: 'Agent seats for the Ops organization.' },\n  ],\n  'Globex Manufacturing Suite': [\n    { product: 'ObjectStack Platform', quantity: 1, unit_price: 50000, description: 'Enterprise edition \u2014 one shared tenant serving all six manufacturing sites.' },\n    { product: 'Admin Training Workshop', quantity: 4, unit_price: 6000, description: 'Four workshop days, one per regional plant cluster.' },\n    { product: 'Standard Support', quantity: 1, unit_price: 9000, description: 'Business-hours support for the first year.' },\n    { product: 'AI Agent Seat (Annual)', quantity: 12, unit_price: 1000, description: 'Agent seats for the plant operations leads.' },\n  ],\n  'Wayne Enterprise License': [\n    { product: 'ObjectStack Platform', quantity: 20, unit_price: 50000, discount: 15, description: 'Enterprise-wide license, volume discount at 20 tenants.' },\n    { product: 'Premium Support', quantity: 4, unit_price: 25000, description: 'Premium support across four business units.' },\n    { product: 'AI Agent Seat (Annual)', quantity: 250, unit_price: 1000, description: 'Agent seats for the global revenue organization.' },\n  ],\n  'Initech Cloud Migration': [\n    { product: 'Data Migration Services', quantity: 1, unit_price: 35000, description: 'Migration off the legacy on-premise CRM.' },\n    { product: 'Cloud Hosting (Annual)', quantity: 2, unit_price: 12000, description: 'Managed hosting, primary + DR region.' },\n    { product: 'Standard Support', quantity: 1, unit_price: 9000, description: 'Business-hours support for the first year.' },\n    { product: 'AI Agent Seat (Annual)', quantity: 12, unit_price: 1000, description: 'Agent seats for the service desk.' },\n  ],\n  'Acme Annual Renewal 2025': [\n    { product: 'ObjectStack Platform', quantity: 3, unit_price: 50000, description: 'Renewal of the three production tenants.' },\n    { product: 'Premium Support', quantity: 1, unit_price: 25000, description: 'Premium support renewal.' },\n    { product: 'AI Agent Seat (Annual)', quantity: 45, unit_price: 1000, description: 'Seat expansion driven by the new EMEA team.' },\n  ],\n  'Stark Medical Pilot': [\n    { product: 'ObjectStack Platform', quantity: 2, unit_price: 50000, description: 'Pilot tenants for two clinical service lines.' },\n    { product: 'Standard Support', quantity: 1, unit_price: 9000, description: 'Standard support during the pilot.' },\n    { product: 'Admin Training Workshop', quantity: 6, unit_price: 6000, description: 'Six workshop days for the clinical operations admins.' },\n  ],\n  'Wayne Q1 Expansion': [\n    { product: 'ObjectStack Platform', quantity: 6, unit_price: 50000, description: 'Expansion into six additional subsidiaries.' },\n    { product: 'Premium Support', quantity: 2, unit_price: 25000, description: 'Premium support for the expanded footprint.' },\n    { product: 'AI Agent Seat (Annual)', quantity: 30, unit_price: 1000, description: 'Agent seats for the expansion teams.' },\n  ],\n  'Globex Training Package': [\n    { product: 'Admin Training Workshop', quantity: 10, unit_price: 6000, description: 'Ten workshop days across the plant admin community.' },\n    { product: 'AI Agent Seat (Annual)', quantity: 5, unit_price: 1000, description: 'Agent seats for the training sandbox.' },\n  ],\n  'Initech Phase 1': [\n    { product: 'Implementation Services', quantity: 1, unit_price: 75000, description: 'Phase 1 implementation: accounts, contacts, pipeline.' },\n    { product: 'Standard Support', quantity: 1, unit_price: 9000, description: 'Standard support for phase 1.' },\n    { product: 'AI Agent Seat (Annual)', quantity: 6, unit_price: 1000, description: 'Agent seats for the phase-1 pilot group.' },\n  ],\n  'Acme Add-on (Lost)': [\n    { product: 'Analytics Add-on', quantity: 2, unit_price: 22000, description: 'Marketing analytics for two business units.' },\n    { product: 'Integration Connector Pack', quantity: 1, unit_price: 16000, description: 'Marketing-automation connector pack.' },\n    { product: 'Sandbox Environment (Annual)', quantity: 2, unit_price: 7500, description: 'Two sandboxes for the marketing build-out.' },\n  ],\n  'Stark Expansion (Lost)': [\n    { product: 'ObjectStack Platform', quantity: 2, unit_price: 50000, description: 'Two additional clinical tenants.' },\n    { product: 'Field Service Mobile', quantity: 1, unit_price: 14000, description: 'Field service mobile for the device-servicing team.' },\n    { product: 'AI Agent Seat (Annual)', quantity: 6, unit_price: 1000, description: 'Agent seats for the service coordinators.' },\n  ],\n  'Globex Line Expansion (Lost)': [\n    { product: 'ObjectStack Platform', quantity: 2, unit_price: 50000, description: 'Two further production-line tenants.' },\n    { product: 'Integration Connector Pack', quantity: 1, unit_price: 16000, description: 'Connector pack for the line-control systems.' },\n    { product: 'AI Agent Seat (Annual)', quantity: 8, unit_price: 1000, description: 'Agent seats for the line supervisors.' },\n  ],\n  'Northwind Field Service Pilot (Lost)': [\n    { product: 'Field Service Mobile', quantity: 1, unit_price: 14000, description: 'Field-service mobile for the metering crews.' },\n    { product: 'Standard Support', quantity: 1, unit_price: 9000, description: 'Business-hours support during the pilot.' },\n    { product: 'AI Agent Seat (Annual)', quantity: 10, unit_price: 1000, description: 'Agent seats for the dispatch desk.' },\n  ],\n  'Apex Compliance Reporting (Lost)': [\n    { product: 'Analytics Add-on', quantity: 1, unit_price: 22000, description: 'Regulatory reporting pack for fleet compliance.' },\n    { product: 'Sandbox Environment (Annual)', quantity: 1, unit_price: 7500, description: 'Sandbox for the compliance rule build-out.' },\n    { product: 'AI Agent Seat (Annual)', quantity: 6, unit_price: 1000, description: 'Agent seats for the compliance analysts.' },\n  ],\n  'Northwind Grid Modernization': [\n    { product: 'ObjectStack Platform', quantity: 1, unit_price: 50000, description: 'Enterprise edition for grid, field and customer operations.' },\n    { product: 'Field Service Mobile', quantity: 1, unit_price: 14000, description: 'Field-service mobile for the grid maintenance crews.' },\n    { product: 'Sandbox Environment (Annual)', quantity: 1, unit_price: 7500, description: 'Sandbox for the operational-data assessment.' },\n    { product: 'AI Agent Seat (Annual)', quantity: 15, unit_price: 1000, description: 'Agent seats for the control-room pilot.' },\n  ],\n  'Lattice Student Success Platform': [\n    { product: 'ObjectStack Platform (SMB Edition)', quantity: 2, unit_price: 18000, description: 'Student-success tenants for the two pilot colleges.' },\n    { product: 'Admin Training Workshop', quantity: 2, unit_price: 6000, description: 'Two workshop days for the student-success advisers.' },\n    { product: 'AI Agent Seat (Annual)', quantity: 5, unit_price: 1000, description: 'Agent seats for the advising team.' },\n  ],\n  'Vertex Analytics Expansion': [\n    { product: 'Analytics Add-on', quantity: 2, unit_price: 22000, description: 'Analytics for the sales and marketing teams.' },\n    { product: 'Premium Support', quantity: 1, unit_price: 25000, description: 'Premium support for the expanded footprint.' },\n    { product: 'AI Agent Seat (Annual)', quantity: 10, unit_price: 1000, description: 'Agent seats for the revenue operations team.' },\n  ],\n  'Apex Logistics Data Hub': [\n    { product: 'ObjectStack Platform', quantity: 1, unit_price: 50000, description: 'Data-hub tenant shared by commercial, operations and finance.' },\n    { product: 'Data Migration Services', quantity: 1, unit_price: 35000, description: 'Consolidation of four fragmented commercial systems.' },\n    { product: 'AI Agent Seat (Annual)', quantity: 8, unit_price: 1000, description: 'Agent seats for the commercial operations team.' },\n  ],\n  'Lattice Education Renewal': [\n    { product: 'ObjectStack Platform', quantity: 1, unit_price: 50000, description: 'Renewal of the institution-wide tenant.' },\n    { product: 'Analytics Add-on', quantity: 1, unit_price: 22000, description: 'Expanded analytics package for the renewal term.' },\n    { product: 'AI Agent Seat (Annual)', quantity: 15, unit_price: 1000, description: 'Student-success automation seats.' },\n  ],\n  'Vertex Enterprise Rollout': [\n    { product: 'ObjectStack Platform', quantity: 1, unit_price: 50000, discount: 20, description: 'Phase-one tenant for the first region, with data-residency controls (multi-phase commitment discount).' },\n    { product: 'Data Migration Services', quantity: 1, unit_price: 35000, description: 'Phase-one migration of the regional revenue data.' },\n    { product: 'Standard Support', quantity: 1, unit_price: 9000, description: 'Business-hours support for phase one.' },\n    { product: 'AI Agent Seat (Annual)', quantity: 10, unit_price: 1000, description: 'Agent seats for the first rollout wave.' },\n  ],\n  // Campaign-attributed wins \u2014 see the campaign metrics note below.\n  'Lattice Analytics Expansion': [\n    { product: 'Analytics Add-on', quantity: 2, unit_price: 22000, description: 'Analytics for admissions and alumni engagement.' },\n    { product: 'Admin Training Workshop', quantity: 1, unit_price: 6000, description: 'Analytics enablement day for the institutional-research team.' },\n    { product: 'AI Agent Seat (Annual)', quantity: 20, unit_price: 1000, description: 'Agent seats for the admissions team.' },\n  ],\n  'Wayne Operations Module Rollout': [\n    { product: 'ObjectStack Platform', quantity: 2, unit_price: 50000, description: 'Operations tenants for two manufacturing divisions.' },\n    { product: 'Standard Support', quantity: 1, unit_price: 9000, description: 'Standard support for the operations rollout.' },\n    { product: 'AI Agent Seat (Annual)', quantity: 11, unit_price: 1000, description: 'Agent seats for the operations planners.' },\n  ],\n  'Vertex Developer Platform Adoption': [\n    { product: 'ObjectStack Platform', quantity: 3, unit_price: 50000, description: 'Developer platform tenants for three product teams.' },\n    { product: 'Integration Connector Pack', quantity: 1, unit_price: 16000, description: 'Connector pack for the internal data warehouse.' },\n    { product: 'Analytics Add-on', quantity: 1, unit_price: 22000, description: 'Product-usage analytics for the platform team.' },\n    { product: 'AI Agent Seat (Annual)', quantity: 12, unit_price: 1000, description: 'Agent seats for the developer-experience team.' },\n  ],\n};\n\n/**\n * `amount` + `expected_revenue` for a seeded deal, both derived from its line\n * items. `expected_revenue` uses opportunity.hook.ts's own expression\n * (`Math.round(amount * probability) / 100`) so the two agree to the cent.\n */\nconst dealValue = (opportunityName: string, probability: number) => {\n  const lines = OPPORTUNITY_LINES[opportunityName];\n  if (!lines) throw new Error(`Seed error: no line items authored for opportunity \"${opportunityName}\"`);\n  const amount = linesTotal(lines);\n  return { amount, expected_revenue: Math.round(amount * probability) / 100 };\n};\n\n// \u2500\u2500\u2500 Opportunities \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n// `probability`, `forecast_category` and `expected_revenue` are derived from\n// `stage` by opportunity.hook.ts (STAGE_PROBABILITY / STAGE_FORECAST). Hooks\n// don't run over seeds, so every row below carries the exact values the hook\n// would compute \u2014 anything else gets silently rewritten on the first user\n// edit (#490).\n//\n// `stage_entry_date` follows the same rule: the hook stamps it on every insert\n// and stage change, so a seeded deal without one is a shape real data never\n// has \u2014 and it is what the stagnation sweep filters on and what the\n// `days_in_stage` FORMULA counts from, so it replaces the old hardcoded\n// `days_in_stage` numbers (#489). Open deals carry an age that spans the\n// 14-day stale threshold in both directions; settled deals entered their\n// closed stage on their close date.\nexport const opportunities = defineSeed(Opportunity, {\n  mode: 'upsert',\n  externalId: 'name',\n  records: [\n    {\n      name: 'Acme Platform Upgrade',\n      crm_account: 'Acme Corporation',\n      ...dealValue('Acme Platform Upgrade', 60),\n      stage: 'proposal',\n      probability: 60,\n      close_date: cel`daysFromNow(30)`,\n      type: 'existing_upgrade',\n      forecast_category: 'commit',\n      lead_source: 'web',\n      stage_entry_date: celDaysAgo(12),\n      description: `Upgrade from Standard to Enterprise edition for the\nNA + EMEA teams. Drivers: (1) AI agent governance becomes a hard\nrequirement after their internal compliance review, (2) advanced\nanalytics seats for the Ops org, (3) priority support SLA.`,\n      // This sentence used to DATE the workshop itself (\"the week of\n      // close_date - 14d\" => daysFromNow(16)) while the seeded event had it at\n      // daysFromNow(6) and a seeded task chased it at daysFromNow(7) \u2014 three\n      // records, three answers (#1660). The date now lives in exactly ONE\n      // place, the `crm_event` row in service.seed.ts, and this prose states\n      // only what stays true however that event is scheduled: it is booked,\n      // and its invitation has gone out (the attendee builder clamps\n      // `invited_date` at daysAgo(0), so a planned event's invite is never in\n      // the future). Re-dating the event therefore cannot strand this line.\n      // Do not put a date back here, absolute OR relative: a second copy is\n      // a second thing to drift.\n      next_step: `Send the revised proposal (Enterprise edition, 18-month term, 12% multi-year discount) to Jordan Park by EOW. The AI governance workshop with their compliance team is already booked and the invitation is out.`,\n    },\n    {\n      name: 'Globex Manufacturing Suite',\n      crm_account: 'Globex Industries',\n      ...dealValue('Globex Manufacturing Suite', 25),\n      stage: 'qualification',\n      probability: 25,\n      close_date: cel`daysFromNow(60)`,\n      type: 'new_business',\n      forecast_category: 'pipeline',\n      lead_source: 'referral',\n      stage_entry_date: celDaysAgo(45),\n    },\n    {\n      name: 'Wayne Enterprise License',\n      crm_account: 'Wayne Enterprises',\n      ...dealValue('Wayne Enterprise License', 80),\n      stage: 'negotiation',\n      probability: 80,\n      close_date: cel`daysFromNow(14)`,\n      type: 'new_business',\n      forecast_category: 'commit',\n      lead_source: 'partner',\n      stage_entry_date: celDaysAgo(7),\n    },\n    {\n      name: 'Initech Cloud Migration',\n      crm_account: 'Initech Solutions',\n      ...dealValue('Initech Cloud Migration', 40),\n      stage: 'needs_analysis',\n      probability: 40,\n      close_date: cel`daysFromNow(45)`,\n      type: 'existing_upgrade',\n      forecast_category: 'best_case',\n      lead_source: 'event',\n      stage_entry_date: celDaysAgo(38),\n    },\n    // \u2500\u2500\u2500 Closed Won deals (powers KPIs & revenue trends) \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n    {\n      name: 'Acme Annual Renewal 2025',\n      crm_account: 'Acme Corporation',\n      ...dealValue('Acme Annual Renewal 2025', 100),\n      stage: 'closed_won',\n      probability: 100,\n      close_date: cel`daysAgo(15)`,\n      stage_entry_date: cel`daysAgo(15)`,\n      type: 'existing_renewal',\n      forecast_category: 'closed',\n      lead_source: 'partner',\n      win_reason: 'relationship',\n      description: `Annual renewal of the Acme Standard subscription, signed two weeks ahead of the renewal date. 22% YoY uplift driven by seat expansion in the new EMEA team. Multi-year option declined this round \u2014 they want to see how the platform upgrade lands first.`,\n    },\n    {\n      name: 'Stark Medical Pilot',\n      crm_account: 'Stark Medical',\n      ...dealValue('Stark Medical Pilot', 100),\n      stage: 'closed_won',\n      probability: 100,\n      close_date: cel`daysAgo(50)`,\n      stage_entry_date: cel`daysAgo(50)`,\n      type: 'new_business',\n      forecast_category: 'closed',\n      lead_source: 'event',\n      win_reason: 'best_fit',\n    },\n    {\n      name: 'Wayne Q1 Expansion',\n      crm_account: 'Wayne Enterprises',\n      ...dealValue('Wayne Q1 Expansion', 100),\n      stage: 'closed_won',\n      probability: 100,\n      close_date: cel`daysAgo(95)`,\n      stage_entry_date: cel`daysAgo(95)`,\n      type: 'existing_upgrade',\n      forecast_category: 'closed',\n      lead_source: 'web',\n      win_reason: 'better_product',\n    },\n    {\n      name: 'Globex Training Package',\n      crm_account: 'Globex Industries',\n      ...dealValue('Globex Training Package', 100),\n      stage: 'closed_won',\n      probability: 100,\n      close_date: cel`daysAgo(140)`,\n      stage_entry_date: cel`daysAgo(140)`,\n      type: 'new_business',\n      forecast_category: 'closed',\n      lead_source: 'referral',\n      win_reason: 'better_support',\n    },\n    {\n      name: 'Initech Phase 1',\n      crm_account: 'Initech Solutions',\n      ...dealValue('Initech Phase 1', 100),\n      stage: 'closed_won',\n      probability: 100,\n      close_date: cel`daysAgo(200)`,\n      stage_entry_date: cel`daysAgo(200)`,\n      type: 'new_business',\n      forecast_category: 'closed',\n      lead_source: 'web',\n      win_reason: 'better_price',\n    },\n    // \u2500\u2500\u2500 Campaign-attributed wins \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n    // `crm_campaign` is what `campaign_attribution_refresh` counts\n    // (`num_opportunities` / `num_won_opportunities` / the summed\n    // `actual_revenue`) \u2014 on every opportunity insert, update and delete, not\n    // once at completion. Before #591 not one opportunity carried it, so those\n    // three metrics were structurally zero and every campaign's seeded\n    // `actual_revenue` was a number the hook would have overwritten on the\n    // first attributed write.\n    // These three wins are what make the marketing ROI numbers below TRUE.\n    {\n      name: 'Lattice Analytics Expansion',\n      crm_account: 'Lattice Education',\n      primary_contact: 'priya.shah@lattice.example.com',\n      crm_campaign: 'Q3 Enterprise Email Nurture',\n      ...dealValue('Lattice Analytics Expansion', 100),\n      stage: 'closed_won',\n      probability: 100,\n      close_date: cel`daysAgo(6)`,\n      stage_entry_date: cel`daysAgo(6)`,\n      type: 'existing_expansion',\n      forecast_category: 'closed',\n      lead_source: 'email_campaign',\n      win_reason: 'best_fit',\n      description: 'Analytics package for admissions and alumni engagement, sourced from the enterprise nurture track.',\n    },\n    {\n      name: 'Wayne Operations Module Rollout',\n      crm_account: 'Wayne Enterprises',\n      primary_contact: 'rwilson@wayne.example.com',\n      crm_campaign: 'Operations Platform Launch',\n      ...dealValue('Wayne Operations Module Rollout', 100),\n      stage: 'closed_won',\n      probability: 100,\n      close_date: cel`daysAgo(4)`,\n      stage_entry_date: cel`daysAgo(4)`,\n      type: 'existing_upgrade',\n      forecast_category: 'closed',\n      lead_source: 'content',\n      description: 'Operations module for two manufacturing divisions, closed off the operations-platform launch program.',\n      win_reason: 'relationship',\n    },\n    {\n      name: 'Vertex Developer Platform Adoption',\n      crm_account: 'Vertex Analytics',\n      primary_contact: 'ethan.brooks@vertex.example.com',\n      crm_campaign: 'Developer Content Marketing Push',\n      ...dealValue('Vertex Developer Platform Adoption', 100),\n      stage: 'closed_won',\n      probability: 100,\n      close_date: cel`daysAgo(6)`,\n      stage_entry_date: cel`daysAgo(6)`,\n      type: 'existing_expansion',\n      forecast_category: 'closed',\n      lead_source: 'content',\n      description: 'Three product teams adopted the developer platform after the technical content series.',\n      win_reason: 'better_product',\n    },\n    // \u2500\u2500\u2500 Closed Lost deals (powers win-rate + loss-reason analytics) \u2500\u2500\u2500\u2500\n    //\n    // Five losses across five distinct `loss_reason` values, and every one of\n    // them is now MANDATORY rather than decorative: `loss_reason` is\n    // `requiredWhen` stage is `closed_lost` (#593), so a seeded lost deal\n    // without one is rejected by the engine at seed time \u2014 the demo database\n    // cannot boot with the empty column that made the loss-reason widget\n    // unbuildable in the first place.\n    //\n    // Their `lead_source` values are chosen so that the sources carrying a loss\n    // ALSO carry a win (`web`, `referral`, `content`), plus two sources that\n    // only ever lost (`cold_call`, `advertisement`). That is what makes\n    // `win_rate_by_lead_source` a real measurement instead of a column of\n    // 100%s: three rows where both halves of the ratio move, and two rows that\n    // show what an all-loss source looks like.\n    {\n      name: 'Acme Add-on (Lost)',\n      crm_account: 'Acme Corporation',\n      ...dealValue('Acme Add-on (Lost)', 0),\n      stage: 'closed_lost',\n      probability: 0,\n      close_date: cel`daysAgo(25)`,\n      stage_entry_date: cel`daysAgo(25)`,\n      type: 'existing_upgrade',\n      forecast_category: 'omitted',\n      lead_source: 'cold_call',\n      loss_reason: 'timing',\n      loss_details: 'Marketing is locked into a 2-year HubSpot contract; the buying window opens when that renews.',\n      // This line used to end \"Revisit in Q3\" \u2014 a hand-typed calendar quarter\n      // on a record whose `close_date` is `daysAgo(25)`, so the quarter it told\n      // a rep to wait for is the one the deal was already lost in, and it\n      // contradicted this record's own `loss_details`: a 2-year lock does not\n      // reopen inside the quarter the deal closed in (#1712). Same ruling as\n      // the `next_step` block above (#1660): no date goes back into this prose,\n      // absolute OR relative. The renewal is the anchor that stays true however\n      // this record is dated \u2014 which is how `loss_details` and the account\n      // description already state it.\n      description: `Tried to bolt on the Marketing Cloud module via cold outbound. Lost because Acme's marketing org is already on a 2-year HubSpot contract. Revisit when that contract comes up for renewal \u2014 that is when the buying window opens.`,\n    },\n    {\n      name: 'Stark Expansion (Lost)',\n      crm_account: 'Stark Medical',\n      ...dealValue('Stark Expansion (Lost)', 0),\n      stage: 'closed_lost',\n      probability: 0,\n      close_date: cel`daysAgo(60)`,\n      stage_entry_date: cel`daysAgo(60)`,\n      type: 'new_business',\n      forecast_category: 'omitted',\n      lead_source: 'advertisement',\n      loss_reason: 'no_budget',\n      loss_details: 'Capital freeze on non-clinical systems for the rest of the fiscal year.',\n    },\n    {\n      name: 'Globex Line Expansion (Lost)',\n      crm_account: 'Globex Industries',\n      ...dealValue('Globex Line Expansion (Lost)', 0),\n      stage: 'closed_lost',\n      probability: 0,\n      close_date: cel`daysAgo(35)`,\n      stage_entry_date: cel`daysAgo(35)`,\n      type: 'existing_expansion',\n      forecast_category: 'omitted',\n      lead_source: 'referral',\n      loss_reason: 'competitor',\n      loss_details: 'Incumbent MES vendor bundled the two additional lines into an existing master agreement.',\n      description: 'Expansion into two further production lines, lost to the incumbent MES vendor on bundling.',\n    },\n    {\n      name: 'Northwind Field Service Pilot (Lost)',\n      crm_account: 'Northwind Energy',\n      ...dealValue('Northwind Field Service Pilot (Lost)', 0),\n      stage: 'closed_lost',\n      probability: 0,\n      close_date: cel`daysAgo(80)`,\n      stage_entry_date: cel`daysAgo(80)`,\n      type: 'new_business',\n      forecast_category: 'omitted',\n      lead_source: 'web',\n      loss_reason: 'price',\n      loss_details: 'Per-technician pricing landed ~30% above the budget the operations director had approved.',\n      description: 'Field-service pilot for the metering crews, lost on price against a cheaper point solution.',\n    },\n    {\n      name: 'Apex Compliance Reporting (Lost)',\n      crm_account: 'Apex Logistics',\n      ...dealValue('Apex Compliance Reporting (Lost)', 0),\n      stage: 'closed_lost',\n      probability: 0,\n      close_date: cel`daysAgo(110)`,\n      stage_entry_date: cel`daysAgo(110)`,\n      type: 'new_business',\n      forecast_category: 'omitted',\n      lead_source: 'content',\n      loss_reason: 'features',\n      loss_details: 'No native hours-of-service audit trail; the compliance team could not sign off without it.',\n      description: 'Regulatory reporting pack for the fleet compliance team, lost on a missing audit-trail capability.',\n    },\n    // \u2500\u2500\u2500 Curated active pipeline \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n    // Two cards in each active stage make the kanban immediately legible in\n    // a customer demo. They also tell a coherent sales story instead of\n    // overwhelming the board with anonymous generated rows.\n    //\n    // PRICED TO STAY DRAGGABLE (#1902). A deal at or above\n    // `LARGE_DEAL_AMOUNT` is born into `opportunity_approval_on_create`, whose\n    // approval nodes hold the record with `lockRecord: true` \u2014 on the board\n    // that card refuses every drag with `RECORD_LOCKED`. When nine of the ten\n    // open deals sat over the line, the one board a demo opens first was\n    // frozen. So exactly TWO open deals exhibit the approval flow, one per\n    // tier, and both are in the block above: `Acme Platform Upgrade`\n    // (manager review only, $100K\u2013$500K) and `Wayne Enterprise License`\n    // (manager, then director sign-off, over `HIGH_VALUE_DEAL_AMOUNT`). Every\n    // deal in this block is priced under the line, so each active stage keeps\n    // at least one card that moves. `test/seed-consistency.test.ts` pins the\n    // two by name \u2014 re-pricing a deal here over $100K goes red there.\n    {\n      name: 'Northwind Grid Modernization',\n      crm_account: 'Northwind Energy',\n      primary_contact: 'olivia.chen@northwind.example.com',\n      ...dealValue('Northwind Grid Modernization', 10),\n      stage: 'prospecting',\n      probability: 10,\n      close_date: cel`daysFromNow(72)`,\n      type: 'new_business',\n      forecast_category: 'pipeline',\n      lead_source: 'webinar',\n      stage_entry_date: celDaysAgo(4),\n      description: 'Northwind is assessing a unified grid-modernization program after an executive webinar.',\n      next_step: 'Confirm discovery participants and agree the operational-data assessment scope.',\n    },\n    {\n      name: 'Lattice Student Success Platform',\n      crm_account: 'Lattice Education',\n      primary_contact: 'priya.shah@lattice.example.com',\n      crm_campaign: 'Developer Content Marketing Push',\n      ...dealValue('Lattice Student Success Platform', 10),\n      stage: 'prospecting',\n      probability: 10,\n      close_date: cel`daysFromNow(96)`,\n      type: 'new_business',\n      forecast_category: 'pipeline',\n      lead_source: 'content',\n      stage_entry_date: celDaysAgo(11),\n      description: 'A new student-success initiative sourced from the higher-education content series.',\n      next_step: 'Invite the operations sponsor to the discovery workshop.',\n    },\n    {\n      name: 'Vertex Analytics Expansion',\n      crm_account: 'Vertex Analytics',\n      primary_contact: 'ethan.brooks@vertex.example.com',\n      ...dealValue('Vertex Analytics Expansion', 25),\n      stage: 'qualification',\n      probability: 25,\n      close_date: cel`daysFromNow(52)`,\n      type: 'existing_expansion',\n      forecast_category: 'pipeline',\n      lead_source: 'partner',\n      stage_entry_date: celDaysAgo(8),\n      description: 'Vertex wants to extend the platform from its data team to the full revenue organization.',\n      next_step: 'Validate the buying committee, budget owner and expansion timeline.',\n    },\n    {\n      name: 'Apex Logistics Data Hub',\n      crm_account: 'Apex Logistics',\n      primary_contact: 'marcus.reed@apexlogistics.example.com',\n      ...dealValue('Apex Logistics Data Hub', 40),\n      stage: 'needs_analysis',\n      probability: 40,\n      close_date: cel`daysFromNow(38)`,\n      type: 'new_business',\n      forecast_category: 'best_case',\n      lead_source: 'partner',\n      stage_entry_date: celDaysAgo(18),\n      description: 'Apex is mapping its fragmented commercial systems before committing to a data-hub program.',\n      next_step: 'Complete the architecture workshop and quantify the integration backlog.',\n    },\n    {\n      name: 'Lattice Education Renewal',\n      crm_account: 'Lattice Education',\n      primary_contact: 'priya.shah@lattice.example.com',\n      crm_campaign: 'Q3 Enterprise Email Nurture',\n      ...dealValue('Lattice Education Renewal', 60),\n      stage: 'proposal',\n      probability: 60,\n      close_date: cel`daysFromNow(24)`,\n      type: 'existing_renewal',\n      forecast_category: 'commit',\n      lead_source: 'email_campaign',\n      stage_entry_date: celDaysAgo(6),\n      description: 'Renewal proposal adds student-success automation and an expanded analytics package.',\n      next_step: 'Review the two-year option with procurement before the executive sponsor meeting.',\n    },\n    {\n      name: 'Vertex Enterprise Rollout',\n      crm_account: 'Vertex Analytics',\n      primary_contact: 'ethan.brooks@vertex.example.com',\n      ...dealValue('Vertex Enterprise Rollout', 80),\n      stage: 'negotiation',\n      probability: 80,\n      close_date: cel`daysFromNow(11)`,\n      type: 'existing_expansion',\n      forecast_category: 'commit',\n      lead_source: 'referral',\n      stage_entry_date: celDaysAgo(3),\n      description: 'Phase one of an enterprise rollout, negotiated around phased deployment and data-residency requirements.',\n      next_step: 'Resolve the final security addendum and confirm the procurement signature date.',\n    },\n  ]\n});\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/sales/data/_shared.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/sales/data\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/sales/data/_shared.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\n/**\n * Seed helpers shared by every `*.seed.ts` family module.\n *\n * The seed data used to be one 100KB `src/data/index.ts`, which sat ~1.5KB\n * under the `pnpm hygiene` byte cap and turned the next demo record into a\n * build failure (#635). It is now split by object family \u2014 `catalog`, `sales`,\n * `service`, `marketing`, `revenue` \u2014 with `index.ts` reduced to the\n * aggregating `CrmSeedData` export. This module holds what more than one\n * family needs.\n */\nimport { cel } from '@objectstack/spec';\n\n/**\n * A note on system-computed fields in seeds (#490, #617).\n *\n * ### Hooks DO run over seed writes \u2014 automations do not\n *\n * The seed loader writes with `{ isSystem: true, skipTriggers: true,\n * seedReplay: true }`, and the premise this file used to state \u2014 \"hooks do NOT\n * run over seed rows\" \u2014 was wrong (#617). Measured against 17.0.0-rc.1, and\n * matching `SeedLoaderService.SEED_OPTIONS`' own contract:\n *\n *   - `isSystem`   bypasses RBAC and DISABLES the security plugin's injection\n *                  of `organization_id` / `owner_id` \u2014 which is why seeded rows\n *                  land ownerless until the platform's seed-ownership claim\n *                  hands them to the first administrator when the seed settles.\n *   - `skipTriggers` suppresses record-change AUTOMATION (autolaunched flows),\n *                  not lifecycle hooks. Seed data is pre-existing end state,\n *                  not a stream of user events.\n *   - `seedReplay` skips the `state_machine` entry/transition guards, so a\n *                  mid-lifecycle row (a `closed_won` deal) is accepted.\n *\n * Lifecycle HOOKS \u2014 derived fields, defaults, validation \u2014 still run. The boot\n * log shows them firing (`opportunity_amount_rollup`, `quote_total_rollup`),\n * and `crm_account.billing_country` / `crm_account.territory` are only ever\n * populated because `account_protection` derives them from `billing_address`\n * on the seed insert (#638, #639). `test/territory-seed-coverage.test.ts` pins that dependency.\n *\n * ### What that means for authoring\n *\n * The old conclusion survives the corrected premise, and is still the rule:\n *\n * 1. Seeding historical values into readonly fields (`stage_entry_date`,\n *    `last_contacted_date`, `actual_revenue`, and the platform's own\n *    `created_at` \u2014 which the case seeds author since #1992) is legitimate\n *    and load-bearing \u2014 it is the only way demo reports get history \u2014 and the\n *    platform explicitly preserves explicit seed values (`created_at` on the\n *    first insert since @objectstack/objectql 17.7.0, objectstack#21646).\n * 2. Every seeded value of a hook-owned field MUST equal what the hook would\n *    compute (`is_closed` \u21D4 status, `resolution_time_hours` \u21D4 closed\u2212created,\n *    opportunity `probability`/`forecast_category`/`expected_revenue` \u21D4 stage,\n *    forecast `period_label` \u21D4 period_start). Under the corrected premise a\n *    mismatch is rewritten immediately, at seed time, instead of on the first\n *    user edit \u2014 either way the demo does not show what was authored.\n * 3. A field the hook DERIVES and the schema marks `readonly` is not authored\n *    here at all (`crm_account.billing_country`, `crm_account.territory`):\n *    duplicating it would create a second source of truth for a value the hook\n *    already owns.\n *\n * Autonumber fields (`case_number`, `contract_number`, `quote_number`) are\n * NEVER seeded: the runtime owns those sequences (the SQL driver bootstraps\n * each counter past existing rows), so hand-numbering them only invites\n * drift. Upsert identity uses a natural key instead (subject / name /\n * description).\n */\n\n/**\n * Build a CEL `daysAgo(N)` expression from a runtime number. Mirrors the\n * existing tagged-template usage (`cel\\`daysAgo(N)\\``) so we can produce\n * timestamps inside `.map()` generators without manufacturing fake template\n * string arrays.\n */\nexport const celDaysAgo = (n: number) => cel`daysAgo(${n})`;\nexport const celDaysFromNow = (n: number) => cel`daysFromNow(${n})`;\n\n/**\n * A configured product line. `unit_price` is the NEGOTIATED price (what the\n * rep sold at); the catalog `list_price` is stamped separately from the\n * product record, exactly as the price-fill hook would.\n */\nexport type LineSpec = {\n  readonly product: string;\n  readonly quantity: number;\n  readonly unit_price: number;\n  /** Line-level discount %, defaults to 0. */\n  readonly discount?: number;\n  readonly description: string;\n};\n\n/** `quantity \u00D7 unit_price \u00D7 (1 \u2212 discount/100)`, rounded exactly as the rollup hooks round. */\nexport const lineTotal = (l: LineSpec): number =>\n  Math.round(l.quantity * l.unit_price * (1 - (l.discount ?? 0) / 100) * 100) / 100;\n\nexport const linesTotal = (lines: readonly LineSpec[]): number =>\n  Math.round(lines.reduce((sum, l) => sum + lineTotal(l), 0) * 100) / 100;\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/sales/data/activity.seed.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/sales/data\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/sales/data/activity.seed.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\n/**\n * Activity seeds \u2014 the task list and the interaction log.\n *\n * `crm_task`, `crm_event` and `crm_event_attendee` are the activity layer over\n * every object in the app (accounts, opportunities AND cases), which is why\n * plan item 4 folds them into the app package rather than giving activities a\n * module of their own: \"activities are a cross-cutting capability no customer\n * buys separately\". Their rows were authored in `src/data/service.seed.ts`,\n * beside the cases they most often hang off; those cases are now\n * `src/service/data/service.seed.ts` and are referenced from here by natural\n * key exactly as before. The cases are registered by the service package and\n * these rows by the app package; measured on a fresh boot of the two-package\n * artifact (#1907), every seeded event's `related_to_case` resolves to a real\n * case.\n *\n * Seed doctrine lives in `./_shared.ts`.\n */\nimport { defineSeed } from '@objectstack/spec/data';\nimport { cel } from '@objectstack/spec';\nimport { Task } from '../objects/task.object';\nimport { Event } from '../objects/event.object';\nimport { EventAttendee } from '../objects/event_attendee.object';\nimport { celDaysAgo } from './_shared';\n\n// \u2500\u2500\u2500 Tasks \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n// Polymorphic parents need BOTH halves: `related_to_type` names the parent\n// object and the matching `related_to_*` lookup carries the record. The\n// Related tab and task.hook's activity bubble key off `related_to_type`, so a\n// lookup without it is invisible to both (#490).\nexport const tasks = defineSeed(Task, {\n  mode: 'upsert',\n  externalId: 'subject',\n  records: [\n    {\n      subject: 'Follow up with Acme on proposal',\n      description: 'Send Jordan Park the revised Enterprise proposal and a 30-min calendar slot to walk through the AI governance section.',\n      status: 'not_started',\n      priority: 'high',\n      priority_rank: 3,\n      due_date: cel`daysFromNow(2)`,\n      related_to_type: 'crm_opportunity',\n      related_to_account: 'Acme Corporation',\n      related_to_opportunity: 'Acme Platform Upgrade',\n    },\n    {\n      // The workshop this task asks someone to book is ALREADY on the\n      // calendar: the `Acme \u2014 AI agent governance workshop` event lower in\n      // this file is `planned` at daysFromNow(6), and the attendee builder\n      // dates its invitation `daysAgo(max(-6 + invitedDaysBefore(9), 0))` =\n      // daysAgo(3) \u2014 already sent, and already answered `tentative`. So the\n      // booking task is DONE, and it was done the day the invitation went\n      // out. An open \"schedule it\" task beside a booked-and-invited meeting\n      // is the contradiction itself, not a due date to nudge (#1660).\n      //\n      // The EVENT owns the workshop's date. Nothing here restates it \u2014 both\n      // dates below derive from the invitation instant \u2014 so there is no\n      // second copy to drift out of step.\n      subject: 'Acme \u2014 schedule AI governance workshop',\n      description: 'Block a 90-min joint workshop with Acme\u2019s compliance team to walk through how HotCRM agents handle data scoping, RBAC, audit trails, and human-in-the-loop. Pre-read: ADR-0007 + the governance demo deck.',\n      status: 'completed',\n      priority: 'high',\n      priority_rank: 3,\n      due_date: cel`daysAgo(3)`,\n      completed_date: cel`daysAgo(3)`,\n      // Hooks don't run over seeds \u2014 mirror what task_completion would stamp.\n      is_completed: true,\n      progress_percent: 100,\n      related_to_type: 'crm_opportunity',\n      related_to_account: 'Acme Corporation',\n      related_to_opportunity: 'Acme Platform Upgrade',\n    },\n    {\n      subject: 'Acme \u2014 close out login-issues ticket before SLA',\n      description: 'Confirm engineering has the EMEA SSO clock-skew patch ready, deploy to Acme\u2019s tenant, and send Lisa Kim a customer-facing post-mortem.',\n      status: 'in_progress',\n      priority: 'urgent',\n      priority_rank: 4,\n      due_date: cel`daysFromNow(1)`,\n      related_to_type: 'crm_case',\n      related_to_account: 'Acme Corporation',\n      related_to_case: 'Login issues after platform upgrade',\n    },\n    {\n      subject: 'Schedule demo for Globex team',\n      status: 'in_progress',\n      priority: 'normal',\n      priority_rank: 2,\n      due_date: cel`daysFromNow(5)`,\n      related_to_type: 'crm_account',\n      related_to_account: 'Globex Industries',\n    },\n    {\n      subject: 'Prepare contract for Wayne Enterprises',\n      status: 'not_started',\n      priority: 'urgent',\n      priority_rank: 4,\n      due_date: cel`daysFromNow(1)`,\n      related_to_type: 'crm_account',\n      related_to_account: 'Wayne Enterprises',\n    },\n    {\n      subject: 'Send welcome package to Stark Medical',\n      status: 'completed',\n      priority: 'low',\n      priority_rank: 1,\n      completed_date: cel`daysAgo(2)`,\n      // Hooks don't run over seeds \u2014 mirror what task_completion would stamp.\n      is_completed: true,\n      progress_percent: 100,\n      related_to_type: 'crm_account',\n      related_to_account: 'Stark Medical',\n    },\n    {\n      // Internal housekeeping task \u2014 deliberately unparented (the\n      // related_to_required rule is a warning, not an error).\n      subject: 'Update CRM pipeline report',\n      status: 'not_started',\n      priority: 'normal',\n      priority_rank: 2,\n      due_date: cel`daysFromNow(7)`,\n    },\n  ]\n});\n\n// \u2500\u2500\u2500 Events & attendees: the interaction log \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n//\n// #592 shipped the activity model \u2014 `crm_event`, `crm_event_attendee`, the\n// per-object log/schedule actions, the `event_metrics` cube and the Sales\n// Activity dashboard \u2014 and deliberately left the demo rows to this issue\n// (#671). Until now the demo booted with the whole model installed and not one\n// row in it: every widget on that dashboard read 0, the calendar and\n// interaction-history views were empty, and the three churn tiles had nothing\n// to stratify.\n//\n// # Time is authored in CEL, never in TypeScript\n//\n// `start_datetime` / `end_datetime` are `cel` expressions\n// (`daysAgo(12) + duration(\"9h0m\")`), resolved by the seed loader at BOOT.\n// Plain-TS dates would freeze into `dist/objectstack.json` at BUILD time, and a\n// published artifact would ship a calendar that ages out \u2014 the same hazard\n// `test/analytics-integrity.test.ts` guards on report filters. `daysAgo()`\n// alone returns UTC midnight, which is why the duration term is there: a\n// calendar object whose every row starts at 00:00 is a calendar nobody would\n// demo.\n//\n// # A `held` event stamps TODAY on its account \u2014 that is the whole layout rule\n//\n// Lifecycle hooks run over seed writes (#617), so `event_activity_bubble` fires\n// on these inserts and stamps `crm_account.last_activity_date` /\n// `crm_contact.last_contacted_date` / `crm_lead.last_contacted_date` with the\n// SEED MOMENT \u2014 not with the event's own timestamp. Nothing here can make an\n// account look quiet AND give it a held interaction; the two are the same\n// column. So the quiet accounts of `sales.seed.ts` carry only `planned`,\n// `cancelled` and `no_show` rows, none of which bubble, and the accounts that\n// do carry held rows are authored at `today()` there. The long note beside the\n// account records states the boundary; `test/activity-seed-coverage.test.ts`\n// recomputes the bubble's own reachability over these rows and fails if a held\n// event ever reaches an account the churn tiles depend on.\n//\n// # Upsert identity is `subject`\n//\n// Same choice as `crm_task` and `crm_case` above, and it carries the same known\n// cost: a user who logs an interaction under a subject this file also uses\n// would have their row adopted (and overwritten) by the next re-seed. The\n// forecast seeds escape that with a dedicated `seed_key` column (#613), which\n// is an OBJECT change and out of this issue's scope; the subjects below are\n// long and account-specific so the collision needs deliberate effort, and the\n// two activity-shaped objects that came before already accept the same trade.\n// No collision exists with the runtime writer's own rows: `log_call` /\n// `log_meeting` / `schedule_meeting` insert with an explicit `owner_id`\n// (`src/sales/actions/activity-actions.ts`), so they are never ownerless and the\n// platform's seed-ownership claim never touches them \u2014 the \"one producer per\n// window\" question #702 raised, answered for this object.\n\n/** Which `related_to_*` lookup carries each `related_to_type`. */\nconst EVENT_RELATED_FIELD = {\n  crm_account: 'related_to_account',\n  crm_contact: 'related_to_contact',\n  crm_opportunity: 'related_to_opportunity',\n  crm_lead: 'related_to_lead',\n  crm_case: 'related_to_case',\n} as const;\n\ntype EventRelatedType = keyof typeof EVENT_RELATED_FIELD;\n\ntype AttendeeSpec = {\n  /** Contact email \u2014 the contact dataset's externalId. Exclusive with `lead`. */\n  readonly contact?: string;\n  /** Lead email \u2014 the lead dataset's externalId. */\n  readonly lead?: string;\n  readonly response: 'accepted' | 'declined' | 'tentative' | 'no_response';\n};\n\ntype EventSpec = {\n  readonly subject: string;\n  readonly type: 'meeting' | 'call' | 'demo' | 'webinar' | 'onsite_visit' | 'other';\n  readonly status: 'held' | 'planned' | 'cancelled' | 'no_show';\n  /** Days before boot. NEGATIVE means that many days AFTER boot. */\n  readonly daysAgo: number;\n  /** UTC wall clock the slot opens at: `[hour, minute]`. */\n  readonly at: readonly [number, number];\n  /** Slot length in minutes \u2014 the gap between start and end on the calendar. */\n  readonly minutes: number;\n  readonly relatedType: EventRelatedType;\n  /** Natural key of the related record (that dataset's externalId). */\n  readonly relatedKey: string;\n  /**\n   * Account natural key, when the related record hangs off one. Authored on the\n   * event as well as implied through the parent \u2014 same shape the task seeds\n   * use, and it is what puts the row in the ACCOUNT's activity related list.\n   */\n  readonly account?: string;\n  readonly location?: string;\n  readonly description?: string;\n  readonly outcome?: string;\n  readonly attendees: readonly AttendeeSpec[];\n  /** Days before the event the invitation went out. Defaults to 3. */\n  readonly invitedDaysBefore?: number;\n};\n\n/**\n * A wall-clock instant on a day relative to the boot date.\n *\n * `daysAgo(n)` / `daysFromNow(n)` both return UTC midnight of that calendar\n * day, and CEL timestamp + duration arithmetic is what puts a real time on it.\n */\nconst celClock = (daysAgo: number, hour: number, minute: number) => {\n  const clock = `${hour}h${minute}m`;\n  return daysAgo >= 0\n    ? cel`daysAgo(${daysAgo}) + duration(${clock})`\n    : cel`daysFromNow(${-daysAgo}) + duration(${clock})`;\n};\n\n/**\n * The interaction log.\n *\n * `held` rows span all five `related_to_type` values and five of the six\n * `type` values across roughly nine weeks, because that is what the Sales\n * Activity dashboard reads: the mix donut groups by `type`, the \"where the\n * activity lands\" bar groups by `related_to_type`, and the volume area chart\n * buckets `start_datetime` by week. A block of rows in one week on one parent\n * would light every widget up while proving none of them.\n */\nconst EVENT_SPECS: readonly EventSpec[] = [\n  // \u2500\u2500\u2500 Acme Corporation \u2014 the hero account, worked across every parent \u2500\u2500\u2500\u2500\n  {\n    subject: 'Acme \u2014 Enterprise edition walkthrough',\n    type: 'demo', status: 'held', daysAgo: 2, at: [10, 0], minutes: 60,\n    relatedType: 'crm_opportunity', relatedKey: 'Acme Platform Upgrade', account: 'Acme Corporation',\n    location: 'Zoom',\n    outcome: 'Walked the Ops team through agent governance and the analytics seats. Revised proposal to follow this week.',\n    attendees: [{ contact: 'john.smith@acme.example.com', response: 'accepted' }],\n  },\n  {\n    subject: 'Acme \u2014 proposal follow-up call',\n    type: 'call', status: 'held', daysAgo: 5, at: [15, 30], minutes: 25,\n    relatedType: 'crm_contact', relatedKey: 'john.smith@acme.example.com', account: 'Acme Corporation',\n    outcome: 'Procurement wants an 18-month term. Pricing to be re-cut before the governance workshop.',\n    attendees: [{ contact: 'john.smith@acme.example.com', response: 'accepted' }],\n  },\n  {\n    subject: 'Acme \u2014 AI governance scoping session',\n    type: 'meeting', status: 'held', daysAgo: 12, at: [9, 0], minutes: 90,\n    relatedType: 'crm_account', relatedKey: 'Acme Corporation',\n    location: 'Google Meet',\n    outcome: 'Agreed the workshop agenda: data scoping, RBAC, audit trails, human-in-the-loop.',\n    attendees: [{ contact: 'john.smith@acme.example.com', response: 'accepted' }],\n  },\n  {\n    subject: 'Acme \u2014 login incident status call',\n    type: 'call', status: 'held', daysAgo: 16, at: [8, 30], minutes: 20,\n    relatedType: 'crm_case', relatedKey: 'Login issues after platform upgrade', account: 'Acme Corporation',\n    outcome: 'Confirmed the EMEA SSO clock-skew hypothesis; engineering reproducing in staging.',\n    attendees: [{ contact: 'john.smith@acme.example.com', response: 'accepted' }],\n  },\n  {\n    subject: 'Acme \u2014 renewal signature review',\n    type: 'meeting', status: 'held', daysAgo: 20, at: [14, 0], minutes: 45,\n    relatedType: 'crm_opportunity', relatedKey: 'Acme Annual Renewal 2025', account: 'Acme Corporation',\n    outcome: 'Signed two weeks ahead of the renewal date. Multi-year deferred to the upgrade decision.',\n    attendees: [{ contact: 'john.smith@acme.example.com', response: 'accepted' }],\n  },\n  {\n    subject: 'Acme \u2014 San Francisco HQ business review',\n    type: 'onsite_visit', status: 'held', daysAgo: 33, at: [13, 0], minutes: 120,\n    relatedType: 'crm_account', relatedKey: 'Acme Corporation',\n    location: '500 Howard Street, Suite 400, San Francisco',\n    outcome: 'Quarterly review with the CTO org. Expansion into the EMEA team confirmed as the next motion.',\n    attendees: [{ contact: 'john.smith@acme.example.com', response: 'accepted' }],\n  },\n\n  // \u2500\u2500\u2500 Wayne Enterprises \u2014 a deal in negotiation \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n  {\n    subject: 'Wayne \u2014 enterprise license negotiation',\n    type: 'meeting', status: 'held', daysAgo: 3, at: [16, 0], minutes: 60,\n    relatedType: 'crm_opportunity', relatedKey: 'Wayne Enterprise License', account: 'Wayne Enterprises',\n    location: 'Zoom',\n    outcome: 'Volume tier agreed at 20 tenants. Security addendum is the last open item.',\n    attendees: [{ contact: 'rwilson@wayne.example.com', response: 'accepted' }],\n  },\n  {\n    subject: 'Wayne \u2014 security addendum walkthrough',\n    type: 'call', status: 'held', daysAgo: 8, at: [11, 0], minutes: 30,\n    relatedType: 'crm_contact', relatedKey: 'rwilson@wayne.example.com', account: 'Wayne Enterprises',\n    outcome: 'Legal to return redlines within the week.',\n    attendees: [{ contact: 'rwilson@wayne.example.com', response: 'accepted' }],\n  },\n  {\n    subject: 'Wayne \u2014 platform governance webinar',\n    type: 'webinar', status: 'held', daysAgo: 26, at: [15, 0], minutes: 60,\n    relatedType: 'crm_account', relatedKey: 'Wayne Enterprises',\n    location: 'https://acme.example.com/webinars/governance',\n    outcome: 'Four business units attended; two asked for their own rollout plan.',\n    attendees: [{ contact: 'rwilson@wayne.example.com', response: 'accepted' }],\n  },\n  {\n    subject: 'Wayne \u2014 bulk import rollout check-in',\n    type: 'call', status: 'held', daysAgo: 45, at: [10, 30], minutes: 25,\n    relatedType: 'crm_case', relatedKey: 'Request: bulk import via CSV', account: 'Wayne Enterprises',\n    outcome: 'CSV import shipped and documented; the customer closed the request out on the call.',\n    attendees: [{ contact: 'rwilson@wayne.example.com', response: 'accepted' }],\n  },\n\n  // \u2500\u2500\u2500 Vertex Analytics \u2014 expansion, then an enterprise rollout \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n  {\n    subject: 'Vertex \u2014 rollout phasing and data residency',\n    type: 'meeting', status: 'held', daysAgo: 1, at: [9, 30], minutes: 75,\n    relatedType: 'crm_opportunity', relatedKey: 'Vertex Enterprise Rollout', account: 'Vertex Analytics',\n    location: 'Zoom',\n    outcome: 'Phase 1 scoped to four regions. Residency controls to be confirmed with their security team.',\n    attendees: [{ contact: 'ethan.brooks@vertex.example.com', response: 'accepted' }],\n  },\n  {\n    subject: 'Vertex \u2014 revenue analytics demo',\n    type: 'demo', status: 'held', daysAgo: 10, at: [14, 30], minutes: 45,\n    relatedType: 'crm_opportunity', relatedKey: 'Vertex Analytics Expansion', account: 'Vertex Analytics',\n    location: 'Zoom',\n    outcome: 'Sales, marketing and service leads all asked for their own workspace \u2014 the expansion case makes itself.',\n    attendees: [{ contact: 'ethan.brooks@vertex.example.com', response: 'accepted' }],\n  },\n  {\n    subject: 'Vertex \u2014 expansion buying committee call',\n    type: 'call', status: 'held', daysAgo: 19, at: [16, 30], minutes: 30,\n    relatedType: 'crm_contact', relatedKey: 'ethan.brooks@vertex.example.com', account: 'Vertex Analytics',\n    outcome: 'CRO owns the budget; the data team stays the technical sponsor.',\n    attendees: [{ contact: 'ethan.brooks@vertex.example.com', response: 'accepted' }],\n  },\n  {\n    subject: 'Vertex \u2014 developer platform retrospective',\n    type: 'meeting', status: 'held', daysAgo: 38, at: [11, 0], minutes: 60,\n    relatedType: 'crm_account', relatedKey: 'Vertex Analytics',\n    outcome: 'Three product teams live on the developer platform; usage analytics is the next ask.',\n    attendees: [{ contact: 'ethan.brooks@vertex.example.com', response: 'accepted' }],\n  },\n\n  // \u2500\u2500\u2500 Stark Medical \u2014 the partner motion \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n  {\n    subject: 'Stark Medical \u2014 Toronto clinical operations visit',\n    type: 'onsite_visit', status: 'held', daysAgo: 52, at: [9, 0], minutes: 180,\n    relatedType: 'crm_account', relatedKey: 'Stark Medical',\n    location: '181 Bay Street, Suite 2200, Toronto',\n    outcome: 'Two clinical service lines live on the pilot. Device-servicing expansion parked on budget.',\n    attendees: [{ contact: 'emily.d@starkmed.example.com', response: 'accepted' }],\n  },\n\n  // \u2500\u2500\u2500 Leads: the only held rows that touch a prospect's own clock \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n  {\n    subject: 'CloudFirst \u2014 qualification call with Lisa Thompson',\n    type: 'call', status: 'held', daysAgo: 1, at: [11, 0], minutes: 30,\n    relatedType: 'crm_lead', relatedKey: 'lisa.t@cloudfirst.example.com',\n    outcome: 'Budget confirmed and a technical evaluation agreed \u2014 qualified.',\n    attendees: [{ lead: 'lisa.t@cloudfirst.example.com', response: 'accepted' }],\n  },\n  {\n    subject: 'EduTech Labs \u2014 discovery call with David Kim',\n    type: 'call', status: 'held', daysAgo: 4, at: [13, 0], minutes: 30,\n    relatedType: 'crm_lead', relatedKey: 'dkim@edutechlabs.example.com',\n    outcome: 'Replacing spreadsheets across admissions. Referral source confirmed.',\n    attendees: [{ lead: 'dkim@edutechlabs.example.com', response: 'accepted' }],\n  },\n  // The earlier touch on each of the two leads above, so each lead's Activity\n  // tab reads as a short history rather than a single row. Both leads already\n  // carry `last_contacted_date: today()` for their later call, so a second held\n  // row moves no recency clock (`event_activity_bubble` stamps the seed moment).\n  {\n    subject: 'CloudFirst \u2014 follow-up meeting after the Cloud Summit booth',\n    type: 'meeting', status: 'held', daysAgo: 8, at: [15, 0], minutes: 45,\n    relatedType: 'crm_lead', relatedKey: 'lisa.t@cloudfirst.example.com',\n    outcome: 'Walked through pipeline and forecasting. Asked for a qualification call with finance.',\n    attendees: [{ lead: 'lisa.t@cloudfirst.example.com', response: 'accepted' }],\n  },\n  {\n    subject: 'EduTech Labs \u2014 referral intro call with David Kim',\n    type: 'call', status: 'held', daysAgo: 9, at: [10, 0], minutes: 15,\n    relatedType: 'crm_lead', relatedKey: 'dkim@edutechlabs.example.com',\n    outcome: 'Warm intro from the referring partner. Booked a proper discovery call.',\n    attendees: [{ lead: 'dkim@edutechlabs.example.com', response: 'accepted' }],\n  },\n\n  // \u2500\u2500\u2500 Booked, not held: the calendar ahead \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n  // These are what `status` exists for. Not one of them moves a recency clock,\n  // and the three re-engagement rows below sit on the accounts the churn tiles\n  // count \u2014 which is the demonstration, not an oversight.\n  {\n    subject: 'Acme \u2014 AI agent governance workshop',\n    type: 'meeting', status: 'planned', daysAgo: -6, at: [9, 0], minutes: 90,\n    relatedType: 'crm_opportunity', relatedKey: 'Acme Platform Upgrade', account: 'Acme Corporation',\n    location: 'Google Meet',\n    description: 'Joint workshop with Acme compliance: data scoping, RBAC, audit trails, human-in-the-loop.',\n    attendees: [{ contact: 'john.smith@acme.example.com', response: 'tentative' }],\n    invitedDaysBefore: 9,\n  },\n  {\n    subject: 'Wayne \u2014 procurement signature call',\n    type: 'meeting', status: 'planned', daysAgo: -1, at: [11, 0], minutes: 30,\n    relatedType: 'crm_opportunity', relatedKey: 'Wayne Enterprise License', account: 'Wayne Enterprises',\n    description: 'Confirm the signature date once the security addendum is closed.',\n    attendees: [{ contact: 'rwilson@wayne.example.com', response: 'accepted' }],\n    invitedDaysBefore: 4,\n  },\n  {\n    subject: 'Globex \u2014 manufacturing suite demo',\n    type: 'demo', status: 'planned', daysAgo: -5, at: [15, 0], minutes: 60,\n    relatedType: 'crm_opportunity', relatedKey: 'Globex Manufacturing Suite', account: 'Globex Industries',\n    location: 'Zoom',\n    description: 'Plant-operations demo for the six-site rollout, ahead of the qualification review.',\n    attendees: [{ contact: 'sarah.j@globex.example.com', response: 'accepted' }],\n    invitedDaysBefore: 8,\n  },\n  {\n    subject: 'Lattice \u2014 renewal proposal review',\n    type: 'meeting', status: 'planned', daysAgo: -3, at: [10, 0], minutes: 45,\n    relatedType: 'crm_opportunity', relatedKey: 'Lattice Education Renewal', account: 'Lattice Education',\n    description: 'Walk procurement through the two-year option before the executive sponsor meeting.',\n    attendees: [{ contact: 'priya.shah@lattice.example.com', response: 'accepted' }],\n    invitedDaysBefore: 6,\n  },\n  {\n    subject: 'Initech \u2014 re-engagement call before renewal',\n    type: 'call', status: 'planned', daysAgo: -2, at: [14, 0], minutes: 30,\n    relatedType: 'crm_account', relatedKey: 'Initech Solutions',\n    description: 'Nobody has spoken to Initech in ten weeks and the renewal is 75 days out. Re-open the relationship.',\n    attendees: [{ contact: 'mchen@initech.example.com', response: 'no_response' }],\n    invitedDaysBefore: 5,\n  },\n  {\n    subject: 'Northwind \u2014 grid modernization discovery workshop',\n    type: 'meeting', status: 'planned', daysAgo: -7, at: [9, 30], minutes: 120,\n    relatedType: 'crm_opportunity', relatedKey: 'Northwind Grid Modernization', account: 'Northwind Energy',\n    location: 'Leopoldstrasse 21, Munich',\n    description: 'Confirm discovery participants and agree the operational-data assessment scope.',\n    attendees: [{ contact: 'olivia.chen@northwind.example.com', response: 'tentative' }],\n    invitedDaysBefore: 10,\n  },\n  {\n    subject: 'Apex Logistics \u2014 data hub re-engagement call',\n    type: 'call', status: 'planned', daysAgo: -4, at: [16, 0], minutes: 30,\n    relatedType: 'crm_account', relatedKey: 'Apex Logistics',\n    description: 'The data-hub evaluation has been silent for a quarter. Re-establish the commercial sponsor.',\n    attendees: [{ contact: 'marcus.reed@apexlogistics.example.com', response: 'no_response' }],\n    invitedDaysBefore: 6,\n  },\n  {\n    subject: 'NextGen Retail \u2014 first discovery call with Alice Martinez',\n    type: 'call', status: 'planned', daysAgo: -2, at: [15, 0], minutes: 30,\n    relatedType: 'crm_lead', relatedKey: 'alice@nextgenretail.example.com',\n    description: 'Inbound web lead, booked on her follow-up date.',\n    attendees: [{ lead: 'alice@nextgenretail.example.com', response: 'no_response' }],\n    invitedDaysBefore: 3,\n  },\n\n  // \u2500\u2500\u2500 Neither held nor booked \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n  // `duration_minutes` is 0 on both, exactly as `event_schedule_derive`\n  // recomputes it: a meeting nobody attended occupies nobody's time, while the\n  // calendar slot it was booked into stays on the record as evidence of the\n  // attempt.\n  {\n    subject: 'Globex \u2014 line expansion review',\n    type: 'meeting', status: 'cancelled', daysAgo: 30, at: [14, 0], minutes: 60,\n    relatedType: 'crm_opportunity', relatedKey: 'Globex Line Expansion (Lost)', account: 'Globex Industries',\n    description: 'Cancelled by the customer: the incumbent MES vendor had already bundled the two lines.',\n    attendees: [{ contact: 'sarah.j@globex.example.com', response: 'declined' }],\n    invitedDaysBefore: 7,\n  },\n  {\n    subject: 'Initech \u2014 SSO configuration check-in',\n    type: 'call', status: 'no_show', daysAgo: 55, at: [10, 0], minutes: 30,\n    relatedType: 'crm_account', relatedKey: 'Initech Solutions',\n    description: 'Customer did not join. The last attempt to reach Initech before the account went quiet.',\n    attendees: [{ contact: 'mchen@initech.example.com', response: 'no_response' }],\n    invitedDaysBefore: 4,\n  },\n];\n\n/** `[hour, minute]` plus `minutes`, as the end-of-slot wall clock. */\nconst endClock = (spec: EventSpec): readonly [number, number] => {\n  const total = spec.at[0] * 60 + spec.at[1] + spec.minutes;\n  return [Math.floor(total / 60), total % 60];\n};\n\nexport const events = defineSeed(Event, {\n  mode: 'upsert',\n  externalId: 'subject',\n  records: EVENT_SPECS.map((spec) => {\n    const [endHour, endMinute] = endClock(spec);\n    return {\n      subject: spec.subject,\n      type: spec.type,\n      status: spec.status,\n      start_datetime: celClock(spec.daysAgo, spec.at[0], spec.at[1]),\n      end_datetime: celClock(spec.daysAgo, endHour, endMinute),\n      // Authored rather than left to the hook, and authored to the value the\n      // hook computes: `event_schedule_derive` measures the gap between the two\n      // timestamps above, then zeroes it for a cancelled / no-show row. Both\n      // branches agree with this literal, so the figure is right whether or not\n      // hooks fire over the seed write (`./_shared.ts`, doctrine rule 2).\n      duration_minutes: spec.status === 'cancelled' || spec.status === 'no_show' ? 0 : spec.minutes,\n      all_day: false,\n      related_to_type: spec.relatedType,\n      [EVENT_RELATED_FIELD[spec.relatedType]]: spec.relatedKey,\n      // The account link is authored on every row that has one, including rows\n      // whose `related_to_type` is the contact / opportunity / case \u2014 the same\n      // shape the task seeds use, and what fills the ACCOUNT's activity list.\n      ...(spec.account && spec.relatedType !== 'crm_account'\n        ? { related_to_account: spec.account }\n        : {}),\n      ...(spec.location ? { location: spec.location } : {}),\n      ...(spec.description ? { description: spec.description } : {}),\n      ...(spec.outcome ? { outcome_notes: spec.outcome } : {}),\n      // No `owner_id`: a seed cannot name a user (see `objectstack.composition.ts`,\n      // \"A seed can't name a user\"), so these rows land ownerless and the\n      // platform's seed-ownership claim hands them to the first administrator\n      // when the seed settles (#671, #1892).\n    };\n  }),\n});\n\n/**\n * Attendees, seeded as TWO datasets over one object, split by which party\n * lookup is populated \u2014 the same construction, for the same reason, as\n * `campaignMembersFromLeads` / `campaignMembersFromContacts`: the loader's\n * composite key is EMPTY when any component is null, which silently disables\n * dedupe and re-inserts every row on each replay boot.\n *\n * There is no third dataset for `sys_user` attendees, and no `is_organizer:\n * true` row anywhere below. The organiser of every one of these meetings is the\n * rep \u2014 a `sys_user` \u2014 and a seed cannot name a user: lookup values resolve\n * against the target's externalId, which only works inside the app's own\n * object graph. `activity-actions.ts` adds the organiser row at runtime, where\n * the id exists. Nothing is invented here to stand in for it.\n *\n * # The external guest, revisited (#740)\n *\n * #671 seeded no external-only attendee for a reason that has now EXPIRED, and\n * the note is updated rather than deleted because the reason was a defect, not\n * a taste: `attendee_type` had no `external` value, so the only way to store a\n * guest who is in no CRM object was to file the row under `contact` and leave\n * `crm_contact` empty \u2014 a seed that lies about its own discriminator. #740 added\n * the fourth option and made `attendee_resolves` / `attendee_type_exclusive`\n * enforce the pairing, so `{ attendee_type: 'external', external_name: \"\u2026\" }` is\n * now an honest, accepted row and seeding one is legitimate.\n *\n * It is still not seeded, on the narrower ground that survives: every row below\n * is drawn from a seeded contact or lead so the demo's related lists and churn\n * tiles hang together, and an invented outside counsel would buy a third\n * dataset (its own `externalId: ['crm_event', 'external_name']`, since the\n * loader's composite key is empty when a component is null) for one decorative\n * row that no view, cube or dashboard reads. The capability is proven where the\n * question actually is \u2014 on the real engine, in\n * `test/attendee-type-resolution.test.ts` \u2014 not in the fixture book. Add one\n * here the day a demo scenario genuinely has a guest in the room; nothing in\n * the metadata stands in the way any more.\n */\nconst attendeeRecords = (kind: 'contact' | 'lead') =>\n  EVENT_SPECS.flatMap((spec) =>\n    spec.attendees\n      .filter((a) => (kind === 'lead' ? a.lead : a.contact))\n      .map((a) => ({\n        crm_event: spec.subject,\n        attendee_type: kind,\n        ...(kind === 'lead' ? { crm_lead: a.lead } : { crm_contact: a.contact }),\n        response: a.response,\n        is_organizer: false,\n        // The invitation predates the slot. Clamped at 0 so a meeting booked\n        // for the day after tomorrow was invited today, never tomorrow.\n        invited_date: celDaysAgo(Math.max(spec.daysAgo + (spec.invitedDaysBefore ?? 3), 0)),\n      })),\n  );\n\nexport const eventAttendeesFromContacts = defineSeed(EventAttendee, {\n  mode: 'upsert',\n  externalId: ['crm_event', 'crm_contact'],\n  records: attendeeRecords('contact'),\n});\n\nexport const eventAttendeesFromLeads = defineSeed(EventAttendee, {\n  mode: 'upsert',\n  externalId: ['crm_event', 'crm_lead'],\n  records: attendeeRecords('lead'),\n});\n\n/**\n * The lead timeline pointers \u2014 what `log_call` would have written (#1258).\n *\n * A held interaction logged through `log_call` / `log_meeting`\n * (`src/sales/actions/activity-actions.ts`) writes three things: the\n * `crm_event`, its attendees, and one `sys_activity` row \u2014 the ADR-0052\n * ActivityPointer the lead's **Activity** tab reads\n * (`record:activity` \u2192 `sys_activity` by `{ object_name, record_id }`, filtered\n * to the `task` kind, which is `type: 'completed'`). The seeds above author the\n * first two for every held lead interaction; this dataset authors the third,\n * derived from the SAME specs so the two cannot drift apart.\n *\n * `record_id` and `source_id` carry NATURAL KEYS \u2014 the lead's email and the\n * event's subject. Both are `referenceVia` pointer pairs on the platform object\n * (`record_id` \u2194 `object_name`, `source_id` \u2194 `source_object`), so the seed\n * loader resolves each against the object its sibling column names and\n * refuses an unresolvable one loudly rather than storing the literal.\n *\n * Two platform facts bound what is authored here:\n *\n *   - `sys_activity` is `lifecycle.class: 'telemetry'` with\n *     `retention: { maxAge: '14d' }`, so only interactions younger than a\n *     fortnight are seeded \u2014 an older row would be reaped before anyone demos\n *     it. The filter below enforces that rather than trusting the spec list.\n *   - A seed cannot name a user, so `actor_id` / `actor_name` are not authored\n *     (see `objectstack.composition.ts`, \"A seed can't name a user\"). The\n *     action stamps the rep at runtime, where the id exists.\n */\nconst SYS_ACTIVITY_RETENTION_DAYS = 14;\n\n/**\n * The summary prefix of the action that logs each held event type \u2014 the two\n * writers that exist (`LOG_CALL_SPEC` / `LOG_MEETING_SPEC`). A held event of\n * any other type has no action that would have written a pointer for it, so it\n * gets none here either: this dataset mirrors a writer, it is not a fourth one.\n */\nconst LOGGED_SUMMARY_PREFIX: Partial<Record<EventSpec['type'], string>> = {\n  call: '',\n  meeting: 'Meeting: ',\n};\n\nexport const leadInteractionPointers = {\n  object: 'sys_activity',\n  mode: 'upsert' as const,\n  // One timeline pointer per rich source record, exactly as the action writes\n  // it. Matched on the RESOLVED ids, so replay boots dedupe.\n  externalId: ['source_object', 'source_id'],\n  records: EVENT_SPECS.filter(\n    (spec) =>\n      spec.relatedType === 'crm_lead' &&\n      spec.status === 'held' &&\n      LOGGED_SUMMARY_PREFIX[spec.type] !== undefined &&\n      spec.daysAgo >= 0 &&\n      spec.daysAgo < SYS_ACTIVITY_RETENTION_DAYS,\n  ).map((spec) => {\n    const [endHour, endMinute] = endClock(spec);\n    return {\n      // `held` is what both actions write as `completed` \u2014 the `task` feed\n      // kind, the one the lead Activity tab renders.\n      type: 'completed',\n      // The action's own summary: prefix, subject, duration in brackets.\n      summary: `${LOGGED_SUMMARY_PREFIX[spec.type]}${spec.subject} (${spec.minutes} min)`,\n      // Logged when the slot ended.\n      timestamp: celClock(spec.daysAgo, endHour, endMinute),\n      object_name: 'crm_lead',\n      record_id: spec.relatedKey,\n      source_object: 'crm_event',\n      source_id: spec.subject,\n      metadata: JSON.stringify({\n        kind: spec.type,\n        duration_minutes: spec.minutes,\n        notes: spec.outcome ?? '',\n        attendee_count: spec.attendees.length,\n      }),\n    };\n  }),\n};\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/sales/data/forecast.seed.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/sales/data\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/sales/data/forecast.seed.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\n/**\n * Forecast seeds \u2014 the quarterly and monthly snapshot rows.\n *\n * `crm_forecast` is a sales object (plan item 4: the customer core and the\n * activity objects fold into the app package), so its seed rows are sales' \u2014\n * they were authored in `src/data/revenue.seed.ts` because a forecast is a\n * revenue NUMBER, but the assignment rule follows the object, not the subject.\n * Seed doctrine lives in `./_shared.ts`.\n */\nimport { defineSeed } from '@objectstack/spec/data';\nimport { cel } from '@objectstack/spec';\nimport { Forecast } from '../objects/forecast.object';\n\n// \u2500\u2500\u2500 Forecasts \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n// `owner_id` is left unset: a seed cannot name a user and seed writes run\n// `isSystem`, so nothing stamps it \u2014 ownership is backfilled by the platform's\n// seed-ownership claim when the seed settles, which covers `crm_forecast`\n// alongside every other owner-scoped object (#702, #1892). See the note on\n// ownership in `objectstack.composition.ts`.\n//\n// \u2500\u2500\u2500 ONE PRODUCER PER WINDOW (#702) \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n//\n// `forecast_snapshot` (#590) upserts the row whose window contains today, and\n// its lookup is OWNER-SCOPED:\n//\n//     { owner_id: '{currentOwner.id}', period: 'quarter',\n//       period_start: { $lte: '{TODAY()}' }, period_end: { $gte: '{TODAY()}' } }\n//\n// A seeded row in that same window can never satisfy that filter at the moment\n// the sweep reads it \u2014 the seed writes no owner, and the claim is a separate,\n// later sweep \u2014 so the flow concludes the period is missing and opens a SECOND\n// row beside it. Both span the same quarter; one has an owner and one does not.\n// Every owner-grouped consumer then renders a phantom, ownerless duplicate for\n// the current quarter, on every re-seeded dev boot (`quota_attainment_by_rep`\n// most visibly, since it pins exactly that window).\n//\n// Claiming the row does not fix that, it only re-labels the phantom: whichever\n// of the two scheduled sweeps reaches the window first decides whether the\n// second one adopts the row or duplicates it, and a duplicate never heals.\n//\n// So the seeds stop at the window's edge. They ship SETTLED quarters only, plus\n// the current MONTH \u2014 a window no runtime writer touches, since the sweep's\n// period is fixed to `quarter`. The current quarter belongs to\n// `forecast_snapshot` alone. `test/forecast-seeds.test.ts` derives the\n// forbidden window from the flow's own lookup filter and fails on any seeded\n// row that lands inside it.\n//\n// The cost, stated rather than hidden: on a freshly seeded org the Sales\n// dashboard's *Quota Attainment by Rep* table is empty until the 03:00 sweep\n// opens the quarter's rows, and their `quota` stays blank until someone sets\n// one by hand (`quota` has no automated writer \u2014 see `forecast.object.ts`).\n// That is the same honest-empty state the widget already chooses at a quarter\n// boundary; the alternative was a row attributed to nobody, carrying a quota no\n// rep is on the hook for.\n//\n// Periods are REAL calendar periods, labelled exactly the way\n// forecast.hook.ts derives them ('Q3 2026' / 'Aug 2026') \u2014 hooks don't run\n// over seeds, and the hook only fills a BLANK period_label, so seeded rows\n// must speak the same dialect as runtime snapshots or list views end up\n// mixing 'This Quarter' with 'Q3 2026' (#490). Calendar-true `period_start`\n// values carry the same obligation on the QUERY side: `period_start` is one\n// half of the (owner, period, period_start) key the snapshot sweep upserts on,\n// the object indexes, and every period-scoped surface pins by equality \u2014 a\n// value that is not the period's real first day names a row no such filter can\n// ever select, and no rollup can line up against its neighbours.\n//\n// What these rows must NOT do is answer a CURRENT-quarter filter: per #702 that\n// window belongs to `forecast_snapshot` alone, so the seeds below ship settled\n// quarters plus the current month, and `this_quarter_forecasts` /\n// `quota_attainment_by_rep` correctly return none of them.\n//\n// (The sentence that stood here said the opposite \u2014 that these values make the\n// `this_quarter_forecasts` view's `{this_quarter_start}` filter \"match the\n// seeded row\". Corrected in #744, and it was wrong three ways:\n// `{this_quarter_start}` is not in the token vocabulary \u2014 the spelling is\n// `{current_quarter_start}`, and since 17.0.0-rc.0 the misspelling throws\n// `Unresolvable filter placeholder` instead of silently matching nothing; the\n// filter itself was removed from the view in #515 and only came back in #730;\n// and matching is the outcome #702 rules out.)\n//\n// Computed in plain TS (UTC, mirroring the hook's helpers): this module is\n// evaluated when the app bundle loads, the same moment the cel`...` seeds\n// are resolved.\nconst FORECAST_MONTHS = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'];\nconst forecastIsoDate = (d: Date) =>\n  `${d.getUTCFullYear()}-${String(d.getUTCMonth() + 1).padStart(2, '0')}-${String(d.getUTCDate()).padStart(2, '0')}`;\nconst forecastQuarterLabel = (d: Date) => `Q${Math.floor(d.getUTCMonth() / 3) + 1} ${d.getUTCFullYear()}`;\nconst forecastMonthLabel = (d: Date) => `${FORECAST_MONTHS[d.getUTCMonth()]} ${d.getUTCFullYear()}`;\nconst forecastNow = new Date();\nconst forecastYear = forecastNow.getUTCFullYear();\nconst forecastMonth = forecastNow.getUTCMonth();\nconst forecastQuarterMonth = Math.floor(forecastMonth / 3) * 3;\n// No `thisQuarterStart` / `thisQuarterEnd`: that window is `forecast_snapshot`'s\n// and nothing here may open a row in it (#702, note above).\nconst thisMonthStart = new Date(Date.UTC(forecastYear, forecastMonth, 1));\nconst thisMonthEnd = new Date(Date.UTC(forecastYear, forecastMonth + 1, 0));\nconst lastQuarterStart = new Date(Date.UTC(forecastYear, forecastQuarterMonth - 3, 1));\nconst lastQuarterEnd = new Date(Date.UTC(forecastYear, forecastQuarterMonth, 0));\n// Deeper history: quota-attainment and coverage trends need more than a single\n// prior period to plot (#591). These are all SETTLED periods \u2014 deliberately so:\n// the forecast snapshot sweep upserts the CURRENT quarter, so historical rows\n// can never collide with what it writes. That rule is now the whole rule for\n// quarters (#702): every quarterly seed below is settled.\nconst quarterStartAgo = (n: number) => new Date(Date.UTC(forecastYear, forecastQuarterMonth - 3 * n, 1));\nconst quarterEndAgo = (n: number) => new Date(Date.UTC(forecastYear, forecastQuarterMonth - 3 * (n - 1), 0));\nconst monthStartAgo = (n: number) => new Date(Date.UTC(forecastYear, forecastMonth - n, 1));\nconst monthEndAgo = (n: number) => new Date(Date.UTC(forecastYear, forecastMonth - n + 1, 0));\n\n/**\n * The three open-pipeline buckets of a settled snapshot, in the shape the\n * forecast object defines them (`src/sales/objects/forecast.object.ts`).\n *\n * The buckets are CUMULATIVE subsets of one another, so every row satisfies\n * `pipeline >= bestCase >= commit`. Named rather than positional: three bare\n * numbers in a row of eight arguments is the shape a later edit transposes\n * without anything noticing.\n */\ntype OpenBuckets = { pipeline: number; bestCase: number; commit: number };\n\n/**\n * A settled (past) period snapshot, captured on the day the period closed.\n *\n * `open` is what was still OPEN in the period at that moment \u2014 the deals that\n * had not resolved by the last day and went on to slip into the next period.\n *\n * These rows carried `0` for all three buckets until #1244. The theory was\n * \"a closed period has no pipeline left\", and it is the one reading a\n * period-END snapshot cannot have: a period ends with deals still open, which\n * is exactly what the \"slipped into the next quarter\" note below describes.\n * The cost was not cosmetic \u2014 `pipeline_amount`, `best_case_amount`,\n * `commit_amount` and the `coverage_ratio` formula that divides by the first\n * of them are four of the thirteen columns the forecast list renders, so the\n * module opened on six rows of zeros and could not answer the question the\n * object exists for.\n *\n * NOT a licence to seed the CURRENT quarter: that window has exactly one\n * producer, `forecast_snapshot` (#702), and the note above is the whole rule.\n * Pinned by `test/forecast-seeds.test.ts`.\n */\nconst closedPeriod = (\n  seed_key: string,\n  period: 'month' | 'quarter',\n  start: Date,\n  end: Date,\n  quota: number,\n  closed: number,\n  open: OpenBuckets,\n  notes: string,\n) => ({\n  seed_key,\n  period,\n  period_label: period === 'quarter' ? forecastQuarterLabel(start) : forecastMonthLabel(start),\n  period_start: forecastIsoDate(start),\n  period_end: forecastIsoDate(end),\n  snapshot_date: forecastIsoDate(end),\n  quota,\n  pipeline_amount: open.pipeline,\n  best_case_amount: open.bestCase,\n  commit_amount: open.commit,\n  closed_amount: closed,\n  source: 'scheduled' as const,\n  notes,\n});\n\n// Upsert identity is the synthetic `seed_key`, NOT `period_label` (#613).\n// `period_label` names a SET of rows once the forecast_snapshot sweep (#590)\n// writes one per active owner per quarter \u2014 all reading 'Q3 2026' \u2014 and the\n// loader matches against the whole table, so a re-seed could overwrite a real\n// rep's snapshot with the demo numbers. Why a synthetic key and not the true\n// (owner, period, period_start) identity or an insert-once mode: see the\n// `seed_key` declaration in `src/sales/objects/forecast.object.ts`.\n//\n// The keys are POSITIONAL ('current month', 'two quarters back'), not calendar\n// values, because the records are positional \u2014 recomputed against `new Date()`\n// on every import. A positional key keeps the demo at exactly these seven rows\n// as the calendar rolls forward, re-pointing each at its new period; a\n// calendar-derived key would strand last quarter's demo row and add one row per\n// re-seed.\n//\n// There is no `demo_quarter_current`: the current quarter is the one window\n// `forecast_snapshot` writes, and two producers in one window is what #702 was.\n// The current MONTH stays \u2014 the sweep's period is `quarter`, so no runtime\n// writer opens a monthly row.\nexport const forecasts = defineSeed(Forecast, {\n  mode: 'upsert',\n  externalId: 'seed_key',\n  records: [\n    {\n      seed_key: 'demo_month_current',\n      period: 'month',\n      period_label: forecastMonthLabel(thisMonthStart),\n      period_start: forecastIsoDate(thisMonthStart),\n      period_end: forecastIsoDate(thisMonthEnd),\n      snapshot_date: cel`today()`,\n      quota: 500000,\n      pipeline_amount: 760000,\n      best_case_amount: 540000,\n      commit_amount: 360000,\n      closed_amount: 295000,\n      source: 'scheduled',\n      notes: 'Healthy coverage; two commit deals expected to close this week.',\n    },\n    {\n      seed_key: 'demo_quarter_minus_1',\n      period: 'quarter',\n      period_label: forecastQuarterLabel(lastQuarterStart),\n      period_start: forecastIsoDate(lastQuarterStart),\n      period_end: forecastIsoDate(lastQuarterEnd),\n      snapshot_date: forecastIsoDate(lastQuarterEnd),\n      quota: 1400000,\n      pipeline_amount: 240000,\n      best_case_amount: 150000,\n      commit_amount: 95000,\n      closed_amount: 1485000,\n      source: 'scheduled',\n      notes: 'Closed at 106% of quota.',\n    },\n    closedPeriod('demo_quarter_minus_2', 'quarter', quarterStartAgo(2), quarterEndAgo(2), 1300000, 1196000,\n      { pipeline: 285000, bestCase: 190000, commit: 120000 },\n      'Closed at 92% of quota \u2014 two enterprise deals slipped into the next quarter.'),\n    closedPeriod('demo_quarter_minus_3', 'quarter', quarterStartAgo(3), quarterEndAgo(3), 1200000, 1308000,\n      { pipeline: 195000, bestCase: 130000, commit: 85000 },\n      'Closed at 109% of quota, carried by the enterprise renewal cohort.'),\n    closedPeriod('demo_quarter_minus_4', 'quarter', quarterStartAgo(4), quarterEndAgo(4), 1100000, 1045000,\n      { pipeline: 165000, bestCase: 110000, commit: 70000 },\n      'Closed at 95% of quota in the first quarter on the new territory model.'),\n    closedPeriod('demo_month_minus_1', 'month', monthStartAgo(1), monthEndAgo(1), 480000, 505000,\n      { pipeline: 96000, bestCase: 62000, commit: 40000 },\n      'Closed at 105% of quota; the expansion motion covered a soft new-business month.'),\n    closedPeriod('demo_month_minus_2', 'month', monthStartAgo(2), monthEndAgo(2), 460000, 414000,\n      { pipeline: 92000, bestCase: 58000, commit: 35000 },\n      'Closed at 90% of quota \u2014 summer slowdown across the mid-market segment.'),\n  ]\n});\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/sales/data/index.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/sales/data\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/sales/data/index.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\n/**\n * Sales seed data, and the composition knob every package's rows are selected\n * by.\n *\n * The rows themselves are authored per object family in the `*.seed.ts`\n * modules beside this file; `objectstack.composition.ts` collects all four\n * directories' families into the single ordered `CrmSeedData` union and cuts it\n * by owning package \u2014 each package stack registers the families whose object\n * it owns.\n * That assembly is NOT here, and cannot be: it names `crm_product`,\n * `crm_case`, `crm_campaign` and the rest, which are other packages' objects,\n * and a sales file may import from its own directory or from `src/sales/` only\n * (plan item 7). The ORDER it assembles in is load-bearing \u2014 rows reference\n * rows seeded earlier \u2014 so it lives in the one file that can see all four.\n *\n * Where to add a row follows from the object:\n *\n *   - `_shared.ts`        seed doctrine + helpers every package's rows use\n *   - `sales.seed.ts`     accounts, contacts, leads, opportunities\n *   - `activity.seed.ts`  tasks, events, event attendees\n *   - `forecast.seed.ts`  forecast snapshots\n *   - `src/revenue/data/` products, opportunity lines, contracts, quotes, quote lines\n *   - `src/service/data/` cases, knowledge articles\n *   - `src/marketing/data/` campaigns, campaign members\n */\nexport { accounts, contacts, leads, opportunities, OPPORTUNITY_LINES } from './sales.seed';\nexport { tasks, events, eventAttendeesFromContacts, eventAttendeesFromLeads, leadInteractionPointers } from './activity.seed';\nexport { forecasts } from './forecast.seed';\nexport { celDaysAgo, celDaysFromNow, lineTotal, linesTotal, type LineSpec } from './_shared';\n\n// \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500 the SaaS / multi-org composition \u2500\u2500\n\n/**\n * Which SHAPE of this app a build assembles (#1361).\n *\n * `default` is the community/single-org app and is what every build produces\n * unless something asks otherwise \u2014 the demo org and its storytelling data,\n * which the platform's seed-settle ownership claim binds to the first platform\n * administrator.\n *\n * `saas` is the shape a multi-org operator deploys on the enterprise runtime\n * under a walled tenancy posture (`OS_TENANCY_POSTURE=isolated`). The two\n * differ ONLY by what the composition registers; no code branches at runtime,\n * nothing is decided per tenant, and no enterprise package is imported. See\n * {@link SaasTenantSeedData} for why the seed set shrinks and\n * `objectstack.composition.ts` for the permission half.\n */\nexport type HotCrmComposition = 'default' | 'saas';\n\n/** The environment variable {@link resolveComposition} reads. */\nexport const COMPOSITION_ENV_VAR = 'HOTCRM_COMPOSITION';\n\n/** Every value {@link resolveComposition} accepts, for diagnostics and tests. */\nexport const HOTCRM_COMPOSITIONS: readonly HotCrmComposition[] = ['default', 'saas'];\n\n/**\n * Resolve the composition from the environment \u2014 and REFUSE anything else.\n *\n * The refusal is the point, and it is why this is a function rather than a\n * `=== 'saas'` comparison at the one call site. The failure mode a silent\n * default produces is not \"the build is a bit wrong\": `HOTCRM_COMPOSITION=sass`\n * would assemble the FULL demo union, and the operator would only find out when\n * every tenant they onboard receives nine accounts named after other people's\n * companies \u2014 a data-shape mistake that is expensive to unwind once tenants\n * have edited those rows. An unrecognised value therefore throws at\n * config-load time, where a build fails loudly and nothing has shipped.\n *\n * Unset and empty both mean `default`, deliberately: \"no opinion\" is the\n * community app, so no existing build, script or CI job changes behaviour by\n * saying nothing (`pnpm build`, `objectstack validate`, the cloud EE rigs'\n * `scripts/build-hotcrm-artifact.sh`).\n */\nexport function resolveComposition(\n  raw: string | undefined = process.env[COMPOSITION_ENV_VAR],\n): HotCrmComposition {\n  const value = (raw ?? '').trim();\n  if (value === '') return 'default';\n  if ((HOTCRM_COMPOSITIONS as readonly string[]).includes(value)) {\n    return value as HotCrmComposition;\n  }\n  throw new Error(\n    `${COMPOSITION_ENV_VAR}=\"${value}\" is not a HotCRM composition. ` +\n      `Expected one of: ${HOTCRM_COMPOSITIONS.join(', ')} (or leave it unset for 'default').`,\n  );\n}\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/revenue/data/catalog.seed.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/revenue/data\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/revenue/data/catalog.seed.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\n/**\n * Product catalogue seeds \u2014 and the two helpers that read prices back out of\n * it, so a line item's `list_price` can never disagree with the catalogue.\n *\n * Split out of the former monolithic `src/data/index.ts` (#635). Seed doctrine\n * lives in `src/sales/data/_shared.ts`.\n */\nimport { defineSeed } from '@objectstack/spec/data';\nimport { Product } from '../objects/product.object';\nimport type { LineSpec } from '../../sales/data/_shared';\n\n// \u2500\u2500\u2500 Products \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n// The catalog is what every line item below prices against, so it has to be\n// wide enough to configure a realistic deal: an edition, an add-on, a\n// per-seat subscription, support tiers and professional services. Four\n// products could not (#591).\n//\n// `cost` is populated on every product: `cost_less_than_price` is a real\n// validation rule that \"has never once evaluated\" while the field was blank\n// everywhere, and margin is what the product-mix analytics are for. Every row\n// keeps cost strictly below list price.\nexport const products = defineSeed(Product, {\n  mode: 'upsert',\n  externalId: 'name',\n  records: [\n    {\n      name: 'ObjectStack Platform',\n      description: 'The enterprise edition: unlimited objects, AI agents, governance and audit.',\n      category: 'software',\n      family: 'enterprise',\n      sku: 'OS-PLAT-ENT',\n      list_price: 50000,\n      cost: 12000,\n      is_active: true,\n    },\n    {\n      name: 'ObjectStack Platform (SMB Edition)',\n      description: 'The mid-market edition: core CRM objects and automation, capped agent usage.',\n      category: 'software',\n      family: 'smb',\n      sku: 'OS-PLAT-SMB',\n      list_price: 18000,\n      cost: 4500,\n      is_active: true,\n    },\n    {\n      name: 'Cloud Hosting (Annual)',\n      description: 'Managed hosting with regional data residency and a 99.9% availability target.',\n      category: 'subscription',\n      family: 'cloud',\n      sku: 'OS-CLOUD-HOST',\n      list_price: 12000,\n      cost: 4200,\n      is_active: true,\n    },\n    {\n      name: 'Sandbox Environment (Annual)',\n      description: 'A full-copy non-production environment for testing metadata changes before release.',\n      category: 'subscription',\n      family: 'cloud',\n      sku: 'OS-CLOUD-SBX',\n      list_price: 7500,\n      cost: 2600,\n      is_active: true,\n    },\n    {\n      name: 'AI Agent Seat (Annual)',\n      description: 'A named-user seat for the Co-Pilot and agent surfaces, billed annually.',\n      category: 'subscription',\n      family: 'cloud',\n      sku: 'OS-AI-SEAT',\n      list_price: 1000,\n      cost: 260,\n      is_active: true,\n    },\n    {\n      name: 'Analytics Add-on',\n      description: 'Dashboards, cubes and scheduled reporting for the revenue organization.',\n      category: 'software',\n      family: 'enterprise',\n      sku: 'OS-ADDON-ANL',\n      list_price: 22000,\n      cost: 6500,\n      is_active: true,\n    },\n    {\n      name: 'Integration Connector Pack',\n      description: 'Pre-built connectors for ERP, marketing automation and data warehouse targets.',\n      category: 'software',\n      family: 'enterprise',\n      sku: 'OS-ADDON-INT',\n      list_price: 16000,\n      cost: 5200,\n      is_active: true,\n    },\n    {\n      name: 'Field Service Mobile',\n      description: 'Offline-capable mobile app for field technicians and route-based service work.',\n      category: 'software',\n      family: 'smb',\n      sku: 'OS-ADDON-FSM',\n      list_price: 14000,\n      cost: 4200,\n      is_active: true,\n    },\n    {\n      name: 'Premium Support',\n      description: '24\u00D77 support with a one-hour P1 response target and a named technical account manager.',\n      category: 'support',\n      family: 'services',\n      sku: 'OS-SUP-PREM',\n      list_price: 25000,\n      cost: 9000,\n      is_active: true,\n    },\n    {\n      name: 'Standard Support',\n      description: 'Business-hours support with a next-business-day response target.',\n      category: 'support',\n      family: 'services',\n      sku: 'OS-SUP-STD',\n      list_price: 9000,\n      cost: 3600,\n      is_active: true,\n    },\n    {\n      name: 'Implementation Services',\n      description: 'Guided implementation: discovery, metadata build, integration and go-live support.',\n      category: 'service',\n      family: 'services',\n      sku: 'OS-SVC-IMPL',\n      list_price: 75000,\n      cost: 41000,\n      is_active: true,\n    },\n    {\n      name: 'Data Migration Services',\n      description: 'Extraction, mapping and reconciliation of legacy CRM and spreadsheet data.',\n      category: 'service',\n      family: 'services',\n      sku: 'OS-SVC-MIGR',\n      list_price: 35000,\n      cost: 19000,\n      is_active: true,\n    },\n    {\n      name: 'Admin Training Workshop',\n      description: 'A one-day workshop for administrators on metadata, permissions and analytics.',\n      category: 'service',\n      family: 'services',\n      sku: 'OS-SVC-TRN',\n      list_price: 6000,\n      cost: 2400,\n      is_active: true,\n    },\n  ]\n});\n\n/**\n * Catalog price of a seeded product, read back from the dataset above so the\n * price lives in exactly one place.\n *\n * Line items carry `list_price` explicitly because hooks do NOT run over seeds\n * (#490): the shared price-fill hook (`_line-item-price-fill.ts`) is what\n * stamps `list_price` from `crm_product.list_price` on a real write, so a\n * seeded line has to arrive already carrying what that hook would have\n * written. Reading it from the catalog record makes that literally impossible\n * to get wrong.\n */\nexport const catalogPrice = (productName: string): number => {\n  const product = products.records.find((r) => r.name === productName);\n  if (!product || typeof product.list_price !== 'number') {\n    throw new Error(`Seed error: no catalog product named \"${productName}\"`);\n  }\n  return product.list_price;\n};\n\n/**\n * Flatten a `{ parent \u2192 lines }` table into seed records for one line-item\n * object. `list_price` and `line_number` are the two fields a real write gets\n * from machinery a seed cannot count on (the price-fill hook, and the quote /\n * opportunity line editors), so both are materialised here \u2014 the row is then\n * correct whether or not the hook fires over a seed write (#617).\n */\nexport const lineItemRecords = <K extends string>(\n  parentField: K,\n  table: Record<string, readonly LineSpec[]>,\n): Array<Record<string, unknown>> =>\n  Object.entries(table).flatMap(([parent, lines]) =>\n    lines.map((l, i) => ({\n      [parentField]: parent,\n      crm_product: l.product,\n      description: l.description,\n      quantity: l.quantity,\n      list_price: catalogPrice(l.product),\n      unit_price: l.unit_price,\n      discount: l.discount ?? 0,\n      line_number: i + 1,\n    })),\n  );\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/revenue/data/opportunity-line-item.seed.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/revenue/data\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/revenue/data/opportunity-line-item.seed.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport { defineSeed } from '@objectstack/spec/data';\nimport { OpportunityLineItem } from '../objects/opportunity_line_item.object';\nimport { lineItemRecords } from './catalog.seed';\nimport { OPPORTUNITY_LINES } from '../../sales/data/sales.seed';\n\n/**\n * Opportunity line item seed rows.\n *\n * `crm_opportunity_line_item` is a revenue object, so its seed rows are the\n * revenue package's (plan item 5: an item lives with the object it is authored\n * against) \u2014 while the LINES themselves stay with the opportunities they price.\n * `OPPORTUNITY_LINES` is read from `src/sales/data/sales.seed.ts` along the\n * revenue -> sales edge, and it has to be: the same table is what\n * `dealValue()` derives every opportunity's `amount` from, so a second copy\n * here would be a second answer to what a deal is worth.\n *\n * \u2500\u2500\u2500 Opportunity line items \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n * Identity is the COMPOSITE natural key (opportunity, product): the object has\n * no single natural key \u2014 no name, and `line_number` is only unique within a\n * parent \u2014 and a junction-shaped dataset without one can only run\n * `mode: 'insert'`, which re-inserts every row on each replay boot and\n * duplicates the table (framework#3434). The loader matches composite key\n * fields by their RESOLVED ids, so this dedupes correctly across restarts.\n * The practical constraint it imposes: a product appears at most once per\n * deal, which is how these lines are authored anyway.\n */\nexport const opportunityLineItems = defineSeed(OpportunityLineItem, {\n  mode: 'upsert',\n  externalId: ['crm_opportunity', 'crm_product'],\n  records: lineItemRecords('crm_opportunity', OPPORTUNITY_LINES),\n});\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/revenue/data/revenue.seed.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/revenue/data\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/revenue/data/revenue.seed.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\n/**\n * Revenue seeds \u2014 contracts, quotes and their lines.\n *\n * Split out of the former monolithic `src/data/index.ts` (#635). Seed doctrine\n * lives in `src/sales/data/_shared.ts`.\n */\nimport { defineSeed } from '@objectstack/spec/data';\nimport { cel } from '@objectstack/spec';\nimport { Contract } from '../objects/contract.object';\nimport { Quote } from '../objects/quote.object';\nimport { QuoteLineItem } from '../objects/quote_line_item.object';\nimport { linesTotal, type LineSpec } from '../../sales/data/_shared';\nimport { lineItemRecords } from './catalog.seed';\nimport { OPPORTUNITY_LINES } from '../../sales/data/sales.seed';\n\n// \u2500\u2500\u2500 Contracts \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n// `contract_number` is a runtime-owned autonumber and is NOT seeded (#490).\n// Contract has no natural-name field, so the (unique, stable) description\n// doubles as the upsert identity for these fixtures.\nexport const contracts = defineSeed(Contract, {\n  mode: 'upsert',\n  externalId: 'description',\n  records: [\n    // The one ACTIVATED contract in the app \u2014 `contract_renewal`,\n    // `contract_expiration` and `billing_handoff` all filter on exactly that\n    // status \u2014 so it has to be a contract that was really signed, off a deal\n    // that was really won.\n    //\n    // It used to link `Acme Platform Upgrade` and carry that deal's line total\n    // (150000) while that deal is still `proposal`, closing `daysFromNow(30)`\n    // (#1661). Nothing in this app can produce that pairing: `quote_on_accepted`\n    // close-wins an opportunity the moment its quote is accepted, and\n    // `closed_won` is TERMINAL in `opportunity_stage_progression` \u2014 so a signed\n    // contract can never sit on an open deal, from either direction.\n    //\n    // Every field below is now derived from `Acme Annual Renewal 2025`, the\n    // `closed_won` deal this contract's own description was already describing:\n    //   contract_value \u2014 that deal's line-item total, which is also the ARR the\n    //                    account description reports. 150000 was the upgrade's\n    //                    total, i.e. the value came from a different deal than\n    //                    the link did;\n    //   signed_date    \u2014 its `close_date`: you sign when you win, and\n    //                    `quote_on_accepted` stamps that same day;\n    //   start_date     \u2014 signature + 14d, because that deal's description says\n    //                    it was \"signed two weeks ahead of the renewal date\";\n    //   end_date       \u2014 start + 365d, the span every other row here uses for a\n    //                    12-month term.\n    {\n      crm_account: 'Acme Corporation',\n      crm_contact: 'john.smith@acme.example.com',\n      crm_opportunity: 'Acme Annual Renewal 2025',\n      status: 'activated',\n      contract_term_months: 12,\n      start_date: cel`daysAgo(1)`,\n      end_date: cel`daysFromNow(364)`,\n      contract_value: 220000,\n      billing_frequency: 'annually',\n      payment_terms: 'net_30',\n      auto_renewal: true,\n      renewal_notice_days: 60,\n      contract_type: 'subscription',\n      signed_date: cel`daysAgo(15)`,\n      signed_by: 'John Smith',\n      description: 'Annual platform subscription with premium support tier.',\n    },\n    {\n      crm_account: 'Wayne Enterprises',\n      crm_contact: 'rwilson@wayne.example.com',\n      crm_opportunity: 'Wayne Enterprise License',\n      status: 'in_approval',\n      contract_term_months: 36,\n      start_date: cel`daysFromNow(14)`,\n      end_date: cel`daysFromNow(1109)`,\n      contract_value: 1200000,\n      billing_frequency: 'annually',\n      payment_terms: 'net_60',\n      auto_renewal: false,\n      renewal_notice_days: 90,\n      contract_type: 'license',\n      description: 'Multi-year enterprise license with custom SLA.',\n    },\n    {\n      crm_account: 'Initech Solutions',\n      crm_contact: 'mchen@initech.example.com',\n      status: 'expired',\n      contract_term_months: 12,\n      start_date: cel`daysAgo(400)`,\n      end_date: cel`daysAgo(35)`,\n      contract_value: 60000,\n      billing_frequency: 'quarterly',\n      payment_terms: 'net_30',\n      auto_renewal: false,\n      renewal_notice_days: 30,\n      contract_type: 'service',\n      signed_date: cel`daysAgo(405)`,\n      signed_by: 'Michael Chen',\n      description: 'Initial service agreement, pending renewal discussion.',\n    },\n    {\n      crm_account: 'Stark Medical',\n      crm_contact: 'emily.d@starkmed.example.com',\n      status: 'draft',\n      contract_term_months: 24,\n      start_date: cel`daysFromNow(30)`,\n      end_date: cel`daysFromNow(760)`,\n      contract_value: 350000,\n      billing_frequency: 'monthly',\n      payment_terms: 'net_30',\n      auto_renewal: true,\n      renewal_notice_days: 60,\n      contract_type: 'partnership',\n      description: 'Healthcare partnership agreement, currently under legal review.',\n    },\n  ]\n});\n\n// \u2500\u2500\u2500 Quotes \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n// `quote_number` is a runtime-owned autonumber and is NOT seeded (#490);\n// the (unique) quote name is the upsert identity instead.\n/**\n * Quote line items, keyed by quote name. The four quotes generated from a deal\n * carry that deal's configuration verbatim \u2014 which is exactly what the\n * `quote_generation` flow does when it clones opportunity lines onto a quote.\n */\nconst QUOTE_LINES: Record<string, readonly LineSpec[]> = {\n  'Acme Platform Upgrade Quote': OPPORTUNITY_LINES['Acme Platform Upgrade'],\n  'Acme Annual Renewal 2025 Quote': OPPORTUNITY_LINES['Acme Annual Renewal 2025'],\n  'Globex Manufacturing Suite Proposal': OPPORTUNITY_LINES['Globex Manufacturing Suite'],\n  'Wayne Enterprise License Quote': OPPORTUNITY_LINES['Wayne Enterprise License'],\n  'Initech Cloud Migration Estimate': OPPORTUNITY_LINES['Initech Cloud Migration'],\n  // Quoted standalone, before any opportunity existed \u2014 and then rejected.\n  'Stark Medical Pilot Quote': [\n    { product: 'Admin Training Workshop', quantity: 5, unit_price: 6000, description: 'Five workshop days for the pilot clinical teams.' },\n    { product: 'Standard Support', quantity: 1, unit_price: 9000, description: 'Standard support for the pilot term.' },\n    { product: 'AI Agent Seat (Annual)', quantity: 6, unit_price: 1000, description: 'Agent seats for the pilot coordinators.' },\n  ],\n};\n\n/**\n * `subtotal` / `discount_amount` / `total_price` for a quote, derived from its\n * lines with `quote_total_rollup`'s own model:\n *\n *   subtotal        = \u03A3 line (quantity \u00D7 unit_price \u00D7 (1 \u2212 line_discount/100))\n *   discount_amount = subtotal \u00D7 quote.discount%\n *   total_price     = subtotal \u2212 discount_amount + tax + shipping_handling\n *\n * Quote-level `tax` and `shipping_handling` stay manual inputs \u2014 the rollup\n * does not derive them either. Everything the rollup DOES own is computed here\n * so that the first edit to a seeded line item recomputes the same numbers\n * instead of visibly correcting them.\n */\nconst quoteTotals = (\n  quoteName: string,\n  opts: { discount: number; tax: number; shipping_handling: number },\n) => {\n  const lines = QUOTE_LINES[quoteName];\n  if (!lines) throw new Error(`Seed error: no line items authored for quote \"${quoteName}\"`);\n  const subtotal = linesTotal(lines);\n  const discount_amount = Math.round(subtotal * (opts.discount / 100) * 100) / 100;\n  const total_price =\n    Math.round((subtotal - discount_amount + opts.tax + opts.shipping_handling) * 100) / 100;\n  return {\n    subtotal,\n    discount: opts.discount,\n    discount_amount,\n    tax: opts.tax,\n    shipping_handling: opts.shipping_handling,\n    total_price,\n  };\n};\n\nexport const quotes = defineSeed(Quote, {\n  mode: 'upsert',\n  externalId: 'name',\n  records: [\n    {\n      name: 'Acme Platform Upgrade Quote',\n      crm_account: 'Acme Corporation',\n      crm_contact: 'john.smith@acme.example.com',\n      crm_opportunity: 'Acme Platform Upgrade',\n      // `expired`, not `accepted` (#1661). Accepting this quote would have\n      // close-won `Acme Platform Upgrade`, which is `proposal` and 30 days from\n      // close \u2014 the same impossible pairing the contract above carried, one\n      // object over. `expired` is what `quote_expiration` computes for a\n      // presented quote past its `expiration_date`, and it is what the deal's\n      // own next step assumes: the revised Enterprise proposal still has to go\n      // out. Its `crm_contact` stays put \u2014 the row is no longer gated by\n      // `requiredWhen`, but the recipient is still who it was sent to.\n      status: 'expired',\n      quote_date: cel`daysAgo(45)`,\n      expiration_date: cel`daysAgo(15)`,\n      ...quoteTotals('Acme Platform Upgrade Quote', { discount: 10, tax: 11475, shipping_handling: 0 }),\n      payment_terms: 'net_30',\n      description: 'Platform upgrade with 10% loyalty discount applied.',\n    },\n    // The renewal's own quote, and the seed's one ACCEPTED quote. Acceptance is\n    // only coherent here: `quote_on_accepted` close-wins whatever opportunity a\n    // quote links, so an accepted quote can only ever point at a `closed_won`\n    // deal. It also completes the provenance chain the contract above needs \u2014\n    // deal won, quote accepted, contract drafted, then completed and activated\n    // by an admin (the draft the hook writes is explicitly a starting point).\n    // `Acme Annual Renewal 2025` keeps its rep-recorded `relationship` win\n    // reason: the hook only supplies `quote_accepted` when nobody recorded one.\n    {\n      name: 'Acme Annual Renewal 2025 Quote',\n      crm_account: 'Acme Corporation',\n      crm_contact: 'john.smith@acme.example.com',\n      crm_opportunity: 'Acme Annual Renewal 2025',\n      status: 'accepted',\n      quote_date: cel`daysAgo(30)`,\n      expiration_date: cel`daysAgo(1)`,\n      // No discount \u2014 the renewal went at list (\"multi-year option declined\n      // this round\"), which is what its 22% YoY uplift is made of. Tax is 8.5%\n      // of the post-discount subtotal, the rate the other Acme quote bills at;\n      // every non-Acme quote here bills 8%.\n      ...quoteTotals('Acme Annual Renewal 2025 Quote', { discount: 0, tax: 18700, shipping_handling: 0 }),\n      payment_terms: 'net_30',\n      description: 'Annual renewal \u2014 three production tenants, premium support and the EMEA seat expansion.',\n    },\n    {\n      name: 'Globex Manufacturing Suite Proposal',\n      crm_account: 'Globex Industries',\n      crm_contact: 'sarah.j@globex.example.com',\n      crm_opportunity: 'Globex Manufacturing Suite',\n      status: 'presented',\n      quote_date: cel`daysAgo(7)`,\n      expiration_date: cel`daysFromNow(23)`,\n      ...quoteTotals('Globex Manufacturing Suite Proposal', { discount: 5, tax: 7220, shipping_handling: 2500 }),\n      payment_terms: 'net_60',\n      description: 'Manufacturing suite licensing with plant-admin training.',\n    },\n    {\n      name: 'Wayne Enterprise License Quote',\n      crm_account: 'Wayne Enterprises',\n      crm_contact: 'rwilson@wayne.example.com',\n      crm_opportunity: 'Wayne Enterprise License',\n      status: 'in_review',\n      quote_date: cel`daysAgo(3)`,\n      expiration_date: cel`daysFromNow(27)`,\n      ...quoteTotals('Wayne Enterprise License Quote', { discount: 15, tax: 81600, shipping_handling: 0 }),\n      payment_terms: 'net_60',\n      description: 'Multi-year enterprise license with volume discount.',\n    },\n    {\n      name: 'Initech Cloud Migration Estimate',\n      crm_account: 'Initech Solutions',\n      crm_contact: 'mchen@initech.example.com',\n      crm_opportunity: 'Initech Cloud Migration',\n      status: 'draft',\n      quote_date: cel`daysAgo(1)`,\n      expiration_date: cel`daysFromNow(29)`,\n      ...quoteTotals('Initech Cloud Migration Estimate', { discount: 0, tax: 6400, shipping_handling: 0 }),\n      payment_terms: 'net_30',\n      description: 'Cloud migration services, awaiting internal review.',\n    },\n    {\n      name: 'Stark Medical Pilot Quote',\n      crm_account: 'Stark Medical',\n      crm_contact: 'emily.d@starkmed.example.com',\n      status: 'rejected',\n      quote_date: cel`daysAgo(60)`,\n      expiration_date: cel`daysAgo(30)`,\n      ...quoteTotals('Stark Medical Pilot Quote', { discount: 0, tax: 3600, shipping_handling: 0 }),\n      payment_terms: 'net_30',\n      description: 'Pilot project quote, rejected due to budget constraints.',\n      internal_notes: 'Customer requested re-quote with smaller scope.',\n    },\n  ]\n});\n\n// \u2500\u2500\u2500 Quote line items \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n// Same composite-key reasoning as the opportunity lines above: (quote,\n// product) is the only natural key this junction-shaped object has.\nexport const quoteLineItems = defineSeed(QuoteLineItem, {\n  mode: 'upsert',\n  externalId: ['crm_quote', 'crm_product'],\n  records: lineItemRecords('crm_quote', QUOTE_LINES),\n});\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/service/data/service.seed.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/service/data\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/service/data/service.seed.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\n/**\n * Service seeds \u2014 the case backlog and the knowledge base.\n *\n * The task list and the interaction log used to be here too: tasks, events and\n * event attendees are the activity layer over every object, and the case seeds\n * are the records they most often hang off (#671). Those three objects are the\n * SALES package's under the ADR-0130 layout (plan item 4 \u2014 the activity\n * objects fold into the app package), so their rows moved with them to\n * `src/sales/data/activity.seed.ts`. Nothing about the rows changed: they still\n * reference cases by natural key. These case rows are registered by the service\n * package and the activity rows by the app package; measured on a fresh boot\n * of the two-package artifact (#1907), the lookups resolve in both directions \u2014\n * every seeded case's account, and every seeded event's case.\n *\n * Split out of the former monolithic `src/data/index.ts` (#635). Seed doctrine\n * lives in `src/sales/data/_shared.ts`.\n */\nimport { defineSeed } from '@objectstack/spec/data';\nimport { cel } from '@objectstack/spec';\nimport { Case } from '../objects/case.object';\nimport { KnowledgeArticle } from '../objects/knowledge_article.object';\nimport { CASE_SLA_DEFAULT_TIER, caseSlaBreached, caseSlaCalendarHours } from '../objects/_case-sla';\nimport { celDaysAgo } from '../../sales/data/_shared';\nimport { accounts } from '../../sales/data/sales.seed';\n\n// \u2500\u2500\u2500 Seeded SLA due dates \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n//\n// Hooks do not run over seeds, so a hook-owned field has to arrive already\n// holding what the hook would have computed (`test/seed-consistency.test.ts`\n// is the enforcement). `sla_due_date` used to be hand-typed per case \u2014 eight\n// numbers picked to look plausible \u2014 and it is now DERIVED from the same\n// priority \u00D7 account-tier matrix `case_sla_defaults` applies, so a cell change\n// moves the demo data with it instead of leaving it lying.\n//\n// The account tier is read off the account seed itself rather than copied into\n// a table here: `crm_account.tier` is the input the matrix takes, and there is\n// no reason for this file to hold a second opinion about which tier Acme is.\nconst TIER_BY_ACCOUNT = new Map<string, string>(\n  (accounts.records as ReadonlyArray<Record<string, unknown>>).map((a) => [\n    String(a.name),\n    typeof a.tier === 'string' ? a.tier : CASE_SLA_DEFAULT_TIER,\n  ]),\n);\n\n/** The matrix cell `case_sla_defaults` would have applied, in calendar hours after creation. */\nconst seededSlaHours = (priority: string, accountName?: string): number => {\n  const hours = caseSlaCalendarHours(priority, accountName ? TIER_BY_ACCOUNT.get(accountName) : undefined);\n  if (hours === undefined) throw new Error(`seed: no SLA matrix row for priority \"${priority}\"`);\n  return hours;\n};\n\n/**\n * `created_at + matrix(priority, tier)`, as a CEL expression \u2014 the case's\n * authored creation instant (the platform's own `created_at`, which the seed\n * loader keeps on first insert since @objectstack/objectql 17.7.0,\n * objectstack#21646) plus the cell `case_sla_defaults` would have applied.\n *\n * `daysAgo(n)` is a UTC midnight, so the hour offset has to be added on top of\n * it \u2014 hence `+ duration('Nh')` rather than a second day-granular helper.\n *\n * A due date that lands in the past is expected and correct on an old open case\n * \u2014 that is what a breach IS. On an OPEN case the flag is `case_sla_monitor`'s\n * to write, on a deployment that runs scheduled work, and the seed only pre-sets\n * it where the demo wants a breach visible without a sweep.\n */\nconst celCaseSlaDue = (createdDaysAgo: number, priority: string, accountName?: string) =>\n  cel`daysAgo(${createdDaysAgo}) + duration('${seededSlaHours(priority, accountName)}h')`;\n\n/**\n * `is_sla_violated` of a SETTLED case (resolved or closed) \u2014 DERIVED, never\n * picked (#2070). `case_sla_defaults` records the breach on the write that\n * settles a case after its due date, so a settled seed row has to arrive\n * holding exactly what that write would have recorded: `caseSlaBreached` over\n * the row's own dates. Both instants are offsets from the same `daysAgo()`\n * midnight \u2014 the due date `matrix(priority, tier)` hours after creation, the\n * settle instant (`closed_date`, which a settled seed row carries as its\n * resolved-date proxy) whole days after it \u2014 so the hour counts compare\n * directly, and a case settled exactly on its deadline met it.\n *\n * These rows used to be authored `false` across the board, which made the\n * `sla_performance` report and the compliance gauge read 100% met over closed\n * cases that had finished days late by their own dates.\n */\nconst seededSettledBreach = (\n  createdDaysAgo: number,\n  settledDaysAgo: number,\n  priority: string,\n  accountName?: string,\n): boolean => caseSlaBreached(seededSlaHours(priority, accountName), (createdDaysAgo - settledDaysAgo) * 24);\n\n// \u2500\u2500\u2500 Cases \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\nexport const cases = defineSeed(Case, {\n  mode: 'upsert',\n  externalId: 'subject',\n  records: [\n    {\n      subject: 'Login issues after platform upgrade',\n      description: `Users in the EMEA office report intermittent 401 errors when logging in after the v4.2 upgrade rolled out Wednesday night. Pattern: only affects users authenticating via SAML through Okta, only between 09:00\u201310:30 UTC. NA and APAC users are unaffected.\n\n**Customer impact:** ~40 users blocked at peak, costing ~3 productive hours per affected user.\n\n**Initial triage:** Suspect a clock-skew issue on the EMEA SSO relay added during the upgrade window. Engineering is reproducing in staging.`,\n      crm_account: 'Acme Corporation',\n      crm_contact: 'john.smith@acme.example.com',\n      status: 'in_progress',\n      priority: 'high',\n      priority_rank: 3,\n      type: 'problem',\n      origin: 'email',\n      is_closed: false,\n      is_sla_violated: false,\n      is_escalated: false,\n      created_at: cel`daysAgo(2)`,\n      sla_due_date: celCaseSlaDue(2, 'high', 'Acme Corporation'),\n    },\n    {\n      subject: 'Data export timing out for large datasets',\n      description: 'CSV export fails for datasets over 10k rows.',\n      crm_account: 'Globex Industries',\n      crm_contact: 'sarah.j@globex.example.com',\n      status: 'escalated',\n      priority: 'critical',\n      priority_rank: 4,\n      type: 'bug',\n      origin: 'phone',\n      is_closed: false,\n      is_sla_violated: true,\n      is_escalated: true,\n      escalation_reason: 'Customer threatening churn',\n      created_at: cel`daysAgo(5)`,\n      sla_due_date: celCaseSlaDue(5, 'critical', 'Globex Industries'),\n    },\n    {\n      subject: 'How to configure SSO with Okta?',\n      description: 'Customer needs guidance on SSO setup with Okta.',\n      crm_account: 'Initech Solutions',\n      crm_contact: 'mchen@initech.example.com',\n      status: 'resolved',\n      priority: 'medium',\n      priority_rank: 2,\n      type: 'question',\n      origin: 'web',\n      // Resolved-but-not-closed: case.hook keeps is_closed=false and stamps\n      // closed_date as the resolved-date proxy; resolution_time_hours is the\n      // closed\u2212created delta the hook would compute (daysAgo() is day-granular,\n      // so deltas come in 24h steps).\n      is_closed: false,\n      is_sla_violated: seededSettledBreach(3, 2, 'medium', 'Initech Solutions'),\n      is_escalated: false,\n      resolution_time_hours: 24.0,\n      created_at: cel`daysAgo(3)`,\n      closed_date: cel`daysAgo(2)`,\n      sla_due_date: celCaseSlaDue(3, 'medium', 'Initech Solutions'),\n    },\n    {\n      subject: 'API rate limit exceeded on production',\n      description: 'Production environment hitting rate limits during peak hours.',\n      crm_account: 'Wayne Enterprises',\n      crm_contact: 'rwilson@wayne.example.com',\n      status: 'closed',\n      priority: 'high',\n      priority_rank: 3,\n      type: 'problem',\n      origin: 'chat',\n      is_closed: true,\n      is_sla_violated: seededSettledBreach(7, 6, 'high', 'Wayne Enterprises'),\n      is_escalated: false,\n      // `resolution` is REQUIRED when status is 'closed' (object validation\n      // `resolution_required_for_closed`) \u2014 without it the seed row is rejected.\n      resolution: 'Raised the production rate-limit tier and added client-side backoff; usage now within limits.',\n      // The deflection link (#601): this case was answered out of the knowledge\n      // base, so it names the article that resolved it. Referenced by the\n      // article seed's `externalId` (`title`), the same way every other seeded\n      // lookup names its target.\n      resolved_by_article: 'API Rate Limits',\n      // closed\u2212created delta, as case.hook computes it.\n      resolution_time_hours: 24.0,\n      created_at: cel`daysAgo(7)`,\n      closed_date: cel`daysAgo(6)`,\n      sla_due_date: celCaseSlaDue(7, 'high', 'Wayne Enterprises'),\n    },\n    {\n      subject: 'PDF reports not rendering charts correctly',\n      description: 'Charts appear blank when exporting dashboard to PDF.',\n      crm_account: 'Stark Medical',\n      crm_contact: 'emily.d@starkmed.example.com',\n      status: 'new',\n      priority: 'medium',\n      priority_rank: 2,\n      type: 'bug',\n      origin: 'email',\n      is_closed: false,\n      is_sla_violated: false,\n      is_escalated: false,\n      created_at: cel`daysAgo(1)`,\n      sla_due_date: celCaseSlaDue(1, 'medium', 'Stark Medical'),\n    },\n    {\n      subject: 'Billing discrepancy on last invoice',\n      description: `Customer (Lisa Kim, Procurement) flagged that the May invoice shows 15 active seats but Acme is only using 12. Two of the seats were de-provisioned in early April when two engineers left the company.\n\n**Root cause:** the de-provisioning happened in our admin console but the seat-count metric in billing only refreshes monthly, so the May invoice picked up the pre-change count.\n\n**Resolution path:** issue a $1,200 credit memo and switch Acme to the new real-time seat-billing pipeline so this can't recur. Waiting on Lisa to confirm she's good with the credit-memo treatment vs a refund.`,\n      crm_account: 'Acme Corporation',\n      crm_contact: 'john.smith@acme.example.com',\n      status: 'waiting_customer',\n      priority: 'low',\n      priority_rank: 1,\n      type: 'problem',\n      origin: 'email',\n      is_closed: false,\n      is_sla_violated: false,\n      is_escalated: false,\n      created_at: cel`daysAgo(4)`,\n      sla_due_date: celCaseSlaDue(4, 'low', 'Acme Corporation'),\n    },\n    {\n      subject: 'Mobile app crashes on iOS 17',\n      description: 'App crashes on launch for users running iOS 17.2+.',\n      crm_account: 'Globex Industries',\n      crm_contact: 'sarah.j@globex.example.com',\n      status: 'in_progress',\n      priority: 'critical',\n      priority_rank: 4,\n      type: 'bug',\n      origin: 'web',\n      is_closed: false,\n      is_sla_violated: true,\n      is_escalated: true,\n      escalation_reason: 'Affects 30% of mobile users',\n      created_at: cel`daysAgo(3)`,\n      sla_due_date: celCaseSlaDue(3, 'critical', 'Globex Industries'),\n    },\n    {\n      subject: 'Request: bulk import via CSV',\n      description: 'Customer requesting ability to import records via CSV upload.',\n      crm_account: 'Wayne Enterprises',\n      crm_contact: 'rwilson@wayne.example.com',\n      status: 'closed',\n      priority: 'low',\n      priority_rank: 1,\n      type: 'feature_request',\n      origin: 'web',\n      is_closed: true,\n      is_sla_violated: seededSettledBreach(10, 8, 'low', 'Wayne Enterprises'),\n      is_escalated: false,\n      // Required for closed cases (resolution_required_for_closed).\n      resolution: 'Delivered CSV bulk-import in the 9.4 release; shared the docs link with the customer.',\n      // closed\u2212created delta, as case.hook computes it.\n      resolution_time_hours: 48.0,\n      created_at: cel`daysAgo(10)`,\n      closed_date: cel`daysAgo(8)`,\n      sla_due_date: celCaseSlaDue(10, 'low', 'Wayne Enterprises'),\n    },\n    // \u2500\u2500\u2500 Generated demo cases \u2014 30 cases over the last 30 days, mixed across\n    // priorities. Powers `CasesOpenedByDayPriorityReport` (daily bucketing\n    // matrix) and the service dashboard's daily-volume area chart.\n    //\n    // ### Why every axis carries a rotation, and not just `i % length` (#1659)\n    //\n    // These rows used to read ONE counter for every axis: `crm_account` and\n    // `status` both took `i % 5`, and `priority`, `type` and `origin` all took\n    // `i % 4`. Equal-length lists walked by one index advance in lockstep, so\n    // each group came out PERFECTLY correlated \u2014 every Acme case `new`, every\n    // Globex case `in_progress`, and every `low` case a `question` raised by\n    // `email`. Thirty rows of volume with no variety, which is the opposite of\n    // what a volume generator is for: the account \u00D7 status cross-tab held 5 of\n    // its 25 cells, and priority \u00D7 type \u00D7 origin 4 of 16 apiece.\n    //\n    // Each list now advances one step per row PLUS a rotation \u2014 `c` extra steps\n    // every `m` rows. Two axes stay correlated exactly when their relative\n    // offset never moves, so the rotations are chosen to make every relative\n    // offset sweep its whole cycle. `crm_account` is the anchor and carries no\n    // rotation; the other four are stated relative to it.\n    //\n    // `account \u00D7 status` is complete BY CONSTRUCTION rather than by luck, and\n    // the proof is one line: account `a` takes rows i = a, a+5 \u2026 a+25, whose\n    // block numbers run 0\u20265, so its statuses are `(a + b) % 5` over b = 0\u20265 \u2014\n    // all five of them. The thirty rows therefore walk the whole 5 \u00D7 5 grid,\n    // twenty-five cells once and five of them a second time.\n    //\n    // \u26A0\uFE0F The remaining three constants are TUNED, not derived. They were picked\n    // by computing all ten pairwise cross-tabs and keeping the assignment that\n    // left the fewest empty cells. Measured over the lists as shipped: 188 of\n    // the 193 pairwise cells are occupied, no cell holds more than 3 rows, and\n    // the marginals stay as flat as thirty rows allow \u2014 6/6/6/6/6 by account\n    // and by status, 8/7/7/8 by priority, type and origin. \u26D4 Changing the\n    // LENGTH of any list below voids that tuning: re-measure the cross-tabs\n    // rather than assuming the rotations still separate the axes.\n    //\n    // Two schemes that read as more principled than they measure were rejected\n    // here, and are recorded so they are not re-derived: rotating the 5-lists\n    // on the 4-block and the 4-lists on the 5-block (\"the lengths are coprime,\n    // so they cannot resonate\") empties one status completely; and rotating\n    // `crm_account` as well \u2014 to break the every-fifth-day beat it walks the\n    // calendar on \u2014 costs twelve further empty cells. That beat is the\n    // deliberate price of anchoring: with one row per day, some axis has to be\n    // the fixed one the other four are measured against.\n    ...((): readonly Record<string, unknown>[] => {\n      const priorities = ['low', 'medium', 'high', 'critical'] as const;\n      // Mirror of case.hook's priority rank map \u2014 hooks don't run over seeds.\n      const rankByPriority: Record<typeof priorities[number], number> = { low: 1, medium: 2, high: 3, critical: 4 };\n      const types = ['question', 'bug', 'problem', 'feature_request'] as const;\n      const origins = ['email', 'phone', 'web', 'chat'] as const;\n      const statuses = ['new', 'in_progress', 'resolved', 'closed', 'escalated'] as const;\n      const accountsList = ['Acme Corporation', 'Globex Industries', 'Wayne Enterprises', 'Initech Solutions', 'Stark Medical'] as const;\n      const out: Record<string, unknown>[] = [];\n      for (let i = 0; i < 30; i++) {\n        // The anchor, then the four rotations the block comment above derives.\n        // `10` is the one constant with no reading off a list length \u2014 it is\n        // the rotation that measured best for `origin` against the other four.\n        const account = accountsList[i % accountsList.length];\n        const status = statuses[(i + Math.floor(i / accountsList.length)) % statuses.length];\n        const priority = priorities[(i + Math.floor(i / priorities.length)) % priorities.length];\n        const type = types[(i + 2 * Math.floor(i / types.length)) % types.length];\n        const origin = origins[(i + Math.floor(i / 10)) % origins.length];\n        const settled = status === 'resolved' || status === 'closed';\n        const ageDays = 1 + (i % 30);\n        // Settled cases get a resolution delay of 1\u20133 days (capped at the\n        // case's age); resolution_time_hours is exactly the closed\u2212created\n        // delta case.hook would compute (daysAgo() is day-granular \u2192 24h steps).\n        const resolutionDays = Math.min(ageDays, 1 + (i % 3));\n        // A SETTLED row's flag is derived from its own dates (#2070,\n        // `seededSettledBreach`): the write that settled it would have recorded\n        // a late finish, so the seed does too.\n        //\n        // An OPEN row's flag is the sweep's definition \u2014 open, and its due date\n        // already in the past. The old generator flagged rows as violated while\n        // giving every row a FUTURE due date; since #595 the due date is DERIVED\n        // (`celCaseSlaDue` below), so \"already in the past\" holds by\n        // construction here: a critical case is due 4h after creation and every\n        // generated case is at least a day old. The converse is deliberately not\n        // enforced \u2014 other open rows are past due too, and `case_sla_monitor`\n        // notices them where scheduled work runs. Pre-setting the flag here only\n        // decides which open breaches the demo shows without a sweep.\n        const slaViolated = settled\n          ? seededSettledBreach(ageDays, ageDays - resolutionDays, priority, account)\n          : priority === 'critical' && i % 3 === 0;\n        out.push({\n          subject: `Demo case ${String(i + 1).padStart(2, '0')} \u2014 ${priority} ${type}`,\n          description: `Auto-generated demo case for ${priority} priority on day -${ageDays}.`,\n          crm_account: account,\n          status,\n          priority,\n          priority_rank: rankByPriority[priority],\n          type,\n          origin,\n          // is_closed strictly mirrors case.hook: true ONLY for status\n          // 'closed' \u2014 a resolved case is NOT closed yet.\n          is_closed: status === 'closed',\n          is_sla_violated: slaViolated,\n          is_escalated: status === 'escalated',\n          ...(settled ? { resolution_time_hours: resolutionDays * 24 } : {}),\n          // Object validations require these when closed/escalated \u2014 without\n          // them the generated rows are rejected (resolution_required_for_closed\n          // / escalation_reason_required).\n          ...(status === 'closed' ? { resolution: 'Resolved per standard runbook; root cause documented and customer confirmed.' } : {}),\n          ...(status === 'escalated' ? { escalation_reason: 'Escalated to tier-2 engineering for SLA-risk review.' } : {}),\n          created_at: celDaysAgo(ageDays),\n          // Resolved cases also carry closed_date: case.hook stamps it as the\n          // resolved-date proxy while keeping is_closed=false.\n          ...(settled ? { closed_date: celDaysAgo(ageDays - resolutionDays) } : {}),\n          sla_due_date: celCaseSlaDue(ageDays, priority, account),\n        });\n      }\n      return out;\n    })(),\n  ],\n});\n\n// \u2500\u2500\u2500 Knowledge Articles \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n//\n// No `helpful_count` / `not_helpful_count` here, deliberately (#601). Those two\n// are now DERIVED: `article_feedback_metrics_refresh` recounts them from\n// `crm_article_feedback` on every vote. This file used to type in 38, 96, 5, 9\n// \u2014 numbers with no rows behind them \u2014 and the first real vote on an article\n// would have recounted 96 down to 1, in front of whoever pressed the button.\n//\n// The seed doctrine at the top of this file is what decides it: a hook-owned\n// field must arrive holding what the hook WOULD have computed. With no seeded\n// feedback rows the honest value is the field's own default, 0. Rows are not\n// seeded either, because a seed cannot name a user (see the note on\n// `crm_event_attendee` below) and the voter's identity is exactly what the\n// one-vote-per-reader index keys on \u2014 a table of ownerless verdicts would be\n// the same fiction one level down.\n//\n// The deflection half of #601 does not have this problem and IS seeded: a case\n// naming the article that resolved it needs no user, so the closed\n// `API rate limit exceeded on production` case above carries a real\n// `resolved_by_article` and the Service dashboard's KB tiles have something\n// true to show on a fresh `pnpm demo:reset`.\nexport const knowledgeArticles = defineSeed(KnowledgeArticle, {\n  mode: 'upsert',\n  externalId: 'title',\n  records: [\n    {\n      title: 'Getting Started with HotCRM',\n      summary: 'A five-minute tour of accounts, contacts, leads and the sales pipeline.',\n      category: 'getting_started',\n      status: 'published',\n      audience: 'public',\n      language: 'en',\n      body: `# Getting Started with HotCRM\n\nWelcome! This guide walks you through the core objects:\n\n1. **Accounts** \u2014 the companies you sell to and serve.\n2. **Contacts** \u2014 the people at those accounts.\n3. **Leads** \u2014 unqualified prospects in the top of the funnel.\n4. **Opportunities** \u2014 qualified deals moving through your pipeline.\n\nOpen the **Sales Pipeline** kanban to drag deals between stages, and use the\n**Executive Overview** dashboard to track revenue at a glance.`,\n      published_at: cel`daysAgo(40)`,\n      last_reviewed_at: cel`daysAgo(20)`,\n    },\n    {\n      title: 'Resetting Your Password',\n      summary: 'How end users reset a forgotten password from the login screen.',\n      category: 'how_to',\n      status: 'published',\n      audience: 'public',\n      language: 'en',\n      body: `# Resetting Your Password\n\n1. On the login screen, click **Forgot password?**\n2. Enter the email associated with your account.\n3. Check your inbox for a reset link (valid for 30 minutes).\n4. Choose a new password of at least 12 characters.\n\nIf the email does not arrive, check spam or contact your administrator.`,\n      published_at: cel`daysAgo(25)`,\n      last_reviewed_at: cel`daysAgo(10)`,\n    },\n    {\n      title: 'API Rate Limits',\n      summary: 'Per-token request quotas and recommended back-off strategy.',\n      category: 'api',\n      status: 'draft',\n      audience: 'internal',\n      language: 'en',\n      body: `# API Rate Limits (DRAFT)\n\nDefault quota is 600 requests/minute per token. On HTTP 429, back off\nexponentially starting at 1s. Numbers pending final review with platform team.`,\n    },\n    {\n      title: 'Legacy SSO Setup',\n      summary: 'SAML configuration for the pre-2025 identity stack.',\n      category: 'troubleshooting',\n      status: 'published',\n      audience: 'internal',\n      language: 'en',\n      body: `# Legacy SSO Setup\n\nThis covers the deprecated SAML 1.1 flow. New tenants should use the OIDC\nconnector instead. Retained for customers still on the legacy stack.`,\n      published_at: cel`daysAgo(240)`,\n      last_reviewed_at: cel`daysAgo(220)`,\n    },\n  ]\n});\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/service/objects/_case-sla.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/service/objects\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/service/objects/_case-sla.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\n/**\n * The case SLA policy matrix \u2014 priority \u00D7 account tier, in CALENDAR HOURS.\n *\n * # What this replaces\n *\n * Until #595 the only SLA rule in the app was \"critical \u21D2 now + 4h\", hardcoded\n * in `case_sla_defaults`. Three of the four priorities therefore got NO\n * `sla_due_date` at all, which meant `case_sla_monitor` \u2014 the hourly sweep that\n * flags and escalates breaches \u2014 could never fire for them: it selects on\n * `sla_due_date < now`, and a blank date is never in the past. A High case\n * nobody touched entered neither the priority-escalation path nor the time\n * path. The field, the sweep and the four published per-priority targets were\n * all shipped; only the clock behind three of them was missing.\n *\n * `crm_account.tier` was the other half of the same gap: four options declared\n * on the account object and read by nothing outside `src/views/account.view.ts`.\n *\n * # \u26A0\uFE0F CALENDAR HOURS, NOT BUSINESS HOURS\n *\n * Every number below is added to the WALL CLOCK. This app ships no\n * business-hours calendar, no working-day definition and no holiday list \u2014\n * there is nothing in its metadata a deadline could be counted against, and\n * the platform provides no such service either. So a P1 raised at 5pm on a\n * Friday is due at 9pm that same Friday, and a Low case raised on the 23rd of\n * December runs its week down over the holidays.\n *\n * This is stated rather than hidden because it is the single most likely way\n * for these numbers to be misread. Teaching the deadline to skip non-working\n * time means teaching this module a calendar \u2014 it is not a matter of changing\n * a cell.\n *\n * This header is the ONE place the app says it in prose (#1974). Everywhere\n * else the unit rides in a name \u2014 `CASE_SLA_CALENDAR_HOURS` and\n * `caseSlaCalendarHours` below, `slaCalendarHours` in the hook body \u2014 and in\n * `test/case-sla-matrix.test.ts`, which drives the hook on a fixed Friday\n * 17:00 clock and pins the deadlines that land on the weekend. The operator\n * reads it in the `sla_due_date` field description.\n *\n * # Why the `critical` row is flat\n *\n * Every cell in the `critical` row is 4 \u2014 deliberately, and it is the one\n * constraint on this table that is not a product opinion. Before #595 EVERY\n * critical case got 4 hours regardless of tier. Differentiating the row by\n * tier would LOOSEN the deadline on the critical cases of non-strategic\n * accounts, i.e. this change would take a clock away from work that already\n * had one. Flat at 4 keeps the new behaviour a strict superset of the old:\n * every case that had a due date still gets the same one, and three whole\n * priorities gain one. (The ruling on #595 asks for 4h as the *strategic*\n * cell; holding the rest of the row to it too is what makes \"superset\" true\n * rather than approximately true.)\n *\n * The remaining rows never exceed the per-priority target the user docs have\n * always published (High 8h, Medium 2 days = 48h, Low 7 days = 168h) \u2014 the\n * lowest tier gets exactly that commitment and the higher tiers get tighter.\n * No account is worse off at any priority than the docs already promised.\n *\n * # Where this constant is, and is not, the source of truth\n *\n * The hook body in `case.hook.ts` carries a HAND-COPIED mirror of this table\n * and cannot import it: L2 hook bodies run body-only in the QuickJS sandbox,\n * so a module constant resolves at authoring time and arrives as `undefined`\n * at runtime (see `_line-item-price-fill.ts`, and the same forced duplication\n * behind `test/priority-rank-parity.test.ts`). `src/service/data/service.seed.ts`\n * imports this module for real \u2014 seeds are authored-time data and hooks do not\n * run over them, so the seeded due dates have to be right on arrival.\n *\n * `test/case-sla-matrix.test.ts` is what keeps the two copies honest: it pins\n * all sixteen cells by DRIVING the shipped hook handler, so changing a cell in\n * either place without the other fails the suite.\n */\n\n/** The four `crm_account.tier` options, tightest service level first. */\nexport const CASE_SLA_TIERS = ['strategic', 'enterprise', 'mid_market', 'smb'] as const;\nexport type CaseSlaTier = (typeof CASE_SLA_TIERS)[number];\n\n/** The four `crm_case.priority` options that carry a clock. */\nexport const CASE_SLA_PRIORITIES = ['critical', 'high', 'medium', 'low'] as const;\nexport type CaseSlaPriority = (typeof CASE_SLA_PRIORITIES)[number];\n\n/**\n * Tier used when the case names no account, or the account's tier is blank, or\n * the reader cannot see the account row (guest intake through the web form is\n * the ordinary case \u2014 it can create a case and read nothing else).\n *\n * `smb` is the loosest column AND the `defaultValue` the account object already\n * declares for `tier`, so an unreadable account is treated exactly like an\n * account nobody has classified. Erring loose is the safe direction: a deadline\n * invented tighter than the customer's contract would manufacture breaches out\n * of a permission error.\n */\nexport const CASE_SLA_DEFAULT_TIER: CaseSlaTier = 'smb';\n\n/** Calendar hours from case creation to `sla_due_date`, by priority and account tier. */\nexport const CASE_SLA_CALENDAR_HOURS: Record<CaseSlaPriority, Record<CaseSlaTier, number>> = {\n  //           strategic  enterprise  mid_market  smb\n  critical: { strategic: 4, enterprise: 4, mid_market: 4, smb: 4 },\n  high: { strategic: 6, enterprise: 8, mid_market: 8, smb: 8 },\n  medium: { strategic: 24, enterprise: 36, mid_market: 48, smb: 48 },\n  low: { strategic: 96, enterprise: 120, mid_market: 168, smb: 168 },\n};\n\n/** Look a cell up with the documented fallbacks. Unknown priority \u21D2 no clock. */\nexport function caseSlaCalendarHours(priority: string, tier?: string | null): number | undefined {\n  const row = CASE_SLA_CALENDAR_HOURS[priority as CaseSlaPriority];\n  if (!row) return undefined;\n  return row[tier as CaseSlaTier] ?? row[CASE_SLA_DEFAULT_TIER];\n}\n\n/**\n * THE BREACH RULE (#2070): a case breached its SLA when its `sla_due_date` is\n * STRICTLY before the instant its clock stopped. Both arguments are read on one\n * clock \u2014 epoch milliseconds, or hours after the case was created \u2014 so a case\n * that stops exactly on its deadline met it. A case with no due date has no\n * clock, and is never judged at all: callers do not reach this without one.\n *\n * The clock stops when the case stops being live work \u2014 the first write that\n * takes it into `CLOSED_CASE_STATUSES` (`_case-assignment.ts`). Two writers\n * record a breach, one per side of that line, and both apply THIS rule:\n *\n *   - while the case is live: `case_sla_monitor` selects\n *     `sla_due_date: { $lt: NOW() }`, the same strict comparison, with \"now\" as\n *     the instant \u2014 but only on a deployment that runs scheduled work;\n *   - at the stop: `case_sla_defaults` (`case.hook.ts`) compares the due date\n *     with the instant of the resolving or closing write. It needs no schedule,\n *     so the closed-case surfaces \u2014 the `sla_performance` report and the\n *     `sla_compliance_rate` gauge \u2014 are right on every deployment.\n *\n * Neither writer ever clears the flag: a breach, once recorded, stays.\n *\n * The hook body spells this comparison inline, for the reason the matrix above\n * is mirrored there (no module scope in the sandbox). The seed derives the\n * flag of every settled demo case from this function, and\n * `test/case-sla-breach-on-close.test.ts` drives the LOWERED hook body against\n * it on both sides of the boundary, so the two cannot drift.\n */\nexport const caseSlaBreached = (dueAt: number, clockStoppedAt: number): boolean => dueAt < clockStoppedAt;\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/src/marketing/data/marketing.seed.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097/src/marketing/data\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/src/marketing/data/marketing.seed.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\n/**\n * Marketing seeds \u2014 campaigns and their membership.\n *\n * Reads the sales seeds (`leads`, `opportunities`) because the campaign metric\n * block is DERIVED from them rather than typed in \u2014 see `campaignMetrics`.\n *\n * Split out of the former monolithic `src/data/index.ts` (#635). Seed doctrine\n * lives in `src/sales/data/_shared.ts`.\n */\nimport { defineSeed } from '@objectstack/spec/data';\nimport { cel } from '@objectstack/spec';\nimport { Campaign } from '../objects/campaign.object';\nimport { CampaignMember } from '../objects/campaign_member.object';\nimport { celDaysAgo } from '../../sales/data/_shared';\nimport { leads, opportunities } from '../../sales/data/sales.seed';\n\n// \u2500\u2500\u2500 Campaign membership \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n/**\n * Campaign members, keyed by campaign name.\n *\n * Membership is the ONLY path from a campaign to a lead \u2014 `crm_lead` has no\n * campaign field \u2014 so with this table empty (as it was before #591) every\n * campaign reported `num_sent` 0, `response_rate` 0% and no attributed leads\n * at all, whatever the campaign records claimed.\n *\n * Status vocabulary is restricted to the lifecycle values a writer actually\n * produces: `sent` (what the campaign_enrollment flow and the two\n * Add-to-Campaign actions stamp), `responded` (the `mark_responded` action)\n * and `unsubscribed`. The `opened` / `clicked` / `bounced` states and the\n * `first_opened_date` / `first_clicked_date` stamps were REMOVED from the\n * object under #597 \u2014 no email-tracking engine exists on the platform, so\n * nothing could ever have written them.\n *\n * `converted` is a live status with a real writer\n * (`campaign_lead_conversion_refresh` promotes a member when its lead's\n * `is_converted` flips) but is deliberately not SEEDED: no seeded lead is\n * converted \u2014 conversion is the lead_conversion flow's job at runtime \u2014 so a\n * `converted` member would be a member state no lead record backs up.\n */\ntype CampaignMemberSpec = {\n  /** Lead email (the lead dataset's externalId) \u2014 mutually exclusive with `contact`. */\n  readonly lead?: string;\n  /** Contact email (the contact dataset's externalId). */\n  readonly contact?: string;\n  readonly status: 'sent' | 'responded' | 'unsubscribed';\n  readonly addedDaysAgo: number;\n  /** Days ago the member responded. Required by `responded`, absent otherwise. */\n  readonly respondedDaysAgo?: number;\n};\n\nconst CAMPAIGN_MEMBERS: Record<string, readonly CampaignMemberSpec[]> = {\n  'Q3 Enterprise Email Nurture': [\n    { lead: 'noah.patel@vertexanalytics.example.com', status: 'responded', addedDaysAgo: 14, respondedDaysAgo: 9 },\n    { lead: 'maya.singh@bluepeaklogistics.example.com', status: 'sent', addedDaysAgo: 14 },\n    { lead: 'owen.becker@northwindenergy.example.com', status: 'responded', addedDaysAgo: 14, respondedDaysAgo: 11 },\n    { lead: 'sara.lopez@heliossolar.example.com', status: 'sent', addedDaysAgo: 14 },\n    { lead: 'leo.vance@cleancart.example.com', status: 'unsubscribed', addedDaysAgo: 14 },\n    { lead: 'iris.okafor@pulsehealth.example.com', status: 'sent', addedDaysAgo: 13 },\n    { lead: 'ravi.mehta@foundryrobotics.example.com', status: 'sent', addedDaysAgo: 13 },\n    { lead: 'tess.brown@latticeeducation.example.com', status: 'responded', addedDaysAgo: 13, respondedDaysAgo: 8 },\n    { contact: 'john.smith@acme.example.com', status: 'responded', addedDaysAgo: 14, respondedDaysAgo: 10 },\n    { contact: 'ethan.brooks@vertex.example.com', status: 'sent', addedDaysAgo: 14 },\n    { contact: 'priya.shah@lattice.example.com', status: 'responded', addedDaysAgo: 14, respondedDaysAgo: 7 },\n    { contact: 'rwilson@wayne.example.com', status: 'sent', addedDaysAgo: 13 },\n  ],\n  'Operations Platform Launch': [\n    { lead: 'jonas.holt@polarcargo.example.com', status: 'responded', addedDaysAgo: 11, respondedDaysAgo: 6 },\n    { lead: 'anya.volkov@redoakrealty.example.com', status: 'sent', addedDaysAgo: 11 },\n    { lead: 'theo.park@skylinemedia.example.com', status: 'sent', addedDaysAgo: 11 },\n    { lead: 'wren.garcia@maplebakerygroup.example.com', status: 'responded', addedDaysAgo: 10, respondedDaysAgo: 5 },\n    { lead: 'hugo.dubois@nimbusaerospace.example.com', status: 'sent', addedDaysAgo: 10 },\n    { contact: 'rwilson@wayne.example.com', status: 'responded', addedDaysAgo: 11, respondedDaysAgo: 7 },\n    { contact: 'marcus.reed@apexlogistics.example.com', status: 'sent', addedDaysAgo: 11 },\n    { contact: 'olivia.chen@northwind.example.com', status: 'sent', addedDaysAgo: 10 },\n    { contact: 'sarah.j@globex.example.com', status: 'sent', addedDaysAgo: 10 },\n  ],\n  'Developer Content Marketing Push': [\n    { lead: 'lena.fischer@graniteinsurance.example.com', status: 'responded', addedDaysAgo: 33, respondedDaysAgo: 27 },\n    { lead: 'kai.watanabe@coralreefhotels.example.com', status: 'sent', addedDaysAgo: 33 },\n    { lead: 'mira.costa@atlasconstruction.example.com', status: 'unsubscribed', addedDaysAgo: 33 },\n    { lead: 'pia.anand@citrinefinance.example.com', status: 'responded', addedDaysAgo: 32, respondedDaysAgo: 24 },\n    { lead: 'marco.ricci@auroratravel.example.com', status: 'sent', addedDaysAgo: 32 },\n    { lead: 'lisa.t@cloudfirst.example.com', status: 'responded', addedDaysAgo: 30, respondedDaysAgo: 21 },\n    { contact: 'ethan.brooks@vertex.example.com', status: 'responded', addedDaysAgo: 33, respondedDaysAgo: 19 },\n    { contact: 'mchen@initech.example.com', status: 'sent', addedDaysAgo: 33 },\n    { contact: 'john.smith@acme.example.com', status: 'sent', addedDaysAgo: 32 },\n    { contact: 'emily.d@starkmed.example.com', status: 'sent', addedDaysAgo: 32 },\n    { contact: 'sarah.j@globex.example.com', status: 'sent', addedDaysAgo: 30 },\n  ],\n  // Campaigns still in `planning` carry their invitation / registration list:\n  // the enrollment flow runs for `planning` and `in_progress` campaigns alike\n  // and stamps `sent` on enrollment, so a pre-launch target list looks exactly\n  // like this.\n  'Cloud Migration Webinar': [\n    { lead: 'dkim@edutechlabs.example.com', status: 'sent', addedDaysAgo: 4 },\n    { lead: 'alice@nextgenretail.example.com', status: 'sent', addedDaysAgo: 4 },\n    { lead: 'jonas.holt@polarcargo.example.com', status: 'sent', addedDaysAgo: 3 },\n    { lead: 'anya.volkov@redoakrealty.example.com', status: 'sent', addedDaysAgo: 3 },\n    { contact: 'mchen@initech.example.com', status: 'sent', addedDaysAgo: 4 },\n    { contact: 'marcus.reed@apexlogistics.example.com', status: 'sent', addedDaysAgo: 3 },\n  ],\n  'Executive AI Governance Roundtable': [\n    { contact: 'john.smith@acme.example.com', status: 'sent', addedDaysAgo: 6 },\n    { contact: 'rwilson@wayne.example.com', status: 'sent', addedDaysAgo: 6 },\n    { contact: 'ethan.brooks@vertex.example.com', status: 'sent', addedDaysAgo: 5 },\n    { contact: 'priya.shah@lattice.example.com', status: 'sent', addedDaysAgo: 5 },\n    { contact: 'emily.d@starkmed.example.com', status: 'sent', addedDaysAgo: 5 },\n  ],\n  'Partner Operations Roadshow': [\n    { lead: 'maya.singh@bluepeaklogistics.example.com', status: 'sent', addedDaysAgo: 7 },\n    { lead: 'ravi.mehta@foundryrobotics.example.com', status: 'sent', addedDaysAgo: 7 },\n    { contact: 'marcus.reed@apexlogistics.example.com', status: 'sent', addedDaysAgo: 6 },\n    { contact: 'olivia.chen@northwind.example.com', status: 'sent', addedDaysAgo: 6 },\n  ],\n  'SaaSCon 2026 Trade Show': [\n    { lead: 'theo.park@skylinemedia.example.com', status: 'sent', addedDaysAgo: 8 },\n    { lead: 'wren.garcia@maplebakerygroup.example.com', status: 'sent', addedDaysAgo: 8 },\n    { lead: 'hugo.dubois@nimbusaerospace.example.com', status: 'sent', addedDaysAgo: 7 },\n    { lead: 'marco.ricci@auroratravel.example.com', status: 'sent', addedDaysAgo: 7 },\n  ],\n};\n\n/**\n * The metric block the campaign metric hooks maintain, computed here from the\n * very same inputs they read: the membership table above and the opportunities\n * attributed via `crm_campaign`.\n *\n * Seeding these by hand is what made them wrong before \u2014 a hand-typed\n * `actual_revenue` survived untouched until something recomputed, at which\n * point the hook replaced it with the truth and the number \"mysteriously\"\n * changed. Deriving it here makes the first recompute a no-op instead: same\n * inputs, same arithmetic, same answer.\n *\n * That first recompute now arrives much sooner than it used to. Before #597 the\n * only writer fired on the `\u2192 completed` transition, so these seeded values\n * were the ONLY numbers a live campaign ever showed; today any membership,\n * attribution or conversion change refreshes them (see the four refresh hooks:\n * `campaign_metrics_refresh` and `campaign_member_metrics_refresh` in\n * `src/marketing/objects/`, `campaign_lead_conversion_refresh` and\n * `campaign_attribution_refresh` in `src/sales/objects/`). The derivation below\n * is therefore a mirror of their one inlined recompute and has to stay one \u2014\n * `test/seed-consistency.test.ts` checks the seeds against it.\n */\nconst campaignMetrics = (campaignName: string) => {\n  const members = CAMPAIGN_MEMBERS[campaignName] ?? [];\n  const leadKeys = new Set(members.map((m) => m.lead).filter((e): e is string => Boolean(e)));\n  const convertedLeads = leads.records.filter(\n    (l) => typeof l.email === 'string' && leadKeys.has(l.email) && l.is_converted === true,\n  ).length;\n  const attributed = opportunities.records.filter((o) => o.crm_campaign === campaignName);\n  const won = attributed.filter((o) => o.stage === 'closed_won');\n  return {\n    // \"Total members enrolled\" \u2014 campaign.hook.ts's single definition of num_sent.\n    num_sent: members.length,\n    // `responded` or `converted`, as in `computeCampaignMetrics`. The seed set\n    // holds no `converted` member (see the note on CAMPAIGN_MEMBERS), so the\n    // two predicates coincide on this data \u2014 spelled the narrow way because\n    // widening it here would suggest a seeded state that does not exist.\n    num_responses: members.filter((m) => m.status === 'responded').length,\n    num_leads: leadKeys.size,\n    num_converted_leads: convertedLeads,\n    num_opportunities: attributed.length,\n    num_won_opportunities: won.length,\n    actual_revenue: won.reduce((sum, o) => sum + (typeof o.amount === 'number' ? o.amount : 0), 0),\n  };\n};\n\n// \u2500\u2500\u2500 Campaigns \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\nexport const campaigns = defineSeed(Campaign, {\n  mode: 'upsert',\n  externalId: 'name',\n  records: [\n    {\n      name: 'Q3 Enterprise Email Nurture',\n      description: 'Multi-touch nurture for enterprise IT decision makers evaluating AI governance and analytics.',\n      type: 'email',\n      channel: 'email',\n      status: 'in_progress',\n      start_date: cel`daysAgo(15)`,\n      end_date: cel`daysFromNow(21)`,\n      budgeted_cost: 28000,\n      actual_cost: 14000,\n      expected_revenue: 560000,\n      target_size: 5000,\n      ...campaignMetrics('Q3 Enterprise Email Nurture'),\n      landing_page_url: 'https://acme.example.com/lp/enterprise-q3',\n      is_active: true,\n    },\n    {\n      name: 'Executive AI Governance Roundtable',\n      description: 'A live executive roundtable on operating AI agents with governance, auditability and trust.',\n      type: 'conference',\n      channel: 'events',\n      status: 'planning',\n      start_date: cel`daysFromNow(2)`,\n      end_date: cel`daysFromNow(3)`,\n      budgeted_cost: 22000,\n      expected_revenue: 320000,\n      target_size: 120,\n      ...campaignMetrics('Executive AI Governance Roundtable'),\n      is_active: true,\n    },\n    {\n      name: 'Cloud Migration Webinar',\n      description: 'A technical webinar on modernizing customer operations and data workflows in the cloud.',\n      type: 'webinar',\n      channel: 'digital',\n      status: 'planning',\n      start_date: cel`daysFromNow(6)`,\n      end_date: cel`daysFromNow(8)`,\n      budgeted_cost: 18000,\n      expected_revenue: 360000,\n      target_size: 1500,\n      ...campaignMetrics('Cloud Migration Webinar'),\n      landing_page_url: 'https://acme.example.com/webinars/cloud-migration',\n      is_active: true,\n    },\n    {\n      name: 'Operations Platform Launch',\n      description: 'Launch campaign for the operations platform, pairing product content with customer proof points.',\n      type: 'content',\n      channel: 'digital',\n      status: 'in_progress',\n      // Was `daysFromNow(12)` \u2014 an `in_progress` campaign that had not started\n      // yet, which no attribution can be consistent with (#591).\n      start_date: cel`daysAgo(12)`,\n      end_date: cel`daysFromNow(14)`,\n      budgeted_cost: 36000,\n      actual_cost: 12000,\n      expected_revenue: 480000,\n      target_size: 8000,\n      ...campaignMetrics('Operations Platform Launch'),\n      landing_page_url: 'https://acme.example.com/launch/operations-platform',\n      is_active: true,\n    },\n    {\n      name: 'Partner Operations Roadshow',\n      description: 'Joint regional sessions with strategic partners for operations and IT leaders.',\n      type: 'partner',\n      channel: 'partner',\n      status: 'planning',\n      start_date: cel`daysFromNow(19)`,\n      end_date: cel`daysFromNow(22)`,\n      budgeted_cost: 48000,\n      expected_revenue: 720000,\n      target_size: 600,\n      ...campaignMetrics('Partner Operations Roadshow'),\n      is_active: true,\n    },\n    {\n      name: 'SaaSCon 2026 Trade Show',\n      description: 'A focused booth, executive dinner and customer-story program at the SaaSCon industry conference.',\n      type: 'trade_show',\n      channel: 'events',\n      status: 'planning',\n      start_date: cel`daysFromNow(27)`,\n      end_date: cel`daysFromNow(30)`,\n      budgeted_cost: 75000,\n      expected_revenue: 1200000,\n      target_size: 3000,\n      ...campaignMetrics('SaaSCon 2026 Trade Show'),\n      is_active: true,\n    },\n    {\n      name: 'Developer Content Marketing Push',\n      description: 'Technical blog posts, video tutorials and developer community engagement completed last month.',\n      type: 'content',\n      channel: 'digital',\n      status: 'completed',\n      start_date: cel`daysAgo(35)`,\n      end_date: cel`daysAgo(4)`,\n      budgeted_cost: 40000,\n      actual_cost: 25000,\n      expected_revenue: 250000,\n      target_size: 10000,\n      ...campaignMetrics('Developer Content Marketing Push'),\n      landing_page_url: 'https://acme.example.com/developers',\n      is_active: true,\n    },\n  ]\n});\n\n/**\n * Campaign members are seeded as TWO datasets over one object, split by which\n * side of the junction is populated.\n *\n * Not a stylistic choice: the object has no single natural key (its only text\n * identity is a runtime-owned autonumber), so identity has to be the composite\n * of campaign + member. The loader builds a composite key by joining the\n * per-field values and returns an EMPTY key \u2014 no dedupe, so a replay boot\n * re-inserts every row \u2014 as soon as ANY component is null. `crm_lead` and\n * `crm_contact` are mutually exclusive by design, so a single\n * `['crm_campaign', 'crm_lead', 'crm_contact']` key would be blank on every\n * row. Splitting the rows by member type gives each dataset a key whose parts\n * are all present.\n */\nconst memberRecords = (\n  kind: 'lead' | 'contact',\n): Array<Record<string, unknown>> =>\n  Object.entries(CAMPAIGN_MEMBERS).flatMap(([campaign, members]) =>\n    members\n      .filter((m) => (kind === 'lead' ? m.lead : m.contact))\n      .map((m) => ({\n        crm_campaign: campaign,\n        ...(kind === 'lead' ? { crm_lead: m.lead } : { crm_contact: m.contact }),\n        status: m.status,\n        added_date: celDaysAgo(m.addedDaysAgo),\n        // `has_responded` / `response_date` track the `responded` status\n        // exactly \u2014 a responded member with no response date is a shape the\n        // response-tracking surfaces cannot render.\n        has_responded: m.status === 'responded',\n        ...(m.respondedDaysAgo !== undefined ? { response_date: celDaysAgo(m.respondedDaysAgo) } : {}),\n      })),\n  );\n\nexport const campaignMembersFromLeads = defineSeed(CampaignMember, {\n  mode: 'upsert',\n  externalId: ['crm_campaign', 'crm_lead'],\n  records: memberRecords('lead'),\n});\n\nexport const campaignMembersFromContacts = defineSeed(CampaignMember, {\n  mode: 'upsert',\n  externalId: ['crm_campaign', 'crm_contact'],\n  records: memberRecords('contact'),\n});\n", "const __injected_filename__ = \"/home/user/hotcrm-issue-2097/objectstack.composition.ts\";const __injected_dirname__ = \"/home/user/hotcrm-issue-2097\";const __injected_import_meta_url__ = \"file:///home/user/hotcrm-issue-2097/objectstack.composition.ts\";// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\n/**\n * The four packages, collected into the two package stacks this artifact\n * carries.\n *\n * A directory under `src/` IS a package (ADR-0130, `module-split-plan.md`\n * items 4\u20139). Two of them are packages of the ARTIFACT as well:\n *\n *   - `src/sales/` \u2014 `app.objectstack.hotcrm`, the `type: 'app'` package this\n *     artifact takes its identity from. Its `defineStack` is the factory in\n *     `src/sales/index.ts`, and this file hands it its collections: the sales\n *     barrels plus those of `src/revenue/` and `src/marketing/`, which stay\n *     directories of the app package until they get packaging cards of their\n *     own, and which a file under `src/sales/` may not import.\n *   - `src/service/` \u2014 `app.objectstack.hotcrm.service`, a `type: 'module'`.\n *     Its `defineStack` is `src/service/index.ts`, which assembles its own\n *     collections from its own barrels; this file hands it only the seed rows\n *     the composition knob selects.\n *\n * `objectstack.config.ts` composes the two into ONE release artifact. This file\n * builds them, because it is the one place that may see every package AND carry\n * named exports.\n *\n * ## Why this is not simply the top of `objectstack.config.ts`\n *\n * That file may carry NO named export. `objectstack build` reads the config\n * module and parses it against `ObjectStackDefinitionSchema`, which is\n * `.strict`, so any export beside the default is an unrecognised top-level\n * stack key and the build fails by name. Measured on the pre-move tree, not\n * assumed: appending `export const ProbeNamedExport = [1, 2, 3];` to the\n * unmodified `objectstack.config.ts` at 590b095 fails `pnpm build` with\n * \"Unrecognized key(s) on this stack definition: `ProbeNamedExport`\".\n *\n * Two kinds of value need to be importable, so they live here:\n *\n *   - the AUTHORED collections \u2014 about a dozen suites assert against them\n *     upstream of `defineStack()`, which is the only side of that call where\n *     `CrmSeedData` and the stack's `data` are distinguishable at all (see the\n *     note in `test/saas-composition.test.ts`);\n *   - the two BUILT package stacks \u2014 a multi-package artifact carries every\n *     collection once, inside its package's body in `packages[]`, and no longer\n *     beside them at the top level (ADR-0130 D4, 2026-09-22 addendum), so a\n *     suite that reads \"every object of the app\" composes these two itself.\n *\n * ## Order\n *\n * Registration order within a collection is a property of each PACKAGE now:\n * the artifact carries each package's collections in its own body, in the order\n * that package's stack was handed them. Two orders stay load-bearing and are\n * stated explicitly below \u2014 `CrmSeedData`, the replay order a seed row's\n * natural-key lookups were written against, and the hand-ordered lists\n * (`appHooks`, `appFlows`, `appSkills`, `appSharingRules`) that keep the order\n * the single-tree barrels had. Everything else uses `byExportName()` \u2014 a\n * module namespace enumerates its exports in ascending code-unit order of the\n * export NAME, so merging several barrels and sorting by that name is the same\n * rule one barrel already applied, rather than a new one.\n */\n\nimport { createHotCrmAppStack } from './src/sales/index.js';\nimport {\n  createHotCrmServiceStack, serviceHooks, serviceFlows, serviceSkills, serviceSharingRules,\n} from './src/service/index.js';\n\nimport * as salesObjects from './src/sales/objects/index.js';\nimport * as revenueObjects from './src/revenue/objects/index.js';\nimport * as marketingObjects from './src/marketing/objects/index.js';\n\nimport * as salesActions from './src/sales/actions/index.js';\nimport * as marketingActions from './src/marketing/actions/index.js';\n\nimport * as salesDashboards from './src/sales/dashboards/index.js';\n\nimport * as salesDatasets from './src/sales/datasets/index.js';\nimport * as revenueDatasets from './src/revenue/datasets/index.js';\n\nimport * as salesReports from './src/sales/reports/index.js';\n\nimport * as mappings from './src/sales/mappings/index.js';\nimport * as apps from './src/sales/apps/index.js';\nimport * as profiles from './src/sales/profiles/index.js';\nimport * as translations from './src/sales/translations/index.js';\n\nimport * as salesViews from './src/sales/views/index.js';\nimport * as revenueViews from './src/revenue/views/index.js';\nimport * as marketingViews from './src/marketing/views/index.js';\n\nimport * as salesPages from './src/sales/pages/index.js';\n\nimport * as salesEmailTemplates from './src/sales/email-templates/index.js';\nimport * as revenueEmailTemplates from './src/revenue/email-templates/index.js';\n\nimport { SystemAdminProfile } from './src/sales/profiles/index.js';\nimport { TenantAdminProfile } from './src/sales/profiles/tenant-admin.profile.js';\n\n// Hooks \u2014 one barrel per directory, assembled below in source-file-name order.\nimport {\n  accountHook, contactHook, eventHook, forecastHook, leadHook,\n  leadCampaignMetricsHook, opportunityHook, opportunityCampaignMetricsHook, taskHook,\n} from './src/sales/objects/hooks.js';\nimport {\n  contractHook, opportunityLineItemHook, productHook, quoteHook, quoteLineItemHook,\n} from './src/revenue/objects/hooks.js';\nimport { campaignHook, campaignMemberHook } from './src/marketing/objects/hooks.js';\n\n// Flows \u2014 the registration order the single `allFlows` array used to hold.\nimport {\n  ContactWelcomeFlow, ForecastSnapshotFlow, LeadAssignmentFlow,\n  AccountApprovalFlow,\n  LeadConversionFlow, LeadConversionApprovalFlow,\n  OpportunityApprovalFlow, OpportunityApprovalOnCreateFlow,\n  OpportunityStatusChangeApprovalFlow, OpportunityQualificationApprovalFlow,\n  OpportunityStagnationFlow, OpportunityWonAlertFlow, ScheduleFollowUpFlow,\n  TaskDueReminderFlow, TaskUrgentAlertFlow, BillingHandoffClosedWonFlow,\n} from './src/sales/flows/index.js';\nimport {\n  QuoteGenerationFlow, ContractRenewalFlow, QuoteExpirationFlow, ContractExpirationFlow,\n  BillingHandoffContractActivatedFlow,\n} from './src/revenue/flows/index.js';\nimport {\n  CampaignEnrollmentFlow, CampaignLeadMemberEnrollFlow, CampaignContactMemberEnrollFlow,\n  CampaignCompletionFlow,\n} from './src/marketing/flows/index.js';\n\n// Skills \u2014 likewise.\nimport {\n  LeadQualificationSkill, EmailDraftingSkill, RevenueForecastingSkill,\n  Customer360Skill, LiveDataSkill,\n} from './src/sales/skills/index.js';\n\nimport {\n  AccountTeamSharingRule, TerritorySharingRules,\n  OpportunitySalesSharingRule, OpportunityExecutiveSharingRule,\n  CrmPositions,\n} from './src/sales/sharing/index.js';\nimport { CampaignLeadershipSharingRules } from './src/marketing/sharing/index.js';\n\nimport type { EmailTemplateDefinition } from '@objectstack/spec/system';\n\n// Seed rows \u2014 the replay order lives in `CrmSeedData` below.\nimport type { HotCrmComposition } from './src/sales/data/index.js';\nimport {\n  resolveComposition,\n  accounts, contacts, leads, opportunities,\n  tasks, events, eventAttendeesFromContacts, eventAttendeesFromLeads, leadInteractionPointers, forecasts,\n} from './src/sales/data/index.js';\nimport { products, opportunityLineItems, contracts, quotes, quoteLineItems } from './src/revenue/data/index.js';\nimport { cases, knowledgeArticles } from './src/service/data/index.js';\nimport { campaigns, campaignMembersFromLeads, campaignMembersFromContacts } from './src/marketing/data/index.js';\n\n/**\n * One registration array out of the merged per-package barrels of a metadata\n * type, ordered by EXPORT NAME.\n *\n * `Object.values(<module namespace>)` \u2014 what this file did for each of these\n * collections while there was one barrel per type \u2014 enumerates in ascending\n * code-unit order of the export name, not in the barrel's declaration order.\n * (Measured on the pre-move artifact: `src/pages/index.ts` declared\n * `LeadDetailPage` first and the artifact's `pages[]` still began with\n * `account_detail_page`.) So sorting the merged entries by export name is not\n * a new ordering rule \u2014 it is the same one, applied across four namespaces\n * instead of one.\n *\n * The namespaces are spread into one object at the call site, which is also\n * what keeps the entries TYPED: each barrel is its own module namespace with\n * its own element union, so passing them as separate arguments makes\n * TypeScript infer `T` from the first one alone and reject the rest. A\n * duplicate export name across two packages would collide in that spread \u2014 it\n * could not happen while the exports shared one namespace either, and it is a\n * compile error the day two packages export the same name.\n */\nconst byExportName = <T>(merged: Record<string, T>): T[] =>\n  Object.entries(merged)\n    .sort(([a], [b]) => (a < b ? -1 : a > b ? 1 : 0))\n    .map(([, value]) => value);\n\n/* \u2500\u2500\u2500 The app package's collections \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500 */\n\n/**\n * Every CRM lifecycle hook the APP PACKAGE registers, in the order\n * `src/hooks/index.ts` registered them (by hook source file name) \u2014 see the\n * ORDER note at the top of this file.\n *\n * `*.hook.ts` files sit beside the `*.object.ts` they name, one directory each,\n * which is what enforces ADR-0130 R4. Two entries therefore come from a\n * different directory than the campaign metadata they maintain:\n * `opportunityCampaignMetricsHook` and `leadCampaignMetricsHook` are attached\n * to `crm_opportunity` and `crm_lead`, so they live in sales. The three service\n * hooks register with the service package (`serviceHooks`).\n */\nexport const appHooks = [\n  accountHook,\n  campaignHook,\n  opportunityCampaignMetricsHook,\n  leadCampaignMetricsHook,\n  campaignMemberHook,\n  contactHook,\n  contractHook,\n  eventHook,\n  forecastHook,\n  leadHook,\n  opportunityHook,\n  opportunityLineItemHook,\n  productHook,\n  quoteHook,\n  quoteLineItemHook,\n  taskHook,\n].flatMap((entry) => (Array.isArray(entry) ? entry : [entry]));\n\n/**\n * Every flow the app package registers, in the order the single `allFlows`\n * array registered them. The seven case flows register with the service\n * package (`serviceFlows`).\n */\nexport const appFlows = [\n  CampaignEnrollmentFlow,\n  CampaignLeadMemberEnrollFlow,\n  CampaignContactMemberEnrollFlow,\n  AccountApprovalFlow,\n  LeadConversionFlow,\n  LeadConversionApprovalFlow,\n  ScheduleFollowUpFlow,\n  OpportunityApprovalFlow,\n  OpportunityApprovalOnCreateFlow,\n  OpportunityStatusChangeApprovalFlow,\n  OpportunityQualificationApprovalFlow,\n  QuoteGenerationFlow,\n  ContractRenewalFlow,\n  OpportunityStagnationFlow,\n  ForecastSnapshotFlow,\n  LeadAssignmentFlow,\n  CampaignCompletionFlow,\n  QuoteExpirationFlow,\n  ContractExpirationFlow,\n  ContactWelcomeFlow,\n  OpportunityWonAlertFlow,\n  TaskUrgentAlertFlow,\n  TaskDueReminderFlow,\n  BillingHandoffClosedWonFlow,\n  BillingHandoffContractActivatedFlow,\n];\n\n/**\n * Every skill the app package registers \u2014 the cross-domain ones are all here.\n * The case-triage skill registers with the service package (`serviceSkills`).\n */\nexport const appSkills = [\n  LeadQualificationSkill,\n  EmailDraftingSkill,\n  RevenueForecastingSkill,\n  Customer360Skill,\n  LiveDataSkill,\n];\n\n/** Every object definition the app package registers. */\nexport const appObjects = byExportName({\n  ...salesObjects, ...revenueObjects, ...marketingObjects,\n});\n\n/** Every UI / AI-callable action it registers. */\nexport const appActions = byExportName({ ...salesActions, ...marketingActions });\n\n/** Its dashboards \u2014 the cross-domain ones included (plan item 4). */\nexport const appDashboards = byExportName({ ...salesDashboards });\n\n/** Its analytics datasets (ADR-0021). */\nexport const appDatasets = byExportName({ ...salesDatasets, ...revenueDatasets });\n\n/** Its reports. */\nexport const appReports = byExportName({ ...salesReports });\n\n/** Its list-view groups. */\nexport const appViews = byExportName({\n  ...salesViews, ...revenueViews, ...marketingViews,\n});\n\n/** Its page layouts \u2014 `home`, `app_launcher` and `utility_bar` among them. */\nexport const appPages = byExportName({ ...salesPages });\n\n/** Every import mapping \u2014 sales only; nothing else authors one. */\nexport const appMappings = byExportName({ ...mappings });\n\n/** The app itself, and its navigation GROUPS (the containers modules aim at). */\nexport const appApps = byExportName({ ...apps });\n\n/** The locale packs \u2014 whole in the app package (plan item 4), service labels included. */\nexport const appTranslations = byExportName({ ...translations });\n\n/**\n * Every `sys_email_template` row the app package registers \u2014 the localizable\n * content path for `notify` (#9205). The service package registers its own two\n * case templates, beside the flows that send them.\n *\n * A package barrel exports ONE symbol carrying that package's rows, so\n * `byExportName()` orders them by export name and `.flat()` produces the\n * single array `defineStack({ emailTemplates })` takes. Reaching the package\n * barrel IS reaching the registration here: no hand-kept ordered list, because\n * nothing about the order is load-bearing \u2014 a row is resolved by\n * `(name, locale)` at delivery time, never by position.\n */\nexport const appEmailTemplates = byExportName<EmailTemplateDefinition[]>({\n  ...salesEmailTemplates, ...revenueEmailTemplates,\n}).flat();\n\n/**\n * The permission sets, as the NAMESPACE rather than an array: the SaaS\n * composition filters them by identity below, which needs `Object.values()`\n * over the same object the named exports come from.\n *\n * They stay WHOLE in the app package (ADR-0130 addendum, 2026-09-02), service\n * grants included: a permission set is a role a person holds across the whole\n * product, not a property of one module.\n */\nexport const allProfiles = profiles;\n\nexport { SystemAdminProfile, TenantAdminProfile };\n\n/**\n * The sharing rules the app package registers, in the order this app has\n * always registered them. The three CASE rules are authored against\n * `crm_case` and register with the service package (`serviceSharingRules`).\n */\nexport const appSharingRules = [\n  AccountTeamSharingRule,\n  OpportunitySalesSharingRule,\n  OpportunityExecutiveSharingRule,\n  ...TerritorySharingRules,\n  ...CampaignLeadershipSharingRules,\n];\n\nexport { CrmPositions };\n\n/* \u2500\u2500\u2500 Artifact-wide sweeps \u2014 what the suites read \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500 */\n\n/**\n * Every hook in the ARTIFACT, both packages.\n *\n * The suites that sweep hooks (`test/refusal-envelope.test.ts`,\n * `test/runtime-coverage.test.ts`, `test/hook-write-shape.test.ts`,\n * `test/action-sandbox.test.ts`, `test/territory-single-source.test.ts`) are\n * about the app a customer installs, which is the whole artifact \u2014 so they keep\n * reading one list, assembled here from each package's own.\n */\nexport const allHooks = [...appHooks, ...serviceHooks];\n\n/** Every flow in the artifact, both packages \u2014 same reason as {@link allHooks}. */\nexport const allFlows = [...appFlows, ...serviceFlows];\n\n/** Every skill in the artifact, both packages \u2014 same reason as {@link allHooks}. */\nexport const allSkills = [...appSkills, ...serviceSkills];\n\n/** Every sharing rule in the artifact, both packages \u2014 same reason as {@link allHooks}. */\nexport const CrmSharingRules = [...appSharingRules, ...serviceSharingRules];\n\n\n/**\n * Ownership and CRM positions are NOT seeded here \u2014 they can't be.\n *\n * A seed can't name a user. Lookup values are resolved against the target's\n * externalId and that only works for objects in the app's own graph, so\n * `owner_id: 'Dev Admin'` would store the literal string rather than an id (verified:\n * a `sys_user_position` row seeded that way is unmatchable by the real user\n * id), and `cel\\`os.user.id\\`` inside a seed evaluates to nothing. The id does\n * not exist until first boot.\n *\n * The PLATFORM does it, at the only moment it can: when the seed settles,\n * `@objectstack/plugin-security` re-runs its seed-ownership claim on\n * `app:seeded` and hands every ownerless row of every object carrying\n * `owner_id` to the first platform administrator (objectstack#17872, shipped in\n * 17.6.0). No HotCRM flow is involved. The `demo_bootstrap` sweep that used\n * to do this every ten minutes was retired once a fresh boot measured that\n * claim leaving all twelve seeded owner-scoped objects at zero ownerless rows\n * with the sweep disabled (#1892).\n *\n * `owner_id` is the app's ONE ownership column (#548 retired the app-authored\n * `owner` lookup that used to sit beside it \u2014 the #622 split). Seed writes run\n * under `{ isSystem: true }`, which short-circuits the security middleware, so\n * its insert-time auto-stamp of `owner_id` never fires \u2014 \"seeds either declare\n * those fields explicitly per record\" \u2014 and per the paragraph above these seeds\n * cannot declare it. So a seeded row reaches the database owned by nobody\n * (`owner_id` null) until that claim runs. Nothing here should grow an\n * `owner_id` seed value to paper over that: the platform claim is the\n * mechanism.\n */\n\n/**\n * All CRM seed datasets, in REPLAY ORDER \u2014 the ARTIFACT's whole seed union.\n *\n * This list assembles here rather than in a package barrel for two reasons,\n * and the second is the binding one. It names rows from all four packages, and\n * no `src/` file may reach sideways into another package (plan item 7). And\n * the order is load-bearing \u2014 rows resolve their lookups against rows seeded\n * earlier, and the order interleaves the packages (products between\n * opportunities and tasks, contracts after campaign members), so it is not\n * recoverable by concatenating four per-package lists in any package order.\n * It is exactly the order `CrmSeedData` has always had. About ten suites read\n * this union; {@link seedDataFor} is what the two package stacks register.\n */\nexport const CrmSeedData = [\n  accounts,\n  contacts,\n  leads,\n  opportunities,\n  products,\n  opportunityLineItems,\n  tasks,\n  cases,\n  // Events come after the five objects their `related_to_*` lookups resolve\n  // against (accounts, contacts, leads, opportunities, cases); the attendee\n  // junctions come after the events they hang off.\n  events,\n  eventAttendeesFromContacts,\n  eventAttendeesFromLeads,\n  leadInteractionPointers,\n  campaigns,\n  campaignMembersFromLeads,\n  campaignMembersFromContacts,\n  contracts,\n  quotes,\n  quoteLineItems,\n  forecasts,\n  knowledgeArticles,\n];\n\n/**\n * The seed datasets a SaaS tenant gets: the product CATALOGUE, and nothing else.\n *\n * Maintainer ruling, 2026-08-27 (objectstack#12701, quoted untranslated):\n * \u300C\u6BCF\u4E2A\u79DF\u6237\u5E94\u8BE5\u5404\u81EA\u4F7F\u7528\u5404\u81EA\u7684\u6570\u636E\u5427\u300D \u2014 every tenant uses its own data, the\n * product catalogue included; and \u300C\u79CD\u5B50\u4E5F\u4E0D\u5E94\u8BE5\u662F\u5168\u5C40\u7684\u5440\uFF0C\u56E0\u4E3A\u79CD\u5B50\u6570\u636E\u4E0D\u540C\u7684\u5BA2\u6237\n * \u90FD\u662F\u8981\u6539\u7684\u5440\uFF0C\u53EA\u662F\u53C2\u8003\u5440\uFF0C\u79DF\u6237\u8981\u81EA\u5DF1\u5220\u9664\u5440\u300D \u2014 a seed is a per-tenant\n * REFERENCE copy the tenant edits and deletes.\n *\n * The platform already replays per tenant: `@objectstack/runtime`'s\n * `seed-replayer` replays the registered dataset union into each newly founded\n * organization stamped with that organization's id. What it has no notion of is\n * WHICH families to replay \u2014 it always replays the whole union \u2014 so the\n * selection is made HERE, once, at composition time. That is also the shape the\n * ruling wants: uniform for every tenant, with no per-tenant opt-in mechanism\n * to author, mis-set, or support.\n *\n * Why the catalogue and only the catalogue:\n *\n *  - A catalogue is the one family that is genuinely a starting point. A new\n *    tenant needs priceable products before they can quote anything, and the\n *    rows are theirs to rename, re-price and delete.\n *  - `sales` / `service` / `marketing` / `revenue` are STORYTELLING: Acme\n *    Corporation's pipeline, nine escalated cases, a finished campaign. Landing\n *    those in a paying tenant's org is not a helpful head start, it is someone\n *    else's data in their CRM.\n *  - It is also the family with no outgoing references, so the shrink cannot\n *    strand a lookup: `src/revenue/data/catalog.seed.ts` resolves nothing against\n *    another object, while every other family points at accounts, contacts or products\n *    by natural key.\n *\n * \u26D4 Not a place to grow a \"starter data\" bundle. A family added here ships\n * into every tenant of every SaaS deployment; the bar is \"a tenant cannot\n * operate without it\", not \"it looks nice on day one\".\n */\nexport const SaasTenantSeedData = [products];\n\n/**\n * The seed families of the SERVICE package \u2014 the rows whose object it owns.\n *\n * \u26A0\uFE0F A seed family is REGISTERED BY THE PACKAGE THAT OWNS ITS OBJECT. Named\n * here, beside the replay order it is cut out of, so the two cannot drift\n * apart: the split is a property of {@link CrmSeedData}.\n */\nexport const ServiceSeedData = [cases, knowledgeArticles];\n\n/** Everything else \u2014 the app package's own families, in {@link CrmSeedData} order. */\nexport const AppSeedData = CrmSeedData.filter((family) => !ServiceSeedData.includes(family));\n\n/**\n * The seed datasets each package registers under a composition.\n *\n * The SaaS selection is still made once, here: a tenant gets the product\n * catalogue and nothing else, so the service package registers no rows at all\n * in that shape. See {@link SaasTenantSeedData} for why.\n */\nexport const seedDataFor = (\n  composition: HotCrmComposition,\n): { app: typeof CrmSeedData; service: typeof CrmSeedData } =>\n  composition === 'saas'\n    ? { app: SaasTenantSeedData, service: [] }\n    : { app: AppSeedData, service: ServiceSeedData };\n\n// \u2500\u2500\u2500 Which SHAPE of HotCRM this build assembles (#1361) \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n//\n// `default` (unset, or `HOTCRM_COMPOSITION=default`) is the community app and\n// is byte-for-byte what it always was \u2014 every field below that a composition\n// touches falls through to the same value it had before this knob existed.\n// `HOTCRM_COMPOSITION=saas` assembles the shape a multi-org operator deploys on\n// the enterprise runtime under a walled tenancy posture; an unrecognised value\n// throws here rather than quietly assembling the wrong app (see\n// `resolveComposition`).\n//\n// The knob is resolved ONCE, here, and handed to the package stacks already\n// applied. It is deliberately COMPOSITION-time and uniform. The platform's\n// `seed-replayer` gives every newly founded organization its own private copy\n// of the registered dataset union (maintainer ruling 2026-08-27,\n// objectstack#12701: \u300C\u79CD\u5B50\u4E5F\u4E0D\u5E94\u8BE5\u662F\u5168\u5C40\u7684\u5440 \u2026\u53EA\u662F\u53C2\u8003\u5440\uFF0C\u79DF\u6237\u8981\u81EA\u5DF1\u5220\u9664\u5440\u300D),\n// but it has no per-family or per-tenant selection and none is chartered \u2014 so\n// WHAT gets replayed is decided once, here, for every tenant alike.\n//\n// Two things change, and nothing else. There is no runtime branch anywhere in\n// `src/`, and no enterprise package is imported: an artifact built either way\n// runs on the community runtime. Both shapes register the same flows: the one\n// flow the SaaS shape used to drop, the `demo_bootstrap` ownership sweep, is\n// retired from the app (#1892) \u2014 the platform claims seeded rows itself.\n//\n//  1. `data` \u2014 the catalogue family only, so the service package registers\n//     none. See `SaasTenantSeedData`.\n//     `demo-staffing` needs no exclusion \u2014 `src/sales/sharing/demo-staffing.ts` is\n//     deliberately not exported from `src/sales/sharing/index.js` and not registered\n//     in any composition (#640, pinned by `test/demo-staffing.test.ts`).\n//  2. `permissions` \u2014 `system_admin` is replaced by `tenant_admin`, which holds\n//     org-scoped `manage_org_users` instead of platform-scope `manage_users`.\n//     Read `src/sales/profiles/tenant-admin.profile.ts` for the full audit, including\n//     what `view_all_data` / `modify_all_data` mean under the wall.\nconst composition = resolveComposition();\nconst isSaas = composition === 'saas';\nconst seedData = seedDataFor(composition);\n\n/**\n * Permission sets this composition registers. Filtered by IDENTITY, not by name\n * string, so a rename cannot silently turn the substitution into a no-op.\n */\nconst compositionPermissions = isSaas\n  ? [...Object.values(allProfiles).filter((set) => set !== SystemAdminProfile), TenantAdminProfile]\n  : Object.values(allProfiles);\n\n/* \u2500\u2500\u2500 The two package stacks `objectstack.config.ts` composes \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500 */\n\n/** `app.objectstack.hotcrm.service` \u2014 see `src/service/index.ts`. */\nexport const serviceStack = createHotCrmServiceStack({ data: seedData.service });\n\n/**\n * `app.objectstack.hotcrm` \u2014 see `src/sales/index.ts`, including why it is\n * handed `artifactObjects`: its permission sets stay whole here and grant on\n * the service package's objects too.\n */\nexport const appStack = createHotCrmAppStack(\n  {\n    objects: appObjects,\n    actions: appActions,\n    dashboards: appDashboards,\n    datasets: appDatasets,\n    reports: appReports,\n    // Reusable import projections (#603). Referenced by name from the import\n    // endpoint \u2014 `mappingName: 'crm_account_import'` \u2014 so a customer's own\n    // spreadsheet loads without per-column mapping by hand. Templates:\n    // `assets/import-templates/`.\n    mappings: appMappings,\n    flows: appFlows,\n    skills: appSkills,\n    permissions: compositionPermissions,\n    apps: appApps,\n    views: appViews,\n    pages: appPages,\n    // Approvals are modeled as `record_change` flows with `approval` nodes\n    // (ADR-0019); see src/sales/flows/opportunity-approval.flow.ts. The\n    // standalone `approvals` stack field was removed in ObjectStack 7.4.\n    // No `analyticsCubes`: datasets (ADR-0021) are the semantic layer \u2014 the\n    // analytics service compiles each dataset into its cube internally, and a\n    // second hand-written cube layer only duplicates and drifts.\n\n    hooks: appHooks,\n\n    data: seedData.app,\n\n    translations: appTranslations,\n\n    // The localizable content path for `notify` (#9205). A node names a template\n    // and supplies its `templateData`; the delivery path resolves\n    // `(name, locale)` against these rows PER RECIPIENT, after fan-out \u2014 the\n    // recipient's own `sys_user.locale` when set, else `i18n.defaultLocale` \u2014\n    // so two people on one notification can read it in two languages.\n    emailTemplates: appEmailTemplates,\n\n    sharingRules: appSharingRules,\n    // ADR-0090 D3: positions are flat capability-distribution groups \u2014 the v1\n    // role hierarchy's parent links are gone (hierarchy belongs to the\n    // business-unit tree, which this app does not model).\n    positions: CrmPositions,\n  },\n  { artifactObjects: (serviceStack.objects ?? []).map((object) => object.name) },\n);\n"],
  "mappings": "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",
  "names": ["defineStack", "ObjectSchema", "Field", "P", "ObjectSchema", "Field", "P", "ObjectSchema", "Field", "F", "P", "ObjectSchema", "Field", "F", "P", "objects_exports", "ObjectSchema", "Field", "F", "ObjectSchema", "Field", "F", "ObjectSchema", "Field", "F", "ObjectSchema", "Field", "F", "P", "ObjectSchema", "Field", "ObjectSchema", "Field", "P", "ObjectSchema", "Field", "ObjectSchema", "Field", "ObjectSchema", "Field", "F", "P", "ObjectSchema", "Field", "F", "P", "ObjectSchema", "Field", "F", "P", "ObjectSchema", "Field", "F", "P", "ObjectSchema", "Field", "F", "P", "ObjectSchema", "Field", "F", "P", "ObjectSchema", "Field", "P", "ObjectSchema", "Field", "P", "objects_exports", "P", "P", "P", "P", "cel", "cel", "cel", "cel", "P", "cel", "P", "cel", "P", "P", "defineView", "defineView", "defineStack", "objects_exports", "ObjectSchema", "Field", "P", "ObjectSchema", "Field", "P", "ObjectSchema", "Field", "F", "P", "ObjectSchema", "Field", "F", "P", "ObjectSchema", "Field", "F", "P", "ObjectSchema", "Field", "F", "P", "ObjectSchema", "Field", "F", "P", "cel", "ObjectSchema", "Field", "F", "P", "cel", "ObjectSchema", "Field", "F", "P", "ObjectSchema", "Field", "F", "P", "objects_exports", "ObjectSchema", "Field", "F", "P", "ObjectSchema", "Field", "F", "P", "ObjectSchema", "Field", "P", "ObjectSchema", "Field", "P", "P", "P", "P", "P", "P", "P", "actions_exports", "P", "P", "defineDataset", "defineDataset", "defineDataset", "defineDataset", "defineDataset", "defineDataset", "defineDataset", "defineDataset", "defineDataset", "defineDataset", "defineDataset", "defineDataset", "defineDataset", "defineDataset", "datasets_exports", "defineDataset", "defineDataset", "defineMapping", "defineMapping", "defineMapping", "defineMapping", "en", "appSurface", "activityActions", "customer", "activityActions", "pipeline", "activityActions", "commerce", "service", "activityActions", "activity", "marketing", "zhCN", "customer", "service", "pipeline", "commerce", "activity", "marketing", "appSurface", "appSurface", "activityActions", "customer", "activityActions", "pipeline", "activityActions", "commerce", "service", "activityActions", "activity", "marketing", "jaJP", "customer", "service", "pipeline", "commerce", "activity", "marketing", "appSurface", "appSurface", "activityActions", "customer", "activityActions", "pipeline", "activityActions", "commerce", "service", "activityActions", "activity", "marketing", "esES", "customer", "service", "pipeline", "commerce", "activity", "marketing", "appSurface", "en", "zhCN", "jaJP", "esES", "P", "defineView", "P", "defineView", "defineView", "defineView", "defineView", "defineView", "defineView", "defineView", "defineView", "defineView", "defineView", "defineView", "defineView", "defineView", "defineView", "defineView", "views_exports", "defineView", "defineView", "defineView", "defineView", "defineView", "defineView", "views_exports", "defineView", "defineView", "P", "P", "en", "zhCN", "jaJP", "esES", "en", "zhCN", "jaJP", "esES", "email_templates_exports", "en", "zhCN", "jaJP", "esES", "en", "zhCN", "jaJP", "esES", "opportunities", "period", "input", "contacts", "leads", "type", "interval", "status", "P", "cel", "cel", "P", "P", "cel", "P", "cel", "P", "cel", "P", "cel", "cel", "cel", "P", "cel", "P", "cel", "P", "cel", "P", "cel", "P", "cel", "P", "cel", "P", "cel", "cel", "P", "P", "expression", "cel", "cel", "expression", "P", "P", "cel", "cel", "P", "P", "cel", "P", "cel", "P", "cel", "P", "cel", "P", "cel", "P", "cel", "cel", "cel", "P", "cel", "cel", "expression", "expression", "cel", "P", "cel", "P", "expression", "cel", "cel", "expression", "P", "P", "cel", "cel", "P", "cel", "cel", "cel", "cel", "P", "cel", "P", "cel", "P", "cel", "cel", "P", "cel", "cel", "cel", "cel", "defineSkill", "defineSkill", "defineSkill", "defineSkill", "defineSkill", "defineSkill", "defineSkill", "defineSkill", "defineSkill", "defineSkill", "P", "P", "P", "P", "P", "P", "cel", "cel", "cel", "cel", "defineSeed", "cel", "defineSeed", "cel", "defineSeed", "cel", "defineSeed", "cel", "defineSeed", "defineSeed", "defineSeed", "defineSeed", "defineSeed", "cel", "defineSeed", "cel", "defineSeed", "cel", "cel", "defineSeed", "defineSeed", "cel", "defineSeed", "cel", "objects_exports", "actions_exports", "datasets_exports", "views_exports", "email_templates_exports", "composition"]
}
 diff --git a/test/ownership-model.test.ts b/test/ownership-model.test.ts index 03bae963..abf24c91 100644 --- a/test/ownership-model.test.ts +++ b/test/ownership-model.test.ts @@ -6,6 +6,7 @@ import { InMemoryDriver } from '@objectstack/driver-memory'; import type { VerifyStack } from '@objectstack/verify'; import stack from './helpers/composed-stack'; import { hotcrmStack, signUpPerson, type Person } from './helpers/verify-stack'; +import { LeadViews } from '../src/sales/views/lead.view'; /** * ═══ HotCRM has ONE owner, and it is the platform's (#548) ════════════════ @@ -162,6 +163,21 @@ describe('one ownership column, and it is `owner_id`', () => { ); expect(withDefault, 'owner_id must have no schema default').toEqual([]); }); + + it('the New Lead form leaves `owner_id` to that stamp — offered, not required (#2097)', () => { + // `LeadViews.form` IS the create dialog (see `case-create-form-narrowing`), + // and a `required` entry there is a client-side submit check. Measured on + // 18.0.0-next.0: a rep's Leads → New stopped at "Lead Owner is required" + // with nothing POSTed, so the stamp never saw the insert. The server half — + // a rep's ownerless insert lands owned by the rep — is pinned end to end by + // `stands down when the middleware already stamped an owner` below. + const entries: unknown[] = ((LeadViews as AnyRec).form?.sections ?? []).flatMap( + (s: AnyRec) => s.fields ?? [], + ); + const owner = entries.find((f) => (typeof f === 'string' ? f : (f as AnyRec)?.field) === 'owner_id'); + expect(owner, 'owner_id left the New Lead form — this pin would judge nothing').toBeDefined(); + expect((owner as AnyRec)?.required === true, 'the New Lead form demands an owner again').toBe(false); + }); }); // ──────────────────────────────────── which writers the gate can see ── From ca836d0dd67224e2622ffabfa9e36899efc7763d Mon Sep 17 00:00:00 2001 From: Claude Date: Wed, 14 Oct 2026 08:12:25 +0000 Subject: [PATCH 3/4] chore(changeset): note that a new lead no longer requires an owner pick Claude-Session: https://claude.ai/code/session_01P8mZuzuyZAHSrgQKmv6ASv Co-authored-by: Claude --- .changeset/2097-lead-owner-not-required.md | 5 +++++ 1 file changed, 5 insertions(+) create mode 100644 .changeset/2097-lead-owner-not-required.md diff --git a/.changeset/2097-lead-owner-not-required.md b/.changeset/2097-lead-owner-not-required.md new file mode 100644 index 00000000..594ce653 --- /dev/null +++ b/.changeset/2097-lead-owner-not-required.md @@ -0,0 +1,5 @@ +--- +'hotcrm': patch +--- + +A sales rep can create a lead without first picking themselves as its owner. The **New Lead** form marked **Lead Owner** as required, so clicking **Create** with the field left blank stopped at *"Lead Owner is required"* and nothing was saved. The form no longer requires it. A lead created with the field left blank is owned by the person who created it, as on the **Opportunity**, **Account** and **Contact** New forms. **Lead Owner** stays on the form. From 43a0b4c8c1a571881de71d201226a6ee088ba43a Mon Sep 17 00:00:00 2001 From: Claude Date: Wed, 14 Oct 2026 08:28:37 +0000 Subject: [PATCH 4/4] fix(lead): say that a create-time owner pick is dropped, not kept The owner_id comment on the New Lead form claimed a manager can still choose another owner. Measured on 18.0.0-next.0, the console drops a picked owner on create (objectui#12359); the comment now says so. Claude-Session: https://claude.ai/code/session_01P8mZuzuyZAHSrgQKmv6ASv Co-authored-by: Claude --- src/sales/views/lead.view.ts | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/src/sales/views/lead.view.ts b/src/sales/views/lead.view.ts index 049bedbe..26cdbd17 100644 --- a/src/sales/views/lead.view.ts +++ b/src/sales/views/lead.view.ts @@ -292,8 +292,9 @@ export const LeadViews = defineView({ 'industry', // Offered, ⛔ not `required` (#2097): an insert that leaves it empty is // stamped to the creator by the platform (see `lead.hook.ts`), so a - // rep's new lead is theirs without a pick, and a manager can still - // choose another owner. `required` blocked that save client-side. + // rep's new lead is theirs without a pick. `required` blocked that + // save client-side. A pick of another owner on create is currently + // dropped by the console (objectui#12359). 'owner_id', // `disqualification_reason` is enforced by the // `disqualification_reason_required` validation on crm_lead, so every